HOG Descriptor

In 2005 Navneet Dalal and Bill Triggs asked a deceptively simple question: what single number best describes the local shape of an image patch? Their answer — count the orientations of edges inside tiny grid cells — produced the Histogram of Oriented Gradients (HOG) descriptor, and with it the first reliable pedestrian detector that worked in the wild.

The idea starts with gradients. At each pixel the image brightness changes slightly as you move left-to-right or top-to-bottom. Those two numbers — the horizontal and vertical change — define an edge direction (an angle from $0°$ to $180°$) and a magnitude (how strong the edge is). HOG ignores the exact pixel values and instead bins the angles, weighted by magnitude, inside each small cell of the image.

The resulting histogram — typically 9 bins covering $0°$ to $180°$ in $20°$ steps — is a compact fingerprint of the local shape. Stack the histograms of all cells across a detection window, normalize them in overlapping blocks to handle lighting changes, and you have a vector of a few thousand numbers that is stable, fast to compute, and remarkably effective at telling humans from backgrounds.

Draw on the canvas below — any stroke, letter, or shape. The grid overlaid on the canvas is the HOG cell grid. Inside each cell the demo computes the gradient at every pixel, bins the angle into one of 9 orientation buckets, and draws a small oriented line proportional to the total weight in that bucket.

<!-- {{c_title}} -->
<p class="hint">{{hint_para}}</p>
<div class="controls">
  <label for="brushSize">{{label_brush}}</label>
  <input type="range" id="brushSize" min="4" max="24" value="10" title="{{title_brush}}">
  <button id="clearBtn" type="button">{{btn_clear}}</button>
  <button id="showGrad" type="button">{{btn_toggle}}</button>
</div>
<div class="canvas-wrap">
  <canvas id="drawCanvas" width="288" height="288" aria-label="{{aria_canvas}}"></canvas>
  <canvas id="hogCanvas"  width="288" height="288" aria-label="{{aria_hog}}"></canvas>
</div>
<p class="status" id="status">{{status_draw}}</p>

/* {{c_layout}} */
* { box-sizing: border-box; margin: 0; padding: 0; }
body { font-family: system-ui, sans-serif; color: #222; }
.hint { font-size: .9rem; color: #444; margin-bottom: .6rem; line-height: 1.45; }
.controls { display: flex; align-items: center; gap: .6rem; flex-wrap: wrap; margin-bottom: .5rem; }
.controls label { font-size: .85rem; color: #555; white-space: nowrap; }
.controls input[type=range] { width: 80px; cursor: pointer; }
button { font: 600 13px system-ui; padding: .4rem .8rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 7px; cursor: pointer; }
button#showGrad { background: #fff; color: #1d3557; }
button#showGrad.active { background: #1d3557; color: #fff; }
.canvas-wrap { position: relative; display: inline-block; border: 1px solid #cdd9e3; border-radius: 6px; overflow: hidden; }
canvas { display: block; }
#hogCanvas { position: absolute; top: 0; left: 0; pointer-events: none; }
.status { font-size: .9rem; color: #555; margin-top: .5rem; min-height: 1.3em; }

// Code not found

Notice how straight lines produce a single strong arrow aligned with the edge, while curves fill multiple buckets. Blank regions produce no arrows at all. That is exactly what HOG sends to a classifier: not pixels, but a compact summary of which directions have edges and how strongly.

HOG is a solved feature-engineering problem — a deliberate design rather than an open question. Understanding its tradeoffs explains both why it worked so well and why it was eventually replaced.

• Computation. For a detection window of $W \times H$ pixels, divided into $C \times C$ pixel cells and $B \times B$ cell blocks, the descriptor length is roughly $\frac{W}{C} \cdot \frac{H}{C} \cdot B^2 \cdot k$ where $k = 9$ is the number of orientation bins. A typical $64 \times 128$ window with $8 \times 8$ cells and $2 \times 2$ block normalization yields a 3780-dimensional vector — computed in milliseconds with integral images.
• Why it works. Gradients respond to shape boundaries regardless of color or slow lighting variation. Normalizing overlapping blocks makes the descriptor robust to local contrast changes. The orientation bins are unsigned ($0°$–$180°$), so a left-to-right edge and a right-to-left edge fall in the same bin — capturing shape without being confused by contrast polarity.
• Status: solved (2005). Dalal and Triggs combined HOG with a linear Support Vector Machine and won the PASCAL VOC pedestrian challenge by a large margin. The design choices — cell size, block overlap, $\ell_2$-norm block normalization — were validated exhaustively and have not been significantly bettered for hand-crafted descriptors.
• Limits. HOG cannot handle large viewpoint changes or occlusions, and the sliding-window detection pipeline scales poorly with image size. Deep convolutional networks learn features similar to HOG in their first layers but then build richer representations that surpass it on every benchmark.

HOG sits at the intersection of signal processing and machine learning: a closed-form descriptor that encodes enough shape information to be paired with a simple classifier and still beat the state of the art for nearly a decade.

Oriented gradient histograms appear wherever local shape must be described efficiently:

• Pedestrian and vehicle detection: HOG + SVM was the engine of early automotive-safety cameras and surveillance systems before deep learning took over.
• Action recognition: stacking HOG across video frames gives a descriptor (HOF/MBH) that captures how limbs move even at low resolution.
• Document layout analysis: text regions, tables, and figures produce distinctive orientation patterns that HOG-based classifiers can locate.
• Medical imaging: bone contours and organ boundaries have strong gradient signals; HOG features feed classical classifiers in low-data settings where a neural network would overfit.
• Texture description: the SIFT keypoint descriptor — the backbone of feature matching in panorama stitching and augmented reality — is essentially a HOG computed around salient points.

Even now that deep networks dominate, HOG remains the canonical example of hand-crafted feature engineering: a case where carefully chosen math outperformed raw pixels for a decade and still illuminates why the first layers of a CNN look the way they do.

The HOG descriptor is a beautiful example of insight over brute force: instead of memorizing pixel intensities, it counts how many edges point in each direction, cell by cell, and assembles those counts into a shape fingerprint.

That fingerprint was good enough to solve pedestrian detection in 2005, to inspire SIFT and its descendants, and to reveal — once neural networks arrived — that the first thing a deep model learns is a bank of gradient detectors strikingly similar to HOG cells.

The algorithm is solved, the math is clean, and the lesson endures: understand what varies (pixels, lighting, color) and what stays stable (edge orientations), measure only the stable part, and a simple classifier will do the rest.