Bilateral Filter Edge Smoothing

A bilateral filter blends only neighbours that are close and look similar. Flat zones smooth out while true edges refuse to mix.

The bilateral filter multiplies a closeness weight by a similarity weight, so a bright pixel across an edge contributes almost nothing to a dark center

Why Does This Exist?

The Gaussian filter blurs across edges because it weighs neighbours by distance alone: a dark pixel happily blends with a bright neighbour just because it is nearby. But most photos are flat regions divided by sharp boundaries, and mixing across a boundary destroys exactly the structure later steps need.

The bilateral filter adds a second opinion, similarity, so a neighbour votes only when it is near and alike. It is the edge-aware member of the smoothing family: use it for denoising photos you will display, where median filter output looks patchy and Gaussian output looks melted.

The one idea you need first. A Gaussian blur is a weighted mean with weights falling off by distance. The bilateral filter keeps that idea and multiplies in a second fall-off by brightness difference. If weighted means are unfamiliar, the Gaussian page works one through first.

Think of It Like This

A club with two bouncers

Entry needs two stamps: you must live nearby (spatial closeness) and dress like the regulars (similar brightness). A neighbour in the wrong outfit is turned away, which is how an edge pixel gets excluded from the blend. A Gaussian club employs only the first bouncer, so anyone nearby walks in and the party, your edge, gets diluted.

The analogy stops at arithmetic: the bouncers multiply smooth Gaussian weights rather than stamping yes or no, so a slightly different neighbour gets a slightly smaller vote instead of rejection.

How It Actually Works

Each neighbour's vote multiplies two Gaussian weights. The spatial weight falls with distance and is set by $\sigma_s$ , which controls how far the filter looks. The range weight falls with brightness difference and is set by $\sigma_r$ , which controls how different a pixel may be and still count. With $I(p)$ the center value and $I(q)$ a neighbour value:

w(q) = e^{-\frac{\|p-q\|^2}{2\sigma_s^2}} \cdot e^{-\frac{(I(p)-I(q))^2}{2\sigma_r^2}}

The output is the weighted mean of the neighbourhood using $w(q)$ , divided by the sum of the weights so the brightness stays calibrated. Across a strong edge the range term collapses toward zero, the far side contributes nothing, and the edge survives. In flat regions all neighbours look similar, the range term sits near one, and the filter behaves like an ordinary Gaussian.

Worked example

Take a center pixel of value $50$ with neighbour A at $52$ and neighbour B at $200$ , and set $\sigma_r = 30$ . The range weight of A is $e^{-2^2 / (2 \cdot 900)} = e^{-0.0022} \approx 0.998$ , nearly a full vote. The range weight of B is $e^{-150^2 / 1800} = e^{-12.5} \approx 0.000004$ , effectively zero. Same distances, wildly different votes, and the edge between $50$ and $200$ never mixes.

Code

The point of this snippet is the gate in action: run the weights on a tiny 1-D signal crossing an edge and watch the far side drop out of the average.

1import numpy as np2
3signal: np.ndarray = np.array([50.0, 52.0, 51.0, 200.0, 198.0])4center: int = 25sigma_s: float = 1.06sigma_r: float = 30.07
8pos: np.ndarray = np.arange(signal.size) - center9spatial: np.ndarray = np.exp(-(pos**2) / (2 * sigma_s**2))10range_w: np.ndarray = np.exp(-((signal - signal[center]) ** 2) / (2 * sigma_r**2))11weights: np.ndarray = spatial * range_w12print(weights)  # -> [1.35e-01 6.06e-01 1.00e+00 2.67e-06 8.27e-07]13print(float(weights @ signal / weights.sum()))  # -> 51.27072321480588

The last two weights print near zero: the $200$ -valued pixels across the edge are excluded, and the output $51.27$ averages only the similar side.

Watch Out For

Range sigma too wide degrades to Gaussian

Crank $\sigma_r$ far above the image contrast and every neighbour counts as similar, so the filter blurs across edges exactly like the Gaussian you meant to beat. The symptom is melted boundaries despite paying bilateral cost. Set $\sigma_r$ near the noise level: small enough to reject true edges, large enough to accept grain.

The Quick Version

The bilateral filter weights each neighbour by distance times brightness similarity, then takes a weighted mean.
Flat regions smooth normally while strong edges block blending across them.
Sigma-s sets how far the filter reaches and sigma-r sets how different a voter may be.
Setting sigma-r near the noise level keeps edges while killing grain.
It costs far more than a Gaussian because the weights change at every pixel.