Canny算子_百度百科 (baidu.com)https://baike.baidu.com/item/Canny%E7%AE%97%E5%AD%90/8821789?fr=ge_ala

图像处理中最经典的边沿检测算法： Canny边缘检测_哔哩哔哩_bilibilihttps://www.bilibili.com/video/BV1U4411277i/?spm_id_from=333.1007.top_right_bar_window_history.content.click&vd_source=7c3bfbf39d037fe80c97234396acc524

读取图像

需要处理成灰度图，因为输出会根据图片的尺寸来决定输出的位置以及窗口的大小，所以我这里自己初始化固定了窗口大小有输出的位置。

import numpy as np
import cv2

# 读取图像
image = cv2.imread('input_image.jpg', cv2.IMREAD_GRAYSCALE)

# 将灰度图像调整为固定大小
gray_resized = cv2.resize(image, (500, 400), interpolation=cv2.INTER_NEAREST)

# 获取屏幕尺寸
screen_height, screen_width = 1080, 1920

# 计算窗口左上角位置
window_x = int((screen_width - 500) / 2)
window_y = int((screen_height - 400) / 2)

# 创建窗口并显示结果
cv2.namedWindow('GrayImage', cv2.WINDOW_NORMAL)  # 设置窗口大小可调整
cv2.resizeWindow('GrayImage', 500, 400)
cv2.moveWindow('GrayImage', window_x, window_y)
cv2.imshow('GrayImage', gray_resized)
cv2.waitKey(0)
cv2.destroyAllWindows()

降噪（高斯滤波）

高斯滤波_百度百科 (baidu.com)https://baike.baidu.com/item/%E9%AB%98%E6%96%AF%E6%BB%A4%E6%B3%A2/9032353?fr=ge_ala

OpenCV高斯滤波函数--GaussianBlur()参数说明_gaussianblur参数-CSDN博客https://blog.csdn.net/qq_28126689/article/details/105953157用于平滑图像以消除噪声，使得后续的梯度计算更加稳定。

# 高斯滤波
image_blur = cv2.GaussianBlur(image, (5, 5), 1)

梯度计算

计算水平和垂直方向的梯度，因为是向量的形式他这个只有四条线来划分，假设计算出水平方向是指向0，垂直方向是指向90，他结果就是指向45，如果角度是30也会变成40。

# 计算梯度
gradient_x = cv2.Sobel(image_blur, cv2.CV_64F, 1, 0, ksize=3)
gradient_y = cv2.Sobel(image_blur, cv2.CV_64F, 0, 1, ksize=3)

gradient_magnitude = np.sqrt(gradient_x ** 2 + gradient_y ** 2)
gradient_direction = np.arctan2(gradient_y, gradient_x) * 180 / np.pi

非极大值抑制

将梯度图像中的局部最大值保留，以消除非边缘像素。对于每个像素，只有梯度方向上的像素值是局部最大值，才会保留，其他像素将被抑制。

就是根据前面梯度的方向，假设他梯度方向是垂直的，如果当前位置上面的元素和下面位置的元素都小于当前位置的元素，则当前位置就是局部最大值，就应该保留下来，反之就会被抑制。

 # 非极大值抑制
gradient_magnitude_suppressed = np.zeros_like(gradient_magnitude)
    for i in range(1, gradient_magnitude.shape[0] - 1):
        for j in range(1, gradient_magnitude.shape[1] - 1):
            angle = gradient_direction[i, j]
            if (0 <= angle < 22.5) or (157.5 <= angle <= 180) or (-22.5 <= angle < 0) or (-180 <= angle < -157.5):
                if (gradient_magnitude[i, j] >= gradient_magnitude[i, j + 1]) and (
                        gradient_magnitude[i, j] >= gradient_magnitude[i, j - 1]):
                    gradient_magnitude_suppressed[i, j] = gradient_magnitude[i, j]
            elif (22.5 <= angle < 67.5) or (-157.5 <= angle < -112.5):
                if (gradient_magnitude[i, j] >= gradient_magnitude[i - 1, j + 1]) and (
                        gradient_magnitude[i, j] >= gradient_magnitude[i + 1, j - 1]):
                    gradient_magnitude_suppressed[i, j] = gradient_magnitude[i, j]
            elif (67.5 <= angle < 112.5) or (-112.5 <= angle < -67.5):
                if (gradient_magnitude[i, j] >= gradient_magnitude[i - 1, j]) and (
                        gradient_magnitude[i, j] >= gradient_magnitude[i + 1, j]):
                    gradient_magnitude_suppressed[i, j] = gradient_magnitude[i, j]
            elif (112.5 <= angle < 157.5) or (-67.5 <= angle < -22.5):
                if (gradient_magnitude[i, j] >= gradient_magnitude[i - 1, j - 1]) and (
                        gradient_magnitude[i, j] >= gradient_magnitude[i + 1, j + 1]):
                    gradient_magnitude_suppressed[i, j] = gradient_magnitude[i, j]

双阈值检测

像素梯度大于高阈值，则将其标记为强边缘；如果像素梯度介于低阈值和高阈值之间，则将其标记为弱边缘；否则，将其标记为非边缘。

介于两条线之间的就是可能保留可能淘汰还要看后续的处理，高分数线以上的直接保留，低分数线没达到的直接淘汰。

# 双阈值检测
gradient_magnitude_suppressed_normalized = cv2.normalize(gradient_magnitude_suppressed, None, 0, 255,
                                                             cv2.NORM_MINMAX, cv2.CV_8U)
    low_threshold = int(low_threshold)
    high_threshold = int(high_threshold)

    strong_edges = (gradient_magnitude_suppressed_normalized >= high_threshold)
    weak_edges = (gradient_magnitude_suppressed_normalized >= low_threshold) & (
                gradient_magnitude_suppressed_normalized < high_threshold)

边缘连接

将弱边缘连接到强边缘，以形成完整的边缘。如果弱边缘与任何一个强边缘相连，则将其标记为边缘；否则，将其标记为非边缘。

就是画了两条分数线，低分数线以下的直接淘汰，高分数以上的直接录取，如果介于两条线之间的，看有没有关系，如果有关系就保留，没有关系就淘汰。

# 边缘连接
strong_edges_idx = np.argwhere(strong_edges)
weak_edges_idx = np.argwhere(weak_edges)

edge_image = np.zeros_like(gradient_magnitude_suppressed_normalized)
edge_image[strong_edges] = 255

for i, j in weak_edges_idx:
    if np.any(strong_edges[i - 1:i + 2, j - 1:j + 2]):
       edge_image[i, j] = 255

代码 

import numpy as np
import cv2


def CannyEdgeDetection(image, sigma=1, low_threshold=20, high_threshold=50):
    # 1. 高斯滤波
    image_blur = cv2.GaussianBlur(image, (5, 5), sigma)

    # 2. 计算梯度
    gradient_x = cv2.Sobel(image_blur, cv2.CV_64F, 1, 0, ksize=3)
    gradient_y = cv2.Sobel(image_blur, cv2.CV_64F, 0, 1, ksize=3)

    gradient_magnitude = np.sqrt(gradient_x ** 2 + gradient_y ** 2)
    gradient_direction = np.arctan2(gradient_y, gradient_x) * 180 / np.pi

    # 3. 非极大值抑制
    gradient_magnitude_suppressed = np.zeros_like(gradient_magnitude)
    for i in range(1, gradient_magnitude.shape[0] - 1):
        for j in range(1, gradient_magnitude.shape[1] - 1):
            angle = gradient_direction[i, j]
            if (0 <= angle < 22.5) or (157.5 <= angle <= 180) or (-22.5 <= angle < 0) or (-180 <= angle < -157.5):
                if (gradient_magnitude[i, j] >= gradient_magnitude[i, j + 1]) and (
                        gradient_magnitude[i, j] >= gradient_magnitude[i, j - 1]):
                    gradient_magnitude_suppressed[i, j] = gradient_magnitude[i, j]
            elif (22.5 <= angle < 67.5) or (-157.5 <= angle < -112.5):
                if (gradient_magnitude[i, j] >= gradient_magnitude[i - 1, j + 1]) and (
                        gradient_magnitude[i, j] >= gradient_magnitude[i + 1, j - 1]):
                    gradient_magnitude_suppressed[i, j] = gradient_magnitude[i, j]
            elif (67.5 <= angle < 112.5) or (-112.5 <= angle < -67.5):
                if (gradient_magnitude[i, j] >= gradient_magnitude[i - 1, j]) and (
                        gradient_magnitude[i, j] >= gradient_magnitude[i + 1, j]):
                    gradient_magnitude_suppressed[i, j] = gradient_magnitude[i, j]
            elif (112.5 <= angle < 157.5) or (-67.5 <= angle < -22.5):
                if (gradient_magnitude[i, j] >= gradient_magnitude[i - 1, j - 1]) and (
                        gradient_magnitude[i, j] >= gradient_magnitude[i + 1, j + 1]):
                    gradient_magnitude_suppressed[i, j] = gradient_magnitude[i, j]

    # 4. 双阈值检测
    gradient_magnitude_suppressed_normalized = cv2.normalize(gradient_magnitude_suppressed, None, 0, 255,
                                                             cv2.NORM_MINMAX, cv2.CV_8U)
    low_threshold = int(low_threshold)
    high_threshold = int(high_threshold)

    strong_edges = (gradient_magnitude_suppressed_normalized >= high_threshold)
    weak_edges = (gradient_magnitude_suppressed_normalized >= low_threshold) & (
                gradient_magnitude_suppressed_normalized < high_threshold)

    # 5. 边缘连接
    strong_edges_idx = np.argwhere(strong_edges)
    weak_edges_idx = np.argwhere(weak_edges)

    edge_image = np.zeros_like(gradient_magnitude_suppressed_normalized)
    edge_image[strong_edges] = 255

    for i, j in weak_edges_idx:
        if np.any(strong_edges[i - 1:i + 2, j - 1:j + 2]):
            edge_image[i, j] = 255

    return edge_image


# 读取图像
image = cv2.imread('input_image.jpg', cv2.IMREAD_GRAYSCALE)

# 使用Canny算子进行边缘检测
edges = CannyEdgeDetection(image)

# 将边缘图像调整为固定大小
edges_resized = cv2.resize(edges, (500, 400), interpolation=cv2.INTER_NEAREST)

# 获取屏幕尺寸
screen_height, screen_width = 1080, 1920

# 计算窗口左上角位置
window_x = int((screen_width - 500) / 2)
window_y = int((screen_height - 400) / 2)

# 创建窗口并显示结果
cv2.namedWindow('Canny Edge Detection', cv2.WINDOW_NORMAL)  # 设置窗口大小可调整
cv2.resizeWindow('Canny Edge Detection', 500, 400)
cv2.moveWindow('Canny Edge Detection', window_x, window_y)
cv2.imshow('Canny Edge Detection', edges_resized)
cv2.waitKey(0)
cv2.destroyAllWindows()

 这个代码是用chatGpt生成的，思路大概是没错的，但是不知道能不能对的上，还有就是识别出来的图像不对，可能很稀疏的几个点，也可能很密集，这个就需要调整高阈值和低阈值来处理。