边缘检测算法综合指南

介绍

图像处理是一个广泛使用的概念，用于利用图像中的信息。图像处理算法需要很长时间来处理数据，因为图像很大，并且其中可用的信息量很大。因此，在这些前沿技术中，有必要减少算法所关注的信息量。有时这只能通过传递图像的边缘来完成。

所以在这篇博客中，让我们了解 Canny 边缘检测器和整体嵌套边缘检测器。

什么是边缘检测？

图像中的边缘是图像强度的显着局部变化。顾名思义，边缘检测是检测图像边缘的过程。下面的示例描述了海星图像的边缘检测。

图1.1 边缘检测

为什么我们需要边缘检测？

深度、表面方向、场景照明变化和材料属性变化的不连续性会导致图像亮度的不连续性。我们得到表示对象边界和表面标记的曲线集，以及对应于表面方向不连续性的曲线。

因此，将边缘检测算法应用于图像可以显着减少要处理的数据量，因此可以过滤掉可能被认为不太相关的信息，同时保留图像的重要结构属性。

如图 1.1 所示，图像的结构属性是通过边缘检测捕获的。

了解流行的边缘检测算法

在讨论了边缘检测算法的重要性之后，本节将重点了解一些流行且广泛使用的边缘检测算法。

边缘检测有多种方法。让我们将这些方法大致分为：

传统方法
基于深度学习的方法

现在，让我们讨论最流行的边缘检测算法之一——canny 边缘检测器，并将其与 Sobel 和 Prewitt 进行比较。

Canny 边缘检测器

Canny 边缘检测算法是当今图像处理应用中广泛使用的边缘检测算法。它在多个阶段工作，如图 1.2 所示。Canny 边缘检测算法产生比 Sobel 和 Prewitt 过滤器更平滑、更薄、更清晰的图像。

这里是canny边缘检测算法的总结：

对输入图像进行平滑处理，应用 Sobel 滤波器检测图像的边缘。然后我们应用非最大抑制，保留梯度方向上的局部最大像素，其余的被抑制。我们应用阈值处理来去除低于某个阈值的像素，并保留高于某个阈值的像素以去除可能由于噪声而形成的边缘。

稍后，如果 8 个相邻像素中的任何一个像素很强，我们就会应用滞后跟踪来使像素变强。

图1.2 Canny 边缘检测器

现在，我们将详细讨论每个步骤。

Canny边缘检测涉及5个步骤，如上图1.2所示。我们将使用下图进行说明。

图像平滑

在这一步中，我们将图像转换为灰度，因为边缘检测不依赖于颜色。然后我们用高斯滤波器去除图像中的噪声，因为边缘检测容易产生噪声。

寻找图像的强度梯度

然后，我们在水平和垂直方向上应用 Sobel 核，以获得平滑图像上水平方向 (G x ) 和垂直方向 (G y ) 的一阶导数。然后我们计算边缘梯度（G）和角度（θ），如下所示，

我们知道梯度方向垂直于边缘。我们将角度四舍五入到代表垂直、水平和两个对角线方向的四个角度之一。

非最大值抑制

现在我们删除所有可能不构成边缘的像素。为此，如果每个像素在其邻域中是局部最大值，则在梯度方向上进行检查。如果是局部最大值，则考虑用于下一阶段，否则，将其变暗，设置为 0。这将在输出图像中给出一条细线。

双阈值

由于噪声和颜色变化导致的像素会在图像中持续存在。因此，为了消除这一点，我们从用户那里获得了两个阈值，lowerVal 和 upperVal。

我们过滤掉具有弱梯度（lowerVal）值的边缘像素，并保留具有高梯度值（upperVal）的边缘像素。强度梯度大于upperVal的边缘肯定是边缘，低于lowerVal的肯定是非边缘，所以丢弃。像素值小于 upperVal 且大于 lowerVal 的像素如果连接到“确定边缘（sure-edge）”，则被视为边缘的一部分。否则，它们也会被丢弃。

滞后边缘跟踪

如果一个像素周围的 8 个像素中有一个是强像素（像素值 = 255），则将其设为强像素，否则将其设为 0。

这几乎是关于 Canny 边缘检测的。如图，边缘是从图像中检测到的。

现在，我们将探索基于深度学习的边缘检测方法。但是为什么我们首先需要使用基于深度学习的边缘检测算法呢？Canny边缘检测只关注局部变化，不理解图像的语义，即图像内容。因此，提出了基于深度学习的算法来解决这些问题。我们现在将详细讨论它。

但在我们深入研究深度学习的数学之前，让我们首先尝试在 OpenCV 中实现 Canny 边缘检测器和基于深度学习的模型（HED）。

实现 - Canny 边缘检测器

让我们导入必要的模块

import cv2 
from skimage.metrics 
import mean_squared_error,peak_signal_noise_ratio,structural_similarity

import matplotlib.pyplot 
as plt

以下代码在海星图像上应用 Canny 边缘检测器

img_path = 
'starfish.png'
#Reading the image
image = cv2.imread(img_path)

(H, W) = image.shape[:
2]

# convert the image to grayscale
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# blur the image
blurred = cv2.GaussianBlur(gray, (
5, 
5), 
0)

# Perform the canny operator
canny = cv2.Canny(blurred, 
30, 
150)

让我们看看 Canny 边缘检测器的输出

fig,ax =  plt.subplots(
1,
2,figsize=(
18, 
18))

ax[
0].imshow(gray,cmap=
'gray')

ax[
1].imshow(canny,cmap=
'gray')

ax[
0].axis(
'off')

ax[
1].axis(
'off')

接下来，让我们在进行数学运算之前看看 HED 的代码。

实现 - HED

#This class helps in cropping the specified coordinated in the function
classCropLayer(object):
def__init__(self, params, blobs):
# initialize our starting and ending (x, y)-coordinates of
        self.startX = 
0
        self.startY = 
0
        self.endX = 
0
        self.endY = 
0
defgetMemoryShapes(self, inputs):
        (inputShape, targetShape) = (inputs[
0], inputs[
1])

        (batchSize, numChannels) = (inputShape[
0], inputShape[
1])

        (H, W) = (targetShape[
2], targetShape[
3])

# compute the starting and ending crop coordinates
        self.startX = int((inputShape[
3] - targetShape[
3]) / 
2)

        self.startY = int((inputShape[
2] - targetShape[
2]) / 
2)

        self.endX = self.startX + W

        self.endY = self.startY + H

# return the shape of the volume (we'll perform the actual
# crop during the forward pass
return [[batchSize, numChannels, H, W]]

defforward(self, inputs):
return [inputs[
0][:, :, self.startY:self.endY,self.startX:self.endX]]

你可以从此 repo 下载 deploy.prototxt 和 caffemodel：https://github.com/ashukid/hed-edge-detector

#The caffemodel contains the model of the architecture and the deploy.prototxt contains the weights
protoPath = 
'deploy.prototxt.txt'
modelPath = 
'hed_pretrained_bsds.caffemodel'
net = cv2.dnn.readNetFromCaffe(protoPath, modelPath)

# register our new layer with the model
cv2.dnn_registerLayer(
"Crop", CropLayer)

现在我们读取我们的图像并将其传递给算法。

#Input image is converted to a blog
blob = cv2.dnn.blobFromImage(image, scalefactor=
1.0, size=(W, H),mean=(
104.00698793, 
116.66876762, 
122.67891434),swapRB=
False, crop=
False)

#We pass the blob into the network and make a forward pass
net.setInput(blob)

hed = net.forward()

hed = cv2.resize(hed[
0, 
0], (W, H))

hed = (
255 * hed).astype(
"uint8")

我们读取由边缘组成的实际图像

test_y_path = 
'edge.png'
test_y = cv2.imread(test_y_path)

#The test image has its third dimesion as 3
#So we are extractin only one dimension
test_y = test_y[:,:,
0]

我们对图像进行标准化，以使 MSE 值不会上升

#Normalising all the images
test_y = test_y/
255
hed = hed/
255
canny = canny/
255
gray = gray/
255

我们现在可视化我们的结果

fig,ax =  plt.subplots(
1,
2,figsize=(
18, 
18))

ax[
0].imshow(gray,cmap=
'gray')

ax[
1].imshow(hed,cmap=
'gray')

ax[
0].axis(
'off')

ax[
1].axis(
'off')

最后，我们计算指标并比较我们的结果

#Calculating metrics between actual test image and the output we got through Canny edge detection
print(mean_squared_error(test_y,canny),peak_signal_noise_ratio(test_y,canny),structural_similarity(test_y,canny))

#Calculating metrics between actual test image and the output we got through HED
print(mean_squared_error(test_y,hed),peak_signal_noise_ratio(test_y,hed),structural_similarity(test_y,hed))