Frequency-Domain Filtering: Low-Pass, High-Pass & Notch

"I deleted every frequency above the cutoff, exactly as designed. The image rang like a struck bell. Nobody warned me that being decisive has side effects."

A Heavy-Handed Ideal Low-Pass Filter

Section 4.2 built the transform machinery; this section uses it as a workbench. The recipe never changes: transform the image, multiply by a transfer function $H(u, v)$, transform back. What changes is the shape of $H$, and the section's running lesson is that the shape of the cut matters as much as where you cut. We will watch the most intuitive design (a hard cutoff) produce the worst artifacts, understand exactly why through the Gibbs phenomenon from Section 4.1, and end with the one filter family that spatial convolution genuinely cannot replace: the notch.

1. Filtering as Spectrum Sculpting Beginner

The full pipeline, with the shift conventions made explicit, is:

$$g(x, y) = \mathcal{F}^{-1}\Big[\, H(u, v) \cdot \mathcal{F}\big[f(x, y)\big] \,\Big]$$

where $H$ is built in centered coordinates (so it must multiply a shifted spectrum, per Figure 4.2.1). Since most useful filters care only about how far a frequency is from the center, not its direction, we first compute a radial distance grid and then express every filter as a function of it:

import numpy as np
from skimage import data

img = data.camera().astype(np.float64)

def radial_distance(shape):
    """Distance of each (centered) frequency bin from the spectrum center."""
    h, w = shape
    yy, xx = np.ogrid[:h, :w]
    return np.sqrt((yy - h / 2) ** 2 + (xx - w / 2) ** 2)

def apply_filter(image, H):
    """Transform, multiply by the centered transfer function H, invert."""
    F = np.fft.fftshift(np.fft.fft2(image))
    return np.real(np.fft.ifft2(np.fft.ifftshift(F * H)))

D = radial_distance(img.shape)        # same shape as img, zero at center

Before designing new masks, note what this view says about old friends. The Gaussian blur of Chapter 3 has a transfer function that is itself a Gaussian (wide kernel, narrow $H$, and vice versa); the box filter's $H$ is a sinc function that dips negative, which is the frequency-domain explanation of the box filter's odd artifacts on fine patterns. A filter's spatial and spectral faces are two views of one object, and you can design on whichever side is clearer, then translate.

2. Three Low-Pass Designs: Ideal, Butterworth, Gaussian Intermediate

A low-pass filter keeps frequencies near the center (smooth content) and attenuates the rest (detail, edges, noise). The three classical designs differ only in how abruptly they say no:

$$H_{\text{ideal}}(u,v) = \begin{cases} 1 & D(u,v) \le D_0 \\ 0 & D(u,v) > D_0 \end{cases} \qquad H_{\text{btw}}(u,v) = \frac{1}{1 + \big[D(u,v)/D_0\big]^{2n}} \qquad H_{\text{gauss}}(u,v) = e^{-D^2(u,v) / 2 D_0^2}$$

Here $D_0$ is the cutoff radius and $n$ the Butterworth order, which dials its steepness anywhere between Gaussian-gentle ($n = 1$) and ideal-brutal ($n \to \infty$). Figure 4.3.1 plots the three profiles; the only visual difference is the sharpness of the shoulder, and that shoulder is the whole story.

D0 = 30.0                                       # cutoff radius, in frequency bins
H_ideal  = (D <= D0).astype(np.float64)
H_butter = 1.0 / (1.0 + (D / D0) ** (2 * 2))    # Butterworth, order n = 2
H_gauss  = np.exp(-(D ** 2) / (2 * D0 ** 2))

lp_ideal  = apply_filter(img, H_ideal)    # blur + ripples hugging every edge
lp_butter = apply_filter(img, H_butter)   # blur, only a whisper of ringing
lp_gauss  = apply_filter(img, H_gauss)    # pure blur, zero ringing

Run the code and look closely at the ideal-filtered image: every strong edge has ripples radiating from it, like a pond after a stone. This is the ringing artifact, and it is the Gibbs phenomenon of Section 4.1 in its adult form. The hard spectral cutoff is itself an edge, and an edge in one domain is an oscillation in the other: the ideal filter's spatial form is a 2D sinc whose decaying lobes stamp themselves around every feature they convolve with.

3. High-Pass Filtering and Sharpening Intermediate

Every low-pass design yields a high-pass twin for free: $H_{\text{HP}} = 1 - H_{\text{LP}}$. A pure high-pass result keeps only edges and texture floating on a mid-gray void (the DC term is gone, so the mean is zero), which is useful for inspection but rarely the goal. The practical sharpening tool is high-frequency emphasis: keep the whole image and add back an extra helping of its high frequencies,

$$H_{\text{hfe}}(u, v) = a + b \cdot H_{\text{HP}}(u, v)$$

with $a \approx 1$ preserving the original and $b$ controlling the boost. This is precisely the unsharp masking of Chapter 3 wearing frequency-domain clothes: there you computed "image plus $b$ times (image minus blur)", and expanding that expression gives exactly $1 + b(1 - H_{\text{blur}})$ as a spectral multiplier.

H_hp  = 1.0 - H_gauss                  # Gaussian high-pass: smooth, no ringing
H_hfe = 1.0 + 1.2 * H_hp               # a = 1 keeps the image, b = 1.2 boosts detail

sharp = np.clip(apply_filter(img, H_hfe), 0, 255)
# Edges and fine texture visibly crisper; flat regions untouched, because
# H_hfe equals 1.0 exactly at the spectrum center where smooth content lives.

4. Notch Filters: Surgical Removal of Periodic Noise Advanced

Now for the filter family that justifies the whole frequency-domain detour. Periodic interference, scanner banding, electrical hum coupled into a sensor, halftone dots from printed sources, screen-door moiré, is spread across every pixel in the spatial domain, hopelessly entangled with the signal. But in the frequency domain, a periodic pattern is a point: one conjugate pair of bright spikes at its frequency (visible in Figure 4.3.2). A notch filter zeroes a small disk around each spike and leaves everything else untouched. No spatial kernel of reasonable size can do this; the notch's spatial equivalent is an oscillating pattern as large as the image itself.

h, w = img.shape
yy, xx = np.mgrid[0:h, 0:w]
noisy = img + 25 * np.sin(2 * np.pi * 60 * yy / h)   # 60-cycle horizontal banding

def notch_mask(shape, centers, radius=6):
    """All-ones mask with zeroed disks at given (row, col) offsets from center."""
    hh, ww = shape
    Y, X = np.ogrid[:hh, :ww]
    mask = np.ones(shape, dtype=np.float64)
    for dv, du in centers:
        cy, cx = hh / 2 + dv, ww / 2 + du
        mask[(Y - cy) ** 2 + (X - cx) ** 2 <= radius ** 2] = 0.0
    return mask

# The banding lives at (v, u) = (+60, 0) and its conjugate (-60, 0)
H_notch = notch_mask(img.shape, centers=[(60, 0), (-60, 0)])
clean = apply_filter(noisy, H_notch)
# The banding vanishes completely; the tiny residual difference from the
# original is the sliver of true image energy that shared those two bins.

In production you rarely hard-code spike positions: detect them as local maxima of the log-magnitude spectrum beyond some radius (excluding the natural center blob and axis streaks), then notch each detection and its conjugate. Soft-edged notches (a small inverted Gaussian rather than a hard zero disk) avoid introducing miniature ringing of their own, the same lesson as Figure 4.3.1 at a smaller scale.

from skimage.filters import butterworth

low  = butterworth(img, cutoff_frequency_ratio=0.06, high_pass=False, order=2)
high = butterworth(img, cutoff_frequency_ratio=0.06, high_pass=True,  order=2)