diff --git a/changelog.d/1817-estimated-trail.md b/changelog.d/1817-estimated-trail.md new file mode 100644 index 0000000000..db24565fb8 --- /dev/null +++ b/changelog.d/1817-estimated-trail.md @@ -0,0 +1,4 @@ +- An aircraft feed can mark estimated positions (`estimatedByIcao` beside state + vectors, `estimated: true` on a readsb-style row). Such a position still + places the aircraft, but stands in on the tracked trail only until the next + received one, so oceanic trails no longer zigzag (samehkhamis, #1817). diff --git a/src/data/trailContinuity.js b/src/data/trailContinuity.js index a18a4e32b3..cd3fc585ab 100644 --- a/src/data/trailContinuity.js +++ b/src/data/trailContinuity.js @@ -410,6 +410,25 @@ function keepTrailLimit(fixes, maxPoints) { return fixes; } +/** + * Take the estimated reports out of the trail, judging again the break before + * each report that followed one. + */ +function dropEstimatedFixes(fixes) { + let dropped = false; + let kept = 0; + for (const fix of fixes) { + if (fix.estimated) { + dropped = true; + continue; + } + if (dropped) fix.breakBefore = trailFixBreaks(fixes[kept - 1], fix); + dropped = false; + fixes[kept++] = fix; + } + fixes.length = kept; +} + /** Index a fix at `timeMs` goes in at: after every entry at or before it. */ function insertionIndex(fixes, timeMs) { let i = fixes.length; @@ -425,9 +444,13 @@ function insertionIndex(fixes, timeMs) { * @param {{x: number, y: number, z: number}} position - Owned position. * @param {number} timeMs - The report's epoch ms. * @param {number} maxPoints - Point limit across all segments. - * @param {{nullAltitude?: boolean, onGround?: boolean, track?: number}} [options] + * @param {{nullAltitude?: boolean, onGround?: boolean, track?: number, estimated?: boolean}} [options] * `onGround`: whether the report was on the ground, when known; - * `track`: its reported track, which the curve leaves it along. + * `track`: its reported track, which the curve leaves it along; + * `estimated`: the feed estimated the position rather than received it. An + * estimated report stands in only until the next received one, which takes + * every estimated report out of the trail: the line runs between received + * positions, never through a feed's guesses and the jump back. * @returns {object[]} `fixes`. */ export function insertTrailFix( @@ -435,14 +458,21 @@ export function insertTrailFix( position, timeMs, maxPoints, - { nullAltitude = false, onGround = undefined, track = undefined } = {}, + { + nullAltitude = false, + onGround = undefined, + track = undefined, + estimated = false, + } = {}, ) { + if (!estimated) dropEstimatedFixes(fixes); const entry = { position: nullAltitude ? null : position, timeMs, nullAltitude, breakBefore: false, }; + if (estimated) entry.estimated = true; if (Number.isFinite(track)) entry.track = track; // Whether the report was on the ground, when known: a history backfill // joins it only across a landing or take-off it saw. diff --git a/src/data/trailReports.test.mjs b/src/data/trailReports.test.mjs index 4811871b0e..5a303536c2 100644 --- a/src/data/trailReports.test.mjs +++ b/src/data/trailReports.test.mjs @@ -109,6 +109,35 @@ test('a report with no altitude keeps no position and breaks the line', () => { assert.equal(trailBodySegments(fixes, fixes.length).length, 2); }); +test('an estimated report stands in only until the next received one', () => { + // Out of receiver range a feed carries the aircraft on its last course; the + // next received report is 900 m off that line. The guesses go, so the line + // runs received report to received report. + const fixes = []; + insertTrailFix(fixes, at(0, 0), 0, LIMIT); + insertTrailFix(fixes, at(1_500, 0), 15 * SEC, LIMIT, { estimated: true }); + insertTrailFix(fixes, at(3_000, 0), 30 * SEC, LIMIT, { estimated: true }); + assert.equal(fixes.length, 3); + assert.equal(fixes[2].estimated, true); + insertTrailFix(fixes, at(4_500, -900), 45 * SEC, LIMIT); + assert.deepEqual( + fixes.map((fix) => [fix.timeMs, fix.estimated === true]), + [ + [0, false], + [45 * SEC, false], + ], + ); + // 45 s and 4.6 km apart: still one path, joined. + assert.equal(fixes[1].breakBefore, false); + // A received report a sweep late, older than the guesses, takes them out too. + insertTrailFix(fixes, at(6_000, -900), 60 * SEC, LIMIT, { estimated: true }); + insertTrailFix(fixes, at(5_000, -900), 50 * SEC, LIMIT); + assert.deepEqual( + fixes.map((fix) => fix.timeMs), + [0, 45 * SEC, 50 * SEC], + ); +}); + test('a report arriving late goes in time order and the curve stays smooth', () => { const fixes = []; for (const t of [0, 30, 15, 45]) diff --git a/src/layers/flights/records.js b/src/layers/flights/records.js index 9b4653330c..eeb25a8cc1 100644 --- a/src/layers/flights/records.js +++ b/src/layers/flights/records.js @@ -336,6 +336,9 @@ export class FlightRecords { geoAltitudeM, renderAltitudeM, renderAltitudeInvented, + // The feed estimated this position: it places the aircraft, and stands + // in on the tracked trail only until the next received report. + estimated: observation.estimated === true, groundM: Number.isFinite(groundM) ? groundM : null, onGround, // Round 7: sticky airborne history — the landed fast-cull only diff --git a/src/layers/flights/snapshotRenderer.js b/src/layers/flights/snapshotRenderer.js index 228e2d3624..fbe8c67a12 100644 --- a/src/layers/flights/snapshotRenderer.js +++ b/src/layers/flights/snapshotRenderer.js @@ -217,6 +217,7 @@ export function createFlightSnapshotRenderer({ { nullAltitude: meta.renderAltitudeInvented === true, track: meta.true_track, + estimated: meta.estimated === true, }, ); } else { diff --git a/src/layers/flights/tracking.js b/src/layers/flights/tracking.js index b995b8a3a1..1243ae267d 100644 --- a/src/layers/flights/tracking.js +++ b/src/layers/flights/tracking.js @@ -336,15 +336,17 @@ export function createTracking({ * @param {{x: number, y: number, z: number}} position - The report's ECEF position. * @param {number} [epochMs] - The report's time; defaults to the tracked * aircraft's newest position-history fix, which every caller has just pushed. - * @param {{nullAltitude?: boolean, track?: number}} [options] - `nullAltitude`: + * @param {{nullAltitude?: boolean, track?: number, estimated?: boolean}} [options] - `nullAltitude`: * the report had no altitude, so its position is not kept and the line - * breaks there; `track`: its reported track, which the line leaves it along. + * breaks there; `track`: its reported track, which the line leaves it along; + * `estimated`: the feed estimated it, so it stands in only until the next + * received report. */ function _appendTrailFix( position, epochMs, - { nullAltitude = false, track = undefined } = {}, + { nullAltitude = false, track = undefined, estimated = false } = {}, ) { const history = flightState._positionHistory.get(flightState._trackedIcao); const timeMs = Number.isFinite(epochMs) @@ -355,7 +357,7 @@ export function createTracking({ position, timeMs, TRAIL_MAX_POINTS, - { nullAltitude, track }, + { nullAltitude, track, estimated }, ); _refreshTrailDisplay(); } diff --git a/src/sources/live/aircraft.js b/src/sources/live/aircraft.js index accc8672d8..e0f37ddeab 100644 --- a/src/sources/live/aircraft.js +++ b/src/sources/live/aircraft.js @@ -11,6 +11,20 @@ import { readAdsbVerticalRateFpm } from '../adsbFields.js'; const openSkyId = (row) => Array.isArray(row) ? cleanText(row[0]).toLowerCase() : ''; +/** The aircraft (lowercase ICAO) a state-vector snapshot's `estimatedByIcao` names. */ +const estimatedCache = new WeakMap(); +function estimatedIds(payload) { + const list = payload?.estimatedByIcao; + if (!Array.isArray(list)) return EMPTY_IDS; + let ids = estimatedCache.get(list); + if (!ids) { + ids = new Set(list.map((id) => cleanText(id).toLowerCase())); + estimatedCache.set(list, ids); + } + return ids; +} +const EMPTY_IDS = new Set(); + /** Normalize the OpenSky state-vector route, including its regional fallback. */ export function normalizeOpenSkyAircraft(row) { const id = openSkyId(row); @@ -114,6 +128,10 @@ export function openSkySnapshot( const types = payload?.typeByIcao; if (record && types && Object.hasOwn(types, record.id)) record.typeCode = cleanText(types[record.id]).toUpperCase() || null; + // Nor a position source; a feed that estimates some positions (carried + // on the last course out of receiver range) names those aircraft. + if (record && estimatedIds(payload).has(record.id)) + record.estimated = true; return record; }, 'OpenSky', @@ -157,7 +175,12 @@ export function readsbSnapshot( ) { const admitted = admitRecords( payload?.ac, - (row) => normalizeReadsbAircraft(row, observedAtMs), + (row) => { + const record = normalizeReadsbAircraft(row, observedAtMs); + // A row whose position the feed estimated rather than received. + if (record && row.estimated === true) record.estimated = true; + return record; + }, 'adsb.lol', readsbUnpositionedId, ); diff --git a/src/sources/live/contract.test.mjs b/src/sources/live/contract.test.mjs index bc5c57a3c8..8e8e7a90a2 100644 --- a/src/sources/live/contract.test.mjs +++ b/src/sources/live/contract.test.mjs @@ -615,6 +615,32 @@ test('a vessel with no name is not named by its id; a ten-digit MMSI is an MMSI' assert.equal(named.name, 'EVER GIVEN'); }); +test('aircraft a feed names as estimated are marked estimated, and only those', () => { + const row = (id) => [id, 'TEST1', 'US', 1, 1, -77, 39, 1000, false, 100, 90]; + const vectors = openSkySnapshot({ + time: 1, + states: [row('abc123'), row('def456')], + estimatedByIcao: ['ABC123', 'zzz999'], + }).records; + assert.equal(vectors[0].estimated, true); + assert.equal('estimated' in vectors[1], false); + assert.equal( + 'estimated' in openSkySnapshot({ states: [row('abc123')] }).records[0], + false, + ); + const rows = readsbSnapshot( + { + ac: [ + { hex: 'abc123', lat: 39, lon: -77, estimated: true }, + { hex: 'def456', lat: 39, lon: -77 }, + ], + }, + { observedAtMs: null }, + ).records; + assert.equal(rows[0].estimated, true); + assert.equal('estimated' in rows[1], false); +}); + test('a type sent alongside the state vectors becomes the record type code', () => { const row = (id) => [id, 'TEST1', 'US', 1, 1, -77, 39, 1000, false, 100, 90]; const snapshot = openSkySnapshot({