Laplacian Filter Explained: From Second Derivatives to LoG, Zero Crossings and Sharpening

Key facts

• Laplacian: ∇²f = ∂²f/∂x² + ∂²f/∂y², the sum of second derivatives; it is rotation invariant.
• Discrete form: f(x+1) − 2f(x) + f(x−1) in each direction gives the 4-neighbour kernel [0 1 0; 1 −4 1; 0 1 0], with error of order h².
• Meaning: ∇²f ≈ 4 × (average of the 4 neighbours − f); it is zero on flat areas and ramps.
• Edges are the zero crossings of the Laplacian (the inflection points of the intensity profile).
• Noise: its frequency response grows as |ω|², so smooth first: LoG = ∇²G_σ * f, zero at r = √2σ.
• DoG G_kσ − G_σ ≈ (k − 1)σ²∇²G_σ; sharpening is g = f − c∇²f.

Take one row of pixels across the boundary between a dark field and a bright road in a satellite image. Because optics and sensors blur slightly, the brightness does not jump; it rises along a smooth S-shaped curve. Three curves describe that edge:

The first derivative is large where brightness changes quickly, so its peak marks the edge, but its height depends on the edge contrast and a threshold is needed to say where the peak is. The second derivative is positive where the profile curves upward (the dark foot of the edge), negative where it curves downward (the bright shoulder) and exactly zero at the inflection point between them. A sign change is a sharp, threshold-free location, which is the idea behind Laplacian edge detection.

Pixels are samples with spacing h = 1, so derivatives must be approximated from neighbouring values. Write the Taylor series of f one step to the right and one to the left:

Adding the two lines cancels every odd term:

Worked example. For the step f = [10, 10, 10, 10, 50, 50, 50, 50], applying [1 −2 1] gives [0, 0, 0, 40, −40, 0, 0, 0]: zero on both flat parts, +40 on the last dark pixel, −40 on the first bright pixel, and a sign change exactly between them. The central first difference (f(x+1) − f(x−1))/2 gives [0, 0, 0, 20, 20, 0, 0, 0], a plateau two pixels wide whose centre must still be located.

The 2-D Laplacian adds the second derivatives in x and y. Writing each as a 3 × 3 kernel and adding them gives the 4-neighbour Laplacian:

Three other kernels are common:

• 8-neighbour [1 1 1; 1 −8 1; 1 1 1]: add the second differences along the two diagonals to the 4-neighbour kernel. The diagonal neighbours are √2 pixels away, so for smooth images this kernel approximates 3∇², not ∇². It responds more evenly in all directions.
• Isotropic 9-point (1/6)[1 4 1; 4 −20 4; 1 4 1]: a weighted mix of the two that approximates ∇² and is rotation invariant up to fourth order in frequency.
• Positive-centre versions [0 −1 0; −1 4 −1; 0 −1 0] are simply −∇². Gonzalez and Woods and scikit-image use this sign; SciPy, OpenCV and MATLAB's fspecial use the negative centre. Always check which one a library or paper uses, because the sign of sharpening flips with it.

All Laplacian kernels share one property: their weights sum to zero, because the second derivative of a constant is zero.

Rearranging the 4-neighbour kernel gives the most useful intuition for the Laplacian:

Worked example. A pixel of value 120 with neighbours 53 (north), 50 (east), 51 (south) and 52 (west): ∇²f = 53 + 50 + 51 + 52 − 4 × 120 = 206 − 480 = −274, or 4 × (51.5 − 120). A hot pixel, a bright star or a small bright building gives a strong negative response. The 8-neighbour kernel adds the diagonals (50, 48, 48, 52) and gives 404 − 8 × 120 = −556.

This "difference from the local average" view also explains the Laplacian's role in physics: in a steady state with no sources, every point equals the average of its surroundings, which is Laplace's equation ∇²u = 0.

Choose a profile, add noise and smooth it. The charts show the (smoothed) signal, its central first difference and its second difference [1 −2 1], with zero crossings of strong lobes marked.

Three experiments are worth doing. Ramp: the second derivative is zero everywhere except at the corners, because a constant slope has no curvature. Thin line: the Laplacian gives a strong negative centre with two positive side lobes and therefore two zero crossings, one on each side of the line. Noise 3, smoothing 0: the second derivative is dominated by noise even though the edge is obvious in the signal; then raise the smoothing to 2 and the edge's zero crossing reappears. That is the whole motivation for the Laplacian of Gaussian.

Differentiation multiplies a sinusoid of angular frequency ω by iω; doing it twice multiplies by −ω². The Laplacian therefore boosts each frequency in proportion to its square. Image structure lives mostly at low frequencies, while pixel noise is spread evenly up to the highest frequency, so the Laplacian amplifies noise far more than edges. The discrete kernels show this exactly:

For white noise of standard deviation σₙ, the 4-neighbour Laplacian outputs noise with standard deviation σₙ√(1 + 1 + 1 + 1 + 16) = σₙ√20 ≈ 4.47σₙ. A step of height 40 with noise σₙ = 10 gives an edge response of ±40 against noise of about 45: the edge is lost.

The plain kernels keep rising to the highest frequency; the 4-neighbour kernel also responds less along the diagonal than along the axes, so it is not perfectly isotropic. The LoG rises like the ideal |ω|² at low frequencies, peaks at |ω| = √2/σ and then falls to zero: it is a band-pass filter tuned to structures of a chosen size.

The fix is to smooth with a Gaussian filter first. Because convolution and differentiation are both linear and commute, the two steps combine into a single kernel:

To find ∇²G, differentiate G = (1/2πσ²)e^{−(x²+y²)/2σ²} twice with respect to x using the chain and product rules:

• Shape: a negative centre and a positive ring; its negative, −∇²G, is the "Mexican hat" or Ricker wavelet.
• Zero crossing of the kernel at r = √2σ; its central lobe is 2√2σ wide.
• Discrete kernel: sample on a grid of radius about 4σ and shift it so its weights sum to zero; otherwise truncation leaves a small non-zero sum (−0.0127 for a 9 × 9 kernel with σ = 1.4) that adds a copy of the average brightness.
• Separable in practice: ∇²G = G_xx + G_yy, and each term is a product of 1-D kernels, so a LoG costs four 1-D passes.

The Marr–Hildreth edge detector (1980) is: convolve with the LoG, mark zero crossings, and keep those whose slope across the crossing is large. σ selects the scale: small σ finds fine, noisy edges; large σ finds only major boundaries, smoothly but with rounded corners. You can run it on your own image in the Laplacian Filter Tool.

The Gaussian satisfies the heat (diffusion) equation in the variable t = σ²/2: ∂G/∂t = ∇²G. Rewriting with σ gives

Two Gaussian blurs are each separable and cheap, and in a Gaussian pyramid they are computed anyway, so the DoG costs almost nothing extra. Marr and Hildreth found a ratio k ≈ 1.6 gives a good match to the LoG. Lowe's SIFT detector finds keypoints as extrema of the DoG across position and scale. The DoG also models the centre–surround receptive fields of retinal ganglion cells. As the demo above shows, a DoG with k = 1.6 crosses zero at the same radius as a LoG of scale σk√(2 ln k/(k² − 1)) ≈ 1.24σ. In other words, the DoG matches the shape of a LoG about 24% wider than σ, not the LoG at σ itself; the demo's 49% difference at k = 1.6 shrinks towards zero as k approaches 1.

The LoG responds most strongly to a blob whose size matches the kernel's central lobe. To compare responses across scales, the response must be scale-normalized by multiplying by σ² (Lindeberg); otherwise larger σ always gives smaller numbers. For a bright disc of radius R and unit contrast, the divergence theorem gives the response at its centre in closed form:

This is how automatic scale selection works: compute σ²∇²G * f over a ladder of σ values and keep the local extrema in (x, y, σ). In remote sensing, the same idea counts and sizes tree crowns in high-resolution imagery, detects ponds or sinkholes in DEM-derived layers, and finds cells or particles in microscopy. On the pixel grid, the discrete LoG gives the best σ within a few percent of R/√2 (σ ≈ 5.5 for R = 8, against the theoretical 5.66).

Since ∇²f is negative on the bright side of an edge and positive on the dark side, subtracting it makes bright sides brighter and dark sides darker, which steepens the edge:

Worked example. For the step [10, 10, 10, 10, 50, 50, 50, 50], ∇²f = [0, 0, 0, 40, −40, 0, 0, 0] and g = f − ∇²f = [10, 10, 10, −30, 90, 50, 50, 50]. The jump grows from 40 to 120, with an undershoot and an overshoot on either side; in an 8-bit image −30 is clipped to 0. These over- and undershoots are the halos you see when an image is over-sharpened.

Unsharp masking, the sharpening found in Photoshop, GIMP and most camera pipelines, is the same idea with a smoother Laplacian. A Taylor expansion of a small Gaussian blur gives G_σ * f ≈ f + (σ²/2)∇²f, so

import numpy as np
from scipy import ndimage

f = img.astype(float)                       # never use uint8: negative values would wrap

# 1. plain Laplacian (4-neighbour) and its pixel-wise meaning
lap = ndimage.laplace(f)                    # = f_E + f_W + f_N + f_S - 4 f

# 2. Laplacian of Gaussian, scale-normalized
sigma = 2.0
log = sigma**2 * ndimage.gaussian_laplace(f, sigma)

# 3. zero crossings with a slope threshold (Marr-Hildreth)
def zero_crossings(L, thr):
    """Sign change to the right or below, with a jump larger than thr."""
    z = np.zeros(L.shape, bool)
    h = (L[:, :-1] * L[:, 1:] < 0) & (np.abs(L[:, :-1] - L[:, 1:]) > thr)
    v = (L[:-1, :] * L[1:, :] < 0) & (np.abs(L[:-1, :] - L[1:, :]) > thr)
    z[:, :-1] |= h
    z[:-1, :] |= v
    return z
edges = zero_crossings(log, thr=0.05 * np.percentile(np.abs(log), 99.5))

# 4. sharpening and the blur measure
sharp = np.clip(f - 1.0 * lap, 0, 255)
focus = lap.var()                           # variance of the Laplacian

Library equivalents: cv2.Laplacian(img, cv2.CV_64F, ksize=1) is the 4-neighbour kernel (its ksize=3 is a different kernel, [2 0 2; 0 −8 0; 2 0 2]); skimage.filters.laplace returns −∇²; MATLAB's edge(I, 'log') implements Marr–Hildreth and del2 returns ∇²/4.

• Computing in uint8. The Laplacian is signed; in 8-bit unsigned arithmetic negative values wrap around or clip to 0 and half the information is lost. Use float (or at least int16).
• Skipping the smoothing on real, noisy data. Use the LoG, or blur before applying a 3 × 3 kernel.
• Mixing sign conventions between the positive-centre and negative-centre kernels, which turns sharpening into blurring.
• Treating |∇²f| as edge strength. The Laplacian is zero at the edge itself; strength comes from the slope across the zero crossing or from the gradient.
• Comparing raw LoG responses across σ. Multiply by σ² first.
• Ignoring no-data and borders. A no-data value of 0 or −9999 next to valid pixels creates huge false responses; zero padding creates a false edge around the image.