cdib.cpp

一般的论文 毕业用的 有很大的用处

	int n;
	p_data = m_pDibBits;
	// DIB的宽度
	LONG wide= m_Width;
	// DIB的高度
	LONG height =m_Height;
	if (m_pBIH->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 ++)
			{
				lpSrc = (unsigned char *)(p_data + wide * j + i);
				lpDst = (unsigned char *)(temp + wide * j + i);
				*lpDst = 255;
				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
	{
		// 暂时分配内存，以保存新图像
		temp = new BYTE[wide*height*3];
		// 初始化新分配的内存，设定初始值为255
		lpDst = (LPBYTE)temp;
		memset(lpDst, (BYTE)255, wide * height*3 );
		// 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*3 -1; i ++)
			{
				lpSrc = (unsigned char *)(p_data +  wide*3 * j + i);
				lpDst = (unsigned char *)(temp + wide*3 * j + i);
				*lpDst = 255;
				for (m = 0; m < 3; m++)
				{
					for (n = 0; n < 3; n++)
					{
						if (B[m + n] == 1)
							continue;
						if (*(lpSrc + (1 - m) *  wide*3 +(n - 1) ) < 128)
						{
							*lpDst = 0;						 
							break;
						}
					}
				}				
			}
		}
		memcpy(p_data, temp, wide * height*3 );
		// 释放内存
		delete temp;
	}

		return TRUE;
}
BOOL CDib::Xihua()
{
  	// 循环变量
	LONG i;
	LONG j;
	LONG m;
	LONG n;
	// 5×5相邻区域像素值
	unsigned char S[5][5];
	// 计数器
	unsigned char Num;
	// 循环跳出标志
	BOOL fp=TRUE;
	// 指向DIB象素指针
	LPBYTE  p_data;
	// 指向源图像的指针
	LPBYTE	lpSrc;
	// 指向缓存图像的指针
	LPBYTE	lpDst;
	// 指向缓存DIB图像的指针
	LPBYTE	temp;
	// 找到DIB图像象素起始位置
	p_data = m_pDibBits;
	// DIB的宽度
	LONG wide= m_Width;
	// DIB的高度
	LONG height =m_Height;
		// 暂时分配内存，以保存新图像
		temp = new BYTE [wide *height];
		// 初始化新分配的内存，设定初始值为255
		lpDst = temp;
		memset(lpDst, (BYTE)255, wide  * height);
		while (fp)
		{
			fp = FALSE;
			// 初始化新分配的内存，设定初始值为255
			lpDst = temp;
			memset(lpDst, (BYTE)255, wide  * height);
			// 由于使用5×5的结构元素，为防越界，不处理外围的2行、2列像素
			for (j = 2; j < height - 2; j++)
			{
				for (i = 2 ; i < wide  - 2 ; i ++)
				{
					// 指向源图像倒数第j行，第i个象素的指针			
					lpSrc = (LPBYTE)(p_data + wide  *j + i);
					// 指向目标图像倒数第j行，第i个象素的指针			
					lpDst = (LPBYTE)(temp + wide  * j + i);
					// 如果源图像中当前点为白色，则跳过
					if (*lpSrc > 127)
						continue;
					// 获得当前点相邻的5×5区域内像素值，白色用0代表，黑色用1代表
					for (m = 0; m < 5; m++)
					{
						for (n = 0; n < 5; n++)
						{
							if (*(lpSrc + (2- m) * wide  + (n - 2)*2 ) > 127)
								S[m][n] = 0;
							else
								S[m][n] = 1;
						}
					}
					// 判断条件一是否成立：
					Num =  S[1][1] + S[1][2] + S[1][3] + S[2][1] 
						+ S[2][3] + S[3][1]	+ S[3][2] + S[3][3];
					if (Num < 2 || Num >6)
					{
						*lpDst = 0;
						continue;
					}
					// 判断条件二是否成立：
					Num = 0;
					if (S[1][2] == 0 && S[1][1] == 1) 
						Num++;
					if (S[1][1] == 0 && S[2][1] == 1)
						Num++;
					if (S[2][1] == 0 && S[3][1] == 1)
						Num++;
					if (S[3][1] == 0 && S[3][2] == 1)
						Num++;
					if (S[3][2] == 0 && S[3][3] == 1)
						Num++;
					if (S[3][3] == 0 && S[2][3] == 1)
						Num++;
					if (S[2][3] == 0 && S[1][3] == 1)
						Num++;
					if (S[1][3] == 0 && S[1][2] == 1)
						Num++;
					if (Num != 1)
					{
						*lpDst = 0;
						continue;
					}
					// 判断条件三是否成立；
					if (S[1][2] * S[2][1] * S[2][3] != 0)
					{
						Num = 0;
						if (S[0][2] == 0 && S[0][1] == 1)
							Num++;
						if (S[0][1] == 0 && S[1][1] == 1)
							Num++;
						if (S[1][1] == 0 && S[2][1] == 1)
							Num++;
						if (S[2][1] == 0 && S[2][2] == 1)
							Num++;
						if (S[2][2] == 0 && S[2][3] == 1)
							Num++;
						if (S[2][3] == 0 && S[1][3] == 1)
							Num++;
						if (S[1][3] == 0 && S[0][3] == 1)
							Num++;
						if (S[0][3] == 0 && S[0][2] == 1)
							Num++;
						if (Num == 1)
						{
							*lpDst = 0;
							continue;
						}
					}
					// 判断条件四是否成立：
					if (S[1][2] * S[2][1] * S[3][2] != 0)
					{
						Num = 0;
						if (S[1][1] == 0 && S[1][0] == 1)
							Num++;
						if (S[1][0] == 0 && S[2][0] == 1)
							Num++;
						if (S[2][0] == 0 && S[3][0] == 1)
							Num++;
						if (S[3][0] == 0 && S[3][1] == 1)
							Num++;
						if (S[3][1] == 0 && S[3][2] == 1)
							Num++;
						if (S[3][2] == 0 && S[2][2] == 1)
							Num++;
						if (S[2][2] == 0 && S[1][2] == 1)
							Num++;
						if (S[1][2] == 0 && S[1][1] == 1)
							Num++;
						if (Num == 1)
						{
							*lpDst = 0;
							continue;
						}
					}
					// 如果条件均满足则删除该点
					*lpDst = 255;
					fp = TRUE;
				}
			}
			// 复制细化后的图像
			memcpy(p_data, temp, wide  * height);
		}
		 // 复制细化后的图像
		memcpy(p_data, temp, wide  * height);
		// 释放内存
		delete temp ;
		return TRUE;
	
}
BOOL CDib::Cuhua()
{
	// 循环变量
	LONG i;
	LONG j;
	// 指向DIB象素指针
	LPBYTE p_data;
	// 找到DIB图像象素起始位置
	p_data = m_pDibBits;
	// DIB的宽度
	LONG wide= m_Width;
	// DIB的高度
	LONG height =m_Height;
		// 对各像素进行灰度转换
		for (j = 0; j < height; j ++)
		{
			for (i = 0; i < wide; i ++)
			{
				// 对像素各颜色分量进行二值化求补处理
				unsigned char temp = *((unsigned char *)p_data + wide * j +i);
				if (temp > 127)
					*((unsigned char *)p_data + wide * j + i) = 0;
				else
					*((unsigned char *)p_data + wide * j + i) = 255;
			}
		}
		// 在求补后再对图象进行细化
		Xihua(); 
		return TRUE;
}

BOOL CDib::Segmentation(int Yuzhi)
{
    // 指向源图像的指针
	LPBYTE  p_data;
	LPBYTE	lpSrc;
	// 指向缓存图像的指针
	LPBYTE	lpDst;
	// 指向缓存DIB图像的指针
	LPBYTE	temp;
	//循环变量
	long i;
	long j;
	//图像的高和宽
	p_data = m_pDibBits;
	// DIB的宽度
	LONG wide= m_Width;
	// DIB的高度
	LONG height =m_Height;
	temp=new BYTE[wide*height];
	memset(temp,255,wide*height);
	for (j=0;j<height;j++)
	{
		for(i=0;i<wide;i++)
		{
			lpSrc=p_data+wide*j+i;
			
			lpDst=temp+wide*j+i;
			
			if((*lpSrc-Yuzhi)<30)
				*lpDst=*lpSrc;			
		}
	}
    memcpy(p_data,temp,wide*height);
	delete temp;
	return TRUE;
}

BOOL CDib::Boundary()
{
    LPBYTE  p_data ;     //原图数据区指针
	p_data = m_pDibBits;
	// DIB的宽度
	LONG wide= m_Width;
	// DIB的高度
	LONG height =m_Height;
	// 指向源图像的指针
	LPBYTE	lpSrc;
	// 指向缓存图像的指针
	LPBYTE	lpDst;	
	// 指向缓存DIB图像的指针
	LPBYTE	temp;
	//循环变量
	long i;
	long j;
	unsigned char n1,n2,n3,n4,n5,n6,n7,n8;
	//像素值
	unsigned char pixel;
	if (m_pBIH->biBitCount <9)
	{
	// 暂时分配内存，以保存新图像
	temp = new BYTE[wide * height];
	for (j=0;j<height;j++)
	{
		for(i=0;i<wide;i++)
		{
			lpSrc = (LPBYTE)p_data + wide * j + i;
			if(*lpSrc>127)
				*lpSrc=255;
			else
				*lpSrc=0;
		}
	}
	// 初始化新分配的内存，设定初始值为255
	memset(temp,  255, wide * height);
	for(j = 1; j <height-1; j++)
	{
		for(i = 1;i <wide-1; i++)
		{
			// 指向源图像倒数第j行，第i个象素的指针			
			lpSrc = (LPBYTE)p_data + wide * j + i;
			// 指向目标图像倒数第j行，第i个象素的指针			
			lpDst = (LPBYTE)temp + wide * j + i;
			//取得当前指针处的像素值，注意要转换为unsigned char型
			pixel = (unsigned char)*lpSrc;
			if(pixel == 0)
			{
				*lpDst = (unsigned char)0;
				n1 = (unsigned char)*(lpSrc + wide -1);
				n2  = (unsigned char)*(lpSrc + wide );
				n3 = (unsigned char)*(lpSrc + wide +1);
				n4 = (unsigned char)*(lpSrc -1);
				n5= (unsigned char)*(lpSrc +1);
				n6 = (unsigned char)*(lpSrc - wide -1);
				n7 = (unsigned char)*(lpSrc - wide );
				n8 = (unsigned char)*(lpSrc - wide +1);
				//如果相邻的八个点都是黑点
				if(n1+n2+n3+n4+n5+n6+n7+n8==0)
				{
					*lpDst = (unsigned char)255;
				}
			}
		}
	}
	// 复制腐蚀后的图像
	memcpy(p_data,temp, wide * height);
	// 释放内存
	delete temp;	 		
	}
	else
	{

	
	temp = new BYTE[3*wide * height];
	for (j=0;j<height;j++)
	{
		for(i=0;i<3*wide;i++)
		{
			lpSrc = (LPBYTE)p_data +3* wide * j + i;
			if(*lpSrc>127)
				*lpSrc=255;
			else
				*lpSrc=0;
		}
	}
	// 初始化新分配的内存，设定初始值为255
	memset(temp,  255, 3*wide * height);
	for(j = 1; j <height-1; j++)
	{
		for(i = 1;i <3*wide-1; i++)
		{
			// 指向源图像倒数第j行，第i个象素的指针			
			lpSrc = (LPBYTE)p_data +3* wide * j + i;
			// 指向目标图像倒数第j行，第i个象素的指针			
			lpDst = (LPBYTE)temp +3* wide * j + i;
			//取得当前指针处的像素值，注意要转换为unsigned char型
			pixel = (unsigned char)*lpSrc;
			if(pixel == 0)
			{
				*lpDst = (unsigned char)0;
				n1 = (unsigned char)*(lpSrc +3* wide -1);
				n2  = (unsigned char)*(lpSrc +3* wide );
				n3 = (unsigned char)*(lpSrc +3* wide +1);
				n4 = (unsigned char)*(lpSrc -1);
				n5= (unsigned char)*(lpSrc +1);
				n6 = (unsigned char)*(lpSrc - 3*wide -1);
				n7 = (unsigned char)*(lpSrc -3* wide );
				n8 = (unsigned char)*(lpSrc -3* wide +1);
				//如果相邻的八个点都是黑点
				if(n1+n2+n3+n4+n5+n6+n7+n8==0)
				{
					*lpDst = (unsigned char)255;
				}
			}
		}
	}
	// 复制腐蚀后的图像
	memcpy(p_data,temp, wide * height*3);
	// 释放内存
	delete temp;
	}
	return TRUE;
}

BOOL CDib::biaoji(int yuzhi_gray)
{
	    LPBYTE  p_data ;     //原图数据区指针
	p_data = m_pDibBits;
	// DIB的宽度
	LONG wide= m_Width;
	// DIB的高度
	LONG height =m_Height;


    if(m_pBIH->biBitCount <9)	//灰度图像
	{
		for(int j=0;j<height;j++)	// 每行
			for(int i=0;i<wide;i++)	// 每列
			{
				int temp=0;
				temp= *(p_data+(height-j-1)*wide+i);
				if(temp<yuzhi_gray)
					*(p_data+(height-j-1)*wide+i)=0;
				else
					*(p_data+(height-j-1)*wide+i)=255;
			}
	}
	else	//24位彩色
	{
		for(int j=0;j<height;j++)	// 每行
			for(int i=0;i<wide;i++)	// 每列
			{
				int temp=0;
				temp= *(p_data+(height-j-1)*wide*3+i*3);
				if(temp<yuzhi_gray)
				{
					*(p_data+(height-j-1)*wide*3+i*3)=0;
					*(p_data+(height-j-1)*wide*3+i*3+1)=0;
					*(p_data+(height-j-1)*wide*3+i*3+2)=0;
				}
				else
				{
					*(p_data+(height-j-1)*wide*3+i*3)=255;
					*(p_data+(height-j-1)*wide*3+i*3+1)=255;
					*(p_data+(height-j-1)*wide*3+i*3+2)=255;
				}
			}
	}
	return TRUE;

}

BOOL CDib::Multiple()
{
	LPBYTE p_data; 
	int wide,  height;
		  p_data = m_pDibBits;
	// DIB的宽度
    	 wide= m_Width;
	// DIB的高度
     	   height =m_Height;

		int i,j,a=80;  //循环变量		 
		LPBYTE  temp1=new BYTE[wide*height]; //新图像缓冲区
		LPBYTE  temp2=new BYTE[wide*height]; 
		memset( temp1,0,wide*height);
		memset( temp2,0,wide*height);
		for(j=0;j<height;j++)
		{
			for(i=0;i<wide;i++)
			{
					temp1[wide*j+i]=p_data[wide*j+i]; 
			}
		}

        biaoji(a);
        Erosion();
		Dilation();
		for(j=0;j<height;j++)
		{
			for(i=0;i<wide;i++)
			{
					temp2[wide*j+i]=p_data[wide*j+i]; 
			}
		}

		for(j=1;j<height-1;j++)
		{
			for(i=1;i<wide-1;i++)
			{   
				if( temp2[wide*j+i]==0)
					temp1[wide*j+i]=temp1[wide*j+i]*1;
				else 
					temp1[wide*j+i]=255;
			}
		}
		memcpy(p_data, temp1,wide*height);   //复制处理后的图像
		delete  temp1;
		delete  temp2;
		return TRUE;

}


BOOL CDib::Cell()
{
	int a=200,b=60,i,j;
	LPBYTE p_data=m_pDibBits;
    int	 wide= m_Width;
    int  height =m_Height;

	LPBYTE  temp1=new BYTE[3*wide*height]; //新图像缓冲区
	LPBYTE  temp2=new BYTE[3*wide*height]; 
	memset( temp1,0,wide*height*3);
	memset( temp2,0,wide*height*3);
	for(j=0;j<height;j++)
	{
		for(i=0;i<3*wide;i++)
		{
				temp1[3*wide*j+i]=p_data[3*wide*j+i]; 
		}
	}	
    biaoji(a);
	Erosion();
	Dilation();
	Boundary();
	biaoji(b);

	for(j=0;j<height;j++)
	{
		for(i=0;i<3*wide;i++)
		{
					temp2[3*wide*j+i]=p_data[3*wide*j+i]; 
		}
	}

	for(j=1;j<height-1;j++)
	{
		for(i=1;i<3*wide-1;i++)
		{   
			if( temp2[3*wide*j+i]==0)
					temp1[3*wide*j+i]=0;
			else 
					temp1[3*wide*j+i]=temp1[3*wide*j+i]*1;
		}
	}
	memcpy(p_data, temp1,wide*height*3);   //复制处理后的图像
	delete  temp1;
	delete  temp2;	
	// 	ADD(m_pDibBits,temp1,m_Width,m_Height);
//	memcpy(p_data, temp1,m_Width*m_Height);   //复制处理后的图像
	return true;
}


BOOL CDib::ADD(LPBYTE p_data, LPBYTE p_dataBK, int wide, int height)
{
    p_data = m_pDibBits;
    wide= m_Width;
    height =m_Height;
	LPBYTE lpSrc;  //原图像像素指针
    LPBYTE lpDst;   //目标像素指针
    LPBYTE lpSrcBK;  //背景像素指针	
	if (m_pBIH->biBitCount <9)//灰度图像
	{
		int i,j;  //循环变量
		LPBYTE  temp=new BYTE[wide*height];    //新图像缓冲区
		//初始化新分配的内存为255
		memset(temp,255,wide*height);			
		//进行每个像素的加运算
		for(j=1;j<height-1;j++)
		{
			for(i=1;i<wide-1;i++)
			{
				//获得原像素指针
				lpSrc=p_data+wide*j+i;
				//获得目标像素指针
				lpDst=temp+wide*j+i;
				//获得背景像素指针
				lpSrcBK=p_dataBK+wide*j+i;
				//进行加运算
				if((*lpSrc+*lpSrcBK)>255)
					*lpDst=255;
				else
					*lpDst=(*lpSrc+*lpSrcBK);
			}
		}
		memcpy(p_data, temp,wide*height);   //复制处理后的图像
		delete  temp;
	}
	else //24位真彩色
	{
		LONG DibWidth;    //原图长、宽
		DibWidth=wide*3;   //取得原图的每行字节数
		BYTE *p_temp=new BYTE[height*DibWidth];
		//进行每个像素的加运算
		for(int j=1;j<height-1;j++)
		{
			for(int i=3;i<DibWidth-3;i++)
			{
				//获得原像素指针
				lpSrc=p_data+DibWidth*j+i;
				//获得目标像素指针
				lpDst=p_temp+DibWidth*j+i;
				//获得背景像素指针
				lpSrcBK=p_dataBK+DibWidth*j+i;
				//进行加运算
				if((*lpSrc+*lpSrcBK)>255)
					*lpDst=255;
				else
					*lpDst=(*lpSrc+*lpSrcBK);
			}
		}
		memcpy(p_data, p_temp,DibWidth*height);   //复制处理后的图像
		delete  []p_temp;
	}	
	return true;
}