腐蚀膨胀_腐蚀膨胀算法 - CSDN
精华内容
参与话题
  • 图像形态学运算之腐蚀-膨胀

    千次阅读 2017-10-18 09:13:53
    在http://blog.csdn.net/piaoxuezhong/article/details/77966132中,由于睫毛等影响所以对采集的虹膜图像进行闭操作,由于形态学运算在图像预处理应用还是比较广发的,这里单独对它进行汇总说明 ...

           在http://blog.csdn.net/piaoxuezhong/article/details/77966132中,为了消除睫毛等对边缘识别的影响,对采集的虹膜图像进行闭操作,由于形态学运算在图像预处理中应用还是比较广泛的,本篇单独进行总结。

    • 形态学简介:

          形态学指的是对象的形式和结构,或说是对象中各个部分之间的布局和相互关系,形态学和形状相关,数码形态学指的是一种对数字对象的形状的描述和分析(摘自《图像处理及计算机视觉算法及应用,第二版》)。1964年法国学者在积分几何的研究成果上,将数学形态学引入图像处理领域,并研制了基于数学形态学的图像处理系统。1982年出版的专著《Image Analysis and Mathematical Morphology》表明数学形态学在理论上的完备和在应用上的深入。目前,数学形态学已在计算机视觉、信号处理与图像分析、模式识别、计算方法与数据处理等方面得到了极为广泛的应用。在图像处理方面,数学形态学可以用于抑制噪声、特征提取、边缘检测、图像分割、形状识别、纹理分析、图像恢复与重建、图像压缩等问题。

    • 形态学分类:

          数学形态学背后的数学理论是集合论,图像是由一组图片元素组成的,这些像素组合起来组成二维结构,即是形状。其基本思想是用具有一定形态的结构元素去度量和提取图像中的对应形状,从而达到对图像分析和识别的目的。数学形态学的应用可以简化图像数据,但保持基本的形状特征,除去不相干的结构。数学形态学的基本运算有4种:膨胀、腐蚀、开启和闭合。基于这些基本运算还可以推导和组合成其他数学形态学实用算法。

         形态学的运算背后的概念有连通性(就是常说的4邻域,8邻域等概念),二值操作等,这些图像处理里的基本知识,不多说了,下面进入正题吧:膨胀与腐蚀。

    • 图像膨胀

    膨胀,就是用一个核去扫描原图,即卷积,用核所覆盖区域的最大像素值代替锚点位置的像素。核函数生成一般使用getStructuringElement函数,返回指定形状和尺寸的结构元素。

    int g_nStructElementSize = 3; //内核矩阵的尺寸  
    Mat element = getStructuringElement(MORPH_RECT,  
        Size(2*g_nStructElementSize+1,2*g_nStructElementSize+1),  
        Point( g_nStructElementSize, g_nStructElementSize ));  
    其中,getStructuringElement函数的第一个参数表示内核的形状,可以选择一下三种形状之一:
    矩形: MORPH_RECT、交叉形: MORPH_CROSS、椭圆形:MORPH_ELLIPSE;
    getStructuringElement函数的第二和第三个参数分别是内核的尺寸以及锚点的位置。对于锚点的位置,默认值为Point(-1,-1),表示锚点位于中心;并且交叉形的element形状唯一依赖于锚点的位置,其他情况下,锚点只影响形态学运算结果的偏移。


    opencv实现函数:

    void cv::dilate( InputArray src,OutputArray dst, InputArray kernel,  
                     Point anchor, int iterations,  
                     int borderType, constScalar& borderValue )  
    {  
       morphOp( MORPH_DILATE, src, dst, kernel, anchor, iterations, borderType,borderValue );  
    }  
    实例:

    #include <opencv2/core/core.hpp>  
    #include<opencv2/highgui/highgui.hpp>  
    #include<opencv2/imgproc/imgproc.hpp>  
    #include <iostream>  
    
    using namespace std;
    using namespace cv;
    
    int main()
    {
    	Mat image = imread("desertEagle.jpg");
    
    	namedWindow("【原图】膨胀操作");
    	namedWindow("【效果图】膨胀操作");
    
    	imshow("【原图】膨胀操作", image);
    	Mat element = getStructuringElement(MORPH_RECT, Size(5, 5));
    	Mat out;
    	dilate(image, out, element);
    	imshow("【效果图】膨胀操作", out);
    
    	waitKey(0);
    	return 0;
    }

    • 图像腐蚀

    腐蚀,是用一个核去扫描原图,即卷积,用核所覆盖区域的最小像素值代替锚点位置的像素。opencv实现函数:

    void cv::erode( InputArray src, OutputArraydst, InputArray kernel,  
                    Point anchor, int iterations,  
                    int borderType, constScalar& borderValue )  
    {  
       morphOp( MORPH_ERODE, src, dst, kernel, anchor, iterations, borderType,borderValue );  
    }  
    实例:

    #include <opencv2/core/core.hpp>  
    #include<opencv2/highgui/highgui.hpp>  
    #include<opencv2/imgproc/imgproc.hpp>  
    #include <iostream>  
    
    using namespace std;
    using namespace cv;
    
    int main()
    {
    	Mat image = imread("desertEagle.jpg");
    
    	namedWindow("【原图】腐蚀操作");
    	namedWindow("【效果图】腐蚀操作");
    
    	imshow("【原图】腐蚀操作", image);
    	Mat element = getStructuringElement(MORPH_RECT, Size(5, 5));
    	Mat out;
    	erode(image, out, element);
    	imshow("【效果图】腐蚀操作", out);
    
    	waitKey(0);
    
    	return 0;
    }

    小结:腐蚀和膨胀都是对白色部分说的,膨胀使得图像中的高亮部分进行膨胀、扩张,膨胀后图像比原图拥有更大的高亮区域。腐蚀则恰恰相反,效果图拥有比原图更小的高亮区域。腐蚀是消除物体的边界点的过程,使剩下的物体沿其周边比原物体小一个像素的面积;膨胀运算是将与某物体接触的所有背景点合并到该物体中的过程,使物体的面积增大了相应数量的点,如果两个物体在某一点的任意方向相隔少于三个像素,它们将在该点连通起来。也可以说腐蚀可以消除图像中小的噪声区域,膨胀可以填补物体中的空洞。

         开操作/闭操作

         通常情况下,含有噪声的图像二值化后,得到的边界是不平滑的,物体区域具有一些错判的孔洞,背景区域散布着一些小的噪声物体。对一个图像先进行腐蚀运算然后再膨胀的操作过程称为开运算,它可以消除细小的物体、在纤细点处分离物体、平滑较大物体的边界时不明显的改变其面积。对一个图像先膨胀然后再收缩,称为闭运算,它具有填充物体内细小的空洞、连接邻近物体、在不明显改变物体面积的情况下平滑其边界的作用。

        形态学梯度、顶帽、黑帽等操作

         其中,形态学梯度(Morphological Gradient)是指膨胀图与腐蚀图的差值,这样就可以得到边缘轮廓;

         顶帽运算(Top Hat)是指原图像与“开运算“结果图的差值,开运算可以放大裂缝或者局部低亮度的区域,原图减去开运算后的图,得到的图突出了比原图轮廓周围区域更明亮的区域。顶帽一般用于校正不均匀光照的影响(补充:均匀光照在从背景中提取目标的处理中扮演核心的角色)。

         黑帽(Black Hat)是指”闭运算“结果图与原图像的差值。黑帽运算后的效果图突出了比原图轮廓周围的区域更暗的区域。黑帽运算一般用来分离比邻近点暗一些的斑块。

         opencv中的morphologyEx函数,可以实现上述操作,源码为:

    void cv::morphologyEx( InputArray _src,OutputArray _dst, int op,  
                           InputArray kernel, Pointanchor, int iterations,  
                           int borderType, constScalar& borderValue )  
    {  
       Mat src = _src.getMat(), temp;  
       _dst.create(src.size(), src.type());  
       Mat dst = _dst.getMat();   
       switch( op )  
        {  
       case MORPH_ERODE:  
           erode( src, dst, kernel, anchor, iterations, borderType, borderValue );  
           break;  
       case MORPH_DILATE:  
           dilate( src, dst, kernel, anchor, iterations, borderType, borderValue );  
           break;  
       case MORPH_OPEN:  
           erode( src, dst, kernel, anchor, iterations, borderType, borderValue );  
           dilate( dst, dst, kernel, anchor, iterations, borderType, borderValue );  
           break;  
       case CV_MOP_CLOSE:  
           dilate( src, dst, kernel, anchor, iterations, borderType, borderValue );  
           erode( dst, dst, kernel, anchor, iterations, borderType, borderValue );  
           break;  
       case CV_MOP_GRADIENT:  
           erode( src, temp, kernel, anchor, iterations, borderType, borderValue );  
           dilate( src, dst, kernel, anchor, iterations, borderType, borderValue );  
           dst -= temp;  
           break;  
       case CV_MOP_TOPHAT:  
           if( src.data != dst.data )  
               temp = dst;  
           erode( src, temp, kernel, anchor, iterations, borderType, borderValue );  
            dilate( temp, temp, kernel, anchor,iterations, borderType, borderValue );  
           dst = src - temp;  
           break;  
       case CV_MOP_BLACKHAT:  
           if( src.data != dst.data )  
               temp = dst;  
           dilate( src, temp, kernel, anchor, iterations, borderType, borderValue);  
           erode( temp, temp, kernel, anchor, iterations, borderType, borderValue);  
           dst = temp - src;  
           break;  
       default:  
           CV_Error( CV_StsBadArg, "unknown morphological operation" );  
        }  
    }  
    morphologyEx函数根据不同的标识符采取不同的操作,对图像腐蚀和膨胀操作进行不同的运算。

    参考:

    • http://www.cnblogs.com/libing64/archive/2012/01/05/2878735.html
    • http://blog.csdn.net/poem_qianmo/article/details/24599073
    • http://blog.csdn.net/vast_sea/article/details/8192975
    • http://blog.csdn.net/qq_18343569/article/details/47816689
    • http://blog.csdn.net/TonyShengTan/article/details/42426033
    展开全文
  • 【形态学滤波】——腐蚀膨胀

    千次阅读 2019-06-21 10:40:44
    本篇文章主要用于记录python调用opencv实现图像膨胀腐蚀的算法,以及相关的知识点。 一、基础理论 二、图像腐蚀代码 三、图像膨胀代码 四、形态学处理图像常规操作 一、基础理论 1、形态学概述 图像处理中...

    本篇文章主要用于记录python调用opencv实现图像膨胀与腐蚀的算法,以及相关的知识点。

    一、基础理论

    二、图像腐蚀代码

    三、图像膨胀代码

    四、形态学处理图像常规操作


    一、基础理论

    1、形态学概述

    图像处理中的形态学往往指的是数学形态学。

    2、数学形态学

    建立在格论和拓扑学基础之上的图像分析学科,是数字形态学图像图像处理的基本理论。 其基本的运算包括二值化腐蚀和膨胀、二值开闭运算、骨架抽取、极限腐蚀、击中于击不中变换、形态学梯度、 Top-hat变换、颗粒分析、流域变换、灰度腐蚀和膨胀、灰度开闭运算、灰值形态学梯度等。

    3、膨胀与腐蚀的功能:

    消除噪声;

    分割出独立的图像元素,在图像中连接相邻的元素;

    寻找图像中的明细的极大值区域或极小值区域;

    求出图像的梯度。

    4、膨胀的概念

    从数学角度,膨胀或腐蚀就是将图像(原图中的部分区域A)与核(锚点B)进行卷积。 膨胀就是求局部最大值的操作,与B卷积,就是求B所覆盖区域的像素点的最大值,并将最大值赋给参考点指定的像素,从而增长高亮区域。其运算符为“⊕”。

                                            dst(x,y)=max(src(x+x',y+y'))             其中,(x',y‘):element(x',y’)≠0

                                                   

    5、腐蚀的概念

    dst(x,y)=min(src(x+x',y+y')) 其中,(x',y‘):element(x',y’)≠0 在python中,dst=cv2.erode(src,kernel,iterations) iterations表示迭代次数 即被扫描到的原始图像中的像素点,只有当卷积核对应的元素值均为1时,其值才为1,否则其值修改为0。 换句话说,遍历到的某个位置时,其周围全部是白色,保留白色,否则变为黑色,图像腐蚀变小。 其过程正好与膨胀相反。其运算符为"_"。

                                                    

    二、图像腐蚀代码

    import cv2
    import numpy as np
    #读取图片
    src = cv2.imread('F:/image/12.jpg', cv2.IMREAD_UNCHANGED)
    #设置卷积核
    kernel = np.ones((5,5), np.uint8)
    #图像腐蚀处理
    erosion = cv2.erode(src, kernel,iterations=1)  #iterations未出现时表示此时为1,即一次腐蚀
    #显示图像
    cv2.imshow("src", src)
    cv2.imshow("result", erosion)
    #等待显示
    cv2.waitKey(0)
    cv2.destroyAllWindows()

    其效果图如下:

    三、图像膨胀代码

    import cv2
    import numpy as np
    #读取图片
    src = cv2.imread('F:/image/12.jpg', cv2.IMREAD_UNCHANGED)
    #设置卷积核
    kernel = np.ones((3,3), np.uint8)
    #图像膨胀处理
    dil = cv2.dilate(src, kernel,iterations=1)  #iterations未出现时表示此时为1,即一次腐蚀
    #显示图像
    cv2.imshow("src", src)
    cv2.imshow("result", dil)
    #等待显示
    cv2.waitKey(0)
    cv2.destroyAllWindows()

    其效果如下:

    四、形态学处理图像常规操作

    在实际的图像去噪中,通常是先腐蚀后膨胀,即所谓的开运算。其效果相比单一操作要好许多。其效果如下:

    展开全文
  • 腐蚀膨胀 的理解 原理:在特殊领域运算形式——结构元素(Sturcture Element),在每个像素位置上与二值图像对应的区域进行特定的逻辑运算。运算结构是输出图像的相应像素。运算效果取决于结构元素大小...

    对腐蚀 和 膨胀 的理解

    原理:在特殊领域运算形式——结构元素(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  

    腐蚀源码

    膨胀

    膨胀(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  

    膨胀源码

    腐蚀运算和膨胀运算互为对偶的,用公式表示为(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。每次都是如此,直到剩最中间一列,就不能再删了。为什么会这样呢?原因是这样的处理过程只实现了水平细化,如果在每一次水平细化后,再进行一次垂直方向的细化(只要把上述过程的行列换一下),就可以了。

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

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

    细化源码

    题外话:

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

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

    算法:

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

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

    展开全文
  • OpenCV学习笔记-腐蚀膨胀

    千次阅读 2018-05-28 12:13:27
    一、腐蚀这个操作会把前景物体的边界腐蚀掉(但是前景仍然是白色)。卷积核沿着图像滑动,如果与卷积核对应的原图像的所有像素值都是1,那么中心元素就保持原来的像素值,否则就变为0。作用:1、前景物体会变小,整...

    形态学操作是根据图像形状进行的简单操作。一般情况下对二值化图像进行的操作。

    一、腐蚀

    这个操作会把前景物体的边界腐蚀掉(但是前景仍然是白色)。卷积核沿着图像滑动,如果与卷积核对应的原图像的所有像素值都是1,那么中心元素就保持原来的像素值,否则就变为0。

    作用:

    1、前景物体会变小,整幅图像的白色区域会减少,这对于去除白噪声很有用。

    2、平滑对象边缘

    3、弱化或分割图像之间的半岛型连接
    代码:

    def erode_demo(img):
        gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
        ret, thresh = cv.threshold(gray, 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)
        cv.imshow('binary iamge', thresh)
        kernel = cv.getStructuringElement(cv.MORPH_RECT, (5,5))
        dst = cv.erode(thresh, kernel=kernel)
        cv.imshow('erode_demo', dst)

    效果展示:

    二、膨胀

    与腐蚀相反,与卷积核对应的原图像的像素值中只要有一个是1,中心元素的像素值就是1。所以这个操作会增加图像中的白色区域(前景)。一般在去噪声时先用腐蚀再用膨胀。这时噪声已经去除了,不会再回来了,但是前景还在并会增加。

    作用:

    1、对象大小增加一个像素(3x3)

    2、平滑对象边缘

    3、减少或填充对象之间的距离,也可以连接两个分开的物体。

    具体代码:

    def dilate_demo(img):
        gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
        ret, thresh = cv.threshold(gray, 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)
        cv.imshow('binary iamge', thresh)
        kernel = cv.getStructuringElement(cv.MORPH_RECT, (5, 5))
        dst = cv.dilate(thresh, kernel)
        cv.imshow('dilate image', dst)

    效果展示:
    展开全文
  • 腐蚀膨胀

    千次阅读 2018-01-28 11:29:20
    结构元素:膨胀腐蚀操作的最基本组成部分,用于测试输出图像,通常要比待处理的图像小还很多。二维平面结构元素由一个数值为0或1的矩阵组成。结构元素的原点指定了图像中需要处理的像素范围,结构元
  • 数字图像处理---通俗理解腐蚀膨胀

    千次阅读 多人点赞 2018-11-08 21:35:20
    0.腐蚀膨胀有什么卵用? 腐蚀膨胀是数字形态学里的两个基本操作,一般用于二值图像(当然RGB图也可以用)。腐蚀的作用说白了就是让暗的区域变大,而膨胀的作用就是让亮的区域变大(可以想象成巴啦啦能量和古娜拉...
  • 一、腐蚀膨胀

    千次阅读 2018-11-01 15:11:21
    一、腐蚀膨胀 1、腐蚀膨胀的主要功能 (1)消除噪声 (2)分割出独立的图像元素,在图像中连接相邻的元素 (3)寻找图像中的极大值或者极小值区域 (4)求出图像的梯度 2、膨胀(dilate) 膨胀就是求局部...
  • 腐蚀膨胀基本原理:就是用一个特定的结构元素来与待处理图像按像素做逻辑操作;可以理解成拿一个带孔的网格板(结构元素矩阵中元素为1的为孔)盖住图像的某一部分,然后按照各种不同的观察方式来确定操作类型。 ...
  • 数学形态学运算——腐蚀膨胀、开运算、闭运算

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

    千次阅读 2015-10-10 20:11:19
    腐蚀膨胀(Eroding and Dilating) 目标 本文档尝试解答如下问题: 如何使用OpenCV提供的两种最基本的形态学操作,腐蚀膨胀( Erosion 与 Dilation): erodedilate 原理 Note   以下内容...
  • 形态学操作:膨胀腐蚀

    万次阅读 多人点赞 2019-12-09 10:03:31
    形态学操作其实就是改变物体的形状,比如腐蚀就是”变瘦”,膨胀就是”变胖”,看下图就明白了: 形态学操作一般作用于二值化图,来连接相邻的元素或分离成独立的元素。腐蚀膨胀是针对图片中的白色部分! ...
  • opencv-python中的腐蚀膨胀函数

    万次阅读 2017-09-04 15:22:51
    就像土壤侵蚀一样,这个操作会把前景物体的边界腐蚀掉(但是前景仍然是白色)。 这是怎么做到的呢?卷积核沿着图像滑动,如果与卷积核对应的原图像的所有像素值都是1,那么中心元素就保持原来的像素值,否则就变为零...
  • 图像的腐蚀膨胀算法原理

    千次阅读 2017-07-31 09:27:22
    腐蚀:用结构元素B腐蚀X,过程如下: 1.用结构元素B扫描图像X的所有像素点(以B的原点为坐标,对应A的各个像素点进行扫描),用结构元素B与X覆盖的二值X图像做 “与”操作。 2.如果结构元素B为黑色的点,图像A相对应...
  • 图像腐蚀与图像膨胀(Python篇)

    万次阅读 2018-11-17 11:45:07
    本文介绍图像的膨胀腐蚀的基本概念及其各自的代码实现。  1.膨胀腐蚀的基本概念  图像的膨胀(Dilation)和腐蚀(Erosion)是两种基本的形态学运算,主要用来寻找图像中的极大区域和极小区域。其中膨胀类似...
  • 膨胀腐蚀在MATLAB中

    千次阅读 2016-05-18 19:52:10
    腐蚀膨胀操作更细致的分析(主要谈论涉及图像边缘的腐蚀膨胀运算)。 注:结构元素在扫描图像中的每个像素时,结构元素的邻域有部分会在图像外面。比如当结构元素扫描图像上方第一行像素值(这里默认结构元素为3×...
  • 在学习这一部分之前,我们必须先有个明确的膨胀腐蚀的概念,就上图而言,膨胀腐蚀都是针对白色部分而不是黑色部分,膨胀就是白色区域扩大,腐蚀就是白色区域缩小 1、腐蚀 要进行腐蚀操作,我们要用到cv2....
  • 图像处理中腐蚀膨胀的原理

    万次阅读 2018-10-30 15:56:28
    腐蚀的原理: 二值图像前景物体为1,背景为0.假设原图像中有一个前景物体,那么我们用一个结构元素去腐蚀原图的过程是这样的:遍历原图像的每一个像素,然后用结构元素的中心点对准当前正在遍历的这个像素,然后取...
  • Halcon入门之腐蚀膨胀

    万次阅读 2017-07-22 00:15:08
    基本手法如下: 1、采集图像 2、预处理 3、分割 4、识别显示1、采集图像 read_image (Image, ‘D:/**‘) get_image_size (Image, Width, Height) dev_open_window(0, 0, Width, Height, ‘black’, Window...
  • 形态学滤波:腐蚀膨胀(浅谈)

    千次阅读 2018-05-17 08:19:13
    四 接下来谈谈自己对腐蚀膨胀的理解与认知 五 关于OPENCV中的膨胀和腐蚀函数 形态学滤波:腐蚀与膨胀(浅谈) 一 关于二值化、膨胀、腐蚀以及拟合椭圆中心的代码如下** bool...
  • 常用的图像形态学操作包括膨胀腐蚀、闭运算、开运算。 膨胀操作会扩大(粗化)图像中物体的轮廓,可以用来弥补(填充)物体间的孔洞,强化离散点,代价是导致物体的面积比原来的面积要大。 腐蚀操作会收缩(细化...
1 2 3 4 5 ... 20
收藏数 8,620
精华内容 3,448
关键字:

腐蚀膨胀