精华内容
下载资源
问答
  • 目录 1 边缘检测的基本原理 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

     

     

     

    展开全文
  • 本文分别采用Laplacian算子、Robert算子、Prewitt算子和Sobel算子进行图像锐化边缘处理实验。本文主要讲解灰度线性变换,基础性知识希望对您有所帮助。 1.Roberts算子 2.Prewitt算子 3.Sobel算子 4.Laplacian算子 5....

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

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

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

    该系列在github所有源代码:

    展开全文
  • Prewitt算子

    千次阅读 2013-11-18 13:54:13
    Prewitt算子是一种一阶微分算子的边缘检测,利用像素点上下、左右邻点的灰度差,在边缘处达到 极值检测边缘,去掉部分伪边缘,对噪声具有平滑作用 。其原理是在图像空间利用两个方向模板与图 像进行邻域卷积来完成的...
    Prewitt算子是一种一阶微分算子的边缘检测,利用像素点上下、左右邻点的灰度差,在边缘处达到
    极值检测边缘,去掉部分伪边缘,对噪声具有平滑作用 。其原理是在图像空间利用两个方向模板与图
    像进行邻域卷积来完成的,这两个方向模板一个检测水平边缘,一个检测垂直边缘。

    [1]

    对数字图像f(x,y),Prewitt算子的定义如下:
    G(i)=|[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)]|
    G(j)=|[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)]|
    则 P(i,j)=max[G(i),G(j)]或 P(i,j)=G(i)+G(j)
    经典Prewitt算子认为:凡灰度新值大于或等于阈值的像素点都是边缘点。即选择适当的阈值T,若P(i,j)≥T,则(i,j)为边缘点,P(i,j)为边缘图像。这种判定是欠合理的,会造成边缘点的误判,因为许多噪声点的灰度值也很大,而且对于幅值较小的边缘点,其边缘反而丢失了。
    Prewitt算子程序:
    
    clc
    clear all
    close all
    A = imread('tig.jpg');  %读入图像
    imshow(A);title('原图');
    y_mask = [-1 -1 -1;0 0 0;1 1 1];  %建立Y方向的模板
    x_mask = y_mask';  %建立X方向的模板
    I = im2double(A);   %将图像数据转化为双精度
    dx = imfilter(I, x_mask);  %计算X方向的梯度分量
    dy = imfilter(I, y_mask);  %计算Y方向的梯度分量
    grad = sqrt(dx.*dx + dy.*dy);  %计算梯度
    grad = mat2gray(grad);   %将梯度矩阵转换为灰度图像
    level = graythresh(grad);  %计算灰度阈值
    BW = im2bw(grad,level);  %用阈值分割梯度图像
    figure, imshow(BW);  %显示分割后的图像即边缘图像
    title('Prewitt')
    展开全文
  • 分别采用Roberts?算子、Sobel算子、Prewitt算子和Log算子进行图像锐化
  • sobel 算子 prewitt 算子 roberts 算子 log 算子 zerocross 算子
  • 本资源提供了五种边缘检测算子,包括Sobel 算子、roberts 算子prewitt 算子、log算子、canny算子,用于图像处理中的图像边缘检测。
  • prewitt算子边缘检测

    2018-07-26 14:26:34
    简单的prewitt算子边缘检测,文档内含两幅试验图片(效果不太好,可以换图)
  • Prewitt算子程序

    2013-08-16 11:30:18
    Prewitt算子程序,边缘检测,简单,实用,比较有用!
  • prewitt算子

    千次阅读 2018-06-23 13:38:40
    #include "opencv2/highgui/highgui.hpp" #include "opencv2/imgproc/imgproc.hpp" using namespace cv; int main( int, char** argv ) { Mat src,gray,Kernelx,Kernely;...
    1. #include "opencv2/highgui/highgui.hpp"    
    2. #include "opencv2/imgproc/imgproc.hpp"    
    3. using namespace cv;     
    4.   
    5. int main( intchar** argv )    
    6. {    
    7.     Mat src,gray,Kernelx,Kernely;  
    8.        
    9.     src = imread( argv[1] );    
    10.     cvtColor( src, gray, CV_RGB2GRAY );  
    11.     namedWindow("srcImage", 1);    
    12.     namedWindow("dstImage", 1);    
    13.     
    14.     Kernelx = (Mat_<double>(3,3) << 1, 1, 1, 0, 0, 0, -1, -1, -1);    
    15.     Kernely = (Mat_<double>(3,3) << -1, 0, 1, -1, 0, 1, -1, 0, 1);   
    16.       
    17.     Mat grad_x, grad_y;  
    18.     Mat abs_grad_x, abs_grad_y, grad;  
    19.     
    20.     filter2D(gray, grad_x, CV_16S , Kernelx, Point(-1,-1));    
    21.     filter2D(gray, grad_y, CV_16S , Kernely, Point(-1,-1));  
    22.     convertScaleAbs( grad_x, abs_grad_x );  
    23.     convertScaleAbs( grad_y, abs_grad_y );  
    24.       
    25.     addWeighted( abs_grad_x, 0.5, abs_grad_y, 0.5, 0, grad );   
    26.     imshow("dstImage", grad);    
    27.    
    28.     waitKey();    
    29.     return 0;    
    30. }   
    展开全文
  • 图像边缘检测之Prewitt算子

    千次阅读 2020-05-10 19:45:49
    由于Prewitt算子采用 3x3 模板对区域内的像素值进行计算,而Robert算子的模板为 2x2,故Prewitt算子的边缘检测结果在水平方向和垂直方向均比Robert算子更加明显。Prewitt算子适合用来识别噪声较多、灰度渐变的图像,...
  • 为了提高人脸识别算法的识别性能,提出了基于Prewitt算子的卷积神经网络人脸识别方法。首先通过直方图均衡化和Prewitt算子对人脸图像进行预处理;然后将其输入卷积神经网络进行训练,并采用指数衰减法来设置学习率加快...
  • 本次代码共包含5个程序,均由MATLAB实现,其功能为图像锐化。包含laplacian算子、Prewitt算子、Robert算子、sobel算子实现图像锐化,并有一维和二维laplacian算子对比。内还有各个算子的运算过程(Word文档)
  • 自编matlab下的边缘检测算法,以prewitt算子示例
  • 基于Prewitt算子的卷积神经网络人脸识别方法.pdf
  • 10.1 Python图像处理之边缘算子-Sobel算子、Roberts算子、拉普拉斯算子、Canny算子、Prewitt算子、高斯拉普拉斯算子 文章目录10.1 Python图像处理之边缘算子-Sobel算子、Roberts算子、拉普拉斯算子、Canny算子、...
  • java 边缘检测 sobel算子和Prewitt算子

    千次阅读 2014-07-27 17:15:16
    Prewitt算子
  • Matlab采用梯度算子、拉普拉斯算子、Sobel算子及Prewitt算子对图像进行锐化 文章目录Matlab采用梯度算子、拉普拉斯算子、Sobel算子及Prewitt算子对图像进行锐化梯度算子拉普拉斯算子Robel算子Prewitt算子整体程序:...
  • prewitt算子高通滤波

    2010-06-14 20:53:05
    prewitt算子高通滤波 windows平台 MFC编写
  • Prewitt算子计算图像梯度

    千次阅读 2018-11-28 08:52:33
    Prewitt算子是一阶微分算子的边缘检测,利用像素点上下、左右邻点的灰度差,在边缘处达到极值检测边缘,去掉部分伪边缘,对噪声具有平滑作用。其原理是在图像空间利用两个方向模板与图像进行邻域卷积来完成,这两个...
  • 垂直水平方向 垂直水平方向的Prewitt算子是可分离的卷积核。 45°、135°方向
  • prewitt算子实现

    2021-06-13 14:07:32
    //获取Prewitt算子 Mat getPrewitt_horizontal = (Mat_<float>(3, 3) << -1, -1, -1, 0, 0, 0, 1, 1, 1); //水平方向 Mat getPrewitt_vertical = (Mat_<float>(3, 3) << -1, 0, 1, -1, 0...
  • 请用MATLAB或其它语言编写相关程序,输入一幅灰度图像,分别采用梯度算子、拉普拉斯算子、Sobel算子、Prewitt算子对图像进行锐化,在同一个窗口输出显示原始图像和4种结果图像。
  • 图像边缘提取——梯度算子、Roberts算子、prewitt算子、Sobel算子、Kirsch算子、LOG算子的matlab实现
  • 基于Prewitt算子的抗雷达同频干扰法设计与FPGA实现.pdf
  • Matlab数字图像处理——Sobel算子锐化、Prewitt算子锐化
  • Sobel和 Prewitt算子思想 之所以把这个两个算子拿出来一起说,是因为Sobel算子可以看做是Prewitt的改进版本,向对于Prewitt算子,Sobel算子的模板使用的权值2,可以增加中心点的重要性,在某种程度上实现平滑效果。 ...
  • Prewitt算子边缘检测原理及实现

    万次阅读 2019-06-10 18:22:36
    Prewitt算子同样也是一种一阶微分算子,利用像素点上下左右邻点灰度差,在边缘处达到极值检测边缘,对噪声具有平滑的作用。 原理 其原理是在图像空间利用两个方向模板与图像进行邻域卷积来完成的,这两个方向模板...
  • Prewitt算子的运用

    千次阅读 2015-07-15 14:46:57
    Prewitt算子折叠 是一种一阶微分算子的边缘检测,利用像素点上下、左右邻点的灰度差,在边缘处达到 极值检测边缘,去掉部分伪边缘,对噪声具有平滑作用 。其原理是在图像空间利用两个方向模板与图 像...
  • Robert算子、sobel算子、Prewitt算子、canny边缘检测算子 之前做的笔记,懒得再敲一遍了,先传上来,方便自己以后加深记忆

空空如也

空空如也

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

prewitt算子