dib.cpp

一个简单的基于肤色模型的人脸检测程序。基于DSPTMSP6711；

		}
		GlobalUnlock(hDIB);
		return true;
		}
		else AfxMessageBox("Can't find the corresponding point!");
	GlobalUnlock(hDIB);
	return false;
}
//比较两张图片的相似度




BOOL DIB::IsScaterPoint(int x, int y, int width, int height, LPBYTE lpData,WORD wBytesPerLine,  int threshold,bool lab[m_HEIGHT][m_WIDTH])
{
	long lOffset;
	//得到数据的偏移
	lOffset = this->PixelOffset(y,x,wBytesPerLine);
	//判断该点是否为白色以及是否计算过了
	if(*(lpData+lOffset) == 255 && lab[y][x] == false)
	{	
		//链长度加一
		this->lenth++;
		//更改标志位
		lab[y][x] = true;
		//如果链长度达到临界值则返回真
	if(this->lenth >= threshold)
		return true;
	//对右边点的边界判断以及标志位判断
	if(x+1<width && lab[y][x+1] == false)
	{	
		//递归调用本函数，对右边的点进行判断
		IsScaterPoint(x+1,y,width,height,lpData,wBytesPerLine,threshold,lab);
		if(this->lenth>=threshold)
			return true;
		
	}
	//处理左边的点
	if(x-1>=0 && lab[y][x-1] == false)
	{
		(IsScaterPoint(x-1,y,width,height,lpData,wBytesPerLine,threshold,lab));
		if(this->lenth>=threshold)
			return true;
		
	}
	//处理上面的点
	if(y-1>=0 && lab[y-1][x]==false)
	{
		(IsScaterPoint(x,y-1,width,height,lpData,wBytesPerLine,threshold,lab));
		if(this->lenth>=threshold)
			return true;
		
	}
	//处理下面的点
	if(y+1<height && lab[y+1][x]==false)
	{	(IsScaterPoint(x,y+1,width,height,lpData,wBytesPerLine,threshold,lab));
			if(this->lenth>=threshold)
			return true;
			
	}
	//处理右下的点
	if(y+1<height  && x+1 <width && lab[y+1][x+1]==false)
	{	(IsScaterPoint(x+1,y+1,width,height,lpData,wBytesPerLine,threshold,lab));
			if(this->lenth>=threshold)
			return true;
			
	}
	//处理左下的点
	if(y+1<height && x-1 >=0 && lab[y+1][x-1]==false)
	{	(IsScaterPoint(x-1,y+1,width,height,lpData,wBytesPerLine,threshold,lab));
			if(this->lenth>=threshold)
			return true;
			
	}
	//处理左上的点
	if(y-1>=0 && x-1 >=0 &&lab[y-1][x-1]==false)
	{	(IsScaterPoint(x-1,y-1,width,height,lpData,wBytesPerLine,threshold,lab));
			if(this->lenth>=threshold)
			return true;
			
	}
	//处理右上的点
	if(y-1<height && x+1<width && lab[y+1][x]==false)
	{	(IsScaterPoint(x+1,y-1,width,height,lpData,wBytesPerLine,threshold,lab));
			if(this->lenth>=threshold)
			return true;
			
	}
	}	
		//如果递归结束，长度达不到临界值，返回假
		return false;
}



BOOL DIB::LightingCompensate(HANDLE hDIB)
{
	if(!hDIB)
		return FALSE;
	LPBITMAPINFOHEADER lpbi;
	int width,height;
	LPBYTE lpData;
	WORD wBytesPerLine;
	lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
	//得到图片宽和高
	width = lpbi->biWidth;
	height = lpbi->biHeight;
	//得到图片数据区
	lpData = this->FindDIBBits(hDIB);
	//得到图片每行的象素所占字节个数
	wBytesPerLine = this->BytePerLine(hDIB);
	//比例系数
	const float thresholdco = 0.05;
	//象素个数的临界常数
	const int thresholdnum = 100;
	//灰度级数组
	int histogram[256];
	for(int i =0;i<256;i++)
		histogram[i] = 0;
	//对于过于小的图片的判断
	if(width*height*thresholdco < thresholdnum)
		return false;
	int colorr,colorg,colorb;
	long lOffset;
	//考察整个图片
	for( i=0;i<height;i++)
		for(int j=0;j<width;j++)
		{	
			//得到象素数据的偏移
			lOffset = this->PixelOffset(i,j,wBytesPerLine);
			//得到rgb值
			colorb = *(lpData+lOffset++);
			colorg = *(lpData+lOffset++);
			colorr = *(lpData+lOffset++);
			//计算灰度值
			int gray = (colorr * 299 + colorg * 587 + colorb * 114)/1000;
			histogram[gray]++;
		}
		int calnum =0;
		int total = width*height;
		int num;
		//下面的循环得到满足系数thresholdco的临界灰度级
		for(i =0;i<256;i++)
		{
			if((float)calnum/total < thresholdco)
			{
				calnum+= histogram[255-i];
				num = i;
			}
			else
				break;
		}
		int averagegray = 0;
		calnum =0;
		//得到满足条件的象素总的灰度值
		for(i = 255;i>=255-num;i--)
		{
			averagegray += histogram[i]*i;
			calnum += histogram[i];
		}
		averagegray /=calnum;
		//得到光线补偿的系数
		float co = 255.0/(float)averagegray;
		//下面的循环对图象进行光线补偿
		for(i =0;i<height;i++)
			for(int j=0;j<width;j++)
			{	
				//得到数据便宜
				lOffset = this->PixelOffset(i,j,wBytesPerLine);
				//得到蓝色分量
				colorb = *(lpData+lOffset);
				//调整
				colorb *=co;
				//临界判断
				if(colorb >255)
					colorb = 255;
				//保存
				*(lpData+lOffset) = colorb;
				//绿色分量
				colorb = *(lpData+lOffset+1);
				colorb *=co;
				if(colorb >255)
					colorb = 255;
				*(lpData+lOffset+1) = colorb;
				//红色分量
				colorb = *(lpData+lOffset+2);
				colorb *=co;
				if(colorb >255)
					colorb = 255;
				*(lpData+lOffset+2) = colorb;

			}
			return TRUE;
}

BOOL DIB::FaceModeling(int Cr,int Cb)
{	
	//Cb的系数常量
	const float cx = 114.38;
	//cr的系数常量
	const float cy = 160.02;
	//角度常量
	const float theta = 2.53;
	//x轴线和y轴线的两个常量
	const float ecx = 1.60;
	const float ecy = 2.41;
	//长轴
	const float a = 25.39;
	//短轴
	const float b = 14.03;
	//相似度常量
	const float judge = 0.5;
	//计算得到x轴数值
	float  x = cos(theta)*(Cb-cx)+sin(theta)*(Cr-cy);
	//y轴数值
	float  y = -sin(theta)*(Cb -cx)+cos(theta)*(Cr-cy);
	//计算离心率
	float temp = pow(x-ecx,2)/pow(a,2)+pow(y-ecy,2)/pow(b,2);
	//如果满足要求返回真，否则假
	if(fabs(temp-1.0)<judge)
		return TRUE;
	else
		return FALSE;

}

LPBYTE DIB::YcctoRgb(LPBYTE lpYcc,WORD wBytesPerLine,int height,int width)
{
	LPBYTE lpRGB;
	//申请内存
	lpRGB = new BYTE[wBytesPerLine*height];
	//检查内容分配
	if(lpRGB == NULL)
	{
		AfxMessageBox("not enought memory");
		return NULL;
	}
	long lOffset;
	//下面的循环实现从ycc到rgb的转换
	for(int i=0;i<height;i++)
		for(int j=0;j<width;j++)
		{	
			//得到数据便宜
			lOffset = PixelOffset(i,j,wBytesPerLine);
			//得到y，Cr，Cb的数值
			int Y = *(lpYcc+lOffset);
			int Cr = *(lpYcc+lOffset+1);
			int Cb = *(lpYcc+lOffset+2);
			//利用公式进行计算，并把结果保存到动态数组里面
			*(lpRGB+lOffset+2) = (1164*(Y-16)+1596*(Cr-128))/1000;
			*(lpRGB+lOffset+1) = (1164*(Y-16) - 813*(Cr-128) - 392*(Cb-128))/1000;
			*(lpRGB+lOffset)   = (1164*(Y-16) +2017*(Cb-128))/1000;
		}
	return lpRGB;
}


int DIB::_Cb(int Y)
{	
	int Cb;
	//如果亮度很小的情况
	if(Y<Kl)
		Cb = 108 + ((Kl-Y)*10)/(Kl-Ymin);
	//亮度很大的情况
	else if(Y>Kh)
		Cb = 108 + ((Y-Kh)*10)/(Ymax - Kh);
	else 
		Cb = -1;
	return Cb;
}

int DIB::_Cr(int Y)
{
	int Cr;
	//亮度很小的情况
	if(Y<Kl)
		Cr = 154 - ((Kl-Y)*10)/(Kl-Ymin);
	//亮度很大的情况
	else if(Y>Kh)
		Cr = 154 - ((Y-Kh)*22)/(Ymax - Kh);
	else
		Cr = -1;
	return Cr;
}
int DIB::_WCr(int Y)
{
	int WCr;
	if(Y<Kl)
		//亮度很小的情况
		WCr = WLcr + ((Y-Ymin)*(Wcr-WLcr))/(Kl-Ymin);
	else if(Y>Kh)
		//亮度很大的情况
		WCr = WHcr + ((Ymax-Y)*(Wcr-WHcr))/(Ymax-Kh);
	else WCr = -1;
	return WCr;
}

int DIB:: _WCb(int Y)
{
	int WCb;
	if(Y<Kl)
		//亮度很小的情况
		WCb = WLcb + ((Y-Ymin)*(Wcb-WLcb))/(Kl-Ymin);
	else if(Y>Kh)
		//亮度很大的情况
		WCb = WHcb + ((Ymax-Y)*(Wcb-WHcb))/(Ymax-Kh);
	else WCb = -1;
	return WCb;
}
void DIB::YccTransform(LPBYTE lpYcc,WORD wBytesPerLine,int height,int width)
{	
	int Y,Cr,Cb;
	long lOffset;
	//下面的循环实现ycc色彩空间的非线性转换
	for(int i=0;i<height;i++)
		for(int j=0;j<width;j++)
		{	
			//得到数据偏移
			lOffset = PixelOffset(i,j,wBytesPerLine);
			//得到y，Cr，Cb数值
			Y = *(lpYcc+lOffset);
			Cr = *(lpYcc+lOffset+1);
			Cb = *(lpYcc+lOffset+2);
			//如果y数值在两个临界值之间，保持不变
			if(Y>=Kl && Y<=Kh)
				continue;
			//调用非线性转换函数调整Cr，Cb的数值
			Cr = (Cr-_Cr(Y))*(Wcr/_WCr(Y))+_Cr(Kh);
			Cb = (Cb-_Cb(Y))*(Wcb/_WCb(Y))+_Cb(Kh);
			*(lpYcc+lOffset+1) = Cr;
			*(lpYcc+lOffset+2) = Cb;
		}
}

void DIB::faceear(LPBYTE lpYcc, WORD wBytesPerLine, int height,int width, bool flag[ImgRange][ImgRange])
{	
	//初始化标志位
	for (int i=0; i<ImgRange; i++)
		for (int j=0; j<ImgRange; j++)
		{
			flag[i][j] = false;
		}

	long lOffset;
	int Cr;
	int Cb;
	for (i=0; i<height; i++)
		for (int j=0; j<width; j++)
		{	
			//得到偏移
			lOffset = PixelOffset(i,j,wBytesPerLine);
			//得到Cr，Cb数值
			Cr = *(lpYcc+lOffset+1);
			Cb = *(lpYcc+lOffset+2);
			//人脸颜色建模
			if(FaceModeling(Cr,Cb))
			{	
				//修改标志位
				flag[i][j] = true;
			}
		}
	
}

void  DIB::FaceLocate(HANDLE hDIB, CRect faceLocation[10], int &faceNum)
{	

	HANDLE hDIBTemp;
	//保存当前数据
	hDIBTemp = this->CopyHandle(hDIB);
	LPBITMAPINFOHEADER lpbi;
	LPBYTE lpData;
	WORD wBytesPerLine;
	int height;
	int width;
	long lOffset;
	//得到图象的基本信息
	lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
	height = lpbi->biHeight;
	width  = lpbi->biWidth;
	lpData = FindDIBBits(hDIB);
	wBytesPerLine = BytePerLine(hDIB);

	//人脸数目初始化为0
	faceNum =0;
	for(int k=0; k<10; k++)
	{	
		//初始化区域
		faceLocation[k].bottom = -1;
		faceLocation[k].top = height;
		faceLocation[k].right = -1;
		faceLocation[k].left = width;
	}

	for(int i=0; i<height; i++)
		for (int j=0; j<width; j++)
		{	
			//偏移
			lOffset = PixelOffset(i,j,wBytesPerLine);
			int num;
			//当前点的数值
			num = *(lpData + lOffset);
			if (num !=0)//不是黑色
			{	
				//递归计算
				RecursiveLocateRect(lpData, wBytesPerLine, i, j, num, faceLocation[faceNum]);
				faceNum++;
			}
		}
	GlobalUnlock(hDIB);
	GlobalFree(hDIB);
	//数值还原
	hDIB = this->CopyHandle(hDIBTemp);
	lpData = FindDIBBits(hDIB);
	wBytesPerLine = BytePerLine(hDIB);
	for (i=0; i<faceNum; i++)
		for (int j=faceLocation[i].top; j<faceLocation[i].bottom; j++)
		{	
			//把得到的人脸区域用绿色矩形标注，处理竖直的两条边
			lOffset = this->PixelOffset(j, faceLocation[i].left, wBytesPerLine);
			*(lpData + lOffset++) = 0;
			*(lpData + lOffset++) = 255;
			*(lpData + lOffset++) = 0;
			lOffset = this->PixelOffset(j, faceLocation[i].right, wBytesPerLine);
			*(lpData + lOffset++) = 0;
			*(lpData + lOffset++) = 255;
			*(lpData + lOffset++) = 0;

		}

		for (i=0; i<faceNum; i++)
		for (int j=faceLocation[i].left; j<faceLocation[i].right; j++)
		{	
			//处理水平的两天矩形边
			lOffset = this->PixelOffset(faceLocation[i].top, j, wBytesPerLine);
			*(lpData + lOffset++) = 0;
			*(lpData + lOffset++) = 255;
			*(lpData + lOffset++) = 0;
			lOffset = this->PixelOffset(faceLocation[i].bottom, j, wBytesPerLine);
			*(lpData + lOffset++) = 0;
			*(lpData + lOffset++) = 255;
			*(lpData + lOffset++) = 0;

		}
	
		
	
	GlobalFree(hDIBTemp);	
	GlobalUnlock(hDIB);
}

void DIB::RecursiveLocateRect(LPBYTE lpData,WORD wBytesPerLine, int y, int x, int num, CRect &faceRect)
{	
	long lOffset;
	//得到偏移
	lOffset = PixelOffset(y,x,wBytesPerLine);
	//数值判断
	if(*(lpData + lOffset) == num)
	{	
		//更改颜色为黑色
		*(lpData + lOffset++) = 0;
		*(lpData + lOffset++) = 0;
		*(lpData + lOffset++) = 0;
		//修改矩形的上下左右四个点位置
		if(faceRect.bottom < y)
		{
			faceRect.bottom = y;
		}

		if(faceRect.top > y)
		{
			faceRect.top = y;
		}

		if(faceRect.right < x)
		{
			faceRect.right = x;
		}

		if(faceRect.left > x)
		{
			faceRect.left = x;
		}
		//上下左右调用本函数进行区域判定
		RecursiveLocateRect(lpData, wBytesPerLine, y-1, x, num,faceRect);
		RecursiveLocateRect(lpData, wBytesPerLine, y+1, x, num, faceRect);
		RecursiveLocateRect(lpData, wBytesPerLine, y, x-1, num, faceRect);
		RecursiveLocateRect(lpData, wBytesPerLine, y, x+1, num, faceRect);
	}
	
}

void DIB::EyeMapC(LPBYTE lpRgb, const LPBYTE lpYcc,  WORD wBytesPerLine, CRect faceLocation)
{
	long lOffset;
	int cr;
	int cb;
	//根据传进来的矩形区域进行眼睛的色度匹配
	for(int i=faceLocation.top; i<=faceLocation.bottom; i++)
		for (int j=faceLocation.left; j<=faceLocation.right; j++)
		{	
			//得到Cr，Cb数值
			lOffset = PixelOffset(i, j, wBytesPerLine);
			cr = *(lpYcc + lOffset +1);
			cb = *(lpYcc + lOffset +2);
			//标志
			bool lab;
			//判断Cb分量的数值，并修改标志
			int cmap = cb -116 ;
			if(cmap >-1 && cmap <4)
				lab = true;
			else
				lab = false;