Redis未授权利用方式总结-CFANZ编程社区

一、基本概念

1.图像边缘检测目的

2.图像边缘检测重要性

3.何为图像边缘？

4.图像边缘检测原理

5.边缘检测算法分类

二、边缘检测步骤

1. 滤波

2. 增强

3. 检测

4. 定位

5. 边缘连接（可选）

三、边缘检测算法

算法实现一般步骤：

1. Sobel边缘检测算法

OpenCV实现示例：

import cv2  
import numpy as np  
import matplotlib.pyplot as plt  
  
# 读取图像  
def load_image(image_path):  
    # 使用cv2.imread()读取图像，参数0表示以灰度模式读取  
    img = cv2.imread(image_path, 0)  
    if img is None:  
        raise FileNotFoundError("图像文件未找到或路径错误")  
    return img  
  
# 使用Sobel算子进行边缘检测  
def sobel_edge_detection(image):  
    # 将图像转换为float32类型，以避免在计算中出现数据类型溢出  
    image_float = np.float32(image)  
      
    # 分别计算X和Y方向的Sobel梯度  
    # 参数dx=1, dy=0, ksize=3表示计算X方向的Sobel梯度  
    sobelx = cv2.Sobel(image_float, cv2.CV_64F, 1, 0, ksize=3)  
    # 参数dx=0, dy=1, ksize=3表示计算Y方向的Sobel梯度  
    sobely = cv2.Sobel(image_float, cv2.CV_64F, 0, 1, ksize=3)  
      
    # 计算梯度幅度，这里使用欧几里得距离  
    sobel_magnitude = np.sqrt(sobelx**2 + sobely**2)  
      
    # 将梯度幅度转换为uint8类型，便于显示  
    sobel_magnitude_uint8 = np.uint8(np.absolute(sobel_magnitude))  
      
    return sobel_magnitude_uint8  
  
# 主函数  
def main():  
    # 图像路径  
    image_path = 'path_to_your_image.jpg'  
      
    # 加载图像  
    img = load_image(image_path)  
      
    # 使用Sobel算子进行边缘检测  
    edges = sobel_edge_detection(img)  
      
    # 显示原图和处理后的图像  
    plt.figure(figsize=(10, 5))  
    plt.subplot(121), plt.imshow(img, cmap='gray'), plt.title('Original Image')  
    plt.xticks([]), plt.yticks([])  
    plt.subplot(122), plt.imshow(edges, cmap='gray'), plt.title('Sobel Edge Detection')  
    plt.xticks([]), plt.yticks([])  
    plt.show()  
  
if __name__ == "__main__":  
    main()

2. Canny边缘检测算法

OpenCV实现示例：

import cv2  
import numpy as np  
  
# 读取图片  
# 请确保你的图片路径是正确的，或者将'path_to_your_image.jpg'替换为图片的文件名（如果图片和脚本在同一目录下）  
image_path = 'path_to_your_image.jpg'  
image = cv2.imread(image_path)  
  
# 检查图片是否成功读取  
if image is None:  
    print("Error: 图片没有成功读取。请检查文件路径。")  
else:  
    # 转换为灰度图，因为Canny边缘检测在灰度图上运行  
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)  
  
    # 应用Canny边缘检测  
    # 第一个参数是灰度图  
    # 第二个和第三个参数分别是Canny算法中的低阈值和高阈值  
    # 这两个阈值的选择取决于你的具体图像，可能需要一些实验来找到最佳值  
    edges = cv2.Canny(gray_image, threshold1=100, threshold2=200)  
  
    # 显示原图和边缘检测结果  
    cv2.imshow('Original Image', image)  
    cv2.imshow('Canny Edges', edges)  
  
    # 等待按键操作，之后关闭所有窗口  
    cv2.waitKey(0)  
    cv2.destroyAllWindows()

3. Roberts边缘检测算法

OpenCV实现示例：

import cv2  
import numpy as np  
  
def roberts_edge_detection(image_path):  
    # 读取图像  
    image = cv2.imread(image_path)  
    if image is None:  
        print("Error: Image not found or unable to read.")  
        return  
  
    # 转换为灰度图  
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)  
  
    # 定义Roberts算子的两个卷积核  
    kernel_x45 = np.array([[-1, 0],  
                           [ 0, 1]], dtype=np.float32)  
    kernel_y135 = np.array([[0, -1],  
                            [1,  0]], dtype=np.float32)  
  
    # 应用Roberts算子得到两个方向的梯度图  
    grad_x45 = cv2.filter2D(gray_image, cv2.CV_16S, kernel_x45)  
    grad_y135 = cv2.filter2D(gray_image, cv2.CV_16S, kernel_y135)  
  
    # 将梯度图转换为绝对值，并转换为8位无符号整数  
    abs_grad_x45 = cv2.convertScaleAbs(grad_x45)  
    abs_grad_y135 = cv2.convertScaleAbs(grad_y135)  
  
    # 计算梯度的幅值（这里使用绝对值相加作为近似）  
    gradient_magnitude = cv2.addWeighted(abs_grad_x45, 0.5, abs_grad_y135, 0.5, 0)  
  
    # 对梯度幅值进行阈值化处理，得到二值边缘图像  
    _, edges = cv2.threshold(gradient_magnitude, 50, 255, cv2.THRESH_BINARY)  
  
    # 显示结果  
    cv2.imshow('Original Image', image)  
    cv2.imshow('Roberts Edges', edges)  
    cv2.waitKey(0)  
    cv2.destroyAllWindows()  
  
# 调用函数，传入图像路径  
roberts_edge_detection('path_to_your_image.jpg')

4. Prewitt边缘检测算法

OpenCV实现示例：

import cv2  
import numpy as np  
  
def prewitt_operator(image, axis='both'):  
    """  
    使用Prewitt算子进行边缘检测  
  
    参数:  
    - image: 输入图像，应为灰度图  
    - axis: 指定使用哪个方向的Prewitt算子，'x'为水平方向，'y'为垂直方向，'both'为两个方向都使用  
  
    返回:  
    - 如果axis为'x'或'y'，则返回相应方向的边缘检测结果；  
    - 如果axis为'both'，则返回两个方向边缘检测结果的叠加。  
    """  
    # 定义Prewitt算子  
    prewitt_x = np.array([[-1, 0, 1],  
                          [-1, 0, 1],  
                          [-1, 0, 1]], dtype=np.float32)  
    prewitt_y = np.array([[-1, -1, -1],  
                          [ 0,  0,  0],  
                          [ 1,  1,  1]], dtype=np.float32)  
  
    # 将图像转换为浮点数类型，以便进行精确计算  
    image_float = np.float32(image)  
  
    # 根据指定的axis计算边缘  
    if axis == 'x':  
        edges = cv2.filter2D(image_float, -1, prewitt_x)  
    elif axis == 'y':  
        edges = cv2.filter2D(image_float, -1, prewitt_y)  
    elif axis == 'both':  
        edges_x = cv2.filter2D(image_float, -1, prewitt_x)  
        edges_y = cv2.filter2D(image_float, -1, prewitt_y)  
        edges = cv2.addWeighted(edges_x, 0.5, edges_y, 0.5, 0)  
    else:  
        raise ValueError("Invalid axis value. Use 'x', 'y', or 'both'.")  
  
    # 将边缘检测结果转换为8位无符号整数  
    edges = np.uint8(np.absolute(edges))  
  
    return edges  
  
# 读取图像并转换为灰度图  
image = cv2.imread('your_image_path.jpg', cv2.IMREAD_GRAYSCALE)  
  
# 使用Prewitt算子进行边缘检测  
edges = prewitt_operator(image, 'both')  
  
# 显示原图和边缘检测结果  
cv2.imshow('Original Image', image)  
cv2.imshow('Prewitt Edges', edges)  
cv2.waitKey(0)  
cv2.destroyAllWindows()

5. Laplacian边缘检测算法

6.LoG边缘检测算法

OpenCV实现示例：

import cv2  
import numpy as np  
  
def log_edge_detection(image_path, sigma=1.4, ksize=5):  
    """  
    使用LoG（Laplacian of Gaussian）算子进行边缘检测  
  
    参数:  
    image_path : str  
        图像文件的路径  
    sigma : float  
        高斯模糊的标准差。较大的sigma值会产生更平滑的图像，适用于检测更广泛的边缘。  
    ksize : int  
        高斯核的大小，必须是正数和奇数。它会影响高斯模糊的效果。  
  
    返回:  
    edges : ndarray  
        边缘检测后的图像  
    """  
    # 读取图像  
    image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)  
    if image is None:  
        raise FileNotFoundError("无法找到或读取图像文件")  
  
    # 应用高斯模糊  
    blurred = cv2.GaussianBlur(image, (ksize, ksize), sigma)  
  
    # 计算拉普拉斯算子  
    # 注意：OpenCV中的Laplacian函数默认使用ddepth=cv2.CV_64F，然后转换为8位以显示  
    laplacian = cv2.Laplacian(blurred, cv2.CV_64F)  
    laplacian = np.uint8(np.absolute(laplacian))  
  
    # 由于拉普拉斯算子可能会产生负值，使用绝对值函数将其转换为正值  
    # 然后将数据类型转换为uint8以用于显示  
  
    # 返回边缘检测后的图像  
    return laplacian  
  
# 使用示例  
if __name__ == "__main__":  
    image_path = 'path_to_your_image.jpg'  # 替换为你的图像文件路径  
    edges = log_edge_detection(image_path)  
  
    # 显示原图和处理后的图像  
    cv2.imshow('Original Image', cv2.imread(image_path, cv2.IMREAD_GRAYSCALE))  
    cv2.imshow('LoG Edge Detection', edges)  
    cv2.waitKey(0)  
    cv2.destroyAllWindows()

详细参考以下几篇文章：@搬运程序的小垃圾

http://t.csdnimg.cn/s71P6http://t.csdnimg.cn/s71P6深度学习系列-几种边缘检测算法 - 知乎 (zhihu.com)https://zhuanlan.zhihu.com/p/324540079数字图像处理——边缘检测算法 - 知乎 (zhihu.com)https://zhuanlan.zhihu.com/p/357515658