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

    2020-10-19 20:14:44
    彻底理解数字图像处理中的卷积-以Sobel算子为例https://www.cnblogs.com/freeblues/p/5738987.html python自编程序实现——robert算子、sobel算子、Laplace算子进行图像边缘提取...
    展开全文
  • Sobel算子

    2021-05-16 10:57:01
    Sobel算子 卷积的应用 图像边缘提取 边缘:是像素值发生跃迁的地方,是图像的显著特征之一,在图像特的显著特征之一,在图像特诊提取、对象检测、模式识别等方面都有重要的作用。 捕捉/提取边缘:对图像求它的一阶...

    Sobel算子

    卷积的应用

    图像边缘提取
    在这里插入图片描述

    • 边缘:是像素值发生跃迁的地方,是图像的显著特征之一,在图像特的显著特征之一,在图像特诊提取、对象检测、模式识别等方面都有重要的作用。
    • 捕捉/提取边缘:对图像求它的一阶导数 delta=f(x)-f(x-1),delta越大,说明像素在X方向变化越大,边缘信号越强。
    Sobel算子
    • 是离散微分算子,用来计算图像灰度的近似梯度
    • Soble算子功能集合高斯平滑和微分求导
    • 又被称为一阶微分算子,求导算子,在水平和垂直两个方向上求导,得到图像X方法于Y方法梯度图像。

    在这里插入图片描述

    • 求导的近似值,kernel=3时不是很准确,OpenCV使用改进版本Scharr函数,算子如下:
      在这里插入图片描述
    API说明
    • CV::Sobel
    cv::Sobel(
    InputArray src,//输入图像
    OutputArray dst,//输出图像,大小与输入图像一致
    int depth,//输出图像深度
    int dx,//X方向,几阶导数
    int dy,//Y方向,几阶导数
    int ksize,//SOBEL算子kernel大小,必须是 1、3、5、7
    double scale=1,
    double delta=0,
    int borderType=BORDER_DEFAULT
    )
    

    在这里插入图片描述

    • cv::Scharr
    cv::Scharr(
    InputArray Src,//输入图像
    OutputArray dst,//输出图像,大小与输入图像一致
    int depth,//输出图像深度
    int dx,//X方向,几阶导数
    int dy,//Y方向,几阶导数
    double scale=1,
    double delta=0,
    int borderType=BORDER_DEFAULT
    )
    
    其他API
    • GaussianBlur(src,dst,Size(3,3),0,0,BORDER_DEFAULT);

    • cvtColor(src,gray,COLOR_RGB2GRAY);

    • addWeighted(A,0.5,B,0.5,0,AB);

    • convertScaleAbs(A,B)//计算图像A的像素绝对值,输出到图像B

      dst(I)=saturate\_cast<ucahr>(|src(I)*alpha+beta|)
      
    代码

    实现:在这里插入图片描述

    #include<opencv2/opencv.hpp>
    #include<iostream>
    #include<math.h>
    
    using namespace cv;
    int main(int argc,char** argv){
    	Mat src,dst;
    	src=imread("E:/opencv/zzz/hbz.jpg");
    	if(!src.data){
    		printf("could not load image...\n");
    		return -1;
    	}
    
    	char INPUT_TITLE[]="input image";
    	char OUTPUT_TITLE[]="Final Result";
    	namedWindow(INPUT_TITLE,CV_WINDOW_AUTOSIZE);
    	namedWindow(OUTPUT_TITLE,CV_WINDOW_AUTOSIZE);
    	imshow(INPUT_TITLE,src);
    
    	GaussianBlur(src,dst,Size(3,3),0,0);
    	Mat gray_src;
    	cvtColor(dst,gray_src,CV_BGR2GRAY);
    	imshow("gray image",gray_src);
    
    	Mat xgrad,ygrad;
    	Scharr(gray_src,xgrad,CV_16S,1,0);
    	Scharr(gray_src,ygrad,CV_16S,0,1);
    	//Sobel(gray_src,xgrad,CV_16S,1,0,3);
    	//Sobel(gray_src,ygrad,CV_16S,0,1,3);
    	convertScaleAbs(xgrad,xgrad);
    	convertScaleAbs(ygrad,ygrad);
    
    	/*
    	Sobel(gray_src,xgrad,-1,1,0,3);
    	Sobel(gray_src,ygrad,-1,0,1,3);*/
    
    	imshow("xgrad",xgrad);
    	imshow("ygrad",ygrad);
    
    	/*
    	Mat xygrad;
    	addWeighted(xgrad,0.5,ygrad,0.5,0,xygrad);
    	imshow("Final Result",xygrad);*/
    	Mat xygrad=Mat(xgrad.size(),xgrad.type());
    	printf("type:%d",xgrad.type());
    	int width=xgrad.cols;
    	int height=ygrad.rows;
    	for(int row=0;row<height;row++){
    		for(int col=0;col<width;col++){
    			int xg=xgrad.at<uchar>(row,col);
    			int yg=ygrad.at<uchar>(row,col);
    			int xy=xg+yg;
    			xygrad.at<uchar>(row,col)=saturate_cast<uchar>(xy);
    		}
    	}
    	imshow(OUTPUT_TITLE,xygrad);
    
    	waitKey(0);
    	return 0;
    }
    
    显示

    在这里插入图片描述
    注:笔记来源观看此教程的记录:https://www.bilibili.com/video/BV1Q54y1z7kz?p=18

    展开全文
  • 目录 1 边缘检测的基本原理 2 边缘检测算子分类 3 梯度 3.1 图像梯度 3.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

     

     

     

    展开全文
  • Sobel算子用例

    2018-06-29 15:37:13
    c++ opencv中的sobel算子用例,Sobel算子是像素图像边缘检测中最重要的算子之一,在机器学习、数字媒体、计算机视觉等信息科技领域起着举足轻重的作用。
  • 本文分别采用Laplacian算子、Robert算子、Prewitt算子和Sobel算子进行图像锐化边缘处理实验。本文主要讲解灰度线性变换,基础性知识希望对您有所帮助。 1.Roberts算子 2.Prewitt算子 3.Sobel算子 4.Laplacian算子 5....

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

    该系列在github所有源代码:https://github.com/eastmountyxz/ImageProcessing-Python
    PS:请求帮忙点个Star,哈哈,第一次使用Github,以后会分享更多代码,一起加油。

    同时推荐作者的C++图像系列知识:
    [数字图像处理] 一.MFC详解显示BMP格式图片
    [数字图像处理] 二.MFC单文档分割窗口显示图片
    [数字图像处理] 三.MFC实现图像灰度、采样和量化功能详解
    [数字图像处理] 四.MFC对话框绘制灰度直方图
    [数字图像处理] 五.MFC图像点运算之灰度线性变化、灰度非线性变化、阈值化和均衡化处理详解
    [数字图像处理] 六.MFC空间几何变换之图像平移、镜像、旋转、缩放详解
    [数字图像处理] 七.MFC图像增强之图像普通平滑、高斯平滑、Laplacian、Sobel、Prewitt锐化详解

    前文参考:
    [Python图像处理] 一.图像处理基础知识及OpenCV入门函数
    [Python图像处理] 二.OpenCV+Numpy库读取与修改像素
    [Python图像处理] 三.获取图像属性、兴趣ROI区域及通道处理
    [Python图像处理] 四.图像平滑之均值滤波、方框滤波、高斯滤波及中值滤波
    [Python图像处理] 五.图像融合、加法运算及图像类型转换
    [Python图像处理] 六.图像缩放、图像旋转、图像翻转与图像平移
    [Python图像处理] 七.图像阈值化处理及算法对比
    [Python图像处理] 八.图像腐蚀与图像膨胀
    [Python图像处理] 九.形态学之图像开运算、闭运算、梯度运算
    [Python图像处理] 十.形态学之图像顶帽运算和黑帽运算
    [Python图像处理] 十一.灰度直方图概念及OpenCV绘制直方图
    [Python图像处理] 十二.图像几何变换之图像仿射变换、图像透视变换和图像校正
    [Python图像处理] 十三.基于灰度三维图的图像顶帽运算和黑帽运算
    [Python图像处理] 十四.基于OpenCV和像素处理的图像灰度化处理
    [Python图像处理] 十五.图像的灰度线性变换
    [Python图像处理] 十六.图像的灰度非线性变换之对数变换、伽马变换

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

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

    本文主要讲解灰度线性变换,基础性知识希望对您有所帮助。
    1.Roberts算子
    2.Prewitt算子
    3.Sobel算子
    4.Laplacian算子
    5.总结代码

    PS:文章参考自己以前系列图像处理文章及OpenCV库函数,同时参考如下文献:
    杨秀璋等. 基于苗族服饰的图像锐化和边缘提取技术研究[J]. 现代计算机,2018(10).
    《数字图像处理》(第3版),冈萨雷斯著,阮秋琦译,电子工业出版社,2013年.
    《数字图像处理学》(第3版),阮秋琦,电子工业出版社,2008年,北京.
    《OpenCV3编程入门》,毛星云,冷雪飞,电子工业出版社,2015.
    [数字图像处理] 七.MFC图像增强之图像普通平滑、高斯平滑、Laplacian、Sobel、Prewitt锐化详解

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

    投票地址:http://m234140.nofollow.ax.mvote.cn/opage/ed8141a0-ed19-774b-6b0d-39c3aaf89dde.html?from=singlemessage

    在这里插入图片描述


    一.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和安全,写了近十年文章,真心想把自己所学所感所做分享出来,还请各位多多指教,真诚邀请您的关注!谢谢。

    展开全文
  • Sobel算子matlab实现

    2020-07-31 13:36:46
    这里给大家分享一个Sobel算子matlab实现的源代码。
  • sobel算子 边缘检测

    2015-09-25 23:18:28
    详细讲解sobel算子的原理,有程序与实例图像,sobel算子是边缘检测的基本算子之一。
  • sobel 算子 prewitt 算子 roberts 算子 log 算子 zerocross 算子
  • 18-Sobel算子

    2020-02-12 20:22:03
    文章目录Sobel算子 Sobel算子
  • 2. Sobel算子 3. 拉普拉斯算子 算法原理 1. Robert算子 输出结果: 2.sobel算子 输出结果 3. 拉普拉斯算子 输出结果" 代码 #include <ostream> #include <opencv.hpp> int ...
  • OpenCV Sobel算子

    千次阅读 2017-12-03 10:24:15
    Sobel算子
  • 本资源提供了五种边缘检测算子,包括Sobel 算子、roberts 算子、prewitt 算子、log算子、canny算子,用于图像处理中的图像边缘检测。
  • Sobel 算子、Scharr 算子、laplacian 算子
  • python opencv sobel算子 laplace算子 canny算子
  • sobel算子,scharr算子,Laplacian算子

    千次阅读 2020-03-07 11:22:34
    1.sobel算子sobel算子可以计算图像梯度,计算图像梯度的作用是提取边界,一般我们用一个3x3的卷积核去指示sobel算子是如何运算的: 图中左边就是计算水平梯度时的卷积核,简单来说就是右边减左边,权重由卷积核...
  • 一种改进的八方向的sobel算子,matlab源代码
  • 算子实际上是用来对图像进行卷积处理,其本质是用变分法来处理梯度问题,用途就是边缘检测。45度和135度效果一般,水平检测加垂直检测效果还可以。function Sobel(name,Threshold)f = imread(name);f = rgb2gray(f);f...
  • Sobel算子杂谈

    2021-01-06 11:33:52
    Sobel算子杂谈 Sobel算子是一种数字图像处理种常用的边缘提取算子,更多基础内容可以参考冈萨雷斯版《数字图像处理》,这里不做过多介绍。 基本概念 Sobel算子包括检测水平变化的卷积核GxG_xGx​和检测垂直方向变化...
  • Sobel算子C++源码

    2017-04-07 12:54:25
    Sobel算子C++源码在VS2015中可用

空空如也

空空如也

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

sobel算子