fushiyupengzhangdib.cpp

形态学腐蚀与膨胀

		// 释放内存
		delete []p_temp;
	}   
}



///***************************************************************/           
/*函数名称：Shuipingpengzhang()                                        
/*函数类型：void                                      
/*功能：对图像进行水平膨胀。            
/***************************************************************/
void FuShiYuPengZhangDib::Shuipingpengzhang()
{
	// 指向DIB象素指针
	LPBYTE p_data;
	// 指向源图像的指针
	LPBYTE	lpSrc;
	// 指向缓存图像的指针
	LPBYTE	lpDst;
	// 指向缓存DIB图像的指针
 	LPBYTE	temp;
	//循环变量
	int i;
	int j;
	int n;
 	// 找到DIB图像象素起始位置
	p_data= GetData();
	// DIB的宽度
	LONG wide = GetWidth();
	// DIB的高度
	LONG height = GetHeight();
	if (m_pBitmapInfoHeader->biBitCount<9)//灰度图像
	{    
		// 暂时分配内存，以保存新图像
		temp = new BYTE[wide*height];
		// 初始化新分配的内存，设定初始值为255
		lpDst = (LPBYTE)temp;
		memset(lpDst, (BYTE)255, wide * height);
		// 使用水平方向的结构元素进行膨胀
		for (j = 0; j < height; j++)
		{
			for (i = 1; i < wide - 1; i++)
			{
				// 由于使用1×3的结构元素，为防止越界，所以不处理最左边和最右边的两列像素
				// 指向源图像倒数第j行，第i个象素的指针			
				lpSrc = (unsigned char *)(p_data + wide * j + i);
				// 指向目标图像倒数第j行，第i个象素的指针			
				lpDst = (unsigned char *)(temp + wide * j + i);
				// 目标图像中的当前点先赋成白色
				*lpDst = 255;		 
				// 如果源图像中(-1,0)、(0,0)、(1,0)三个点之一有黑点，
				// 则将目标图像中的(0,0)点赋成黑色
				for (n = 0; n < 3; n++)
				{
					if (*(lpSrc + (n - 1) ) < 128)
					{
						*lpDst = 0;					 
						break;
					}
				}				
			}
		}
		// 复制膨胀后的图像
		memcpy(p_data, temp, wide * height); 
		// 释放内存
		delete temp;
	}
	else //24位真彩色
	{
		LONG DibWidth;    //原图长、宽	     
		DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
		BYTE *p_temp=new BYTE[height*DibWidth];
		// 使用水平方向的结构元素进行膨胀
		for (j = 0; j < height-1; j++)
		{
			for (i = 3; i < DibWidth ; i+=3)
			{
				// 由于使用1×3的结构元素，为防止越界，所以不处理最左边和最右边的两列像素
				// 指向源图像倒数第j行，第i个象素的指针			
				lpSrc = (unsigned char *)(p_data + DibWidth * j + i);
				// 指向目标图像倒数第j行，第i个象素的指针			
				lpDst = (unsigned char *)(p_temp + DibWidth * j + i);
				// 目标图像中的当前点先赋成白色
				*lpDst = *lpSrc;			 
				*(lpDst+1) = *(lpSrc+1);
				*(lpDst+2) = *(lpSrc+2);
				// 如果源图像中(-1,0)、(0,0)、(1,0)三个点之一有黑点，
				// 则将目标图像中的(0,0)点赋成黑色
				for(int m=0;m<3;m++)
				{
					for (n = 0; n < 3; n++)
					{
						if (*(lpSrc + (n - 1)*3 ) < 127)
						{
							*lpDst = 0;
							break;
						}				
					}
					*lpSrc++;
					*lpDst++;
				}
			}
		}
		// 复制膨胀后的图像
		memcpy(p_data, p_temp, DibWidth * height); 
		// 释放内存
		delete []p_temp;
	}  
}


///***************************************************************/           
/*函数名称：Chuizhipengzhang()                                        
/*函数类型：void                                      
/*功能：对图像进行垂直膨胀。            
/***************************************************************/
void FuShiYuPengZhangDib::Chuizhipengzhang()
{
	// 指向DIB象素指针
	LPBYTE p_data;
	// 指向源图像的指针
	LPBYTE	lpSrc;
	// 指向缓存图像的指针
	LPBYTE	lpDst;
	// 指向缓存DIB图像的指针
 	LPBYTE	temp;
	//循环变量
	int i;
	int j;
	int n;
	// 找到DIB图像象素起始位置
	p_data = GetData();
	// DIB的宽度
	LONG wide = GetWidth();
	// DIB的高度
	LONG height = GetHeight();
	if (m_pBitmapInfoHeader->biBitCount<9)//灰度图像
	{    
	    // 暂时分配内存，以保存新图像
		temp =new BYTE[wide*height];
		// 初始化新分配的内存，设定初始值为255
		lpDst = (LPBYTE)temp;
		memset(lpDst, (BYTE)255, wide * height);
		//使用垂直方向的结构元素进行膨胀
		for(j = 1; j < height - 1; j++)
		{
			for(i = 0; i < wide; i ++)
			{
				//由于使用3×1的结构元素，为防止越界，所以不处理最上边和最下边的两列像素
				// 指向源图像倒数第j行，第i个象素的指针			
				lpSrc = (unsigned char *)(p_data+ wide * j + i);
				// 指向目标图像倒数第j行，第i个象素的指针			
				lpDst = (unsigned char *)(temp + wide * j + i);
				//目标图像中的当前点先赋成白色		
				*lpDst = 255;			 
				// 如果源图像中(0,-1)、(0,0)、(0,1)三个点之一有黑点，
				// 则将目标图像中的(0,0)点赋成黑色
				for (n = 0; n < 3; n++)
				{
					if (*(lpSrc + (n - 1) * wide) < 128)
					{
						*lpDst = 0;
						break;
					}
				}				
			}
		}
		// 复制膨胀后的图像
		memcpy(p_data, temp, wide *height);
		// 释放内存
		delete temp;
	}
	else //24位真彩色
	{
		LONG DibWidth;    //原图长、宽	    
		DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
		BYTE *p_temp=new BYTE[height*DibWidth];
		//使用垂直方向的结构元素进行膨胀
		for(j = 1; j < height - 1; j++)
		{
			for(i = 0; i < DibWidth; i +=3)
			{
				//由于使用3×1的结构元素，为防止越界，所以不处理最上边和最下边的两列像素
				// 指向源图像倒数第j行，第i个象素的指针			
				lpSrc = (unsigned char *)(p_data+ DibWidth * j + i);
				// 指向目标图像倒数第j行，第i个象素的指针			
				lpDst = (unsigned char *)(p_temp + DibWidth * j + i);
				//目标图像中的当前点先赋成白色
				*lpDst = *lpSrc;			 
				*(lpDst+1) = *(lpSrc+1);
				*(lpDst+2) = *(lpSrc+2);
				// 如果源图像中(0,-1)、(0,0)、(0,1)三个点之一有黑点，
				// 则将目标图像中的(0,0)点赋成黑色
				for (int m=0;m<3;m++)
				{
					for (n = 0; n < 3; n++)
					{
						if (*(lpSrc + (n - 1) * DibWidth) < 127)
						{
							*lpDst = 0;                  
							break;
						}				
					}
					*lpSrc++;
					*lpDst++;
				}
			}
		}
		// 复制膨胀后的图像
		memcpy(p_data, p_temp, DibWidth *height);
		// 释放内存
		delete []p_temp;
	}	
}


///***************************************************************/           
/*函数名称：Quanfangxiangpengzhang()                                        
/*函数类型：void                                      
/*功能：对图像进行全方向膨胀。            
/***************************************************************/
void FuShiYuPengZhangDib::Quanfangxiangpengzhang()
{
	// 指向DIB象素指针
	LPBYTE p_data;
	// 指向源图像的指针
	LPBYTE	lpSrc;
	// 指向缓存图像的指针
	LPBYTE	lpDst;
	// 指向缓存DIB图像的指针
	LPBYTE	temp;
	//循环变量
	int i;
	int j;
	int m;
	int n;
	// 找到DIB图像象素起始位置
	p_data = GetData();
 	// DIB的宽度
	LONG wide =GetWidth();
	// DIB的高度
	LONG height = GetHeight();
	if (m_pBitmapInfoHeader->biBitCount<9)//灰度图像
	{    
		// 暂时分配内存，以保存新图像
		temp = new BYTE[wide*height];
		// 初始化新分配的内存，设定初始值为255
		lpDst = (LPBYTE)temp;
		memset(lpDst, (BYTE)255, wide * height);
		// 3×3的结构元素
		int B[9] = {1, 0, 1,
			        0, 0, 0,
			        1, 0, 1};
		// 使用全方向的结构元素进行腐蚀
		for (j = 1; j <  height - 1; j++)
		{
			for (i = 1; i < wide -1; i ++)
			{
				// 由于使用3×3的结构元素，为防止越界，所以不处理最左、右、上、下四边的像素
				// 指向源图像倒数第j行，第i个象素的指针			
				lpSrc = (unsigned char *)(p_data + wide * j + i);
				// 指向目标图像倒数第j行，第i个象素的指针			
				lpDst = (unsigned char *)(temp + wide * j + i);
				// 目标图像中的当前点先赋成白色
				*lpDst = 255;
				// 如果源图像中3×3结构元素对应位置有黑点	
				// 则将目标图像中的(0,0)点赋成黑色
				for (m = 0; m < 3; m++)
				{
					for (n = 0; n < 3; n++)
					{
						if (B[m + n] == 1)
							continue;
						if (*(lpSrc + (1 - m) * wide +(n - 1) ) < 128)
						{
							*lpDst = 0;						 
							break;
						}
					}
				}				
			}
		}
		// 复制腐蚀后的图像
		memcpy(p_data, temp, wide * height);
		// 释放内存
		delete temp;
	}
	else //24位真彩色
	{
		LONG DibWidth;    //原图长、宽	     
		DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
		BYTE *p_temp=new BYTE[height*DibWidth];
		// 3×3的结构元素
		int B[9] = {1, 0, 1,
					0, 0, 0,
					1, 0, 1};
		// 使用全方向的结构元素进行腐蚀
		for (j = 1; j <  height - 1; j++)
		{
			for (i = 3; i < DibWidth -3; i +=3)
			{
				// 由于使用3×3的结构元素，为防止越界，所以不处理最左、右、上、下四边的像素
				// 指向源图像倒数第j行，第i个象素的指针			
				lpSrc = (unsigned char *)(p_data + DibWidth * j + i);
				// 指向目标图像倒数第j行，第i个象素的指针			
				lpDst = (unsigned char *)(p_temp + DibWidth * j + i);
				// 目标图像中的当前点先赋成白色
				*lpDst = *lpSrc;			 
				*(lpDst+1) = *(lpSrc+1);
				*(lpDst+2) = *(lpSrc+2);
				// 如果源图像中3×3结构元素对应位置有黑点	
				// 则将目标图像中的(0,0)点赋成黑色
				for(int l=0;l<3;l++)
				{
					for (m = 0; m < 3; m++)
					{
						for (n = 0; n < 3; n++)
						{
							if (B[m + n] == 1)
								continue;
							if (*(lpSrc + (1 - m) * DibWidth +(n - 1)*3 ) < 128)
							{
								*lpDst = 0;	
								break;
							}
						}
					}
					*lpSrc++;
					*lpDst++;
				}
			}
		}
		// 复制腐蚀后的图像
		memcpy(p_data, p_temp, DibWidth * height);
		// 释放内存
		delete []p_temp;
	}  
}