（自己编写函数）Python + Opencv 图像形态学处理(腐蚀、膨胀、开运算、闭运算)

最新推荐文章于 2024-03-07 10:00:07 发布
最新推荐文章于 2024-03-07 10:00:07 发布
阅读量2.2k 收藏 32
点赞数 10
分类专栏： python OpenCV
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38970783/article/details/90296102
版权

原理：

形态学运算是结构元素与图像进行逻辑运算，产生新的图像的图像处理方法。二值图像B和结构元素S是定义在笛卡儿网格上的集合，网格中值为1的点是集合的元素。

  1. 腐蚀
    定义：
    在这里插入图片描述
    算法：
    a) 用3x3的结构元素，扫描图像的每一个像素。
    b) 用结构元素与其覆盖的二值图像做“与”操作。
    c) 如果都为1，结果图像的该像素为1，否则为0。

  2. 膨胀
    定义：
    在这里插入图片描述
    算法：
    a) 用3x3的结构元素，扫描图像的每一个像素。
    b) 用结构元素与其覆盖的二值图像做“与”操作。
    c) 如果都为0，结果图像的该像素为0，否则为1。

  3. 开运算
    在这里插入图片描述
    定义： 即先腐蚀，再膨胀。
    算法：
    a) 用3x3的结构元素，对图像做腐蚀操作。
    b) 再用3x3的结构元素，对图像做膨胀操作。

  4. 闭运算
    在这里插入图片描述
    定义： 即先膨胀，再腐蚀。
    算法：
    a) 用3x3的结构元素，对图像做膨胀操作。
    b) 再用3x3的结构元素，对图像做腐蚀操作。

代码以及算法设计：

一、首先使用OSTU算法进行计算最适合的阈值，ostu算法的原理如下：

  1. 先计算图像的直方图，即将图像所有的像素点按照0~255共256个bin，统计落在每个bin的像素点数量
  2. 归一化直方图，也即将每个bin中像素点数量除以总的像素点
  3. i表示分类的阈值，也即一个灰度级，从0开始迭代
  4. 通过归一化的直方图，统计0~i 灰度级的像素(假设像素值在此范围的像素叫做前景像素) 所占整幅图像的比例w0，并统计前景像素的平均灰度u0；统计i~255灰度级的像素(假设像素值在此范围的像素叫做背景像素) 所占整幅图像的比例w1，并统计背景像素的平均灰度u1；
  5. 计算前景像素和背景像素的方差 g = w0w1(u0-u1) (u0-u1)
  6. i++；转到 4 ，直到i为256时结束迭代
  7. 将最大g相应的i值作为图像的全局阈值
#使用otsu算法思维求出阈值并对图像进行二值化处理
def myotsu(gray):
    countdown = 0
    countup = 0
    hist_new = []
    num = []
    hist_countresult = []
    hist_key = []
    hist_proresult = []
    #处理后最终输出矩阵将齐大小设置为与原图一样
    gray2=np.array([[0 for i in range(gray.shape[1])] for i in range(gray.shape[0])], dtype='float') 
    #gray1 用于统计每哥灰度级所有的个数 ，因为是列表不是矩阵，
    #所以要先将gray的灰度级矩阵变成一维列表
    gray1 = list(gray.ravel())
    #以字典的形式保存，统计出来的灰度级及其个数
    obj = dict(collections.Counter(gray1))
    obj = sorted(obj.items(),key=lambda item:item[0])
    #将统计出来的灰度级的值与他的个数分开用列表保存
    for each in obj :
        key = list(each)[0]
        num =list(each)[1]
        hist_key.append(key)
        hist_new.append(num)
    #检查从0-255每个灰度级是否都有个数，没有的话添加并将值设为0
    for i in range (0,256) :
        if i in hist_key :
            num = hist_key.index(i)
            hist_countresult.append(hist_new[num])
        else :
            hist_countresult.append(0)
    if len(hist_countresult) < 256 :
        for i in range (0,256-len(hist_countresult)) :
            hist_new.append(0)
    #计算整幅图的像素数目
    hist_sum = gray.shape[0] * gray.shape[1]
    #计算每个灰度级的像素数目占整个数目的比重
    for each in hist_countresult :
        result = float(each / hist_sum)
        hist_proresult.append(result)
    #遍历灰度级[0,255],寻找合适的threshold
    w0 = w1 = u0tmp = u1tmp = u0 = u1 = deltaTmp = deltaMax = float(0)
    for i in range (256) :
        w0 = w1 = u0tmp = u1tmp = u0 = u1 = deltaTmp = float(0)
        for j in range (256) :
            if j <= i : #背景部分
                w0 = float(w0 + hist_proresult[j])
                u0tmp += j * hist_proresult[j]
            else :  #前景部分
                w1 += float(hist_proresult[j])
                u1tmp += j * hist_proresult[j]
        if w0 == 0.0 or w1 == 0.0:
            pass
        else :
            u0 = float(u0tmp / w0)
            u1 = float(u1tmp / w1)
            deltaTmp = (float)(w0 *w1* pow((u0 - u1), 2)) 
            if deltaTmp > deltaMax : 
                deltaMax = deltaTmp
                threshold = i
    #用ostu大津算法得出最适当的阈值后，将图片进行二值化
    for i in range(gray.shape[0]) :
        for j in range(gray.shape[1]) :
             #对大于阈值的显示为255白色，小于阈值的显示为0黑色
            if gray[i][j] <= threshold :
                gray2[i][j] = 0
                countdown += 1
            else :
                gray2[i][j] = 255
                countup += 1
    return gray2

二、使用numpy模块的函数生成一个3 * 3 的矩阵

三、腐蚀：

  • a) 用3x3的结构元素，扫描图像的每一个像素。
  • b) 用结构元素与其覆盖的二值图像做“与”操作。
  • c) 如果都为1，结果图像的该像素为1，否则为0。
#腐蚀
def corrode(twovalue_img) :
    #处理后最终输出矩阵将齐大小设置为与原图一样
    gray2=np.array([[0 for i in range(twovalue_img.shape[1])] for i in range(twovalue_img.shape[0])], dtype='float') 
    #生成 3*3的结构元素
    structuralelement = np.array([[1 for i in range (3)]for i in range (3)],dtype='int')
    #使用结构元素去与原二值图像中为1的值进行与操作
    for i in range (1,twovalue_img.shape[0]-1) :
        for j in range (1,twovalue_img.shape[1]-1) :
            #添加每次处理后的元素到集合中
            list1 = []
            count1 = 0 #保存进行于操作后图中到底有几个1
            list1.append(twovalue_img[i-1][j-1] and structuralelement[0][0])
            list1.append(twovalue_img[i-1][j] and structuralelement[0][1])
            list1.append(twovalue_img[i-1][j+1] and structuralelement[0][2])
            list1.append(twovalue_img[i][j-1] and structuralelement[1][0])
            list1.append(twovalue_img[i][j] and structuralelement[1][1])
            list1.append(twovalue_img[i][j+1] and structuralelement[1][2])
            list1.append(twovalue_img[i+1][j-1] and structuralelement[2][0])
            list1.append(twovalue_img[i+1][j] and structuralelement[2][1])
            list1.append(twovalue_img[i+1][j+1] and structuralelement[2][2])
            #如果都为1，结果图像的该像素为1，否则为0。
            for each in list1 :
                if each == 1 :
                    count1 += 1
            if count1 == 9 :
                gray2[i][j] = 255
            else :
                gray2[i][j] = 0        
    return gray2

四、膨胀：

  • a) 用3x3的结构元素，扫描图像的每一个像素。
  • b) 用结构元素与其覆盖的二值图像做“与”操作。
  • c) 如果都为0，结果图像的该像素为0，否则为1。
#膨胀
def swell(twovalue_img):
    #处理后最终输出矩阵将齐大小设置为与原图一样
    gray2=np.array([[0 for i in range(twovalue_img.shape[1])] for i in range(twovalue_img.shape[0])], dtype='float') 
    #生成 3*3的结构元素
    structuralelement = np.array([[1 for i in range (3)]for i in range (3)],dtype='int')
    #使用结构元素去与原二值图像中为1的值进行与操作
    for i in range (1,twovalue_img.shape[0]-1) :
        for j in range (1,twovalue_img.shape[1]-1) :
            #添加每次处理后的元素到集合中
            list1 = []
            count1 = 0 #保存进行于操作后图中到底有几个1
            list1.append(twovalue_img[i-1][j-1] and structuralelement[0][0])
            list1.append(twovalue_img[i-1][j] and structuralelement[0][1])
            list1.append(twovalue_img[i-1][j+1] and structuralelement[0][2])
            list1.append(twovalue_img[i][j-1] and structuralelement[1][0])
            list1.append(twovalue_img[i][j] and structuralelement[1][1])
            list1.append(twovalue_img[i][j+1] and structuralelement[1][2])
            list1.append(twovalue_img[i+1][j-1] and structuralelement[2][0])
            list1.append(twovalue_img[i+1][j] and structuralelement[2][1])
            list1.append(twovalue_img[i+1][j+1] and structuralelement[2][2])
            #如果都为0，结果图像的该像素为0，否则为1。
            for each in list1 :
                if each == 1 :
                    count1 += 1
            if count1 > 0 :
                gray2[i][j] = 255
            else :
                gray2[i][j] = 0        
    return gray2

五、开运算：先腐蚀，后膨胀（直接调用两次函数即可）

  • a) 用3x3的结构元素，对图像做腐蚀操作。
  • b) 再用3x3的结构元素，对图像做膨胀操作。
#开运算
def opencalc(twovalue_img) :
    #先腐蚀，再膨胀
    corrode_pic = corrode(twovalue_img)
    open_img = swell(corrode_pic)
    return open_img

六、闭运算：先膨胀，后腐蚀（直接调用两次函数即可）

  • a) 用3x3的结构元素，对图像做膨胀操作。
  • b) 再用3x3的结构元素，对图像做腐蚀操作。
#闭运算
def closecalc(twovalue_img) :
    #先膨胀，再腐蚀
    swell_pic = swell(twovalue_img)
    close_img = corrode(swell_pic)
    return close_img

完整代码：

import matplotlib.pyplot as plt
from scipy import signal
import numpy as np
import copy as cp
import random
import math
import cv2
import collections

#使用otsu算法思维求出阈值并对图像进行二值化处理
def myotsu(gray):
    countdown = 0
    countup = 0
    hist_new = []
    num = []
    hist_countresult = []
    hist_key = []
    hist_proresult = []
    #处理后最终输出矩阵将齐大小设置为与原图一样
    gray2=np.array([[0 for i in range(gray.shape[1])] for i in range(gray.shape[0])], dtype='float') 
    #gray1 用于统计每哥灰度级所有的个数 ，因为是列表不是矩阵，
    #所以要先将gray的灰度级矩阵变成一维列表
    gray1 = list(gray.ravel())
    #以字典的形式保存，统计出来的灰度级及其个数
    obj = dict(collections.Counter(gray1))
    obj = sorted(obj.items(),key=lambda item:item[0])
    #将统计出来的灰度级的值与他的个数分开用列表保存
    for each in obj :
        key = list(each)[0]
        num =list(each)[1]
        hist_key.append(key)
        hist_new.append(num)
    #检查从0-255每个灰度级是否都有个数，没有的话添加并将值设为0
    for i in range (0,256) :
        if i in hist_key :
            num = hist_key.index(i)
            hist_countresult.append(hist_new[num])
        else :
            hist_countresult.append(0)
    if len(hist_countresult) < 256 :
        for i in range (0,256-len(hist_countresult)) :
            hist_new.append(0)
    #计算整幅图的像素数目
    hist_sum = gray.shape[0] * gray.shape[1]
    #计算每个灰度级的像素数目占整个数目的比重
    for each in hist_countresult :
        result = float(each / hist_sum)
        hist_proresult.append(result)
    #遍历灰度级[0,255],寻找合适的threshold
    w0 = w1 = u0tmp = u1tmp = u0 = u1 = deltaTmp = deltaMax = float(0)
    for i in range (256) :
        w0 = w1 = u0tmp = u1tmp = u0 = u1 = deltaTmp = float(0)
        for j in range (256) :
            if j <= i : #背景部分
                w0 = float(w0 + hist_proresult[j])
                u0tmp += j * hist_proresult[j]
            else :  #前景部分
                w1 += float(hist_proresult[j])
                u1tmp += j * hist_proresult[j]
        if w0 == 0.0 or w1 == 0.0:
            pass
        else :
            u0 = float(u0tmp / w0)
            u1 = float(u1tmp / w1)
            deltaTmp = (float)(w0 *w1* pow((u0 - u1), 2)) 
            if deltaTmp > deltaMax : 
                deltaMax = deltaTmp
                threshold = i
    #用ostu大津算法得出最适当的阈值后，将图片进行二值化
    for i in range(gray.shape[0]) :
        for j in range(gray.shape[1]) :
             #对大于阈值的显示为255白色，小于阈值的显示为0黑色
            if gray[i][j] <= threshold :
                gray2[i][j] = 0
                countdown += 1
            else :
                gray2[i][j] = 255
                countup += 1
    return gray2

#腐蚀
def corrode(twovalue_img) :
    #处理后最终输出矩阵将齐大小设置为与原图一样
    gray2=np.array([[0 for i in range(twovalue_img.shape[1])] for i in range(twovalue_img.shape[0])], dtype='float') 
    #生成 3*3的结构元素
    structuralelement = np.array([[1 for i in range (3)]for i in range (3)],dtype='int')
    #使用结构元素去与原二值图像中为1的值进行与操作
    for i in range (1,twovalue_img.shape[0]-1) :
        for j in range (1,twovalue_img.shape[1]-1) :
            #添加每次处理后的元素到集合中
            list1 = []
            count1 = 0 #保存进行于操作后图中到底有几个1
            list1.append(twovalue_img[i-1][j-1] and structuralelement[0][0])
            list1.append(twovalue_img[i-1][j] and structuralelement[0][1])
            list1.append(twovalue_img[i-1][j+1] and structuralelement[0][2])
            list1.append(twovalue_img[i][j-1] and structuralelement[1][0])
            list1.append(twovalue_img[i][j] and structuralelement[1][1])
            list1.append(twovalue_img[i][j+1] and structuralelement[1][2])
            list1.append(twovalue_img[i+1][j-1] and structuralelement[2][0])
            list1.append(twovalue_img[i+1][j] and structuralelement[2][1])
            list1.append(twovalue_img[i+1][j+1] and structuralelement[2][2])
            #如果都为1，结果图像的该像素为1，否则为0。
            for each in list1 :
                if each == 1 :
                    count1 += 1
            if count1 == 9 :
                gray2[i][j] = 255
            else :
                gray2[i][j] = 0        
    return gray2

#膨胀
def swell(twovalue_img):
    #处理后最终输出矩阵将齐大小设置为与原图一样
    gray2=np.array([[0 for i in range(twovalue_img.shape[1])] for i in range(twovalue_img.shape[0])], dtype='float') 
    #生成 3*3的结构元素
    structuralelement = np.array([[1 for i in range (3)]for i in range (3)],dtype='int')
    #使用结构元素去与原二值图像中为1的值进行与操作
    for i in range (1,twovalue_img.shape[0]-1) :
        for j in range (1,twovalue_img.shape[1]-1) :
            #添加每次处理后的元素到集合中
            list1 = []
            count1 = 0 #保存进行于操作后图中到底有几个1
            list1.append(twovalue_img[i-1][j-1] and structuralelement[0][0])
            list1.append(twovalue_img[i-1][j] and structuralelement[0][1])
            list1.append(twovalue_img[i-1][j+1] and structuralelement[0][2])
            list1.append(twovalue_img[i][j-1] and structuralelement[1][0])
            list1.append(twovalue_img[i][j] and structuralelement[1][1])
            list1.append(twovalue_img[i][j+1] and structuralelement[1][2])
            list1.append(twovalue_img[i+1][j-1] and structuralelement[2][0])
            list1.append(twovalue_img[i+1][j] and structuralelement[2][1])
            list1.append(twovalue_img[i+1][j+1] and structuralelement[2][2])
            #如果都为0，结果图像的该像素为0，否则为1。
            for each in list1 :
                if each == 1 :
                    count1 += 1
            if count1 > 0 :
                gray2[i][j] = 255
            else :
                gray2[i][j] = 0        
    return gray2

#开运算
def opencalc(twovalue_img) :
    #先腐蚀，再膨胀
    corrode_pic = corrode(twovalue_img)
    open_img = swell(corrode_pic)
    return open_img

#闭运算
def closecalc(twovalue_img) :
    #先膨胀，再腐蚀
    swell_pic = swell(twovalue_img)
    close_img = corrode(swell_pic)
    return close_img

def MAIN():
    image = cv2.imread(r"D:/Code/Python/2.png")
    cv2.imshow("old_img",image)
    gray = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
    #调用自己写的otsu算法，并将处理后的二值化图像输出
    twovalue_img = myotsu(gray)
    cv2.imshow("twovalue_img",twovalue_img)
    #腐蚀操作
    corrode_img = corrode(twovalue_img)
    cv2.imshow("corrode_img",corrode_img)
    #膨胀操作
    swell_img = swell(twovalue_img)
    cv2.imshow("swell_img",swell_img)
    #开运算
    open_img = opencalc(twovalue_img)
    cv2.imshow("open_img",open_img)
    #闭运算
    close_img = closecalc(twovalue_img)
    cv2.imshow("close_img",close_img)
    cv2.waitKey(0)


if __name__ == "__main__":
    MAIN()

原始图片：

在这里插入图片描述

二值化图像：

在这里插入图片描述

腐蚀：

在这里插入图片描述

膨胀：

在这里插入图片描述

开运算：

在这里插入图片描述

闭运算：

在这里插入图片描述

一只没有脚的猪
关注
  • 10
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
opencv 形态学变换(开运算，闭运算，梯度运算)
09-16
OpenCV中的形态学变换是图像处理领域中一种强大的工具，常用于处理二值图像或灰度图像。形态学变换主要包括开运算、闭运算和梯度运算，这些操作可以帮助去除噪声，连接断开的线条，填充小孔洞，以及分离粘连的物体。...
图像处理(5) : 形态学处理
热门推荐
QtHalcon
05-12 2万+
​ 形态学是图像处理中应用最为广泛的技术之一，主要用于从图像中提取对表达和描绘区域形状有意义的图像分量，使后续的识别工作能够抓住目标对象最为本质的形状特征，如边界和连通区域等。同时像细化、像素化和修剪毛刺等技术也常应用于图像的预处理和后处理中，成为图像增强技术的有力补充。 形态学的基本思想是利用一种特殊的结构元来测量或提取输入图像中相应的形状或特征，以便进一步进行图像分析和目标识别。 一、腐蚀与膨胀 在经阈值处理提取出目标区域的二值图像之后，区域边缘可能并不理想，这时可以使用...
图像基本变换---图像形态学算法(膨胀+腐蚀+开运算+闭运算)
bravebean的博客
05-11 1万+
本文详细 介绍图像形态学算法(膨胀+腐蚀+开运算+闭运算)算法及实现，并给出了一份完整程序DEMO下载链接，跟大家分享一下，希望大家喜欢！
【数字图像处理】图像形态学算法C语言实现（图像卷积，膨胀，腐蚀，开运算，闭运算，顶帽，黑帽，雕版，锐化）
yy197696的博客
11-25 2928
文章目录(一)图像卷积1. 图像卷积2. 数字信号处理中的卷积3 数字图像处理中的卷积（二）图像卷积实现各种形态学运算腐蚀膨胀形态学梯度开运算闭运算顶帽黑帽雕版锐化li_conv.cmain.c(三)效果展示原图腐蚀膨胀形态学梯度开运算闭运算顶帽黑帽雕版锐化 (一)图像卷积 1. 图像卷积 图像卷积是进行空间域滤波与梯度运算的基础。首先我们需要理解卷积的运算方式从而可以编程实现。 2. 数字信号处理中的卷积 卷积一词最开始出现在信号与线性系统中，信号与线性系统中讨论的就是信号经过一个线性系统以后发生的变化。
【计算机视觉】图像处理算法（形态学滤波篇）
小賀のBlog
03-07 1958
来源：《OpenCV3编程入门》，怀念毛星云大佬🕯️。
图像处理基础：图像膨胀、腐蚀、开闭运算及梯度运算的Python实现
AI_dataloads的博客
10-13 4765
通过这些形态学操作，我们可以更好地理解图像处理的基本原理和方法，掌握图像处理的基本技能，为进一步的图像分析和处理打下基础。
Python+Opencv图像处理图片
01-07
此外，OpenCV还提供了形态学操作，如腐蚀、膨胀、开闭运算等，这些在图像分割、噪声去除和目标检测中十分常见。`cv2.erode()`和`cv2.dilate()`分别用于腐蚀和膨胀操作，`cv2.morphologyEx()`则可以执行更复杂的形态...
Python+OpenCV数字图像处理课程设计作业[车牌识别].zip
最新发布
06-14
然后，我们可以利用形态学操作（如腐蚀和膨胀）来细化边缘并分离出可能的车牌区域。轮廓检测也可以用来识别出独立的形状，进一步筛选出可能的车牌。 一旦定位了车牌，下一步是字符分割。这通常通过连通组件分析和...
Python-openCV开运算实例
09-16
在本实例中，我们将探讨的是OpenCV中的“开运算”（MORPH_OPEN），这是一种用于去除噪声和分离物体的形态学操作。 开运算是一种组合操作，由先腐蚀（Erosion）后膨胀（Dilation）两个步骤组成。在Python的OpenCV中...
图像的开运算和闭运算_闭运算_开运算_
10-01
在图像处理领域，开运算和闭运算是一种非常重要的形态学操作，它们主要用于图像的形态学细化、噪声消除以及边缘检测等任务。这两种操作基于数学形态学理论，是图像处理中的基本工具，尤其在处理二值图像时效果显著。...
图像的基本形态学处理方法（开运算、闭运算、顶帽运算、底帽运算）
w1050321758的博客
04-27 6072
图像的基本形态学处理方法（开运算、闭运算、顶帽运算、底帽运算） 图像的形态学运算可以对图像进行预处理（去噪声、简化形状）、增强物体结构（抽取骨骼、细化、粗化、凸包）、从背景中分割物体、对物体进行量化描述（面积、周长、投影）。 图像的形态学处理经常以二值化图像为源图像。二值化图像是将原始图像的灰度图以某一阈值进行分割，把像素点的灰度在阈值范围内的设置为255，用白色表示，在阈值范围之外的设置为0，用黑色表示。其具体的公式如下： 上式中， f(x,y)代表灰度图某一像素的灰度值，T1、T2 分别是设置的上下灰
图像腐蚀、膨胀算法
horizons_kong的博客
11-21 7516
腐蚀运算的含义：每当在目标图像中找到一个与结构元素相同的子图像时，就把该子图像中与结构元素的原点位置对应的那个像素位置标注出来，目标图像上被标注出来的所有像素组成的集合，即为腐蚀运算的结果。其实质就是在目标图像中标出那些与结构元素相同的子图像的原点位置的像素。 算法描述： 1.获得源图像每行像素的宽度 2.创建一幅大小与源图像相同，所有像素置黑的目标图像 3.为
图像处理之膨胀腐蚀操作
cxf7394373的专栏
01-23 5981
腐蚀的算法： 用3x3的结构元素，扫描图像的每一个像素，用结构元素与其覆盖的二值图像做“与”操作：如果都为1，结果图像的该像素为1。否则为0。 结果：使二值图像减小一圈 B}Í S = { x,y | SxyÄ定义：E = B   膨胀的算法： 用3x3的结构元素，扫描图像的每一个像素，用结构元素与其覆盖的二值图像做“与”操作：如果都为0，结果图像的该像素为0。否则为1 结果：使二
cv形态学运算--腐蚀和膨胀
Cris_Wang7的博客
11-01 1218
基于 OpenCV 的图像形态学处理 - 膨胀，腐蚀，开运算，闭运算. 涉及到的 OpenCV 函数 -cv2.erode()，cv2.dilate()，cv2.morphologyEx() 膨胀和腐蚀是图像形态学的两个基本操作. 典型应用是在二值图像中的使用，是很多识别技术中重要的中间处理步骤. 在灰度图像中根据阈值同样可以完成膨胀与腐蚀操作. 1. 原理 二值图像fx,y的膨胀操作，类似于对图像的卷积操作. 需要有个 kernel 操作矩阵，类似于卷积核filters,kernel，常见的是 ..
OpenCV图像处理学习十，图像的形态学操作——膨胀腐蚀
weixin_44651073的博客
08-13 8079
图像的形态学操作——膨胀腐蚀
图像处理入门系列之形态学运算
znh_peak的博客
03-14 745
图像的形态学运算又分为二值图像的形态学运算以及灰度图像的形态学运算。形态学运算的基本操作有腐蚀、膨胀、开运算、闭运算等。开运算以及闭运算都属于腐蚀和膨胀两种操作的结合。腐蚀和膨胀都是通过卷积核在目标图像中移动进行卷积操作完成的。腐蚀能够使图像中目标区域缩小，膨胀是目标区域变大。 1.腐蚀 简单来说，腐蚀是通过缩小目标区域边界实现图像缩小的一种运算。一般腐蚀运算用于消除较小的多余目标物。对于二值图像...
python --opencv图像处理(图像腐蚀与图像膨胀)
weixin_44634704的博客
08-22 3659
卷积核是腐蚀中的关键，卷积核的中心点逐个扫描原始图像中的每一个像素点，被扫描到的原始图像中的像素点，只有当卷积核对应的元素值均为 1 时，其值才为 1 ，否则其值修改为 0。图像膨胀正好和图像腐蚀相反，卷积核的中心点逐个扫描原始图像中的每一个像素点，被扫描到的原始图像中的像素点，只要有一个值为 1 时则为 1 ，否则为 0。在接着往下看之前，有一点需要注意的是，图像的腐蚀与膨胀，主要针对的是二值图像（黑白图）的，其中进行变化的部分是图像的白色部分（高亮）部分，不是黑色部分。又出来新名词了：形态学。
计算机视觉教程2-7：天使与恶魔?图文详解图像形态学运算(附代码)
FRIGIDWINTER的博客
03-14 9761
本文用最通俗的语言介绍什么是图像形态学运算，最后用腐蚀和膨胀对同一图片制造出光与影、正与邪、天使与恶魔两种强烈反差
【OpenCV入门--python--腐蚀与膨胀】
qq_43536231的博客
07-11 957
OpenCV入门 之 学习官网中的例子
python opencv 图像形态学开操作
06-12
图像形态学是一种基于形态学理论的图像处理方法，可以用于图像分割、去噪、边缘检测等。OpenCV提供了一系列形态学操作函数。以下是一些基本的图像形态学操作： 1. 导入OpenCV库 ``` import cv2 import numpy as np...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值