图像处理学习2，边缘检测1（sobel算子，kirsch算子）

烈焰的冰玫瑰

已于 2023-04-28 19:24:06 修改

阅读量1.3k

点赞数 11

分类专栏：图像处理文章标签：图像处理计算机视觉

于 2023-04-28 19:18:13 首次发布

本文链接：https://blog.csdn.net/m0_72786913/article/details/130363121

版权

图像处理专栏收录该内容

3 篇文章 0 订阅

订阅专栏

图像边缘的种类

图像中的边缘是像素灰度值发生加速变化而不连续的结果，边缘检测是常见的图像基元检测的基础，也是所有基于边界的图像分割方法的第一步。

Alt
图片来源：章毓晋.计算机视觉教程[M].北京：人民邮电出版社，2021.1：46

图像的边缘通常分为阶梯状边缘，脉冲状边缘和屋顶状边缘，通常用一阶导数的幅度值或二阶导数的过零点来检测图像的边缘，本文主要介绍一阶导数算子中的sobel算子和kirsch算子来检测边缘。

算子与模板卷积

广义的讲，对任何函数进行某一项操作都可以认为是一个算子，狭义的算子实际上是指从一个函数空间到另一个函数空间（或它自身）的映射。我们这里使用的算子都是用模板卷积的方式进行计算的。

例如，考虑一个 $3\times3$ 的算子 $A$

$\left[ \begin{matrix} a_{11} & a_{12} & a_{13} \\ a_{21} & a_{22} & a_{23} \\ a_{31} & a_{32} & a_{33} \end{matrix} \right]$
待处理的图像为图像 $F$

$\left[ \begin{matrix} f_{11} & f_{12} &\cdots & f_{1j} \\ f_{21} & f_{22} &\cdots & f_{2j} \\ \vdots & \vdots & &\vdots \\ f_{i1} & f_{i2} & \cdots & f_{ij} \end{matrix} \right]$
将这个算子和图像 $F$ 进行卷积操作，得到的图像为 $G$

$\left[ \begin{matrix} g_{11} & g_{12} &\cdots & g_{1j} \\ g_{21} & g_{22} &\cdots & g_{2j} \\ \vdots & \vdots & &\vdots \\ g_{i1} & g_{i2} & \cdots & g_{ij} \end{matrix} \right]$
考虑算子 $A$ 和 $f_{ij}$ 的邻域

$\left[ \begin{matrix} a_{11} & a_{12} & a_{13} \\ a_{21} & a_{22} & a_{23} \\ a_{31} & a_{32} & a_{33} \end{matrix} \right] \left[ \begin{matrix} f_{i-1,j-1} & f_{i-1,j} & f_{i-1,j+1} \\ f_{i,j-1} & f_{i,j} & f_{i,j+1} \\ f_{i+1,j-1} & f_{i+1,j} & f_{i+1,j+1} \end{matrix} \right]$
则对于 $G$ 有

$g_{ij} = a_{11}*f_{i-1,j-1} + a_{12}*f_{i-1,j} + a_{13}*f_{i-1,j+1} +\\ a_{21}*f_{i,j-1} + a_{22}*f_{i,j} + a_{23}*f_{i,j+1} +\\ a_{31}*f_{i+1,j-1} + a_{32}*f_{i+1,j} + a_{33}*f_{i+1,j+1}\\$
这就是一般情况下算子的模板卷积操作，即将模板在图像上移动，并在每个位置将模板上的各个系数和模板下各对应像素的灰度值相乘求和，来计算对应中心像素的值，边缘检测所得到的像素值就是原像素的梯度值。

sobel算子

sobel算子是一种梯度算子，即所求的最终像素是原始像素的梯度值，它有两个方向的卷积核

沿 X 方向
$\left[ \begin{matrix} -1 & 0 & 1\\ -2 & 0 & 2\\ -1 & 0 & 1 \end{matrix} \right]$
沿 Y 方向
$\left[ \begin{matrix} 1 & 2 & 1\\ 0 & 0 & 0\\ -1 & -2 & -1 \end{matrix} \right]$
它的卷积运算相当于对目标像素求一阶导。

Kirsch算子

kirsch模板除了 X 方向和 Y 方向外还包含了两个对角方向

比如，左上到右下方向
$\left[ \begin{matrix} 3 & 3 & 3\\ 3 & 0 & -5\\ 3 & -5 & -5 \end{matrix} \right]$
右上到左下方向
$\left[ \begin{matrix} -5 & -5 & 3\\ -5 & 0 & 3\\ 3 & 3 & 3 \end{matrix} \right]$
它的卷积运算也相当于对目标像素求一阶导，只是求导的方向不同，类似的，你可以得到其他方向上的kirsch模板。

代码实现

下面我们将用 Python 来实现对图像的边缘检测算法

首先应该获取原始图像的灰度图像，这里我们直接使用之前处理得到的灰度图像

import cv2 as cv
# 获得原始图像
# 所得图像应为之前处理过的灰度图像
image = cv.imread("pai_mon_01_gray.jpg")

原始图像

在这里插入图片描述
先用sobel算子进行边缘检测

# 边缘检测
gray_gradient = gray.copy()
gray_height, gray_width = gray.shape[0:2]
for i in range(1, gray_height - 1):
    for j in range(1, gray_width - 1):
        # 水平方向检测
        # sobel 算子 [[-1, 0, 1], [-2, 0 ,2], [-1, 0, 1]]
        gradient_x = int(gray[i - 1, j - 1, 0]) - int(gray[i + 1, j - 1, 0]) + \
                     2 * int(gray[i - 1, j, 0]) - 2 * int(gray[i + 1, j, 0]) + \
                     int(gray[i - 1, j + 1, 0]) - int(gray[i + 1, j + 1, 0])

        # 垂直方向检测
        # sobel 算子 [[1, 2, 1], [0, 0, 0], [-1, -2, -1]]
        gradient_y = int(gray[i - 1, j + 1, 0]) - int(gray[i - 1, j - 1, 0]) + \
                     2 * int(gray[i, j + 1, 0]) - 2 * int(gray[i, j - 1, 0]) + \
                     int(gray[i + 1, j + 1, 0]) - int(gray[i - 1, j - 1, 0])
        gradient = max(gradient_x, gradient_y)
        # 将 gradient 转到像素值范围内
        if gradient < 0:
            gradient = abs(min(255, gradient))
        elif gradient > 255:
            gradient = 255
        gray_gradient[i, j, 0] = gradient
        gray_gradient[i, j, 1] = gradient
        gray_gradient[i, j, 2] = gradient


cv.imshow("gray_gradient", gray_gradient)
cv.waitKey(0)

这里需要注意的是我们要把卷积后得到的梯度值进行处理，使它在0到255这一个灰度值的取值范围内

得到的图像为

在这里插入图片描述
如果只用水平方向的sobel算子的话，得到的图像为

在这里插入图片描述
可以看到得到的效果明显不如前一张图片好

下面我们再加上kirsch算子观察检测结果

import cv2 as cv

# 获得原始图像
# 所得图像应为之前处理过的灰度图像
gray = cv.imread("pai_mon_01_gray.jpg")

# 边缘检测
gray_gradient = gray.copy()
gray_height, gray_width = gray.shape[0:2]
for i in range(1, gray_height - 1):
    for j in range(1, gray_width - 1):
        # 水平方向检测
        # sobel 算子 [[-1, 0, 1], [-2, 0 ,2], [-1, 0, 1]]
        gradient_x = int(gray[i - 1, j - 1, 0]) - int(gray[i + 1, j - 1, 0]) + \
                     2 * int(gray[i - 1, j, 0]) - 2 * int(gray[i + 1, j, 0]) + \
                     int(gray[i - 1, j + 1, 0]) - int(gray[i + 1, j + 1, 0])

        # 垂直方向检测
        # sobel 算子 [[1, 2, 1], [0, 0, 0], [-1, -2, -1]]
        gradient_y = int(gray[i - 1, j + 1, 0]) - int(gray[i - 1, j - 1, 0]) + \
                     2 * int(gray[i, j + 1, 0]) - 2 * int(gray[i, j - 1, 0]) + \
                     int(gray[i + 1, j + 1, 0]) - int(gray[i - 1, j - 1, 0])

        # 西北到东南方向检测
        # 基尔希算子 Kirsch = [[3, 3, 3], [3, 0, -5], [3, -5, -5]]
        gradient_WN_to_ES = 3 * (int(gray[i - 1, j - 1, 0]) + int(gray[i, j - 1, 0]) + int(gray[i + 1, j - 1, 0]) +
                                 int(gray[i - 1, j, 0]) + int(gray[i - 1, j + 1, 0])) - \
                            5 * (int(gray[i + 1, j, 0]) + int(gray[i, j + 1, 0]) + int(gray[i + 1, j + 1, 0]))

        # 东北到西南方向检测
        # 基尔希算子 Kirsch = [[3, 3, 3], [-5, 0, 3], [-5, -5, 3]]
        gradient_EN_to_WS = 3 * (int(gray[i - 1, j - 1, 0]) + int(gray[i - 1, j, 0]) + int(gray[i - 1, j + 1, 0]) +
                                 int(gray[i, j + 1, 0]) + int(gray[i + 1, j + 1, 0])) - \
                            5 * (int(gray[i, j - 1, 0]) + int(gray[i + 1, j - 1, 0]) + int(gray[i + 1, j, 0]))
        gradient = int(max(gradient_x, gradient_y, gradient_WN_to_ES, gradient_EN_to_WS))
        # 将 gradient 转到像素值范围内
        if gradient < 0:
            gradient = abs(min(255, gradient))
        elif gradient > 255:
            gradient = 255
        gray_gradient[i, j, 0] = gradient
        gray_gradient[i, j, 1] = gradient
        gray_gradient[i, j, 2] = gradient


cv.imshow("gray_gradient", gray_gradient)
cv.waitKey(0)