上节介绍了求边缘的常用的一些一阶微分算子，这一节重点介绍二级微分算子。
3.2 二阶微分算子
3.2.1 Canny
首先是边缘检测算法中的大哥Canny边缘检测算法，它是目前最优秀的边缘检测算法。平常在使用Canny算法的时候往往就是一行代码就完事了，对其中的原理还是一知半解，接下来就对Canny算法进行剖析，了解其真正的工作原理。
Canny算法实现的步骤如下：
① 对图像进行灰度化
② 对图像进行高斯滤波：根据待滤波的像素点及其邻域点的灰度值按照一定的参数规则进行加权平均。这样可以有效滤去理想图像中叠加的高频噪声。
③ 检测图像中的水平、垂直和对角边缘（如Prewitt，Sobel算子等）。
④ 对梯度幅值进行非极大值抑制
⑤ 用双阈值算法检测和连接边缘
针对Canny算法的步骤思考下面两个问题
① 为什么要将图像转为灰度图？
因为在进行边缘检测的时候并不关系图像的颜色，并且使用三通道计算量和所占用的空间都比较大，所以图像要转为灰度图
② 为什么是高斯滤波？
如果在图像中存在许多噪声，这些噪声就会产生假的边缘信息，影响边缘检测的准确性，因此需要使用滤波器来去除噪声；滤波器和边缘检测是存在一定矛盾的。滤波器会模糊图像，而边缘检测需要准确地捕捉图像中的边缘。那么高斯滤波器就像是两者之间的和事老，它可以平衡滤波和边缘检测的需求。
下面就重点介绍Canny算子的灵魂非极大值抑制和双阈值算法检测
非极大值抑制
非极大值抑制(Non-Maximum Suppression，NMS），其思想是搜素局部最大值，抑制非极大值。
NMS算法在不同应用中的具体实现不太一样，但思想是一样的。在边缘检测中，通俗意义上是指寻找像素点局部最大值，将非极大值点所对应的灰度值置为0，这样可以剔除掉一大部分非边缘的点。
1) 将当前像素的梯度强度与沿正负梯度方向上的两个像素进行比较。
2) 如果当前像素的梯度强度与另外两个像素相比最大，则该像素点保留为边缘点，否则
该像素点将被抑制（灰度值置为0）
热知识：梯度方向另外的两个像素的值可通过插值得到。
那么问题来了，为什么要用非极大值抑制?
Canny算子作为一种边缘检测算法，旨在从图像中准确地提取出边缘信息。但是在边缘检测过程中，我们常常会遇到一个问题：边缘变得模糊而宽，丧失了明确的轮廓。这是因为在边缘方向上存在多个局部极大值的情况。所以，Canny引入了非极大值抑制这个武功绝技，来解决这个问题。非极大值抑制能够在边缘方向上找到像素值的真正最大值，并将其保留，从而使得边缘线条更加锐利、明确。
双阈值算法检测
完成非极大值抑制之后得到的边缘检测结果还包含了很由噪声或其他原因造成的假边缘 。因此需要进一步的处理。
双阈值检测：
如果边缘像素的梯度值高于高阈值，则将其标记为强边缘像素；
如果边缘像素的梯度值小于高阈值并且大于低阈值，则将其标记为弱边缘像素；
如果边缘像素的梯度值小于低阈值，则会被抑制。
大于高阈值为强边缘，小于低阈值不是边缘。介于中间是弱边缘。
阈值的选择取决于给定输入图像的内容。
边缘连接
目前为止，被划分为强边缘的像素点已经被确定为边缘，因为它们是从图像中的真实边缘中提取 出来的。 然而，对于弱边缘像素，将会有一些争论，因为这些像素可以从真实边缘提取也可以是因噪声或颜 色变化引起的。 为了获得准确的结果，应该抑制由后者引起的弱边缘：
通常，由真实边缘引起的弱边缘像素将连接到强边缘像素，而噪声响应未连接。
为了跟踪边缘连接，通过查看弱边缘像素及其8个邻域像素，只要其中一个为强边缘像素， 则该弱边缘点就可以保留为真实的边缘。 至此，整个Canny算法就结束了。
接下来是手撕Canny
import numpy as np
import matplotlib.pyplot as plt
import math
if __name__ == '__main__':
pic_path = 'lenna.png'
img = plt.imread(pic_path)
if pic_path[-4:] == '.png': # .png图片在这里的存储格式是0到1的浮点数，所以要扩展到255再计算
img = img * 255 # 还是浮点数类型
img = img.mean(axis=-1) # 取均值就是灰度化了
# 1、高斯平滑
#sigma = 1.52 # 高斯平滑时的高斯核参数，标准差，可调
sigma = 0.5 # 高斯平滑时的高斯核参数，标准差，可调
dim = int(np.round(6 * sigma + 1)) # round是四舍五入函数，根据标准差求高斯核是几乘几的，也就是维度
if dim % 2 == 0: # 最好是奇数,不是的话加一
dim += 1
Gaussian_filter = np.zeros([dim, dim]) # 存储高斯核，这是数组不是列表了
tmp = [i-dim//2 for i in range(dim)] # 生成一个序列
n1 = 1/(2*math.pi*sigma**2) # 计算高斯核
n2 = -1/(2*sigma**2)
for i in range(dim):
for j in range(dim):
Gaussian_filter[i, j] = n1*math.exp(n2*(tmp[i]**2+tmp[j]**2))
Gaussian_filter = Gaussian_filter / Gaussian_filter.sum()
dx, dy = img.shape
img_new = np.zeros(img.shape) # 存储平滑之后的图像，zeros函数得到的是浮点型数据
tmp = dim//2
img_pad = np.pad(img, ((tmp, tmp), (tmp, tmp)), 'constant') # 边缘填补
for i in range(dx):
for j in range(dy):
img_new[i, j] = np.sum(img_pad[i:i+dim, j:j+dim]*Gaussian_filter)
plt.figure(1)
plt.imshow(img_new.astype(np.uint8), cmap='gray') # 此时的img_new是255的浮点型数据，强制类型转换才可以，gray灰阶
plt.axis('off')
# 2、求梯度。以下两个是滤波求梯度用的sobel矩阵（检测图像中的水平、垂直和对角边缘）
sobel_kernel_x = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]])
sobel_kernel_y = np.array([[1, 2, 1], [0, 0, 0], [-1, -2, -1]])
img_tidu_x = np.zeros(img_new.shape) # 存储梯度图像
img_tidu_y = np.zeros([dx, dy])
img_tidu = np.zeros(img_new.shape)
img_pad = np.pad(img_new, ((1, 1), (1, 1)), 'constant') # 边缘填补，根据上面矩阵结构所以写1
for i in range(dx):
for j in range(dy):
img_tidu_x[i, j] = np.sum(img_pad[i:i+3, j:j+3]*sobel_kernel_x) # x方向
img_tidu_y[i, j] = np.sum(img_pad[i:i+3, j:j+3]*sobel_kernel_y) # y方向
img_tidu[i, j] = np.sqrt(img_tidu_x[i, j]**2 + img_tidu_y[i, j]**2)
img_tidu_x[img_tidu_x == 0] = 0.00000001
angle = img_tidu_y/img_tidu_x
plt.figure(2)
plt.imshow(img_tidu.astype(np.uint8), cmap='gray')
plt.axis('off')
# 3、非极大值抑制
img_yizhi = np.zeros(img_tidu.shape)
for i in range(1, dx-1):
for j in range(1, dy-1):
flag = True # 在8邻域内是否要抹去做个标记
temp = img_tidu[i-1:i+2, j-1:j+2] # 梯度幅值的8邻域矩阵
if angle[i, j] <= -1: # 使用线性插值法判断抑制与否
num_1 = (temp[0, 1] - temp[0, 0]) / angle[i, j] + temp[0, 1]
num_2 = (temp[2, 1] - temp[2, 2]) / angle[i, j] + temp[2, 1]
if not (img_tidu[i, j] > num_1 and img_tidu[i, j] > num_2):
flag = False
elif angle[i, j] >= 1:
num_1 = (temp[0, 2] - temp[0, 1]) / angle[i, j] + temp[0, 1]
num_2 = (temp[2, 0] - temp[2, 1]) / angle[i, j] + temp[2, 1]
if not (img_tidu[i, j] > num_1 and img_tidu[i, j] > num_2):
flag = False
elif angle[i, j] > 0:
num_1 = (temp[0, 2] - temp[1, 2]) * angle[i, j] + temp[1, 2]
num_2 = (temp[2, 0] - temp[1, 0]) * angle[i, j] + temp[1, 0]
if not (img_tidu[i, j] > num_1 and img_tidu[i, j] > num_2):
flag = False
elif angle[i, j] < 0:
num_1 = (temp[1, 0] - temp[0, 0]) * angle[i, j] + temp[1, 0]
num_2 = (temp[1, 2] - temp[2, 2]) * angle[i, j] + temp[1, 2]
if not (img_tidu[i, j] > num_1 and img_tidu[i, j] > num_2):
flag = False
if flag:
img_yizhi[i, j] = img_tidu[i, j]
plt.figure(3)
plt.imshow(img_yizhi.astype(np.uint8), cmap='gray')
plt.axis('off')
# 4、双阈值检测，连接边缘。遍历所有一定是边的点,查看8邻域是否存在有可能是边的点，进栈
lower_boundary = img_tidu.mean() * 0.5
high_boundary = lower_boundary * 3 # 这里我设置高阈值是低阈值的三倍
zhan = []
for i in range(1, img_yizhi.shape[0]-1): # 外圈不考虑了
for j in range(1, img_yizhi.shape[1]-1):
if img_yizhi[i, j] >= high_boundary: # 取，一定是边的点
img_yizhi[i, j] = 255
zhan.append([i, j])
elif img_yizhi[i, j] <= lower_boundary: # 舍
img_yizhi[i, j] = 0
while not len(zhan) == 0:
temp_1, temp_2 = zhan.pop() # 出栈
a = img_yizhi[temp_1-1:temp_1+2, temp_2-1:temp_2+2]
if (a[0, 0] < high_boundary) and (a[0, 0] > lower_boundary):
img_yizhi[temp_1-1, temp_2-1] = 255 # 这个像素点标记为边缘
zhan.append([temp_1-1, temp_2-1]) # 进栈
if (a[0, 1] < high_boundary) and (a[0, 1] > lower_boundary):
img_yizhi[temp_1 - 1, temp_2] = 255
zhan.append([temp_1 - 1, temp_2])
if (a[0, 2] < high_boundary) and (a[0, 2] > lower_boundary):
img_yizhi[temp_1 - 1, temp_2 + 1] = 255
zhan.append([temp_1 - 1, temp_2 + 1])
if (a[1, 0] < high_boundary) and (a[1, 0] > lower_boundary):
img_yizhi[temp_1, temp_2 - 1] = 255
zhan.append([temp_1, temp_2 - 1])
if (a[1, 2] < high_boundary) and (a[1, 2] > lower_boundary):
img_yizhi[temp_1, temp_2 + 1] = 255
zhan.append([temp_1, temp_2 + 1])
if (a[2, 0] < high_boundary) and (a[2, 0] > lower_boundary):
img_yizhi[temp_1 + 1, temp_2 - 1] = 255
zhan.append([temp_1 + 1, temp_2 - 1])
if (a[2, 1] < high_boundary) and (a[2, 1] > lower_boundary):
img_yizhi[temp_1 + 1, temp_2] = 255
zhan.append([temp_1 + 1, temp_2])
if (a[2, 2] < high_boundary) and (a[2, 2] > lower_boundary):
img_yizhi[temp_1 + 1, temp_2 + 1] = 255
zhan.append([temp_1 + 1, temp_2 + 1])
for i in range(img_yizhi.shape[0]):
for j in range(img_yizhi.shape[1]):
if img_yizhi[i, j] != 0 and img_yizhi[i, j] != 255:
img_yizhi[i, j] = 0
# 绘图
plt.figure(4)
plt.imshow(img_yizhi.astype(np.uint8), cmap='gray')
plt.axis('off') # 关闭坐标刻度值
plt.show()
懂了Canny的原理以及实现过程后，往往在实用的时候一行代码就可以完成Canny边缘检测
img = cv2.imread("lenna.png", 1)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
cv2.imshow("canny", cv2.Canny(gray, 200, 300))
cv2.waitKey()
cv2.destroyAllWindows()
扫一扫
719
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
