Canny边缘检测原理及python实现

最新推荐文章于 2024-10-16 09:47:57 发布
最新推荐文章于 2024-10-16 09:47:57 发布
阅读量2.9k 收藏 50
点赞数 7
分类专栏： 图像处理 文章标签： opencv 计算机视觉 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wang_xinyu/article/details/111414386
版权
  1. Canny边缘检测原理
    从表面效果上来讲，Canny算法是对Sobel、Prewitt等算子效果的进一步细化和更加准确的定位。
    Canny算法基于三个基本目标：
    a. 低错误率。所有边缘都应被找到，且没有伪响应。
    b. 边缘点应该被很好地定位。已定位的边缘必须尽可能接近真实边缘。
    c. 单一的边缘点响应。这意味在仅存一个单一边缘点的位置，检测器不应指出多个像素边缘。
    进而，Canny的工作本质是，从数学上表达前面的三个准则。因此Canny的步骤如下：
    a. 对输入图像进行高斯平滑，降低错误率。
    b. 计算梯度幅度和方向来估计每一点处的边缘强度与方向。
    c. 根据梯度方向，对梯度幅值进行非极大值抑制。本质上是对Sobel、Prewitt等算子结果的进一步细化。
    d. 用双阈值处理和连接边缘。
  2. 高斯平滑操作
    在这里插入图片描述
# 第一步：高斯平滑滤波
img = cv2.imread("lena.jpg", 0)
img = cv2.GaussianBlur(img, (3, 3), 2)
  1. 计算梯度幅度和方向，找到边缘强度
    可选用的模板：soble算子、Prewitt算子、Roberts模板等等;在这里插入图片描述

一般采用soble算子，OpenCV也是如此，利用soble水平和垂直算子与输入图像卷积计算dx、dy：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
进一步可以得到图像梯度的幅值：
在这里插入图片描述
为了简化计算，幅值也可以作如下近似：
在这里插入图片描述
角度为：
在这里插入图片描述
如下图表示了中心点的梯度向量、方位角以及边缘方向（任一点的边缘与梯度向量正交） ：
在这里插入图片描述

# 第二步：计算每一点的梯度幅值与方向，找到边缘强度
img1 = np.zeros(img.shape, dtype="uint8")  # 与原图大小相同
theta = np.zeros(img.shape, dtype="float")  # 方向矩阵原图像大小
rows, cols = img.shape
for i in range(1, rows - 1):
    for j in range(1, cols - 1):
        Gy = [np.sum(m2 * img[i - 1:i + 2, j - 1:j + 2])]
        Gx = [np.sum(m1 * img[i - 1:i + 2, j - 1:j + 2])]

        # 计算角度
        if Gx[0] == 0:
            theta[i - 1, j - 1] = 90
            continue
        else:
            temp = ((np.arctan2(Gy[0], Gx[0])) * 180 / np.pi) + 90

        if Gx[0] * Gy[0] > 0:
            if Gx[0] > 0:
                # 第一象线
                theta[i - 1, j - 1] = np.abs(temp)
            else:
                # 第三象线
                theta[i - 1, j - 1] = (np.abs(temp) - 180)
        if Gx[0] * Gy[0] < 0:
            if Gx[0] > 0:
                # 第四象线
                theta[i - 1, j - 1] = (-1) * np.abs(temp)
            else:
                # 第二象线
                theta[i - 1, j - 1] = 180 - np.abs(temp)
        # 图像梯度的幅值
        img1[i - 1, j - 1] = (np.sqrt(Gx[0] ** 2 + Gy[0] ** 2))

# 计算梯度方向：四个角度进行量化
for i in range(1, rows - 2):
    for j in range(1, cols - 2):
        if (((theta[i, j] >= -22.5) and (theta[i, j] < 22.5)) or
                ((theta[i, j] <= -157.5) and (theta[i, j] >= -180)) or
                ((theta[i, j] >= 157.5) and (theta[i, j] < 180))):
            theta[i, j] = 0.0
        elif (((theta[i, j] >= 22.5) and (theta[i, j] < 67.5)) or
              ((theta[i, j] <= -112.5) and (theta[i, j] >= -157.5))):
            theta[i, j] = -45.0
        elif (((theta[i, j] >= 67.5) and (theta[i, j] < 112.5)) or
              ((theta[i, j] <= -67.5) and (theta[i, j] >= -112.5))):
            theta[i, j] = 90.0
        elif (((theta[i, j] >= 112.5) and (theta[i, j] < 157.5)) or
              ((theta[i, j] <= -22.5) and (theta[i, j] >= -67.5))):
            theta[i, j] = 45.0
  1. 非极大值抑制
    划重点：是沿着梯度方向对幅值进行非极大值抑制，而非边缘方向。
    在这里插入图片描述
    在这里插入图片描述
    量化情况可总结为：
    水平边缘–梯度方向为垂直： 在这里插入图片描述
    135°边缘–梯度方向为45°：在这里插入图片描述
    垂直边缘–梯度方向为水平：在这里插入图片描述
    45°边缘–梯度方向为135°： 在这里插入图片描述
    非极大值抑制即为沿着上述4种类型的梯度方向，比较3*3邻域内对应邻域值的大小：
    在这里插入图片描述
    在每一点上，领域中心 x 与沿着其对应的梯度方向的两个像素相比，若中心像素为最大值，则保留，否则中心置0，这样可以抑制非极大值，保留局部梯度最大的点，以得到细化的边缘。
# 第三步：非极大值抑制计算
img2 = np.zeros(img1.shape)  # 非极大值抑制图像矩阵
# 非极大值抑制即为沿着上述4种类型的梯度方向，比较3*3邻域内对应邻域值的大小：
for i in range(1, img2.shape[0] - 1):
    for j in range(1, img2.shape[1] - 1):
        # 0度为水平边缘
        if (theta[i, j] == 0.0) and (img1[i, j] == np.max([img1[i, j], img1[i + 1, j], img1[i - 1, j]])):
            img2[i, j] = img1[i, j]
        # -45度边缘
        if (theta[i, j] == -45.0) and img1[i, j] == np.max([img1[i, j], img1[i - 1, j - 1], img1[i + 1, j + 1]]):
            img2[i, j] = img1[i, j]
        # 90度垂直边缘
        if (theta[i, j] == 90.0) and img1[i, j] == np.max([img1[i, j], img1[i, j + 1], img1[i, j - 1]]):
            img2[i, j] = img1[i, j]
        # 45度边缘
        if (theta[i, j] == 45.0) and img1[i, j] == np.max([img1[i, j], img1[i - 1, j + 1], img1[i + 1, j - 1]]):
            img2[i, j] = img1[i, j]
  1. 双阈值方法进行二值化，并连接边缘在这里插入图片描述

a. 选取系数TH和TL，比率为2:1或3:1。（一般取TH=0.3或0.2,TL=0.1）；
b. 将小于低阈值的点抛弃，赋0；将大于高阈值的点立即标记（这些点为确定边缘点），赋1或255；
c. 将小于高阈值，大于低阈值的点使用8连通区域确定（即：只有与TH像素连接时才会被接受，成为边缘点，赋 1或255）

# 第四步：双阈值检测和边缘连接
img3 = np.zeros(img2.shape)  # 定义双阈值图像
TL = 50
TH = 100  # 关键在这两个阈值的选择
for i in range(1, img3.shape[0] - 1):
    for j in range(1, img3.shape[1] - 1):
        if img2[i, j] < TL:
            img3[i, j] = 0
        elif img2[i, j] > TH:
            img3[i, j] = 255
        # 将小于高阈值，大于低阈值的点使用8连通区域确定（即：只有与TH像素连接时才会被接受，成为边缘点，赋255）
        elif ((img2[i + 1, j] < TH) or (img2[i - 1, j] < TH) or (img2[i, j + 1] < TH) or
              (img2[i, j - 1] < TH) or (img2[i - 1, j - 1] < TH) or (img2[i - 1, j + 1] < TH) or
              (img2[i + 1, j + 1] < TH) or (img2[i + 1, j - 1] < TH)):
            img3[i, j] = 255
  1. 完整代码
import cv2
import numpy as np

m1 = np.array([[1, 0, -1], [2, 0, -2], [1, 0, -1]])
m2 = np.array([[1, 2, 1], [0, 0, 0], [-1, -2, -1]])

# 第一步：高斯平滑滤波
img = cv2.imread("lena.jpg", 0)
sobel = cv2.Canny(img, 50, 100)
cv2.imshow("canny", sobel)  # 角度值灰度图
img = cv2.GaussianBlur(img, (3, 3), 2)

# 第二步：计算每一点的梯度幅值与方向，找到边缘强度
img1 = np.zeros(img.shape, dtype="uint8")  # 与原图大小相同
theta = np.zeros(img.shape, dtype="float")  # 方向矩阵原图像大小
rows, cols = img.shape
for i in range(1, rows - 1):
    for j in range(1, cols - 1):
        Gy = [np.sum(m2 * img[i - 1:i + 2, j - 1:j + 2])]
        Gx = [np.sum(m1 * img[i - 1:i + 2, j - 1:j + 2])]

        # 计算角度
        if Gx[0] == 0:
            theta[i - 1, j - 1] = 90
            continue
        else:
            temp = ((np.arctan2(Gy[0], Gx[0])) * 180 / np.pi) + 90

        if Gx[0] * Gy[0] > 0:
            if Gx[0] > 0:
                # 第一象线
                theta[i - 1, j - 1] = np.abs(temp)
            else:
                # 第三象线
                theta[i - 1, j - 1] = (np.abs(temp) - 180)
        if Gx[0] * Gy[0] < 0:
            if Gx[0] > 0:
                # 第四象线
                theta[i - 1, j - 1] = (-1) * np.abs(temp)
            else:
                # 第二象线
                theta[i - 1, j - 1] = 180 - np.abs(temp)
        # 图像梯度的幅值
        img1[i - 1, j - 1] = (np.sqrt(Gx[0] ** 2 + Gy[0] ** 2))

# 计算梯度方向：四个角度进行量化
for i in range(1, rows - 2):
    for j in range(1, cols - 2):
        if (((theta[i, j] >= -22.5) and (theta[i, j] < 22.5)) or
                ((theta[i, j] <= -157.5) and (theta[i, j] >= -180)) or
                ((theta[i, j] >= 157.5) and (theta[i, j] < 180))):
            theta[i, j] = 0.0
        elif (((theta[i, j] >= 22.5) and (theta[i, j] < 67.5)) or
              ((theta[i, j] <= -112.5) and (theta[i, j] >= -157.5))):
            theta[i, j] = -45.0
        elif (((theta[i, j] >= 67.5) and (theta[i, j] < 112.5)) or
              ((theta[i, j] <= -67.5) and (theta[i, j] >= -112.5))):
            theta[i, j] = 90.0
        elif (((theta[i, j] >= 112.5) and (theta[i, j] < 157.5)) or
              ((theta[i, j] <= -22.5) and (theta[i, j] >= -67.5))):
            theta[i, j] = 45.0

# 第三步：非极大值抑制计算
img2 = np.zeros(img1.shape)  # 非极大值抑制图像矩阵
# 非极大值抑制即为沿着上述4种类型的梯度方向，比较3*3邻域内对应邻域值的大小：
for i in range(1, img2.shape[0] - 1):
    for j in range(1, img2.shape[1] - 1):
        # 0度为水平边缘
        if (theta[i, j] == 0.0) and (img1[i, j] == np.max([img1[i, j], img1[i + 1, j], img1[i - 1, j]])):
            img2[i, j] = img1[i, j]
        # -45度边缘
        if (theta[i, j] == -45.0) and img1[i, j] == np.max([img1[i, j], img1[i - 1, j - 1], img1[i + 1, j + 1]]):
            img2[i, j] = img1[i, j]
        # 90度垂直边缘
        if (theta[i, j] == 90.0) and img1[i, j] == np.max([img1[i, j], img1[i, j + 1], img1[i, j - 1]]):
            img2[i, j] = img1[i, j]
        # 45度边缘
        if (theta[i, j] == 45.0) and img1[i, j] == np.max([img1[i, j], img1[i - 1, j + 1], img1[i + 1, j - 1]]):
            img2[i, j] = img1[i, j]

# 第四步：双阈值检测和边缘连接
img3 = np.zeros(img2.shape)  # 定义双阈值图像
TL = 50
TH = 100  # 关键在这两个阈值的选择
for i in range(1, img3.shape[0] - 1):
    for j in range(1, img3.shape[1] - 1):
        if img2[i, j] < TL:
            img3[i, j] = 0
        elif img2[i, j] > TH:
            img3[i, j] = 255
        # 将小于高阈值，大于低阈值的点使用8连通区域确定（即：只有与TH像素连接时才会被接受，成为边缘点，赋255）
        elif ((img2[i + 1, j] < TH) or (img2[i - 1, j] < TH) or (img2[i, j + 1] < TH) or
              (img2[i, j - 1] < TH) or (img2[i - 1, j - 1] < TH) or (img2[i - 1, j + 1] < TH) or
              (img2[i + 1, j + 1] < TH) or (img2[i + 1, j - 1] < TH)):
            img3[i, j] = 255


cv2.imshow("original_img", img)  # 原始图像
cv2.imshow("grad_img", img1)  # 梯度幅值图
cv2.imshow("max_img", img2)  # 非极大值抑制灰度图
cv2.imshow("final_img", img3)  # 最终效果图
cv2.waitKey(0)
  1. 运行结果
    original_img
    在这里插入图片描述

final_img

在这里插入图片描述
参考文献：https://blog.csdn.net/qq_43043256/article/details/102947533
cnblogs.com/april0315/p/13629813.html

Fancy Wang
关注
专栏目录
Python实现Canny边缘检测算法——附详细源代码
带你成为别人眼中的大佬！
05-25 937
Canny边缘检测算法是由John F. Canny在1986年提出的一种多级别边缘检测算法，其核心思想是通过滤波器对图像进行平滑处理，然后使用梯度算子检测出图像中的边缘，最后通过非极大值抑制和双阈值处理确定边缘。为了精确检测出边缘，需要对梯度方向进行判断，只有在梯度方向与垂直或水平方向夹角小于45度时才算边缘，将其他方向的梯度值置为0。为了减少噪声对边缘的影响，需要对灰度图像进行平滑处理，本文采用了高斯滤波器，使用cv2.GaussianBlur()函数实现。
Canny边缘检测算法原理及实现（Python + OpenCV）
weixin_44403952的博客
05-20 1万+
Canny算法思想 Canny算子是John F.Canny 大佬在1986年在其发表的论文 《Canny J. A computational approach to edge detection [J]. IEEE Transactions on Pattern Analysis and Machine Intelligence, 1986 (6): 679-698.》提出来的 可以说，C...
canny边缘检测python实现
qq_43043256的博客
11-07 2282
canny边缘检测原理 canny边缘检测共有5部分组成，下边我会分别来介绍。 1 高斯模糊（略） 2 计算梯度幅值和方向。 可选用的模板：soble算子、Prewitt算子、Roberts模板等等; 一般采用soble算子，OpenCV也是如此，利用soble水平和垂直算子与输入图像卷积计算dx、dy： 进一步可以得到图像梯度的幅值： 为了简化计算，幅值也可以作如下近似： 角度为： 如下...
python图像边缘检测_python Canny边缘检测算法的实现
weixin_39893042的博客
11-23 805
图像边缘信息主要集中在高频段，通常说图像锐化或检测边缘，实质就是高频滤波。我们知道微分运算是求信号的变化率，具有加强高频分量的作用。在空域运算中来说，对图像的锐化就是计算微分。对于数字图像的离散信号，微分运算就变成计算差分或梯度。图像处理中有多种边缘检测（梯度）算子，常用的包括普通一阶差分，Robert算子（交叉差分），Sobel算子等等，是基于寻找梯度强度。拉普拉斯算子（二阶差分）是基于过零点检...
python 实现 canny边缘检测算法
最新发布
luthane的博客
10-16 393
Canny边缘检测算法是一种优秀的边缘检测方法，由John F. Canny于1986年开发出来。它旨在找到图像中的最优边缘，确保好的检测、定位和最小响应。图像灰度化：如果输入的是彩色图像，首先需要进行灰度化处理，将其转换为灰度图像。这一步是为了简化后续的计算过程。高斯滤波：对灰度图像进行高斯滤波，以平滑图像并减少噪声。这一步是非常重要的，因为噪声可能会影响到边缘检测的结果。梯度计算：使用Sobel（或Prewitt）算子等计算图像中每个像素点的梯度幅值和方向。
python图像边缘检测报告_Python 实现 Canny 边缘检测算法
weixin_39795479的博客
11-23 339
Canny 边缘检测算法由计算机科学家 John F. Canny 于 1986 年提出的。其不仅提供了算法，还带来了一套边缘检测的理论，分阶段的解释如何实现边缘检测。Canny 检测算法包含下面几个阶段：灰度化高斯模糊计算图片梯度幅值非极大值抑制双阈值选取灰度化灰度化实际上是一种降维的操作，可以减少计算。如果算法不进行色彩相关的识别的话，不灰度化，也可以直接进行后面的阶段。# 灰度化def gr...
Canny边缘检测算法(python 实现）
热门推荐
MasterMiao的博客
08-14 7万+
文章目录最优边缘准则算法实现步骤1. 应用高斯滤波来平滑(模糊)图像，目的是去除噪声2. 计算梯度强度和方向3. 应用非最大抑制技术NMS来消除边误检4. 应用双阈值的方法来决定可能的（潜在的）边界5. 利用滞后技术来跟踪边界opencv实现Canny边缘检测手写代码参考文章 最优边缘准则     Canny 的目标是找到一个最优的边缘检测算法，最优边缘检测的含义是：     (1)最优检测：算法能够尽可能多地标识出图像中的实际边缘，漏检真实边缘的概率和误检非边缘的概率都尽可能小；     (2)最优定
python canny边缘检测算法_【python-opencv】canny边缘检测
weixin_32567181的博客
02-02 645
Canny Edge Detection是一种流行的边缘检测算法。它由John F. Canny发明，这是一个多阶段算法，我们将经历每个阶段。1、降噪由于边缘检测容易受到图像中噪声的影响，因此第一步是使用5x5高斯滤波器消除图像中的噪声。我们已经在前面的章节中看到了这一点。2、查找图像的强度梯度然后使用Sobel核在水平和垂直方向上对平滑的图像进行滤波，以在水平方向(Gx)和垂直方向(Gy)上获得...
python实现canny边缘检测
01-19
canny边缘检测原理 canny边缘检测共有5部分组成，下边我会分别来介绍。 1 高斯模糊（略） 2 计算梯度幅值和方向。 可选用的模板：soble算子、Prewitt算子、Roberts模板等等; 一般采用soble算子，OpenCV也是如此，...
Canny边缘检测原理与Python实现详解
"本文主要介绍了Canny边缘检测的原理，包括高斯模糊、计算梯度幅值和方向、非极大值抑制、双阈值算法以及Python实现。文章详细阐述了每个步骤，并给出了Python代码示例。" Canny边缘检测是一种经典的图像处理技术，...
python canny边缘检测算法_Python实现Canny边缘检测算法
weixin_39875516的博客
12-09 459
Canny边缘检测算法由计算机科学家John F. Canny于1986年提出. 它不仅提供算法，而且带来了一组边缘检测理论，分阶段说明了如何实现边缘检测. Canny检测算法包括以下阶段:灰度高斯模糊计算图像梯度幅度非最大抑制双重阈值选择灰度Graying实际上是降维操作，可以减少计算量. 如果该算法不执行与颜色相关的识别，它也可以直接执行后续阶段而不会发灰.高斯模糊噪声将包含在实际图片中. ...
python Canny边缘检测算法的实现
09-17
主要介绍了python Canny边缘检测算法的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
基于彩色图像的Canny边缘检测算法
06-09
基于图像边缘检测的Canny算法，梯度幅值和角度，进行非极大值抑制
Python实现Canny边缘检测
weixin_43348230的博客
04-14 8068
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录一、Canny边缘检测二、具体步骤1. 高斯平滑滤波 Noise Reduction2. Sobel Kernel3. NMS (Non-Maximum Suppression）4.Hysteresis Thresholding5.主函数6.实验结果三. 解决报错cv.imshow报错解决方案四 .完整代码 一、Canny边缘检测 基于Canny算子的边缘检测主要有5个步骤，依次是： 1.高斯滤波 2.像素梯度计算 3.非.
python Canny边缘检测
qq_40107571的博客
11-23 4111
python Canny边缘检测
python-OpenCV之Canny边缘检测
xddwz的博客
11-29 342
OpenCV提供了非常方便的Canny边缘检测函数，一行代码即可实现。 import os import cv2 import numpy as np image = cv2.imread('1.png') gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) edges = cv2.Canny(gray, 10, 250) cv2.imwrite('edgs.jpg', edges) Canny边缘检测算法其实非常复杂，包括5个步骤： 用高斯滤波
c#用canny算子做边缘提取_机器视觉学习（三）边缘检测
weixin_39997443的博客
11-18 479
一、边缘检测二、边缘检测流程三、Canny边缘检测前言边缘检测是图像处理和计算机视觉中，尤其是特征提取中的一个研究领域。有许多方法用于边缘检测，它们的绝大部分可以划分为两类：基于一阶导数首先计算边缘强度， 通常用一阶导数表示， 例如梯度模，然后，用计算估计边缘的局部方向， 通常采用梯度的方向，并利用此方向找到局部梯度模的最大值。即：图像一阶导数中的最大和最小值来检测边界，通常是将边界定位在梯度最大...
Python图像处理（8）：边缘检測
aoe41606的博客
04-05 77
快乐虾http://blog.csdn.net/lights_joy/欢迎转载，但请保留作者信息此前已经得到了单个区域植株图像，接下来似乎应该尝试对这些区域进行分类识别。通过外形和叶脉进行植物种类的识别显然是一种直观的做法。然而因为叶片交叠和光照等现实条件的存在，限制了这类方法的应...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值