Gaussian Filter Explained: From Convolution Basics to Kernels, Sigma and the Frequency Domain

Key facts

• Definition: a Gaussian filter replaces each pixel with a weighted average of its neighbours, using weights G(x, y) = exp(−(x² + y²)/(2σ²))/(2πσ²).
• σ (standard deviation, in pixels) controls the amount of blur; the kernel radius is usually 3σ to 4σ and the weights are normalized to sum to 1.
• Separable: a 2-D Gaussian blur = 1-D blur of rows, then of columns.
• Frequency response is also Gaussian, H(f) = exp(−2π²σ²f²): a smooth low-pass filter with no ripples or contrast reversals.
• Cascade: blurring with σ₁ then σ₂ equals one blur with √(σ₁² + σ₂²); a Gaussian blur is the heat equation run for time t = σ²/2.
• Noise: white-noise standard deviation falls by about 1/(2√π σ) = 0.282/σ, at the cost of detail finer than about 7.5σ pixels.

A digital image is a grid of numbers. In a greyscale image each number is a brightness, usually from 0 (black) to 255 (white); a colour image has three such grids (red, green, blue); a satellite image may have a dozen bands of reflectance. Filtering means computing a new image in which every output pixel depends on a small neighbourhood of input pixels.

The simplest useful filter is an average: replace each pixel by the mean of itself and its eight neighbours. Random noise goes up in one pixel and down in the next, so averaging cancels much of it; the underlying scene changes slowly, so averaging mostly keeps it. The Gaussian filter refines this idea with one question: should a neighbour two pixels away count as much as the pixel itself? Physically, no. Nearby pixels are more likely to belong to the same object, so their weight should be larger.

Sliding a set of weights over a signal and computing a weighted sum at each position is called convolution (strictly, correlation; for a symmetric kernel such as the Gaussian the two are identical). In 1-D, with a kernel w of radius r:

Three things decide what a convolution does: the shape of the weights (flat for a box, bell for a Gaussian), their width (σ), and what happens at the ends of the signal, where the window runs out of data (reflect, replicate, wrap or zero padding). Watch it happen below.

Notice three things in the demo. The output (blue) is much smoother than the input (grey dots). The sharp steps become ramps about 2–3σ wide. And the narrow bump near the right end is lowered and widened: a feature narrower than the kernel loses contrast. These are the benefit and the price of every smoothing filter.

The weights come from the Gaussian, the same bell curve as the normal distribution in statistics:

• σ is a distance in pixels. 68.3% of the weight lies within ±σ, 95.4% within ±2σ and 99.7% within ±3σ.
• Full width at half maximum (FWHM), the width where the curve is half its peak: 2√(2 ln 2) σ ≈ 2.355σ. Optics and remote sensing often quote the blur of a sensor this way.
• Peak height 1/(√(2π)σ): doubling σ halves the peak and doubles the width; the area stays 1.

For σ ≥ 1 the sampled weights (bars) sit almost exactly on the continuous curve. Move σ below about 0.8 and they no longer do: nearly all the weight falls on the centre pixel and the bars no longer describe a bell. A Gaussian narrower than a pixel cannot be represented by sampling it at pixel centres.

If you want to explore the bell curve itself, with areas and percentiles, try the normal distribution graph generator.

Four steps turn the formula into a kernel. Here they are for σ = 1 and radius r = 2 (a 5-tap kernel).

1. Choose the radius. Use r ≈ 3σ (here we use 2 to keep the arithmetic short; the 3σ rule would give 3).
2. Evaluate e^{−i²/(2σ²)} at i = −2 … 2. With σ = 1: e⁻² = 0.135335, e^−0.5 = 0.606531, e⁰ = 1. The constant 1/(√(2π)σ) can be skipped because the next step removes it.
3. Normalize. The sum is 1 + 2(0.606531) + 2(0.135335) = 2.483732. Divide: w = [0.054489, 0.244201, 0.402620, 0.244201, 0.054489], Σw = 1
4. Make it 2-D by the outer product w_ij = w_iw_j. The centre weight is 0.402620² = 0.162103; the corners are 0.054489² = 0.002969.

The "exact variance" column is Σ i² w_i, the true σ² of the discrete kernel. The binomial kernels are rows of Pascal's triangle divided by their sum. By the central limit theorem they converge to a Gaussian, which is why they are often used as cheap, integer-only Gaussians.

Images are 2-D, so we need the 2-D Gaussian. Because e^a+b = e^ae^b, it factors into a product of two 1-D Gaussians:

This factorization means a 2-D blur can be done in two 1-D passes: first blur every row, then blur every column of the result. For a kernel of size n, a direct 2-D convolution needs n² multiplications per pixel; the separable version needs 2n.

A remarkable fact: the Gaussian is essentially the only function that is both separable and rotationally symmetric. That combination is why it appears everywhere, from image blur to the Maxwell–Boltzmann velocity distribution of gas molecules.

Any image can be written as a sum of sinusoidal patterns of different spatial frequencies f (cycles per pixel). Coarse shapes are low frequencies; fine texture, sharp edges and pixel noise are high frequencies. The convolution theorem says that convolving in space multiplies in frequency, so a filter is fully described by its frequency response H(f): the factor by which it multiplies each frequency.

A sinusoid with a period of p pixels (f = 1/p) is therefore multiplied by e^{−2π²σ²/p²}. With σ = 2, a pattern with a 10-pixel period keeps 45% of its contrast; a 4-pixel pattern keeps 0.7%. The −3 dB cutoff (gain 0.707) is at f_c = √(ln 2)/(2πσ) ≈ 0.1325/σ, a period of about 7.55σ pixels.

The box (mean) filter's response is a sinc-like curve with negative lobes: some fine patterns are passed with inverted contrast, so dark stripes become light. The Gaussian's response is never negative, and it falls smoothly and monotonically. That is why a Gaussian blur looks "natural", like an out-of-focus lens, while a box blur shows faint artefacts on fine textures.

Suppose each pixel carries independent noise with standard deviation σₙ (white noise). The filtered value is a weighted sum, and the variance of a weighted sum of independent variables is the sum of the squared weights times the variance:

The noise falls only as 1/σ, but the finest surviving detail grows as σ. There is always an optimum σ that balances the two, and it depends on the image: an image with large, smooth regions tolerates a large σ, while one full of sharp edges and text does not. The σ search in the calculator finds this optimum by maximizing the PSNR. On its synthetic satellite scene with noise σₙ = 35, the best σ is only about 0.9 pixels, with a gain of about 6.7 dB.

import numpy as np
from scipy import ndimage

def gaussian_kernel_1d(sigma, truncate=3.0):
    r = int(truncate * sigma + 0.5)
    x = np.arange(-r, r + 1)
    w = np.exp(-x**2 / (2 * sigma**2))
    return w / w.sum()

def gaussian_blur(img, sigma):
    """Separable Gaussian blur with reflect padding."""
    w = gaussian_kernel_1d(sigma)
    r = len(w) // 2
    out = img.astype(float)
    for axis in (0, 1):                                  # columns, then rows
        pad = [(r, r) if a == axis else (0, 0) for a in range(out.ndim)]
        p = np.pad(out, pad, mode='symmetric')           # = SciPy 'reflect'
        out = sum(w[k] * np.take(p, np.arange(k, k + out.shape[axis]), axis=axis)
                  for k in range(len(w)))
    return out

img = np.random.default_rng(0).normal(128, 20, (64, 64))
mine = gaussian_blur(img, 2.0)
ref  = ndimage.gaussian_filter(img, 2.0, truncate=3.0)  # same kernel, mode='reflect'
print(np.abs(mine - ref).max())                          # ~6e-14

For real work use the library function: ndimage.gaussian_filter (SciPy), cv2.GaussianBlur (OpenCV) or skimage.filters.gaussian. For a colour or multiband image, pass σ = 0 on the band axis so the bands are not mixed, for example sigma=(2, 2, 0).

• Confusing σ with the kernel size. "A 5 × 5 Gaussian" says nothing about σ. Specify σ; derive the size.
• Forgetting to normalize after sampling and truncating, which brightens or darkens the image.
• Using pixels when you mean metres. In geospatial data σ_pixels = σ_metres / pixel size. The same σ = 2 px means 20 m on Sentinel-2 and 60 m on Landsat.
• Blurring across bands or time. A 3-D call such as gaussian_filter(cube, 2) also smooths along the spectral or temporal axis.
• Ignoring borders and no-data. Zero padding darkens edges; NaN or fill values (e.g. −9999) spread into valid pixels. Use normalized convolution: blur the data with no-data set to 0, blur a validity mask, and divide.
• Adding blurs linearly. σ = 2 then σ = 2 is σ = 2.83, not 4.
• Expecting it to remove salt-and-pepper or speckle noise. Use a median or a speckle filter.