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

tests/test_aircraft_menu.py

@@ -344,3 +344,88 @@ def test_the_map_underneath_is_an_option_that_can_be_turned_off(monkeypatch,
     cfg = ScanConfig(output_dir=str(tmp_path))
     run(monkeypatch, console, [number("basemap"), "no", "s", "b"], cfg)
     assert air.load_options().basemap is False
+
+
+# ---------------------------------------------------------------------------
+# How far the map reaches
+# ---------------------------------------------------------------------------
+
+def test_the_radius_defaults_to_a_hundred():
+    """An aerial hears about that far; a map drawn to fit everything heard
+    is drawn to fit the mistakes."""
+    assert air.AircraftOptions().radius == 100.0
+
+
+def test_the_radius_is_changed_from_the_menu(monkeypatch, console,
+                                             settings_dir, tmp_path):
+    cfg = ScanConfig(output_dir=str(tmp_path))
+    run(monkeypatch, console, [number("radius"), "40", "s", "b"], cfg)
+    assert air.load_options().radius == 40.0
+
+
+def test_the_radius_follows_the_unit_the_speeds_are_in():
+    """A picture measuring its speeds in one unit and its own extent in
+    another would be a puzzle rather than a map."""
+    assert air.radius_in_nm(air.AircraftOptions(radius=100)) == 100.0
+    assert air.radius_in_nm(
+        air.AircraftOptions(radius=100, speed_unit="mph")) == pytest.approx(
+            86.9, abs=0.1)
+    assert air.radius_in_nm(
+        air.AircraftOptions(radius=100, speed_unit="kph")) == pytest.approx(
+            54.0, abs=0.1)
+
+
+def test_no_radius_at_all_goes_back_to_fitting_what_was_heard():
+    assert air.radius_in_nm(air.AircraftOptions(radius=0)) == 0.0
+
+
+def test_the_receiver_position_can_be_given_or_worked_out():
+    from bandsaunter.flightlog import read_position
+
+    assert read_position("32.54,-111.17") == pytest.approx((32.54, -111.17))
+    assert read_position("") is None
+    assert read_position("somewhere near Tucson") is None
+    assert read_position("240.0,-111.0") is None      # not a place
+    assert air.AircraftOptions().location == ""       # worked out by default
+
+
+def test_rechecking_is_an_option_and_is_off_unless_asked(monkeypatch, console,
+                                                         settings_dir,
+                                                         tmp_path):
+    """Logs written by this version have the check applied as they are
+    written, so it is a repair for older ones rather than a default."""
+    assert air.AircraftOptions().recheck is False
+    cfg = ScanConfig(output_dir=str(tmp_path))
+    run(monkeypatch, console, [number("recheck"), "yes", "s", "b"], cfg)
+    assert air.load_options().recheck is True
+
+
+def test_rechecking_says_what_it_threw_out(capsys):
+    from bandsaunter.flightlog import Fix, Track
+
+    loud = Console(width=100)
+    track = Track(icao="4CA1FA", fixes=[
+        Fix(at=0.0, latitude=51.5, longitude=-0.12),
+        Fix(at=0.5, latitude=-9.5, longitude=-112.5),
+        Fix(at=1.0, latitude=51.5, longitude=-0.12)])
+    air.checked(loud, air.AircraftOptions(recheck=True), [track])
+    printed = capsys.readouterr().out
+    assert "dropped" in printed and "could have been in" in printed
+
+
+def test_a_clean_log_is_told_so_rather_than_left_silent(capsys):
+    loud = Console(width=100)
+    air.checked(loud, air.AircraftOptions(recheck=True), [])
+    assert "checks out" in capsys.readouterr().out
+
+
+def test_leaving_it_off_changes_nothing(capsys):
+    from bandsaunter.flightlog import Fix, Track
+
+    loud = Console(width=100)
+    track = Track(icao="4CA1FA", fixes=[
+        Fix(at=0.0, latitude=51.5, longitude=-0.12),
+        Fix(at=0.5, latitude=-9.5, longitude=-112.5)])
+    same = air.checked(loud, air.AircraftOptions(recheck=False), [track])
+    assert same[0] is track
+    assert capsys.readouterr().out.strip() == ""