Convolution: What the Radar Actually Hears

When you sweep a GPR antenna across soil, you’re not recording clean reflection spikes. You’re recording the transmitted pulse—maybe 8 nanoseconds of a 400 MHz wavelet—convolved with the reflectivity profile of everything beneath you. Clay at 1.8 m, a buried pipe at 0.6 m, the water table: each boundary imprints a scaled, time-shifted copy of your pulse onto the trace.

Convolution is the operation that models this. Given a signal x and a kernel h, each output sample is the weighted sum of x around that point, using h as weights. For GPR, h is your pulse shape, x is the impulse response of the ground.

In Rust, convolution is a nested loop with bounds checking:

fn convolve(signal: &[f64], kernel: &[f64]) -> Vec<f64> {
    let n = signal.len() + kernel.len() - 1;
    (0..n).map(|i| {
        kernel.iter().enumerate()
            .filter_map(|(j, &k)| signal.get(i.wrapping_sub(j)).map(|&s| s * k))
            .sum()
    }).collect()
}

Haskell lets you write it almost like the mathematical definition:

convolve :: [Double] -> [Double] -> [Double]
convolve xs hs = 
  let padded = replicate (length hs - 1) 0 ++ xs ++ replicate (length hs - 1) 0
  in [sum [padded !! (i - j) * h | (j, h) <- zip [0..] hs] 
      | i <- [length hs - 1 .. length padded - 1]]

Both are O(n·m). FFT-based convolution drops that to O(n log n), which is why modern GPR processors convert to frequency domain, multiply, and convert back. But for understanding your first hyperbola on screen—why a point reflector draws a curve, why clay layers blur—discrete convolution is the answer. Your antenna doesn’t lie; it just convolves.