Canny Edge Detection

When you look at a photograph, your eye effortlessly traces the contour of a face, a road, a leaf. Computers have to earn that ability. For decades, the best answer to the question "where are the edges in this image?" has been a four-step pipeline published by John Canny in 1986 — a pipeline so elegant that it still ships in almost every modern vision system.

An edge is simply a place where pixel brightness changes sharply. Smooth regions change slowly; boundaries between objects change fast. Canny's insight was to make that notion of "fast change" precise: compute the gradient of the image (how brightness varies in every direction), thin it down to single-pixel ridges, and then decide which ridges are real edges with a double threshold called hysteresis.

The result is a map of the image's skeleton — the outlines of every object, drawn with one-pixel-wide curves, without gaps in important lines and without noise masquerading as signal.

Paint a simple shape on the pixel grid below, then step through the Canny pipeline to watch edges emerge. Each button advances one stage.

<!-- {{c_html_intro}} -->
<p class="hint">{{hint_para}}</p>
<div class="controls top-controls">
  <button id="btn-paint" class="active" type="button">{{btn_paint}}</button>
  <button id="btn-erase" type="button">{{btn_erase}}</button>
  <button id="btn-reset" type="button" class="ghost">{{btn_reset}}</button>
</div>
<div id="grid-wrap">
  <canvas id="canvas" width="240" height="240"></canvas>
</div>
<div class="pipeline-row">
  <button id="btn-gradient" type="button">{{btn_gradient}}</button>
  <button id="btn-nms" type="button" disabled>{{btn_nms}}</button>
  <button id="btn-hysteresis" type="button" disabled>{{btn_hysteresis}}</button>
</div>
<div class="status" id="status">{{status_paint}}</div>

/* {{c_css_reset}} */
* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; padding: 4px; }
.hint { font-size: .85rem; color: #444; margin: 0 0 .6rem; line-height: 1.45; }
#grid-wrap { display: inline-block; border: 2px solid #8899aa; border-radius: 6px; overflow: hidden; cursor: crosshair; margin: .4rem 0; }
canvas { display: block; image-rendering: pixelated; }
.controls { display: flex; gap: .4rem; flex-wrap: wrap; margin-bottom: .4rem; }
.pipeline-row { display: flex; gap: .4rem; flex-wrap: wrap; margin: .4rem 0; }
button { font: 600 13px system-ui, sans-serif; padding: .4rem .75rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; transition: opacity .15s; }
button.ghost { background: #fff; color: #1d3557; }
button.active { outline: 2px solid #e63946; outline-offset: 2px; }
button:disabled { opacity: .35; cursor: default; }
.status { font-size: .9rem; font-weight: 600; min-height: 1.4em; margin-top: .35rem; color: #1d3557; }
.status.done { color: #0a7d33; }

// Code not found

Notice that non-maximum suppression thins broad gradient ridges into crisp one-pixel lines, and hysteresis keeps weak pixels that are connected to strong ones — bridging gaps without being fooled by isolated noise.

Canny did not just build a detector that works — he defined what a perfect edge detector should do, then proved his pipeline satisfies all three criteria at once.

The three optimality criteria:

• Good detection. The detector must not miss real edges and must not invent fake ones. Formally, it maximises the signal-to-noise ratio of the response.
• Good localisation. Detected edges must sit as close as possible to the true boundary — Canny minimises the expected distance between a detected edge and the actual edge.
• Minimal response. Each physical edge should produce exactly one detected edge; no double responses. Non-maximum suppression enforces this by keeping only the local peak of the gradient magnitude along each ridge direction.

Runtime: the pipeline is $O(n)$ in the number of pixels. Every step — Gaussian blur, gradient computation, non-maximum suppression, hysteresis — scans the image a constant number of times with fixed-size kernels.

The two thresholds (high $T_h$ and low $T_l$) are the only free parameters, and setting $T_h / T_l \approx 2\text{–}3$ is a robust rule of thumb. Unlike many algorithms, the sensitivity to these parameters is predictable: raising $T_h$ removes weaker edges; lowering $T_l$ keeps more of the chains connected to strong edges.

For a deeper look at how gradient-based reasoning powers many algorithms, see the article on Dijkstra's algorithm — both exploit the idea of propagating information along a "steepest direction."

Edge maps are the lingua franca of computer vision. Almost every pipeline that understands images starts with edges:

• Medical imaging: CT and MRI scans use edge detection to delineate organs, tumours, and bone boundaries before any higher-level analysis. Canny's precision matters here — a missed boundary can change a diagnosis.
• Autonomous vehicles: lane-keeping systems find road markings by detecting the sharp contrast between asphalt and paint. Edge maps are cheap to compute on embedded hardware.
• Face and object detection: classical detectors like Viola–Jones use Haar features that respond to intensity differences — essentially oriented edge energy — to locate faces in real time.
• Document scanning: apps that straighten a photographed page first detect the four edges of the document, then warp the perspective.
• Industrial inspection: detecting cracks, scratches, or missing features on a manufactured part is a high-precision edge-finding problem where Canny's localization guarantee saves money.

The algorithm is also a conceptual ancestor of the learned feature detectors inside modern neural networks. The first layer of a convolutional network trained on natural images learns filters that look almost exactly like oriented Canny-style edge detectors — the network rediscovers what Canny proved optimal in 1986.

Canny edge detection is a rare algorithm that was both practically useful the day it was published and theoretically justified — it provably satisfies three simultaneous optimality criteria. Its $O(n)$ runtime, single-pixel-wide output, and predictable sensitivity to thresholds make it the default choice whenever a vision system needs to find outlines.

The deeper lesson is about what "optimal" even means in image processing: Canny forced the field to write down what a good edge detector should do before building one, and that discipline produced something still copied by neural networks four decades later.

If edge detection is about finding the fastest-changing direction in a field of values, you are never far from ideas like Dijkstra's algorithm, which propagates along the cheapest path in a weighted graph — both are fundamentally about following gradients.