数字图像处理(19): 边缘检测算子(Roberts算子、Prewitt算子、Sobel算子和 Laplacian算子)

柔光的暖阳◎ 2022-02-05 07:21 702阅读 0赞

![20190702121634683.png_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aW9uZ3lpbWluZy5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70][]

**目录**

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所示，当我们看到一个有边缘的物体时，首先感受到的就是**边缘**。

![20190505102611513.png][] 图1 灰度级跃变的边缘模型

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

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

--------------------

# 2 边缘检测算子分类 #

（1）一阶导数的边缘算子

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

（2）二阶导数的边缘算子

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

（3）其他边缘算子

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

--------------------

# 3 梯度 #

## 3.1 图像梯度 ##

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

为了在一幅图像![f][] 的![(x,y)][x_y]位置处寻找**边缘**的强度和方向，所以选择的工具就是**梯度**，梯度用![\\nabla f][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_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][nabla f] 为一个向量，它表示![f][] 在位置![(x,y)][x_y] 处的最大变化率的方向。

梯度![\\nabla f][nabla f] 的大小用![M(x,y)][M_x_y] 表示，则：

![M(x,y)=mag(\\nabla f)=\\sqrt\{g\_\{x\}^\{2\}+g\_\{y\}^\{2\}\}][M_x_y_mag_nabla f_sqrt_g_x_2_g_y_2]

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

**数学梯度的简单推导**

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

![\\nabla f=\\frac\{\\partial f\}\{\\partial x\}=\{\{f\}^\{'\}\}(x)=f(x+1)-f(x)][nabla f_frac_partial f_partial x_f_x_f_x_1_-f_x]

## 3.2 梯度算子 ##

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

![\{\{g\}\_\{x\}\}=\\frac\{\\partial f(x,y)\}\{\\partial x\}=f(x+1,y)-f(x,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)][g_y_frac_partial f_x_y_partial y_f_x_y_1_-f_x_y]

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

![20200527091431152.png][]

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

对于不同的滤波器模板得到的梯度是不同的，这也就衍生出很多算子，如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\]][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_x] 和 ![\{g\}\_\{y\}\}][g_y] 分别计算为：

![20190505104614320.png][]

![\{\{g\}\_\{x\}\}=\\frac\{\\partial f\}\{\\partial x\}=\\text\{P9-P5\}][g_x_frac_partial f_partial x_text_P9-P5]

![\{\{g\}\_\{y\}\}=\\frac\{\\partial f\}\{\\partial y\}=\\text\{P8-P6\}][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()

运行结果如下图所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3phaXNodWl5aWZhbmd4eW0_size_16_color_FFFFFF_t_70][]

--------------------

# 5 Prewitt 算子 #

## 5.1 基本原理 ##

**Prewitt算子**是一种图像边缘检测的微分算子，其原理是利用特定区域内像素灰度值产生的差分实现边缘检测。由于Prewitt算子采用 3![\\times][times]3 模板对区域内的像素值进行计算，而Robert算子的模板为 2![\\times][times]2，故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\]][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_x] 和 ![\{g\}\_\{y\}\}][g_y] 分别计算为：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3phaXNodWl5aWZhbmd4eW0_size_16_color_FFFFFF_t_70 1][]

![\{\{g\}\_\{x\}\}=\\frac\{\\partial f\}\{\\partial x\}=(\\text\{P7+P8+P9)-\}(\\text\{P1+P2+P3)\}][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)\}][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()

运行结果如下图所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3phaXNodWl5aWZhbmd4eW0_size_16_color_FFFFFF_t_70 2][]

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

--------------------

# 6 Sobel 算子 #

## 6.1 基本原理 ##

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

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

Sobel算子的边缘定位更准确，常用于噪声较多、灰度渐变的图像。其算法模板如下面的公式所示，其中 ![\{\{d\}\_\{x\}\}][d_x] 表示水平方向，![\{\{d\}\_\{y\}\}][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\]][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_x] 和 ![\{g\}\_\{y\}\}][g_y] 分别计算为：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3phaXNodWl5aWZhbmd4eW0_size_16_color_FFFFFF_t_70 3][]

![\{\{g\}\_\{x\}\}=\\frac\{\\partial f\}\{\\partial x\}=(\\text\{P7+2P8+P9)-\}(\\text\{P1+2P2+P3)\}][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)\}][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()

运行结果如下图所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3phaXNodWl5aWZhbmd4eW0_size_16_color_FFFFFF_t_70 4][]

--------------------

# 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\]][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\]][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位图**进行显示。其函数用法如下：

当ksize=1时，**Laplacian()** 函数采用 3![\\times][times]3 的孔径 (四邻域模板) 进行变换处理。下面的代码是采用 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()

运行结果如下图所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3phaXNodWl5aWZhbmd4eW0_size_16_color_FFFFFF_t_70 5][]

--------------------

# 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()

运行结果如下图所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3phaXNodWl5aWZhbmd4eW0_size_16_color_FFFFFF_t_70 6][]

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3phaXNodWl5aWZhbmd4eW0_size_16_color_FFFFFF_t_70 7][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3phaXNodWl5aWZhbmd4eW0_size_16_color_FFFFFF_t_70 8][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3phaXNodWl5aWZhbmd4eW0_size_16_color_FFFFFF_t_70 9][]

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

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][https_blog.csdn.net_Eastmount_article_details_89001702]

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

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

--------------------

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

1. 微信公众号:

![20200627154603554.jpg][]

2. CSDN博客：[https://xiongyiming.blog.csdn.net/][https_xiongyiming.blog.csdn.net]

3. 知乎：[https://www.zhihu.com/people/xiongyiming][https_www.zhihu.com_people_xiongyiming]

[20190702121634683.png_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aW9uZ3lpbWluZy5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70]: /images/20220205/0be4a112180c46fc83c73b253bbdfcba.png
[20190505102611513.png]: /images/20220205/d27a622087264032ae629e03bd6bc7ef.png
[f]: https://private.codecogs.com/gif.latex?f
[x_y]: https://private.codecogs.com/gif.latex?%28x%2Cy%29
[nabla f]: https://private.codecogs.com/gif.latex?%5Cnabla%20f
[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]: https://private.codecogs.com/gif.latex?%5Cnabla%20f%5Cequiv%20%5Ctext%7Bgrad%7D%28f%29%5Cequiv%20%5Cleft%5B%20%5Cbegin%7Bmatrix%7D%20%7B%7Bg%7D_%7Bx%7D%7D%20%5C%5C%20%7B%7Bg%7D_%7By%7D%7D%20%5C%5C%20%5Cend%7Bmatrix%7D%20%5Cright%5D%5Cequiv%20%5Cleft%5B%20%5Cbegin%7Bmatrix%7D%20%5Cfrac%7B%5Cpartial%20f%7D%7B%5Cpartial%20x%7D%20%5C%5C%20%7B%7D%20%5C%5C%20%5Cfrac%7B%5Cpartial%20f%7D%7B%5Cpartial%20y%7D%20%5C%5C%20%5Cend%7Bmatrix%7D%20%5Cright%5D
[M_x_y]: https://private.codecogs.com/gif.latex?M%28x%2Cy%29
[M_x_y_mag_nabla f_sqrt_g_x_2_g_y_2]: https://private.codecogs.com/gif.latex?M%28x%2Cy%29%3Dmag%28%5Cnabla%20f%29%3D%5Csqrt%7Bg_%7Bx%7D%5E%7B2%7D&plus;g_%7By%7D%5E%7B2%7D%7D
[f_x]: https://private.codecogs.com/gif.latex?f%28x%29
[x]: https://private.codecogs.com/gif.latex?x
[f_x_Delta x]: https://private.codecogs.com/gif.latex?f%28x&plus;%5CDelta%20x%29
[Delta x_1]: https://private.codecogs.com/gif.latex?%5CDelta%20x%3D1
[nabla f_frac_partial f_partial x_f_x_f_x_1_-f_x]: https://private.codecogs.com/gif.latex?%5Cnabla%20f%3D%5Cfrac%7B%5Cpartial%20f%7D%7B%5Cpartial%20x%7D%3D%7B%7Bf%7D%5E%7B%27%7D%7D%28x%29%3Df%28x&plus;1%29-f%28x%29
[y]: https://private.codecogs.com/gif.latex?y
[g_x]: https://private.codecogs.com/gif.latex?%7Bg%7D_%7Bx%7D%7D
[g_y]: https://private.codecogs.com/gif.latex?%7Bg%7D_%7By%7D%7D
[g_x_frac_partial f_x_y_partial x_f_x_1_y_-f_x_y]: https://private.codecogs.com/gif.latex?%7B%7Bg%7D_%7Bx%7D%7D%3D%5Cfrac%7B%5Cpartial%20f%28x%2Cy%29%7D%7B%5Cpartial%20x%7D%3Df%28x&plus;1%2Cy%29-f%28x%2Cy%29
[g_y_frac_partial f_x_y_partial y_f_x_y_1_-f_x_y]: https://private.codecogs.com/gif.latex?%7B%7Bg%7D_%7By%7D%7D%3D%5Cfrac%7B%5Cpartial%20f%28x%2Cy%29%7D%7B%5Cpartial%20y%7D%3Df%28x%2Cy&plus;1%29-f%28x%2Cy%29
[f_x_y]: https://private.codecogs.com/gif.latex?f%28x%2Cy%29
[20200527091431152.png]: /images/20220205/bc5a1d3dc22f4405a7e9cb424282d314.png
[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]: https://private.codecogs.com/gif.latex?%7B%7Bd%7D_%7Bx%7D%7D%3D%5Cleft%5B%20%5Cbegin%7Bmatrix%7D%20-1%20%26%200%20%5C%5C%200%20%26%201%20%5C%5C%20%5Cend%7Bmatrix%7D%20%5Cright%5D%5Cbegin%7Bmatrix%7D%20%7B%7D%20%26%20%7B%7D%20%5C%5C%20%7B%7D%20%26%20%7B%7D%20%5C%5C%20%5Cend%7Bmatrix%7D%7B%7Bd%7D_%7By%7D%7D%3D%5Cleft%5B%20%5Cbegin%7Bmatrix%7D%200%20%26%20-1%20%5C%5C%201%20%26%200%20%5C%5C%20%5Cend%7Bmatrix%7D%20%5Cright%5D
[20190505104614320.png]: /images/20220205/40b2969d76874183bc35a8d20a9532c0.png
[g_x_frac_partial f_partial x_text_P9-P5]: https://private.codecogs.com/gif.latex?%7B%7Bg%7D_%7Bx%7D%7D%3D%5Cfrac%7B%5Cpartial%20f%7D%7B%5Cpartial%20x%7D%3D%5Ctext%7BP9-P5%7D
[g_y_frac_partial f_partial y_text_P8-P6]: https://private.codecogs.com/gif.latex?%7B%7Bg%7D_%7By%7D%7D%3D%5Cfrac%7B%5Cpartial%20f%7D%7B%5Cpartial%20y%7D%3D%5Ctext%7BP8-P6%7D
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3phaXNodWl5aWZhbmd4eW0_size_16_color_FFFFFF_t_70]: /images/20220205/025f1c8e9d074ac09972899e67dea00d.png
[times]: https://private.codecogs.com/gif.latex?%5Ctimes
[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]: https://private.codecogs.com/gif.latex?%7B%7Bd%7D_%7By%7D%7D%3D%5Cleft%5B%20%5Cbegin%7Bmatrix%7D%20-1%20%26%200%20%26%201%20%5C%5C%20-1%20%26%200%20%26%201%20%5C%5C%20-1%20%26%200%20%26%201%20%5C%5C%20%5Cend%7Bmatrix%7D%20%5Cright%5D%5Cbegin%7Bmatrix%7D%20%7B%7D%20%26%20%7B%7D%20%26%20%7B%7D%20%5C%5C%20%7B%7D%20%26%20%7B%7D%20%26%20%7B%7D%20%5C%5C%20%7B%7D%20%26%20%7B%7D%20%26%20%7B%7D%20%5C%5C%20%5Cend%7Bmatrix%7D%7B%7Bd%7D_%7Bx%7D%7D%3D%5Cleft%5B%20%5Cbegin%7Bmatrix%7D%20-1%20%26%20-1%20%26%20-1%20%5C%5C%200%20%26%200%20%26%200%20%5C%5C%201%20%26%201%20%26%201%20%5C%5C%20%5Cend%7Bmatrix%7D%20%5Cright%5D
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3phaXNodWl5aWZhbmd4eW0_size_16_color_FFFFFF_t_70 1]: /images/20220205/2954830e6e234b90aecd2a25e9020723.png
[g_x_frac_partial f_partial x_text_P7_P8_P9_-_text_P1_P2_P3]: https://private.codecogs.com/gif.latex?%7B%7Bg%7D_%7Bx%7D%7D%3D%5Cfrac%7B%5Cpartial%20f%7D%7B%5Cpartial%20x%7D%3D%28%5Ctext%7BP7&plus;P8&plus;P9%29-%7D%28%5Ctext%7BP1&plus;P2&plus;P3%29%7D
[g_y_frac_partial f_partial y_text_P3_P6_P9_-_text_P1_P4_P7]: https://private.codecogs.com/gif.latex?%7B%7Bg%7D_%7By%7D%7D%3D%5Cfrac%7B%5Cpartial%20f%7D%7B%5Cpartial%20y%7D%3D%28%5Ctext%7BP3&plus;P6&plus;P9%29-%7D%28%5Ctext%7BP1&plus;P4&plus;P7%29%7D
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3phaXNodWl5aWZhbmd4eW0_size_16_color_FFFFFF_t_70 2]: /images/20220205/e459d93e718e4f3283130ea330968cab.png
[d_x]: https://private.codecogs.com/gif.latex?%7B%7Bd%7D_%7Bx%7D%7D
[d_y]: https://private.codecogs.com/gif.latex?%7B%7Bd%7D_%7By%7D%7D
[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]: https://private.codecogs.com/gif.latex?%7B%7Bd%7D_%7Bx%7D%7D%3D%5Cleft%5B%20%5Cbegin%7Bmatrix%7D%20-1%20%26%200%20%26%201%20%5C%5C%20-2%20%26%200%20%26%202%20%5C%5C%20-1%20%26%200%20%26%201%20%5C%5C%20%5Cend%7Bmatrix%7D%20%5Cright%5D%5Cbegin%7Bmatrix%7D%20%7B%7D%20%26%20%7B%7D%20%26%20%7B%7D%20%5C%5C%20%7B%7D%20%26%20%7B%7D%20%26%20%7B%7D%20%5C%5C%20%7B%7D%20%26%20%7B%7D%20%26%20%7B%7D%20%5C%5C%20%5Cend%7Bmatrix%7D%7B%7Bd%7D_%7By%7D%7D%3D%5Cleft%5B%20%5Cbegin%7Bmatrix%7D%20-1%20%26%20-2%20%26%20-1%20%5C%5C%200%20%26%200%20%26%200%20%5C%5C%201%20%26%202%20%26%201%20%5C%5C%20%5Cend%7Bmatrix%7D%20%5Cright%5D
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3phaXNodWl5aWZhbmd4eW0_size_16_color_FFFFFF_t_70 3]: /images/20220205/eabc7828d8ae4aeea6baddecb636bbf2.png
[g_x_frac_partial f_partial x_text_P7_2P8_P9_-_text_P1_2P2_P3]: https://private.codecogs.com/gif.latex?%7B%7Bg%7D_%7Bx%7D%7D%3D%5Cfrac%7B%5Cpartial%20f%7D%7B%5Cpartial%20x%7D%3D%28%5Ctext%7BP7&plus;2P8&plus;P9%29-%7D%28%5Ctext%7BP1&plus;2P2&plus;P3%29%7D
[g_y_frac_partial f_partial y_text_P3_2P6_P9_-_text_P1_2P4_P7]: https://private.codecogs.com/gif.latex?%7B%7Bg%7D_%7By%7D%7D%3D%5Cfrac%7B%5Cpartial%20f%7D%7B%5Cpartial%20y%7D%3D%28%5Ctext%7BP3&plus;2P6&plus;P9%29-%7D%28%5Ctext%7BP1&plus;2P4&plus;P7%29%7D
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3phaXNodWl5aWZhbmd4eW0_size_16_color_FFFFFF_t_70 4]: /images/20220205/c9479bf7b50a447c9c4e145403e4375c.png
[n]: https://private.codecogs.com/gif.latex?n
[text_H_left_ _begin_matrix_ 0 _ -1 _ 0 _ -1 _ 4 _ -1 _ 0 _ -1 _ 0 _ _end_matrix_ _right]: https://private.codecogs.com/gif.latex?%5Ctext%7BH%7D%3D%5Cleft%5B%20%5Cbegin%7Bmatrix%7D%200%20%26%20-1%20%26%200%20%5C%5C%20-1%20%26%204%20%26%20-1%20%5C%5C%200%20%26%20-1%20%26%200%20%5C%5C%20%5Cend%7Bmatrix%7D%20%5Cright%5D
[text_H_left_ _begin_matrix_ -1 _ -1 _ -1 _ -1 _ 8 _ -1 _ -1 _ -1 _ -1 _ _end_matrix_ _right]: https://private.codecogs.com/gif.latex?%5Ctext%7BH%7D%3D%5Cleft%5B%20%5Cbegin%7Bmatrix%7D%20-1%20%26%20-1%20%26%20-1%20%5C%5C%20-1%20%26%208%20%26%20-1%20%5C%5C%20-1%20%26%20-1%20%26%20-1%20%5C%5C%20%5Cend%7Bmatrix%7D%20%5Cright%5D
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3phaXNodWl5aWZhbmd4eW0_size_16_color_FFFFFF_t_70 5]: /images/20220205/5d0c2eeb9caa4d8c971cbeb6eb8c2f9c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3phaXNodWl5aWZhbmd4eW0_size_16_color_FFFFFF_t_70 6]: /images/20220205/82ab464386a7494ca96cdb4b73a810e8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3phaXNodWl5aWZhbmd4eW0_size_16_color_FFFFFF_t_70 7]: /images/20220205/317c036bd70b4bda8cae7b535edc0ce7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3phaXNodWl5aWZhbmd4eW0_size_16_color_FFFFFF_t_70 8]: /images/20220205/4ec5bb8ca3484884929fa82a2f6e85ff.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3phaXNodWl5aWZhbmd4eW0_size_16_color_FFFFFF_t_70 9]: /images/20220205/0ea33ba4ffc34529bd3d7eb69bbeb6fe.png
[https_blog.csdn.net_Eastmount_article_details_89001702]: https://blog.csdn.net/Eastmount/article/details/89001702
[.]: https://download.csdn.net/download/zaishuiyifangxym/10044192
[20200627154603554.jpg]: /images/20220205/dd5835e79696458181e36c1c76f286da.png
[https_xiongyiming.blog.csdn.net]: https://xiongyiming.blog.csdn.net/
[https_www.zhihu.com_people_xiongyiming]: https://www.zhihu.com/people/xiongyiming