二值化.txt

迭代法的二值化

我记得我那时主要处理灰度图，灰度图像素是从0~255的，假设120是分解，你可以将灰度值小于120的像素的灰度值置为0，将灰度值大于120的像素的灰度值置为1，这样整个图像就成了黑白两色了。 

二值化的难点不是编程，而是找阈值，120就是阈值 

另外，“用C语言实现对图像的二值化”是我觉得有些奇怪，C语言只是语法，它不是编程工具，你必须用vc或者bcb等工具编程才行 
你的邮箱我发给你一些相关的阈值分割的论文。还有几个全局阈值选取得源代码，一个是迭代法，一个是大津法。局部阈值的比较复杂，我也在这方面找呢。   
  /***************************************************************************   
    *   函数名称   
    *   OSTUThreshold()   
    *   参数   
    *         LPSTR   lpDIBBits           -   指向源DIB图像指针   
    *         LONG     lWidth                 -   源图像宽度(像素数)   
    *         LONG     lHeight               -   源图像高度(像素数)   
    *   返回值   
    *         BOOL                                 -   运算成功   返回TRUE   ,   否则   返回FALSE。   
    *   说明   
    *         该函数采用大津法进行阈值分割   二值化   
    ***************************************************************************/   
  BOOL   WINAPI   OSTUThreshold(LPSTR   lpDIBBits,   LONG   lWidth,   LONG   lHeight)   
  {   
  //   指向源图像像素指针   
  LPSTR   lpSrc;   
    
  //   指向缓存图像指针   
  LPSTR   lpDst;   
    
  //   指向缓存图像像素指针   
  LPSTR   lpNewDIBBits;   
  HLOCAL   hNewDIBBits;   
    
  //   循环变量   
  int   i,   j,   t;   
    
  //   用于计算两个区域的中间变量   
  long   lP1,   lS1,   lP2,   lS2;   
    
  //   像素值   
  unsigned   char   pixel;   
    
  //   灰度直方图数组   
  long   lHistogram[256];   
    
  //   阈值,   最大灰度值和最小灰度值,   两个区域的平均灰度值   
  unsigned   char   iThreshold,   iNewThreshold,   iMaxGrayValue,   iMinGrayValue,   iMean1GrayValue,   iMean2GrayValue;   
    
  //     前景点数占图像比例,   背景点数占图像比例   
  double   w0,w1;   
    
  //   方差   
  double   G,   tempG;   
    
  //   图像每行占字节数   
  LONG   lLineBytes;   
    
  //   暂时分配内存,   以保存新图像   
  hNewDIBBits   =   LocalAlloc(LHND,   lWidth   *   lHeight);   
    
  if   (hNewDIBBits   ==   NULL)     
  {   
  //分配内存失败   
  return   FALSE;   
  }   
    
  //   锁定内存   
  lpNewDIBBits   =   (char   *)   LocalLock(hNewDIBBits);   
    
  //   初始化新分配的内存,   设定初始值为255   
  lpDst   =   (char   *)   lpNewDIBBits;   
  memset(lpDst,   (BYTE)255,   lWidth   *   lHeight);   
    
  lLineBytes   =   WIDTHBYTES(lWidth   *   8);   
    
  for(i=   0;   i   <   256;   i++)   
  {   
  lHistogram[i]   =   0;   
  }   
    
  //   获得灰度直方图，灰度最大值和灰度最小值   
  iMaxGrayValue   =   0;   
  iMinGrayValue   =   255;   
  for(i   =   0;   i   <   lWidth;   i++)   
  {   
  for(j   =   0;   j   <   lHeight;   j++)   
  {   
  lpSrc   =   (char   *)   lpDIBBits   +   lLineBytes   *   j   +   i;   
  pixel   =   (unsigned   char)   *lpSrc;   
  lHistogram[pixel]++;   
    
  //   修改最大灰度值和最小灰度值   
  if   (iMinGrayValue   >   pixel)   
  {   
  iMinGrayValue   =   pixel;   
  }   
  if   (iMaxGrayValue   <   pixel)   
  {   
  iMaxGrayValue   =   pixel;   
  }   
  }   
  }   
    
  //   遍历t,   选取最佳阈值   
  for(t   =   iMinGrayValue;   t   <   iMaxGrayValue   ;   t++)   
  {   
  iNewThreshold   =   t;   
  lP1   =   0;   
  lS1   =   0;   
  lP2   =   0;   
  lS2   =   0;   
    
  //     求前景,背景两个区域的平均灰度值,   点数所占比例   
  for(i   =   iMinGrayValue;   i   <=   iNewThreshold;   i++)   
  {   
  lP1   +=   lHistogram[i]   *   i;   
  lS1   +=   lHistogram[i];   
  }   
  iMean1GrayValue   =   (unsigned   char)   (lP1/lS1);   
  w0   =   (double)   (lS1)   /   (lWidth   *   lHeight);   
  for(i   =   iNewThreshold   +   1;   i   <=   iMaxGrayValue;   i++)   
  {   
  lP2   +=   lHistogram[i]   *   i;   
  lS2   +=   lHistogram[i];   
  }   
  iMean2GrayValue   =   (unsigned   char)   (lP2/lS2);   
                  w1   =   1   -   w0;   
    
  //   计算类间方差   
  G   =   (double)   w0   *   w1     
      *   (iMean1GrayValue   -   iMean2GrayValue)   *   (iMean1GrayValue   -   iMean2GrayValue);   
  if   (G   >   tempG)     
  {   
  tempG   =   G;   
  iThreshold   =   iNewThreshold;   
  }   
  }   
    
  //   根据阈值将图像二值化   
          for(i   =   0;   i   <   lWidth;   i++)   
  {   
  for(j   =   0;   j   <   lHeight;   j++)   
  {   
  lpSrc   =   (char   *)   lpDIBBits   +   lLineBytes   *   j   +   i;   
  lpDst   =   (char   *)   lpNewDIBBits   +   lLineBytes   *   j   +   i;   
  pixel   =   (unsigned   char)   *lpSrc;   
  if   (pixel   <=   iThreshold)     
  {   
  *lpDst   =   (unsigned   char)0;   
  }   
  else   
  {   
  *lpDst   =   (unsigned   char)   255;   
  }   
  }   
  }   avaScript：window。top。space-addItem（14，5077，0，0，1，1，0）；
    
          //   复制图像   
  memcpy(lpDIBBits,   lpNewDIBBits,   lWidth   *   lHeight);   
    
  //   释放内存   
  LocalUnlock(hNewDIBBits);   
  LocalFree(hNewDIBBits);   
    
  //   返回   
  return   TRUE;   
  }


//   迭代法   
  BOOL   WINAPI   MeanThreshold(LPSTR   lpDIBBits,   LONG   lWidth,   LONG   lHeight)   
  {   
          //   指向源图像的指针   
  LPSTR   lpSrc;   
    
  //   指向缓存图像的指针   
  LPSTR   lpDst;   
    
  //   指向缓存DIB图像的指针   
  LPSTR       lpNewDIBBits;   
  HLOCAL     hNewDIBBits;   
    
  //   循环变量   
  long   i;   
  long   j;   
    
  //   像素值   
  unsigned   char   pixel;   
    
  //   灰度直方图数组   
  long   lHistogram[256];   
    
  //   阈值,   最大灰度值与最小灰度值,   两个区域的平均灰度值   
  unsigned   char   iThreshold,   iNewThreshold,   iMaxGrayValue,   iMinGrayValue,   iMean1GrayValue,   iMean2GrayValue;   
    
  //   用于计算   （最小灰度-阈值），（阈值-最大灰度）   两个区域的中间变量   
  long   lP1,   lP2,   lS1,   lS2;   
    
  //   迭代次数   
  int   iIterationTimes;   
    
  //   图像每行的字节数   
  LONG   lLineBytes;   
    
  //   暂时分配内存,   以保存新图像   
  hNewDIBBits   =   LocalAlloc(LHND,   lWidth   *   lHeight);   
    
  if   (hNewDIBBits   ==   NULL)     
  {   
  //   分配内存失败   
  return   FALSE;   
  }   
    
  //   锁定内存   
  lpNewDIBBits   =   (char   *)   LocalLock(hNewDIBBits);   
    
  //   初始化新分配的内存,   设定初始值为255   
  lpDst   =   (char   *)   lpNewDIBBits;   
  memset(lpDst,   (BYTE)255,   lWidth   *   lHeight);   
    
  //   计算每行的字节数   
  lLineBytes   =   WIDTHBYTES(lWidth   *   8);   
    
  for(i=   0;   i   <   256;   i++)   
  {   
  lHistogram[i]   =   0;   
  }   
    
  //   获得灰度直方图   灰度最大值和最小值   
  iMaxGrayValue   =   0;   
  iMinGrayValue   =   255;   
  for(i=   0;   i   <   lWidth;   i++)   
  {   
  for(j=   0;   j   <   lHeight;   j++)   
  {   
  //   指向源图像倒数第j行，第i个象素的指针   
  lpSrc   =   (char   *)lpDIBBits   +   lLineBytes   *   j   +   i;   
    
  pixel   =   (unsigned   char)   *lpSrc;   
    
  lHistogram[pixel]++;   
  //修改最大，最小灰度值   
  if(iMinGrayValue   >   pixel)   
  {   
  iMinGrayValue   =   pixel;   
  }   
  if(iMaxGrayValue   <   pixel)   
  {   
  iMaxGrayValue   =   pixel;   
  }   
  }   
  }   
    
  //   迭代求最佳阈值   
  iNewThreshold   =   (iMinGrayValue   +   iMaxGrayValue)/2;   
  iThreshold   =   0;   
    
  for(iIterationTimes   =   0;   iIterationTimes   <   100   &&   iThreshold   !=   iNewThreshold;   iIterationTimes++)   
  {   
  iThreshold   =   iNewThreshold;   
  lP1   =   0;   
  lS1   =   0;   
  lP2   =   0;   
  lS2   =   0;   
    
  //   求以iNewThresHold分割的两个区域的灰度平均值   
  for(i   =   iMinGrayValue;   i   <   iThreshold;   i++)   
  {   
  lP1   +=   lHistogram[i]   *   i;   
  lS1   +=   lHistogram[i];   
  }   
  iMean1GrayValue   =   (unsigned   char)   (lP1/lS1);   
  for(i   =   iThreshold   +   1;   i   <   iMaxGrayValue;   i++)   
  {   
  lP2   +=   lHistogram[i]   *   i;   
  lS2   +=   lHistogram[i];   
  }   
  iMean2GrayValue   =   (unsigned   char)   (lP2/lS2);   
  iNewThreshold   =   (iMean1GrayValue   +   iMean2GrayValue)/2;   
  }   
    
  //   根据阈值将图像二值化   
          for(i   =   0;   i   <   lWidth;   i++)   
  {   
  for(j   =   0;   j   <   lHeight;   j++)   
  {   
  lpSrc   =   (char   *)   lpDIBBits   +   lLineBytes   *   j   +   i;   
  lpDst   =   (char   *)   lpNewDIBBits   +   lLineBytes   *   j   +   i;   
  pixel   =   (unsigned   char)   *lpSrc;   
  if   (pixel   <=   iThreshold)     
  {   
  *lpDst   =   (unsigned   char)0;   
  }   
  else   
  {   
  *lpDst   =   (unsigned   char)255;   
  }   
  }   
  }   
    
  //   复制图像   
  memcpy(lpDIBBits,   lpNewDIBBits,   lWidth   *   lHeight);   
    
  //   释放内存   
  LocalUnlock(hNewDIBBits);   
  LocalFree(hNewDIBBits);   
    
  //   返回   
  return   TRUE;   
  }