Python 图像处理 OpenCV （12）： Roberts 算子、 Prewitt 算子、 Sobel 算子和 Laplacian 算子边缘检测技术

2020-06-29 00:00:00 图像 算子 灰度 边缘 邻域

前文传送门：

「Python 图像处理 OpenCV （1）：入门」

「Python 图像处理 OpenCV （2）：像素处理与 Numpy 操作以及 Matplotlib 显示图像」

「Python 图像处理 OpenCV （3）：图像属性、图像感兴趣 ROI 区域及通道处理」

「Python 图像处理 OpenCV （4）：图像算数运算以及修改颜色空间」

「Python 图像处理 OpenCV （5）：图像的几何变换」

「Python 图像处理 OpenCV （6）：图像的阈值处理」

「Python 图像处理 OpenCV （7）：图像平滑（滤波）处理」

「Python 图像处理 OpenCV （8）：图像腐蚀与图像膨胀」

「Python 图像处理 OpenCV （9）：图像处理形态学开运算、闭运算以及梯度运算」

「Python 图像处理 OpenCV （10）：图像处理形态学之顶帽运算与黑帽运算」

「Python 图像处理 OpenCV （11）：Canny 算子边缘检测技术」

引言

前文介绍了 Canny 算子边缘检测，本篇继续介绍 Roberts 算子、 Prewitt 算子、 Sobel 算子和 Laplacian 算子等常用边缘检测技术。

Roberts 算子

Roberts 算子，又称罗伯茨算子，是一种简单的算子，是一种利用局部差分算子寻找边缘的算子。他采用对角线方向相邻两象素之差近似梯度幅值检测边缘。检测垂直边缘的效果好于斜向边缘，定位精度高，对噪声敏感，无法抑制噪声的影响。

1963年， Roberts 提出了这种寻找边缘的算子。 Roberts 边缘算子是一个 2x2 的模版，采用的是对角方向相邻的两个像素之差。

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

Roberts 算子在水平方向和垂直方向的计算公式如下：

Roberts 算子像素的终计算公式如下：

今天的公式都是小学生水平，千万别再说看不懂了。

实现 Roberts 算子，我们主要通过 OpenCV 中的 filter2D() 这个函数，这个函数的主要功能是通过卷积核实现对图像的卷积运算：

def filter2D(src, ddepth, kernel, dst=None, anchor=None, delta=None, borderType=None)
复制代码
  • src: 输入图像
  • ddepth: 目标图像所需的深度
  • kernel: 卷积核

接下来开始写代码，首先是图像的读取，并把这个图像转化成灰度图像，这个没啥好说的：

# 读取图像
img = cv.imread('maliao.jpg', cv.COLOR_BGR2GRAY)
rgb_img = cv.cvtColor(img, cv.COLOR_BGR2RGB)

# 灰度化处理图像
grayImage = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
复制代码

然后是使用 Numpy 构建卷积核，并对灰度图像在 x 和 y 的方向上做一次卷积运算：

# Roberts 算子
kernelx = np.array([[-1, 0], [0, 1]], dtype=int)
kernely = np.array([[0, -1], [1, 0]], dtype=int)

x = cv.filter2D(grayImage, cv.CV_16S, kernelx)
y = cv.filter2D(grayImage, cv.CV_16S, kernely)
复制代码

注意：在进行了 Roberts 算子处理之后，还需要调用convertScaleAbs()函数计算值，并将图像转换为8位图进行显示，然后才能进行图像融合：

# 转 uint8 ,图像融合
absX = cv.convertScaleAbs(x)
absY = cv.convertScaleAbs(y)
Roberts = cv.addWeighted(absX, 0.5, absY, 0.5, 0)
复制代码

后是通过 pyplot 将图像显示出来：

# 显示图形
titles = ['原始图像', 'Roberts算子']
images = [rgb_img, 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()
复制代码

终结果如下：

Prewitt 算子

Prewitt 算子是一种一阶微分算子的边缘检测，利用像素点上下、左右邻点的灰度差，在边缘处达到极值检测边缘，去掉部分伪边缘，对噪声具有平滑作用。

由于 Prewitt 算子采用 3 * 3 模板对区域内的像素值进行计算，而 Robert 算子的模板为 2 * 2 ，故 Prewitt 算子的边缘检测结果在水平方向和垂直方向均比 Robert 算子更加明显。Prewitt算子适合用来识别噪声较多、灰度渐变的图像。

Prewitt 算子的模版如下：

在代码实现上， Prewitt 算子的实现过程与 Roberts 算子比较相似，我就不多介绍，直接贴代码了：

import cv2 as cv
import numpy as np
import matplotlib.pyplot as plt

# 读取图像
img = cv.imread('maliao.jpg', cv.COLOR_BGR2GRAY)
rgb_img = cv.cvtColor(img, cv.COLOR_BGR2RGB)

# 灰度化处理图像
grayImage = cv.cvtColor(img, cv.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 = cv.filter2D(grayImage, cv.CV_16S, kernelx)
y = cv.filter2D(grayImage, cv.CV_16S, kernely)

# 转 uint8 ,图像融合
absX = cv.convertScaleAbs(x)
absY = cv.convertScaleAbs(y)
Prewitt = cv.addWeighted(absX, 0.5, absY, 0.5, 0)

# 用来正常显示中文标签
plt.rcParams['font.sans-serif'] = ['SimHei']

# 显示图形
titles = ['原始图像', 'Prewitt 算子']
images = [rgb_img, 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()
复制代码

从结果上来看， Prewitt 算子图像锐化提取的边缘轮廓，其效果图的边缘检测结果比 Robert 算子更加明显。

Sobel 算子

Sobel 算子的中文名称是索贝尔算子，是一种用于边缘检测的离散微分算子，它结合了高斯平滑和微分求导。

Sobel 算子在 Prewitt 算子的基础上增加了权重的概念，认为相邻点的距离远近对当前像素点的影响是不同的，距离越近的像素点对应当前像素的影响越大，从而实现图像锐化并突出边缘轮廓。

算法模版如下：

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

Sobel 算子近似梯度的大小的计算公式如下：

梯度方向的计算公式如下：

如果以上的角度 θ 等于零，即代表图像该处拥有纵向边缘，左方较右方暗。

在 Python 中，为我们提供了 Sobel() 函数进行运算，整体处理过程和前面的类似，代码如下：

import cv2 as cv
import matplotlib.pyplot as plt

# 读取图像
img = cv.imread('maliao.jpg', cv.COLOR_BGR2GRAY)
rgb_img = cv.cvtColor(img, cv.COLOR_BGR2RGB)

# 灰度化处理图像
grayImage = cv.cvtColor(img, cv.COLOR_BGR2GRAY)

# Sobel 算子
x = cv.Sobel(grayImage, cv.CV_16S, 1, 0)
y = cv.Sobel(grayImage, cv.CV_16S, 0, 1)

# 转 uint8 ,图像融合
absX = cv.convertScaleAbs(x)
absY = cv.convertScaleAbs(y)
Sobel = cv.addWeighted(absX, 0.5, absY, 0.5, 0)

# 用来正常显示中文标签
plt.rcParams['font.sans-serif'] = ['SimHei']

# 显示图形
titles = ['原始图像', 'Sobel 算子']
images = [rgb_img, Sobel]

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()
复制代码

Laplacian 算子

拉普拉斯（ Laplacian ）算子是 n 维欧几里德空间中的一个二阶微分算子，常用于图像增强领域和边缘提取。

Laplacian 算子的核心思想：判断图像中心像素灰度值与它周围其他像素的灰度值，如果中心像素的灰度更高，则提升中心像素的灰度；反之降低中心像素的灰度，从而实现图像锐化操作。

在实现过程中， Laplacian 算子通过对邻域中心像素的四方向或八方向求梯度，再将梯度相加起来判断中心像素灰度与邻域内其他像素灰度的关系，后通过梯度运算的结果对像素灰度进行调整。

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

四邻域模板如下：

八邻域模板如下：

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

在 OpenCV 中， Laplacian 算子被封装在 Laplacian() 函数中，其主要是利用Sobel算子的运算，通过加上 Sobel 算子运算出的图像 x 方向和 y 方向上的导数，得到输入图像的图像锐化结果。

import cv2 as cv
import matplotlib.pyplot as plt

# 读取图像
img = cv.imread('maliao.jpg', cv.COLOR_BGR2GRAY)
rgb_img = cv.cvtColor(img, cv.COLOR_BGR2RGB)

# 灰度化处理图像
grayImage = cv.cvtColor(img, cv.COLOR_BGR2GRAY)

# Laplacian
dst = cv.Laplacian(grayImage, cv.CV_16S, ksize = 3)
Laplacian = cv.convertScaleAbs(dst)

# 用来正常显示中文标签
plt.rcParams['font.sans-serif'] = ['SimHei']

# 显示图形
titles = ['原始图像', 'Laplacian 算子']
images = [rgb_img, Laplacian]

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()
复制代码

后

边缘检测算法主要是基于图像强度的一阶和二阶导数，但导数通常对噪声很敏感，因此需要采用滤波器来过滤噪声，并调用图像增强或阈值化算法进行处理，后再进行边缘检测。

后我先使用高斯滤波去噪之后，再进行边缘检测：

import cv2 as cv
import numpy as np
import matplotlib.pyplot as plt

# 读取图像
img = cv.imread('maliao.jpg')
rgb_img = cv.cvtColor(img, cv.COLOR_BGR2RGB)

# 灰度化处理图像
gray_image = cv.cvtColor(img, cv.COLOR_BGR2GRAY)

# 高斯滤波
gaussian_blur = cv.GaussianBlur(gray_image, (3, 3), 0)

# Roberts 算子
kernelx = np.array([[-1, 0], [0, 1]], dtype = int)
kernely = np.array([[0, -1], [1, 0]], dtype = int)
x = cv.filter2D(gaussian_blur, cv.CV_16S, kernelx)
y = cv.filter2D(gaussian_blur, cv.CV_16S, kernely)
absX = cv.convertScaleAbs(x)
absY = cv.convertScaleAbs(y)
Roberts = cv.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 = cv.filter2D(gaussian_blur, cv.CV_16S, kernelx)
y = cv.filter2D(gaussian_blur, cv.CV_16S, kernely)
absX = cv.convertScaleAbs(x)
absY = cv.convertScaleAbs(y)
Prewitt = cv.addWeighted(absX, 0.5, absY, 0.5, 0)

# Sobel 算子
x = cv.Sobel(gaussian_blur, cv.CV_16S, 1, 0)
y = cv.Sobel(gaussian_blur, cv.CV_16S, 0, 1)
absX = cv.convertScaleAbs(x)
absY = cv.convertScaleAbs(y)
Sobel = cv.addWeighted(absX, 0.5, absY, 0.5, 0)

# 拉普拉斯算法
dst = cv.Laplacian(gaussian_blur, cv.CV_16S, ksize = 3)
Laplacian = cv.convertScaleAbs(dst)

# 展示图像
titles = ['Source Image', 'Gaussian Image', 'Roberts Image',
          'Prewitt Image','Sobel Image', 'Laplacian Image']
images = [rgb_img, gaussian_blur, 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()
复制代码

示例代码

如果有需要获取源码的同学可以在公众号回复「OpenCV」进行获取。

参考

blog.csdn.net/Eastmount/a…

您的扫码关注，是对小编坚持原创的大鼓励：）

相关文章