Gaussian Blur

Problem

Real images are noisy. Tiny local fluctuations can create:

• broken thresholds
• unstable edge maps
• flickering masks

You need a way to reduce local noise without destroying the large-scale structure of the image.

Intuition

Gaussian blur replaces each pixel with a weighted average of nearby pixels.

But not all neighbors count equally:

• close pixels matter more
• far pixels matter less

That weighting is what makes Gaussian blur better behaved than a crude box average.

The core operator

For each pixel, apply a small kernel such as:

1 2 1
2 4 2
1 2 1

Then divide by the sum of the weights:

16

The center pixel gets the most influence, direct neighbors get less, and diagonal neighbors get even less.

That weighting approximates the Gaussian distribution.

Worked example

Suppose a 1D signal is:

0 0 1 0 0

If you apply a small Gaussian-like kernel, the impulse spreads:

0.0 0.25 0.5 0.25 0.0

The result is softer and less sensitive to isolated spikes.

In 2D, the same thing happens around bright dots, edges, and noise patches.

Why it matters in pipelines

Gaussian blur is often an early-stage cleanup step:

• before thresholding, so a mask becomes less speckled
• before Sobel, so gradients are driven by real boundaries instead of random noise
• before downsampling, so high-frequency detail does not alias badly

That is why blur is usually not an end in itself. It often exists to stabilize the next operator.

Complexity

For an image with $W \times H$ pixels and a kernel radius $r$:

• naive 2D blur costs $O(WHr^2)$
• Gaussian blur is often implemented as two 1D passes, reducing it to $O(WHr)$

That separable implementation is one reason Gaussian blur is so common in real graphics systems.

GPU implementation note

This is a very natural WebGPU workload:

• each output pixel reads a small neighborhood
• the same kernel logic runs independently for every pixel
• separable blur lets you run one horizontal pass and one vertical pass

So Gaussian blur is both conceptually foundational and practically important.

When to choose it

Choose Gaussian blur when:

• the image should stay continuous
• the goal is denoising or softening
• later steps depend on stable local values

Choose something else when:

• you need a binary mask instead of a smooth image
• you need explicit edges rather than smoothing
• you already have a mask and need structural repair instead of tone smoothing

Key takeaways

• Gaussian blur is a weighted local average
• Nearby pixels matter more than distant ones
• It reduces noise while preserving large-scale structure better than a flat average
• It is commonly used before thresholding or edge detection
• A separable implementation makes it especially GPU-friendly

Practice ideas

• Compare a box blur and Gaussian blur on the same noisy grayscale pattern
• Blur an image before thresholding, then threshold the original and blurred versions to see the stability difference
• Implement the same blur as one 2D pass and as two 1D passes, then compare cost and output

Relation to other topics

• Image processing fundamentals gives the neighborhood-based mental model Gaussian blur relies on
• Thresholding often follows blur when you want a cleaner mask
• Sobel edge detection often benefits from a mild blur first
• Opening and closing solve mask cleanup later in the pipeline, not continuous-image smoothing