精华内容
下载资源
问答
  • 图像处理 腐蚀膨胀算法
  • 传统的腐蚀膨胀算法会在一定层度上改变图像,为消除这一影响,在该算法基础上又设计了一种对比采样的方法,将原图像与初步处理过的图像进行对比,得到最终图像。结果表明在:此方法能够在基本不改变原图的情况下有效...
  • 本篇文章我要写的是基于的腐蚀膨胀算法实现腐蚀膨胀是形态学图像处理的基础 腐蚀在二值图像的基础上做收缩或细化操作膨胀在二值图像的基础上做加长 或变粗的操作那么什么是二值图像呢把一幅图片看做成一个二维的数组...
  • 传统的腐蚀膨胀算法会在一定程度上改变图像,为消除这一影响,在该算法基础上又设计了一种对比采样的方法,将原图与初步处理过的图像进行对比,得到最终图像。结果表明:此方法能够在基本不改变原图的情况下有效地...
  • 本篇文章要分享的是基于MATLAB的腐蚀膨胀算法实现,腐蚀膨胀是形态学图像处理的基础,腐蚀在二值图像的基础上做“收缩”或“细化”操作,膨胀在二值图像的基础上做“加长”或“变粗”的操作。 什么是二值图像呢?把...

    本篇文章要分享的是基于MATLAB的腐蚀膨胀算法实现,腐蚀膨胀是形态学图像处理的基础,腐蚀在二值图像的基础上做“收缩”或“细化”操作,膨胀在二值图像的基础上做“加长”或“变粗”的操作。

      什么是二值图像呢?把一幅图片看做成一个二维的数组,那么二值图像是一个只有0和1的逻辑数组,我们前面Sobel边缘检测后的图像输出边缘效果,设置个阈值,大于阈值输出为1,小于阈值输出为0,最后输出就是一幅二维图像了。

    腐蚀

      腐蚀是一种消除边界点,使边界向内部收缩的过程。可以用来消除小且无意义的物体。用3X3的结构元素,扫描图像的每一个像素,用结构元素与其覆盖的二值图像做“与”操作,如果都为1,结果图像的该像素为1。否则为0。结果会使二值图像小一圈。

      有一个形象的比喻来可以说明该运算,用0表示蛀虫,1表示大米。蛀虫腐蚀大米的过程便是腐蚀运算,

    v2-fae8aec3c2738c29068dc0c51c38990d_b.jpg

    腐蚀

    如图所示,对于一个像素矩阵而言,只要有蛀虫(0)的存在,大米(1)就会被腐蚀掉了,即使只存在一个蛀虫(0),但是还是会被蛀虫腐蚀完毕,最后一幅图上面由于没有蛀虫(0)所以大米完好无损。

    关于算法的实现,可以用下式子来表示,即3x3像素的运算:

    P = P11 & P12 & P13 & P21 & P22 & P23 & P31 & P32 & P33

    在FPGA中,为了通过面积去换速度,我们将上式改变如下:                       

    P1 = P11 & P12 & P13

    P2 = P21 & P22 & P23

    P3 = P31 & P32 & P33

    P = P1 & P2 & P3

    MATLAB中可以直接写一个按位或运算。


    膨胀

      膨胀是将与物体接触的所有背景点合并到该物体中,使边界向外部扩张的过程。可以用来填补物体中的空洞。用3X3的结构元素,扫描图像的每一个像素,用结构元素与其覆盖的二值图像做“与”操作,如果都为0,结果图像的该像素为0,。否则为1。结果使二值图像扩大一圈。

      先腐蚀后膨胀的过程称为开运算。用来消除小物体、在纤细点处分离物体、平滑较大物体的边界的同时并不明显的改变其面积。先膨胀后腐蚀的过程称为比运算,用来填充物体内细小空间、连接邻近物体、平滑其边界的同时并不明显改变其面积。

      膨胀算法用最简单的比喻来描述:0表示害虫,1表示青蛙,青蛙吃了害虫表示膨胀运算,我们用3*3像素阵列来解释:

    v2-dea1ffba01bf049cbf70e712bc62cd68_b.jpg

    膨胀

    如图所示,图左只有害虫(0),所以害虫都活着,中间那个图,虽然只有一个害虫,但是还是会被青蛙全部吃掉,最右边的那幅图,都是青蛙,所以青蛙始终是青蛙。

    关于算法的实现,可以用下式子来表示,即3x3像素的运算:

    P = P11 | P12 | P13 | P21 | P22 | P23 | P31 | P32 | P33

    在HDL中,为了通过面积去换速度,我们将上式改变如下:                             

    P1 = P11 | P12 | P13

    P2 = P21 | P22 | P23

    P3 = P31 | P32 | P33

    P = P1 | P2 | P3

    MATLAB中可以直接写一个按位与运算。

    开运算闭运算

      先腐蚀后膨胀叫开运算,开运算的作用是清除图像边缘周围非边缘的细小的点。先膨胀后腐蚀为闭运算,闭运算的作用是清除图像内部的空洞,

      如果我们的目标物体外面有很多无关的小区域,就用开运算去除掉;如果物体内部有很多小黑洞,就用闭运算填充掉。

    MATLAB逻辑运算函数

    bitand(), 对十进制数进行逐位逻辑与运算:先将十进制数转换成二进制数,然后逐位与运算,其运算结果转换为十进制。

    bitor(), 对十进制数进行逐位逻辑或运算:先将十进制数转换成二进制数,然后逐位与运算,其运算结果转换为十进制。

    MATLAB代码实现

    需要了解代码的私聊我,发你。(这就不再复制了)

    处理后结果对比

    为了可以清晰的看到图像边缘的变化,我们把黑色作为背景,白色作为边缘。


    v2-21d008ade544ce5a55e3c68a50c145d7_b.jpg

    Sobel边缘检测后的lena

    v2-352feb115898c62f837c6f392e12d72f_b.jpg

    腐蚀后的lena


    v2-929f1cf9f430902dc17f2106f9712846_b.jpg

    膨胀后的lena


    v2-c6e930ecac632267be000747728e19e4_b.jpg

    先腐蚀后膨胀开运算lena


    v2-826b83ecfba777b11e0bd3d61b9d6fbb_b.jpg

    先膨胀后腐蚀闭运算lena

      从上面两幅图可以看出,腐蚀后的图像边缘明显变细,消除了更多假边缘,在腐蚀基础上使用膨胀算法的lena将腐蚀后的边缘扩大、加粗,这样看起来更清楚。

    展开全文
  • 形态学运算中腐蚀膨胀开运算和闭运算 (针对二值图而言 ) 6.1 腐蚀 腐蚀是一种消除边界点使边界向内部收缩的过程可以用来消除小且无意义的物体 腐蚀的算法 用 3x3 的结构元素扫描图像的每一个像素 用结构元素与其...
  • Matlab 基于腐蚀膨胀的边缘检测 文/天神 一.课题背景 形态学运算只针对二值图像二进制图像并依据数学形态学Mathermatical Morphogy集合论方法发展起来 的图像处理方法起源于岩相对岩石结构的定量描述工作在数字...
  • 本文基于《OpenCV-Python图像矩阵不扩充边界腐蚀膨胀函数处理算法探究》介绍算法的基础上,用Python 的矩阵操作模拟实现了OpenCV灰度图的腐蚀和膨胀的自定义函数,并在图像处理中,使用OpenCV的膨胀和腐蚀函数和...

    ☞ ░ 前往老猿Python博客 https://blog.csdn.net/LaoYuanPython

    一、引言

    在《OpenCV-Python图像矩阵不扩充边界腐蚀膨胀函数处理算法探究:https://blog.csdn.net/LaoYuanPython/article/details/109283825》介绍了OpenCV图像腐蚀膨胀具体实现算法,在本节我们将用Python模拟实现OpenCV的图像腐蚀膨胀,结合相关代码,有助于大家更加清晰的理解腐蚀膨胀以及图像卷积的具体原来和算法。

    本文是老猿关于图像腐蚀与膨胀系列博文之一,也是最后一篇,该系列包括如下博文:

    1. OpenCV-Python图像处理:腐蚀和膨胀原理及erode、dilate函数介绍:https://blog.csdn.net/LaoYuanPython/article/details/109441709
    2. OpenCV-Python腐蚀膨胀函数erode、dilate使用详解:https://blog.csdn.net/LaoYuanPython/article/details/109477130
    3. OpenCV-Python图像矩阵不扩充边界腐蚀膨胀函数处理算法探究:https://blog.csdn.net/LaoYuanPython/article/details/109283825
    4. OpenCV图像腐蚀膨胀算法的Python模拟实现:
      https://blog.csdn.net/LaoYuanPython/article/details/109407091

    二、关于实现的一些处理思路

    本次介绍的图像腐蚀膨胀算法模拟实现,有如下特殊处理:

    1. 对于边界扩充处理,只采用固定填0值的边界扩充处理模式;
    2. 对边界是否扩充的处理,程序对源矩阵的处理都采用在其上部和下部各扩充核矩阵高度减一行数据,对左边和右边各扩充核矩阵宽度减一列数据,但二者扩充数据填值不同,对于扩边模式,采用固定填值为0,对于非扩边模式,填值为np.NaN无效数字值,当运算时,对于np.NaN值不参与运算处理,这样就等于没有扩充边界,具体请参考代码中的matirxKernalOp函数;
    3. 对于卷积处理运算,运算过程是对源矩阵当前处理位置返回与卷积核矩阵相同大小的矩阵进行后续运算,然后当前位置往前移动一个位置(先按列移动,移动到矩阵最右时下移一行),具体实现请参考movKernalGetNextCoverMatrix函数;
    4. 在进行腐蚀和膨胀处理时,处理分为扩边和不扩边两种模式,分别调用OpenCV函数和自定义函数进行处理, 处理完之后对比两种模式处理结果,看结果是否相同来核实自定义函数的算法正确性,具体实现请参考kernalAndAnchorTest函数。

    三、代码

    
    
    import cv2,sys
    import numpy as np
    
    def print2DMatrix(matrix):
        """
        将2阶矩阵按照行和列方式打印输出每个元素
        :param matrix: 需要打印的矩阵
        :return: None
        """
        if len(matrix.shape)!=2:
            print("只能输出一阶矩阵的信息,传入实参不是一阶矩阵,退出!")
            return None
    
        x,y = matrix.shape
        for i in range(x):
            print(" ")
            for j in range(y):
                if matrix[i][j]==np.NaN:print(f' NAN',end=' ')
                if matrix.dtype in(np.uint8,np.uint,np.uint16,np.uint32):print(f'{matrix[i][j]:4d}',end='\t')
                else:print(f'{matrix[i][j]:4f}',end='\t')
        print("\n")
    
    def movKernalGetNextCoverMatrix(matrix,kernal,anchor):
        """
        movKernalGetNextCoverMatrix为生成器函数:
        以卷积矩阵kernal对源矩阵matrix进行卷积处理,处理时从matrix的零行零列的当前位置开始,按列和行将kernal矩阵左上角
        与matrix的当前位置重合,重合后yield返回kernal矩阵锚点anchor对应的matrix位置、matrix矩阵与kernal重合部分的matrix子矩阵,
        以方便后续继续对该子矩阵进行锚点对应位置的值计算
        由于自定义方式程序效率不高,所以处理过程中每处理一行数据就会输出处理进度
        :param matrix:源矩阵
        :param kernal:核矩阵
        :param anchor:核矩阵锚点,为(-1,-1)表示核矩阵中心为锚点
        :return:
        """
        print(f"开始处理矩阵卷积,矩阵大小:{matrix.shape}")
        matrixH,matrixW = matrix.shape
        kernalH,kernalW = kernal.shape
    
        if anchor==(-1,-1):
            anchor = (int(kernalW/2),int(kernalH/2))
        elif (anchor[0]<0) or (anchor[1]<0) or (anchor[0]>=kernalW) or (anchor[1]>=kernalH) :
            raise ValueError("matirxKernalOp函数中,锚点坐标非法")
    
        if (len(matrix.shape)!=2) and (len(kernal.shape)!=2):
            raise ValueError("源矩阵和核都必须是二阶矩阵")
        if (matrixW<=kernalW) or (matrixH<=kernalH):
            raise ValueError("核矩阵的长和宽都必须小于源矩阵的长和宽")
        rowMax = matrixH - kernalH + 1
        colMax = matrixW-kernalW+1
        for row in range(rowMax):
            inf = f"\r进度:{row*100.0/rowMax:.2f}%"
            print(inf,end='')
            #sys.stdout.flush()
            for col in range(colMax):
                yield row+anchor[1],col+anchor[0],matrix[row:row+kernalH,col:col+kernalW]
        print(f"\n矩阵卷积处理完成")
    
    
    
    def matirxKernalOp(matrix,kernal,op='+'): #anchor
        """
        使用matrix和kernal两个相同大小的矩阵进行运算,返回运算结果,具体运算由运算符决定。
        运算时,先进行两个矩阵的乘法得到一个积矩阵,当为加法时,将积矩阵所有元素相加返回,当腐蚀时,取积矩阵所有元素非0值的最小值返回,
        当膨胀时,取积矩阵所有元素非0值的最大值返回。但上述运算过程如果积矩阵元素值为np.NaN无效值时(实际上由于matrix对应位置为无效
        值导致积矩阵对应位置元素无效,这种情况是用于卷积处理时对没有采用扩充边界模式计算源矩阵边界元素位置的卷积值的特殊处理),该元素则不参与运算。
        :param matrix: 源矩阵
        :param kernal: 核矩阵
        :param anchor: 该参数已废弃
        :param op: +为加法,&为腐蚀,|为膨胀
        :return: 锚点对应矩阵元素卷积处理结果
        """
    
        if op not in '&|+':raise ValueError("matirxKernalOp函数的运算符参数错误,运算符必须为:+、&、|")
        result = 0
        if op == '&':#腐蚀
            result = 999999999
        elif op=='|':#膨胀
            result = -1
    
        if matrix.shape!=kernal.shape:
            raise ValueError("matirxKernalOp函数中,参数两个矩阵大小不同")
        if kernal.shape[1]%2==0:
            raise ValueError("matirxKernalOp函数中,参数kernal矩阵宽不为奇数")
        if kernal.shape[0]%2==0:
            raise ValueError("matirxKernalOp函数中,参数kernal矩阵高不为奇数")
        """if anchor==(-1,-1):
            anchor = (int(kernal.shape[1]/2),int(kernal.shape[0]/2))
        elif (anchor[0]<0) or (anchor[1]<0):
            raise ValueError("matirxKernalOp函数中,锚点坐标非法")"""
        k = kernal.astype(matrix.dtype) #确保乘法处理时两个矩阵类型一致
        dest = cv2.multiply(matrix, k)
    
        for x in range(kernal.shape[0]):
            for y in range(kernal.shape[1]):
                if kernal[x,y]==0:continue #核位置无有效值
                if dest[x][y]==np.NaN:continue #不扩边情况下该位置已经超出源矩阵位置所以不参与运算
                if op=='+': #如果是卷积加则有效值相加
                    result += dest[x][y]
                elif op=='&':#如果腐蚀取所有有效值的最小值
                    result = min([result,dest[x][y]])
                elif op=='|': #如果膨胀取所有有效值最大值
                    result = max([result,dest[x][y]])
        if result in [-1,999999999]:#没有找到有效单元值
            #if kernal[anchor[0],anchor[1]]:return matrix[anchor[0],anchor[1]]
            if result==-1:#如果膨胀返回0
                return 0
            else:return 255#如果腐蚀返回255
    
        return result
    
    def extendMatrixKernalOp(matrix,kernal,anchor,op='+',bExtend=True):
        """
        :param matrix: 源矩阵
        :param kernal: 核矩阵
        :param anchor: 核的锚点
        :param op: 运算符,+表示kernal对matrix进行卷积得到的各像素值相加,&为腐蚀,|为膨胀
        :param bExtend:是否扩充边界
        :return:卷积处理结果矩阵
        """
        w = kernal.shape[1]-1
        h = kernal.shape[0]-1
        mh,mw = matrix.shape[0:2]
        if bExtend:
            extendMatrix = cv2.copyMakeBorder(matrix, h, h, w, w,borderType=cv2.BORDER_CONSTANT, value=0)
        else:
            shape = (mh+2*h,mw+2*w)
            extendMatrix = np.full(shape,np.NaN)
            extendMatrix[h:mh+h,w:mw+w] = matrix #np.array(matrix,extendMatrix.dtype)
    
        nh,nw = extendMatrix.shape[0:2]
    
        if op=='&':
            dest = np.array(extendMatrix)
        else:
            dest = np.zeros(extendMatrix.shape, extendMatrix.dtype)
        for row, col, m in movKernalGetNextCoverMatrix(extendMatrix, kernal, anchor):
            #print(row,col,m.shape,extendMatrix.shape)
            dest[row, col] = matirxKernalOp(m, kernal,  op)
        return dest[h:nh-h,w:nw-w].astype(np.uint8)
    
    
    
    
    def myErode(matrix,kernal,anchor=(-1,-1),bExtend=True):
        """
        自定义腐蚀运算函数
        :param matrix: 需要进行腐蚀处理的图像源矩阵
        :param kernal: 核矩阵
        :param anchor: 锚点
        :param bExtend: 是否扩充边界
        :return: 腐蚀处理结果矩阵
        """
        return extendMatrixKernalOp(matrix,kernal,anchor,'&',bExtend)
    
    def myDilate(matrix,kernal,anchor=(-1,-1),bExtend=True):
        """
        自定义膨胀运算函数
        :param matrix: 需要进行膨胀处理的图像源矩阵
        :param kernal: 核矩阵
        :param anchor: 锚点
        :param bExtend: 是否扩充边界
        :return: 膨胀处理结果矩阵
        """
    
        return extendMatrixKernalOp(matrix,kernal,anchor,'|',bExtend)
    
    def myConvolution(matrix,kernal,anchor=(-1,-1)):
        """
        自定义卷积加运算函数
        :param matrix: 需要进行卷积加处理的图像源矩阵
        :param kernal: 核矩阵
        :param anchor: 锚点
        :return: 卷积加处理结果矩阵
        """
    
        return extendMatrixKernalOp(matrix,kernal,anchor,'+',False)
    
    def kernalAndAnchorTest(img,kernal,anchor):
        """
        测试函数,对图像进行腐蚀和膨胀,处理分为扩边和不扩边两种模式,分别调用OpenCV函数和自定义函数进行处理,
        处理完之后对比两种模式处理结果看结果是否相同。
        :param img:
        :return:
        """
        if isinstance(img, str): img = cv2.imread(img, cv2.IMREAD_GRAYSCALE)
        print("图像矩阵前10行10列内容如下:")
        print2DMatrix(img[0:10, 0:10])
        print("核矩阵内容如下:")
        print2DMatrix(kernal)
        print('anchor=',anchor)
        imgErode = cv2.erode(img, kernal, anchor=anchor, borderType=cv2.BORDER_CONSTANT, borderValue=0)
        myImgErode = myErode(img, kernal, anchor=anchor)
        cmpMatrix = myImgErode == imgErode
        if cmpMatrix.all():
            print("myImgErode=imgErode,扩充0边界腐蚀结果图像矩阵内容如下:")
            print2DMatrix(imgErode[0:10,0:10])
            cv2.imshow('imgErodeEdge', imgErode)
    
        else:
            print("myImgErode!=imgErode,扩充0边界腐蚀结果图像矩阵内容如下:")
            print2DMatrix(imgErode[0:10,0:10])
            print('扩充0边界自定义腐蚀结果图像矩阵内容如下:')
    
            print2DMatrix(myImgErode[0:10,0:10])
    
        imgDilate = cv2.dilate(img, kernal, anchor=anchor, borderType=cv2.BORDER_CONSTANT, borderValue=0)
        myImgDilate = myDilate(img, kernal, anchor=anchor)
        cmpMatrix = imgDilate == myImgDilate
        if cmpMatrix.all():
            print("imgDilate = myImgDilate,扩充0边界膨胀结果图像矩阵内容如下:")
            print2DMatrix(imgDilate[0:10,0:10])
            cv2.imshow('imgDilateEdge', imgDilate)
        else:
            print("imgDilate != myImgDilate,扩充0边界膨胀结果图像矩阵内容如下:")
            print2DMatrix(imgDilate[0:10,0:10])
    
            print('扩充0边界自定义膨胀结果图像矩阵内容如下:')
            print2DMatrix(myImgDilate[0:10,0:10])
        ###################################
    
        imgErode = cv2.erode(img, kernal, borderType=cv2.BORDER_ISOLATED, anchor=anchor)
    
        """for bordtype in [0,1,2,4,16]:
            imgErode = cv2.erode(img, rectElement, borderType=bordtype,anchor=anchor)
            print2DMatrix(imgErode)"""
    
        myImgErode = myErode(img, kernal, anchor,False)
        imgDilate = cv2.dilate(img, kernal,borderType=cv2.BORDER_ISOLATED, anchor=anchor)
        myImgDilate = myDilate(img, kernal, anchor,False)
    
        cmpMatrix = myImgErode==imgErode
        if cmpMatrix.all():
            print("不扩边myImgErode=imgErode,不扩边腐蚀结果图像矩阵内容如下:")
            print2DMatrix(imgErode[0:10,0:10])
            cv2.imshow('imgErodeNoEdge',imgErode)
        else:
            print("不扩边myImgErode!=imgErode,不扩边腐蚀结果图像矩阵内容如下:")
            print2DMatrix(imgErode[0:10,0:10])
            print('不扩边自定义腐蚀结果图像矩阵内容如下:')
            print2DMatrix(myImgErode[0:10,0:10])
    
        cmpMatrix = imgDilate == myImgDilate
        if cmpMatrix.all():
            print("不扩边imgDilate = myImgDilate,不扩边膨胀结果图像矩阵内容如下:")
            print2DMatrix(imgDilate[0:10,0:10])
            cv2.imshow('imgDilateNoEdge', imgDilate)
        else:
            print("不扩边imgDilate != myImgDilate,不扩边膨胀结果图像矩阵内容如下:")
            print2DMatrix(imgDilate[0:10,0:10])
            print('不扩边自定义膨胀结果图像矩阵内容如下:')
            print2DMatrix(myImgDilate[0:10,0:10])
        cv2.waitKey(0)
    
    def main():
        #构建图像源矩阵
        img = np.zeros((5, 5), dtype=np.uint8)
        img[2, 2] = img[3, 3] = img[3, 4] = 1
    
        #设定锚点
        anchor = (-1, -1)
    
        #设定核矩阵
    
        kernal = np.zeros((3, 3), np.uint8)
        kernal[0, 0] = kernal[1, 1] = 1
    
        kernalAndAnchorTest(img,kernal,anchor)  # (r'F:\pic\imgs.jpg')
    
    main()
    
    

    四、运行输出

    图像矩阵前1010列内容如下:
     
       0	   0	   0	   0	   0	 
       0	   0	   0	   0	   0	 
       0	   0	   1	   0	   0	 
       0	   0	   0	   1	   1	 
       0	   0	   0	   0	   0	
    
    核矩阵内容如下:
     
       1	   0	   0	 
       0	   1	   0	 
       0	   0	   0	
    
    anchor= (-1, -1)
    开始处理矩阵卷积,矩阵大小:(9, 9)
    进度:85.71%
    矩阵卷积处理完成
    myImgErode=imgErode,扩充0边界腐蚀结果图像矩阵内容如下:
     
       0	   0	   0	   0	   0	 
       0	   0	   0	   0	   0	 
       0	   0	   0	   0	   0	 
       0	   0	   0	   1	   0	 
       0	   0	   0	   0	   0	
    
    开始处理矩阵卷积,矩阵大小:(9, 9)
    进度:85.71%
    矩阵卷积处理完成
    imgDilate = myImgDilate,扩充0边界膨胀结果图像矩阵内容如下:
     
       0	   0	   0	   0	   0	 
       0	   0	   0	   0	   0	 
       0	   0	   1	   0	   0	 
       0	   0	   0	   1	   1	 
       0	   0	   0	   0	   1	
    
    开始处理矩阵卷积,矩阵大小:(9, 9)
    进度:85.71%
    矩阵卷积处理完成
    开始处理矩阵卷积,矩阵大小:(9, 9)
    进度:85.71%
    矩阵卷积处理完成
    不扩边myImgErode=imgErode,不扩边腐蚀结果图像矩阵内容如下:
     
       0	   0	   0	   0	   0	 
       0	   0	   0	   0	   0	 
       0	   0	   0	   0	   0	 
       0	   0	   0	   1	   0	 
       0	   0	   0	   0	   0	
    
    不扩边imgDilate = myImgDilate,不扩边膨胀结果图像矩阵内容如下:
     
       0	   0	   0	   0	   0	 
       0	   0	   0	   0	   0	 
       0	   0	   1	   0	   0	 
       0	   0	   0	   1	   1	 
       0	   0	   0	   0	   1	
    
    
    Process finished with exit code 0
    

    矩阵打印输出时,没有判断矩阵是否超过10行10列,都是按10行10列提示的。

    五、使用真正图像进行测试

    5.1、原始图像

    在这里插入图片描述

    5.2、测试代码修改

    def main():
        #设定锚点
        anchor = (-1, -1)
    
        #设定核矩阵
        kernal = cv2.getStructuringElement(cv2.MORPH_RECT,(3, 3),anchor)
    
        kernalAndAnchorTest(r'F:\pic\imgs.jpg',kernal,anchor)
    
    

    5.3、程序运行输出

    打印输出内容如下:

    图像矩阵前1010列内容如下:
     
     251	 253	 255	 254	 134	 255	 247	 255	 255	 255	 
     178	 154	 162	 186	 166	 255	 254	 249	 255	 255	 
     255	 246	 255	 244	 240	 253	 255	 252	 255	 255	 
     245	 252	 255	 247	 255	 254	 251	 254	 255	 255	 
     253	 254	 250	 254	 255	 252	 241	 254	 255	 255	 
     255	 250	 242	 252	 252	 255	 246	 253	 255	 255	 
     251	 255	 252	 255	 248	 252	 255	 254	 255	 255	 
     253	 255	 247	 255	 250	 250	 255	 246	 255	 255	 
     255	 255	 255	 255	 255	 255	 255	 255	 255	 255	 
     255	 255	 255	 255	 255	 255	 255	 255	 255	 255	
    
    核矩阵内容如下:
     
       1	   1	   1	 
       1	   1	   1	 
       1	   1	   1	
    
    anchor= (-1, -1)
    开始处理矩阵卷积,矩阵大小:(604, 724)
    进度:99.83%
    矩阵卷积处理完成
    myImgErode=imgErode,扩充0边界腐蚀结果图像矩阵内容如下:
     
       0	   0	   0	   0	   0	   0	   0	   0	   0	   0	 
       0	 154	 154	 134	 134	 134	 247	 247	 249	 255	 
       0	 154	 154	 162	 166	 166	 249	 249	 249	 255	 
       0	 245	 244	 240	 240	 240	 241	 241	 252	 255	 
       0	 242	 242	 242	 247	 241	 241	 241	 253	 255	 
       0	 242	 242	 242	 248	 241	 241	 241	 253	 255	 
       0	 242	 242	 242	 248	 246	 246	 246	 246	 255	 
       0	 247	 247	 247	 248	 248	 246	 246	 246	 255	 
       0	 247	 247	 247	 250	 250	 246	 246	 246	 255	 
       0	 255	 255	 255	 255	 255	 255	 255	 255	 255	
    
    开始处理矩阵卷积,矩阵大小:(604, 724)
    进度:99.83%
    矩阵卷积处理完成
    imgDilate = myImgDilate,扩充0边界膨胀结果图像矩阵内容如下:
     
     253	 255	 255	 255	 255	 255	 255	 255	 255	 255	 
     255	 255	 255	 255	 255	 255	 255	 255	 255	 255	 
     255	 255	 255	 255	 255	 255	 255	 255	 255	 255	 
     255	 255	 255	 255	 255	 255	 255	 255	 255	 255	 
     255	 255	 255	 255	 255	 255	 255	 255	 255	 255	 
     255	 255	 255	 255	 255	 255	 255	 255	 255	 255	 
     255	 255	 255	 255	 255	 255	 255	 255	 255	 255	 
     255	 255	 255	 255	 255	 255	 255	 255	 255	 255	 
     255	 255	 255	 255	 255	 255	 255	 255	 255	 255	 
     255	 255	 255	 255	 255	 255	 255	 255	 255	 255	
    
    开始处理矩阵卷积,矩阵大小:(604, 724)
    进度:99.83%
    矩阵卷积处理完成
    开始处理矩阵卷积,矩阵大小:(604, 724)
    进度:99.83%
    矩阵卷积处理完成
    不扩边myImgErode=imgErode,不扩边腐蚀结果图像矩阵内容如下:
     
     154	 154	 154	 134	 134	 134	 247	 247	 249	 255	 
     154	 154	 154	 134	 134	 134	 247	 247	 249	 255	 
     154	 154	 154	 162	 166	 166	 249	 249	 249	 255	 
     245	 245	 244	 240	 240	 240	 241	 241	 252	 255	 
     245	 242	 242	 242	 247	 241	 241	 241	 253	 255	 
     250	 242	 242	 242	 248	 241	 241	 241	 253	 255	 
     250	 242	 242	 242	 248	 246	 246	 246	 246	 255	 
     251	 247	 247	 247	 248	 248	 246	 246	 246	 255	 
     253	 247	 247	 247	 250	 250	 246	 246	 246	 255	 
     255	 255	 255	 255	 255	 255	 255	 255	 255	 255	
    
    不扩边imgDilate = myImgDilate,不扩边膨胀结果图像矩阵内容如下:
     
     253	 255	 255	 255	 255	 255	 255	 255	 255	 255	 
     255	 255	 255	 255	 255	 255	 255	 255	 255	 255	 
     255	 255	 255	 255	 255	 255	 255	 255	 255	 255	 
     255	 255	 255	 255	 255	 255	 255	 255	 255	 255	 
     255	 255	 255	 255	 255	 255	 255	 255	 255	 255	 
     255	 255	 255	 255	 255	 255	 255	 255	 255	 255	 
     255	 255	 255	 255	 255	 255	 255	 255	 255	 255	 
     255	 255	 255	 255	 255	 255	 255	 255	 255	 255	 
     255	 255	 255	 255	 255	 255	 255	 255	 255	 255	 
     255	 255	 255	 255	 255	 255	 255	 255	 255	 255
    

    从上述输出可以看出,自定义腐蚀和膨胀函数和OpenCV对应输入的腐蚀和膨胀函数的真正处理图像也是一致的。

    5.4、图像处理效果

    扩边腐蚀图像:

    在这里插入图片描述

    不扩边腐蚀图像:

    在这里插入图片描述

    扩边膨胀图像:

    在这里插入图片描述

    不扩边膨胀图像:

    在这里插入图片描述

    六、小结

    本文基于《OpenCV-Python图像矩阵不扩充边界腐蚀膨胀函数处理算法探究:https://blog.csdn.net/LaoYuanPython/article/details/109283825》介绍算法的基础上,用Python 的矩阵操作模拟实现了OpenCV灰度图的腐蚀和膨胀的自定义函数,并在图像处理中,使用OpenCV的膨胀和腐蚀函数和自定义函数的处理结果进行了对比,来验证了自定义函数的正确性。通过自定义函数的实现,结合上节介绍的算法,有助于大家深入理解OpenCV图像腐蚀和膨胀的机制。

    不过注意,本文的实现仅基于灰度图,另外对于核全0的情况没有考虑。

    写作不易,敬请支持:

    如果阅读本文于您有所获,敬请点赞、评论、收藏,谢谢大家的支持!可以通过点击博文下面的一键三连按钮实现对相关文章的点赞、收藏和对博客的关注,谢谢!

    更多OpenCV-Python的介绍请参考专栏《OpenCV-Python图形图像处理 》
    专栏网址https://blog.csdn.net/laoyuanpython/category_9979286.html

    关于老猿的付费专栏

    老猿的付费专栏《使用PyQt开发图形界面Python应用 》(https://blog.csdn.net/laoyuanpython/category_9607725.html)专门介绍基于Python的PyQt图形界面开发基础教程,付费专栏《moviepy音视频开发专栏》 (https://blog.csdn.net/laoyuanpython/category_10232926.html)详细介绍moviepy音视频剪辑合成处理的类相关方法及使用相关方法进行相关剪辑合成场景的处理,两个专栏都适合有一定Python基础但无相关知识的小白读者学习。

    付费专栏文章目录:《moviepy音视频开发专栏文章目录》(https://blog.csdn.net/LaoYuanPython/article/details/107574583)、《使用PyQt开发图形界面Python应用专栏目录 》(https://blog.csdn.net/LaoYuanPython/article/details/107580932)。

    对于缺乏Python基础的同仁,可以通过老猿的免费专栏《专栏:Python基础教程目录》(https://blog.csdn.net/laoyuanpython/category_9831699.html)从零开始学习Python。

    如果有兴趣也愿意支持老猿的读者,欢迎购买付费专栏。

    跟老猿学Python、学OpenCV!

    ☞ ░ 前往老猿Python博文目录 https://blog.csdn.net/LaoYuanPython

    展开全文
  • MATLAB三维形态学腐蚀膨胀操作代码。做三维形态学操作的时候,没找到MATLAB自带的函数,所以自己写了一个。

    (MATLAB)三维形态学腐蚀膨胀算法(代码)

    by HPC_ZY

    MATLAB三维形态学腐蚀膨胀操作代码。做三维形态学操作的时候,没找到MATLAB自带的函数,所以自己写了一个。

    膨胀

    膨胀比较简单,总之就是原始图像某一位置为1时,把周围的全置为1

    %% 三维膨胀
    function out = dilate3d(in,r)
    
    [R,C,S] = size(in);
    % 生成球形结构元
    [se,n,rx,ry,rz] = strel3d(r);
    
    out = false(R,C,S);
    for i = 1+rx:R-rx
        for j = 1+ry:C-ry
            for k = 1+rz:S-rz
                if in(i,j,k) == 1                
                    for idx = 1:n
                        out(i+se(idx,1),j+se(idx,2),k+se(idx,3)) = 1;
                    end
                end
            end
        end
    end
    
    end
    

    腐蚀

    与膨胀相反,当原始图像某邻域范围内全为1,中心点才能置为1

    %% 三维腐蚀
    function out = erode3d(in,r)
    % 生成球形结构元
    [R,C,S] = size(in);
    [se,n,rx,ry,rz] = strel3d(r);
    
    out = false(R,C,S);
    for i = 1+rx:R-rx
        for j = 1+ry:C-ry
            for k = 1+rz:S-rz
                out(i,j,k) = 1;
                for idx = 1:n
                    if in(i+se(idx,1),j+se(idx,2),k+se(idx,3))<1
                        out(i,j,k) = 0;
                        break;                    
                    end
                end                                   
            end
        end
    end
    
    end
    

    结构元与其他函数

    生成结构元的函数,建议三个方向半径一致。
    注:由于此处结构元特殊的判定方式,当三个方向半径不一致时,最终尺寸不一定等于用户输入的尺寸,但大体形态是相同的

    %% 生成三维球形结构元
    function [se,n,rx,ry,rz] = strel3d(r)
    
    % 判断用户输入半径
    if length(r)<2
        rx = r;
        ry = r;
        rz = r;
    elseif length(r)>2
        rx = r(1);
        ry = r(2);
        rz = r(3);
    else
        rx = r(1);
        ry = r(1);
        rz = r(2);
    end
    
    % 生成球形二值图 并获得目标索引
    [x,y,z] = meshgrid(-rx:rx,-ry:ry,-rz:rz);
    [x,y,z] = find3d(sqrt(x.^2+y.^2+z.^2)<(rx+ry+rz)/2.5); % 注意这里的判定方式
    se = [x-rx-1,y-ry-1,z-rz-1];
    
    n = size(se,1);
    
    end
    

    find3函数(类似MATLAB自带的find,但这里是三维的)

    %% 找到满足条件的值,类似MATLAB自带的find,但这里是三维的
    function [x,y,z] = find3d(in)
    
    [M,N,~] = size(in);
    
    idx = find(in);
    
    z = ceil(idx/M/N);
    idx = idx-(z-1)*M*N;
    y = ceil(idx/M);
    x = idx-(y-1)*M;
    
    end
    

    测试

    clear; close all; clc
    
    %% 生成测试图像(三维)
    im = zeros(50,50,50);
    im(20:30,20:30,10:40) = 1;
    
    %% 形态学操作
    % 膨胀
    im1 = dilate3d(im,5);
    
    % 腐蚀
    im2 = erode3d(im,3);
    im3 = erode3d(im,[3,3,10]);
    
    %% 显示结果
    viewer3d(im,double(im1),im,double(im2),im,double(im3))
    % 注意,仅仅运行到这里,是什么都不会显示的哦
    % viewer3d是可视化界面,你得和它互动,要显示什么你的自己学。
    % 这个东西怎么用,就参考“其他=2.关于viewer3d函数”
    

    测试结果如下,其中 红色为原始模型,绿色为操作后模型,黄色为重叠部分
    在这里插入图片描述


    其他

    1. 为了简便易理解,所以没有进行优化,运行速度一般
    2. 关于viewer3d函数,可查看另一篇文章
    3. 三维开闭运算可以组合腐蚀膨胀实现,这里就不贴代码了
    4. 如果有其他问题或需求,欢迎评论区留言或私信
    展开全文
  • 1.图像膨胀的Matlab实现:可以使用imdilate函数进行图像膨胀,imdilate函数需要两个基本输入参数,即待处理的输入图像和结构元素对象。结构元素对象可以是strel函数返回的对象,也可以是一个自己定义的表示结构元素...

    1.图像膨胀的Matlab实现:

    可以使用imdilate函数进行图像膨胀,imdilate函数需要两个基本输入参数,即待处理的输入图像和结构元素对象。结构元素对象可以是strel函数返回的对象,也可以是一个自己定义的表示结构元素邻域的二进制矩阵。此外,imdilate还可以接受两个可选参数:PADOPT(padopt) ——影响输出图片的大小、PACKOPT(packopt).——说明输入图像是否为打包的二值图像(二进制图像)。举个实例如下:

    步骤1,首先创建一个包含矩形对象的二值图像矩阵。

    >> BW=zeros(9,10);

    >> BW(4:6,4:7) =1

    BW =

    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 0 0 0 0

    0 0 0 1 1 1 1 0 0 0

    0 0 0 1 1 1 1 0 0 0

    0 0 0 1 1 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 0 0 0 0 0 0 0

    步骤2,使用一个3×3的正方形结构元素对象对创建的图像进行膨胀。

    >> SE=strel('square',3)

    SE =

    Flat STREL object containing 9 neighbors.

    Neighborhood:

    1 1 1

    1 1 1

    1 1 1

    步骤3,将图像BW和结构元素SE传递给imdilate函数。

    >> BW2=imdilate(BW,SE)

    BW2 =

    0 0 0 0 0 0 0 0 0 0

    0 0 0 0 0 0 0 0 0 0

    0 0 1 1 1 1 1 1 0 0

    0 0 1 1 1 1 1 1 0 0

    0 0 1 1 1 1 1 1 0 0

    0 0 1 1 1 1 1 1 0 0

    0 0 1 1 1 1 1 1 0 0

    0 0 0 0 0 0 0 0 0 0

    0 0 0 0 0 0 0 0 0 0

    步骤4,显示结果。

    >> imshow(BW,'notruesize')

    >> imshow(BW2,'notruesize')

    2.图像腐蚀的Matlab实现:

    可以使用imerode函数进行图像腐蚀。imerode函数需要两个基本输入参数:待处理的输入图像以及结构元素对象。此外,imerode函数还可以接受3个可选参数:PADOPT(padopt) ——影响输出图片的大小、PACKOPT(packopt).——说明输入图像是否为打包的二值图像(二进制图像)。M——指定原始图像的行数。

    以下程序示例说明了如何对某一副具体图像进行腐蚀操作,腐蚀前后的效果对比如图末。

    步骤1,读取图像cameraman.tif (该图像是Matlab当前目录下自带的图片)

    >> BW1=imread('cameraman.tif');

    步骤2,创建一个任意形状的结构元素对象

    >> SE=strel('arbitrary',eye(5));

    步骤3,以图像BW1和结构元素SE为参数调用imerode函数进行腐蚀操作。

    >> BW2=imerode(BW1,SE);

    步骤4,显示操作结果

    >> imshow(BW1)

    >> figure,imshow(BW2)

    3.膨胀和腐蚀联合操作(图像开运算操作):

    下面以图像开启为例,说明如何综合使用imdilate和imerode这两个函数,实现图像处理操作。

    步骤1,创建结构元素:

    >> clear;close all

    >> SE = strel('rectangle',[40 30]); %注意:结构元素必须具有适当的大小,既可以删电流线又可以删除矩形.

    步骤2,使用结构元素腐蚀图像: %将会删除所有直线,但也会缩减矩形

    >> BW1=imread('circbw.tif');

    >> BW2=imerode(BW1,SE);

    >> imshow(BW2)

    >> figure,imshow(BW1)

    步骤3,恢复矩形为原有大小,使用相同的结构元素对腐蚀过的图像进行膨胀.

    >> BW3=imdilate(BW2,SE);

    >> figure,imshow(BW3)

    4.基于膨胀与腐蚀的形态操作——骨架化和边缘检测

    (1)骨架化:

    某些应用中,针对一副图像,希望对图像中所有对象简化为线条,但不修改图像的基本结构,保留图像基本轮廓,这个过程就是所谓的骨架化。提供了专门的函数bwmorph,可以实现骨架化操作。

    >> clear;close all

    >> BW1=imread('circbw.tif');

    >> BW2=bwmorph(BW1,'skel',Inf);

    >> imshow(BW1)

    >> figure,imshow(BW2)

    (2)边缘检测

    对于一副灰度二进制图像,如果图像像素值为1,则该像素的状态为ON,如果其像素值为0,则该像素的状态为OFF。在一副图像中,如果图像某个像素满足以下两个条件:

    1.该像素状态为ON,

    2.该像素邻域中有一个或多个像素状态为OFF。

    则认为该像素为边缘像素。

    Matlab中提供了专门的函数bwperim,可以用于判断一副二进制图像中的哪些像素为边缘像素。

    以下程序代码示例就是利用bwperim函数,对图像circbw.tif进行边缘检测,其边缘像素检测效果如尾图。

    >> clear;close all

    >> BW1=imread('circbw.tif');

    >> BW2=bwperim(BW1);

    >> imshow(BW1)

    >> figure,imshow(BW2)

    基于腐蚀和膨胀的形态操作函数如下:

    bwhitmiss 图像逻辑"与"操作,该函数使用一个结构元素对图像进行腐蚀操作后,再使用第二个结构元素对图像进行腐蚀操作

    imbothat 从原始图像中减去经过形态关闭后的图像,该函数可用来寻找图像中的灰度槽

    imclose 闭合操作.首先对图像进行膨胀,然后再对膨胀后的图像进行腐蚀,两个操作使用同样的结构元素

    imopen 开启操作,首先对图像进行腐蚀,然后再对腐蚀后的图像进行膨胀,两个操作使用同样的结构元素

    imtophat 从原始图像中减去形态开启后的图像,可以用来增强图像的对比度

    基于MATLAB的腐蚀膨胀算法实现

    本篇文章要分享的是基于MATLAB的腐蚀膨胀算法实现,腐蚀膨胀是形态学图像处理的基础,腐蚀在二值图像的基础上做“收缩”或“细化”操作,膨胀在二值图像的基础上做“加长”或“变粗”的操作. 什么是二值图像 ...

    基于FPGA的腐蚀膨胀算法实现

    本篇文章我要写的是基于的腐蚀膨胀算法实现,腐蚀膨胀是形态学图像处理的基础,,腐蚀在二值图像的基础上做"收缩"或"细化"操作,膨胀在二值图像的基础上做" ...

    opencv中的图像形态学——腐蚀膨胀

    腐蚀膨胀是图像形态学比较常见的处理,腐蚀一般可以用来消除噪点,分割出独立的图像元素等. 一般腐蚀操作对二值图进行处理,腐蚀操作如下图,中心位置的像素点是否与周围领域的像素点颜色一样(即是否是白色点,即 ...

    OpenCV 腐蚀膨胀操作

    利用腐蚀膨胀操作实现对椭圆周围线条的消除,椭圆的大小不变 代码如下: #include "cv.h" #include "highgui.h" int main ...

    OpenCV计算机视觉学习(5)——形态学处理(腐蚀膨胀,开闭运算,礼帽黑帽,边缘检测)

    如果需要处理的原图及代码,请移步小编的GitHub地址 传送门:请点击我 如果点击有误:https://github.com/LeBron-Jian/ComputerVisionPractice 形态 ...

    数学软件 之 基于MATLAB的DFP算法

    DFP算法是本科数学系中最优化方法的知识,也是无约束最优化方法中非常重要的两个拟Newton算法之一,上一周写了一周的数学软件课程论文,姑且将DFP算法的实现细节贴出来分享给学弟学妹参考吧,由于博客不 ...

    C&num;中调用Matlab人工神经网络算法实现手写数字识别

    手写数字识别实现 设计技术参数:通过由数字构成的图像,自动实现几个不同数字的识别,设计识别方法,有较高的识别率 关键字:二值化  投影  矩阵  目标定位  Matlab 手写数字图像识别简介: 手写 ...

    matlab实现分水岭算法处理图像分割

    此程序为优化后的分水岭算法,避免了图像过分割 I= imread('D:\Images\pic_loc\1870405130305041503.jpg'); imshow(I); h=fspecial ...

    matlab实现感知机算法--统计学习小灶

    clear all; clc; %% %算法 %输入:训练数据集T = {(x1,y1),(x2,y2),...,(xn,yn)};学习率η %输出:w,b;感知机模型f(x) = sign(w*x+ ...

    随机推荐

    从Eclipse迁移到Android Studio碰到的问题记录

    背景: 1. 一直在做.NET的开发,工作之余,学习了一下Android开发,写了一些Demo,当时用的Eclipse开发工具:这两天,刚好项目不是很忙,就打算把之前写的Demo,迁移到Android ...

    mysql客户端导入sql文件命令

    mysql -h localhost -u root -p dbname < filename

    Java 7 中的Switch 谈 Java版本更新和反编译知识

    Java 7 中的Switch 谈 Java版本更新和反编译知识          学习编程,享受生活,大家好,我是追寻梦的飞飞.今天主要讲述的是Java7中的更新Switch实现内部原理和JAD反编 ...

    EEPlat 的数据层模式

    EEPlat 的数据库底层架构能够同一时候支持多种数据库的集成应用.同一时候能够支持分布式数据库的集成应用.业务对象通过指定数据源与对应的数据库通过数据源层进行数据交互,数据源层通过数据库种类.自己主 ...

    Haystack

    什么是Haystack Haystack是django的开源全文搜索框架(全文检索不同于特定字段的模糊查询,使用全文检索的效率更高 ),该框架支持Solr,Elasticsearch,Whoosh,  ...

    Timus 1132 Square Root&lpar;二次剩余)

    http://acm.timus.ru/problem.aspx?space=1&num=1132 题意: 求 x^2 ≡ n mod p  p是质数 的 解 本题中n>=1 特判p=2 ...

    java栈的实现复习

    栈是一种线性表,仅限在一端进行插入和删除操作,特点是先进后出. 由于栈是一种线性结构,首先可以想到用数组来实现,但由于数组初始化后容量就已经确定,如果不添加扩容操作,则会出现栈溢出,同时扩容操作也会降 ...

    Python开发——数据结构【深浅拷贝】

    浅拷贝 # 浅拷贝只copy一层 s = [3,'Lucy',4,[1,2]] s1 = s.copy() 深拷贝 # 深拷贝——克隆一分 import copy s = [3,'Lucy',4,[1 ...

    jctable

    1.jctable 选择单项并删除: var items = Co["MyTable"].GetSelected("HtmlEle"); if (items.l ...

    Python&plus;OpenCV图像处理(二)——打印图片属性、设置图片存储路径、电脑摄像头的调取和显示

    一. 打印图片属性.设置图片存储路径 代码如下: #打印图片的属性.保存图片位置 import cv2 as cv import numpy as np #numpy是一个开源的Python科学计算库 ...

    展开全文
  • Matlab图像处理知识(四) ?... 上述程序主要是采用了 bwlabel 和 beselect 函数,虽然没有直接使用 Matlab 的形态学操作的膨胀腐蚀函数,但其实质过程和达到的效果是遵循形 态学操作......C=mdilate(A,...
  • 膨胀腐蚀算法

    2019-11-15 19:08:26
    膨胀腐蚀算法
  • 图像处理 膨胀腐蚀 matlab算法实现
  • 基于一维级联快速腐蚀膨胀算法

    千次阅读 2017-04-30 23:26:34
    基于一维级联快速膨胀腐蚀算法一:基本原理膨胀腐蚀是图像形态学两个基本操作之一,传统的代码实现都是基于二维窗口卷积模式,对于正常的3x3窗口要八次与运算,而基于一维级联方式先X方向后Y方向只需要4次与运算...
  • 图像处理,用于腐蚀膨胀算法,希望对大家会有帮助
  • 图像腐蚀膨胀算法

    千次阅读 2016-11-21 18:47:03
    腐蚀运算的含义:每当在目标图像中找到一个与结构元素相同的子图像时,就把该子图像中与结构元素的原点位置对应的那个像素位置标注出来,目标图像上被标注出来的所有像素组成的集合,即为腐蚀运算的结果。...
  • 腐蚀膨胀细化算法

    千次阅读 2011-03-29 11:46:00
    6.1 腐蚀 |"L o x%v M g!p0把结构元素B平移a后得到Ba,若Ba包含于X,我们记下这个a点,所有满足上述条件的a点组成的集合称做X被B腐蚀(Erosion)的结果。用公式表示为:E(X)={a| Ba X}=X B,如图6.8所示。...
  • 图像的腐蚀膨胀算法原理

    万次阅读 2017-07-25 16:08:25
    腐蚀:用结构元素B腐蚀X,过程如下: 1.用结构元素B扫描图像X的所有像素点(以B的原点为坐标,对应A的各个像素点进行扫描),用结构元素B与X覆盖的二值X图像做 “与”操作。 2.如果结构元素B为黑色的点,图像A相对应...
  • 采用形态学技术检测噪声的算法,称为数学形态学差检测法(Morphological Residues Detector, MRD。通常腐蚀运算的输出为结构兀素定义域中的最小值,膨胀运算则输出最大值;Ifu开运算滤除盐噪声,闭运算滤除椒盐噪声。
  • 分水岭算法+腐蚀膨胀

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,875
精华内容 1,950
关键字:

腐蚀膨胀算法