dib.cpp

《数字图象工程案例》原码

	for(int i=0; i<dstHeight;i++)
	{
		float y_inverse_map = (float)i/scal_y;
		int y_lt = (int)y_inverse_map;
		float v=y_inverse_map - y_lt;
		int indexBase = i *wid;
		for(int j=0;j<dstWidth;j++)
		{
			float x_inverse_map = (float)j/scal_x;
			int x_lt = (int) x_inverse_map;
			float u=x_inverse_map - x_lt;
			int index = indexBase + j*3;
			*(lpData+index) = Src[y_lt*((w*24+31)/32*4)+x_lt*3];
			*(lpData+index+1) = Src[y_lt*((w*24+31)/32*4)+x_lt*3+1];
			*(lpData+index+2) = Src[y_lt*((w*24+31)/32*4)+x_lt*3+2];
		//	int r,g,b;
			//((interPolate(Src,x_lt,y_lt,u,v,srcWidth,srcHeight,&r,&g,&b))) ;
		//	*(lpData+temp)   = b;
			//*(lpData+index++)   = (BYTE)((interPolate(Src,x_lt,y_lt,u,v,srcWidth,srcHeight)>>16)) & 0x000000ff;
		//	(interPolate(Src,x_lt,y_lt,u,v,srcWidth,srcHeight,&r,&g,&b));
		//	*(lpData+temp+1)   = g;
		  //  (interPolate(Src,x_lt,y_lt,u,v,srcWidth,srcHeight,&r,&g,&b));
		//	 *(lpData+temp+2)   =r;
			
		}
	}
	GlobalUnlock(hDIB);
	GlobalUnlock(hDIB2);
	return hDIB2;

}

//cwh 01.6.20
/*****************************************
卷积核心算法
*****************************************/
void DIB::interPolate(LPBYTE Src,int x,int y, float u,float v, int scanw, int scanh,int *r,int *g,int *b)
{
//	UINT r11,g11,b11;
	//r=g=b=0;
		int red1[2][2];
		int green1[2][2];
		int blue1[2][2];
		int xx1[2];
		int yy1[2];
		xx1[0]=x*3;xx1[1]=x*3+3;
		yy1[0]=y;yy1[1]=y+1;
		if(xx1[1]>scanw-1)
			xx1[1] = scanw-1;
		if(yy1[1]>scanh-1)
			yy1[1] = scanh-1;

		for(int i=0;i<2;i++)
		{
			int indexBase1 = yy1[i]*((scanw*24+31)/32*4);
			for(int j=0;j<2;j++)
			{
				int index1 = indexBase1 + xx1[j];
				blue1[j][i] = (*(Src+index1));
			    green1[j][i] = (*(Src+index1+1));
			    red1[j][i] =  (*(Src+index1+2));

			}
		}

		//r11 = ((1-u)*(1-v)*red1[0][0]+(1-u)*v*red1[0][1]+u*(1-v)*red1[1][0]+u*v*red1[1][1]);
	//	g11 = ((1-u)*(1-v)*green1[0][0]+(1-u)*v*green1[0][1]+u*(1-v)*green1[1][0]+u*v*green1[1][1]);
		//b11 = ((1-u)*(1-v)*blue1[0][0]+(1-u)*v*blue1[0][1]+u*(1-v)*blue1[1][0]+u*v*blue1[1][1]);
  
	//	*r=r11;
		//*g=g11;
	//	*b=b11;
//	return (0x00ffffff&((b<<16)|(g<<8)|r));
}

HANDLE DIB::CopyHandle( HANDLE hSrc)
{	
	HANDLE hDst;
	LPBITMAPINFOHEADER lpbi;
	int width,height;
	lpbi = (LPBITMAPINFOHEADER)GlobalLock(hSrc);
	width = lpbi->biWidth;
	height = lpbi->biHeight;
	hDst = GlobalAlloc(GMEM_MOVEABLE,lpbi->biSize+lpbi->biSizeImage);
	if(!hDst)
		return NULL;
	LPBYTE lpDest;
	lpDest = (LPBYTE)GlobalLock(hDst);
	memcpy(lpDest,(LPBYTE)lpbi,lpbi->biSize+lpbi->biSizeImage);
	GlobalUnlock(hSrc);
	GlobalUnlock(hDst);
	return hDst;

}

void DIB::WangGeHua(HANDLE hDIB, int steplen, float jwm)
{
	
	LPBITMAPINFOHEADER lpbi;
	lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
	int width = lpbi->biWidth;
	int height = lpbi->biHeight;
	LPBYTE lpData = this->FindDIBBits(hDIB);
	int templen = (int)(steplen*jwm);
	WORD wBytesPerline = this->BytePerLine(hDIB);
	for(int i =0;i<height/(int)(steplen*jwm);i++)
		for(int j =0;j<width/steplen;j++)
		{
			int redcount =0;
			int greencount =0;
			int bluecount = 0;
			int yellowcount =0;
			int whitecount = 0;
		
			for(int k=0;k<(int)(steplen*jwm);k++)
				for(int kk =0;kk<steplen;kk++)
				{
					long lOffset = this->PixelOffset(i*templen+k,j*steplen+kk,wBytesPerline);
					int blue = *(lpData+lOffset++);
					int green = *(lpData+lOffset++);
					int red = *(lpData+lOffset++);
					if(red == 255 && blue == 0 && green == 0 )
						redcount++;
					if(red == 0 && blue == 0 && green == 255 )
						greencount++;
					if(red == 0 && blue == 255 && green == 0 )
						bluecount++;
					if(red == 255 && blue == 0 && green == 255 )
						yellowcount++;
					if(red == 255 && blue == 255 && green == 255 )
						whitecount++;
				}
				PICTURECOLOR pc;
				int sum;
				if(redcount>greencount)
				{
					pc = m_RED;
					sum = redcount;
				}
				else
				{
				
					pc = m_GREEN;
					sum = greencount;
				}
				if(bluecount>sum)
				{
					sum = bluecount;
					pc = m_BLUE;
				}
				if(yellowcount>sum)
				{
					pc = m_YELLOW;
					sum = yellowcount;
				}
				if(whitecount>sum)
					pc = m_WHITE;

				if(pc == m_RED){
				
					for( k=0;k<(int)(steplen*jwm);k++)
					for(int kk =0;kk<steplen;kk++)
					{
						long lOffset = this->PixelOffset(i*templen+k,j*steplen+kk,wBytesPerline);
						*(lpData+lOffset++) = 0;
						*(lpData+lOffset++) = 0;
						*(lpData+lOffset++) = 255;

					}	
				}
				
				if(pc == m_GREEN){
				
					for( k=0;k<(int)(steplen*jwm);k++)
					for(int kk =0;kk<steplen;kk++)
					{
						long lOffset = this->PixelOffset(i*templen+k,j*steplen+kk,wBytesPerline);
						*(lpData+lOffset++) = 0;
						*(lpData+lOffset++) = 255;
						*(lpData+lOffset++) = 0;

					}	
				}
				
					if(pc == m_BLUE)
					{
				
					for( k=0;k<(int)(steplen*jwm);k++)
					for(int kk =0;kk<steplen;kk++)
					{
						long lOffset = this->PixelOffset(i*templen+k,j*steplen+kk,wBytesPerline);
						*(lpData+lOffset++) = 255;
						*(lpData+lOffset++) = 0;
						*(lpData+lOffset++) = 0;

					}	
				}

						if(pc == m_YELLOW)
					{
				
					for( k=0;k<(int)(steplen*jwm);k++)
					for(int kk =0;kk<steplen;kk++)
					{
						long lOffset = this->PixelOffset(i*templen+k,j*steplen+kk,wBytesPerline);
						*(lpData+lOffset++) = 0;
						*(lpData+lOffset++) = 255;
						*(lpData+lOffset++) = 255;

					}	
				}

					if(pc == m_WHITE)
					{
				
					for( k=0;k<(int)(steplen*jwm);k++)
					for(int kk =0;kk<steplen;kk++)
					{
						long lOffset = this->PixelOffset(i*templen+k,j*steplen+kk,wBytesPerline);
						*(lpData+lOffset++) = 255;
						*(lpData+lOffset++) = 255;
						*(lpData+lOffset++) = 255;

					}	
				}				

		}
		GlobalUnlock(hDIB);
}


void DIB::PicAssemble(HANDLE hDIB, CPoint mousepos, CPoint scroll, bool type, int width, int height)
{
	if(type == false)//水平方向
	{
		if(mousepos.x+scroll.x >=width || mousepos.x+scroll.x <= OFFSET)
		return;
		else
		{
			WORD wbytesPerline = this->BytePerLine(hDIB);
			long size = wbytesPerline * height;
			byte *ptemp = new byte[size];
			if(!ptemp)
			{
				AfxMessageBox("not enough memory");
				return;
			}
			LPBYTE lpData = this->FindDIBBits(hDIB);
			for(int i=0;i<height;i++)
				for(int j=0;j<width;j++)
				{
					long lOffset = this->PixelOffset(i,j,wbytesPerline);
					ptemp[lOffset] = *(lpData+lOffset);
					ptemp[lOffset+1] = *(lpData+lOffset+1);
					ptemp[lOffset+2] = *(lpData+lOffset+2);
				}
			int x = mousepos.x + scroll.x ;
			for(int j=0;j<height;j++)
				for(i =0;i<width-x;i++)
				{
					long lOffset = this->PixelOffset(j,i,wbytesPerline);
					*(lpData+lOffset) = ptemp[j*wbytesPerline+(x+i)*3];
					*(lpData+lOffset+1) = ptemp[j*wbytesPerline+(x+i)*3+1];
					*(lpData+lOffset+2) = ptemp[j*wbytesPerline+(x+i)*3+2];
				}
			for( i=0;i<height;i++)
				for(j=width-x;j<width;j++)
				{
					long lOffset = this->PixelOffset(i,j,wbytesPerline);
					*(lpData+lOffset) = ptemp[i*wbytesPerline+(j-width+x)*3];
					*(lpData+lOffset+1) = ptemp[i*wbytesPerline+(j-width+x)*3+1];
					*(lpData+lOffset+2) = ptemp[i*wbytesPerline+(j-width+x)*3+2];

				}
		}
	}
	
	else//竖直方向
	{
		int y = mousepos.y + scroll.y ;
		if(y <=OFFSET || y >= height)
			return;
		else
		{
			
			WORD wbytesPerline = this->BytePerLine(hDIB);
			long size = wbytesPerline * height;
			byte *ptemp = new byte[size];
			if(!ptemp)
			{
				AfxMessageBox("not enough memory");
				return;
			}
			LPBYTE lpData = this->FindDIBBits(hDIB);
			for(int i=0;i<height;i++)
				for(int j=0;j<width;j++)
				{
					long lOffset = this->PixelOffset(i,j,wbytesPerline);
					ptemp[lOffset] = *(lpData+lOffset);
					ptemp[lOffset+1] = *(lpData+lOffset+1);
					ptemp[lOffset+2] = *(lpData+lOffset+2);
				}
			for(i = 0;i<height-y;i++)
				for(int j=0;j<width;j++)
				{
					long lOffset = this->PixelOffset(i,j,wbytesPerline);
					*(lpData+lOffset) = ptemp[(i+y)*wbytesPerline+j*3];
					*(lpData+lOffset+1) = ptemp[(i+y)*wbytesPerline+j*3+1];
					*(lpData+lOffset+2) = ptemp[(i+y)*wbytesPerline+j*3+2];
				}
			for( i=height-y ;i<height;i++)
				for(int j=0;j<width;j++)
				{
					long lOffset = this->PixelOffset(i,j,wbytesPerline);
					*(lpData+lOffset) = ptemp[(i-height+y)*wbytesPerline+j*3];
					*(lpData+lOffset+1) = ptemp[(i-height+y)*wbytesPerline+j*3+1];
					*(lpData+lOffset+2) = ptemp[(i-height+y)*wbytesPerline+j*3+2];
				}
		}
	}
	
}
	
HANDLE DIB::PicLinkZy(HANDLE hDIBL, HANDLE hDIBR,int scrolll,int scrollr,int scrolllh,int scrollrh)//scroll 为左侧图象竖直滚动条滚动的距离,scroll向下为正数
{																									//scrolllh,scrollrh 为图象在中间被遮去的宽度
	LPBITMAPINFOHEADER lpbi;
	int widthl,widthr,heightl,heightr;
	WORD wBytesPerLinel,wBytesPerLiner;
	LPBYTE lpDatal,lpDatar;
	lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIBL);
	widthl = lpbi->biWidth;
	heightl = lpbi->biHeight;
	lpDatal = this->FindDIBBits(hDIBL);
	lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIBR);
	wBytesPerLinel = this->BytePerLine(hDIBL);
	wBytesPerLiner = this->BytePerLine(hDIBR);
	widthr = lpbi->biWidth;
	heightr = lpbi->biHeight;
	lpDatar = this->FindDIBBits(hDIBR);
	int widthresult;
	int curwidl = widthl - scrolllh;
	if(curwidl<0)
		curwidl =0;
	int curwidr = widthr - scrollrh;
	if(curwidr <0)
		curwidr =0;
	widthresult = curwidl+curwidr;
	int heightresult = 0;
	if(heightl/2-scrolll<heightr/2-scrollr)
		heightresult +=heightr/2-scrollr;
	else
		heightresult +=heightl/2 -scrolll;
	if(heightl/2+scrolll<heightr/2+scrollr)
		heightresult +=heightr/2+scrollr;
	else
		heightresult +=heightl/2 +scrolll;
	 long imgsize = (widthresult*24+31)/8*heightresult;
	 HANDLE hNewDib =  GlobalAlloc(GMEM_MOVEABLE,(DWORD)(sizeof(BITMAPINFOHEADER)+imgsize));
	 if(!hNewDib)
		 return NULL;
	 LPBITMAPINFOHEADER lpbi2 = (LPBITMAPINFOHEADER)GlobalLock(hNewDib);
	 memcpy((LPBYTE)lpbi2,(LPBYTE)lpbi,sizeof(BITMAPINFOHEADER));
	 lpbi2->biWidth = widthresult;
	 lpbi2->biHeight = heightresult;
	 lpbi2->biSizeImage = imgsize;
	 
	 LPBYTE lpResult = this->FindDIBBits(hNewDib);
	 WORD wBytesPerLineRes = this->BytePerLine(hNewDib);
	 if(heightl/2-scrolll<=heightr/2-scrollr)  //左上比右上底
	 {	
		 long lOffset1,lOffset2;
		
		 for(int i=0;i<heightr/2-scrollr-heightl/2+scrolll;i++)
			 for(int j=0;j<curwidl;j++)
			 {
				 
				 lOffset2 = this->PixelOffset(i,j,wBytesPerLineRes);
				 *(lpResult+lOffset2++) = 255;
				 *(lpResult+lOffset2++) = 255;
				 *(lpResult+lOffset2++) = 255;
			 }

		for(i=0;i<heightl;i++)//原左侧图象
			for(int j=0;j<curwidl;j++)
			{
				lOffset1 = this->PixelOffset(i,j,wBytesPerLinel);
				lOffset2 =this->PixelOffset(i+heightr/2-heightl/2-scrollr+scrolll,j,wBytesPerLineRes);
				*(lpResult+lOffset2++) = *(lpDatal + lOffset1++);
				*(lpResult+lOffset2++) = *(lpDatal + lOffset1++);
				*(lpResult+lOffset2++) = *(lpDatal + lOffset1++);
			}
			if(heightl/2+scrolll<heightr/2+scrollr) //左下比右下高
			{
				for( i=0;i<heightr/2-heightl/2+scrollr-scrolll;i++)
					for(int j=0;j<curwidl;j++)
					{
						lOffset2 = this->PixelOffset(i+heightr/2-heightl/2-scrollr+scrolll+heightl,j,wBytesPerLineRes);
						*(lpResult+lOffset2++) = 255;
						*(lpResult+lOffset2++) = 255;
						*(lpResult+lOffset2++) = 255;
					}
			}
			for(i =0;i<heightr;i++) //右侧原图象
				for(int j=widthr-curwidr;j<widthr;j++)
				{
					
					lOffset1 = this->PixelOffset(i,j,wBytesPerLiner);
					lOffset2 = this->PixelOffset(i,j+curwidl-(widthr-curwidr),wBytesPerLineRes);
					*(lpResult+lOffset2++) = *(lpDatar + lOffset1++);
					*(lpResult+lOffset2++) = *(lpDatar + lOffset1++);
					*(lpResult+lOffset2++) = *(lpDatar + lOffset1++);
				}
				if(heightl/2+scrolll>=heightr/2+scrollr)
				{
				for(i =0;i<heightl/2+scrolll-heightr/2-scrollr;i++)
					for(int j=widthr-curwidr;j<widthr;j++)
					{
						lOffset2 = this->PixelOffset(i+heightr,j+curwidl-(widthr-curwidr),wBytesPerLineRes);
						*(lpResult+lOffset2++) = 255;
						*(lpResult+lOffset2++) = 255;
						*(lpResult+lOffset2++) = 255;
					}
				}
	 }
	 
 


	if(heightl/2-scrolll>heightr/2-scrollr)  //左上比右上高
	 {	
		 long lOffset1,lOffset2;
		 
		for(int i=0;i<heightl;i++)//原左侧图象
			for(int j=0;j<curwidl;j++)
			{
				lOffset1 = this->PixelOffset(i,j,wBytesPerLinel);
				lOffset2 =this->PixelOffset(i,j,wBytesPerLineRes);
				*(lpResult+lOffset2++) = *(lpDatal + lOffset1++);
				*(lpResult+lOffset2++) = *(lpDatal + lOffset1++);
				*(lpResult+lOffset2++) = *(lpDatal + lOffset1++);
			}
			if(heightl/2+scrolll<heightr/2+scrollr) //左下比右下高
			{
				for( i=0;i<heightr/2-heightl/2+scrollr-scrolll;i++)
					for(int j=0;j<curwidl;j++)
					{
						lOffset2 = this->PixelOffset(heightl+i,j,wBytesPerLineRes);
						*(lpResult+lOffset2++) = 255;
						*(lpResult+lOffset2++) = 255;
						*(lpResult+lOffset2++) = 255;
					}
			}
			
			for(i =0;i<heightl/2+scrollr-heightr/2-scrolll;i++)//右上
				for(int j =widthr-curwidr;j<widthr;j++)
				{
					lOffset2 = this->PixelOffset(i,j+curwidl-(widthr-curwidr),wBytesPerLineRes);
					*(lpResult+lOffset2++) = 255;
					*(lpResult+lOffset2++) = 255;
					*(lpResult+lOffset2++) = 255;
				}

			for(i =0;i<heightr;i++) //右侧原图象

				for(int j=widthr-curwidr;j<widthr;j++)
				{
					
					lOffset1 = this->PixelOffset(i,j,wBytesPerLiner);
					lOffset2 = this->PixelOffset(i+heightl/2-heightr/2-scrolll+scrollr,j+curwidl-(widthr-curwidr),wBytesPerLineRes);
					*(lpResult+lOffset2++) = *(lpDatar + lOffset1++);
					*(lpResult+lOffset2++) = *(lpDatar + lOffset1++);
					*(lpResult+lOffset2++) = *(lpDatar + lOffset1++);
				}
				if(heightl/2+scrolll>=heightr/2+scrollr) //右下有空白
				{
				for(i =0;i<heightl/2+scrolll-heightr/2-scrollr;i++)
					for(int j=widthr-curwidr;j<widthr;j++)
					{
						lOffset2 = this->PixelOffset(i+heightr/2+heightl/2-scrolll+scrollr,j+curwidl-(widthr-curwidr),wBytesPerLineRes);
						*(lpResult+lOffset2++) = 255;
						*(lpResult+lOffset2++) = 255;
						*(lpResult+lOffset2++) = 255;
					}
				}
	 }

	GlobalUnlock(hDIBL);
	GlobalUnlock(hDIBR);
	return hNewDib;
	 
}