jihebianhuandib.cpp

VC++图像处理程序设计配套光盘的设计源码 VC++ImageProcessingProgrammeDesign

	LONG	newheight;
	// 指向源图像的指针
	LPBYTE	p_data ;
	LPBYTE  temp;
    temp=this->GetData();
    p_data= temp;
	// 指向源象素的指针
	LPBYTE	lpSrc;
	// 指向缩放图像对应象素的指针
	LPBYTE	lpDst;
	// 指向缩放图像的指针
	LPBYTE	hDIB;
	// 循环变量（象素在新DIB中的坐标）
	LONG	i;
	LONG	j;
	// 象素在源DIB中的坐标
	LONG	i0;
	LONG	j0;
	if(m_pBitmapInfoHeader->biBitCount<9)		//灰度图像
	{
		// 获取图像的宽度
		wide = this->GetWidth();
		LineBytes=(wide*8+31)/32*4;
		// 获取图像的高度
		height = this->GetHeight();
		// 计算缩放后的图像实际宽度和高度
		// 此处直接加0.5是由于强制类型转换时不四舍五入，而是直接截去小数部分
		newwide = (LONG) (wide * xzoom  + 0.5);
		newheight = (LONG) (height * yzoom  + 0.5);
		// 分配内存，以保存新DIB
		hDIB = new BYTE[ newwide * newheight*3 ];
		int k1 =yzoom+ 0.5;
		int k2 =xzoom+ 0.5;
		// 针对图像每行进行操作
		for(j = 0; j < height-1; j=j+k1)
		{
			// 针对图像每列进行操作
			for(i = 0; i < wide-1; i=i+k2)
			{
				// 指向新DIB第i行，第j个象素的指针
				// 注意此处宽度和高度是新DIB的宽度和高度
				lpDst = (LPBYTE)hDIB  + newwide * j + i;
				// 计算该象素在源DIB中的坐标
				j0 = (LONG) (j / yzoom  + 0.5);
				i0 = (LONG) (i / xzoom  + 0.5);
				// 判断是否在源图范围内
				if( (i0 >= 0) && (i0 < wide) && (j0 >= 0) && (j0 < height))
				{
					// 指向源DIB第i0行，第j0个象素的指针
					lpSrc = (LPBYTE)p_data + wide * j0 + i0;
					// 复制象素
					*lpDst = *lpSrc;
				}
				else
				{
					// 对于源图中没有的象素，直接赋值为255
					*lpDst = 255;
				}
			}
		}
		// 复制缩小后的图像
		for(j=0;j<height;j++)
		{	
			for(i=0;i<wide;i++)
			{
				if(j<=newheight&&i<=newwide)
				{ 
					lpDst = (LPBYTE)hDIB  + newwide * j + i;
					*p_data=*lpDst;		     
				}
				else *p_data=255;
				p_data++;
			}
		}	    
		delete hDIB; 
	}
	else	//24位彩色
	{
		// 获取图像的宽度
		wide = this->GetDibWidthBytes();
		LineBytes = (((wide * 8)+31)/32*4);
		// 获取图像的高度
		height = this->GetHeight();
		// 计算缩放后的图像实际宽度
		// 此处直接加0.5是由于强制类型转换时不四舍五入，而是直接截去小数部分
		newwide = (LONG) (LineBytes * xzoom  + 0.5);
		// 计算缩放后的图像高度
		newheight = (LONG) (height * yzoom  + 0.5);
		// 分配内存，以保存新DIB
		hDIB = new BYTE[ newwide * newheight*3 ];
		int k1 =(int)(yzoom+ 0.5);
		int k2 =(int)(xzoom+ 0.5);
		// 针对图像每行进行操作
		for(j = 0; j < height-1; j=j+k1)
		{
			// 针对图像每列进行操作
			for(i = 0; i < LineBytes-1; i=i+k2*3)
			{
				// 指向新DIB第i行，第j个象素的指针
				// 注意此处宽度和高度是新DIB的宽度和高度
				lpDst = (LPBYTE)hDIB  + newwide * j + i;			
				// 计算该象素在源DIB中的坐标
				j0 = (LONG) (j / yzoom  + 0.5);
				i0 = (LONG) (i / xzoom  + 0.5);
				// 判断是否在源图范围内
				if( (i0 >= 0) && (i0 < LineBytes) && (j0 >= 0) && (j0 < height))
				{				
					// 指向源DIB第i0行，第j0个象素的指针
					lpSrc = (LPBYTE)p_data + LineBytes * j0 + i0;
					// 复制象素
					*lpDst = *lpSrc;
					*(lpDst+1)=*(lpSrc+1);
					*(lpDst+2)=*(lpSrc+2);               
				}
				else
				{
					// 对于源图中没有的象素，直接赋值为255
					*lpDst = 255;
				}
			}
		}
		// 复制缩小后的图像
		for(j=0;j<height;j++)
		{	
			for(i=0;i<LineBytes;i++)
			{
				if(j<=newheight&&i<=newwide)
				{   
					lpDst = (LPBYTE)hDIB  + newwide * j + i;
					*p_data=*lpDst;
				
				}
				else *p_data=255;
				
				p_data++;
			}
		}
	}
}

/***************************************************************/           
/*函数名称：PingYi(int m_Xmove, int m_Ymove)                                       
/*函数类型：void
/*参数说明：m_Xmove 图像的水平平移量，m_Ymove 图像的垂直平移量                                    
/*功能：对图像进行平移显示。            
/***************************************************************/ 
void JiHeBianHuanDib::PingYi(int m_Xmove, int m_Ymove)
{
	// 指向源图像的指针
	LPBYTE	lpSrc;
    LPBYTE   p_data;
	// 指向要复制区域的指针
	LPBYTE	lpDst;
	// 指向复制图像的指针
	LPBYTE	temp;
	// 循环变量
	int	i,j;
	//图像的高和宽
	LONG wide,height;
	// 图像每行的字节数
	LONG lLineBytes;
	p_data=GetData();
	wide=GetWidth();
	height=GetHeight();
	if (m_pBitmapInfoHeader->biBitCount<9)		//灰度图像
	{	
		// 计算图像每行的字节数
		lLineBytes = (((wide * 8)+31)/32*4);	
		// 暂时分配内存，以保存新图像
		temp=new BYTE [lLineBytes*height];
		// 初始化新分配的内存，设定初始值为255
		lpDst = (LPBYTE)temp;
		memset(lpDst, (BYTE)255, lLineBytes * height);
		// 每行
		for( i = 0; i < wide; i++)
		{
			// 每列
			for( j = 0; j < height; j++)
			{
				// 计算该象素在源DIB中的坐标
				lpSrc = (LPBYTE)p_data + lLineBytes * (height - 1 - j) + i;
				int i0,j0;
				// 计算该象素在新DIB中的坐标
				i0 = i+m_Xmove;
				j0 = j + m_Ymove;
				// 判断是否在新图范围内
				if( (i0 >= 0) && (i0 < wide) && (j0 >= 0) && (j0 < height))
				{
					lpDst = (LPBYTE)temp + lLineBytes *(height - 1 - j0) + i0;
					// 复制象素
					*lpDst = *lpSrc;
				}
				else
				{
					// 对于源图中没有的象素，直接赋值为255
					* ((unsigned char*)lpDst) = 255;
				}
			}
		}
		// 复制平移后的图像
		memcpy(p_data, temp, lLineBytes * height);
		// 释放内存
		delete temp;
	}
    else 	//24位彩色
    { 	     
		wide=this->GetDibWidthBytes() ;   //取得原图的每行字节数
		BYTE *temp=new BYTE[height*wide];
		// 初始化新分配的内存，设定初始值为255
		lpDst = (LPBYTE)temp;
		memset(lpDst, (BYTE)255, wide * height);
		// 每列
		for(int j = 0; j < height; j++)
		{
			// 每行
			for( i = 0; i < wide; i++)
			{			
				// 计算该象素在源DIB中的坐标
				lpSrc = (LPBYTE)p_data + wide * (height - 1 - j) + i;
				int i0,j0;
				// 计算该象素在新DIB中的坐标
				i0 = i+m_Xmove*3;
				j0 = j + m_Ymove;
				
				// 判断是否在新图范围内
				if( (i0 >= 0) && (i0 < wide) && (j0 >= 0) && (j0 < height))
				{
					lpDst = (LPBYTE)temp + wide*(height - 1 - j0) + i0;
					// 复制象素
					*lpDst = *lpSrc;
				}
				else
				{
					// 对于源图中没有的象素，直接赋值为255
					* ((unsigned char*)lpDst) = 255;
				}			
			}
		}
		// 复制平移后的图像
		memcpy(p_data, temp, wide * height);
	}
}

///*********************************************************************************/           
/*函数名称：FangDa(LPBYTE temp,float xzoom ,float yzoom,LONG wide,LONG	height,LONG	newwide,LONG newheight)
/*函数类型：LPBYTE 
/*参数说明：temp  --新图像的首地址
/*          xzoom --水平放大的比率
/*          yzoom --垂直放大的比率  
/*          wide  --原图像的宽度
/*			height--原图像的高度
/*			newwide--新图像的宽度
/*			newheight--新图像的高度
/*函数类型：LPBYTE                         
/*功能：对图像进行放大处理。            
/************************************************************************************/
LPBYTE JiHeBianHuanDib::FangDa(LPBYTE temp, float xzoom, float yzoom,LONG wide,LONG	height,LONG	newwide,LONG newheight)
{
	// 指向源图像的指针
	LPBYTE	p_data ;
	LPBYTE  temp1;
	// 指向源象素的指针
	LPBYTE	lpSrc;
	// 指向缩放图像对应象素的指针
	LPBYTE	lpDst;
	int	i;
	int	j;
	// 象素在源DIB中的坐标
	int	i0;
	int	j0;
	p_data=this->GetData();
	// 获取图像的宽度
	int	k1=(int)yzoom ;
    int	k2= (int)xzoom ; 
	if(m_pBitmapInfoHeader->biBitCount<9)		//灰度图像
	{
		temp1 = new BYTE[newwide * newheight];
		memset(temp1,(BYTE)255,newwide * newheight);		
		// 针对图像每行进行操作
		for(j = 0; j < newheight; j++)
		{
			// 针对图像每列进行操作
			for(i = 0; i < newwide; i++)
			{
				lpDst = (LPBYTE)temp1+newwide*j+i;
				i0=(int)(i/xzoom+0.5);
				j0=(int)(j/yzoom+0.5);	
				if( (i0 >= 0) && (i0 < wide) && (j0 >= 0) && (j0 < height))
				{
					lpSrc=(LPBYTE)p_data + wide * j0 + i0;	
					*lpDst=*lpSrc;
				}
			}
		}   
		temp=temp1;
		return temp; 
	}
	else	//24位彩色		
	{
		// 分配内存，以保存新DIB
		temp1 = new BYTE[newwide * newheight*4];
		memset(temp1,255,newwide * newheight*4);
		int r,g,b;
		// 针对图像每行进行操作
		for(j = 0; j < height; j++)
		{
			// 针对图像每列进行操作
			for(i = 0; i < wide; i++)
			{
				lpSrc = (LPBYTE)p_data + wide * j*3 + i*3;
				r=*lpSrc++;
				g=*lpSrc++;
				b=*lpSrc;
				// 复制象素
				for(int n=0;n<k1;n++)
				for(int m=0;m<k2;m++)
				{
					// 指向源DIB第i0行，第j0个象素的指针	
					lpDst = (LPBYTE)temp1  + newwide *(j*k1+n) + (i+m)*k2*3;
					*lpDst++ = r;   
					*lpDst++ = g;      
					*lpDst = b;		
				}
			}
		}
		// 复制转置后的图像	
		temp=temp1;
		// 释放内存
		return temp;
	}
}