imgp.cpp

人脸检测接口,图像比对源代码

		{
			GetPixel( j, i, R,G, B );
			yvalue[i*ImageHeight + j ]=R*0.299+G*0.587+B*0.114;
			ivalue[i*ImageHeight + j ]=0-R*0.169-G*0.331+B*0.5;
			qvalue[i*ImageHeight + j ]=R*0.5-G*0.419-B*0.081;
		}
	}

	yimg->CreatFromRaw( ImageWidth, ImageHeight, "GRAY", yvalue, ImageWidth*ImageHeight );
	qimg->CreatFromRaw( ImageWidth, ImageHeight, "GRAY", qvalue, ImageWidth*ImageHeight );
	iimg->CreatFromRaw( ImageWidth, ImageHeight, "GRAY", ivalue, ImageWidth*ImageHeight );

	delete []yvalue;
	delete []qvalue;
	delete []ivalue;
	return TRUE;
}

BOOL CImgP::Trans2RGB(CImgP *rimg, CImgP *gimg, CImgP *bimg)
{
	int i,j;
	unsigned R, G, B;
	BYTE *rvalue, *gvalue, *bvalue;
	int ImageWidth,ImageHeight;
	ImageWidth = bInfoHeader->biWidth;
	ImageHeight = bInfoHeader->biHeight;
	
	rvalue = new BYTE[ImageWidth*ImageHeight];
	gvalue = new BYTE[ImageWidth*ImageHeight];
	bvalue = new BYTE[ImageWidth*ImageHeight];

	for( i=0; i<ImageHeight; i++ )
	{
		for( j=0; j<ImageWidth; j++ )
		{
			GetPixel( j, i, R, G, B );
			rvalue[i*ImageHeight+j] = BYTE(R);
			gvalue[i*ImageHeight+j] = BYTE(G);
			bvalue[i*ImageHeight+j] = BYTE(B);
		}
	}

	rimg->CreatFromRaw( ImageWidth, ImageHeight, "GRAY", rvalue, ImageWidth*ImageHeight );
	gimg->CreatFromRaw( ImageWidth, ImageHeight, "GRAY", gvalue, ImageWidth*ImageHeight );
	bimg->CreatFromRaw( ImageWidth, ImageHeight, "GRAY", bvalue, ImageWidth*ImageHeight );

	delete []rvalue;
	delete []gvalue;
	delete []bvalue;
	return TRUE;
}


int CImgP::GetBitCount()
{
	return bInfoHeader->biBitCount ;
}

BOOL CImgP::CreatFromRaw(int w, int h, CString mode, BYTE *imgdata, int datalen)
{
	if( mode == "RGB" )
	{
		flag=0;
		CreateDirect(w,h);
		
		for(int j=0;j<h;j++)
		{
			for(int i=0;i<w;i++)
			{
				if( (j*w+i) > datalen )
				{
					break;
				}
				BYTE r= *(imgdata + 3*(j*w + i)  );
				BYTE g= *(imgdata + 3*(j*w + i)+1  );
				BYTE b= *(imgdata + 3*(j*w + i)+2  );
				SetPixel(i,j,RGB(r,g,b));
			}
			if( (j*w+i) > datalen )
			{
				break;
			}
		}
		flag=1;
		return TRUE;
	}

	else if( mode == "GRAY" )
	{
		//// add the format information to file header:
		int i,j;
/*		BYTE Palette[256][3];
		char curdir[80];

		curdir[0] = 0;
		CTestlibApp* ap = ( CTestlibApp* )AfxGetApp();
		strcpy( curdir, ap->workdir);
		strcat( curdir, "\\colorinfo.cfg");

		FILE *fcolorinfo;
		fcolorinfo = fopen( curdir, "rt" );
		
		for(i=0;i<256;i++)
		{
			for(j=0;j<3;j++)
			{
				int tempint = 0;
				fscanf( fcolorinfo, "%d ", &tempint );
				Palette[i][j] = BYTE(tempint);
			}
		}
		fclose( fcolorinfo );
*/
		flag=0;
		CreateDirect(w,h);
		for(j=0;j<h;j++)
		{
			for(i=0;i<w;i++)
			{
				if( (j*w+i) > datalen )
				{
					break;
				}
				BYTE Index=*(imgdata+j*w+i);
				BYTE b= Index; //Palette[Index][0];
				BYTE g= Index; //Palette[Index][0];
				BYTE r= Index; //Palette[Index][0];
				SetPixel(i,j,RGB(r,g,b));
			}
			if( (j*w+i) > datalen )
			{
				break;
			}
		}
		flag=1;
	//	delete FileData;
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}


BOOL CImgP::Save(LPCTSTR filename)
{
	CString str(filename,256);
	if(str.Find(".bmp")==-1)
	{
		AfxMessageBox("Only bmp supported");
		return FALSE;
	}
	CFile file;
	CFileException e;
	if(!file.Open(filename,CFile::modeCreate|CFile::modeWrite,&e))
	{
		#ifdef _DEBUG  
			AfxMessageBox("Can't open file!");
		#endif
		return FALSE;
	}
	file.Seek(0L,CFile::begin);
	if(flag==1)
	{
		file.Write(bData,lenth);
	}
	file.Close();
	return TRUE;
}

BOOL CImgP::DownSamp( CImgP *outimg)
{
	int i, j, nwid, nhei;
	nwid = (bInfoHeader->biWidth)/4;
	nhei = (bInfoHeader->biHeight)/4;
	outimg->CreateDirect( nwid, nhei );

	for( i=0; i<nwid; i++ )
		for( j=0; j<nhei; j++ )
			outimg->SetPixel(i, j, GetPixel(4*i, 4*j));
		
	return TRUE;
}

/// input arguments : flag = 1:expenontial; flag = 2 layeighn.
BOOL CImgP::HistoModi( int flag, CImgP *oim, float alpha)
{
	///////new added 0519
	GetGrayData();

	if(!fData)
	{
		AfxMessageBox( "Image fdata wrong!" );
		return FALSE;
	}
	if( (flag==1) && alpha>1 )
	{
		AfxMessageBox("alpha parameter is not proper!");
		return FALSE;
	}
 
	long int data[256];
	BYTE *resultvalue;
	int i,j;
	for(i=0;i<256;i++)
	{
		data[i]=0L;
	}

	int width = GetWidth();
	int height = GetHeight();
	long int total=(long)width*height;
	for(i=0;i<total;i++)
	{
		data[int(fData[i])]++;
	}

	float zft1[256];
	for(i=0;i<256;i++)
	{
		zft1[i]=(float)data[i]/total;
	}

	float count=0.0f;
	for(i=0;i<256;i++)
	{
		count+=zft1[i];
		
		switch( flag ) 
		{
		case 1:           // expotential distribution modification
			data[i] = int(-log(1-count)/alpha+0.5);
			break;
		case 2:          // Layeign distribution modification
			data[i] = int( sqrt(2*alpha*alpha*log(1/(1-count)))+0.5);
			break;
		default:        //default: histogram equilization:
			data[i] = int(count*255);
		}

		if( data[i]>255 )
			data[i]=255;
	}

	resultvalue = new BYTE[total];
	for( i=0; i<height; i++ )
		for( j=0; j<width; j++ )
		{
			resultvalue[i*width+j] = BYTE(data[int(fData[i*width+j])]);
		}

	oim->CreatFromRaw( width, height, "GRAY", resultvalue, width*height);
	delete []resultvalue;
	return TRUE;
}

//////////////////////input arguments:  ///////////////////////////
/////////////ftype: spatial domain filter type
//////// 1: LPf; 2:hpf; 3:directional smoothing; 4: unsharp masking.
void CImgP::Histogram() 
//Get the gray histogram
{
	long int data[256];
	int i,j;
	for(i=0;i<256;i++)
	{
		data[i]=0L;
	}
	int width=GetWidth();
	int height=GetHeight();
	for(i=0;i<width;i++)
	{
		for(j=0;j<height;j++)
		{
			COLORREF color=GetPixel(i,j);
			int r=GetRValue(color);
			int g=GetGValue(color);
			int b=GetBValue(color);
			float gray1=float(r)*0.3f+(float)g*0.59f+(float)b*0.11f+0.5f;
			BYTE Gray=(BYTE)gray1;
			data[Gray]++;
		}
	}
	long int total=0;
	for(i=0;i<256;i++)
	{
		if(data[i]>total)total=data[i];
	}
	for(i=0;i<256;i++)
	{
//		CTestlibApp *app=(CTestlibApp *)AfxGetApp();
//		app->GrayData[i]=(float)data[i]/total;
	}
}

BOOL CImgP::GetGrayData()
{
	int i, j;
	if( !fData )
	{
		fData = new BYTE[bInfoHeader->biHeight*bInfoHeader->biWidth];
		for(j=0;j<bInfoHeader->biHeight;j++)
		{
			for(i=0;i<bInfoHeader->biWidth;i++)
			{			
				COLORREF color = GetPixel(i,j);
				BYTE r=GetRValue(color);
				BYTE g=GetGValue(color);
				BYTE b=GetBValue(color);
				fData[(j)*(bInfoHeader->biWidth)+i]=BYTE(float(r)*0.59+float(g)*0.3+float(b)*0.11+0.5f);
			}
		}
	}

	return	TRUE;
}

int CImgP::search_t(BYTE x1, BYTE x2)
{
	if(x1 == 0 && x2 == 1)
		return 1;
	else 
		return 0;
}

void CImgP::Load_new(LPCTSTR filename)
{
	CString str(filename,256);
	if(str.Find(".bmp")!=-1)
	{
		CFile file;
		CFileException e;
		if(!file.Open(filename,CFile::modeRead,&e))
		{
			#ifdef _DEBUG  
				AfxMessageBox("Can't open img file!");
			#endif
			return;
		}
		file.Seek(0L,CFile::begin);
		unsigned long int FileLenth;
		BYTE *FileData;
		FileLenth=file.GetLength();
		lenth=FileLenth;
		FileData=new BYTE[lenth];
		bData=FileData;
		if(!FileData)
		{
			AfxMessageBox("Fail to allocate memory!");
			return ;
		}
		if(!file.ReadHuge(FileData,FileLenth))
		{
			AfxMessageBox("Fail to read data!");
			return ;
		}
		flag=1;
		bFileHeader=(LPBITMAPFILEHEADER)FileData;
		bInfoHeader=(LPBITMAPINFOHEADER)(FileData+sizeof(BITMAPFILEHEADER));
		lenth = bInfoHeader->biSizeImage;

		bBMI=(LPBITMAPINFO)bInfoHeader;
		bitData=bData+54;
		if(((unsigned char)bFileHeader->bfType!='B')||\
		   ((unsigned char)(bFileHeader->bfType>>8)!='M') )
		{
			AfxMessageBox("It's not a legal bmp file!");
			return ;
		}
		file.Close();

		BytesPerLine=bInfoHeader->biWidth*(bInfoHeader->biBitCount/8);
		if(BytesPerLine%4!=0)BytesPerLine=(BytesPerLine/4+1)*4;

		orderData = new unsigned char[BytesPerLine*(bInfoHeader->biHeight)];

		int x, y;
		for( x=0; x<bInfoHeader->biWidth; x++ )
			for( y=0; y<bInfoHeader->biHeight; y++ )
			{
				orderData[ y*BytesPerLine+x*3 ] = bitData[ (bInfoHeader->biHeight-y-1)*BytesPerLine+x*3 ];
				orderData[ y*BytesPerLine+x*3+1 ] = bitData[ (bInfoHeader->biHeight-y-1)*BytesPerLine+x*3+1 ];
				orderData[ y*BytesPerLine+x*3+2 ] = bitData[ (bInfoHeader->biHeight-y-1)*BytesPerLine+x*3+2 ];
			}
	}
	else
	{
		AfxMessageBox("Unsupported formats!");
		return ;
	}
}