精华内容
下载资源
问答
  • Roberts算子

    2018-12-25 17:43:16
    对输入的图像,用Roberts算子处理,找到目标边缘,达到分割的目的
  • 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 边缘检测的基本原理

    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

     

     

     

    展开全文
  • 图像锐化和边缘提取技术可以消除图像中的噪声,提取图像信息中用来表征图像的一些变量,为图像识别提供基础。通常使用灰度差分法对图像的边缘、...1.Roberts算子 2.Prewitt算子 3.Sobel算子 4.Laplacian算子 5.总结代码

    该系列文章是讲解Python OpenCV图像处理知识,前期主要讲解图像入门、OpenCV基础用法,中期讲解图像处理的各种算法,包括图像锐化算子、图像增强技术、图像分割等,后期结合深度学习研究图像识别、图像分类应用。希望文章对您有所帮助,如果有不足之处,还请海涵~

    由于收集图像数据的器件或传输数图像的通道的存在一些质量缺陷,文物图像时间久远,或者受一些其他外界因素、动态不稳定抓取图像的影响,使得图像存在模糊和有噪声的情况,从而影响到图像识别工作的开展。这时需要开展图像锐化和边缘检测处理,加强原图像的高频部分,锐化突出图像的边缘细节,改善图像的对比度,使模糊的图像变得更清晰。

    图像锐化和边缘提取技术可以消除图像中的噪声,提取图像信息中用来表征图像的一些变量,为图像识别提供基础。通常使用灰度差分法对图像的边缘、轮廓进行处理,将其凸显。本文分别采用Laplacian算子、Robert算子、Prewitt算子和Sobel算子进行图像锐化边缘处理实验。本文主要讲解灰度线性变换,基础性知识希望对您有所帮助。

    该系列在github所有源代码:

    PS:请求帮忙点个Star,哈哈,第一次使用Github,以后会分享更多代码,一起加油。

    同时推荐作者的C++图像系列知识:

    前文参考:

    闲谈:
    希望大家帮我2019年CSDN博客之星投投票,每天可以投5票喔,谢谢大家!八年,在CSDN分享了410篇文章,15个专栏,400多万人次浏览,包括Python人工智能、数据挖掘、网络爬虫、图象处理、网络安全、JAVA网站、Android开发、LAMP/WAMP、C#网络编程、C++游戏、算法和数据结构、面试总结、人生感悟等。当然还有我和你的故事,感恩一路有你,感谢一路同行,希望通过编程分享帮助到更多人,也希望学成之后回贵州教更多学生。因为喜欢,所以分享,且看且珍惜,加油!等我四年学成归来~

    投票地址:


    一.Roberts算子

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

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

    详细计算公式如下所示:(PS-下图参考自己的书和论文)

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

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

    • src表示输入图像
    • dst表示输出的边缘图,其大小和通道数与输入图像相同
    • ddepth表示目标图像所需的深度
    • kernel表示卷积核,一个单通道浮点型矩阵
    • anchor表示内核的基准点,其默认值为(-1,-1),位于中心位置
    • delta表示在储存目标图像前可选的添加到像素的值,默认值为0
    • borderType表示边框模式

    Python实现代码如下所示:

    # -*- coding: utf-8 -*-
    import cv2  
    import numpy as np  
    import matplotlib.pyplot as plt
     
    #读取图像
    img = cv2.imread('lena.png')
    lenna_img = cv2.cvtColor(img,cv2.COLOR_BGR2RGB)
    
    #灰度化处理图像
    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 = [lenna_img, Roberts]  
    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()
    

    运行结果如下图所示:


    二.Prewitt算子

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

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

    # -*- coding: utf-8 -*-
    import cv2  
    import numpy as np  
    import matplotlib.pyplot as plt
     
    #读取图像
    img = cv2.imread('lena.png')
    lenna_img = 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 = [lenna_img, Prewitt]  
    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()
    

    输出结果如下图所示,左边为原始图像,右边为Prewitt算子图像锐化提取的边缘轮廓,其效果图的边缘检测结果在水平方向和垂直方向均比Robert算子更加明显。


    三.Sobel算子

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

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

    Sobel算子根据像素点上下、左右邻点灰度加权差,在边缘处达到极值这一现象检测边缘。对噪声具有平滑作用,提供较为精确的边缘方向信息。因为Sobel算子结合了高斯平滑和微分求导(分化),因此结果会具有更多的抗噪性,当对精度要求不是很高时,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表示原数组元素按比例缩放后添加的值

    Sobel算子的实现代码如下所示:

    # -*- coding: utf-8 -*-
    import cv2  
    import numpy as np  
    import matplotlib.pyplot as plt
     
    #读取图像
    img = cv2.imread('lena.png')
    lenna_img = 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()
    

    最终输出结果如下图所示:


    四.Laplacian算子

    拉普拉斯(Laplacian)算子是n维欧几里德空间中的一个二阶微分算子,常用于图像增强领域和边缘提取。它通过灰度差分计算邻域内的像素,基本流程是:判断图像中心像素灰度值与它周围其他像素的灰度值,如果中心像素的灰度更高,则提升中心像素的灰度;反之降低中心像素的灰度,从而实现图像锐化操作。在算法实现过程中,Laplacian算子通过对邻域中心像素的四方向或八方向求梯度,再将梯度相加起来判断中心像素灰度与邻域内其他像素灰度的关系,最后通过梯度运算的结果对像素灰度进行调整。

    Laplacian算子分为四邻域和八邻域,四邻域是对邻域中心像素的四方向求梯度,八邻域是对八方向求梯度。其中,四邻域模板如公式所示:

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

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

    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位图进行显示。

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

    # -*- coding: utf-8 -*-
    import cv2  
    import numpy as np  
    import matplotlib.pyplot as plt
     
    #读取图像
    img = cv2.imread('lena.png')
    lenna_img = 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()
    

    最终输出结果如下图所示:


    五.总结代码

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

    # -*- coding: utf-8 -*-
    import cv2  
    import numpy as np  
    import matplotlib.pyplot as plt
    
    #读取图像
    img = cv2.imread('lena.png')
    lenna_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    
    #灰度化处理图像
    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)
    
    #拉普拉斯算法
    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()  
    

    输出结果如图所示。其中,Laplacian算子对噪声比较敏感,由于其算法可能会出现双像素边界,常用来判断边缘像素位于图像的明区或暗区,很少用于边缘检测;Robert算子对陡峭的低噪声图像效果较好,尤其是边缘正负45度较多的图像,但定位准确率较差;Prewitt算子对灰度渐变的图像边缘提取效果较好,而没有考虑相邻点的距离远近对当前像素点的影响;Sobel算子考虑了综合因素,对噪声较多的图像处理效果更好。


    这篇文章写于我2019年4月3日下午下课、接晚上上课前,《大数据技术及应用》这门课程我采用Python进行讲解,围绕爬虫、可视化、分析等案例进行。非常高兴看到,晚上的课,同学们提前两个小时就来把前五排的座位占了,这是之前北理工才能看到的,而且是专业课,我非常欣慰,非常高兴!这就是我来这里当老师的目的,我相信不止有文学、电影这类课程这么吸引学生,专业课同样可以,路还很漫长,我还需继续加油,继续探索。

    同时,这周末忙完研究生复试,今天和女神来钟书阁看书。英语真的太差了,找本书来翻译锻炼下,专业知识也还有好多要学的,时间真是不够。哈哈,笑看人生,加油!

    (By:Eastmount 2019-04-03 下午8点 https://blog.csdn.net/Eastmount/)


    2020年8月18新开的“娜璋AI安全之家”,主要围绕Python大数据分析、网络空间安全、人工智能、Web渗透及攻防技术进行讲解,同时分享CCF、SCI、南核北核论文的算法实现。娜璋之家会更加系统,并重构作者的所有文章,从零讲解Python和安全,写了近十年文章,真心想把自己所学所感所做分享出来,还请各位多多指教,真诚邀请您的关注!谢谢。

    PS:文章参考自己以前系列图像处理文章及OpenCV库函数,同时参考如下文献:

    展开全文
  • sobel 算子 prewitt 算子 roberts 算子 log 算子 zerocross 算子
  • 本资源提供了五种边缘检测算子,包括Sobel 算子roberts 算子、prewitt 算子、log算子、canny算子,用于图像处理中的图像边缘检测。
  • Python Roberts算子、Sobel算子——举例说明 ^_^

    万次阅读 多人点赞 2018-08-07 11:50:29
    题目:Roberts算子 作用模板为: Sobel算子 作用模板为: 设图像为: 问题1:用Roberts算子对其进行锐化,写出锐化过程和结果。 解: 插播一条计算方法: (图片来源:第7章 图像的锐化处理.ppt...

    题目:Roberts算子

    作用模板为:

    Sobel算子

    作用模板为:

    设图像为:

    • 问题1:用Roberts算子对其进行锐化,写出锐化过程和结果。

    解:

    插播一条计算方法:

    (图片来源:第7章 图像的锐化处理.ppt - 豆丁网 http://www.docin.com/p-456906827.html)

    结果:

    • 问题2:用Sobel算子对其进行锐化,写出锐化过程和结果。

    解:

    插播一条计算方法:

    (图片来源:第7章 图像的锐化处理.ppt - 豆丁网 http://www.docin.com/p-456906827.html)

    import numpy as np
    d=np.array([[3,3,3,3,3],[3,8,7,6,3],[3,6,0,5,3],[3,7,8,4,3],[3,8,3,3,3]])
    
    def mySobel(myArray,x,y):
        Dx = (myArray[x+1,y-1]-myArray[x-1,y-1])+2*(myArray[x+1,y]-myArray[x-1,y])+(myArray[x+1,y+1]-myArray[x-1,y+1])
        Dy = (myArray[x-1,y+1]-myArray[x-1,y-1])+2*(myArray[x,y+1]-myArray[x,y-1])+(myArray[x+1,y+1]-myArray[x+1,y-1])
        r = (Dx**2+Dy**2)**0.5
        return r
    
    for i in range(1,len(d)-1):
        for j in range(1,len(d)-1):
            print("({0},{1})→".format(i+1,j+1),int(mySobel(d,i,j)))

    输出:

    (2,2)→ 5
    (2,3)→ 5
    (2,4)→ 5
    (3,2)→ 3
    (3,3)→ 7
    (3,4)→ 4
    (4,2)→ 9
    (4,3)→ 13
    (4,4)→ 7

    展开全文
  • 图像边缘提取——梯度算子、Roberts算子、prewitt算子、Sobel算子、Kirsch算子、LOG算子的matlab实现

    #图像边缘提取——
    ##梯度算子、Roberts算子、prewitt算子、Sobel算子、Kirsch算子、LOG算子的matlab实现

    matlab代码

    clear;
    f=rgb2gray(imread('edge2017.jpg'));
    T=20;%阈值
    [m,n]=size(f);
    %------梯度法-------
    f_g=zeros(m,n);
    for i=2:m-1
        for j=2:n-1
            f_g(i,j)=abs(f(i+1,j)-f(i,j))+abs(f(i,j+1)-f(i,j));
            if f_g(i,j)<T
                f_g(i,j)=0;
            else
                f_g(i,j)=255;
            end
        end
    end
    figure(1);
    subplot(2,3,1);imshow(uint8(f_g));title('梯度法');
     
    %------roberts算子-------
    f_r=zeros(m,n);
    for i=2:m-1
        for j=2:n-1
            f_r(i,j)=abs(f(i+1,j+1)-f(i,j))+abs(f(i,j+1)-f(i+1,j));
            if f_r(i,j)<T
                f_r(i,j)=0;
            else
                f_r(i,j)=255;
            end
        end
    end
    %f_r=imbinarize(imfilter(f,r),T);
    subplot(2,3,2);imshow(uint8(f_r));title('Roberts算子');
     
    %------prewitt算子-------
    f_p=zeros(m,n);
    for i=2:m-1
        for j=2:n-1
            f_p(i,j)=abs(f(i-1,j-1)+f(i,j-1)+f(i+1,j-1)-f(i-1,j+1)-f(i,j+1)-f(i+1,j+1))+abs(f(i+1,j-1)+f(i+1,j)+f(i+1,j+1)-f(i-1,j-1)-f(i-1,j)-f(i-1,j+1));
            if f_p(i,j)<15
                f_p(i,j)=0;
            else
                f_p(i,j)=255;
            end
        end
    end
    subplot(2,3,3);imshow(uint8(f_p));title('Prewitt算子');
     
    %------sobel算子-------
    f_s=zeros(m,n);
    for i=2:m-1
        for j=2:n-1
            f_s(i,j)=abs(f(i-1,j-1)+2*f(i,j-1)+f(i+1,j-1)-f(i-1,j+1)-2*f(i,j+1)-f(i+1,j+1))+abs(f(i+1,j-1)+2*f(i+1,j)+f(i+1,j+1)-f(i-1,j-1)-2*f(i-1,j)-f(i-1,j+1));
            if f_s(i,j)<T
                f_s(i,j)=0;
            else
                f_s(i,j)=255;
            end
        end
    end
    subplot(2,3,4);imshow(uint8(f_s));title('Sobel算子');
     
    %------krisch算子-------
    k(:,:,1)=[-3,-3,-3;
        -3,0,5;
        -3,5,5];
    k(:,:,2)=[-3,-3,5;
        -3,0,5;
        -3,-3,5];
    k(:,:,3)=[-3,5,5;
        -3,0,5;
        -3,-3,-3];
    k(:,:,4)=[-3,-3,-3;
        -3,0,-3;
        5,5,5];
    k(:,:,5)=[5,5,5;
        -3,0,-3;
        -3,-3,-3];
    k(:,:,6)=[-3,-3,-3;
        5,0,-3;
        5,5,-3];
    k(:,:,7)=[5,-3,-3;
        5,0,-3;
        5,-3,-3];
    k(:,:,8)=[5,5,-3;
        5,0,-3;
        -3,-3,-3];
    kk=zeros(size(f));
    I=double(f);
    for i=1:8
        f_k(:,:,i)=conv2(I,k(:,:,i),'same');
        kk=max(kk,f_k(:,:,i));
    end
    f_kk=imbinarize(kk,600);
    subplot(2,3,5);imshow(f_kk);title('Krisch算子');
     
    %------LoG算子-------
    log1=[0 0 -1 0 0;
        0 -1 -2 -1 0;
        -1 -2 16 -2 -1;
        0 -1 -2 -1 0;
        0 0 -1 0 0];
     
    f_l=conv2(f,log1,'same');
    f_ll=imbinarize(abs(f_l),300);
    subplot(2,3,6);imshow(f_ll);title('LoG算子');
    
    

    效果
    这里写图片描述
    这里写图片描述

    展开全文
  • Roberts算子边缘检测

    2010-03-01 19:05:26
    Roberts算子边缘检测matlab源码
  • matlab实现灰度图像边缘检测,本代码采用roberts算子,其他算子代码方法类似!
  • Lab4实现Roberts算子 cuda

    2013-07-22 15:07:12
    Lab4实现Roberts算子,高性能计算,cuda,cpu和Gpu实现代码
  • Roberts算子边缘检测原理及实现

    万次阅读 2019-06-10 17:31:41
    写在前面 我们知道,进行边缘检测有两种方法:一阶导数的极值、二阶导数的过零点。 Robert算子是一种一阶微分算子,而且Robert算子是第一个边缘检测算子,提出者是Lawrence Roberts...Roberts算子是一种斜向偏差分...
  • roberts算子提取边缘

    2016-10-30 20:51:59
    先上图,roberts算子和一阶微分算子提取的边缘。 代码: %roberts微分算子边缘提取 function d=roberts(x,n) d=x; operator=zeros(n); operator(1+(n-1)/2,1+(n-1)/2)=1; operator(1+(n-1)/2+1,1...
  • Roberts算子边缘检测 Roberts算子边缘检测 1. 前言 Roberts算子的算法描述 3. 代码实现 1. 前言 在图像中,灰度或结构等信息的突变处称为边缘。边缘可以看作一个区域的结束,另一个区域的开始。利用边缘的...
  • 亲测Roberts算子,非常特别的好用,顶起来啊
  • Roberts算子,matlab代码实现

    千次阅读 2018-11-25 21:42:52
    这段代码实现了Roberts算子的效果,笔者对其进行了加工,笔者认为这样可以快速的确定最合适的阈值范围,省去了很多的调试步骤!欢迎大家指正,谢谢大家! clear; img = imread('img2.jpg'); % 读取图像 img_gray =...
  • 在图像增强过程中,通常利用各类图像平滑算法消除噪声,图像的常见噪声主要有加性...Roberts算子又称交叉微分算法,它是基于交叉差分的梯度算法,通过局部差分计算检测边缘线条,常来处理具有陡峭的低噪声图像,当图
  • Sobel和Roberts算子的推导过程

    千次阅读 2014-06-17 18:19:35
    Sobel和Roberts算子,这两个算子是梯度算子,是一阶微分算子,可以用来检测图像的边缘。推导过程如下所示,以便以后方便。 Sobel算子的推导: Roberts算子的推导:
  • Roberts算子是一种利用局部差分算子寻找边缘的算子,由下式给出: 其中f(x,y)是具有整数像素坐标的输入图像,平方根运算使该处理类似于在人类视觉系统中发生的过程。 Roberts算子边缘定位准,但是对噪声敏感。适用于...
  • matlab中的sobel, pewitt,roberts 算子图像处理的实现算法
  •   相关的梯度算子、Roberts算子和Sobel算子等算子的具体原理网上有很多博客进行描述,原理就不再啰嗦了,主要工作就是基于libpng库使用纯C++语言不依赖其他额外的库对三个算子进行了实现。   完整的代码仓库见:...
  • 本文提出了一种基于改进的Roberts算子二项式插值亚像素的同心圆检测的方法,不仅计算量小,其定位精度可以达到亚像素级,且具有较好的抗噪性能在机械零件尺寸测量中有很高的应用价值。
  • Roberts算子Roberts算子即为交叉微分算法,它是基于交叉差分的梯度算法,通过局部差分计算检测边缘线条。常用来处理具有陡峭的第噪声图像,当图像边缘接近于正45度或负45度时,该算法处理效果更理想,其缺点时对边缘...
  • 自己实现Roberts算子边缘检测

    千次阅读 2016-09-26 16:11:17
    自己实现Roberts算子的代码 ---------------- #include #include using namespace std; using namespace cv; void Roberts(Mat &src,Mat &dst); void Roberts(Mat &src,Mat &dst) { dst=src.clone(); int nWidth ...
  • 本章将介绍在图像处理中常用到的几个卷积核(算子)实现图像的边缘检测和锐化操作,有Premittt算子、Roberts算子、Sobel算子、Scharr算子、Laplacian算子、LoG算子、Canny算子。 1.Premittt算子 介绍:Prewitt算子是...
  • 今天的猪脚是梯度算子和Roberts算子。 1.梯度算子是怎么来的? 答:图像是一个二维集合,在(x, y)处的偏导数(也就是此点的最大变化率)可以写成下图这样,其梯度大小本为,但由于计算量大,所以简化成 2...
  • roberts算子完成边缘检测及边缘锐化

    千次阅读 2014-09-17 10:41:48
    roberts算子分为x方向梯度算子和y方向梯度算子
  • Roberts算子 Roberts边缘算子是一个2x2的模板,采用的是对角方向相邻的两个像素之差。从图像处理的实际效果来看,边缘定位较准,对噪声敏感。适用于边缘明显且噪声较少的图像分割。Roberts边缘检测算子是一种利用...

空空如也

空空如也

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

roberts算子