膨胀_膨胀腐蚀 - CSDN
精华内容
参与话题
  • 图像处理之——膨胀、腐蚀算法详解

    万次阅读 多人点赞 2015-12-30 16:48:39
    结构元素:膨胀和腐蚀操作的最基本组成部分,用于测试输出图像,通常要比待处理的图像小还很多。二维平面结构元素由一个数值为0或1的矩阵组成。结构元素的原点指定了图像中需要处理的像素范围,

    原理:在特殊领域运算形式——结构元素(Sturcture Element),在每个像素位置上与二值图像对应的区域进行特定的逻辑运算。运算结构是输出图像的相应像素。运算效果取决于结构元素大小内容以及逻辑运算性质。

    结构元素:膨胀和腐蚀操作的最基本组成部分,用于测试输出图像,通常要比待处理的图像小还很多。二维平面结构元素由一个数值为0或1的矩阵组成。结构元素的原点指定了图像中需要处理的像素范围,结构元素中数值为1的点决定结构元素的邻域像素在进行膨胀或腐蚀操作时是否需要参与计算。

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

    1.         元素

    设有一幅图象X,若点aX的区域以内,则称aX的元素,记作aX,如图6.1所示。

    2.         B包含于X

    设有两幅图象BX。对于B中所有的元素ai,都有aiX,则称B包含于(included in)X,记作B  X,如图6.2所示。

    3.         B击中X

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

    4.         B不击中X

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

    6.1     元素

    6.2     包含

    6.3     击中

    6.4     不击中

    5.         补集

    设有一幅图象X,所有X区域以外的点构成的集合称为X的补集,记作Xc,如图6.5所示。显然,如果BX=Ф,则BX的补集内,即B  Xc

    6.5     补集的示意图

    6.         结构元素

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

    7.         对称集

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

    8.         平移

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

    6.6     对称集的示意图

    6.7     平移的示意图

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

    6.1 腐蚀

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

    6.8     腐蚀的示意图

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

    值得注意的是,上面的B是对称的,即B的对称集Bv=B,所以XB腐蚀的结果和X Bv腐蚀的结果是一样的。如果B不是对称的,让我们看看图6.9,就会发现XB腐蚀的结果和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)
    
    {
    
           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后得到Ba,若Ba击中X,我们记下这个a点。所有满足上述条件的a点组成的集合称做XB膨胀的结果。用公式表示为:D(X)={a | BaX}=X  B,如图6.13所示。图6.13X是被处理的对象,B是结构元素,不难知道,对于任意一个在阴影部分的点aBa击中X,所以XB膨胀的结果就是那个阴影部分。阴影部分包括X的所有范围,就象X膨胀了一圈似的,这就是为什么叫膨胀的原因。

    同样,如果B不是对称的,XB膨胀的结果和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)
    
    {
    
           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=(Xc  B),即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进行开运算),那么两个岛的分隔,相当于小桥两边海域的连通(Xc做闭运算)

    细化

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

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

    6.22   根据某点的八个相邻点的情况来判断该点是否能删除

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

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

    我们可以根据上述的判据,事先做出一张表,从0255共有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)
    
    {
    
           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;
    
    }

    另外补充说明一下,助于理解

    腐蚀:删除对象边界的某些像素

    膨胀:给图像中的对象边界添加像素

    算法:

    膨胀算法:用3X3的结构元素,扫描二值图像的每一个像素,用结构元素与其覆盖的二值图像做“与”运算,如果都为0,结构图像的该像素为0,否则为1.结果:使二值图像扩大一圈。

    腐蚀算法:用3X3的结构元素,扫描二值图像的每一个像素,用结构元素与其覆盖的二值图像做“与”运算,如果都为1,结构图像的该像素为1,否则为0.结果:使二值图像减小一圈。

     




    展开全文
  • 前言: 数学形态学提供了一组有用...常用的形态学处理方法包括:腐蚀、膨胀、开运算、闭运算、顶帽运算、底帽运算,其中膨胀与腐蚀是图像处理中最常用的形态学操作手段,其他方法是两者相互组合而产生的。 一、膨...

    前言:

          数学形态学提供了一组有用的方法,能够用来调整分割区域的形状以获得比较理想的结果,它最初是从数学中的集合论发展而来并用于处理二值图的,虽然运算很简单,但是往往可以产生很好的效果,后来这些方法推广到普通的灰度级图像处理中。常用的形态学处理方法包括:腐蚀、膨胀、开运算、闭运算、顶帽运算、底帽运算,其中膨胀与腐蚀是图像处理中最常用的形态学操作手段,其他方法是两者相互组合而产生的。 

    一、膨胀

           跟卷积操作类似,假设有图像A和结构元素B,结构元素B在A上面移动,其中B定义其中心为锚点,计算B覆盖下A的最大像素值用来替换锚点的像素,其中B作为结构体可以是任意形状。我们回忆一下中值平滑操作——取每一个位置的矩形领域内值的中值作为该位置的输出灰度值,图像的膨胀操作与中值平滑操作类似,它是取每一个位置的矩形领域内值的最大值作为该位置的输出灰度值。不同的是,这里的领域不再单纯是矩形结构的,也可以是椭圆形结构的、十字交叉形结构的等,其中红色是参考点,也称为锚点(anchor point),如下所示:

                            

          因此取每个位置领域内最大值,所以膨胀后输出图像的总体亮度的平均值比起原图会有所升高,图像中比较亮的区域的面积会变大,而较暗物体的尺寸会减小甚至消失。

    1.1  结构元形状构造函数

                    getStructuringElement( int shape, Size ksize, Point anchor )


    其参数解释如下:

        shape:1)MORPH_RECT 表示产生矩形的结构元

                    2)MORPH_ELLIPSEM 表示产生椭圆形的结构元

                    3)MORPH_CROSS 表示产生十字交叉形的结构元

        ksize:表示结构元的尺寸,即(宽,高),必须是奇数

        anchor:表示结构元的锚点,即参考点。默认值Point(-1, -1)代表中心像素为锚点

    1.2 膨胀操作API

        OpenCV中提供给了dilate()函数来完成膨胀操作,其函数声明如下:


    其参数解释如下:

        src:表示输入矩阵

        element:表示结构元,即 函数getStructuringElement( )的返回值

        anchor:结构元的锚点,即参考点

        iterations:膨胀操作的次数,默认为一次

        borderType:边界扩充类型

        borderValue:边界扩充值


    1.3 创建TrackBar

          opencv提供了一种称为轨迹条或滑动条(Trackbar)的控件工具,能够直观的改变出现处理时的参数,实时看到更改这些参数时对于图像处理结果的影响。createTrackbar这个函数我们以后会经常用到,它创建一个可以调整数值的轨迹条,并将轨迹条附加到指定的窗口上,使用起来很方便。首先大家要记住,它往往会和一个回调函数配合起来使用。先看下他的函数声明:

                     int createTrackbar(conststring& trackbarname, conststring& winname, int* value, int count, TrackbarCallback onChange=0,void* userdata=0); 


        其中参数解释如下:

            trackbarname,表示轨迹条的名字,用来代表我们创建的轨迹条。
            winname,填窗口的名字,表示这个轨迹条会依附到哪个窗口上,即对应namedWindow()创建窗口时填的某一个窗口名。
            value,一个指向整型的指针,表示滑块的位置。并且在创建时,滑块的初始位置就是该变量当前的值。
            count,表示滑块可以达到的最大位置的值。滑块最小的位置的值始终为0。
            onChange,首先注意他有默认值0。这是一个指向回调函数的指针,每次滑块位置改变时,这个函数都会进行回调。并且这个函数的原型必须为void XXXX(int,void*);其中第一个参数是轨迹条的位置,第二个参数是用户数据(看下面的参数)。如果回调是NULL指针,表示没有回调函数的调用,仅第三个参数value有变化。
            userdata,他也有默认值0。这个参数是用户传给回调函数的数据,用来处理轨迹条事件。如果使用的第三个参数value实参是全局变量的话,完全可以不去管这个userdata参数。

            这个createTrackbar函数,为我们创建一个具有特定名称和范围的轨迹条(Trackbar,或者说是滑块范围控制工具),指定一个和轨迹条位置同步的变量。而且要指定回调函数onChange(第五个参数),在轨迹条位置改变的时候来调用这个回调函数。并且我们知道,创建的轨迹条显示在指定的winname(第二个参数)所代表的窗口上。


    1.4 代码演示

    接下来编写演示代码:

    #include <opencv2/opencv.hpp> 
    #include <iostream> 
    using namespace cv;
    
    Mat src, dst;                   // 全局变量
    int element_size = 3;      //全局变量
    int max_size = 21;           // 全局变量
    
    void CallBack_func(int, void*);
    int main( ) 
    {
    	src = imread("test7.png");
    	if (src.empty()) 
    	{
    		printf("could not load the  image...\n");
    		return -1;
    	}
    	namedWindow("原图:", CV_WINDOW_AUTOSIZE);
    	imshow("原图:", src);
    	namedWindow("膨胀操作后:", CV_WINDOW_AUTOSIZE);
    	createTrackbar("结构元尺寸 :", "膨胀操作后:", &element_size, max_size, CallBack_func);        
    	CallBack_func(element_size, 0);
    
    	waitKey(0);
    	return 0;
    }
    
    
    void CallBack_func(int, void*) 
    {
    	int s = element_size * 2 + 1;
    	Mat structureElement = getStructuringElement(MORPH_RECT, Size(s, s), Point(-1, -1));      //创建结构元
    	dilate(src, dst, structureElement, Point(-1, -1), 1);               //调用膨胀API
    	imshow("膨胀操作后:", dst);
    }

    运行程序,如下:



    二、腐蚀

           腐蚀操作与膨胀操作类似,只是它取结构元所指定的领域内值的最小值作为该位置的输出灰度值。因为取每个位置领域内最小值,所以腐蚀后输出图像的总体亮度的平均值比起原图会有所降低,图像中比较亮的区域的面积会变小甚至消失,而较暗物体的尺寸会扩大。

          OpenCV中提供给了erode()函数来完成膨胀操作,其函数声明如下:


    其中参数解释如下:  

        src:表示输入矩阵

        dst:表示输出矩阵

        element:表示结构元,即 函数getStructuringElement( )的返回值

        anchor:结构元的锚点,即参考点

        iterations:腐蚀操作的次数,默认为一次

        borderType:边界扩充类型

        borderValue:边界扩充值


    接下来我们编写演示代码:

    #include <opencv2/opencv.hpp> 
    #include <iostream> 
    using namespace cv;
    
    Mat src, dst;                   // 全局变量
    int element_size = 3;      //全局变量
    int max_size = 21;           // 全局变量
    
    void CallBack_func(int, void*);
    int main( ) 
    {
    	src = imread("test7.png");
    	if (src.empty()) 
    	{
    		printf("could not load the  image...\n");
    		return -1;
    	}
    	namedWindow("原图:", CV_WINDOW_AUTOSIZE);
    	imshow("原图:", src);
    	namedWindow("膨胀操作后:", CV_WINDOW_AUTOSIZE);
    	createTrackbar("结构元尺寸 :", "膨胀操作后:", &element_size, max_size, CallBack_func);        
    	CallBack_func(element_size, 0);
    
    	waitKey(0);
    	return 0;
    }
    
    
    void CallBack_func(int, void*) 
    {
    	int s = element_size * 2 + 1;
    	Mat structureElement = getStructuringElement(MORPH_RECT, Size(s, s), Point(-1, -1));      //创建结构元
    	erode(src, dst, structureElement);               //调用腐蚀API
    	imshow("膨胀操作后:", dst);
    }
    
    
    
    
    

    运行程序,如下:





    展开全文
  • 数学形态学运算——腐蚀、膨胀、开运算、闭运算

    万次阅读 多人点赞 2018-03-27 10:21:48
    数学形态学有2个基本的运算,即腐蚀和膨胀,而腐蚀和膨胀通过结合又形成了开运算和闭运算。 开运算就是先腐蚀再膨胀,闭运算就是先膨胀再腐蚀。 二值形态学 腐蚀 粗略的说,腐蚀可以使目标区域范围“变小”...

    数学形态学操作可以分为二值形态学和灰度形态学,灰度形态学由二值形态学扩展而来。数学形态学有2个基本的运算,即腐蚀和膨胀,而腐蚀和膨胀通过结合又形成了开运算和闭运算。
    开运算就是先腐蚀再膨胀,闭运算就是先膨胀再腐蚀。

    二值形态学

    腐蚀

    粗略的说,腐蚀可以使目标区域范围“变小”,其实质造成图像的边界收缩,可以用来消除小且无意义的目标物。式子表达为:
    这里写图片描述
    该式子表示用结构B腐蚀A,需要注意的是B中需要定义一个原点,【而B的移动的过程与卷积核移动的过程一致,同卷积核与图像有重叠之后再计算一样】当B的原点平移到图像A的像元(x,y)时,如果B在(x,y)处,完全被包含在图像A重叠的区域,(也就是B中为1的元素位置上对应的A图像值全部也为1)则将输出图像对应的像元(x,y)赋值为1,否则赋值为0。
    我们看一个演示图。
    这里写图片描述
    B依顺序在A上移动(和卷积核在图像上移动一样,然后在B的覆盖域上进行形态学运算),当其覆盖A的区域为[1,1;1,1]或者[1,0;1,1]时,(也就是B中‘1’是覆盖区域的子集)对应输出图像的位置才会为1。

    膨胀

    粗略地说,膨胀会使目标区域范围“变大”,将于目标区域接触的背景点合并到该目标物中,使目标边界向外部扩张。作用就是可以用来填补目标区域中某些空洞以及消除包含在目标区域中的小颗粒噪声
    这里写图片描述
    该式子表示用结构B膨胀A,将结构元素B的原点平移到图像像元(x,y)位置。如果B在图像像元(x,y)处与A的交集不为空(也就是B中为1的元素位置上对应A的图像值至少有一个为1),则输出图像对应的像元(x,y)赋值为1,否则赋值为0。
    演示图为:
    这里写图片描述

    小结

    也就是说无论腐蚀还是膨胀,都是把结构元素B像卷积操作那样,在图像上平移,结构元素B中的原点就相当于卷积核的核中心,结果也是存储在核中心对应位置的元素上。只不过腐蚀是B被完全包含在其所覆盖的区域,膨胀时B与其所覆盖的区域有交集即可。

    灰度形态学

    在讲述灰度值形态学之前,我们进行一个约定,即将结构元素B覆盖住的图像A的区域记为P(取Part之意)。

    灰度形态学的腐蚀

    那么灰度形态学中的腐蚀就是类似卷积的一种操作,用P减去结构元素B形成的小矩形,取其中最小值赋到对应原点的位置即可。
    我们来看一个实例,进行加深对灰度形态学的理解。
    假设我们有如下的图像A和结构元素B:
    这里写图片描述
    进行灰度形态学腐蚀的过程如下:
    这里写图片描述
    我们对输出图像的第一个元素的输出结果进行具体的展示,也就是原点对应的4的位置。输出图像其他的元素的值也都是这样得到的。我们会看到,B首先覆盖的区域就是被减数矩阵,然后在其差矩阵中求min(最小值)来作为原点对应位置的值。
    这里写图片描述

    灰度形态学的膨胀

    根据上面对腐蚀的描述,我们对膨胀做出同样的描述,灰度形态学中的膨胀就是类似卷积的一种操作,用P加上B,然后取这个区域中的最大值赋值给结构元素B的原点所对应的位置。
    这里写图片描述
    这里写图片描述
    这里也对输出图像第一个元素值的来历做个说明。
    这里写图片描述
    对上面矩阵的和求最大值就是6,所以把6赋值给结构元素原点所对应的位置。

    小结

    上面介绍了灰度形态学的概念,这里来说一说各自的用处。相比较于原图像,因为腐蚀的结果要使得各像元比之前变得更小,所以适用于去除高峰噪声。而灰度值膨胀的结果会使得各像元比之前的变得更大,所以适用于去除低谷噪声。

    开运算和闭运算

    前面介绍了腐蚀和膨胀,而开运算和闭运算就是2种基本运算的叠加。正如开篇所说的那样,开运算就是先腐蚀再膨胀,闭运算就是先膨胀再腐蚀。这里也就不再赘述。

    展开全文
  • 图像形态学处理——膨胀(Matlab)

    千次阅读 2019-09-04 21:17:46
    clc; clear all; close all; ...%膨胀测试图像 I=im2double(imread('D:\Gray Files\9-7.tif')); %获得图像大小 [M,N]=size(I); %存放膨胀后的图像 J=zeros(M,N); %% %========================...
    clc;
    clear all;
    close all;
    
    %读入图像,并转换为double型,该计算针对的是二值图像,所以加入图像时需注意
    %膨胀测试图像
    I=im2double(imread('D:\Gray Files\9-7.tif'));
    %获得图像大小
    [M,N]=size(I);
    %存放膨胀后的图像
    J=zeros(M,N);
    
    %%
    %===============================膨胀图像===================================
    %结构元素
    B=[0 1 0;
        1 1 1;
        0 1 0];
    n_B=numel(B);
    n=3;
    %这里需要B对其原点进行翻转,因为B是对称的,所以翻转后的结果与其本身相同
    l_m=floor(n/2);
    l_n=floor(n/2);
    %将原始图像进行扩展,这里采用了镜像扩展,以进行图像边缘计算
    I_pad=padarray(I,[l_m,l_n],'symmetric');
    %膨胀过程
    for x=1:M
        for y=1:N
            %从扩展图像中取出子图像
             Block=I_pad(x:x+2*l_m,y:y+2*l_n);
             %将结构元素与子图像点乘,值赋给新图像
             %将结构元素与子图像点乘,即逻辑“与”操作
             c=B.*Block;
              %比较结构元素与c中的0的数量,如都为0,则该点的值为0,否则为1
             ind=find(c==0);
             if length(ind)~=n_B
                 J(x,y)=1;
             end
        end
    end
    imshow(J,[]);

     

    展开全文
  • 形态学——膨胀

    千次阅读 2018-08-03 17:40:18
    膨胀是将与目标区域的背景点合并到该目标物中,使目标物边界向外部扩张的处理。 例如: 2、设计思想 设计一个结构元素,结构元素的原点定位在背景像素上,判断是否覆盖有目标点,来确定是否该点被膨胀为目标点...
  • 腐蚀与膨胀基本原理:就是用一个特定的结构元素来与待处理图像按像素做逻辑操作;可以理解成拿一个带孔的网格板(结构元素矩阵中元素为1的为孔)盖住图像的某一部分,然后按照各种不同的观察方式来确定操作类型。 ...
  • 图像形态学之膨胀算子

    千次阅读 2018-03-03 16:42:49
    膨胀运算在数字形态中的作用是把图像周围的背景点合并到物体中。如果两个物体之间距离比较近,那么膨胀运算可能会使这两个物体连接在一起。膨胀对填补图像分割后物体中的空洞很有用。 dilation1(Region, ...
  • 形态学应用——图像腐蚀与膨胀

    千次阅读 2018-08-17 19:32:59
    图像腐蚀与膨胀 结构元素 设有两幅图象B,X。若X是被处理的对象,而B是用来处理X的,则称B为结构元素(structure element),又被形象地称做刷子。结构元素通常都是一些比较小的图象。 腐蚀 把结构元素B平移a后...
  • 图像的腐蚀与膨胀

    万次阅读 2018-10-11 14:15:46
    图像腐蚀与膨胀 结构元素 设有两幅图象B,X。若X是被处理的对象,而B是用来处理X的,则称B为结构元素(structure element),又被形象地称做刷子。结构元素通常都是一些比较小的图象。 腐蚀 把结构元素B平...
  • MATLAB中四种形态学基本运算 腐蚀 腐蚀是一种消除边界点,使边界向内部收缩的过程。可以用来消除小且无意义的物体。用3X3的结构元素,扫描图像的每一个像素,用结构元素与其覆盖的二值图像做“与”操作,如果都为1,...
  • 二值图像腐蚀与膨胀操作样例

    万次阅读 多人点赞 2020-10-03 20:56:21
    目录 操作方法简要说明 腐蚀操作 结构元素原点在结构元素内部 原点在结构元素外部 二值图像的膨胀操作 点在结构元素内部 原点在结构元素外部
  • 形态学(morphology)一...其基本的运算包括:二值腐蚀和膨胀、二值开闭运算、骨架抽取、极限腐蚀、击中击不中变换、形态学梯度、Top-hat变换、颗粒分析、流域变换、灰值腐蚀和膨胀、灰值开闭运算、灰值形态学梯度等。
  • 腐蚀膨胀

    千次阅读 2018-01-28 11:29:20
    结构元素:膨胀和腐蚀操作的最基本组成部分,用于测试输出图像,通常要比待处理的图像小还很多。二维平面结构元素由一个数值为0或1的矩阵组成。结构元素的原点指定了图像中需要处理的像素范围,结构元
  • 膨胀是将与物体接触的全部背景点合并到该物体中,使边界向外部扩张的过程。 能够用来填补物体中的空洞。膨胀(dilation)能够看做是腐蚀的对偶运算,其定义是:把结构元素B平移a后得到Ba,若Ba击中X,我们记下这个a点...
  • 膨胀

    2020-02-05 12:18:10
    膨胀 膨胀操作是形态学中另外一种基本操作。膨胀操作和腐蚀操作是相反的。 核心总结 如果结构元中任意一点处于前景图像中,就将膨胀结果图像中对应像素点处理为前景色 如果结构元完全处于前景图形外,就将膨胀结果...
  • 1、锁优化 在JDK6之前,通过synchronized来实现同步效率是很低的,被synchronized包裹的代码块经过javac编译后,会在代码块前后加上monitorenter和monitorexit字节码指令,被synchronized修饰的方法则会被加上ACC_...
  • 【C++】OpenCV图像的膨胀与腐蚀示例程序 by浅墨

    千次下载 热门讨论 2020-07-30 23:33:22
    博文《【OpenCV入门教程之十】 形态学图像处理(一): 膨胀与腐蚀》的配套详细注释源代码。 博文链接: http://blog.csdn.net/poem_qianmo/article/details/23710721 1.已将dll打包到Release文件夹下,运行Release...
  • [Python图像处理] 八.图像腐蚀与图像膨胀

    万次阅读 多人点赞 2020-08-20 12:48:51
    图像的膨胀(Dilation)和腐蚀(Erosion)是两种基本的形态学运算,主要用来寻找图像中的极大区域和极小区域。其中膨胀类似于“领域扩张”,将图像中的高亮区域或白色部分进行扩张,其运行结果图比原图的高亮区域更...
  • 膨胀与腐蚀算法

    万次阅读 2017-04-17 11:00:05
    膨胀与腐蚀算法 对图像处理有所了解的人都知道图像的形态学处理里最为基础的膨胀和腐蚀算法。二值图像即只有黑白两种颜色组成的图像,一般的白色为内容,黑色为背景。其实简单点理解二值图像的膨胀与腐蚀,腐蚀即...
  • 图像腐蚀和图像膨胀Matlab代码

    热门讨论 2020-07-29 14:21:49
    该代码首先实现了图像的腐蚀处理和图像的膨胀处理。然后,经过先腐蚀(Erosion)处理,后膨胀(Dilation)处理得到了Opening Image;又经过先膨胀(Dilation)处理,后腐蚀(Erosion)处理得到了Closing Image。 程序执行后...
1 2 3 4 5 ... 20
收藏数 92,685
精华内容 37,074
关键字:

膨胀