fc.cpp

这是一个指纹模块的驱动程序

		unsigned int x, unsigned int y, unsigned int w, unsigned int h)
{
	register unsigned int i,j;
	register unsigned int v;
	unsigned char *p;
	unsigned long sum1 = 0;
	unsigned long sum2 = 0;

	if(width < x + w || heigh < y + h)
		return 0;

	for(i = 0; i < h; i++)
	{
		p = data + (y+i)*width + x;
		for(j = 0; j < w; j++)
		{
			v = *p++;
			sum1 += v;
			sum2 += v*v;
		}
	}

	sum1 /= w*h;
	sum2 /= w*h;
	sum2 -= sum1*sum1;

    	return (float)sum2;
}
float uc2dCoVariance(unsigned char *data1, unsigned char *data2, unsigned int width, unsigned int heigh,
		unsigned int x, unsigned int y, unsigned int w, unsigned int h)
{
	register unsigned int i;
	register unsigned int j;
	register int v1,v2;
	register unsigned int v;
	unsigned char  *p1,*p2; 	
	unsigned long sum1 = 0;
	unsigned long sum2 = 0;
	
    	if(width < x + w || heigh < y + h)
        		return 0;

	for( i = 0; i < h; i++)
    	{
		p1 = data1 + (y+i)*width + x;
		p2 = data2 + (y+i)*width + x;
		for(j = 0; j < w; j++)
        		{
			v1 = *p1++;
			v2 = *p2++;
			v = v1 > v2 ? v1 - v2 : v2 - v1;
			sum1 += v;
			sum2 += v*v;
        		}
   	}

	sum1 /= w*h;
	sum2 /= w*h;
	sum2 -= sum1*sum1;

    	return (float)sum2;
}

int EvaluateSlice(unsigned char *slice, int threshold)
{
	const int startrow = 50;
	const int startline = 0;
	const int checkwidth = slicewidth - startrow*2;
	const int checkheigh = sliceheigh;
	float v;
	v = uc2dVariance(slice, slicewidth, sliceheigh,
				startrow, startline, checkwidth, checkheigh);
	return (int)(v > threshold ? v : 0);
}

static float MatchSlicexy(unsigned char  *slice1, unsigned char  *slice2, int x, int y)
{
	const int startrow = 50;
	const int startline = 0;
	const int checkwidth = slicewidth - startrow*2;
	unsigned char  *p1;
	unsigned char  *p2;

	if(x < -5 || x > 5)
		return defaultminvalue;
	if(y < 0 || y > 7)
		return defaultminvalue;

	p1 = slice1;
	p2 = slice2 + y*slicewidth + x;
	return uc2dCoVariance(p1, p2, slicewidth, 8-y,
			startrow, startline, checkwidth, 8-y);
}

static float MatchSlice(unsigned char  *slice1, unsigned char *slice2, int *dx, int *dy)
{
	float minv = defaultminvalue;
	float v;
	register int y;
	register int x;
	
	for(y = 0; y < 6; y++)
		for( x = -1; x < 1; x++)
		{
			v = MatchSlicexy(slice1, slice2, x, y);
			if(minv > v)
			{
				minv = v;
				*dx = x;
				*dy = y;
			}
		}
	return minv;
}

int GetSlice()
{
	const int maxtime = 10000;
	unsigned char  *p;
	int endn;
	endn = 0;
	DWORD start, end;

    bottomslice = topslice;
	if(!ResetChip())
		return 0;
	start = GetTickCount();
	while(1)
	{
		end = GetTickCount();
		if((end - start)/1000 > maxtime)
		{
			return 0;
		}
		//slicesize = 280*8
		//bottomslice = 999
		p = mapEMS1+((long)bottomslice*slicesize);
		//如果指针存在
		if(!p)
		{
			return 0;
		}
		//读一次
		if(!ReadOneSlice(p))
		{
			return 0;
		}
		//999开始递减
		bottomslice--;
		if(bottomslice < 10)
		{	//bottomslice小于10的时候就退出循环
			break;
		}
		if(EvaluateSlice(p, ciSliceThreshold))
        {
			endn = 0;
		}
        else
        {
		  if(topslice - bottomslice < minslicenum)//100
			bottomslice = topslice;
		  else
		  {
            endn++;
			if(endn > endcount)//10
             break;
		  }
		}
	}
	bottomslice++;
	if(topslice - bottomslice < minslicenum)
	{
		return 0;
	}        		
	p = mapEMS1+((long)bottomslice*slicesize);

	p = mapEMS1+((long)(bottomslice + 2)*slicesize);
	if(!p)
	{
		return 0;
	}
    ucBackGround = (unsigned char)ucAverage(p, slicesize);
	return 1;
}
int Rebuild(long heigh)
{
	RETAILMSG(1, (TEXT("in  Rebuild heigh  is %ld !\r\n"),heigh));
	unsigned char  *p1;
	unsigned char  *p2;
	int accx;
	int accy;
	int saveslice;
	register int i;	
	int dx, dy;	
	register int n;	
	int end ;
	int num = 0;
	register int l;
	
	char  flag[1000];
	int   sumx[1000];
	int   sumy[1000];
	int startslice = bottomslice + endcount + 1;
	int endslice = topslice;
	int slicenum= endslice - startslice;
	if(slicenum < minslicenum)
	{
		iRebuildHeight = 0;
		return iRebuildHeight;
	}
	accx = 0;
	accy = 0;
	saveslice = 0;
	end = saveslice;
	sumx[0] = accx;
	sumy[0] = accy;

	i = 1;
	p1 = mapEMS1+((long)(startslice + saveslice)*slicesize);
	p2 = mapEMS1+((long)(startslice + i)*slicesize);

	for(i = 1; i < slicenum; i++)
	{
		p1 = mapEMS1+((long)(startslice + saveslice)*slicesize);
		p2 = mapEMS1+((long)(startslice + i)*slicesize);

		MatchSlice(p2, p1, &dx, &dy);

		if(dy < 3)
		{
			flag[i] = 0;
			sumx[i] = accx + dx;
			sumy[i] = accy + dy;
			continue;
		}
		
		flag[i] = 1;
        	accx += dx;
		accy += dy;

		sumx[i] = accx;
		sumy[i] = accy;
		saveslice = i;

		if(accy > heigh + 8) 
		{
		  break;
		}
	}
	iRebuildHeight = accy < heigh ? accy : heigh;

	RETAILMSG(1, (TEXT("accy  %d !\r\n"),accy));
	RETAILMSG(1, (TEXT("heigh  %d !\r\n"),heigh));
	RETAILMSG(1, (TEXT("iRebuildHeight  %d !\r\n"),iRebuildHeight));
	saveslice = 0;
	for(i = 0; i < iRebuildHeight; i++)
	{

		for(n = saveslice; n < endslice; n++)
		{
			if(flag[n] && i < sumy[n]+7)
			{
				saveslice = n;
				break;
			}
		}
		for(n = saveslice; n < endslice; n++)
        {
          if(flag[n] && i >= sumy[n])
		  {
		    end = n;
			num++;
		  }
          else
            break;
		}
		p1 = mapEMS1+((long)i*slicewidth);
		p2 = mapEMS1+((long)(startslice + saveslice)*slicesize);

		if(num == 0 || end - saveslice > 7)
			ImgSet3(p1, ucBackGround, slicewidth);
		else
			for(l = 0; l < slicewidth; l++)
			{
            	int v = 0;
				for(n = saveslice; n <= end; n++)
				{
					if(flag[n])
					{
						if(l+sumx[n] >= 0 && l+sumx[n] < slicewidth)
							v += *(p2 + (n-saveslice)*slicesize + slicewidth*(i-sumy[n]) + l+sumx[n]);
						else
							v += ucBackGround;
					}
				}
            	v /= num;
				*(p1 + l) = v;
			}
	}
    return iRebuildHeight;
}


int GetImage(unsigned char  *pImage, long lWidth, long lHeight)
{
	int savewidth;
	unsigned char  *p1;
	unsigned char  *p2;
	register int i;	

	long heihei = lHeight;
	Rebuild(heihei);
	if(iRebuildHeight < 100)
    {
		
    	ImgSet4(pImage, 0, lWidth, lHeight);
		return 0;
    }
	savewidth = slicewidth > lWidth ? lWidth : slicewidth;
	for(i = 0; i < lHeight; i++)
	{
		p1 = pImage + (long)i*lWidth + (lWidth - savewidth)/2;
		if(i < iRebuildHeight)
		{
			p2 = mapEMS1+((long)i*slicewidth + (slicewidth - savewidth)/2);
			ImgCpy3(p1, p2, savewidth);
		}
		else
		ImgSet3(p1, ucBackGround, savewidth);
	}
	return 1;
}




void ImgSet3(unsigned char  *pImage, unsigned char ucValue, int lLenth)
{
	int i;
    unsigned char  *p;
    p = pImage;
    for(i = 0; i < lLenth; i++)
    {
    	*p++ = ucValue;
    }
}

void ImgCpy3(unsigned char  *pDst, unsigned char  *pSrc, int lLenth)
{
	int i;
    unsigned char  *p;
    unsigned char  *q;
    p = pDst;
    q = pSrc;
    for(i = 0; i < lLenth; i++)
    {
        *p++ = *q++;
    }
}

void ImgSet4(unsigned char  *pImage, unsigned char ucValue, long lWidth, long lHeight)
{
	int i, j;
    unsigned char  *p;

    p = pImage;
    for(i = 0; i < lHeight; i++)
    for(j = 0; j < lWidth; j++)
    {
        *p++ = ucValue;
    }
}

void ImgCpy4(unsigned char  *pDst, unsigned char  *pSrc, long lWidth, long lHeight)
{
	int i, j;
    unsigned char  *p;
    unsigned char  *q;

    p = pDst;
    q = pSrc;
    for(i = 0; i < lHeight; i++)
    for(j = 0; j < lWidth; j++)
    {
        *p++ = *q++;
    }
}

float Average2(unsigned char  *pData, long lLenth)
{
    unsigned char  *p;
    int i;
    long sum;

#ifdef __CHECK_OVERFLOW
    if(lLenth <= 0) return 0;
#endif

    p = pData;
    sum = 0;
    for(i = 0; i < lLenth; i++)
        sum += *p++;

    return (float)sum/lLenth;
}

float Variance2(unsigned char  *pData, long lLenth)
{
    unsigned char  *p;
    int i;
    int v;
    long sum1, sum2;

#ifdef __CHECK_OVERFLOW
    if(lLenth <= 0) return 0;
#endif

    p = pData;
    sum1 = 0;
    sum2 = 0;
    for(i = 0; i < lLenth; i++)
    {
        v = *p++;
        sum1 += v;
        sum2 += v*v;
    }

    sum1 /= lLenth;
    sum2 /= lLenth;
    sum2 -= sum1*sum1;

    return (float)sum2;
}
//---------------------------------------------------------------------------

float CoVariance3(unsigned char  *pData1, unsigned char  *pData2, long lLenth)
{
    unsigned char  *p1;
    unsigned char  *p2;
    int i;
    int v1, v2, v;
    long sum1, sum2;

#ifdef __CHECK_OVERFLOW
    if(lLenth <= 0) return 0;
#endif

    p1 = pData1;
    p2 = pData2;
    sum1 = 0;
    sum2 = 0;
    for(i = 0; i < lLenth; i++)
    {
        v1 = *p1++;
        v2 = *p2++;
		v = v1 > v2 ? v1 - v2 : v2 - v1;
		sum1 += v;
		sum2 += v*v;
    }

    sum1 /= lLenth;
    sum2 /= lLenth;
    sum2 -= sum1*sum1;

    return (float)sum2;
}
//---------------------------------------------------------------------------

float Average7(unsigned char  *pImage, long lWidth, long lHeight,
        int iLeft, int iTop, int iRight, int iBottom)
{
    unsigned char  *p;
    int i, j;
    long sum;
    long iArea;

#ifdef __CHECK_OVERFLOW
    if(iLeft < 0 || iTop < 0 || iRight >= lWidth || iBottom >= lHeight) return 0;
#endif

    iArea = (iRight - iLeft + 1)*(iBottom - iTop + 1);

    sum = 0;
    for(i = iTop; i <= iBottom; i++)
    {
        p = pImage + i*lWidth + iLeft;
        for(j = iLeft; j <= iRight; j++)
        {
            sum += *p++;
        }
    }

    return (float)sum/iArea;
}
//---------------------------------------------------------------------------

float Variance7(unsigned char  *pImage, long lWidth, long lHeight,
        int iLeft, int iTop, int iRight, int iBottom)
{
    unsigned char  *p;
    int i, j;
    int v;
    long sum1, sum2;
    long iArea;

#ifdef __CHECK_OVERFLOW
    if(iLeft < 0 || iTop < 0 || iRight >= lWidth || iBottom >= lHeight) return 0;
#endif

    iArea = (iRight - iLeft + 1)*(iBottom - iTop + 1);

    sum1 = 0;
    sum2 = 0;
    for(i = iTop; i <= iBottom; i++)
    {
        p = (unsigned char *)pImage + i*lWidth + iLeft;
        for(j = iLeft; j <= iRight; j++)
        {
            v = *p++;
            sum1 += v;
            sum2 += v*v;
        }
    }

    sum1 /= iArea;
    sum2 /= iArea;
    sum2 -= sum1*sum1;

    return (float)sum2;
}
//---------------------------------------------------------------------------

float CoVariance8(unsigned char  *pImage1, unsigned char  *pImage2, long lWidth, long lHeight,
    int iLeft, int iTop, int iRight, int iBottom)
{
    unsigned char  *p1;
    unsigned char  *p2;
    int i, j;
    int v1, v2, v;
    long sum1, sum2;
    long iArea;

#ifdef __CHECK_OVERFLOW
    if(iLeft < 0 || iTop < 0 || iRight >= lWidth || iBottom >= lHeight) return 0;
#endif

    iArea = (iRight - iLeft + 1)*(iBottom - iTop + 1);

    sum1 = 0;
    sum2 = 0;
    for(i = iTop; i <= iBottom; i++)
    {
        p1 = pImage1 + i*lWidth + iLeft;
        p2 = pImage2 + i*lWidth + iLeft;
        for(j = iLeft; j <= iRight; j++)
        {
            v1 = *p1++;
            v2 = *p2++;
			v = v1 > v2 ? v1 - v2 : v2 - v1;
			sum1 += v;
			sum2 += v*v;
        }
    }
    sum1 /= iArea;
    sum2 /= iArea;
    sum2 -= sum1*sum1;
    return (float)sum2;
}

unsigned char Swing(unsigned char  *pImage, long lWidth, long lHeight,
        int iLeft, int iTop, int iRight, int iBottom)
{
    unsigned char  *p;
    unsigned char  *q;
    int i, j;
    unsigned char v;
    unsigned char ucMax, ucMin;
#ifdef __CHECK_OVERFLOW
    if(iLeft < 0 || iTop < 0 || iRight >= lWidth || iBottom >= lHeight) return 0;
#endif
    ucMax = 0;
    ucMin = 255;
    p = pImage + iTop*lWidth + iLeft;
    for(i = iTop; i <= iBottom; i++)
    {
    	q = p;
        for(j = iLeft; j <= iRight; j++)
        {
            v = *q++;
            if(v > ucMax) ucMax = v;
            if(v < ucMin) ucMin = v;
        }
        p += lWidth;
    }
    if(ucMax < ucMin) return 0;
    return ucMax - ucMin;
}


void Capture()
{
   if(GetSlice())
   {
	   RETAILMSG(1, (TEXT("***FingerDrv: GetSlice sucess!\r\n")));
	   if(GetImage(pImage, clWidth, clHeight))
	   {
	     RETAILMSG(1, (TEXT("***FingerDrv: GetImage sucess!\r\n")));
	   }
   } 	
   else 
   {
	   RETAILMSG(1, (TEXT("***FingerDrv: GetImage Error!\r\n")));
   }
}