Image Filtering with Hough Transforms · Projects

This pipeline builds classical edge and feature detection out of convolutions. Given an image, it smooths, estimates gradients, and votes for the geometric structures those gradients imply, lines and corners, all in Python over OpenCV.

Differentiation amplifies high-frequency noise, so Gaussian smoothing convolves the image with a Gaussian kernel first; without it, single-pixel intensity jumps register as spurious edges and swamp the real ones. The Sobel operator then estimates the intensity gradient with a pair of $3 \times 3$ kernels, one per axis, giving $\nabla I = (I_{x}, I_{y})$ at every pixel. Its magnitude $∥ \nabla I ∥$ measures edge strength and $arctan (I_{y} / I_{x})$ gives the edge orientation. Thresholding the magnitude leaves thick edge bands, so non-maximum suppression thins them: a pixel survives only when its magnitude exceeds both neighbors along the gradient direction, collapsing each band to a one-pixel ridge.

Every filter here is one primitive: the kernel slides over the image, and at each stop the output pixel is the kernel-weighted sum of the window it covers. A Gaussian kernel makes this smoothing; the Sobel pair makes it the image gradient.

The Hough line transform detects lines even when their pixels are broken or partly occluded. A line is written in normal form,

ρ = x cos θ + y sin θ,

with $ρ$ the perpendicular distance from the origin and $θ$ the angle of that perpendicular. This parametrization is bounded and avoids the infinite slope that $y = m x + c$ hits on vertical lines. A fixed edge point $(x, y)$ swept over $θ$ traces a sinusoid in $(ρ, θ)$ space; collinear edge points share one line, so their sinusoids all pass through the single $(ρ, θ)$ that names it.

Left: three collinear edge points in image space and the line through them. Right: each point maps to a sinusoid in

(ρ, θ)

space, and the three sinusoids meet at the single

(ρ, θ)

that names the shared line — the accumulator peak (dot).

Detection becomes counting: quantize $(ρ, θ)$ into a grid (the accumulator $A$ ), and for each edge point add one vote to every cell on its sinusoid. Cells where many sinusoids cross collect high counts, and each such peak is a detected line. Real edges are noisy, so the votes smear across neighboring cells; peaks are recovered by thresholding and then a second non-maximum suppression over $A$ , so one line yields one detection instead of a cluster.

Algorithm:

\textsc{Hough-Lines}(E)

— vote for lines in

(\rho, \theta)

space

1
input: a set $E$ of edge points, an accumulator $A$ over quantized $(\rho, \theta)$
2
for each point $(x, y)$ in $E$ do
3
for each $\theta$ in the quantized range do
4
$\rho \gets x \cos\theta + y \sin\theta$
5
$A[\rho, \theta] \gets A[\rho, \theta] + 1$
6
return the $(\rho, \theta)$ cells whose vote count exceeds a threshold

Harris corner detection finds points where intensity changes sharply in every direction. Over a window it forms the second-moment matrix of gradients

M = window \sum [I_{x}^{2} I_{x} I_{y} I_{x} I_{y} I_{y}^{2}],

and scores each pixel by $R = det M - k (tr M)^{2}$ . Two large eigenvalues — variation along both axes — make $R$ large and mark a corner; a single large eigenvalue signals an edge, and neither signals flat texture.

You can read the full report.

References

Project repository
Reference notes: Vision and Perception

╌╌ END ╌╌