Gaussian Filter Calculator: Kernel Generator and Online Image Blur Tool

Key facts

• 2-D Gaussian kernel: G(x, y) = exp(−(x² + y²)/(2σ²)) / (2πσ²); the discrete kernel samples it at integer offsets and divides by the sum so the weights add up to 1.
• Kernel size: 2r + 1 with radius r ≈ 3σ to 4σ. SciPy's default is r = round(4σ); MATLAB's imgaussfilt uses 2⌈2σ⌉ + 1.
• Separable: a 2-D Gaussian blur equals a row blur followed by a column blur, so it costs 2n instead of n² operations per pixel.
• Width: FWHM = 2√(2 ln 2) σ ≈ 2.355σ; repeated blurs add in quadrature: σ = √(σ₁² + σ₂²).
• Frequency response: H(f) = exp(−2π²σ²f²), a Gaussian with no ripples; −3 dB at f ≈ 0.1325/σ cycles per pixel.
• Noise: white-noise standard deviation falls by about 0.282/σ (for σ ≥ 1 pixel).

1. Set σ. Type a value or drag the slider. σ is in pixels. If your scale is in metres (for example a 10 m satellite image and a 40 m smoothing scale), divide by the pixel size: σ = 40 / 10 = 4 pixels.
2. Pick a size rule. The 3σ rule is a good default. Choose the SciPy or MATLAB rule to reproduce those libraries exactly, or a fixed size to see what truncation does.
3. Read the kernel. The Kernel tab shows the 1-D weights, the 2-D matrix, an integer version and ready-to-paste NumPy code.
4. Filter an image. Choose a test image or upload your own (it is resized to at most 512 pixels and processed locally). Add noise to see denoising, swipe to compare, and move the row slider to see the intensity profile.
5. Optimize. The σ search finds the sigma with the highest PSNR for the current image and noise level.
6. Understand it. The frequency tab shows which detail sizes survive; the step-by-step tab reproduces every number.

Choose σ from the physical size of what you want to keep or remove; the kernel size then follows from σ. The table gives starting values; use the σ search tab to tune them on your own data.

Percentages are the share of the continuous Gaussian inside ±r (erf(r/(σ√2)) in 1-D, its square for the square 2-D window). After normalization the truncated kernel still sums to exactly 1; what is lost is a little of the bell's tail, which slightly lowers the effective σ.

Near the border the kernel extends past the image, so the missing pixels must be invented. The choice only affects a band about r pixels wide, but it matters for small images, tiles of a large raster, and quantitative work.

Example 1: The 5-tap kernel for σ = 1

With r = 2, the unnormalized weights are e^−i²/2: e⁰ = 1, e^−0.5 = 0.606531 and e⁻² = 0.135335. Their sum is 1 + 2(0.606531) + 2(0.135335) = 2.483732. Dividing gives

Example 2: Smoothing a spike

Filter the 1-D signal [10, 10, 10, 80, 10, 10, 10] with the kernel above. The output at the spike is 10 + 70 × 0.402620 = 38.18, and its neighbours become 10 + 70 × 0.244201 = 27.09 and 10 + 70 × 0.054489 = 13.81. The total excess (70) is conserved, but it is spread over five samples: [10, 13.81, 27.09, 38.18, 27.09, 13.81, 10]. This is why blurring reduces impulse noise but cannot remove it completely; a median filter would.

Example 3: A 3 × 3 kernel on an edge

The 3 × 3 binomial kernel [1 2 1; 2 4 2; 1 2 1]/16 (a Gaussian with σ ≈ 0.71) applied to columns of values 20, 20, 20, 80, 80 gives 20, 20, 35, 65, 80 across the row: the sharp step from 20 to 80 becomes a ramp three pixels wide. Wider σ gives a wider ramp, which is the visible "softening" of edges.

Example 4: How much noise does σ = 2 remove?

For σ = 2 with r = 8, Σw_i² = 0.14105, almost equal to the approximation 1/(2√π × 2) = 0.14105. White noise with a standard deviation of 20 grey levels is therefore reduced to 20 × 0.141 = 2.8 grey levels, a factor of 7.1 or 17 dB. Detail with a period shorter than 7.55σ ≈ 15 pixels is attenuated by more than 3 dB, so the gain in PSNR is always smaller than 17 dB on a real image.

Example 5: Matching two satellite sensors

Suppose a 10 m image has a point spread function (PSF) with σ = 0.5 pixels and you want it to look like a coarser sensor whose PSF, expressed on the same 10 m grid, has σ = 1.5 pixels. Assuming both are Gaussian, the extra blur is σ = √(1.5² − 0.5²) = 1.41 pixels. Apply it, then resample to the coarser grid. Real sensor PSFs are only approximately Gaussian, so use the published modulation transfer function when accuracy matters.

All three lines below blur an image with σ = 2. They differ in kernel size and boundary handling, which is why their outputs differ slightly near the edges.

# SciPy: radius = round(truncate * sigma), default truncate=4.0, mode='reflect'
from scipy import ndimage
smooth = ndimage.gaussian_filter(img.astype(float), sigma=2, mode='reflect', truncate=4.0)
# colour image: do not blur across channels
smooth_rgb = ndimage.gaussian_filter(rgb.astype(float), sigma=(2, 2, 0))

# OpenCV: ksize=(0, 0) lets OpenCV choose the size from sigma; default border = REFLECT_101
import cv2
smooth = cv2.GaussianBlur(img, ksize=(0, 0), sigmaX=2, borderType=cv2.BORDER_REFLECT_101)

# scikit-image
from skimage.filters import gaussian
smooth = gaussian(img, sigma=2, preserve_range=True)

% MATLAB: default FilterSize = 2*ceil(2*sigma)+1, default Padding = 'replicate'
J = imgaussfilt(I, 2);
J = imgaussfilt(I, 2, 'FilterSize', 2*ceil(3*2)+1, 'Padding', 'symmetric');

To build the kernel yourself:

import numpy as np
def gaussian_kernel(sigma, truncate=3.0):
    r = int(truncate * sigma + 0.5)
    x = np.arange(-r, r + 1)
    w = np.exp(-x**2 / (2 * sigma**2))
    w /= w.sum()                 # normalize: weights sum to 1
    return w, np.outer(w, w)     # 1-D and 2-D kernels

• It blurs edges as much as noise. A Gaussian filter is linear and the same everywhere. If edges must stay sharp, use a bilateral filter, anisotropic diffusion, non-local means or a median filter.
• Wrong noise model. The Gaussian is a good choice for additive, roughly Gaussian noise. Salt-and-pepper noise needs a median filter; the multiplicative speckle of radar (SAR) images needs speckle filters such as Lee, Frost or Gamma-MAP.
• Very small σ. Below about 0.8 pixels a sampled Gaussian is a poor approximation (most of the weight is on the centre pixel and its effective σ differs from the nominal one). Lindeberg's discrete Gaussian kernel, based on modified Bessel functions, is the exact discrete alternative.
• Large σ. Direct convolution costs O(σ) per pixel per pass. For very large σ use FFT convolution or recursive (IIR) approximations such as Young–van Vliet or Deriche.
• Colour and gamma. Most images are stored in gamma-encoded sRGB. A physically correct blur (one that mimics optical defocus) should be done in linear light; blurring sRGB values directly, as most software does, makes bright-dark boundaries look slightly darker.
• In this tool uploaded images are resized to a maximum of 512 pixels on the long side and processed as 8-bit sRGB in your browser; σ is limited to 20 pixels on the slider and 40 in the box.