图像的膨胀与腐蚀

此文原文http://www.cnblogs.com/slysky/archive/2011/10/16/2214015.html#2619948

腐蚀

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

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　图1

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

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

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　图2

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

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

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　图3

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

　　　　　　　　　　　　　　　　　　　　　　　　　　图4

　　　　　　　　　　　　　　　　　　　　　　　　　　　　图5

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

腐蚀源码

腐蚀源码

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;

}

膨胀

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

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

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

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　图6

　　　　　　　　　　　　　　　　　　　　　　　　　　　　图7

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

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　图8

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

腐蚀源码

膨胀源码

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 B)^c=(X^c B)，即X 被B腐蚀后的补集等于X的补集被B膨胀。这句话可以形象的理解为：河岸的补集为河面，河岸的腐蚀等价于河面的膨胀。你可以自己举个例子来验证一下这个关系。在有些情况下，这个对偶关系是非常有用的。例如：某个图象处理系统用硬件实现了腐蚀运算，那么不必再另搞一套膨胀的硬件，直接利用该对偶就可以实现了。

开运算

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

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

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　图9

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

　　　　　　　　　　　　　　　　　　　　　　　　　图10用B膨胀后，结果向左平移了

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　图11 用B^v膨胀后位置不变

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

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

　　　　　　　　　　　　　　　　　　　　　　　　图12

闭

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

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

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　图13

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

图14为图4经过闭运算后的结果。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　图14

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

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

本文说明：本文中用的事例是把黑点看做的‘1’，把白点看做了‘0’，但是我们在opencv中使用时是把黑点看做‘0’，把白点看做’1‘的，所以膨胀扩张的是白的区域，腐蚀缩小的也是白色的区域

posted @ 2013-02-27 11:05 ying870510 阅读(8679) 评论(0) 编辑收藏举报

刷新页面返回顶部

ying870510

图像的膨胀与腐蚀

此文原文http://www.cnblogs.com/slysky/archive/2011/10/16/2214015.html#2619948

腐蚀

公告