• 假设原图像中有一个前景物体,那么我们用一个结构元素去腐蚀原图的过程是这样的:遍历原图像的每一个像素,然后用结构元素的中心点对准当前正在遍历的这个像素,然后取当前结构元素所覆盖下的原图对应区域内的所有...

    腐蚀的原理:

    二值图像前景物体为1,背景为0.假设原图像中有一个前景物体,那么我们用一个结构元素去腐蚀原图的过程是这样的:遍历原图像的每一个像素,然后用结构元素的中心点对准当前正在遍历的这个像素,然后取当前结构元素所覆盖下的原图对应区域内的所有像素的最小值,用这个最小值替换当前像素值。由于二值图像最小值就是0,所以就是用0替换,即变成了黑色背景。从而也可以看出,如果当前结构元素覆盖下,全部都是背景,那么就不会对原图做出改动,因为都是0.如果全部都是前景像素,也不会对原图做出改动,因为都是1.只有结构元素位于前景物体边缘的时候,它覆盖的区域内才会出现0和1两种不同的像素值,这个时候把当前像素替换成0就有变化了。因此腐蚀看起来的效果就是让前景物体缩小了一圈一样。对于前景物体中一些细小的连接处,如果结构元素大小相等,这些连接处就会被断开。

    膨胀的原理:

    二值图像前景物体为1,背景为0.假设原图像中有一个前景物体,那么我们用一个结构元素去膨胀原图的过程是这样的:遍历原图像的每一个像素,然后用结构元素的中心点对准当前正在遍历的这个像素,然后取当前结构元素所覆盖下的原图对应区域内的所有像素的最大值,用这个最大值替换当前像素值。由于二值图像最大值就是1,所以就是用1替换,即变成了白色前景物体。从而也可以看出,如果当前结构元素覆盖下,全部都是背景,那么就不会对原图做出改动,因为都是0.如果全部都是前景像素,也不会对原图做出改动,因为都是1.只有结构元素位于前景物体边缘的时候,它覆盖的区域内才会出现0和1两种不同的像素值,这个时候把当前像素替换成1就有变化了。因此膨胀看起来的效果就是让前景物体胀大了一圈一样。对于前景物体中一些细小的断裂处,如果结构元素大小相等,这些断裂的地方就会被连接起来。

    下篇文章附上底层源码
    原文:https://blog.csdn.net/woainishifu/article/details/60778033

    展开全文
  • 结构元素:膨胀和腐蚀操作的最基本组成部分,用于测试输出图像,通常要比待处理图像小还很多。二维平面结构元素由一个数值为0或1的矩阵组成。结构元素的原点指定了图像中需要处理的像素范围,结构...

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

    结构元素:膨胀和腐蚀操作的最基本组成部分,用于测试输出图像,通常要比待处理的图像小还很多。二维平面结构元素由一个数值为0或1的矩阵组成。结构元素的原点指定了图像中需要处理的像素范围,结构元素中数值为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所示。

    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所示。

    图6.1     元素

    图6.2     包含

    图6.3     击中

    图6.4     不击中

    5.         补集

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

    图6.5     补集的示意图

    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所示。

    图6.6     对称集的示意图

    图6.7     平移的示意图

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

    6.1 腐蚀
    把结构元素B平移a后得到Ba,若Ba包含于X,我们记下这个a点,所有满足上述条件的a点组成的集合称做X被B腐蚀(Erosion)的结果。用公式表示为:E(X)={a| Ba  X}=X  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)
     
    {
     
           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点组成的集合称做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)
     
    {
     
           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),即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)
     
    {
     
           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.结果:使二值图像减小一圈。

     


    --------------------- 
    作者:minushuang 
    来源:CSDN 
    原文:https://blog.csdn.net/minushuang/article/details/50435689 
    版权声明:本文为博主原创文章,转载请附上博文链接!

    展开全文
  • //图像处理中最基本的形态学运算————膨胀与腐蚀。形态学操作就是基于形状的一系列图像处理操作。最基本的操作有两种:膨胀与腐蚀。 //功能:1 消除噪声 // 2 分割出独立的图像元素,在图像连接相邻的元素 // ...
    //图像处理中最基本的形态学运算————膨胀与腐蚀。形态学操作就是基于形状的一系列图像处理操作。最基本的操作有两种:膨胀与腐蚀。
    //功能:1 消除噪声 
    //      2 分割出独立的图像元素,在图像中连接相邻的元素
    //      3 寻找图像中的明显的极大值区域或者极小值区域
    //      4 求出图像的梯度
    //需注意的是: 腐蚀与膨胀是对白色部分(高亮部分)而言的,不是黑色。膨胀是图像中的高亮部分进行膨胀,效果图拥有比原图更大的高亮区域。
    //即膨胀就是求局部最大值的操作,相当于核与原图的卷积过程中,求核所覆盖的区域的像素点最大值,并把这个最大值赋值给参考点所指定的元素
    //腐蚀是原图中的高亮部分被腐蚀,类似于“领域被蚕食”,效果图拥有比原图更小的高亮区域,这个过程与膨胀的过程正好相反。所以腐蚀就是求
    //局部最小值的操作。
    
    int main()
    {
    	Mat image = imread("1.jpg", 1);// 载入图片
    	namedWindow("【原图】膨胀操作");
    	namedWindow("【效果图】膨胀操作");
    	imshow("【原图】膨胀操作", image);
    	Mat element = getStructuringElement(MORPH_RECT, Size(15, 15));//获取自定义核
    	Mat out1;
    	Mat out2;
    
    	dilate(image, out1, element);//进行膨胀操作
    	erode(image, out2, element);//进行腐蚀操作
    	imshow("【效果图】膨胀操作", out1);
    	imshow("【效果图】腐蚀操作", out2);
    	waitKey(0);
    	return 0;
    }

    展开全文
  •  数字图像处理中的形态学处理是指将数字形态学作为工具从图像提取对于表达和描绘区域形状有用处的图像分量,比如边界、骨架以及凸壳,还包括用于预处理或后处理的形态学过滤、细化和修剪等。图像形态学处理我们...

    图像的腐蚀与膨胀

    一、原理:

    ⑴ 图像形态学处理的概念
            数字图像处理中的形态学处理是指将数字形态学作为工具从图像中提取对于表达和描绘区域形状有用处的图像分量,比如边界、骨架以及凸壳,还包括用于预处理或后处理的形态学过滤、细化和修剪等。图像形态学处理中我们感兴趣的主要是二值图像。

    ⑵ 二值图像的逻辑运算
            逻辑运算尽管本质上很简单,但对于实现以形态学为基础额图像处理算法是一种有力的补充手段。在图像处理中用到的主要逻辑运算是:与、或和非(求补),它们可以互相组合形成其他逻辑运算。

    ⑶ 膨胀和腐蚀

            膨胀和腐蚀这两种操作是形态学处理的基础,许多形态学算法都是以这两种运算为基础的。

    定义结构元素B为:

    1 1
    1 0
    图像元素与结构元素相乘,从而求得右下角元素值
    (i-1,j+1) (i,j+1)
    (i-1,j) 所求此点(i,j)

    ① 膨胀
    ⑴ 用结构元素B,扫描图像A的每一个像素
    ⑵ 用结构元素与其覆盖的二值图像做“或”操作
    ⑶ 如果有一个元素为0,结果图像的该像素为0。否则为255

    ② 腐蚀
             对Z中的集合A和B,B对A进行腐蚀的整个过程如下: 
    ⑴ 用结构元素B,扫描图像A的每一个像素
    ⑵ 用结构元素与其覆盖的二值图像做“与”操作
    ⑶ 如果都为0,结果图像的该像素为0。否则为255

    腐蚀处理的结果是使原来的二值图像减小一圈。

    二、我再加一个轮廓提取,非常简单的方法:用的是9X9的模板;

    (i-1,j+1) (i,j+1) (i+1,j+1)
    (i-1,j) 所求此点(i,j) (i+1,j)
    (i-1,j-1) (i,j-1) (i+1,j_1)
    三、代码

    #include<opencv2/opencv.hpp>
    #include<iostream>
    using  namespace cv;
    using namespace std;
    
    Mat srcImage, grayImage, binarygray, erosion, dilation, outline;
    
    
    static void g_erosion(int, void*);
    static void g_dilation(int, void*);
    static void g_outline(int, void*);
    static void ShowHelpText();
    
    int main()
    {
    	system("color 3f");
    	ShowHelpText();
    
    	srcImage = imread("D://vvoo//cell.jpg");
    	cvtColor(srcImage, grayImage, CV_RGB2GRAY);
    
    	int threshold;
    	cout << "input threshold: " << endl;
    	cin >> threshold;
    
    	//二值化
    	binarygray = Mat::zeros(grayImage.rows, grayImage.cols, grayImage.type());
    	{
    		for (int i = 0; i <grayImage.rows; i++)
    		{
    			for (int j = 0; j < grayImage.cols; j++)
    			{
    				if (grayImage.data[i*grayImage.step + j] > threshold)
    				{
    					binarygray.data[i*binarygray.step + j] = 255;
    				}
    				else
    				{
    					binarygray.data[i*binarygray.step + j] = 0;
    				}
    			}
    		}
    	}
    	//腐蚀
    	g_erosion(0, 0);
    	//膨胀
    	g_dilation(0, 0);
    	//轮廓提取
    	g_outline(0, 0);
    
    	imshow("原图", srcImage);
    	imshow("binarygray", binarygray);
    
    	waitKey(0);
    	return 0;
    }
    static void g_erosion(int, void*)
    {
    	erosion = Mat::zeros(binarygray.rows, binarygray.cols, binarygray.type());
    	{
    		for (int i = 1; i < binarygray.rows; i++)
    		{
    			for (int j = 1; j < binarygray.cols; j++)
    			{
    				if (binarygray.data[(i - 1)*binarygray.step + j] + binarygray.data[(i - 1)*binarygray.step + j + 1] + binarygray.data[i*binarygray.step + j + 1] == 0)
    				{
    					erosion.data[i*erosion.step + j] = 0;
    				}
    				else
    				{
    					erosion.data[i*erosion.step + j] = 255;
    				}
    			}
    
    		}
    
    	}
    	imshow("erosion_1", erosion);
    }
    static void g_dilation(int, void*)
    {
    	dilation = Mat::zeros(binarygray.rows, binarygray.cols, binarygray.type());
    
    	for (int i = 1; i < binarygray.rows; i++)
    	{
    		for (int j = 1; j < binarygray.cols; j++)
    		{
    			if (binarygray.data[(i - 1)*binarygray.step + j] == 0 || binarygray.data[(i - 1)*binarygray.step + j - 1] == 0 || binarygray.data[i*binarygray.step + j + 1] == 0)
    			{
    				dilation.data[i*dilation.step + j] = 0;
    			}
    			else
    			{
    				dilation.data[i*dilation.step + j] = 255;
    			}
    		}
    
    	}
    
    	imshow("dilation_1", dilation);
    }
    static void g_outline(int, void*)
    {
    	outline = Mat::zeros(binarygray.rows, binarygray.cols, binarygray.type());
    
    	for (int i = 1; i < binarygray.rows; i++)
    	{
    		for (int j = 1; j < binarygray.cols; j++)
    		{
    			if (binarygray.data[i*binarygray.step + j + 1] + binarygray.data[(i - 1)*binarygray.step + j]
    				+ binarygray.data[i*binarygray.step + j - 1] + binarygray.data[(i - 1)*binarygray.step + j - 1]
    				+ binarygray.data[(i + 1)*binarygray.step + j - 1] + binarygray.data[(i + 1)*binarygray.step + j]
    				+ binarygray.data[(i - 1)*binarygray.step + j + 1] + binarygray.data[(i + 1)*binarygray.step + j + 1] == 2040)
    			{
    				outline.data[i*erosion.step + j] = 255;
    			}
    			if (binarygray.data[i*binarygray.step + j + 1] + binarygray.data[(i - 1)*binarygray.step + j]
    				+ binarygray.data[i*binarygray.step + j - 1] + binarygray.data[(i - 1)*binarygray.step + j - 1]
    				+ binarygray.data[(i + 1)*binarygray.step + j - 1] + binarygray.data[(i + 1)*binarygray.step + j]
    				+ binarygray.data[(i - 1)*binarygray.step + j + 1] + binarygray.data[(i + 1)*binarygray.step + j + 1] == 0)
    			{
    				outline.data[i*erosion.step + j] = 255;
    			}
    		}
    
    
    	}
    	imshow("outline", outline);
    }
    static void ShowHelpText()
    {
    	cout << "\n\n本程序涉及到:"<<"腐蚀(erosion)、膨胀(dilation)、轮廓提取(outline)。\n\n" << endl;
    }
    四、运行结果




    五、调用Opencv的erode()函数和dilate()函数实现腐蚀和膨胀功能

    1)erode函数,使用像素邻域内的局部极小运算符来腐蚀一张图片,从src输入,由dst输出。支持就地(in-place)操作。

    看一下函数原型:

     void erode(
      InputArray src,
      OutputArray dst,
      InputArray kernel,
      Point anchor=Point(-1,-1),
      int iterations=1,
      int borderType=BORDER_CONSTANT,
      const Scalar& borderValue=morphologyDefaultBorderValue()
     );

    参数原型

    • 第一个参数,InputArray类型的src,输入图像,即源图像,填Mat类的对象即可。图像通道的数量可以是任意的,但图像深度应为CV_8U,CV_16U,CV_16S,CV_32F或 CV_64F其中之一。
    • 第二个参数,OutputArray类型的dst,即目标图像,需要和源图片有一样的尺寸和类型。
    • 第三个参数,InputArray类型的kernel,腐蚀操作的内核。若为NULL时,表示的是使用参考点位于中心3x3的核。我们一般使用函数 getStructuringElement配合这个参数的使用。getStructuringElement函数会返回指定形状和尺寸的结构元素(内核矩阵)。(具体看上文中浅出部分dilate函数的第三个参数讲解部分)
    • 第四个参数,Point类型的anchor,锚的位置,其有默认值(-1,-1),表示锚位于单位(element)的中心,我们一般不用管它。
    • 第五个参数,int类型的iterations,迭代使用erode()函数的次数,默认值为1。
    • 第六个参数,int类型的borderType,用于推断图像外部像素的某种边界模式。注意它有默认值BORDER_DEFAULT。
    • 第七个参数,const Scalar&类型的borderValue,当边界为常数时的边界值,有默认值morphologyDefaultBorderValue(),一般我们不用去管他。需要用到它时,可以看官方文档中的createMorphologyFilter()函数得到更详细的解释。

    同样的,使用erode函数,一般我们只需要填前面的三个参数,后面的四个参数都有默认值。而且往往结合getStructuringElement一起使用。

    2)dilate函数原型

    函数原型:

    C++: void dilate(
      InputArray src,
      OutputArray dst,
      InputArray kernel,
      Point anchor=Point(-1,-1),
      int iterations=1,
      int borderType=BORDER_CONSTANT,
      const Scalar& borderValue=morphologyDefaultBorderValue() 
    );

    参数详解:

    • 第一个参数,InputArray类型的src,输入图像,即源图像,填Mat类的对象即可。图像通道的数量可以是任意的,但图像深度应为CV_8U,CV_16U,CV_16S,CV_32F或 CV_64F其中之一。
    • 第二个参数,OutputArray类型的dst,即目标图像,需要和源图片有一样的尺寸和类型。
    • 第三个参数,InputArray类型的kernel,膨胀操作的核。若为NULL时,表示的是使用参考点位于中心3x3的核。

    我们一般使用函数 getStructuringElement配合这个参数的使用。getStructuringElement函数会返回指定形状和尺寸的结构元素(内核矩阵。其中,getStructuringElement函数的第一个参数表示内核的形状,我们可以选择如下三种形状之一:

    矩形: MORPH_RECT

      • 交叉形: MORPH_CROSS
      • 椭圆形: MORPH_ELLIPSE

    而getStructuringElement函数的第二和第三个参数分别是内核的尺寸以及锚点的位置。

    3)代码实现

    #include<opencv2/opencv.hpp>
    #include<iostream>
    using  namespace cv;
    using namespace std;
    
    #define WINDOWN_NAME_1 "原图"
    #define WINDOWN_NAME_2 "腐蚀图"
    #define WINDOWN_NAME_3 "膨胀图"
    
    int main()
    {
    	Mat srcImage = imread("D://vvoo//cell.jpg");
    
    	//获取自定义核
    	Mat element = getStructuringElement(MORPH_RECT, Size(15, 15));
    	Mat out_erosion, out_dilate;
    
    	//进行膨胀操作
    	erode(srcImage, out_erosion, element);
    	dilate(srcImage, out_dilate, element);
    
    	imshow(WINDOWN_NAME_1, srcImage);
    	imshow(WINDOWN_NAME_2, out_erosion);
    	imshow(WINDOWN_NAME_3, out_dilate);
    
    	waitKey(0);
    	return 0;
    
    }

    4)运行结果



    和自己写的比较下比较一下,差别比较大,主要是因为结构元素大小的关系,我的是2*2,Opencv是15*15的。

    我也是初学者,欢迎纠正!



    六、参考资料

    1.system("color 3f");//输出窗口和字体颜色可变化,3代表窗口颜色(绿色),f代表窗口里字体颜色(白色)

    全部颜色为:


    2.图像腐蚀、膨胀、细化基本原理

    3. 形态学图像处理(一): 膨胀与腐蚀

    展开全文
  • 用3x3的结构元素,扫描图像的每一个像素,用结构元素与其覆盖的二值图像做“与”操作:如果都为1,结果图像的该像素为1。否则为0。 结果:使二值图像减小一圈 B}Í S = { x,y | SxyÄ定义:E = B   膨胀的算法: ...

    腐蚀的算法:

    用3x3的结构元素,扫描图像的每一个像素,用结构元素与其覆盖的二值图像做“与”操作:如果都为1,结果图像的该像素为1。否则为0。

    结果:使二值图像减小一圈

    B}Í S = { x,y | SxyÄ定义:E = B

     

    膨胀的算法:

    用3x3的结构元素,扫描图像的每一个像素,用结构元素与其覆盖的二值图像做“与”操作:如果都为0,结果图像的该像素为0。否则为1

    结果:使二值图像扩大一圈

     S = { x,y | Sxy∩B ≠Ф}Å定义:E = B 

    void erode_image(IplImage * src,IplImage * dst)
    {	
    	if(src == NULL || dst == NULL)
    		return;
    	
    	int width = src->width;
    	int height = src->height;
    
    	//水平方向的腐蚀
    	for (int i=0;i < src->height;i++)
    	{
    		for (int j=1;j < src->width - 1;j++)
    		{
    		//	data = ((uchar *)(src->imageData + src->widthStep * i))[j];
    			if(((uchar *)(src->imageData + src->widthStep * i))[j] == 0)
    			{
    				((uchar *)(dst->imageData + dst->widthStep * i))[j] = 0;
    				for (int k=0;k < 3;k++)
    				{
    				//	data = ((uchar *)(src->imageData + src->widthStep * i))[j + k -1];
    					if(((uchar *)(src->imageData + src->widthStep * i))[j + k -1] == 255)
    					{
    						((uchar *)(dst->imageData + dst->widthStep * i))[j] = 255;
    						break;
    					}
    				}
    			}
    			else
    				((uchar *)(dst->imageData + dst->widthStep * i))[j] = 255;
    		}
    	}
    	//垂直方向的腐蚀
    	for (int i=0;i < dst->width;i++)
    	{
    		for (int j=1;j < dst->height - 1;j++)
    		{
    			//	data = ((uchar *)(src->imageData + src->widthStep * i))[j];
    			if(((uchar *)(dst->imageData + dst->widthStep * j))[i] == 0)
    			{
    				((uchar *)(src->imageData + src->widthStep * j))[i] = 0;
    				for (int k=0;k < 3;k++)
    				{
    					//	data = ((uchar *)(src->imageData + src->widthStep * i))[j + k -1];
    					if(((uchar *)(dst->imageData + dst->widthStep * (j + k -1)))[i] == 255)
    					{
    						((uchar *)(src->imageData + src->widthStep * j))[i] = 255;
    						break;
    					}
    				}
    			}
    			else
    				((uchar *)(src->imageData + src->widthStep * j))[i] = 255;
    		}
    	}
    }	
    void dilate_image(IplImage * src,IplImage * dst)
    {	
    	if(src == NULL || dst == NULL)
    		return;
    
    	int width = src->width;
    	int height = src->height;
    
    	//水平方向的膨胀
    	for (int i=0;i < src->height;i++)
    	{
    		for (int j=1;j < src->width - 1;j++)
    		{
    			if(((uchar *)(src->imageData + src->widthStep * i))[j] == 255)
    			{
    				((uchar *)(dst->imageData + dst->widthStep * i))[j] = 255;
    				for (int k=0;k < 3;k++)
    				{
    					if(((uchar *)(src->imageData + src->widthStep * i))[j + k -1] == 0)
    					{
    						((uchar *)(dst->imageData + dst->widthStep * i))[j] = 0;
    						break;
    					}
    				}
    			}
    			else
    				((uchar *)(dst->imageData + dst->widthStep * i))[j] = 0;
    		}
    	}
    	//垂直方向的膨胀
    	for (int i=0;i < dst->width;i++)
    	{
    		for (int j=1;j < dst->height - 1;j++)
    		{
    			//	data = ((uchar *)(src->imageData + src->widthStep * i))[j];
    			if(((uchar *)(dst->imageData + dst->widthStep * j))[i] == 255)
    			{
    				((uchar *)(src->imageData + src->widthStep * j))[i] = 255;
    				for (int k=0;k < 3;k++)
    				{
    					//	data = ((uchar *)(src->imageData + src->widthStep * i))[j + k -1];
    					if(((uchar *)(dst->imageData + dst->widthStep * (j + k -1)))[i] == 0)
    					{
    						((uchar *)(src->imageData + src->widthStep * j))[i] = 0;
    						break;
    					}
    				}
    			}
    			else
    				((uchar *)(src->imageData + src->widthStep * j))[i] = 0;
    		}
    	}
    }
    image = cvLoadImage(filename,CV_LOAD_IMAGE_GRAYSCALE);
    		dst1 = cvCreateImage(cvSize(image->width,image->height),image->depth,image->nChannels);
    		
    		dilate_image(image,dst1);
    		erode_image(image,dst1);
    
    		cvSaveImage(str,image);

    原图


    结果



    展开全文
  • 图像处理 腐蚀 膨胀 细化
  • 图像形态学即数学形态学(Mathematical morphology)是一门建立在格伦和拓扑学基础上的图像分析学科,是数学形态学图像处理的基本理论; 常见图像形态学运算:腐蚀、膨胀、开运算、闭运算、骨架抽取、极线腐蚀、击中...
  • 上一期:医学图像处理 ——形态学图像处理 在上一期我们揭开了形态学处理的帷幕并介绍了相关的二值图像集合的基本逻辑运算,这一期我们从形态处理最基本的两个应用(膨胀和腐蚀)膨胀开讲。是不是听着就很...
  • 图像膨胀处理

    2018-11-28 09:57:35
    所谓的图片的膨胀处理,其实就是在图像的边缘添加像素值,使得整体的像素值扩张,进而达到图像膨胀效果,也可以说是信号与系统书所提到的像素插值处理。 1、首先打开MATLAB软件,在其主界面的编辑器写入下列...
  • 形态学(morphology)一词通常表示生物学的一个分支,该分支主要研究动植物的形态和结构,而我们图像处理中指的形态学,往往表示的是数学形态学,下面一起来了解数学形态学的概念。 数学形态学(Mathematical ...
  • 腐蚀与膨胀基本原理:就是用一个特定的结构元素来与待处理图像按像素做逻辑操作;可以理解成拿一个带孔的网格板(结构元素矩阵元素为1的为孔)盖住图像的某一部分,然后按照各种不同的观察方式来确定操作类型。 ...
  • //-------------------------------------------------------- 膨胀 其实,膨胀就是求局部最大值的操作。...按数学方面来说,膨胀或者腐蚀操作就是将图像(或图像的一部分区域,我们称之为A)与核(我们
  • 图像膨胀(Dilation)和腐蚀(Erosion)是两种基本的形态学运算,主要用来寻找图像中的极大区域和极小区域。其中膨胀类似于“领域扩张”,将图像中的高亮区域或白色部分进行扩张,其运行结果图比原图的高亮区域更...
  • 这里,我们使用同一词语表示数学形态学的内容,将数学形态学作为工具从图像中提取表达和描绘区域形状的有用图像分量,如边界、骨架和凸壳等。 形态学处理主要针对的是二值图像(0或1)。 形态学通常使用图像腐蚀和...
  • 形态学在数字图像处理中表示的是图像的数学形态里的内容,将数学形态学作为工具从图像提取区域图像形状的有用的图像分量,如边缘、骨架,区域分割等。 如例: 如例: 如例: 2、数学形态学的语言是集合论。这个...
  • 图像膨胀(Dilation)和腐蚀(Erosion)是两种基本的形态学运算,主要用来寻找图像中的极大区域和极小区域。其中膨胀类似于“领域扩张”,将图像中的高亮区域或白色部分进行扩张,其运行结果图比原图的高亮区域更...
  • 参考:【数字图像处理学习笔记之四】图像腐蚀、膨胀:https://blog.csdn.net/zhougynui/article/details/51834725 1 背景知识 结构元素:二维结构元素可以理解成一个二维矩阵,矩阵元素的值为0或者1;通常结构元素...
  • 形态学(morphology)一...其基本的运算包括:二值腐蚀和膨胀、二值开闭运算、骨架抽取、极限腐蚀、击中击不变换、形态学梯度、Top-hat变换、颗粒分析、流域变换、灰值腐蚀和膨胀、灰值开闭运算、灰值形态学梯度等。
1 2 3 4 5 ... 20
收藏数 12,974
精华内容 5,189