Canny Edge Detection Pipeline

hardPROEdge DetectionEdgesCV: Feature Detection and Matching

Implement the complete Canny edge detection pipeline, a multi-stage process for detecting edges in images. The Canny edge detection algorithm is a widely used technique in Computer Vision for identifying and locating edges in images, which is crucial for various applications such as object recognition, image segmentation, and feature extraction.

The process involves several key steps, including Gaussian blur to reduce noise, gradient computation using Sobel operators to calculate the magnitude and direction of the gradient, non-maximum suppression to thin edges to 1 pixel width, and hysteresis thresholding to connect edges using two thresholds. The gradient magnitude is calculated as $G = \sqrt{G_x^2 + G_y^2}$ , where $G_x$ and $G_y$ are the horizontal and vertical gradient components.

Apply Gaussian blur to the input image to reduce noise.
Compute the gradient using Sobel operators to obtain the magnitude and direction of the gradient.
Perform non-maximum suppression to thin edges to 1 pixel width by comparing each pixel to its neighbors along the gradient direction.
Apply hysteresis thresholding to connect edges using two thresholds, where strong edges are retained and weak edges are only kept if connected to strong edges.

G = \sqrt{G_x^2 + G_y^2}

Use a Gaussian with $\sigma = 1.4$ . The output is an array the same shape as the image holding integer values (0 = no edge, 1 = edge), not booleans; the 1-pixel image border is always 0.

This technique is widely used in image processing and analysis applications.

Example

Input

image = grayscale image with edges
low_threshold = 50
high_threshold = 150

Output

Binary edge map with thin, connected edges

Reasoning

Input: image is an $H \times W$ intensity grid; take a $7 \times 9$ image whose every row is $(0, 0, 0, 0, 128, 255, 255, 255, 255)$ , a vertical edge centred on column 4. low_threshold = 50 and high_threshold = 150 are gradient-magnitude cutoffs.
Blur ( $\sigma = 1.4$ ) turns the step into a ramp: $0.8, 5.0, 21.8, 63.1, 127.6, 192.1, 233.3, 250.0, 254.2$ .
Gradient: rows are identical, so $G_y = 0$ and the direction is $0^\circ$ . Across a row $G \approx 16.9, 84.0, 232.4, 423.3, 515.9, 422.6, 231.6, 83.6, 16.8$ .
Suppression: with a horizontal gradient, each pixel is compared with its left and right neighbours. Only column 4 survives ( $515.9 \ge 423.3$ and $\ge 422.6$ ); columns 3 and 5 exceed 150 but are erased.
Hysteresis: $515.9 \ge 150$ , so column 4 is strong.
Output: a Binary edge map with thin, connected edges: five 1s in column 4, rows 1–5, zeros elsewhere. With high_threshold = 600 it is all zeros: $515.9$ clears the low cutoff but has no strong pixel to attach to.

Constraints

image: Grayscale image (H, W)
low_threshold: Lower threshold for hysteresis
high_threshold: Upper threshold for hysteresis
Return: Binary edge map

Learn this in

Feature Detection and MatchingCV Study Plan

More from CV: Feature Detection and Matching

Circle Hough Transformhard Hamming Distance Matcherhard Simple BRIEF Descriptormedium Point to Hough Spaceeasy Edge Non-Maximum Suppressionmedium

Concept primerPREVIEW

Canny Edge Detection Pipeline: Background & Strategy

Background Knowledge

What is Edge Detection and Why Canny?

Edge detection identifies boundaries in images where pixel intensity changes sharply. These boundaries are crucial for higher-level computer vision tasks like object recognition and image segmentation. The Canny edge detector is considered superior to simpler methods because it optimizes three criteria: low error rate (detecting all true edges), good localization (edges positioned accurately), and single response (one edge per true boundary). Unlike basic threshold-based approaches, Canny uses a multi-stage algorithm that progressively refines edge candidates, making it robust to noise while preserving important structural information.

The Four-Stage Pipeline

The Canny algorithm works through sequential stages, each serving a specific purpose. First, Gaussian blur smooths the image to reduce noise without destroying edge information—this is critical because raw pixel data contains high-frequency noise that would create false edges. Second, gradient computation using Sobel operators calculates both the magnitude (edge strength) and direction (edge orientation) at each pixel. Third, non-maximum suppression thins edges to single-pixel width by keeping only local maxima along the gradient direction—this eliminates thick, blurry edges. Finally, hysteresis thresholding uses two thresholds to distinguish strong edges (definitely keep) from weak edges (keep only if connected to strong ones), creating a connected edge map.

Key Insight: Local Geometry Matters

Non-maximum suppression and hysteresis thresholding both rely on understanding local pixel neighborhoods. In non-max suppression, you compare a pixel's gradient magnitude to its two neighbors along the gradient direction—only the strongest survives. In hysteresis, connectivity determines whether weak edges are retained, requiring you to trace connections between pixels. This neighborhood-based reasoning is fundamental to the algorithm's effectiveness.

Algorithm/Approach

The Canny pipeline follows a sequential filtering and refinement pattern:

Noise reduction phase: Apply Gaussian convolution to smooth the image
Feature extraction phase: Compute gradient information using derivative operators
Localization phase: Suppress non-maximal responses to sharpen edges
Decision phase: Apply dual-threshold logic with connectivity constraints

Think of it as progressively filtering out less important information: first noise, then weak gradients, then isolated weak edges. Each stage reduces the data while preserving true edges.

Step-by-Step Strategy

Step 1: Gaussian Blur

Create a Gaussian kernel (typically 5×5) with standard deviation σ (often 1.0-1.5)
Convolve the input image with this kernel
Handle image boundaries (padding strategies: zero-padding, reflection, or border replication)
Output: Smoothed grayscale image

PRO

Continue the full explanation

You're reading the free preview. Unlock the complete walkthrough, the code editor, test runner and reference solution with Premium.

PRO

Editor locked

The code editor is locked for Pro problems. It is only available for free problems. Please upgrade to gain access to the code editor for all problems.

solution.py

Python 3.13

Test results