图像的骨架提取

 

细化方法当中，当属经典的Zhang并行快速细化算法，细化之后的轮廓走势与原图保持得相对较好。

参照 http://blog.csdn.net/byxdaz/article/details/5642669 ， 代码改造结果如下， 

//将 DEPTH_8U型二值图像进行细化  经典的Zhang并行快速细化算法
void thin(const Mat &src, Mat &dst, const int iterations)
{
    const int height =src.rows -1;
    const int width  =src.cols -1;

    //拷贝一个数组给另一个数组
    if(src.data != dst.data)
    {
        src.copyTo(dst);
    }
    

    int n = 0,i = 0,j = 0;
    Mat tmpImg;
    uchar *pU, *pC, *pD;
    BOOL isFinished =FALSE;

     for(n=0; n<iterations; n++)
     {
         dst.copyTo(tmpImg); 
         isFinished =FALSE;   //一次 先行后列扫描 开始
         //扫描过程一 开始
         for(i=1; i<height;  i++) 
        {
            pU = tmpImg.ptr<uchar>(i-1);
            pC = tmpImg.ptr<uchar>(i);
            pD = tmpImg.ptr<uchar>(i+1);
           for(int j=1; j<width; j++)
           {
            if(pC[j] > 0)
            {
                 int ap=0;
                 int p2 = (pU[j] >0);
                 int p3 = (pU[j+1] >0);
                 if (p2==0 && p3==1)
                 {
                  ap++;
                 }
                 int p4 = (pC[j+1] >0);
                 if(p3==0 && p4==1)
                 {
                  ap++;
                 }
                 int p5 = (pD[j+1] >0);
                 if(p4==0 && p5==1)
                 {
                  ap++;
                 }
                 int p6 = (pD[j] >0);
                 if(p5==0 && p6==1)
                 {
                  ap++;
                 }
                 int p7 = (pD[j-1] >0);
                 if(p6==0 && p7==1)
                 {
                  ap++;
                 }
                 int p8 = (pC[j-1] >0);
                 if(p7==0 && p8==1)
                 {
                  ap++;
                 }
                 int p9 = (pU[j-1] >0);
                 if(p8==0 && p9==1)
                 {
                  ap++;
                 }
                 if(p9==0 && p2==1)
                 {
                  ap++;
                 }
                 if((p2+p3+p4+p5+p6+p7+p8+p9)>1 && (p2+p3+p4+p5+p6+p7+p8+p9)<7)
                 {
                      if(ap==1)
                      {
                           if((p2*p4*p6==0)&&(p4*p6*p8==0))
                           {                           
                                dst.ptr<uchar>(i)[j]=0;
                                isFinished =TRUE;                            
                           }
                      
                        //   if((p2*p4*p8==0)&&(p2*p6*p8==0))
                       //    {                           
                       //         dst.ptr<uchar>(i)[j]=0;
                       //         isFinished =TRUE;                            
                       //    }
                       
                     }
                }                    
            }

           } //扫描过程一 结束

     
         dst.copyTo(tmpImg); 
         //扫描过程二 开始
         for(i=1; i<height;  i++)  //一次 先行后列扫描 开始
        {
            pU = tmpImg.ptr<uchar>(i-1);
            pC = tmpImg.ptr<uchar>(i);
            pD = tmpImg.ptr<uchar>(i+1);
           for(int j=1; j<width; j++)
           {
            if(pC[j] > 0)
            {
                 int ap=0;
                 int p2 = (pU[j] >0);
                 int p3 = (pU[j+1] >0);
                 if (p2==0 && p3==1)
                 {
                  ap++;
                 }
                 int p4 = (pC[j+1] >0);
                 if(p3==0 && p4==1)
                 {
                  ap++;
                 }
                 int p5 = (pD[j+1] >0);
                 if(p4==0 && p5==1)
                 {
                  ap++;
                 }
                 int p6 = (pD[j] >0);
                 if(p5==0 && p6==1)
                 {
                  ap++;
                 }
                 int p7 = (pD[j-1] >0);
                 if(p6==0 && p7==1)
                 {
                  ap++;
                 }
                 int p8 = (pC[j-1] >0);
                 if(p7==0 && p8==1)
                 {
                  ap++;
                 }
                 int p9 = (pU[j-1] >0);
                 if(p8==0 && p9==1)
                 {
                  ap++;
                 }
                 if(p9==0 && p2==1)
                 {
                  ap++;
                 }
                 if((p2+p3+p4+p5+p6+p7+p8+p9)>1 && (p2+p3+p4+p5+p6+p7+p8+p9)<7)
                 {
                      if(ap==1)
                      {
                        //   if((p2*p4*p6==0)&&(p4*p6*p8==0))
                        //   {                           
                       //         dst.ptr<uchar>(i)[j]=0;
                       //         isFinished =TRUE;                            
                       //    }
                      
                           if((p2*p4*p8==0)&&(p2*p6*p8==0))
                           {                           
                                dst.ptr<uchar>(i)[j]=0;
                                isFinished =TRUE;                            
                           }
                       
                     }
                }                    
            }

           }

          } //一次 先行后列扫描完成          
        //如果在扫描过程中没有删除点，则提前退出
         if(isFinished ==FALSE)
         {
            break; 
         }
        }

    }
}

 

另一种实现方法，细化结果不大好，但看起来好像是简洁些，适合一般的简单应用。

BOOL isContourPoint(const int x, const int y, const Mat& bwImg)
{
  BOOL p[10] ={0}; //记录当前点的8邻域的有无情况

  const BYTE *pU= bwImg.ptr(y-1, x);  //上一行
  const BYTE *pC= bwImg.ptr(y, x);    //当前行
  const BYTE *pD= bwImg.ptr(y+1, x);  //下一行


   p[2]=*(pU) ? true:false;
   p[3]=*(pU+1) ? true:false;
   p[4]=*(pC+1) ? true:false;
   p[5]=*(pD+1) ? true:false;
   p[6]=*(pD) ? true:false;
   p[7]=*(pD-1) ? true:false;
   p[8]=*(pC-1) ? true:false;
   p[9]=*(pU-1) ? true:false;


  int Np=0;//邻域不为零节点总数
  int Tp=0;//邻域节点由0变成1的次数
  for (int i=2; i<10; i++)
  {
  Np += p[i];
  int k= (i<9) ? (i+1) : 2;
  if ( p[k] -p[i]>0)
  {
  Tp++;
  }
  }
  int p246= p[2] && p[4] && p[6];
  int p468= p[4] && p[6] && p[8];

  int p24= p[2] && !p[3] && p[4] && !p[5] && !p[6] && !p[7] && !p[8] && !p[9];
  int p46= !p[2] && !p[3] && p[4] && !p[5] && p[6] && !p[7] && !p[8] && !p[9];
  int p68= !p[2] && !p[3] && !p[4] && !p[5] && p[6] && !p[7] && p[8] && !p[9];
  int p82= p[2] && !p[3] && !p[4] && !p[5] && !p[6] && !p[7] && p[8] && !p[9];

  int p782= p[2] && !p[3] && !p[4] && !p[5] && !p[6] && p[7] && p[8] && !p[9];
  int p924= p[2] && !p[3] && p[4] && !p[5] && !p[6] && !p[7] && !p[8] && p[9];
  int p346= !p[2] && p[3] && p[4] && !p[5] && p[6] && !p[7] && !p[8] && !p[9];
  int p568= !p[2] && !p[3] && !p[4] && p[5] && p[6] && !p[7] && p[8] && !p[9];

  int p689= !p[2] && !p[3] && !p[4] && !p[5] && p[6] && !p[7] && p[8] && p[9];
  int p823= p[2] && p[3] && !p[4] && !p[5] && !p[6] && !p[7] && p[8] && !p[9];
  int p245= p[2] && !p[3] && p[4] && p[5] && !p[6] && !p[7] && !p[8] && !p[9];
  int p467= !p[2] && !p[3] && p[4] && !p[5] && p[6] && p[7] && !p[8] && !p[9];

  int p2468= p24 || p46 || p68 || p82;
  int p3333= p782 || p924 || p346 || p568 || p689 || p823 || p245 || p467;

  //判定条件第一个由数字图像处理上得到，由于结果不够满意，又加上两个条件
  return ( !p246 && !p468 && (Np<7) && (Np>1) && (Tp==1) ) || p2468 || p3333; 
}


//细化二值图像，得到单像素连通域
void thin(Mat& bwImg)
{
  const int imgRows=bwImg.rows -1;
  const int imgCols=bwImg.cols -1;

  int Remove_Num;
  int i, j;
  do //循环调用，直至没有可以去掉的点
  {
    Remove_Num=0;
    for (j = 1; j < imgRows; j++)
    {
      for(i = 1; i < imgCols; i++)
      {

        if ( *bwImg.ptr(j, i) && isContourPoint( i, j, bwImg))//符合条件，去掉
        {
          *bwImg.ptr(j, i)=0;
          Remove_Num++;
        }  //if
      }  //for
    }  //for
  } while( Remove_Num);
}








====

 

// Algorithm.cpp : All the algorithms.
//

#include "stdafx.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

///
static int erasetable[256]={0,0,1,1,0,0,1,1, 1,1,0,1,1,1,0,1,
1,1,0,0,1,1,1,1, 0,0,0,0,0,0,0,1,
0,0,1,1,0,0,1,1, 1,1,0,1,1,1,0,1,
1,1,0,0,1,1,1,1, 0,0,0,0,0,0,0,1,
1,1,0,0,1,1,0,0, 0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,
1,1,0,0,1,1,0,0, 1,1,0,1,1,1,0,1,
0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,
0,0,1,1,0,0,1,1, 1,1,0,1,1,1,0,1,
1,1,0,0,1,1,1,1, 0,0,0,0,0,0,0,1,
0,0,1,1,0,0,1,1, 1,1,0,1,1,1,0,1,
1,1,0,0,1,1,1,1, 0,0,0,0,0,0,0,0,
1,1,0,0,1,1,0,0, 0,0,0,0,0,0,0,0,
1,1,0,0,1,1,1,1, 0,0,0,0,0,0,0,0,
1,1,0,0,1,1,0,0, 1,1,0,1,1,1,0,0,
1,1,0,0,1,1,1,0, 1,1,0,0,1,0,0,0};
//////////////////////////////////////////////////////////////////
BOOL Thinning(char *pBuffer)
{
BOOL Finished;
char *pPtr;
LONG x,y;
int num;
int nw,n,ne,w,e,sw,s,se;

// w/b bitmap saved with 256 colors !
int NumColors;
int LineBytes;
char *pImgData;

LPBITMAPFILEHEADER pBf;
LPBITMAPINFOHEADER pBi;
RGBQUAD *pRgb;
pBf=(LPBITMAPFILEHEADER) pBuffer;
pBi=(LPBITMAPINFOHEADER )(pBuffer +sizeof(BITMAPFILEHEADER));
pRgb=(RGBQUAD*)(pBuffer+sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER));
//
if(pBi->biClrUsed==0) NumColors=1<<pBi->biBitCount;
//
LineBytes=pBi->biWidth;
//
pImgData=pBuffer+sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+NumColors*sizeof(RGBQUAD);
//结束标志置成假
Finished=FALSE;
while(!Finished)
{ //还没有结束
//结束标志置成假
Finished=TRUE;
//先进行水平方向的细化
for (y=1;y<pBi->biHeight-1;y++)
{ //注意为防止越界，y的范围从1到高度-2
//pPtr指向原图数据
pPtr=pImgData+y*LineBytes;
x=1; //注意为防止越界，x的范围从1到宽度-2
while(x<pBi->biWidth-1)
{
if(*(pPtr+x)==0)
{ //是黑点才做处理
w=(unsigned char)*(pPtr+x-1); //左邻点
e=(unsigned char)*(pPtr+x+1); //右邻点
if( (w==255)|| (e==255))
{
//如果左右两个邻居中至少有一个是白点才处理
nw=(unsigned char)*(pPtr+x+LineBytes-1); //左上邻点
n=(unsigned char)*(pPtr+x+LineBytes); //上邻点
ne=(unsigned char)*(pPtr+x+LineBytes+1); //右上邻点
sw=(unsigned char)*(pPtr+x-LineBytes-1); //左下邻点
s=(unsigned char)*(pPtr+x-LineBytes); //下邻点
se=(unsigned char)*(pPtr+x-LineBytes+1); //右下邻点
//计算索引
num=nw/255+n/255*2+ne/255*4+w/255*8+e/255*16+sw/255*32+s/255*64+se/255*128;
if(erasetable[num]==1)
{ //经查表，可以删除
//在原图缓冲区中将该黑点删除
*(pPtr+x)=(BYTE)255;

Finished=FALSE; //有改动，结束标志置成假

x++; //水平方向跳过一个象素
}
}
}
x++; //扫描下一个象素
}
}
//再进行垂直方向的细化
for (x=1;x<pBi->biWidth-1;x++)
{ //注意为防止越界，x的范围从1到宽度-2
//pPtr指向原图数据
y=1; //注意为防止越界，y的范围从1到高度-2
while(y<pBi->biHeight-1)
{
pPtr=pImgData+y*LineBytes;
if(*(pPtr+x)==0)
{ //是黑点才做处理
n=(unsigned char)*(pPtr+x+LineBytes);
s=(unsigned char)*(pPtr+x-LineBytes);
if( (n==255)|| (s==255))
{//如果上下两个邻居中至少有一个是白点才处理
nw=(unsigned char)*(pPtr+x+LineBytes-1);
ne=(unsigned char)*(pPtr+x+LineBytes+1);
w=(unsigned char)*(pPtr+x-1);
e=(unsigned char)*(pPtr+x+1);
sw=(unsigned char)*(pPtr+x-LineBytes-1);
se=(unsigned char)*(pPtr+x-LineBytes+1);
//计算索引
num=nw/255+n/255*2+ne/255*4+w/255*8+e/255*16+sw/255*32+s/255*64+se/255*128;
if(erasetable[num]==1)
{ //经查表，可以删除
//在原图缓冲区中将该黑点删除
*(pPtr+x)=(BYTE)255;

Finished=FALSE; //有改动，结束标志置成假

y++;//垂直方向跳过一个象素
}
}
}
y++; //扫描下一个象素
}
}
}
return TRUE;
}
BOOL ManageBitmap(HWND hWnd)
{
FILE *fp;
FILE *new_fp;
LPBITMAPFILEHEADER pBf;
LPBITMAPINFOHEADER pBi;
char *pImgData=0;
int NumColors;
char filename[]="res\\bitmap1.bmp";// 229*79
//
fp=fopen("res\\bitmap1.bmp","rb");
if(fp== NULL)
{
MessageBox(hWnd,"Error open fiel!",filename,MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}
// get length
fseek(fp,0L,SEEK_END);
long filelen=ftell(fp);
fseek(fp,0L,SEEK_SET);
char *pBuffer=new char[filelen];
fread(pBuffer,sizeof(char),filelen,fp);
fclose(fp);
//
pBf=(LPBITMAPFILEHEADER) pBuffer;
pBi=(LPBITMAPINFOHEADER )(pBuffer +sizeof(BITMAPFILEHEADER));

if(pBi->biClrUsed==0) NumColors=1 << pBi->biBitCount;
//为了处理的方便，仍采用256级灰度图，不过只用调色板中0和255两项
if( NumColors!=256 )
{
MessageBox(hWnd,"Must be a mono bitmap with grayscale palette!",
"Error Message",MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}
//
if(!Thinning(pBuffer))
{
if(pBuffer) delete []pBuffer;
return FALSE;
}
// write new
new_fp=fopen("res\\thinning.bmp","wb");
fwrite(pBuffer,sizeof(char),filelen,new_fp);
fclose(new_fp);
//
if(pBuffer) delete []pBuffer;
return TRUE;
}