# Few-pixel targets from a moving camera, in real time on the edge

Real-time C++ | 2026 | C++17, pybind11, numpy, aarch64, CMake

A target three pixels wide carries almost no information in space. All of it is in time, so the pipeline integrates before it decides.

## Evidence

- Registration residual on real 4K moving-camera footage: held-out median 0.080 px over 706 pairs, zero failures, at the instrument floor
- Temporal integration gain measured, not assumed: √N law validated at 1.99 / 2.86 / 4.02 against √T; 3.38 dB at detection, 3.52 dB surviving to track level
- Sequential existence test declares a track in 8.24 frames against 16 for a fixed-sample test and 28 for the best M-of-N counter, at matched error rates
- Every number in the repository is traceable to a row in the experiment registry; an experiment earns a row only if it could have come back with the opposite answer

## The problem

A target one to three pixels across has no texture, no shape and no context. Spatial filtering buys it about 3 dB; ten frames of temporal integration buy about 10 dB. Essentially all the information lives in time. But the camera is moving, so everything in the frame moves, and the residual after imperfect motion compensation looks exactly like a target. Registration accuracy is the signal-to-noise ratio of the entire system. The mainstream framing, a detector followed by a tracker, thresholds per frame and discards the only usable signal before tracking begins.

## What I built

The chain is `align → whiten → integrate over motion hypotheses → decide sequentially`, a dependency order with scheduled feedback, not a one-way pipe. The learned component is deliberately small: a tiny verifier over candidate crops nominated by the classical front end, trained on hard negatives mined from the pipeline's own false alarms.

One implementation, not two. A C++17 core that ships, pybind11 bindings, and a Python harness that therefore measures the shipped code. Every stage has a numpy reference written as its executable specification, which the C++ must match to float precision; measured equivalence is at the 1e-7 level. The core cross-compiles to aarch64 for the target board.

## What is measured

Alignment holds a median residual of 0.080 px on real 4K footage over 706 held-out pairs with no failures. The integration gain follows the √N law exactly on synthetic data, and on injected targets in real footage the pipeline recovers targets about twice as weak at a matched false-alarm rate. The gain survives the tracker: 3.52 dB at track level with the false-track rate inside the sequential test's design. IMM filtering through a turn holds 0.24 px against 1.13 px for a single constant-velocity model; amplitude-aided association resolves crossing tracks from a coin flip to 0.9995.

## What is not solved, with numbers

The composed chain on real footage is still 12 to 14 dB short of the detection threshold, by a margin that has been measured rather than estimated. A native-resolution run shrank the shortfall to 10.4 dB while every mechanism improved, because the threshold rises with the number of tests per frame; on the fastest sequence the operating point collapsed to 40 false plots per window against 1.6 at quarter scale. The matched-filter prediction was falsified outright. And 88 to 93 percent of false plots recur within 2 px at fixed stabilised locations across non-overlapping windows, 15 to 25 times the chance floor, which is a finding, not a bug: it names the next mechanism to build. No latency figure in the project is a target-board measurement, and the docs say so.

The code is private. The public face of this competence is track-lab, whose pages are on this site.