精华内容
下载资源
问答
  • 边缘检测VS2017编译通过,可直接运行 包括 Roberts边缘算子 Sobel边缘检测算子 Prewitt边缘检测算子 Kirsch边缘检测算子 拉普拉斯算子 高斯拉普拉斯算子
  • 边缘检测算子

    千次阅读 2018-09-26 11:31:28
    如下边缘检测算子中,时间复杂度最高的是:C  A、Sobel算子 B、Prewitt算子 C、Canny算子 D、Roberts算子  (说明:常见边缘检测算子:Roberts 、Sobel 、Prewitt、Laplacian、Log/Marr、Canny、Kirsch、...

    如下边缘检测算子中,时间复杂度最高的是:C

        A、Sobel算子     B、Prewitt算子     C、Canny算子     D、Roberts算子

        (说明:常见边缘检测算子:Roberts 、Sobel 、Prewitt、Laplacian、Log/Marr、Canny、Kirsch、Nevitia      

          一阶微分算子:Roberts 、Sobel 、Prewitt

          二阶微分算子:Laplacian、Log/Marr

          非微分边缘检测算子:Canny

          方向算子Kirsch(8个3*3模板),Nevitia (12个5*5模板))

          

          

    展开全文
  • 2 边缘检测算子分类 3 梯度 3.1 图像梯度 3.2 梯度算子 4 Roberts 算子 4.1 基本原理 4.2 代码示例 5 Prewitt 算子 5.1 基本原理 5.2 代码示例 6 Sobel 算子 6.1 基本原理 6.2 代码示例 7 Laplacian ...

    目录

    1 边缘检测的基本原理

    2 边缘检测算子分类

    3 梯度

    3.1 图像梯度

    3.2 梯度算子

    4 Roberts 算子

    4.1 基本原理

    4.2 代码示例

    5 Prewitt 算子

    5.1 基本原理

    5.2 代码示例

    6 Sobel 算子

    6.1 基本原理

    6.2 代码示例

    7 Laplacian 算子

    7.1 基本原理

    7.2 代码示例

    8 小结

    8.1 各类算子实验比较

    8.2 各类算子的优缺点

    参考资料


     

    1 边缘检测的基本原理

    图像边缘是图像最基本的特征,所谓边缘(Edge) 是指图像局部特性的不连续性。灰度或结构等信息的突变处称之为边缘。例如,灰度级的突变、颜色的突变,、纹理结构的突变等。边缘是一个区域的结束,也是另一个区域的开始,利用该特征可以分割图像。

    如图1所示,当我们看到一个有边缘的物体时,首先感受到的就是边缘

    图1 灰度级跃变的边缘模型

    图1(a)是一个理想的边缘所具备的特性。每个灰度级跃变到一个垂直的台阶上。而实际上,在图像采集系统的性能、采样率和获取图像的照明条件等因素的影响,得到的边缘往往是模糊的,边缘被模拟成具有“斜坡面”的剖面,如图1(b)所示,在这个模型中,模糊的边缘变得“宽”了,而清晰的边缘变得“窄”了。

    图像的边缘有方向和幅度两种属性。边缘通常可以通过一阶导数二阶导数检测得到。一阶导数是以最大值作为对应的边缘的位置,而二阶导数则以过零点作为对应边缘的位置。


     

    2 边缘检测算子分类

    (1)一阶导数的边缘算子

    通过模板作为核与图像的每个像素点做卷积和运算,然后选取合适的阈值来提取图像的边缘。常见的有Roberts算子、Sobel算子和Prewitt算子。

     

    (2)二阶导数的边缘算子

    依据于二阶导数过零点,常见的有Laplacian 算子,此类算子对噪声敏感。

     

    (3)其他边缘算子

    前面两类均是通过微分算子来检测图像边缘,还有一种就是Canny算子,其是在满足一定约束条件下推导出来的边缘检测最优化算子。


     

    3 梯度

    3.1 图像梯度

    为了达到寻找边缘的目的,检测灰度变化可用一阶导数二阶导数来完成。下面将讨论一阶导数

    为了在一幅图像f 的(x,y)位置处寻找边缘的强度和方向,所以选择的工具就是梯度,梯度用\nabla f来表示,并用向量来定义,定义如下所示:

                                                                                 \nabla f\equiv \text{grad}(f)\equiv \left[ \begin{matrix} {{g}_{x}} \\ {{g}_{y}} \\ \end{matrix} \right]\equiv \left[ \begin{matrix} \frac{\partial f}{\partial x} \\ {} \\ \frac{\partial f}{\partial y} \\ \end{matrix} \right]

     

    其中,梯度\nabla f 为一个向量,它表示f 在位置(x,y) 处的最大变化率的方向。

    梯度\nabla f 的大小用M(x,y) 表示,则:

                                                                              M(x,y)=mag(\nabla f)=\sqrt{g_{x}^{2}+g_{y}^{2}}

    其中,M(x,y) 表示梯度向量方向变化率的值。

     

    数学梯度的简单推导

    对于以为函数f(x) 在点 x 处的导数的近似:将函数f(x+\Delta x) 展开为 x 的泰勒级数,令\Delta x=1,且只保该级数的线性项,则函数f(x) 的梯度\nabla f 计算为:

                                                                          \nabla f=\frac{\partial f}{\partial x}={{f}^{'}}(x)=f(x+1)-f(x)

     

    3.2 梯度算子

    由上面的数学推导可知,要得到一幅图像的梯度,则要求在图像的每个像素点位置处计算偏导数。我们处理的是数字量,因此要求关于一点的邻域上的偏导数的数字近似,因此一幅图像f ,在 (x,y) 位置处的 x 和 y 方向上的梯度大小 {g}_{x}} 和 {g}_{y}} 分别计算为:

                                                                           {{g}_{x}}=\frac{\partial f(x,y)}{\partial x}=f(x+1,y)-f(x,y)

                                                                           {{g}_{y}}=\frac{\partial f(x,y)}{\partial y}=f(x,y+1)-f(x,y)

    上述两个公式对所有 x 和 y 的有关值可用下图的一维模板对 f(x,y) 的滤波得到。

    用于计算梯度偏导数的滤波器模板,通常称之为梯度算子边缘算子边缘检测子等。

    对于不同的滤波器模板得到的梯度是不同的,这也就衍生出很多算子,如Roberts、Prewitt、Sobel和Laplacian算子等。下面将详细介绍不同的算子。


     

    4 Roberts 算子

    4.1 基本原理

    Roberts算子又称为交叉微分算法,它是基于交叉差分的梯度算法,通过局部差分计算检测边缘线条。常用来处理具有陡峭的低噪声图像,当图像边缘接近于正45度或负45度时,该算法处理效果更理想。其缺点是对边缘的定位不太准确,提取的边缘线条较粗。

    Roberts算子的模板分为水平方向和垂直方向,如下式所示,从其模板可以看出,Roberts算子能较好的增强正负45度的图像边缘。

                                                                              {{d}_{x}}=\left[ \begin{matrix} -1 & 0 \\ 0 & 1 \\ \end{matrix} \right]\begin{matrix} {} & {} \\ {} & {} \\ \end{matrix}{{d}_{y}}=\left[ \begin{matrix} 0 & -1 \\ 1 & 0 \\ \end{matrix} \right]

    例如,下面给出Roberts算子模板,在像素点P5处 x 和 y 方向上的梯度大小 {g}_{x}} 和 {g}_{y}} 分别计算为:

                                                                                       {{g}_{x}}=\frac{\partial f}{\partial x}=\text{P9-P5}

                                                                                       {{g}_{y}}=\frac{\partial f}{\partial y}=\text{P8-P6}

     

     

    4.2 代码示例

    在Python中,Roberts算子主要通过numpy定义模板,再调用OpenCV的 filter2D() 函数实现边缘提取。该函数主要是利用内核实现对图像的卷积运算。filter2D() 函数用法如下所示:

    dst = filter2D(src, ddepth, kernel[, dst[, anchor[, delta[, borderType]]]])

    其中,参数:

    src 表示输入图像;

    dst 表示输出的边缘图,其大小和通道数与输入图像相同;

    ddepth 表示目标图像所需的深度;

    kernel 表示卷积核,一个单通道浮点型矩阵;

    anchor 表示内核的基准点,其默认值为 (-1,-1),位于中心位置;

    delta 表示在储存目标图像前可选的添加到像素的值,默认值为0;

    borderType 表示边框模式。

    代码如下所示:

    # -*- coding: utf-8 -*-
    import cv2
    import numpy as np
    import matplotlib.pyplot as plt
    
    # 读取图像
    img = cv2.imread('zxp.jpg')
    img_RGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) #转成RGB 方便后面显示
    
    # 灰度化处理图像
    grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # Roberts算子
    kernelx = np.array([[-1, 0], [0, 1]], dtype=int)
    kernely = np.array([[0, -1], [1, 0]], dtype=int)
    x = cv2.filter2D(grayImage, cv2.CV_16S, kernelx)
    y = cv2.filter2D(grayImage, cv2.CV_16S, kernely)
    # 转uint8
    absX = cv2.convertScaleAbs(x)
    absY = cv2.convertScaleAbs(y)
    Roberts = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)
    
    # 用来正常显示中文标签
    plt.rcParams['font.sans-serif'] = ['SimHei']
    
    # 显示图形
    # titles = [u'原始图像', u'Roberts算子']
    # images = [img_RGB, Roberts]
    # for i in range(2):
    #     plt.subplot(1, 2, i + 1), plt.imshow(images[i], 'gray')
    #     plt.title(titles[i])
    #     plt.xticks([]), plt.yticks([])
    
    # plt.show()
    
    # 显示图形
    plt.subplot(121),plt.imshow(img_RGB),plt.title('原始图像'), plt.axis('off') #坐标轴关闭
    plt.subplot(122),plt.imshow(Roberts, cmap=plt.cm.gray ),plt.title('Roberts算子'), plt.axis('off')
    plt.show()

     

    运行结果如下图所示:

     


     

    5 Prewitt 算子

    5.1 基本原理

    Prewitt算子是一种图像边缘检测的微分算子,其原理是利用特定区域内像素灰度值产生的差分实现边缘检测。由于Prewitt算子采用 3\times3 模板对区域内的像素值进行计算,而Robert算子的模板为 2\times2,故Prewitt算子的边缘检测结果在水平方向和垂直方向均比Robert算子更加明显。Prewitt算子适合用来识别噪声较多、灰度渐变的图像,其计算公式如下所示:

                                                                      {{d}_{y}}=\left[ \begin{matrix} -1 & 0 & 1 \\ -1 & 0 & 1 \\ -1 & 0 & 1 \\ \end{matrix} \right]\begin{matrix} {} & {} & {} \\ {} & {} & {} \\ {} & {} & {} \\ \end{matrix}{{d}_{x}}=\left[ \begin{matrix} -1 & -1 & -1 \\ 0 & 0 & 0 \\ 1 & 1 & 1 \\ \end{matrix} \right]

    例如,下面给出Prewitt算子模板,在像素点P5处 x 和 y 方向上的梯度大小 {g}_{x}} 和 {g}_{y}} 分别计算为:

                                                                    {{g}_{x}}=\frac{\partial f}{\partial x}=(\text{P7+P8+P9)-}(\text{P1+P2+P3)}

                                                                    {{g}_{y}}=\frac{\partial f}{\partial y}=(\text{P3+P6+P9)-}(\text{P1+P4+P7)}

     

    5.2 代码示例

    在Python中,Prewitt算子的实现过程与Roberts算子比较相似。通过Numpy定义模板,再调用OpenCV的filter2D() 函数实现对图像的卷积运算,最终通过 convertScaleAbs() addWeighted() 函数实现边缘提取。filter2D() 函数用法如下所示:

    dst = filter2D(src, ddepth, kernel[, dst[, anchor[, delta[, borderType]]]])

    其中,参数:

    src 表示输入图像;

    dst 表示输出的边缘图,其大小和通道数与输入图像相同;

    ddepth 表示目标图像所需的深度;

    kernel 表示卷积核,一个单通道浮点型矩阵;

    anchor 表示内核的基准点,其默认值为(-1,-1),位于中心位置;

    delta 表示在储存目标图像前可选的添加到像素的值,默认值为0;

    borderType 表示边框模式。

     

    代码如下所示:

    # -*- coding: utf-8 -*-
    import cv2
    import numpy as np
    import matplotlib.pyplot as plt
    
    # 读取图像
    img = cv2.imread('zxp.jpg')
    img_RGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    
    # 灰度化处理图像
    grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # Prewitt算子
    kernelx = np.array([[1, 1, 1], [0, 0, 0], [-1, -1, -1]], dtype=int)
    kernely = np.array([[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]], dtype=int)
    x = cv2.filter2D(grayImage, cv2.CV_16S, kernelx)
    y = cv2.filter2D(grayImage, cv2.CV_16S, kernely)
    # 转uint8
    absX = cv2.convertScaleAbs(x)
    absY = cv2.convertScaleAbs(y)
    Prewitt = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)
    
    # 用来正常显示中文标签
    plt.rcParams['font.sans-serif'] = ['SimHei']
    
    # 显示图形
    # titles = [u'原始图像', u'Prewitt算子']
    # images = [img_RGB, Prewitt]
    # for i in range(2):
    #     plt.subplot(1, 2, i + 1), plt.imshow(images[i], 'gray')
    #     plt.title(titles[i])
    #     plt.xticks([]), plt.yticks([])
    # plt.show()
    
    
    # 显示图形
    plt.subplot(121),plt.imshow(img_RGB),plt.title('原始图像'), plt.axis('off') #坐标轴关闭
    plt.subplot(122),plt.imshow(Prewitt, cmap=plt.cm.gray ),plt.title('Prewitt算子'), plt.axis('off')
    plt.show()

     

    运行结果如下图所示:

    由上图可以看出Prewitt算子的边缘检测结果在水平方向和垂直方向均比Robert算子更加明显。

     


     

    6 Sobel 算子

    6.1 基本原理

    Sobel算子是一种用于边缘检测的离散微分算子,它结合了高斯平滑和微分求导。该算子用于计算图像明暗程度近似值,根据图像边缘旁边明暗程度把该区域内超过某个数的特定点记为边缘。Sobel算子在Prewitt算子的基础上增加了权重的概念,认为相邻点的距离远近对当前像素点的影响是不同的,距离越近的像素点对应当前像素的影响越大,从而实现图像锐化并突出边缘轮廓。

    Sobel算子根据像素点上下、左右邻点灰度加权差,在边缘处达到极值这一现象检测边缘。对噪声具有平滑作用,提供较为精确的边缘方向信息。因为Sobel算子结合了高斯平滑和微分求导(分化),因此结果会具有更多的抗噪性,当对精度要求不是很高时,Sobel算子是一种较为常用的边缘检测方法。

    Sobel算子的边缘定位更准确,常用于噪声较多、灰度渐变的图像。其算法模板如下面的公式所示,其中 {{d}_{x}} 表示水平方向,{{d}_{y}} 表示垂直方向。

                                                                     {{d}_{x}}=\left[ \begin{matrix} -1 & 0 & 1 \\ -2 & 0 & 2 \\ -1 & 0 & 1 \\ \end{matrix} \right]\begin{matrix} {} & {} & {} \\ {} & {} & {} \\ {} & {} & {} \\ \end{matrix}{{d}_{y}}=\left[ \begin{matrix} -1 & -2 & -1 \\ 0 & 0 & 0 \\ 1 & 2 & 1 \\ \end{matrix} \right]

    例如,下面给出Sobel算子模板,在像素点P5处 x 和 y 方向上的梯度大小 {g}_{x}} 和 {g}_{y}} 分别计算为:

                                                                  {{g}_{x}}=\frac{\partial f}{\partial x}=(\text{P7+2P8+P9)-}(\text{P1+2P2+P3)}

                                                                  {{g}_{y}}=\frac{\partial f}{\partial y}=(\text{P3+2P6+P9)-}(\text{P1+2P4+P7)}

     

    6.2 代码示例

    Sobel() 函数用法如下所示:

    dst = Sobel(src, ddepth, dx, dy[, dst[, ksize[, scale[, delta[, borderType]]]]])

    其中,参数:

    src 表示输入图像;

    dst 表示输出的边缘图,其大小和通道数与输入图像相同;

    ddepth 表示目标图像所需的深度,针对不同的输入图像,输出目标图像有不同的深度;

    dx 表示 x 方向上的差分阶数,取值1或 0;

    dy 表示 y 方向上的差分阶数,取值1或0;

    ksize 表示Sobel算子的大小,其值必须是正数奇数

    scale 表示缩放导数的比例常数,默认情况下没有伸缩系数;

    delta 表示将结果存入目标图像之前,添加到结果中的可选增量值;

    borderType 表示边框模式,更多详细信息查阅BorderTypes。

     

    :在进行Sobel算子处理之后,还需要调用 convertScaleAbs() 函数计算绝对值,并将图像转换为8位图进行显示。其函数用法如下所示:

    dst = convertScaleAbs(src[, dst[, alpha[, beta]]])

    其中,参数:

    src 表示原数组;

    dst 表示输出数组,深度为8位;

    alpha 表示比例因子;

    beta 表示原数组元素按比例缩放后添加的值。

     

    代码如下所示:

    # -*- coding: utf-8 -*-
    import cv2
    import numpy as np
    import matplotlib.pyplot as plt
    
    # 读取图像
    img = cv2.imread('zxp.jpg')
    img_RGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    
    # 灰度化处理图像
    grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # Sobel算子
    x = cv2.Sobel(grayImage, cv2.CV_16S, 1, 0)  # 对x求一阶导
    y = cv2.Sobel(grayImage, cv2.CV_16S, 0, 1)  # 对y求一阶导
    absX = cv2.convertScaleAbs(x)
    absY = cv2.convertScaleAbs(y)
    Sobel = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)
    
    # 用来正常显示中文标签
    plt.rcParams['font.sans-serif'] = ['SimHei']
    
    # # 显示图形
    # titles = [u'原始图像', u'Sobel算子']
    # images = [lenna_img, Sobel]
    # for i in xrange(2):
    #     plt.subplot(1, 2, i + 1), plt.imshow(images[i], 'gray')
    #     plt.title(titles[i])
    #     plt.xticks([]), plt.yticks([])
    # plt.show()
    
    # 显示图形
    plt.subplot(121),plt.imshow(img_RGB),plt.title('原始图像'), plt.axis('off') #坐标轴关闭
    plt.subplot(122),plt.imshow(Sobel, cmap=plt.cm.gray ),plt.title('Sobel算子'), plt.axis('off')
    plt.show()

     

    运行结果如下图所示:

     


     

    7 Laplacian 算子

    7.1 基本原理

    拉普拉斯(Laplacian) 算子是 n 维欧几里德空间中的一个二阶微分算子,常用于图像增强领域和边缘提取。它通过灰度差分计算邻域内的像素。

    算法基本流程

    1)判断图像中心像素灰度值与它周围其他像素的灰度值,如果中心像素的灰度更高,则提升中心像素的灰度;反之降低中心像素的灰度,从而实现图像锐化操作;

    2)在算法实现过程中,Laplacian算子通过对邻域中心像素的四方向或八方向求梯度,再将梯度相加起来判断中心像素灰度与邻域内其他像素灰度的关系;

    3)最后通过梯度运算的结果对像素灰度进行调整。

    Laplacian算子分为四邻域和八邻域,四邻域是对邻域中心像素的四个方向求梯度,八邻域是对八个方向求梯度。

    其中,Laplacian算子四邻域模板如下所示:

                                                                                  \text{H}=\left[ \begin{matrix} 0 & -1 & 0 \\ -1 & 4 & -1 \\ 0 & -1 & 0 \\ \end{matrix} \right]

    Laplacian算子的八邻域模板如下所示:

                                                                                  \text{H}=\left[ \begin{matrix} -1 & -1 & -1 \\ -1 & 8 & -1 \\ -1 & -1 & -1 \\ \end{matrix} \right]

    通过Laplacian算子的模板可以发现:

    1)当邻域内像素灰度相同时,模板的卷积运算结果为0;

    2)当中心像素灰度高于邻域内其他像素的平均灰度时,模板的卷积运算结果为正数;

    3)当中心像素的灰度低于邻域内其他像素的平均灰度时,模板的卷积为负数。对卷积运算的结果用适当的衰弱因子处理并加在原中心像素上,就可以实现图像的锐化处理。

                                                                                  

     

    7.2 代码示例

    Python和OpenCV将Laplacian算子封装在 Laplacian() 函数中,其函数用法如下所示:

    dst = Laplacian(src, ddepth[, dst[, ksize[, scale[, delta[, borderType]]]]])

    其中,参数:

    src 表示输入图像;

    dst 表示输出的边缘图,其大小和通道数与输入图像相同;

    ddepth 表示目标图像所需的深度;

    ksize 表示用于计算二阶导数的滤波器的孔径大小,其值必须是正数和奇数,且默认值为1,更多详细信息查阅getDerivKernels ;

    scale 表示计算拉普拉斯算子值的可选比例因子。默认值为1,更多详细信息查阅getDerivKernels;

    delta 表示将结果存入目标图像之前,添加到结果中的可选增量值,默认值为0;

    borderType 表示边框模式,更多详细信息查阅BorderTypes。

    :Laplacian算子其实主要是利用Sobel算子的运算,通过加上Sobel算子运算出的图像 x 方向和 y 方向上的导数,得到输入图像的图像锐化结果。同时,在进行Laplacian算子处理之后,还需要调用 convertScaleAbs() 函数计算绝对值,并将图像转换为8位图进行显示。其函数用法如下:

    dst = convertScaleAbs(src[, dst[, alpha[, beta]]])

    其中,参数:

    src 表示原数组;

    dst 表示输出数组,深度为8位;

    alpha 表示比例因子;

    beta 表示原数组元素按比例缩放后添加的值。

    当ksize=1时,Laplacian() 函数采用 3\times3 的孔径 (四邻域模板) 进行变换处理。下面的代码是采用 ksize=3 的Laplacian算子进行图像锐化处理。

     

    代码如下所示:

    # -*- coding: utf-8 -*-
    import cv2
    import numpy as np
    import matplotlib.pyplot as plt
    
    # 读取图像
    img = cv2.imread('zxp.jpg')
    img_RGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    
    # 灰度化处理图像
    grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # 拉普拉斯算法
    dst = cv2.Laplacian(grayImage, cv2.CV_16S, ksize=3)
    Laplacian = cv2.convertScaleAbs(dst)
    
    # 用来正常显示中文标签
    plt.rcParams['font.sans-serif'] = ['SimHei']
    
    # # 显示图形
    # titles = [u'原始图像', u'Laplacian算子']
    # images = [lenna_img, Laplacian]
    # for i in xrange(2):
    #     plt.subplot(1, 2, i + 1), plt.imshow(images[i], 'gray')
    #     plt.title(titles[i])
    #     plt.xticks([]), plt.yticks([])
    # plt.show()
    
    
    # 显示图形
    plt.subplot(121),plt.imshow(img_RGB),plt.title('原始图像'), plt.axis('off') #坐标轴关闭
    plt.subplot(122),plt.imshow(Laplacian, cmap=plt.cm.gray ),plt.title('Laplacian算子'), plt.axis('off')
    plt.show()

     

    运行结果如下图所示:

     


     

    8 小结

    8.1 各类算子实验比较

    边缘检测算法主要是基于图像强度的一阶导数二阶导数,但导数通常对噪声很敏感,因此需要采用滤波器来过滤噪声,并调用图像增强或阈值化算法进行处理,最后再进行边缘检测。下面是采用高斯滤波去噪和阈值化处理之后,再进行边缘检测的过程,并对比了四种常见的边缘提取算法。

     

    代码如下所示:

    # -*- coding: utf-8 -*-
    import cv2
    import numpy as np
    import matplotlib.pyplot as plt
    
    #读取图像
    img = cv2.imread('zxp.jpg')
    img_RGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) #转成RGB 方便后面显示
    
    #灰度化处理图像
    grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    #高斯滤波
    gaussianBlur = cv2.GaussianBlur(grayImage, (3,3), 0)
    
    #阈值处理
    ret, binary = cv2.threshold(gaussianBlur, 127, 255, cv2.THRESH_BINARY)
    
    #Roberts算子
    kernelx = np.array([[-1,0],[0,1]], dtype=int)
    kernely = np.array([[0,-1],[1,0]], dtype=int)
    x = cv2.filter2D(binary, cv2.CV_16S, kernelx)
    y = cv2.filter2D(binary, cv2.CV_16S, kernely)
    absX = cv2.convertScaleAbs(x)
    absY = cv2.convertScaleAbs(y)
    Roberts = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)
    
    #Prewitt算子
    kernelx = np.array([[1,1,1],[0,0,0],[-1,-1,-1]], dtype=int)
    kernely = np.array([[-1,0,1],[-1,0,1],[-1,0,1]], dtype=int)
    x = cv2.filter2D(binary, cv2.CV_16S, kernelx)
    y = cv2.filter2D(binary, cv2.CV_16S, kernely)
    absX = cv2.convertScaleAbs(x)
    absY = cv2.convertScaleAbs(y)
    Prewitt = cv2.addWeighted(absX,0.5,absY,0.5,0)
    
    #Sobel算子
    x = cv2.Sobel(binary, cv2.CV_16S, 1, 0)
    y = cv2.Sobel(binary, cv2.CV_16S, 0, 1)
    absX = cv2.convertScaleAbs(x)
    absY = cv2.convertScaleAbs(y)
    Sobel = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)
    
    #Laplacian算子
    dst = cv2.Laplacian(binary, cv2.CV_16S, ksize = 3)
    Laplacian = cv2.convertScaleAbs(dst)
    
    # #效果图
    # titles = ['Source Image', 'Binary Image', 'Roberts Image',
    #           'Prewitt Image','Sobel Image', 'Laplacian Image']
    # images = [lenna_img, binary, Roberts, Prewitt, Sobel, Laplacian]
    # for i in np.arange(6):
    #    plt.subplot(2,3,i+1),plt.imshow(images[i],'gray')
    #    plt.title(titles[i])
    #    plt.xticks([]),plt.yticks([])
    # plt.show()
    
    # 用来正常显示中文标签
    plt.rcParams['font.sans-serif'] = ['SimHei']
    
    # # 显示图形
    plt.subplot(231),plt.imshow(img_RGB),plt.title('原始图像'), plt.axis('off') #坐标轴关闭
    plt.subplot(232),plt.imshow(binary, cmap=plt.cm.gray ),plt.title('二值图'), plt.axis('off')
    plt.subplot(233),plt.imshow(Roberts, cmap=plt.cm.gray ),plt.title('Roberts算子'), plt.axis('off')
    plt.subplot(234),plt.imshow(Prewitt, cmap=plt.cm.gray ),plt.title('Prewitt算子'), plt.axis('off')
    plt.subplot(235),plt.imshow(Sobel, cmap=plt.cm.gray ),plt.title('Sobel算子'), plt.axis('off')
    plt.subplot(236),plt.imshow(Laplacian, cmap=plt.cm.gray ),plt.title('Laplacian算子'), plt.axis('off')
    
    plt.show()

     

    运行结果如下图所示:

     

    为了比较不同算子,多测试了几张图像,如下图所示:

     

     

     

    由上面的结果所示,不同的算子进行了比较。可知:

    1)Robert算子对陡峭的低噪声图像效果较好,尤其是边缘正负45度较多的图像,但定位准确率较差;

    2)Prewitt算子对灰度渐变的图像边缘提取效果较好,而没有考虑相邻点的距离远近对当前像素点的影响;

    3)Sobel算子考虑了综合因素,对噪声较多的图像处理效果更好。

    4)Laplacian算子对噪声比较敏感,由于其算法可能会出现双像素边界,常用来判断边缘像素位于图像的明区或暗区,很少用于边缘检测;

     

    8.2 各类算子的优缺点

    (1)Roberts 算子 

    Roberts算子利用局部差分算子寻找边缘,边缘定位精度较高,但容易丢失一部分边缘,不具备抑制噪声的能力。该算子对具有陡峭边缘且含噪声少的图像效果较好,尤其是边缘正负45度较多的图像,但定位准确率较差;

     

    (2)Sobel 算子

    Sobel算子考虑了综合因素,对噪声较多的图像处理效果更好,Sobel 算子边缘定位效果不错,但检测出的边缘容易出现多像素宽度。

     

    (3) Prewitt 算子

    Prewitt算子对灰度渐变的图像边缘提取效果较好,而没有考虑相邻点的距离远近对当前像素点的影响,与Sobel 算子类似,不同的是在平滑部分的权重大小有些差异;

     

    (4)Laplacian 算子

    Laplacian 算子不依赖于边缘方向的二阶微分算子,对图像中的阶跃型边缘点定位准确,该算子对噪声非常敏感,它使噪声成分得到加强,这两个特性使得该算子容易丢失一部分边缘的方向信息,造成一些不连续的检测边缘,同时抗噪声能力比较差,由于其算法可能会出现双像素边界,常用来判断边缘像素位于图像的明区或暗区,很少用于边缘检测;

     

     

    参考资料

    [1] https://blog.csdn.net/Eastmount/article/details/89001702

    [2] 杨帆. 数字图像处理与分析(第三版). 北京航空航天大学出版社

    [3] 冈萨雷斯. 数字图像处理(第三版) 

     


    如果觉得内容还不错的话,欢迎点赞、转发、收藏,还可以关注微信公众号、CSDN博客、知乎。
     

    1. 微信公众号:

    2. CSDN博客:https://xiongyiming.blog.csdn.net/

    3. 知乎:https://www.zhihu.com/people/xiongyiming

     

     

     

    展开全文
  • sobel 产生的边缘有强弱,抗噪性好,计算量小 laplace 对边缘敏感,可能有些是噪声的边缘,也被算进来了 canny 产生的边缘很细,可能就一个像素那么细,没有强弱之分。计算量大,但是准确 global in%使用全局...

    sobel 产生的边缘有强弱,抗噪性好,计算量小

        laplace 对边缘敏感,可能有些是噪声的边缘,也被算进来了
    
        canny 产生的边缘很细,可能就一个像素那么细,没有强弱之分。计算量大,但是准确
    
    global in%使用全局变量in
    %拿到所选按钮的名称
    str=get(hObject,'string');
    
    axes(handles.axes1);
    
    switch str
        case '原图'
             imshow(in);  
        case 'sobel'
            BW=edge(rgb2gray(in),'sobel');
            imshow(BW); 
        case 'prewitt' 
             BW=edge(rgb2gray(in),'prewitt');
            imshow(BW); 
        case 'canny'
            BW=edge(rgb2gray(in),'canny');
            imshow(BW); 
    end
    

    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述
    注:
    1、Sobel 算子

     基于 Sobel 算子的边缘检测法由包含水平边缘和垂直边缘信息的卷积核组成,其中水平边缘信息的卷积核对该检测法的影响较大。该方法的主要原理是通过卷积算法得到水平边缘和垂直边缘的最大值,将该值作为 Sobel 算子输出,进而实现对图像的边缘检测并提取。
    

    2、Prewitt边缘检测算子
    其原理是在图像空间利用两个方向模板与图像进行邻域卷积来完成的,这两个方向模板一个检测水平边缘,一个检测垂直边缘。

    相比Roberts算子,Prewitt算子对噪声有抑制作用,抑制噪声的原理是通过像素平均,因此噪声较多的图像处理得比较好,但是像素平均相当于对图像的低通滤波,所以Prewitt算子对边缘的定位却不如Roberts算子。

    3、Canny边缘检测算子
    从表面效果上来讲,Canny算法是对Sobel、Prewitt等算子效果的进一步细化和更加准确的定位。

    Canny算法基于三个基本目标:

    (1)低错误率。所有边缘都应被找到,且没有伪响应。
    (2)边缘点应该被很好地定位。已定位的边缘必须尽可能接近真实边缘。
    (3)单一的边缘点响应。这意味在仅存一个单一边缘点的位置,检测器不应指出多个像素边缘。
    进而,Canny的工作本质是,从数学上表达前面的三个准则。因此Canny的步骤如下:

    (1)对输入图像进行高斯平滑,降低错误率。
    (2)计算梯度幅度和方向来估计每一点处的边缘强度与方向。
    (3)根据梯度方向,对梯度幅值进行非极大值抑制。本质上是对Sobel、Prewitt等算子结果的进一步细化。
    用双阈值处理和连接边缘。

    4、rgb2gray - 将 RGB 图像或颜色图转换为灰度图

    此 MATLAB 函数 将真彩色图像 RGB 转换为灰度强度图像 I。rgb2gray 函数通过消除色调和饱和度信息,同时保留亮度,来将 RGB
    图像转换为灰度图。如果已安装 Parallel Computing Toolbox,则 rgb2gray 可以在 GPU 上执行此转换。
    
    展开全文
  • canny边缘检测算子.pptx

    2021-01-05 22:01:18
    图像分割之Canny边缘检测算子PPT,大致讲解三部分内容:求导、NMS、边缘寻找
  • canny边缘检测算子,运用C++来写的,后面还有许多其他的边缘检测算子更新
  • 本资源提供了五种边缘检测算子,包括Sobel 算子、roberts 算子、prewitt 算子、log算子、canny算子,用于图像处理中的图像边缘检测。
  • 根据对焊接过程中采集的图像特征分析,提出了一种基于复合边缘检测算子的焊缝边缘提取方法,即通过Sobel边缘检测算子对焊缝区域进行锁定,然后采用Canny边缘检测算子对焊缝的上下边缘进行精确定位.结果表明,该方法...
  • 边缘检测算子中laplace的maltab程序
  • 边缘检测算子中的canny的maltab
  • 文章分析Sobel,Canny等几种常用边缘检测算子原理并将其应用于红外图像的边缘检测,同时根据仿真结果比较了它们所代表的一阶梯度算子、二阶梯度算子以及复合检测算子在不同类型红外图像边缘检测中的表现,总结了不同...
  • 3种边缘检测算子

    2015-03-30 10:55:22
    3种边缘检测算子。图像的边缘有方向和幅度两个属性,沿边缘方向像素变化平缓,垂直于边缘方向像素变化剧烈.边缘上的这种变化可以用微分算子检测出来,通常用一阶或二阶导数来检测边缘。
  • 数字图像处理(20): 边缘检测算子(Canny算子)

    千次阅读 多人点赞 2019-05-12 21:46:35
    1 边缘检测算子分类 2 Canny算子 2.1 基本理论 2.2 代码示例 3 各类算子实验比较 参考资料 前面已经介绍了边缘检测算子(Roberts算子、Prewitt算子、Sobel算子 和 Laplacian算子), 下面会介绍Canny算子。介绍...

    目录

    1 边缘检测算子分类

    2 Canny算子

    2.1 基本理论

    2.2 代码示例

    3 各类算子实验比较

    参考资料


    前面已经介绍了 边缘检测算子(Roberts算子、Prewitt算子、Sobel算子 和 Laplacian算子), 下面会介绍Canny算子。介绍Canny算子之前,还是看一下边缘检测算子分类。

     

    1 边缘检测算子分类

    (1)一阶导数的边缘检测算子

    通过模板作为核与图像的每个像素点做卷积和运算,然后选取合适的阈值来提取图像的边缘。常见的有Roberts算子、Sobel算子和Prewitt算子。

     

    (2)二阶导数的边缘算子

    依据于二阶导数过零点,常见的有Laplacian 算子,此类算子对噪声敏感。

     

    (3)Canny算子

    前面两类均是通过微分算子来检测图像边缘,还有一种就是Canny算子,其是在满足一定约束条件下推导出来的边缘检测最优化算子。


     

    2 Canny算子

    2.1 基本理论

    John F.Canny于1986年发明了一个多级边缘检测算法——Canny边缘检测算子,并创立了边缘检测计算理论(Computational theory of edge detection),该理论有效地解释了这项技术的工作理论。

    通常情况下边缘检测的目的是在保留原有图像属性的情况下,显著减少图像的数据规模。目前有多种算法可以进行边缘检测,虽然Canny算法年代久远,但可以说它是边缘检测的一种标准算法,而且仍在研究中广泛使用。

    Canny算法是一种被广泛应用于边缘检测的标准算法,其目标是找到一个最优的边缘检测解或找寻一幅图像中灰度强度变化最强的位置。最优边缘检测主要通过低错误率、高定位性和最小响应三个标准进行评价。Canny算子的简要步骤如下:

    (1)去噪声:应用高斯滤波来平滑图像,目的是去除噪声

    (2)梯度:找寻图像的梯度

    (3)非极大值抑制:应用非最大抑制技术来过滤掉非边缘像素,将模糊的边界变得清晰。该过程保留了每个像素点上梯度强度的极大值,过滤掉其他的值。

    (4)应用双阈值的方法来决定可能的(潜在的)边界;

    (5)利用滞后技术来跟踪边界。若某一像素位置和强边界相连的弱边界认为是边界,其他的弱边界则被删除。

     

    Canny算子的具体步骤如下:

    1 去噪声

    边缘检测容易受到噪声的影像。因此,在进行边缘检测前,通常需要进行去噪。通常,使用高斯滤波来去除噪声,例如去高斯滤波的核大小为 5\times5,公式如下所示:

                                                                             \frac{1}{273}\times \left[ \begin{matrix} 1 & 4 & 7 & 4 & 1 \\ 4 & 16 & 26 & 16 & 4 \\ 7 & 26 & 41 & 26 & 7 \\ 4 & 16 & 26 & 16 & 4 \\ 1 & 4 & 7 & 4 & 1 \\ \end{matrix} \right]

    关于高斯滤波去除噪声可以参见博客:图像平滑 (均值滤波、中值滤波和高斯滤波)

     

    2 梯度:找寻图像的梯度

    按照Sobel算子计算梯度幅值和方向,寻找图像的梯度。先将卷积模板分别作用xy方向,再计算梯度幅值和方向,其公式如下所示:

                                                                      {{d}_{x}}=\left[ \begin{matrix} -1 & 0 & 1 \\ -2 & 0 & 2 \\ -1 & 0 & 1 \\ \end{matrix} \right]\begin{matrix} {} & {} & {} \\ {} & {} & {} \\ {} & {} & {} \\ \end{matrix}{{d}_{y}}=\left[ \begin{matrix} -1 & -2 & -1 \\ 0 & 0 & 0 \\ 1 & 2 & 1 \\ \end{matrix} \right]

                                                                                          S=\sqrt{d_{x}^{2}+d_{y}^{2}}

                                                                                          \theta =\arctan (\frac{{{d}_{y}}}{{{d}_{x}}})

    例如,下图为计算好的梯度和方向:

    梯度的方向一般总是与边界垂直,梯度的方向被归为四类:垂直、水平和两个对角线(即,0度、45度、90度和135度四个方向)。

     

    3 非极大值抑制

    对于每个像素点,它进行如下操作:应用非最大抑制技术来过滤掉非边缘像素,将模糊的边界变得清晰。该过程保留了每个像素点上梯度强度的极大值,过滤掉其他的值。

    1)将其梯度方向近似为以下值中的一个,包括0、45、90、135、180、225、270和315,即表示上下左右和45度方向。

    2)比较该像素点和其梯度正负方向的像素点的梯度强度,如果该像素点梯度强度最大则保留,否则抑制(删除,即置为0)。

     

     

    4 应用双阈值的方法来决定可能的(潜在的)边界

    经过非极大抑制后图像中仍然有很多噪声点。Canny算法中应用了一种叫双阈值的技术。即设定一个阈值上界和阈值下界(opencv中通常由人为指定的),图像中的像素点如果大于阈值上界则认为必然是边界(称为强边界,strong edge),小于阈值下界则认为必然不是边界,两者之间的则认为是候选项(称为弱边界,weak edge),需进行进一步处理。过程如下图所示:

     

    经过双阈值处理的图像如下图所示:

     

    5 利用滞后技术来跟踪边界。若某一像素位置和强边界相连的弱边界认为是边界,其他的弱边界则被删除

    最后Canny算子检测到的边缘,如下图所示:

     

    2.2 代码示例

    在OpenCV中,Canny() 函数用法如下所示:

    edges = Canny(image, threshold1, threshold2[, edges[, apertureSize[, L2gradient]]])

    其中,参数:

    mage 表示输入图像;

    edges 表示输出的边缘图,其大小和类型与输入图像相同;

    threshold1 表示第一个滞后性阈值;

    threshold2 表示第二个滞后性阈值;

    apertureSize 表示应用Sobel算子的孔径大小,其默认值为3;

    L2gradient 表示一个计算图像梯度幅值的标识,默认值为false。

     

    代码如下所示:

    # -*- coding: utf-8 -*-
    import cv2
    import numpy as np
    import matplotlib.pyplot as plt
    
    # 读取图像
    img = cv2.imread('zxp.jpg')
    lenna_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    
    # 灰度化处理图像
    grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # 高斯滤波降噪
    gaussian = cv2.GaussianBlur(grayImage, (5, 5), 0)
    
    # Canny算子
    Canny = cv2.Canny(gaussian, 50, 150)
    
    # 用来正常显示中文标签
    plt.rcParams['font.sans-serif'] = ['SimHei']
    
    # 显示图形
    titles = [u'原始图像', u'Canny算子']
    images = [lenna_img, Canny]
    for i in range(2):
        plt.subplot(1, 2, i + 1), plt.imshow(images[i], 'gray')
        plt.title(titles[i])
        plt.xticks([]), plt.yticks([])
    plt.show()
    

     

    运行结果如下图所示:

     


     

    3 各类算子实验比较

    边缘检测算法主要是基于图像强度的一阶导数二阶导数,但导数通常对噪声很敏感,因此需要采用滤波器来过滤噪声,并调用图像增强或阈值化算法进行处理,最后再进行边缘检测。下面是采用高斯滤波去噪和阈值化处理之后(Canny检测之前没有阈值化处理),再进行边缘检测的过程,并对比了5种常见的边缘提取算法。

     

    代码如下所示:

    # -*- coding: utf-8 -*-
    import cv2
    import numpy as np
    import matplotlib.pyplot as plt
    
    # 读取图像
    img = cv2.imread('zxp.jpg')
    img_RGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)  # 转成RGB 方便后面显示
    
    # 灰度化处理图像
    grayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # 高斯滤波
    gaussianBlur = cv2.GaussianBlur(grayImage, (3, 3), 0)
    
    # 阈值处理
    ret, binary = cv2.threshold(gaussianBlur, 127, 255, cv2.THRESH_BINARY)
    
    # Roberts算子
    kernelx = np.array([[-1, 0], [0, 1]], dtype=int)
    kernely = np.array([[0, -1], [1, 0]], dtype=int)
    x = cv2.filter2D(binary, cv2.CV_16S, kernelx)
    y = cv2.filter2D(binary, cv2.CV_16S, kernely)
    absX = cv2.convertScaleAbs(x)
    absY = cv2.convertScaleAbs(y)
    Roberts = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)
    
    # Prewitt算子
    kernelx = np.array([[1, 1, 1], [0, 0, 0], [-1, -1, -1]], dtype=int)
    kernely = np.array([[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]], dtype=int)
    x = cv2.filter2D(binary, cv2.CV_16S, kernelx)
    y = cv2.filter2D(binary, cv2.CV_16S, kernely)
    absX = cv2.convertScaleAbs(x)
    absY = cv2.convertScaleAbs(y)
    Prewitt = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)
    
    # Sobel算子
    x = cv2.Sobel(binary, cv2.CV_16S, 1, 0)
    y = cv2.Sobel(binary, cv2.CV_16S, 0, 1)
    absX = cv2.convertScaleAbs(x)
    absY = cv2.convertScaleAbs(y)
    Sobel = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)
    
    # Laplacian算子
    dst = cv2.Laplacian(binary, cv2.CV_16S, ksize=3)
    Laplacian = cv2.convertScaleAbs(dst)
    
    # Canny算子
    Canny = cv2.Canny(gaussianBlur, 50, 150)
    
    
    
    
    # 用来正常显示中文标签
    plt.rcParams['font.sans-serif'] = ['SimHei']
    
    # # 显示图形
    plt.subplot(231), plt.imshow(img_RGB), plt.title('原始图像'), plt.axis('off')  # 坐标轴关闭
    plt.subplot(232), plt.imshow(Canny, cmap=plt.cm.gray), plt.title('Canny算子'), plt.axis('off')
    plt.subplot(233), plt.imshow(Roberts, cmap=plt.cm.gray), plt.title('Roberts算子'), plt.axis('off')
    plt.subplot(234), plt.imshow(Prewitt, cmap=plt.cm.gray), plt.title('Prewitt算子'), plt.axis('off')
    plt.subplot(235), plt.imshow(Sobel, cmap=plt.cm.gray), plt.title('Sobel算子'), plt.axis('off')
    plt.subplot(236), plt.imshow(Laplacian, cmap=plt.cm.gray), plt.title('Laplacian算子'), plt.axis('off')
    
    plt.show()
    

     

    运行结果如下图所示:

     

    多测试几幅图像,看看效果

     

     


     

    参考资料

    [1] https://blog.csdn.net/Eastmount/article/details/89056240

    [2] Python+OpenCV图像处理

    [3] 冈萨雷斯. 数字图像处理(第三版) 

    展开全文
  • 各种边缘检测算子代码分析,含有C++源程序,其中程序含有详细的代码分析
  • 图像边缘检测算子

    2013-03-25 15:24:12
    这是图像边缘检测算子,有canny算子 sobel算子 拉普拉斯算子,log算子等,有程序 有图片 效果比较好。
  • 是很有效的边缘检测算子,在这里提出了两种算子,分别是Robert和Sobel算子
  • Log和Canny边缘检测算子
  • canny边缘检测算子

    2011-11-24 10:57:38
    canny 算子是计算机图形学中的很好用的一种边缘检测算子
  • 基于MATLAB仿真的边缘检测算子研究.pdf

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,328
精华内容 7,331
关键字:

边缘检测算子