图像的腐蚀与膨胀 图像膨胀腐蚀 图像处理 膨胀 腐蚀 opencv 膨胀腐蚀 膨胀腐蚀 膨..
扫扫二维码，随身浏览文档
手机或平板扫扫即可继续访问
图像膨胀和腐蚀
举报该文档为侵权文档。
举报该文档含有违规或不良信息。
反馈该文档无法正常浏览。
举报该文档为重复文档。
推荐理由：
将文档分享至：
分享完整地址
文档地址：
粘贴到BBS或博客
flash地址：
支持嵌入FLASH地址的网站使用
html代码：
&embed src='/DocinViewer-4.swf' width='100%' height='600' type=application/x-shockwave-flash ALLOWFULLSCREEN='true' ALLOWSCRIPTACCESS='always'&&/embed&
450px*300px480px*400px650px*490px
支持嵌入HTML代码的网站使用
您的内容已经提交成功
您所提交的内容需要审核后才能发布，请您等待！
3秒自动关闭窗口3411人阅读
这是数字图像处理的第二次作业，包含的内容很多，有图像的二值化 膨胀&腐蚀 以及图像的开闭操作 击中击不中变换等。
1、图像的二值化
难点在于如何选取合适的Threshold。
基本思想：将二值化得到的二值图像视为两部分，一部分对应前景（Foreground），另一部分对应背景（Background）。尝试找到一个合适的threshold使得到的前景和背景的内部方差最小，而它们之间的方差则最大。
用上面一个很简单的式子就可以求出最优化的阈值 我用matlab实现了，C的可以参考下面的链接，很简单，不妨一试。
当然还有更好的方法 可以上网搜搜相关的论文 还是挺多的 人民的智慧还是无穷滴\(^o^)/~
2 图像的膨胀和腐蚀 【B是结构元】
膨胀(dilate)：由B对A膨胀所产生的二值图象D是满足以下条件的点(x,y)的集合：如果B的中心原点平移到点(x,y)，那么它与A的交集非空
腐蚀(erode)：由B对A腐蚀所产生的二值图象E是满足以下条件的点(x,y)的集合：如果B的中心原点平移到点(x,y)，那么B将完全包含于A中
A-B A被B腐蚀&
A+B A被B膨胀&
A -B的补集 等于 A的补集被B膨胀
A+B的补集 等于 A的补集被B腐蚀
膨胀和腐蚀 是对偶的关系
*腐蚀和膨胀的应用：边界提取（Boundary Extraction）
3、图像的开运算和闭运算
开运算：先腐蚀 后膨胀
用来消除小物体 在纤细点处分离物体，平滑较大的物体的边界 同时不明显的改变其面积
闭运算：先膨胀 后腐蚀
用来填充物体内细小空洞、连接邻近物体、平滑其边界的同时并不明显改变其面积。
4、击中或击不中变换（Hit-or miss transformation, HMT）
我的理解就是一个完全的模板匹配过程。
击中：找出满足的前景&
击不中：找出满足的背景
两者的交集就是一个完全的模板匹配过程。#
HMT是形态学运算推广到更为一般的情况,这时结构元不仅含有物体（前景）点，而且还含有背景点，只有当结构元素与所对应的区域完全符合时才作为结果输出到输出图象。实际上就演变为条件严格的模板匹配。
*HMT的应用
图像的Thining：
图像的细化 一般是指二值图像的骨骼化
在进行thinning操作的时候，首先从物体的边界上取一小块，然后用其做HMT，去掉HMT选择出来的点，
依此类推，经过一系列的HMT和删减之后，我们就能够对整个物体做thinning
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：16322次
排名：千里之外
原创：29篇
评论：13条
(9)(6)(10)(5)(1)膨胀和腐蚀--数字图像处理的一个问题_百度知道
膨胀和腐蚀--数字图像处理的一个问题
(1。膨胀,1)}谢谢各位了,5),1)我看了网上的一些介绍,2),3)，看了答案,0),2)：A={(1,(5,(0,(4,1)}腐蚀,(2。两个题目都是A什么B,1)。不过中心点怎么确定啊,1),(1,(0，感觉我做的和答案不一样,1)}
B={(0？我遇到两个题目,(1：A={(0,4), (2,(1,1),(1,(3,(6,1)，他们举得例子我都懂,-1)，都不知道是谁错,1)}
B={(0！,(1。,2),0)，不知道大家的答案是什么呢
提问者采纳
你这题是考试用还是自己研究，不需要中心点。如果是考试这是灰度图的腐蚀膨胀，都是二值图多，我查查资料给你算算？要是自己研究就跳过去得了，平时很少用到灰度图形态学运算
是考试前老师给的资料，感觉应该会考。。麻烦大哥你了
提问者评价
其他类似问题
按默认排序
其他2条回答
如果对点a（0,0）进行膨胀，即像素值是0或者非零，就是将这个点的8领域的点设置成与a点的值一样，这两种操作都是对二值图像进行操作好像没有中心的说法
中心点不是（0,0）么
第一题？不是吧？我看别人的讲解，都是集合里的一个点，（0,0）都不是B集合里的点
数字图像处理的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁数字图像处理中的膨胀原理是怎样的？_百度知道
数字图像处理中的膨胀原理是怎样的？
⑶ 膨胀和腐蚀膨胀和腐蚀这两种操作是形态学处理的基础://blog，这里B1＝X，结果图像的该像素为1。细化算法应满足以下条件，形成骨架后能比较容易的分析图像，B对A进行腐蚀的整个过程如下。① 膨胀是以得到B的相对与它自身原点的映像并且由z对映像进行移位为基础的，Y和Z组成的集合：与,即图像中只包含“黑”和“白”两种颜色，即是将原图像中线条宽度大于1个像素的线条细化成只有一个像素宽，而在检测完整幅图像后一次性去除要细化的点：① 将条形区域变成一条薄线，并保持其形状的基本拓扑结构不变，网格中值为1的点是集合的元素、或和非（求补），则X在A内能得到精确拟合位置集合是由X对A的腐蚀后由（W－X）对A的补集Ac腐蚀的交集。我们可以把上式改写为。在二值图像中，在这种限制下，为简单起见。否则为0腐蚀处理的结果是使原来的二值图像减小一圈，则在A中对B进行匹配可以表示为，二值图像的各个分量是Z2的元素，B2＝（W－X），目的是提取源图像的骨架：进行细化算法前要先对图像进行二值化.aspx关键词是 数学形态学，从而为文字识别中的特征抽取等应用奠定了基础，pavlidis算法和rosenfeld算法等，记为Sxy，我们设X被包围在一个小窗口W中。还可以参考，且全都为1。⑷ 击中（匹配）或击不中变换假设集合A是由3个子集X://blog，直到线条剩下一个像素的为止，所有黑色像素的集合是图像完整的形态学描述。否则为1② 腐蚀对Z中的集合A和B，许多形态学算法都是以这两种运算为基础的。假定二值图像A和形态学处理的结构元素B是定义在笛卡儿网格上的集合。细化基本思想是“层层剥夺”，一边删除细化点： ⑴ 用结构元素B，串行细化即是一边检测满足细化条件的点。图像形态学处理中我们感兴趣的主要是二值图像:http，如提取图像的特征。常用的图像细化算法有hilditch算法。在图像处理中用到的主要逻辑运算是
其他类似问题
数字图像处理的相关知识
您可能关注的推广回答者：
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁trackbacks-0
原理：在特殊领域运算形式&&结构元素（Sturcture Element），在每个像素位置上与二值图像对应的区域进行特定的逻辑运算。运算结构是输出图像的相应像素。运算效果取决于结构元素大小内容以及逻辑运算性质。
结构元素：膨胀和腐蚀操作的最基本组成部分，用于测试输出图像，通常要比待处理的图像小还很多。二维平面结构元素由一个数值为0或1的矩阵组成。结构元素的原点指定了图像中需要处理的像素范围，结构元素中数值为1的点决定结构元素的邻域像素在进行膨胀或腐蚀操作时是否需要参与计算。
先来定义一些基本符号和关系。
设有一幅图象X，若点a在X的区域以内，则称a为X的元素，记作a&X，如图6.1所示。
2.B包含于X
设有两幅图象B，X。对于B中所有的元素ai，都有ai&X，则称B包含于(included in)X，记作B
X，如图6.2所示。
设有两幅图象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所示。
图6.1&&&& 元素
图6.2&&&& 包含
图6.3&&&& 击中
图6.4&&&& 不击中
设有一幅图象X，所有X区域以外的点构成的集合称为X的补集，记作Xc，如图6.5所示。显然，如果B&X=Ф，则B在X的补集内，即B
图6.5&&&& 补集的示意图
6.结构元素
设有两幅图象B，X。若X是被处理的对象，而B是用来处理X的，则称B为结构元素(structure element)，又被形象地称做刷子。结构元素通常都是一些比较小的图象。
设有一幅图象B，将B中所有元素的坐标取反，即令(x，y)变成(-x，-y)，所有这些点构成的新的集合称为B的对称集，记作Bv，如图6.6所示。
设有一幅图象B，有一个点a(x0,y0)，将B平移a后的结果是，把B中所有元素的横坐标加x0，纵坐标加y0，即令(x，y)变成(x+x0，y+y0)，所有这些点构成的新的集合称为B的平移，记作Ba，如图6.7所示。
图6.6&&&& 对称集的示意图
图6.7&&&& 平移的示意图
好了，介绍了这么多基本符号和关系，现在让我们应用这些符号和关系，看一下形态学的基本运算。
把结构元素B平移a后得到Ba，若Ba包含于X，我们记下这个a点，所有满足上述条件的a点组成的集合称做X被B腐蚀(Erosion)的结果。用公式表示为：E(X)={a| Ba
B，如图6.8所示。
图6.8&&&& 腐蚀的示意图
图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腐蚀的结果不同。
图6.9&&&& 结构元素非对称时，腐蚀的结果不同
图6.8和图6.9都是示意图，让我们来看看实际上是怎样进行腐蚀运算的。
在图6.10中，左边是被处理的图象X(二值图象，我们针对的是黑点)，中间是结构元素B，那个标有origin的点是中心点，即当前处理元素的位置，我们在介绍模板操作时也有过类似的概念。腐蚀的方法是，拿B的中心点和X上的点一个一个地对比，如果B上的所有点都在X的范围内，则该点保留，否则将该点去掉；右边是腐蚀后的结果。可以看出，它仍在原来X的范围内，且比X包含的点要少，就象X被腐蚀掉了一层。
图6.10&& 腐蚀运算
图6.11为原图，图6.12为腐蚀后的结果图，能够很明显地看出腐蚀的效果。
图6.11&&& 原图
图6.12&& 腐蚀后的结果图
下面的这段程序，实现了上述的腐蚀运算，针对的都是黑色点。参数中有一个BOOL变量，为真时，表示在水平方向进行腐蚀运算，即结构元素B为
；否则在垂直方向上进行腐蚀运算，即结构元素B为
BOOL Erosion(HWND hWnd,BOOL Hori){
OffBits,BufSLPBITMAPINFOHEADER
LPBITMAPINFOHEADER
lpTempImgD
unsigned char
//为了处理方便，仍采用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*LineB
//为新的缓冲区分配内存
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);
//在水平方向进行腐蚀运算
for(y=0;y&bi.biHy++){
//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)*lpP
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;
}//原图中就是白点的，新图中仍是白点
else *lpTempPtr=(unsigned char)255;
//指向下一个象素
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.biWx++){
num=(unsigned char)*lpP
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;
}//原图中就是白点的，新图中仍是白点
else *lpTempPtr=(unsigned char)255;
//指向下一个象素
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);
//起不同的结果文件名
hf=_lcreat("c:\\herosion.bmp",0);
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;}
膨胀(dilation)可以看做是腐蚀的对偶运算，其定义是：把结构元素B平移a后得到Ba，若Ba击中X，我们记下这个a点。所有满足上述条件的a点组成的集合称做X被B膨胀的结果。用公式表示为：D(X)={a | Ba&X}=X
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膨胀了一圈似的。
图6.13&& 膨胀的示意图
图6.14&& 膨胀运算
图6.15为图6.11膨胀后的结果图，能够很明显的看出膨胀的效果。
图6.15&& 图6.11膨胀后的结果图
下面的这段程序，实现了上述的膨胀运算，针对的都是黑色点。参数中有一个BOOL变量，为真时，表示在水平方向进行膨胀运算，即结构元素B为
；否则在垂直方向上进行膨胀运算，即结构元素B为
BOOL Dilation(HWND hWnd,BOOL Hori){
OffBits,BufSLPBITMAPINFOHEADER
LPBITMAPINFOHEADER
lpTempImgD
unsigned char
//为了处理的方便，仍采用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*LineB//为新的缓冲区分配内存
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);
//在水平方向进行膨胀运算
for(y=0;y&bi.biHy++){
//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)*lpP//原图中是黑点的，新图中肯定也是，所以要考虑的是那些原图//中的白点，看是否有可能膨胀成黑点
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;
}//原图中就是黑点的，新图中仍是黑点
else *lpTempPtr=(unsigned char)0;
//指向下一个象素
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.biWx++){
num=(unsigned char)*lpP
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;
else *lpTempPtr=(unsigned char)0;
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);
//起不同的结果文件名
hf=_lcreat("c:\\hdilation.bmp",0);
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
B)，即X 被B腐蚀后的补集等于X的补集被B膨胀。这句话可以形象的理解为：河岸的补集为河面，河岸的腐蚀等价于河面的膨胀。你可以自己举个例子来验证一下这个关系。在有些情况下，这个对偶关系是非常有用的。例如：某个图象处理系统用硬件实现了腐蚀运算，那么不必再另搞一套膨胀的硬件，直接利用该对偶就可以实现了。
先腐蚀后膨胀称为开(open)，即OPEN(X)=D(E(X))。
让我们来看一个开运算的例子(见图6.16)：
图6.16开运算
在图16上面的两幅图中，左边是被处理的图象X(二值图象，我们针对的是黑点)，右边是结构元素B，下面的两幅图中左边是腐蚀后的结果；右边是在此基础上膨胀的结果。可以看到，原图经过开运算后，一些孤立的小点被去掉了。一般来说，开运算能够去除孤立的小点，毛刺和小桥(即连通两块区域的小点)，而总的位置和形状不变。这就是开运算的作用。要注意的是，如果B是非对称的，进行开运算时要用B的对称集Bv膨胀，否则，开运算的结果和原图相比要发生平移。图6.17和图6.18能够说明这个问题。
图6.17 用B膨胀后，结果向左平移了
图6.18&& 用Bv膨胀后位置不变
图6.17是用B膨胀的，可以看到，OPEN(X)向左平移了。图18是用Bv膨胀的，可以看到，总的位置和形状不变。
图6.19为图6.11经过开运算后的结果。
图6.19&& 图6.11经过开运算后的结果
开运算的源程序可以很容易的根据上面的腐蚀，膨胀程序得到，这里就不给出了。
先膨胀后腐蚀称为闭(close)，即CLOSE(X)=E(D(X))。
让我们来看一个闭运算的例子(见图6.20)：
图6.20&& 闭运算
在图6.20上面的两幅图中，左边是被处理的图象X(二值图象，我们针对的是黑点)，右边是结构元素B，下面的两幅图中左边是膨胀后的结果，右边是在此基础上腐蚀的结果可以看到，原图经过闭运算后，断裂的地方被弥合了。一般来说，闭运算能够填平小湖(即小孔)，弥合小裂缝，而总的位置和形状不变。这就是闭运算的作用。同样要注意的是，如果B是非对称的，进行闭运算时要用B的对称集Bv膨胀，否则，闭运算的结果和原图相比要发生平移。
图6.21为图6.11经过闭运算后的结果。
图6.21&& 图.611经过闭运算后的结果
闭运算的源程序可以很容易的根据上面的膨胀，腐蚀程序得到，这里就不给出了。
你大概已经猜到了，开和闭也是对偶运算，的确如此。用公式表示为(OPEN(X))c=CLOSE((Xc))，或者(CLOSE(X))c =OPEN((Xc))。即X 开运算的补集等于X的补集的闭运算，或者X 闭运算的补集等于X的补集的开运算。这句话可以这样来理解：在两个小岛之间有一座小桥，我们把岛和桥看做是处理对象X，则X的补集为大海。如果涨潮时将小桥和岛的外围淹没(相当于用尺寸比桥宽大的结构元素对X进行开运算)，那么两个岛的分隔，相当于小桥两边海域的连通(对Xc做闭运算)。
细化(thinning)算法有很多，我们在这里介绍的是一种简单而且效果很好的算法，用它就能够实现从文本抽取骨架的功能。我们的对象是白纸黑字的文本，但在程序中为了处理的方便，还是采用256级灰度图，不过只用到了调色板中0和255两项。
所谓细化，就是从原来的图中去掉一些点，但仍要保持原来的形状。实际上，是保持原图的骨架。所谓骨架，可以理解为图象的中轴，例如一个长方形的骨架是它的长方向上的中轴线；正方形的骨架是它的中心点；圆的骨架是它的圆心，直线的骨架是它自身，孤立点的骨架也是自身。文本的骨架嘛，前言中的例子显示的很明白。那么怎样判断一个点是否能去掉呢？显然，要根据它的八个相邻点的情况来判断，我们给几个例子(如图6.22所示)。
图6.22&& 根据某点的八个相邻点的情况来判断该点是否能删除
图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经过细化后，我们预期的结果是一条水平直线，且位于该黑色矩形的中心。实际的结果确实是一条水平直线，但不是位于黑色矩形的中心，而是最下面的一条边。
为什么会这样，我们来分析一下：在从上到下，从左到右的扫描过程中，我们遇到的第一个黑点就是黑色矩形的左上角点，经查表，该点可以删。下一个点是它右边的点，经查表，该点也可以删，如此下去，整个一行被删了。每一行都是同样的情况，所以都被删除了。到了最后一行时，黑色矩形已经变成了一条直线，最左边的黑点不能删，因为它是直线的端点，它右边的点也不能删，因为如果删除，直线就断了，如此下去，直到最右边的点，也不能删，因为它是直线的右端点。所以最下面的一条边保住了，但这并不是我们希望的结果。
解决的办法是，在每一行水平扫描的过程中，先判断每一点的左右邻居，如果都是黑点，则该点不做处理。另外，如果某个黑点被删除了，那么跳过它的右邻居，处理下一个点。这样就避免了上述的问题。
图6.23& 黑色矩形
图6.24& 图6.23细化后的结果
解决了上面的问题，我们来看看处理后的结果，如图6.24所示。这次变成一小段竖线了，还是不对，是不是很沮丧？别着急，让我们再来分析一下：在上面的算法中，我们遇到的第一个能删除的点就是黑色矩形的左上角点；第二个是第一行的最右边的点，即黑色矩形的右上角点；第三个是第二行的最左边的点；第四个是第二行的最右边的点；&&；整个图象处理这样一次后，宽度减少2。每次都是如此，直到剩最中间一列，就不能再删了。为什么会这样呢？原因是这样的处理过程只实现了水平细化，如果在每一次水平细化后，再进行一次垂直方向的细化(只要把上述过程的行列换一下)，就可以了。
这样一来，每处理一次，删除点的顺序变成：(先是水平方向扫描)第一行最左边的点；第一行最右边的点；第二行最左边的点；第二行最右边的点；&&最后一行最左边的点；最后一行最右边的点；(然后是垂直方向扫描)第二列最上边的点(因为第一列最上边的点已被删除)；第二列最下边的点；第三列最上边的点；第三列最下边的点；&&倒数第二列最上边的点(因为倒数第一列最上边的点已被删除)；倒数第二列最下边的点。我们发现，刚好剥掉了一圈，这也正是细化要做的事。实际的结果也验证了我们的想法。
以下是源程序，黑体字部分是值得注意的地方。
BOOL Thinning(HWND hWnd){
OffBits,BufS
LPBITMAPINFOHEADER
LPBITMAPINFOHEADER
lpTempImgD
nw,n,ne,w,e,sw,s,//为了处理的方便，仍采用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*LineB//为新的缓冲区分配内存
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;}
腐蚀：删除对象边界的某些像素
膨胀：给图像中的对象边界添加像素
膨胀算法：用3X3的结构元素，扫描二值图像的每一个像素，用结构元素与其覆盖的二值图像做&与&运算，如果都为0，结构图像的该像素为0，否则为1.结果：使二值图像扩大一圈。
腐蚀算法：用3X3的结构元素，扫描二值图像的每一个像素，用结构元素与其覆盖的二值图像做&与&运算，如果都为1，结构图像的该像素为1，否则为0.结果：使二值图像减小一圈。
阅读(...) 评论()