CloudSignal AI

Blog

Seeing at the limit: diffraction, sampling, and what a camera can never see

By Ashwin Rajendraprasad Computer Vision

Every imaging system, whether an eye, a telescope, a phone camera, or a computer-vision pipeline, eventually runs into the same wall. It isn’t a lens defect or a cheap sensor you can upgrade your way past. It’s physics. There is a hard limit on what any camera can resolve, and no algorithm can honestly recover what diffraction has already destroyed. Knowing exactly where that limit sits is the difference between a system that ships and a demo that overpromises.

Light doesn’t travel in straight lines

Geometric optics (rays, straight lines, neat ray diagrams) is a convenient fiction. Real image formation is governed by wave optics, and waves diffract. Send light through a finite aperture and a single point in the world does not map to a single point on the sensor; it spreads into a small bullseye called the Airy disk. The angular radius of that spot is

θ ≈ 1.22 λ / D

where λ is the wavelength and D the aperture diameter. Two points closer together than that (the Rayleigh criterion, after Lord Rayleigh) blur into one, and no amount of post-processing cleanly separates them again.

Microscopy hits the same wall in a different guise, Ernst Abbe’s diffraction limit (1873):

d = λ / (2·NA)

For green light (~550 nm) through a good oil-immersion objective (NA ≈ 1.4), that’s roughly 200 nm. That number stalled optical microscopy for the better part of a century, until techniques that sidestep the limit rather than break it (STED and single-molecule/PALM microscopy) earned the 2014 Nobel Prize in Chemistry (Eric Betzig, Stefan Hell, William Moerner). The limit itself was never repealed; the winners found clever ways around it.

The imaging equation

It helps to write down what a camera actually records. To a good approximation, an observed image is the true scene convolved with the system’s point-spread function, plus noise:

I(x, y) = (O ∗ h)(x, y) + n(x, y)

Here O is the true scene, h is the point-spread function (the Airy disk, blurred further by aberrations and motion), and n is noise. In the frequency domain, the optical transfer function H(f) behaves like a low-pass filter with a hard cutoff: beyond a certain spatial frequency, the scene’s detail is multiplied by zero.

That last point is the one worth internalizing. Information multiplied by zero is gone — not attenuated, gone. Deconvolution and sharpening can restore detail that was suppressed but survived; they cannot invent detail that was never recorded. When a model appears to add fine structure past the cutoff, it is producing a plausible fabrication, not a measurement. For entertainment that’s fine. For a system that makes decisions, it’s a liability.

The sensor gets a vote too

Even if the optics were perfect, the sensor imposes its own limit. Sampling a continuous image onto a grid of pixels is governed by the Nyquist–Shannon theorem: the highest spatial frequency you can represent without aliasing is

f_Nyquist = 1 / (2p)

where p is the pixel pitch. This sets up a genuine design tension. Pixels much smaller than the Airy disk mostly oversample blur: you spend silicon and light-gathering area to record the lens’s imperfections in high resolution. Pixels much larger throw away optical detail the lens actually delivered. Good camera design is largely choosing which physical limit you’d rather hit first.

Photons are countable, and that’s a problem

Light arrives as discrete photons, and photon arrivals follow Poisson statistics. That produces shot noise, and for N collected photons the signal-to-noise ratio scales as

SNR = √N

This is a quantum floor, not an engineering flaw. It’s why low-light footage is grainy no matter what the camera cost: in the dark, N is small, so √N/N (the relative noise) is large. You beat it only by collecting more photons (bigger aperture, longer exposure, more light), and every one of those has a product cost.

Why this matters for AI

Modern vision models are extraordinary at restoring information that physics attenuated but preserved. They are equally capable of generating detail that physics never captured, and the two can look identical in a demo. The discipline is to keep the line between them bright: restoration is recovery, generation is invention, and a system that can’t tell you which one it’s doing shouldn’t be trusted to decide anything.

The practical habit is simple and it happens before any model is chosen: compute the diffraction spot, the Nyquist limit, and the photon budget for the actual optics, sensor, and lighting you’ll ship on. Those three numbers tell you the ceiling on what’s recoverable, and they settle which argument a team is actually having.

If the detail your product depends on is smaller than the diffraction spot, finer than the pixel grid can sample, or dimmer than the photon floor allows, no model will retrieve it. What’s left to change is the optics, the sensor, the lighting, or how much detail the product needs in the first place. If it clears all three, the problem is engineering, and the production side of this applies: device coverage, the frame budget, quality measured without an answer key. From inside a demo the two cases look identical, which is how a team ends up retraining against a limit no training can move.

The three numbers take an afternoon and specs you already have, so run them yourself. The step after is where an outside read earns its place: choosing optics, sensor, and model against each other before the hardware is locked, which is the scoping a CloudSignal architecture review is for.

Sources / further reading

Written by Ashwin Rajendraprasad for CloudSignal AI.