数学形态学——腐蚀、膨胀、开、闭、细化

迷南。 2022-06-13 05:59 362阅读 0赞

http://www.cnblogs.com/lxt287994374/p/3269261.html

数学形态学(Mathematical Morphology)：属于一门新兴的学科。说起来很有意思，它是法国和德国的科学家在研究岩石结构时建立的一门学科。形态学的用途主要是获取物体拓扑和结构信息，它通过物体和结构元素相互作用的某些运算，得到物体更本质的形态。在图象处理中的应用主要是：(1)利用形态学的基本运算，对图象进行观察和处理，从而达到改善图象质量的目的；(2)描述和定义图象的各种几何参数和特征，如面积、周长、连通度、颗粒度、骨架和方向性等。

限于篇幅，我们只介绍二值图象的形态学运算，对于灰度图象的形态学运算，有兴趣的读者可以阅读有关的参考书。在程序中，为了处理的方便，还是采用256级灰度图，不过只用到了调色板中的0和255两项。

先来定义一些基本符号和关系。

1. 元素

设有一幅图象X，若点a在X的区域以内，则称a为X的元素，记作a∈X，如图6.1所示。

2. B包含于X

设有两幅图象B，X。对于B中所有的元素ai，都有ai∈X，则称B包含于(included in)X，记作B ![image002.gif][] X，如图6.2所示。

3. B击中X

设有两幅图象B，X。若存在这样一个点，它即是B的元素，又是X的元素，则称B击中(hit)X，记作B↑X，如图6.3所示。

4. B不击中X

设有两幅图象B，X。若不存在任何一个点，它即是B的元素，又是X的元素，即B和X的交集是空，则称B不击中(miss)X，记作B∩X=Ф；其中∩是集合运算相交的符号，Ф表示空集。如图6.4所示。

![0_1304412985593w.gif][]

5.         补集

设有一幅图象X，所有X区域以外的点构成的集合称为X的补集，记作Xc，如图6.5所示。显然，如果B∩X=Ф，则B在X的补集内，即B ![image011.gif][] Xc。

![0_130441307955O5.gif][]

6. 结构元素

设有两幅图象B，X。若X是被处理的对象，而B是用来处理X的，则称B为结构元素(structure element)，又被形象地称做刷子。结构元素通常都是一些比较小的图象。

7. 对称集

设有一幅图象B，将B中所有元素的坐标取反，即令(x，y)变成(-x，\-y)，所有这些点构成的新的集合称为B的对称集，记作Bv，如图6.6所示。

8. 平移

设有一幅图象B，有一个点a(x0,y0)，将B平移a后的结果是，把B中所有元素的横坐标加x0，纵坐标加y0，即令(x，y)变成(x+x0，y+y0)，所有这些点构成的新的集合称为B的平移，记作Ba，如图6.7所示。

![0_1304413147EH82.gif][]

好了，介绍了这么多基本符号和关系，现在让我们应用这些符号和关系，看一下形态学的基本运算。

## 6.1 腐蚀 ##

把结构元素B平移a后得到Ba，若Ba包含于X，我们记下这个a点，所有满足上述条件的a点组成的集合称做X被B腐蚀(Erosion)的结果。用公式表示为：E(X)=\{a| Ba  X\}=X - B，如图6.8所示。

![0_1304413191cHv5.gif][]

图6.8中X是被处理的对象，B是结构元素。不难知道，对于任意一个在阴影部分的点a，Ba 包含于X，所以X被B腐蚀的结果就是那个阴影部分。阴影部分在X的范围之内，且比X小，就象X被剥掉了一层似的，这就是为什么叫腐蚀的原因。

值得注意的是，上面的B是对称的，即B的对称集Bv=B，所以X被B腐蚀的结果和X被 Bv腐蚀的结果是一样的。如果B不是对称的，让我们看看图6.9，就会发现X被B腐蚀的结果和X被 Bv腐蚀的结果不同。

![0_1304413196MnAT.gif][]

图6.8和图6.9都是示意图，让我们来看看实际上是怎样进行腐蚀运算的。

在图6.10中，左边是被处理的图象X(二值图象，我们针对的是黑点)，中间是结构元素B，那个标有origin的点是中心点，即当前处理元素的位置，我们在介绍模板操作时也有过类似的概念。腐蚀的方法是，拿B的中心点和X上的点一个一个地对比，如果B上的所有点都在X的范围内，则该点保留，否则将该点去掉；右边是腐蚀后的结果。可以看出，它仍在原来X的范围内，且比X包含的点要少，就象X被腐蚀掉了一层。

![0_1304413203997e.gif][]

图6.11为原图，图6.12为腐蚀后的结果图，能够很明显地看出腐蚀的效果。

![0_13044132066OxB.gif][]

下面的这段程序，实现了上述的腐蚀运算，针对的都是黑色点。参数中有一个BOOL变量，为真时，表示在水平方向进行腐蚀运算，即结构元素B为 ![0_13044139975TL7.gif][] ；否则在垂直方向上进行腐蚀运算，即结构元素B为 ![0_130441400196mL.gif][] 。

BOOL Erosion(HWND hWnd,BOOL Hori)

DWORD                             OffBits,BufSize;

LPBITMAPINFOHEADER    lpImgData;

LPSTR                   lpPtr;

HLOCAL                  hTempImgData;

LPBITMAPINFOHEADER    lpTempImgData;

LPSTR                            lpTempPtr;

HDC                      hDc;

HFILE                    hf;

LONG                    x,y;

unsigned char              num;

int                        i;

//为了处理方便，仍采用256级灰度图，不过只用调色板中0和255两项

if( NumColors!=256)\{

MessageBox(hWnd,"Must be a mono bitmap with grayscale palette!",

"Error Message",MB\_OK|MB\_ICONEXCLAMATION);

return FALSE;

OffBits=bf.bfOffBits-sizeof(BITMAPFILEHEADER);

//BufSize为缓冲区大小

BufSize=OffBits+bi.biHeight\*LineBytes;

//为新的缓冲区分配内存

if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)

MessageBox(hWnd,"Error alloc memory!","Error Message",

MB\_OK|MB\_ICONEXCLAMATION);

return FALSE;

lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);

lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);

//拷贝头信息和位图数据

memcpy(lpTempImgData,lpImgData,BufSize);

if(Hori)

//在水平方向进行腐蚀运算

for(y=0;y<bi.biHeight;y++)\{

//lpPtr指向原图数据，lpTempPtr指向新图数据

lpPtr=(char \*)lpImgData+(BufSize-LineBytes-y\*LineBytes)+1;

lpTempPtr=(char\*)lpTempImgData+

(BufSize-LineBytes-y\*LineBytes)+1;

for(x=1;x<bi.biWidth-1;x++)\{

//注意为防止越界，x的范围从1到宽度\-2

num=(unsigned char)\*lpPtr;

if (num==0)\{  //因为腐蚀掉的是黑点，所以只对黑点处理

\*lpTempPtr=(unsigned char)0;  //先置成黑点

for(i=0;i<3;i++)\{

num=(unsigned char)\*(lpPtr+i-1);

if(num==255)\{

//自身及上下邻居中若有一个不是黑点，则将该点腐

//蚀成白点

\*lpTempPtr=(unsigned char)255;

break;

//原图中就是白点的，新图中仍是白点

else \*lpTempPtr=(unsigned char)255;

//指向下一个象素

lpPtr++;

lpTempPtr++;

else\{

//在垂直方向进行腐蚀运算

for(y=1;y<bi.biHeight-1;y++)\{ //注意为防止越界，y的范围从1到高度\-2

//lpPtr指向原图数据，lpTempPtr指向新图数据

lpPtr=(char \*)lpImgData+(BufSize-LineBytes-y\*LineBytes);

lpTempPtr=(char \*)lpTempImgData+(BufSize-LineBytes-y\*LineBytes);

for(x=0;x<bi.biWidth;x++)\{

num=(unsigned char)\*lpPtr;

if (num==0)\{ //因为腐蚀掉的是黑点，所以只对黑点处理

\*lpTempPtr=(unsigned char)0; //先置成黑点

for(i=0;i<3;i++)\{

num=(unsigned char)\*(lpPtr+(i-1)\*LineBytes);

if(num==255)\{

//自身及上下邻居中若有一个不是黑点，则将该点腐

//蚀成白点

\*lpTempPtr=(unsigned char)255;

break;

//原图中就是白点的，新图中仍是白点

else \*lpTempPtr=(unsigned char)255;

//指向下一个象素

lpPtr++;

lpTempPtr++;

if(hBitmap!=NULL)

DeleteObject(hBitmap);

hDc=GetDC(hWnd);

//产生新的位图

hBitmap=CreateDIBitmap(hDc,(LPBITMAPINFOHEADER)lpTempImgData,

(LONG)CBM\_INIT,

(LPSTR)lpTempImgData+

sizeof(BITMAPINFOHEADER)+

NumColors\*sizeof(RGBQUAD),

(LPBITMAPINFO)lpTempImgData, DIB\_RGB\_COLORS);

//起不同的结果文件名

if(Hori)

hf=\_lcreat("c://herosion.bmp",0);

else

hf=\_lcreat("c://verosion.bmp",0);

\_lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER));

\_lwrite(hf,(LPSTR)lpTempImgData,BufSize);

\_lclose(hf);

//释放内存及资源

ReleaseDC(hWnd,hDc);

LocalUnlock(hTempImgData);

LocalFree(hTempImgData);

GlobalUnlock(hImgData);

return TRUE;

## 6.2 膨胀 ##

膨胀(dilation)可以看做是腐蚀的对偶运算，其定义是：把结构元素B平移a后得到Ba，若Ba击中X，我们记下这个a点。所有满足上述条件的a点组成的集合称做X被B膨胀的结果。用公式表示为：D(X)=\{a | Ba↑X\}=X ![image037.jpg][] B，如图6.13所示。图6.13中X是被处理的对象，B是结构元素，不难知道，对于任意一个在阴影部分的点a，Ba击中X，所以X被B膨胀的结果就是那个阴影部分。阴影部分包括X的所有范围，就象X膨胀了一圈似的，这就是为什么叫膨胀的原因。

同样，如果B不是对称的，X被B膨胀的结果和X被 Bv膨胀的结果不同。

让我们来看看实际上是怎样进行膨胀运算的。在图6.14中，左边是被处理的图象X(二值图象，我们针对的是黑点)，中间是结构元素B。膨胀的方法是，拿B的中心点和X上的点及X周围的点一个一个地对，如果B上有一个点落在X的范围内，则该点就为黑；右边是膨胀后的结果。可以看出，它包括X的所有范围，就象X膨胀了一圈似的。

![0_13044132177llE.gif][]

图6.15为图6.11膨胀后的结果图，能够很明显的看出膨胀的效果。

![0_1304413231HssS.gif][]

下面的这段程序，实现了上述的膨胀运算，针对的都是黑色点。参数中有一个BOOL变量，为真时，表示在水平方向进行膨胀运算，即结构元素B为 ![0_13044139975TL7.gif][] ；否则在垂直方向上进行膨胀运算，即结构元素B为 ![0_130441400196mL.gif][] 。

BOOL Dilation(HWND hWnd,BOOL Hori)

DWORD                             OffBits,BufSize;

LPBITMAPINFOHEADER    lpImgData;

LPSTR                   lpPtr;

HLOCAL                  hTempImgData;

LPBITMAPINFOHEADER    lpTempImgData;

LPSTR                     lpTempPtr;

HDC                     hDc;

HFILE                    hf;

LONG                    x,y;

unsigned char              num;

int                        i;

//为了处理的方便，仍采用256级灰度图，不过只调色板中0和255两项

if( NumColors!=256)\{

MessageBox(hWnd,"Must be a mono bitmap with grayscale palette!",

"Error Message",MB\_OK|MB\_ICONEXCLAMATION);

return FALSE;

OffBits=bf.bfOffBits-sizeof(BITMAPFILEHEADER);

//BufSize为缓冲区大小

BufSize=OffBits+bi.biHeight\*LineBytes;

//为新的缓冲区分配内存

if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)

MessageBox(hWnd,"Error alloc memory!","Error Message",

MB\_OK|MB\_ICONEXCLAMATION);

return FALSE;

lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);

lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);

//拷贝头信息和位图数据

memcpy(lpTempImgData,lpImgData,BufSize);

if(Hori)

//在水平方向进行膨胀运算

for(y=0;y<bi.biHeight;y++)\{

//lpPtr指向原图数据，lpTempPtr指向新图数据

lpPtr=(char \*)lpImgData+(BufSize-LineBytes-y\*LineBytes)+1;

lpTempPtr=(char\*)lpTempImgData+

(BufSize-LineBytes-y\*LineBytes)+1;

for(x=1;x<bi.biWidth-1;x++)\{

//注意为防止越界，x的范围从1到宽度\-2

num=(unsigned char)\*lpPtr;

//原图中是黑点的，新图中肯定也是，所以要考虑的是那些原图

//中的白点，看是否有可能膨胀成黑点

if (num==255)\{

\*lpTempPtr=(unsigned char)255; //先置成白点

for(i=0;i<3;i++)\{

num=(unsigned char)\*(lpPtr+i-1);

//只要左右邻居中有一个是黑点，就膨胀成黑点

if(num==0)\{

\*lpTempPtr=(unsigned char)0;

break;

//原图中就是黑点的，新图中仍是黑点

else \*lpTempPtr=(unsigned char)0;

//指向下一个象素

lpPtr++;

lpTempPtr++;

else\{

//在垂直方向进行腐蚀运算

for(y=1;y<bi.biHeight-1;y++)\{ //注意为防止越界，y的范围从1到高度\-2

lpPtr=(char \*)lpImgData+(BufSize-LineBytes-y\*LineBytes);

lpTempPtr=(char \*)lpTempImgData+(BufSize-LineBytes-y\*LineBytes);

for(x=0;x<bi.biWidth;x++)\{

num=(unsigned char)\*lpPtr;

if (num==255)\{

\*lpTempPtr=(unsigned char)255;

for(i=0;i<3;i++)\{

num=(unsigned char)\*(lpPtr+(i-1)\*LineBytes);

//只要上下邻居中有一个是黑点，就膨胀成黑点

if(num==0)\{

\*lpTempPtr=(unsigned char)0;

break;

else \*lpTempPtr=(unsigned char)0;

lpPtr++;

lpTempPtr++;

if(hBitmap!=NULL)

DeleteObject(hBitmap);

hDc=GetDC(hWnd);

//产生新的位图

hBitmap=CreateDIBitmap(hDc,(LPBITMAPINFOHEADER)lpTempImgData,

(LONG)CBM\_INIT,

(LPSTR)lpTempImgData+

sizeof(BITMAPINFOHEADER)+

NumColors\*sizeof(RGBQUAD),

(LPBITMAPINFO)lpTempImgData,

DIB\_RGB\_COLORS);

//起不同的结果文件名

if(Hori)

hf=\_lcreat("c://hdilation.bmp",0);

else

hf=\_lcreat("c://vdilation.bmp",0);

\_lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER));

\_lwrite(hf,(LPSTR)lpTempImgData,BufSize);

\_lclose(hf);

//释放内存及资源

ReleaseDC(hWnd,hDc);

LocalUnlock(hTempImgData);

LocalFree(hTempImgData);

GlobalUnlock(hImgData);

return TRUE;

腐蚀运算和膨胀运算互为对偶的，用公式表示为(X ![image046.jpg][] B)c=(Xc ![image047.jpg][] B)，即X 被B腐蚀后的补集等于X的补集被B膨胀。这句话可以形象的理解为：河岸的补集为河面，河岸的腐蚀等价于河面的膨胀。你可以自己举个例子来验证一下这个关系。在有些情况下，这个对偶关系是非常有用的。例如：某个图象处理系统用硬件实现了腐蚀运算，那么不必再另搞一套膨胀的硬件，直接利用该对偶就可以实现了。

## 6.3 开 ##

先腐蚀后膨胀称为开(open)，即OPEN(X)=D(E(X))。

让我们来看一个开运算的例子(见图6.16)：

![0_1304413235Stk7.gif][]

在图16上面的两幅图中，左边是被处理的图象X(二值图象，我们针对的是黑点)，右边是结构元素B，下面的两幅图中左边是腐蚀后的结果；右边是在此基础上膨胀的结果。可以看到，原图经过开运算后，一些孤立的小点被去掉了。一般来说，开运算能够去除孤立的小点，毛刺和小桥(即连通两块区域的小点)，而总的位置和形状不变。这就是开运算的作用。要注意的是，如果B是非对称的，进行开运算时要用B的对称集Bv膨胀，否则，开运算的结果和原图相比要发生平移。图6.17和图6.18能够说明这个问题。

![0_1304413238oPIm.gif][]

图6.17是用B膨胀的，可以看到，OPEN(X)向左平移了。图18是用Bv膨胀的，可以看到，总的位置和形状不变。

图6.19为图6.11经过开运算后的结果。

![0_1304413246l55o.gif][]

开运算的源程序可以很容易的根据上面的腐蚀，膨胀程序得到，这里就不给出了。

## 6.4 闭 ##

先膨胀后腐蚀称为闭(close)，即CLOSE(X)=E(D(X))。

让我们来看一个闭运算的例子(见图6.20)：

![0_13044132595dnh.gif][]

在图6.20上面的两幅图中，左边是被处理的图象X(二值图象，我们针对的是黑点)，右边是结构元素B，下面的两幅图中左边是膨胀后的结果，右边是在此基础上腐蚀的结果可以看到，原图经过闭运算后，断裂的地方被弥合了。一般来说，闭运算能够填平小湖(即小孔)，弥合小裂缝，而总的位置和形状不变。这就是闭运算的作用。同样要注意的是，如果B是非对称的，进行闭运算时要用B的对称集Bv膨胀，否则，闭运算的结果和原图相比要发生平移。

图6.21为图6.11经过闭运算后的结果。

![0_1304413263300q.gif][]

闭运算的源程序可以很容易的根据上面的膨胀，腐蚀程序得到，这里就不给出了。

你大概已经猜到了，开和闭也是对偶运算，的确如此。用公式表示为(OPEN(X))c=CLOSE((Xc))，或者(CLOSE(X))c =OPEN((Xc))。即X 开运算的补集等于X的补集的闭运算，或者X 闭运算的补集等于X的补集的开运算。这句话可以这样来理解：在两个小岛之间有一座小桥，我们把岛和桥看做是处理对象X，则X的补集为大海。如果涨潮时将小桥和岛的外围淹没(相当于用尺寸比桥宽大的结构元素对X进行开运算)，那么两个岛的分隔，相当于小桥两边海域的连通(对Xc做闭运算)。

## 6.5 细化 ##

细化(thinning)算法有很多，我们在这里介绍的是一种简单而且效果很好的算法，用它就能够实现从文本抽取骨架的功能。我们的对象是白纸黑字的文本，但在程序中为了处理的方便，还是采用256级灰度图，不过只用到了调色板中0和255两项。

所谓细化，就是从原来的图中去掉一些点，但仍要保持原来的形状。实际上，是保持原图的骨架。所谓骨架，可以理解为图象的中轴，例如一个长方形的骨架是它的长方向上的中轴线；正方形的骨架是它的中心点；圆的骨架是它的圆心，直线的骨架是它自身，孤立点的骨架也是自身。文本的骨架嘛，前言中的例子显示的很明白。那么怎样判断一个点是否能去掉呢？显然，要根据它的八个相邻点的情况来判断，我们给几个例子(如图6.22所示)。

![0_130441326701H0.gif][]

图6.22中，(1)不能删，因为它是个内部点，我们要求的是骨架，如果连内部点也删了，骨架也会被掏空的；(2)不能删，和(1)是同样的道理；(3)可以删，这样的点不是骨架；(4)不能删，因为删掉后，原来相连的部分断开了；(5)可以删，这样的点不是骨架；(6)不能删，因为它是直线的端点，如果这样的点删了，那么最后整个直线也被删了，剩不下什么；(7)不能删，因为孤立点的骨架就是它自身。

总结一下，有如下的判据：(1)内部点不能删除；(2)孤立点不能删除；(3)直线端点不能删除；(4)如果P是边界点，去掉P后，如果连通分量不增加，则P可以删除。

我们可以根据上述的判据，事先做出一张表，从0到255共有256个元素，每个元素要么是0，要么是1。我们根据某点(当然是要处理的黑色点了)的八个相邻点的情况查表，若表中的元素是1，则表示该点可删，否则保留。

查表的方法是，设白点为1，黑点为0；左上方点对应一个8位数的第一位(最低位)，正上方点对应第二位，右上方点对应的第三位，左邻点对应第四位，右邻点对应第五位，左下方点对应第六位，正下方点对应第七位，右下方点对应的第八位，按这样组成的8位数去查表即可。例如上面的例子中(1)对应表中的第0项，该项应该为0；(2)对应37，该项应该为0；(3)对应173，该项应该为1；(4)对应231，该项应该为0；(5)对应237，该项应该为1；(6)对应254，该项应该为0；(7)对应255，该项应该为0。

这张表我已经替大家做好了，可花了我不少时间呢！

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

\};

有了这张表，算法就很简单了，每次对一行一行的将整个图象扫描一遍，对于每个点(不包括边界点)，计算它在表中对应的索引，若为0，则保留，否则删除该点。如果这次扫描没有一个点被删除，则循环结束，剩下的点就是骨架点，如果有点被删除，则进行新的一轮扫描，如此反复，直到没有点被删除为止。

实际上，该算法有一些缺陷。举个简单的例子，有一个黑色矩形，如图6.23所示。

图6.23经过细化后，我们预期的结果是一条水平直线，且位于该黑色矩形的中心。实际的结果确实是一条水平直线，但不是位于黑色矩形的中心，而是最下面的一条边。

为什么会这样，我们来分析一下：在从上到下，从左到右的扫描过程中，我们遇到的第一个黑点就是黑色矩形的左上角点，经查表，该点可以删。下一个点是它右边的点，经查表，该点也可以删，如此下去，整个一行被删了。每一行都是同样的情况，所以都被删除了。到了最后一行时，黑色矩形已经变成了一条直线，最左边的黑点不能删，因为它是直线的端点，它右边的点也不能删，因为如果删除，直线就断了，如此下去，直到最右边的点，也不能删，因为它是直线的右端点。所以最下面的一条边保住了，但这并不是我们希望的结果。

解决的办法是，在每一行水平扫描的过程中，先判断每一点的左右邻居，如果都是黑点，则该点不做处理。另外，如果某个黑点被删除了，那么跳过它的右邻居，处理下一个点。这样就避免了上述的问题。

![0_1304413271pAGx.gif][]

解决了上面的问题，我们来看看处理后的结果，如图6.24所示。这次变成一小段竖线了，还是不对，是不是很沮丧？别着急，让我们再来分析一下：在上面的算法中，我们遇到的第一个能删除的点就是黑色矩形的左上角点；第二个是第一行的最右边的点，即黑色矩形的右上角点；第三个是第二行的最左边的点；第四个是第二行的最右边的点；……；整个图象处理这样一次后，宽度减少2。每次都是如此，直到剩最中间一列，就不能再删了。为什么会这样呢？原因是这样的处理过程只实现了水平细化，如果在每一次水平细化后，再进行一次垂直方向的细化(只要把上述过程的行列换一下)，就可以了。

这样一来，每处理一次，删除点的顺序变成：(先是水平方向扫描)第一行最左边的点；第一行最右边的点；第二行最左边的点；第二行最右边的点；……最后一行最左边的点；最后一行最右边的点；(然后是垂直方向扫描)第二列最上边的点(因为第一列最上边的点已被删除)；第二列最下边的点；第三列最上边的点；第三列最下边的点；……倒数第二列最上边的点(因为倒数第一列最上边的点已被删除)；倒数第二列最下边的点。我们发现，刚好剥掉了一圈，这也正是细化要做的事。实际的结果也验证了我们的想法。

以下是源程序，黑体字部分是值得注意的地方。

BOOL Thinning(HWND hWnd)

DWORD                             OffBits,BufSize;

LPBITMAPINFOHEADER    lpImgData;

LPSTR                            lpPtr;

HLOCAL                  hTempImgData;

LPBITMAPINFOHEADER    lpTempImgData;

LPSTR                   lpTempPtr;

HDC                      hDc;

HFILE                    hf;

LONG                    x,y;

int                                        num;

BOOL                     Finished;

int                        nw,n,ne,w,e,sw,s,se;

//为了处理的方便，仍采用256级灰度图，不过只用调色板中0和255两项

if( NumColors!=256)\{

MessageBox(hWnd,"Must be a mono bitmap with grayscale palette!",

"Error Message",MB\_OK|MB\_ICONEXCLAMATION);

return FALSE;

OffBits=bf.bfOffBits-sizeof(BITMAPFILEHEADER);

//BufSize为缓冲区大小

BufSize=OffBits+bi.biHeight\*LineBytes;

//为新的缓冲区分配内存

if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)

MessageBox(hWnd,"Error alloc memory!","Error Message",

MB\_OK|MB\_ICONEXCLAMATION);

return FALSE;

lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);

lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);

//拷贝头信息和位图数据

memcpy(lpTempImgData,lpImgData,BufSize);

//结束标志置成假

Finished=FALSE;

while(!Finished)\{ //还没有结束

//结束标志置成假

Finished=TRUE;

//先进行水平方向的细化

for (y=1;y<bi.biHeight-1;y++)\{ //注意为防止越界，y的范围从1到高度\-2

//lpPtr指向原图数据，lpTempPtr指向新图数据

lpPtr=(char \*)lpImgData+(BufSize-LineBytes-y\*LineBytes);

lpTempPtr=(char \*)lpTempImgData+(BufSize-LineBytes-y\*LineBytes);

x=1; //注意为防止越界，x的范围从1到宽度\-2

while(x<bi.biWidth-1)\{

if(\*(lpPtr+x)==0)\{ //是黑点才做处理

w=(unsigned char)\*(lpPtr+x-1);  //左邻点

e=(unsigned char)\*(lpPtr+x+1);  //右邻点

if( (w==255)|| (e==255))\{

//如果左右两个邻居中至少有一个是白点才处理

nw=(unsigned char)\*(lpPtr+x+LineBytes-1); //左上邻点

n=(unsigned char)\*(lpPtr+x+LineBytes); //上邻点

ne=(unsigned char)\*(lpPtr+x+LineBytes+1); //右上邻点

sw=(unsigned char)\*(lpPtr+x-LineBytes-1); //左下邻点

s=(unsigned char)\*(lpPtr+x-LineBytes); //下邻点

se=(unsigned char)\*(lpPtr+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)\{ //经查表，可以删除

//在原图缓冲区中将该黑点删除

\*(lpPtr+x)=(BYTE)255;

//结果图中该黑点也删除

\*(lpTempPtr+x)=(BYTE)255;

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

x++; //水平方向跳过一个象素

x++; //扫描下一个象素

//再进行垂直方向的细化

for (x=1;x<bi.biWidth-1;x++)\{ //注意为防止越界，x的范围从1到宽度\-2

y=1; //注意为防止越界，y的范围从1到高度\-2

while(y<bi.biHeight-1)\{

lpPtr=(char \*)lpImgData+(BufSize-LineBytes-y\*LineBytes);

lpTempPtr=(char\*)lpTempImgData+

(BufSize-LineBytes-y\*LineBytes);

if(\*(lpPtr+x)==0)\{ //是黑点才做处理

n=(unsigned char)\*(lpPtr+x+LineBytes);

s=(unsigned char)\*(lpPtr+x-LineBytes);

if( (n==255)|| (s==255))\{

//如果上下两个邻居中至少有一个是白点才处理

nw=(unsigned char)\*(lpPtr+x+LineBytes-1);

ne=(unsigned char)\*(lpPtr+x+LineBytes+1);

w=(unsigned char)\*(lpPtr+x-1);

e=(unsigned char)\*(lpPtr+x+1);

sw=(unsigned char)\*(lpPtr+x-LineBytes-1);

se=(unsigned char)\*(lpPtr+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)\{ //经查表，可以删除

//在原图缓冲区中将该黑点删除

\*(lpPtr+x)=(BYTE)255;

//结果图中该黑点也删除

\*(lpTempPtr+x)=(BYTE)255;

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

y++;//垂直方向跳过一个象素

y++; //扫描下一个象素

if(hBitmap!=NULL)

DeleteObject(hBitmap);

hDc=GetDC(hWnd);

//产生新的位图

hBitmap=CreateDIBitmap(hDc,(LPBITMAPINFOHEADER)lpTempImgData,

(LONG)CBM\_INIT,

(LPSTR)lpTempImgData+

sizeof(BITMAPINFOHEADER)+

NumColors\*sizeof(RGBQUAD),

(LPBITMAPINFO)lpTempImgData,

DIB\_RGB\_COLORS);

hf=\_lcreat("c://thinning.bmp",0);

\_lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER));

\_lwrite(hf,(LPSTR)lpTempImgData,BufSize);

\_lclose(hf);

//释放内存及资源

ReleaseDC(hWnd,hDc);

LocalUnlock(hTempImgData);

LocalFree(hTempImgData);

GlobalUnlock(hImgData);

return TRUE;

摘自：[http://blog.csdn.net/yeqiu712/article/details/6387678\#t0][http_blog.csdn.net_yeqiu712_article_details_6387678_t0]

[image002.gif]: /images/20220613/43dbfe85dcc14888b84a3e761325c62d.png
[0_1304412985593w.gif]: /images/20220613/50fd36d1d6a14135bdec7faaa636c5f7.png
[image011.gif]: /images/20220613/33129076233f464889295f3159e85b06.png
[0_130441307955O5.gif]: /images/20220613/ca9718f42cd14cf1b278da68ebc345af.png
[0_1304413147EH82.gif]: /images/20220613/b986c5204d74486d9222a2c4c2c388e3.png
[0_1304413191cHv5.gif]: /images/20220613/248585dec2df4de3a1597a0340f5233c.png
[0_1304413196MnAT.gif]: /images/20220613/30a696d524d24e8da21eccf47e24a7d2.png
[0_1304413203997e.gif]: /images/20220613/24fd97abd0df4d75a0cbf2de02978421.png
[0_13044132066OxB.gif]: /images/20220613/f97cdb248962424b83cc9549df73835d.png
[0_13044139975TL7.gif]: http://hi.csdn.net/attachment/201105/3/0_13044139975TL7.gif
[0_130441400196mL.gif]: /images/20220613/d48b2126b5664ee39064186c952de554.png
[image037.jpg]: /images/20220613/b14c9960e7fe44289adafa8ddb456f41.png
[0_13044132177llE.gif]: /images/20220613/eca726632692406984c8e9206e6fece6.png
[0_1304413231HssS.gif]: /images/20220613/0436157d93e34041bcb74b69deecc1f0.png
[image046.jpg]: http://blog.csdn.net/yeqiu712/article/details/chap06.files/image046.jpg
[image047.jpg]: /images/20220613/bf85d21dba3b458f81fae09c38e30c14.png
[0_1304413235Stk7.gif]: /images/20220613/2f09e59baefb4ff1b6abb2d16d97be6f.png
[0_1304413238oPIm.gif]: /images/20220613/e29c03355cbe4de68c85389614643a11.png
[0_1304413246l55o.gif]: /images/20220613/0a6ae597a1174e1fbc18a4e7423a0db5.png
[0_13044132595dnh.gif]: /images/20220613/de3777128d0f4737924bbdfc755f3815.png
[0_1304413263300q.gif]: /images/20220613/6b90ffbdee56471582e4a6c821a8bbe2.png
[0_130441326701H0.gif]: /images/20220613/0b9025bbbdd64d048bddb18530cbe894.png
[0_1304413271pAGx.gif]: /images/20220613/b3a1cbef115d4647ba112d1c59e1902b.png
[http_blog.csdn.net_yeqiu712_article_details_6387678_t0]: http://blog.csdn.net/yeqiu712/article/details/6387678#t0