Frame the map on the receiver, and throw out what never happened

A first real capture came back as a map spanning 240 degrees north to 20
south, with the aircraft an indistinguishable smudge in one corner.  Two
separate faults, one of them mine from the start.

A position is sent as half a position -- an even frame and an odd one --
and the pair only means anything while the aircraft has not moved between
them.  The registry kept the last of each forever and paired them
regardless of age, so an even frame from ten minutes ago decoded against
a fresh odd one to a place on the wrong side of the world.  Measured: a
pair 300 seconds apart puts the aircraft 2,566 nm from where it is, and
one night's log had it happening to two aircraft in three, with eleven
positions off the planet altogether.  A pair is now good for ten seconds,
the answer has to be on Earth, and the aircraft has to have been able to
reach it.

--radius, defaulting to a hundred, frames the picture on the receiver
rather than on whatever was heard, so the scale is the same from one
evening to the next.  In the same unit as the speeds.  The centre is the
median of everything heard, which a handful of wrong positions cannot
move, or --at LAT,LON says where the aerial is.

--recheck repairs a log recorded before all this: for each aircraft it
keeps the longest run of positions that could describe one aeroplane.
Not a forward walk dropping whatever disagrees with the last position
kept -- that lets one bad fix become the reference, and on the same log
it discarded a fifth of everything, most of it the truth.

Two calibrations came from the recording rather than from taste.  The
failures separate cleanly -- a hundred artefacts under a mile, twelve
hundred real errors over fifty, and nothing in between -- because
positions are stamped to the millisecond, so two a thousandth of a second
apart imply thousands of knots across a few yards.  Nothing under two
miles is called an error.  Afterwards the worst surviving jump is 513 kt.

One rendering bug the tighter frame exposed: an aircraft just off the top
left painted 743,774 pixels of an 844,200-pixel picture, because the dot
at a marker's centre clamped its near edge and left the far one alone, and
numpy reads a negative slice end as counting back from the far side.  And
a still of a whole evening was dead-reckoning every aircraft forward to
the final moment, which for a ten-hour log flew 291 of 335 clean off the
picture; a still now draws each where it was last actually heard.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016PsWPTweCT6pwxKngvVxcg

README.md

@@ -1105,6 +1105,61 @@ elsewhere, so nothing but numpy is needed to draw one. Where ffmpeg happens to
 be installed, `--out something.mp4` is smaller and smoother; where it is not,
 nothing breaks and a GIF is written instead.
 
+### How far the map reaches
+
+```bash
+bandsaunter flights --radius 100          # the default: a hundred miles round
+bandsaunter flights --radius 0            # fit whatever turned up, warts and all
+bandsaunter flights --at 32.54,-111.17    # say where the receiver is
+```
+
+**The map is framed on the receiver, not on whatever was heard.** An aerial
+reaches a hundred miles on a good day, and a position that decoded wrongly can
+land anywhere on Earth — so a map drawn to fit everything is drawn to fit the
+mistakes, and the aircraft come out a pixel wide in the middle of an empty
+continent. One real night's recording spanned 240°N to 20°S before this.
+
+`--radius` is in the same unit as the speeds, so it is nautical miles with
+knots and statute miles with mph. Left alone, the centre is the *median* of
+everything heard — a receiver hears aircraft all round it, and a median cannot
+be dragged anywhere by a handful of bad positions — or `--at LAT,LON` fixes it,
+which is worth doing if you want the same frame every night. Fixes outside the
+radius are dropped from the drawing, one fix at a time rather than one aircraft
+at a time, so a single bad position in the middle of a real flight does not
+take the whole flight off the map with it. Nothing is dropped from the log.
+
+### Positions that never happened
+
+```bash
+bandsaunter flights --recheck             # throw out the impossible ones
+```
+
+A position is sent as *half* a position — an even frame and an odd one — and
+the pair only means anything while the aircraft has not moved between them.
+Logs written before this version paired them however old they were, so an even
+frame kept from ten minutes ago decoded against a fresh odd one to a place on
+the wrong side of the world, written down as confidently as a real position.
+On one night's recording that was **two aircraft in three**, with positions out
+to 7,378 nautical miles and one latitude of 239°.
+
+`--recheck` reads a log back and keeps, for each aircraft, the longest run of
+positions that could describe one aeroplane. It is deliberately not a forward
+walk that drops whatever disagrees with the last position kept: one bad fix
+then becomes the reference, and it is the truth that gets thrown away — on the
+same recording that discarded a fifth of everything, most of it real. Nothing
+is changed in the log; the frames stay exactly as they arrived.
+
+Two things it will not do, on purpose. An aircraft that goes quiet for five
+minutes and is heard again a long way off is an aeroplane, not an error, and
+nothing after that gap is second-guessed — the radius is what keeps those off
+the picture. And where two positions contradict each other and nothing else
+has an opinion, one of them is wrong and there is no saying which, so the
+later one goes.
+
+**New logs need none of this**: the decoder now refuses a pair more than ten
+seconds apart, refuses a position that is not on Earth, and refuses one the
+aircraft could not have reached, as the frames arrive.
+
 ### The ground under it
 
 **There is a real map under the aircraft.** A flight path over a black