mydiblib.h

本目录主要包括：文档和两个源代 其中源代码是识别程序的

	}

	// 将新的图像的内容拷贝到旧的图像中
	memcpy(lpDIBBits,lpNewDIBBits,lLineBytes*lHeight);

   // 解除锁定
	::GlobalUnlock ((HGLOBAL)hDIB);
}



/******************************************************************
*
*  函数名称：
*      StdDIBbyRect()
*
*  参数：
*     HDIB  hDIB          －图像的句柄
*     int   tarWidth      －标准化的宽度
*     int   tarHeight     －标准化的高度
*
*  返回值：
*         无
*
*  功能：
*     将经过分割的字符，进行缩放处理使他们的宽和高一直，以方便特征的提取
*
*  说明：
*     函数中用到了，每个字符的位置信息，所以必须在执行完分割操作之后才能执行标准化操作
*
******************************************************************/
void StdDIBbyRect(HDIB hDIB, int tarWidth, int tarHeight)
{	

	//指向图像的指针
	BYTE* lpDIB=(BYTE*)::GlobalLock ((HGLOBAL)hDIB);

	//指向象素起始位置的指针
	BYTE* lpDIBBits=(BYTE*)::FindDIBBits ((char*)lpDIB);
	
	//指向象素的指针
	BYTE* lpSrc;

	//获取图像的的宽度
	LONG lWidth=::DIBWidth ((char*)lpDIB);

	//获取图像的高度
	LONG lHeight=::DIBHeight ((char*)lpDIB);

	// 循环变量
	int	i;
	int	j;
	
	// 图像每行的字节数
	LONG	lLineBytes = WIDTHBYTES(lWidth * 8);

	//宽度、高度方向上的缩放因子
	double wscale,hscale;

	//开辟一块临时缓存区,来存放变化后的图像信息
	LPSTR lpNewDIBBits;
	LPSTR lpDst;
 
    //缓存区的大小和原图像的数据区大小一样
	HLOCAL nNewDIBBits=LocalAlloc(LHND,lLineBytes*lHeight);

	//指向缓存区开始位置的指针
	lpNewDIBBits=(char*)LocalLock(nNewDIBBits);

	//指向缓存内信息的指针
	lpDst=(char*)lpNewDIBBits;

	//将缓存区的内容赋初始值
	memset(lpDst,(BYTE)255,lLineBytes*lHeight);

	//进行映射操作的坐标变量
	int i_src,j_src;

	//存放字符位置信息的结构体
	CRect rect;
	CRect rectnew;

	//先清空一个新的矩形区域链表以便存储标准化后的矩形区域链表
	m_charRectCopy.clear ();

	//从头到尾逐个扫描各个结点
	while(!m_charRect.empty())
	{
		//从表头上得到一个矩形
		rect= m_charRect.front();

		//从链表头上面删掉一个
		m_charRect.pop_front();

		//计算缩放因子

		//横坐标方向的缩放因子
		wscale=(double)tarWidth/rect.Width ();

		//纵坐标方向的缩放因子
		hscale=(double)tarHeight/rect.Height ();

		//计算标准化矩形

		//上边界
		rectnew.top =rect.top ;

		//下边界
		rectnew.bottom =rect.top +tarHeight;

		//左边界
		rectnew.left =rect.left ;

		//右边界
		rectnew.right =rectnew.left +tarWidth;

		//将原矩形框内的象素映射到新的矩形框内
		for(i=rectnew.top ;i<rectnew.bottom ;i++)
		{
			for(j=rectnew.left ;j<rectnew.right ;j++)
			{   

				//计算映射坐标
				i_src=rectnew.top +int((i-rectnew.top )/hscale);
				j_src=rectnew.left +int((j-rectnew.left )/wscale);

				//将相对应的象素点进行映射操作
				lpSrc=(unsigned char *)lpDIBBits + lLineBytes *  i_src + j_src;
				lpDst = (char *)lpNewDIBBits + lLineBytes * i + j;
				*lpDst=*lpSrc;
			}
		}
		//将标准化后的矩形区域插入新的链表
		m_charRectCopy.push_back (rectnew);

	
	}

	//存储标准化后新的rect区域
    m_charRect=m_charRectCopy;

	//将缓存区的内容拷贝到图像的数据区内
	memcpy(lpDIBBits,lpNewDIBBits,lLineBytes*lHeight);

	//解除锁定
	::GlobalUnlock ((HGLOBAL)hDIB);
}


void Thinning(HDIB hDIB)
{
	// 指向DIB的指针
	LPSTR lpDIB=(LPSTR) ::GlobalLock((HGLOBAL)hDIB);
	
	// 指向DIB象素指针
	LPSTR    lpDIBBits;	

	// 找到DIB图像象素起始位置
	lpDIBBits = ::FindDIBBits(lpDIB);	
	
	// 指向源图像的指针
	LPSTR	lpSrc;

	//图像的高度和宽度
	LONG lWidth;
	LONG lHeight;

	//获取图像的宽度
	lWidth=::DIBWidth ((char*)lpDIB);

	//获取图像的高度
	lHeight=::DIBHeight ((char*)lpDIB);

    //计算每行的字节数
    LONG  lLineBytes = (lWidth+3)*4/4;

	//循环变量
    int i,j;

    //建立存储区存放2值矩阵
	BYTE *image = (BYTE*)malloc(lWidth*lHeight*sizeof(BYTE));

	//给2值矩阵赋值

	for(i=0;i<lHeight;i++)
	{
	    for(j=0;j<lWidth;j++)
		{
	      lpSrc=lpDIBBits+i*lLineBytes+j;
	    
	      if(*lpSrc==0)
	      image[i*lWidth+j]=1;

		  else
         image[i*lWidth+j]=0;
		}
	}

   //调用函数进行细化,两种函数可以选择

   ThinnerRosenfeld(image,lHeight,lWidth);

   //ThinnerHilditch(image,lHeight,lWidth);



   //将结果赋值到原图像中

   for(i=0;i<lHeight;i++)
   {
     for(j=0;j<lWidth;j++)
	 {
	   lpSrc=lpDIBBits+i*lLineBytes+j;

       if(image[i*lWidth+j]==1)
	   *lpSrc=(BYTE)0;

	   else
       *lpSrc=(BYTE)255;
	 }
   
   }


 //清空内存
   free(image);
   ::GlobalUnlock ((HGLOBAL)hDIB);

	return;
}

/*****************************************************
* 
*   函数名称：
*      Template：
*
*    参数：
*	   HDIB    hDIB         －图像的句柄
*      double  *tem         －指向模板的指针
*      int  tem_w           －模板的宽度
*      int  tem_h           －模板的高度
*      double xishu         －模板的系数
*         
*    功能：
*	   对图像进行模板操作
*
*    说明：
*	   为处理方便起见，模板的宽度和高度都应为奇数
*******************************************************/
 HDIB Template(HDIB hDIB,double * tem ,int tem_w,int tem_h,double xishu)
{

    //统计中间值
    double sum;

    //指向图像起始位置的指针
    BYTE *lpDIB=(BYTE*)::GlobalLock((HGLOBAL) hDIB);

	//指向象素起始位置的指针
	BYTE *pScrBuff =(BYTE*)::FindDIBBits((char*)lpDIB);
   
	//获取图像的颜色信息
    int numColors=(int) ::DIBNumColors((char *)lpDIB);

    //如果图像不是256色返回
     if (numColors!=256) 
	 {   
        //解除锁定
	  	::GlobalUnlock((HGLOBAL) hDIB);

		//返回
		return(hDIB);
	 }
    
    //将指向图像象素起始位置的指针，赋值给指针变量
    BYTE* oldbuf = pScrBuff;

    //循环变量
    int i,j,m,n;

	int w, h, dw;

	//获取图像的宽度
	w = (int) ::DIBWidth((char *)lpDIB);
	
	//获取图像的高度
	h = (int) ::DIBHeight((char *)lpDIB);
	
	//计算图像每行的字节数
	dw = (w+3)/4*4;      
	
	//建立一个和原图像大小相同的25色灰度位图
    HDIB newhDIB=NewDIB(w,h,8);  
    
	//指向新的位图的指针
	BYTE *newlpDIB=(BYTE*)::GlobalLock((HGLOBAL) newhDIB);

	//指向新的位图的象素起始位置的指针 
    BYTE *destBuf = (BYTE*)FindDIBBits((char *)newlpDIB);
    
   //将指向新图像象素起始位置的指针，赋值给指针变量
    BYTE *newbuf=destBuf; 
	
	//对图像进行扫描
   
	//行 
    for(i=0;i<h;i++)
    {  
		//列
	   for(j=0;j<w;j++)
	   {   

		   //为统计变量赋初始值
	       sum=0;

         //对于图像的4个边框的象素保持原灰度不变
	     if( j<((tem_w-1)/2) || j>(w-(tem_w+1)/2) || i<((tem_h-1)/2) || i>(h-(tem_h+1)/2) )
	      *(newbuf+i*dw+j)=*(oldbuf+i*dw+j);
		 
         //对于其他的象素进行模板操作
		 else 
         { 

          //将点（i,j）点作为模板的中心
          for(m=i-((tem_h-1)/2);m<=i+((tem_h-1)/2);m++)
          {
		     for(n=j-((tem_w-1)/2);n<=j+((tem_w-1)/2);n++)
		    
             //将以点（i，j）为中心，与模板大小相同的范围内的象素与模板对用位置的系数
			 //进行相乘并线形叠加
		     sum+=*(oldbuf+m*dw+n)* tem[(m-i+((tem_h-1)/2))*tem_w+n-j+((tem_w-1)/2)];
		  
		  }
          
		  //将结果乘上总的模板系数
          sum=(int)sum*xishu;

		  //计算绝对值
		  sum = fabs(sum);

		  //如果小于0，强制赋值为0
          if(sum<0)     
          sum=0;

		  //如果大于255，强制赋值为255
          if(sum>255)
		  sum=255;

		  //将计算的结果放到新的位图的相应位置
	      *(newbuf+i*dw+j)=sum;
		 }
	   }
	} 
   
	//解除锁定
	::GlobalUnlock((HGLOBAL)hDIB);
    
	//返回新的位图的句柄
    return(newhDIB);
}
/*****************************************************
* 
*   函数名称：
*      Template：
*
*    参数：
*	   HDIB    hDIB         －图像的句柄
*      int  tem_w           －模板的宽度
*      int  tem_h           －模板的高度
*      
*    功能：
*	   对图像进行中值
*
*    说明：
*	   为处理方便起见，模板的宽度和高度都应为奇数
*******************************************************/

HDIB MidFilter(HDIB hDIB,int tem_w,int tem_h)
{

    //统计中间值
    double mid;

	BYTE *temp=(BYTE*)malloc(tem_w*tem_h*sizeof(BYTE));

    //指向图像起始位置的指针
    BYTE *lpDIB=(BYTE*)::GlobalLock((HGLOBAL) hDIB);

	//指向象素起始位置的指针
	BYTE *pScrBuff =(BYTE*)::FindDIBBits((char*)lpDIB);
   
	//获取图像的颜色信息
    int numColors=(int) ::DIBNumColors((char *)lpDIB);

    //如果图像不是256色返回
     if (numColors!=256) 
	 {   
        //解除锁定
	  	::GlobalUnlock((HGLOBAL) hDIB);

		//返回
		return(hDIB);
	 }
    
    //将指向图像象素起始位置的指针，赋值给指针变量
    BYTE* oldbuf = pScrBuff;

    //循环变量
    int i,j,m,n;

	int w, h, dw;

	//获取图像的宽度
	w = (int) ::DIBWidth((char *)lpDIB);
	
	//获取图像的高度
	h = (int) ::DIBHeight((char *)lpDIB);
	
	//计算图像每行的字节数
	dw = (w+3)/4*4;      
	
	//建立一个和原图像大小相同的25色灰度位图
    HDIB newhDIB=NewDIB(w,h,8);  
    
	//指向新的位图的指针
	BYTE *newlpDIB=(BYTE*)::GlobalLock((HGLOBAL) newhDIB);

	//指向新的位图的象素起始位置的指针 
    BYTE *destBuf = (BYTE*)FindDIBBits((char *)newlpDIB);
    
   //将指向新图像象素起始位置的指针，赋值给指针变量
    BYTE *newbuf=destBuf; 
	
	//对图像进行扫描
   
	//行 
    for(i=0;i<h;i++)
    {  
		//列
	   for(j=0;j<w;j++)
	   {   

		   //为统计变量赋初始值
	       

         //对于图像的4个边框的象素保持原灰度不变
	     if( j<((tem_w-1)/2) || j>(w-(tem_w+1)/2) || i<((tem_h-1)/2) || i>(h-(tem_h+1)/2) )
	      *(newbuf+i*dw+j)=*(oldbuf+i*dw+j);
		 
         //对于其他的象素进行模板操作
		 else 
         { 

          //将点（i,j）点作为模板的中心
          for(m=i-((tem_h-1)/2);m<=i+((tem_h-1)/2);m++)
          {
		     for(n=j-((tem_w-1)/2);n<=j+((tem_w-1)/2);n++)
		    
             //将以点（i，j）为中心，与模板大小相同的范围内的象素传递到模板矩阵中
		     temp[(m-i+((tem_h-1)/2))*tem_w+n-j+((tem_w-1)/2)]=*(oldbuf+m*dw+n);
		  
		  }
          
		 //利用气泡法计算中值
           for(m=0;m<tem_w*tem_h-1;m++)
           {
		   
		      for(n=0;n<tem_w*tem_h-m-1;n++)
			  {
			    if(temp[n]>temp[n+1]) 
			    mid=temp[n];
                temp[n]=temp[n+1];
			    temp[n+1]=mid;
			  }
		   
		   } 

           //将计算的结果放到新的位图的相应位置
	      *(newbuf+i*dw+j)=temp[(tem_w*tem_h-1)/2];
		 }
	   }
	} 
   
	//解除锁定
	::GlobalUnlock((HGLOBAL)hDIB);
    
	//返回新的位图的句柄
    return(newhDIB);
}



/*************************************************************************
 *
 * 函数名称：
 *   Equalize()
 *
 * 参数:
 *   HDIB hDIB
 *
 *
 * 说明:
 *   该函数用来对图像进行直方图均衡。
 *
 ************************************************************************/
void Equalize(HDIB hDIB)
{
	BYTE* lpDIB=(BYTE*)::GlobalLock ((HGLOBAL)hDIB);
	BYTE* lpDIBBits=(BYTE*)::FindDIBBits((char*)lpDIB);
	LONG lHeight=::DIBHeight ((char*)lpDIB);
	LONG lWidth=::DIBWidth ((char*)lpDIB);
	// 指向源图像的指针
	unsigned char*	lpSrc;
	
	// 临时变量
	LONG	lTemp;
	
	// 循环变量
	LONG	i;
	LONG	j;
	
	// 灰度映射表
	BYTE	bMap[256];
	
	// 灰度映射表
	LONG	lCount[256];
	
	// 图像每行的字节数
	LONG	lLineBytes;
	
	// 计算图像每行的字节数
	lLineBytes = WIDTHBYTES(lWidth * 8);
	
	// 重置计数为0
	for (i = 0; i < 256; i ++)
	{
		// 清零
		lCount[i] = 0;
	}
	
	// 计算各个灰度值的计数
	for (i = 0; i < lHeight; i ++)
	{
		for (j = 0; j < lWidth; j ++)
		{
			lpSrc = (unsigned char *)lpDIBBits + lLineBytes * i + j;
			
			// 计数加1
			lCount[*(lpSrc)]++;
		}
	}
	
	// 计算灰度映射表
	for (i = 0; i < 256; i++)
	{
		// 初始为0
		lTemp = 0;
		
		for (j = 0; j <= i ; j++)
		{
			lTemp += lCount[j];
		}
		
		// 计算对应的新灰度值
		bMap[i] = (BYTE) (lTemp * 255 / lHeight / lWidth);
	}
	
	// 每行
	for(i = 0; i < lHeight; i++)
	{
		// 每列
		for(j = 0; j < lWidth; j++)
		{
			// 指向DIB第i行，第j个象素的指针
			lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + j;
			
			// 计算新的灰度值
			*lpSrc = bMap[*lpSrc];
		}
	}
	
	::GlobalUnlock ((HGLOBAL)hDIB);
}