Introduction

Photography, medical scans, satellite imagery — almost every image you process has noise: random grains that obscure the real signal. The obvious fix is blurring: average nearby pixels together and the random spikes cancel out.

The problem is that blurring does not distinguish noise from structure. A standard Gaussian blur weights neighbors purely by distance: the closer a pixel, the more it contributes. That kills noise, but it also bleeds bright pixels across dark edges, turning every sharp boundary into a soft gradient.

The bilateral filter, introduced by Carlo Tomasi and Roberto Manduchi in 1998, adds a second weight. Each neighbor's contribution is scaled not only by how close it is (the spatial Gaussian) but also by how similar its color is (the range Gaussian). Pixels on the other side of an edge are very different in intensity, so they get a tiny weight and barely influence the output. Noise, which is random and small, averages away. Edges, which represent large, consistent differences, survive intact.

The result is a filter that knows the difference between a noisy smooth region and a genuine boundary — and treats each accordingly.

Try It

The canvas below shows a synthetic image with a sharp edge and additive noise. Adjust the spatial radius (how far the filter reaches) and the color threshold (how different a neighbor must be before it is ignored). Then press Apply filter to see the result.

<!-- Demo layout — two canvases (noisy input | filtered output) + sliders -->
<div class="controls">
  <label>Spatial radius: <span id="radius-val">5</span>
    <input type="range" id="radius" min="1" max="12" value="5">
  </label>
  <label>Color threshold (σ): <span id="color-val">30</span>
    <input type="range" id="color-thresh" min="5" max="100" value="30">
  </label>
</div>
<div class="canvas-row">
  <figure>
    <figcaption>Noisy input</figcaption>
    <canvas id="c-noisy" width="200" height="200"></canvas>
  </figure>
  <figure>
    <figcaption>Result</figcaption>
    <canvas id="c-result" width="200" height="200"></canvas>
  </figure>
</div>
<div class="btns">
  <button id="btn-bilateral" type="button">Apply bilateral filter</button>
  <button id="btn-gaussian" type="button" class="ghost">Apply Gaussian blur</button>
  <button id="btn-reset" type="button" class="ghost">New noise</button>
</div>
<div id="status" class="status"></div>

/* Responsive two-canvas layout with controls */
* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; }
.controls { display: flex; flex-direction: column; gap: .5rem; margin-bottom: .7rem; }
label { font-size: .88rem; color: #333; display: flex; align-items: center; gap: .5rem; flex-wrap: wrap; }
label span { font-weight: 700; min-width: 2ch; }
input[type=range] { flex: 1; min-width: 120px; accent-color: #1d3557; }
.canvas-row { display: flex; gap: 12px; flex-wrap: wrap; margin: .5rem 0; }
figure { margin: 0; display: flex; flex-direction: column; align-items: center; gap: 4px; }
figcaption { font-size: .8rem; color: #555; font-weight: 600; }
canvas { border: 1px solid #cdd9e3; border-radius: 6px; display: block;
         image-rendering: pixelated; width: 200px; height: 200px; }
.btns { display: flex; gap: .5rem; flex-wrap: wrap; margin-top: .4rem; }
button { font: 600 13px system-ui, sans-serif; padding: .4rem .85rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
.status { font-size: .9rem; font-weight: 600; margin-top: .5rem; min-height: 1.3em; color: #1d3557; }

const i18nFmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// Bilateral filter demo — shows edge-preserving vs plain Gaussian smoothing
const W = 100, H = 100;
let noisyData = null;

// Generate a synthetic noisy image with a hard vertical edge
function generateNoisyImage() {
  const data = new Uint8Array(W * H);
  for (let y = 0; y < H; y++) {
    for (let x = 0; x < W; x++) {
      // Piecewise-constant base intensity — left half dark, right half bright
      const base = x < W / 2 ? 60 : 180;
      // Add random noise — uniform noise in range [-30, 30]
      const noise = Math.round((Math.random() - 0.5) * 60);
      data[y * W + x] = Math.max(0, Math.min(255, base + noise));
    }
  }
  return data;
}

// Render a grayscale pixel array to a canvas element
function drawToCanvas(canvasId, data) {
  const canvas = document.getElementById(canvasId);
  const ctx = canvas.getContext('2d');
  const img = ctx.createImageData(W, H);
  for (let i = 0; i < W * H; i++) {
    const v = data[i];
    img.data[i * 4] = v;
    img.data[i * 4 + 1] = v;
    img.data[i * 4 + 2] = v;
    img.data[i * 4 + 3] = 255;
  }
  ctx.putImageData(img, 0, 0);
}

// Bilateral filter — weighted by spatial AND intensity distance
// Output pixel p = sum_q [ G_s(|p-q|) * G_r(|I_p - I_q|) * I_q ]
//                  / sum_q [ G_s(|p-q|) * G_r(|I_p - I_q|) ]
function bilateralFilter(src, radius, colorSigma) {
  const out = new Uint8Array(W * H);
  const sigmaS = radius / 2;
  const sigmaR = colorSigma;
  for (let y = 0; y < H; y++) {
    for (let x = 0; x < W; x++) {
      const center = src[y * W + x];
      let sumW = 0, sumI = 0;
      for (let dy = -radius; dy <= radius; dy++) {
        for (let dx = -radius; dx <= radius; dx++) {
          const ny = y + dy, nx = x + dx;
          if (ny < 0 || ny >= H || nx < 0 || nx >= W) continue;
          const neighbor = src[ny * W + nx];
          // Spatial Gaussian weight — Gaussian on Euclidean distance
          const spatialDist2 = dx * dx + dy * dy;
          const wS = Math.exp(-spatialDist2 / (2 * sigmaS * sigmaS));
          // Range (intensity) Gaussian weight — Gaussian on intensity difference
          const diff = center - neighbor;
          const wR = Math.exp(-(diff * diff) / (2 * sigmaR * sigmaR));
          const w = wS * wR;
          sumW += w;
          sumI += w * neighbor;
        }
      }
      out[y * W + x] = Math.round(sumI / sumW);
    }
  }
  return out;
}

// Plain Gaussian blur for comparison — ignores intensity difference
function gaussianFilter(src, radius) {
  const out = new Uint8Array(W * H);
  const sigma = radius / 2;
  for (let y = 0; y < H; y++) {
    for (let x = 0; x < W; x++) {
      let sumW = 0, sumI = 0;
      for (let dy = -radius; dy <= radius; dy++) {
        for (let dx = -radius; dx <= radius; dx++) {
          const ny = y + dy, nx = x + dx;
          if (ny < 0 || ny >= H || nx < 0 || nx >= W) continue;
          const spatialDist2 = dx * dx + dy * dy;
          const w = Math.exp(-spatialDist2 / (2 * sigma * sigma));
          sumW += w;
          sumI += w * src[ny * W + nx];
        }
      }
      out[y * W + x] = Math.round(sumI / sumW);
    }
  }
  return out;
}

function getParams() {
  const radius = parseInt(document.getElementById('radius').value, 10);
  const colorThresh = parseInt(document.getElementById('color-thresh').value, 10);
  return { radius, colorThresh };
}

function setStatus(msg) {
  document.getElementById('status').textContent = msg;
}

function applyBilateral() {
  const { radius, colorThresh } = getParams();
  setStatus('Computing…');
  setTimeout(() => {
    const result = bilateralFilter(noisyData, radius, colorThresh);
    drawToCanvas('c-result', result);
    setStatus(i18nFmt('Bilateral filter applied — radius %r%, color σ=%c%.', { r: radius, c: colorThresh }));
  }, 10);
}

function applyGaussian() {
  const { radius } = getParams();
  setStatus('Computing…');
  setTimeout(() => {
    const result = gaussianFilter(noisyData, radius);
    drawToCanvas('c-result', result);
    setStatus(i18nFmt('Gaussian blur applied — radius %r%.', { r: radius }));
  }, 10);
}

function reset() {
  noisyData = generateNoisyImage();
  drawToCanvas('c-noisy', noisyData);
  drawToCanvas('c-result', noisyData);
  setStatus('Click a button to filter the image.');
}

// Live slider value display
document.getElementById('radius').addEventListener('input', function () {
  document.getElementById('radius-val').textContent = this.value;
});
document.getElementById('color-thresh').addEventListener('input', function () {
  document.getElementById('color-val').textContent = this.value;
});

document.getElementById('btn-bilateral').addEventListener('click', applyBilateral);
document.getElementById('btn-gaussian').addEventListener('click', applyGaussian);
document.getElementById('btn-reset').addEventListener('click', reset);

reset();
Result
Console

Notice the key trade-off: a large color threshold lets dissimilar pixels contribute, blurring edges but also removing more noise. A small threshold respects edges but may leave some noise behind. The spatial radius controls the smoothing neighborhood — bigger radius averages more pixels. Together these two parameters give you precise control that a plain Gaussian blur never offers.

The Real Complexity

How expensive is the bilateral filter?

  • Naive cost. For each of the nn pixels in an image, the filter visits every pixel in a (2r+1)×(2r+1)(2r+1) \times (2r+1) window, computing two Gaussian weights and accumulating a weighted sum. That is O(n⋅r2)O(n \cdot r^{2}) operations — quadratic in the radius.
  • Why radius matters. Double rr and the work per pixel quadruples. On a 12-megapixel photo with radius 15, that is roughly 2.7 billion multiplications. A plain Gaussian can be separated into two 1-D passes and runs in O(n)O(n) regardless of radius — bilateral filtering cannot, because the range weight depends on the actual pixel values encountered in the window.
  • Approximations rescue it. The permutohedral lattice (Adams et al., 2010) and bilateral grid (Chen et al., 2007) reformulate the filter as a splat-blur-slice operation and achieve O(n)O(n) complexity with a small accuracy trade-off. Real-time bilateral filtering in GPUs exploits massive parallelism: all nn pixels are processed simultaneously, hiding the O(r2)O(r^{2}) per-pixel cost behind hardware concurrency.
  • Not in the P vs NP sense. Unlike constraint problems such as SAT, bilateral filtering is always polynomial — the challenge is the constant factor, not the complexity class. It belongs to the world of numerical algorithms where the battle is over speed in practice, not tractability in theory.

Modern photo apps run bilateral filtering (or its close cousin, the guided filter) in real time on phone hardware — a reminder that polynomial-time algorithms can still need clever engineering to be fast enough.

Where It Matters

The bilateral filter's ability to smooth without destroying edges turns up across image processing:

  • Computational photography. Smartphone cameras run bilateral filtering (or learned variants) to reduce sensor noise in low-light shots without smearing the edges of faces and objects.
  • HDR tone mapping. Compressing a high-dynamic-range image into display range requires splitting it into a large-scale luminance layer and a detail layer. The bilateral filter separates the two because it averages large smooth regions while leaving fine edges in the detail layer.
  • Depth-map refinement. Depth sensors (e.g. LiDAR, time-of-flight cameras) produce noisy depth maps with sharp object boundaries. A bilateral filter — guided by the color image — smooths the depth noise while snapping depth edges to the color edges.
  • Medical imaging. MRI and CT slices are filtered bilaterally to reduce acquisition noise before segmentation, where preserving tissue boundaries is critical.
  • Stylization and abstraction. Artists apply the bilateral filter repeatedly to flatten smooth regions into solid-color patches while keeping pencil-sharp outlines — the look of a painting or graphic novel.

The core idea — weight by similarity, not just proximity — also inspired dimensionality reduction methods like locally linear embedding and the non-local means filter, which extend the principle from pixels to high-dimensional feature spaces.

Conclusion

The bilateral filter is a small idea with large consequences. By multiplying a spatial Gaussian by a range Gaussian, it teaches the kernel to ignore neighbors that differ too much in color — and that single change is enough to separate noise from edges.

The price is a higher computational cost than plain blurring, but approximations and modern GPU parallelism have made it real-time. Today it runs invisibly inside the camera app on your phone every time you shoot in dim light.

It is a reminder that the right mathematical lens can turn a brute-force average into a structure-aware operation — and that the difference between "blur everything" and "blur only what belongs together" is, ultimately, the difference between destroying information and preserving it.

Share this article

Pick a channel — or use your device's native share sheet.

Comments

Loading comments...

https://www.kipuhub.com/en/article/bilateral-filter/Content licensed under CC BY-NC 4.0.