Course from fixes only moves forward in time, from an anchor fix, and not for a standing contact; military contacts too

A fix that is not a second newer (a repeat, or an older position from another
feed) never gives a course, so a source switch cannot turn an aircraft
around. The course runs from an anchor fix that moves only when a course is
read, so frequent short steps add up, and a contact reported under 2 m/s
reads none. The helper moves to src/data/courseFromFixes.js and the military
records use it as well.
This commit is contained in:
Sameh Khamis committed 2026-11-15 11:19:58 -08:00
1 parent e08dcd0326
commit fc4db81d0b
9 files changed
+217 -92

No files matched your search

+42 -52
View File
@@ -3,7 +3,7 @@ import assert from 'node:assert/strict';
import fs from 'node:fs';
import path from 'node:path';
import { fileURLToPath } from 'node:url';
import { FlightRecords, courseFromFixes } from './records.js';
import { FlightRecords } from './records.js';
const FLEET = path.resolve(
path.dirname(fileURLToPath(import.meta.url)),
@@ -320,58 +320,48 @@ test('a ground vehicle or station with no altitude stands on the ground; an airc
assert.equal(unloaded.onGround, false);
});
test('a contact reported with no course faces the way it moved since its last fix', () => {
test('a contact reported with no course faces the way its newer fixes went', () => {
const store = records();
// Taxiing south along a runway with no track or true heading reported.
store.receive(
observation({
latitude: 30.1908,
longitude: -97.6588,
courseDeg: null,
onGround: true,
speedMps: 8,
}),
view(),
const T = 1700000000000;
const taxi = (latitude, seconds, fields = {}) =>
store.receive(
observation({
latitude,
longitude: -97.6588,
courseDeg: null,
onGround: true,
speedMps: 8,
positionTimeMs: T + seconds * 1000,
...fields,
}),
view(),
);
const course = () => store.data.get('abc123').true_track;
taxi(30.1908, 0);
assert.equal(course(), 0, 'nothing known yet');
// Fixes a second apart, 8 m each: they add up until 30 m are covered.
taxi(30.19073, 1);
taxi(30.19066, 2);
assert.equal(course(), 0, 'under 30 m: still nothing');
taxi(30.19059, 3);
taxi(30.19052, 4);
assert.ok(Math.abs(course() - 180) < 0.1, 'southbound');
// An older fix from another feed, behind it: never turns it around.
taxi(30.1912, 2);
assert.ok(Math.abs(course() - 180) < 0.1, 'an older fix gives no course');
taxi(30.1901, 8);
assert.ok(Math.abs(course() - 180) < 0.1);
// Standing (reported under 2 m/s) with 40 m of position noise: kept.
taxi(30.18974, 12, { speedMps: 0.5, longitude: -97.6584 });
assert.ok(
Math.abs(course() - 180) < 0.1,
'a standing contact keeps its course',
);
assert.equal(store.data.get('abc123').true_track, 0, 'nothing known yet');
store.receive(
observation({
latitude: 30.1885,
longitude: -97.6588,
courseDeg: null,
onGround: true,
speedMps: 8,
}),
view(),
);
assert.ok(Math.abs(store.data.get('abc123').true_track - 180) < 0.1);
// Standing still (a metre of position noise): the last course is kept.
store.receive(
observation({
latitude: 30.18849,
longitude: -97.6588,
courseDeg: null,
onGround: true,
speedMps: 0,
}),
view(),
);
assert.ok(Math.abs(store.data.get('abc123').true_track - 180) < 0.1);
// A reported course always wins.
store.receive(
observation({
latitude: 30.188,
longitude: -97.6588,
courseDeg: 175,
onGround: true,
}),
view(),
);
assert.equal(store.data.get('abc123').true_track, 175);
});
test('course from fixes ignores position noise and reads east as 90', () => {
assert.equal(courseFromFixes(30, -97, 30.0001, -97), null, 'about 11 m');
assert.ok(Math.abs(courseFromFixes(0, 0, 0, 0.01) - 90) < 1e-6);
assert.equal(courseFromFixes(null, 0, 0, 0.01), null);
taxi(30.189, 16, { courseDeg: 175 });
assert.equal(course(), 175);
// A reset forgets where it was: it starts again from north.
store.reset();
taxi(30.188, 20);
assert.equal(course(), 0);
});