Where the Gradient Changes, There Lives the Edge

I was holding the blade up to the window this morning, tilting it back and forth, watching how the light behaved along the edge. When the angle is right, the edge itself disappears—too thin to reflect anything. What you’re really seeing is the transition, the place where one plane stops and another begins at an angle sharp enough to slice tomato skins.

In 1970, Irwin Sobel and Gary Feldman were wrestling with the same problem in two dimensions. Given a grid of brightness values—a digitized photograph—where are the edges? Their answer: look for the gradient. An edge is just a place where intensity changes rapidly. The Sobel operator convolves a 3×3 kernel across the image, computing the rate of change in x and y, then combines them into a magnitude.

The one-dimensional case makes this clearer:

fn gradient(signal: &[f64]) -> Vec<f64> {
    signal.windows(2)
        .map(|w| (w[1] - w[0]).abs())
        .collect()
}

fn main() {
    let brightness = [0.1, 0.1, 0.1, 0.9, 0.9, 0.9];
    let edges = gradient(&brightness);
    println!("{:?}", edges);  // [0.0, 0.0, 0.8, 0.0, 0.0]
}

That 0.8 in the middle? That’s where the edge lives—the sudden jump from dim to bright. The Haskell version reads almost like the mathematical definition:

gradient :: [Double] -> [Double]
gradient xs = zipWith (\a b -> abs (b - a)) xs (tail xs)

main :: IO ()
main = print $ gradient [0.1, 0.1, 0.1, 0.9, 0.9, 0.9]
-- [0.0, 0.0, 0.8, 0.0, 0.0]

The elegance of zipWith against tail—you’re pairing each element with its successor, computing the delta, done.

What I like about both is that they don’t detect the edge so much as reveal it. The edge was always there in the data; the gradient just makes it visible. Same with a knife, honestly. The forty minutes I spent on the whetstone yesterday weren’t creating an edge—they were removing everything that wasn’t edge. Metal has a transition zone too, a region where the steel curves from one face to the other. My job was to narrow that transition until the gradient became infinite, or close enough for tomatoes.

The Sobel operator fell out of fashion once Canny published his multi-stage approach in 1986, but the principle remains: edges are boundaries, boundaries are gradients, and gradients are just the derivative wearing a shop apron. Whether you’re sliding a window across pixels or sliding a blade across stone, you’re asking the same question—where does the change happen?

The tomato didn’t stand a chance.