Frequency-domain filtering

"Give me a spectrum and I will delete whichever frequencies displease me. Give me a stream and I will remember, too late, that the world does not arrive in tidy blocks."

An Overconfident AI Agent

Filtering is multiplication in the frequency domain

The engine of this whole section is one identity. Convolving a signal \(x\) with a filter kernel \(h\) in time is exactly the same as multiplying their spectra point by point in frequency. Writing \(\mathcal{F}\) for the Fourier transform,

This is the convolution theorem, and it reframes filtering completely. A time-domain filter answers "what weighted average of nearby samples do I output?" The frequency view answers "by how much do I scale each sinusoid the signal is built from?" The scaling factor at each frequency is the filter's frequency response \(H(f) = \mathcal{F}\{h\}\). A filter is nothing more than a volume knob per frequency: turned up near \(1\) where a sinusoid should survive, turned down near \(0\) where it should vanish; a low-pass filter simply keeps the low-frequency dials up and the high-frequency dials down. Because you can draw \(H(f)\) directly and inverse-transform it into a kernel, the frequency domain lets you design the response first and derive the filter second, which is the reverse of hand-tuning taps.

Why does this matter for sensors? Because the interference you fight is usually named in frequency, not in time: power-line hum sits at 50 or 60 Hz, a drone's rotor whine sits at its blade-pass frequency, a structure's resonance sits at its natural mode. When you can point at the offender on a spectrum, deleting it there is the most direct move available, and it costs almost nothing: the FFT turns an \(O(N^2)\) convolution into an \(O(N\log N)\) transform-multiply-transform, which is why long kernels are almost always applied this way in practice.

Sculpting a spectral mask, and the ringing it invites

The seductive move is to build a "brick-wall" filter: set \(H(f)=1\) inside the pass-band and \(H(f)=0\) everywhere else, a perfectly rectangular mask. In the spectrum this looks flawless. In time it is a disaster, because the inverse transform of a rectangle is a \(\operatorname{sinc}\) function that oscillates forever. Multiply by a sharp-edged mask and every step or transient in your signal sprouts ripples on both sides of it, an overshoot that does not shrink as you add resolution. This is the Gibbs phenomenon, and it is the single most common way frequency-domain filtering goes wrong: an ECG with a hard 40 Hz cutoff grows phantom wiggles around every QRS spike that a clinician could mistake for pathology.

The cure is to forbid infinitely sharp edges. Replace the vertical wall with a smooth roll-off, a raised-cosine or Gaussian taper that eases \(H(f)\) from \(1\) to \(0\) over a transition band. A smoother mask has a shorter, better-behaved time-domain kernel and rings far less. The price is a gentler cutoff: you cannot both delete a frequency 1 Hz away from one you keep and avoid ringing. That trade, transition sharpness against time-domain artifacts, is the same delay-versus-fidelity tension that Section 6.7 makes central, seen now from the spectral side.

import numpy as np

def fft_lowpass(x, fs, f_cut, width):
    """Low-pass by masking the spectrum with a smooth raised-cosine edge."""
    X = np.fft.rfft(x)
    f = np.fft.rfftfreq(len(x), d=1.0 / fs)
    # Raised-cosine roll-off from 1 to 0 across [f_cut, f_cut + width]:
    mask = np.clip((f_cut + width - f) / width, 0.0, 1.0)
    mask = 0.5 - 0.5 * np.cos(np.pi * mask)          # smooth the ramp
    return np.fft.irfft(X * mask, n=len(x))

fs = 1000.0
t = np.arange(0, 2, 1 / fs)
sig = np.sin(2 * np.pi * 5 * t) + 0.6 * np.sin(2 * np.pi * 120 * t)
clean = fft_lowpass(sig, fs, f_cut=20.0, width=8.0)   # keep 5 Hz, kill 120 Hz

Listing 6.4.1 is a working filter in a dozen lines, and it exposes the whole idea: the response you want is literally the array mask, drawn by hand. Try replacing the raised-cosine with a hard mask = (f <= f_cut) and you will see the QRS-style ripples appear around any sharp feature in sig.

Streaming reality: circular convolution and the block problem

Listing 6.4.1 quietly assumed you own the entire signal at once. Real sensors deliver a never-ending stream, so you must filter in blocks. Here the FFT hides a trap. The multiplication \(X\cdot H\) followed by an inverse transform does not compute the ordinary (linear) convolution; it computes circular convolution, which treats each block as if it wrapped around into a loop. Energy that a real filter would push past the end of a block instead reappears, folded back, at the beginning. The result is wrap-around artifacts: corrupted samples at the block edges that grow worse the longer your kernel.

The fix is a pair of classic block methods, and both work the same trick: give the wrap-around a harmless place to land, then discard that place. A kernel of length \(L\) spills \(L-1\) samples of a true linear convolution past a block's edge; circular convolution folds those \(L-1\) samples back onto the block's start instead. Overlap-add pads each non-overlapping input block with \(L-1\) zeros before transforming, so the fold lands on padding rather than real data, then sums the overlapping tails of consecutive filtered blocks, exactly where the true convolution would have spilled. Overlap-save works the same idea from the other end: it feeds the FFT input blocks that already overlap the previous one by \(L-1\) samples, so the corrupted output samples are always the wrap of data already filtered correctly, and discarding the first \(L-1\) samples of each output block leaves clean interior only. Both recover the exact linear-convolution result at FFT speed; overlap-save suits fixed-latency streaming, since it needs no running accumulator, while overlap-add is simpler off-line. You rarely implement either yourself, but knowing they exist explains why a naive "FFT, mask, inverse-FFT, repeat" pipeline glitches at every block boundary.

Spectral subtraction: a filter with no time-domain twin

Some denoising is natural only in the frequency domain. Spectral subtraction assumes you can estimate the noise's magnitude spectrum, from a quiet interval, say, and then subtract that magnitude from every subsequent block's spectrum while keeping the block's phase. What survives is the signal energy that stood above the noise floor at each frequency. This is not a fixed \(H(f)\): the amount removed at each frequency adapts to how much noise you measured there, so it can suppress broadband hiss that no single pass-band filter would touch. It is the ancestor of the noise-reduction in every hearing aid and voice call.

The catch is a distinctly spectral artifact. Because the noise estimate fluctuates, subtraction leaves behind isolated surviving bins that warble in and out, an eerie "musical noise" of random tones. Taming it (over-subtraction margins, spectral flooring, smoothing across blocks) is a craft of its own, and a reminder that operating in the frequency domain buys new powers and new ways to fail. Where spikes and outliers are the enemy rather than steady-state noise, the frequency domain is the wrong tool entirely, and Section 6.5 reaches instead for robust, order-statistic filters.

from scipy.signal import firwin, oaconvolve

taps = firwin(255, cutoff=20.0, fs=1000.0)      # smooth low-pass kernel
y = oaconvolve(sig, taps, mode="same")          # FFT-fast overlap-add convolution

What's Next

In Section 6.5, we confront the noise that frequency-domain filtering handles worst: isolated spikes, dropouts, and outliers that smear their energy across every FFT bin. There the right instinct is not a smooth mask but a robust, order-statistic filter that ignores the outlier entirely, and we will see exactly when linear filtering must step aside for the median.