#Edge detection and contour extraction: A complete guide to Canny operator, Hough transform, and contour analysis

#Introduction

Have you ever wondered: How do self-driving cars “see” lane lines? Why can the mobile app measure the diameter of coins with one click? ** Behind these scenes, there are two basic and hard-core computer vision technologies - edge detection and contour extraction.

A simple analogy:

• Edge: Just like the hook line in a pencil sketch, it is the place where the brightness or color changes the most in the image, usually corresponding to the boundary, shadow outline or texture change of the object.
• Contour: It is a closed curve obtained by connecting the points of these hook lines, which can directly circle the shape of the object we are interested in.

These two technologies are the "stepping stone" for traditional computer vision and are also the preliminary steps for many advanced vision tasks. By mastering them, you can quickly realize practical functions such as shape recognition, size measurement, and defect detection.

📂 Learning stage: Stage 1 — Cornerstone of image processing (traditional CV) 🔗 Related chapters: 图像增强与滤波 · 特征匹配实战

#1. Basic concepts of edge detection

#1.1 What is an edge?

In layman's terms, edges are those pixels in the image that have "obvious jumps in color or brightness." They often appear in:

• The intersection of object and background
• Transition areas between different materials or textures
• Shadow boundaries produced by lighting
• Location of color mutation

In these places, the brightness value of the image will change drastically, just like the "high frequency component" in the signal, so the edges are also regarded as the "high frequency signal" of the image.

#1.2 Gradient: a tool for measuring change

The core idea of ​​edge detection is to find the most intensely changing points on the image. We use a quantity called "gradient" to describe this change.

• Gradient Strength: How strong the change is (the larger the value, the more likely it is an edge)
• Gradient direction: In which direction the brightness changes (the direction of the edge is perpendicular to this direction)

The following example demonstrates the use of the Sobel operator to calculate gradient strength:

import numpy as np
import cv2

def compute_gradient_mag(image):
    """计算Sobel梯度强度（简化版边缘检测演示）"""
    gray = cv2.imread(image, 0) if isinstance(image, str) else image
    # Sobel算子可以分别检测水平和垂直方向的亮度变化
    grad_x = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
    grad_y = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
    # 合并两个方向的梯度得到整体强度
    mag = np.sqrt(grad_x**2 + grad_y**2)
    # 归一化到0~255便于显示
    return cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX, dtype=cv2.CV_8U)

In actual projects, such a simple gradient map is not directly used as the final edge, because the place with strong gradient is not necessarily a clean single-pixel edge. The Canny operator introduced next is a complete optimization process.

#2. Detailed explanation of Canny edge detection

The Canny operator is an optimal edge detection algorithm proposed by John F. Canny in 1986. Decades later, it is still the "gold standard" in the industry. A set of Canny operations can produce thin, accurate, and less noisy edge images.

#2.1 Four key steps

Canny's process can be divided into four major steps:

1. Gaussian filter: First smooth the image and suppress the noise. Noise can easily be misjudged as edges, and this step is equivalent to "skin grinding".
2. Calculate gradient: Use the Sobel (or Scharr) operator to calculate the gradient strength and direction of each pixel.
3. Non-maximum suppression (NMS): Remove those points that are "not local maximum" in the gradient map, retain only the centermost pixels on the edge, and make the thick edges thinner.
4. Hysteresis Threshold: Set two thresholds, high and low. Points whose intensity is higher than the high threshold are directly confirmed as "true edges"; points whose intensity is lower than the low threshold are directly discarded; points in between will only be retained when they are connected to true edges, so that intermittent edges can be connected.

#2.2 Code implementation and parameter tuning

When actually using Canny, the most troublesome thing is how to set the two thresholds. A very classic technique is to automatically calculate based on the median value of the image gradient, which can be adapted to different images:

def auto_canny(image, sigma=0.33):
    """
    自动计算Canny阈值：基于图像中值
    sigma 越小 → 阈值范围越窄 → 边缘多（可能包含噪声）
    sigma 越大 → 阈值范围越宽 → 边缘少（可能漏掉细节）
    """
    gray = cv2.imread(image, 0) if isinstance(image, str) else image
    blurred = cv2.GaussianBlur(gray, (5, 5), 0)  # 内置高斯滤波
    
    v = np.median(blurred)
    lower = int(max(0, (1.0 - sigma) * v))
    upper = int(min(255, (1.0 + sigma) * v))
    return cv2.Canny(blurred, lower, upper)

# 简单调用
edges = auto_canny("test.jpg")
cv2.imshow("Auto Canny", edges)
cv2.waitKey(0)

def detect_lines(image_path):
    img = cv2.imread(image_path)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    edges = auto_canny(gray)  # 复用前面的自动Canny
    
    # 概率霍夫变换
    lines = cv2.HoughLinesP(
        edges,
        rho=1,           # ρ 的精度（像素）
        theta=np.pi/180, # θ 的精度（1度）
        threshold=50,    # 累加器阈值（线段上最少要有的点数）
        minLineLength=50,# 线段的最小长度
        maxLineGap=10    # 同一方向上两点允许的最大间隙（用于连接断线）
    )
    
    # 绘制结果
    result = img.copy()
    if lines is not None:
        for x1, y1, x2, y2 in lines[:, 0]:
            cv2.line(result, (x1, y1), (x2, y2), (0, 255, 0), 2)
    return result

def detect_circles(image_path):
    img = cv2.imread(image_path)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    blurred = cv2.GaussianBlur(gray, (9, 9), 2)  # 较强模糊去噪
    
    circles = cv2.HoughCircles(
        blurred,
        cv2.HOUGH_GRADIENT,
        dp=1,           # 累加器分辨率（1 表示和原图一致）
        minDist=20,     # 圆心之间的最小距离，避免检测到一堆重复圆
        param1=50,      # Canny 的高阈值
        param2=30,      # 圆心检测阈值（越小找到的圆越多）
        minRadius=5,    # 最小半径
        maxRadius=100   # 最大半径
    )
    
    # 绘制圆和圆心
    result = img.copy()
    if circles is not None:
        circles = np.round(circles[0, :]).astype("int")
        for x, y, r in circles:
            cv2.circle(result, (x, y), r, (0, 255, 0), 2)
            cv2.circle(result, (x, y), 2, (0, 0, 255), 3)
    return result

#4. Contour extraction and analysis

Contour can be regarded as an "upgraded version" of edge detection - it can not only find boundary points, but also string these points into closed curves to directly obtain the outer frame of the object.

#4.1 Basics of contour extraction

To extract contours, you must first turn the image into a binary image (black and white, the background is black, and the foreground is white). OpenCVfindContoursThe function returns a list of contours, each contour is a sequence of point coordinates.

def extract_contours(image_path):
    img = cv2.imread(image_path)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    # 简单二值化（光照不均时可改用自适应阈值）
    _, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY_INV)  # 反转，让目标变成白色
    
    # 查找轮廓
    # RETR_EXTERNAL：只检测最外层轮廓
    # CHAIN_APPROX_SIMPLE：压缩掉水平/垂直/对角线方向上的冗余点，节省内存
    contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    
    # 绘制所有轮廓
    result = img.copy()
    cv2.drawContours(result, contours, -1, (0, 255, 0), 2)
    return result

#4.2 Analysis of contour geometric features

With the contour, we can calculate many useful geometric features for shape recognition or size measurement.

def analyze_contour(contour):
    """分析单个轮廓的核心几何特征"""
    # 1. 基础特征
    area = cv2.contourArea(contour)          # 面积
    perimeter = cv2.arcLength(contour, True) # 周长（True 表示闭合）
    
    # 2. 边界矩形
    x, y, w, h = cv2.boundingRect(contour)   # 轴对齐的外接矩形
    aspect_ratio = w / h                      # 宽高比
    
    # 3. 圆度（越接近1，说明形状越像圆）
    circularity = 4 * np.pi * area / (perimeter**2) if perimeter > 0 else 0
    
    # 4. 凸包与坚实度
    hull = cv2.convexHull(contour)
    hull_area = cv2.contourArea(hull)
    solidity = area / hull_area if hull_area > 0 else 0  # 轮廓面积占凸包面积的比例
    
    return {
        "area": area,
        "perimeter": perimeter,
        "aspect_ratio": aspect_ratio,
        "circularity": circularity,
        "solidity": solidity,
        "bounding_box": (x, y, w, h)
    }

These features can be combined into simple rules to determine shapes, such as:

• Rectangle: If the aspect ratio is close to 1, it is a square, otherwise it is an ordinary rectangle.
• Circle: If the roundness is greater than a certain threshold (such as 0.8), it can be judged as a circle.

#5. Practical project: simple shape detector

Combined with the previous contour analysis and contour approximation (approxPolyDP), we can quickly build a simple shape detector to automatically identify common shapes such as triangles, rectangles, squares, circles, etc.

class SimpleShapeDetector:
    def detect(self, contour):
        # 1. 轮廓近似：用更少的拐点逼近轮廓
        perimeter = cv2.arcLength(contour, True)
        approx = cv2.approxPolyDP(contour, 0.04 * perimeter, True)
        vertices = len(approx)
        
        # 2. 计算辅助特征
        features = analyze_contour(contour)
        
        # 3. 基于顶点数量和几何特征判断形状
        if vertices == 3:
            return "Triangle"
        elif vertices == 4:
            return "Square" if 0.95 < features["aspect_ratio"] < 1.05 else "Rectangle"
        elif vertices == 5:
            return "Pentagon"
        elif features["circularity"] > 0.8:
            return "Circle"
        else:
            return "Polygon"
    
    def detect_in_image(self, image_path):
        img = cv2.imread(image_path)
        binary = cv2.threshold(
            cv2.cvtColor(img, cv2.COLOR_BGR2GRAY), 127, 255, cv2.THRESH_BINARY_INV
        )[1]
        contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
        
        result = img.copy()
        for c in contours:
            if cv2.contourArea(c) < 200:  # 过滤掉太小的噪声
                continue
            shape = self.detect(c)
            # 计算轮廓中心点，用于标注文字
            M = cv2.moments(c)
            cX = int(M["m10"] / M["m00"]) if M["m00"] != 0 else 0
            cY = int(M["m01"] / M["m00"]) if M["m00"] != 0 else 0
            
            cv2.drawContours(result, [c], -1, (0, 255, 0), 2)
            cv2.putText(result, shape, (cX - 20, cY),
                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2)
        return result

The logic of this detector is very simple, but it can handle a large number of standard shape recognition tasks. You can use it to test different pictures and feel the parameters (such as approximate accuracy0.04) on the results.

#6. Summary

Edge detection and contour extraction are very core skills in traditional computer vision systems. The relationship and applicable scenarios between the three are summarized as follows:

🔗 Extended reading

• OpenCV Canny 边缘检测官方教程
• OpenCV 霍夫变换官方教程
• 图像增强与滤波