From 134138931fa93a29c78dfd9a93e54389782fff70 Mon Sep 17 00:00:00 2001 From: German Khokhlov Date: Tue, 17 Nov 2026 19:30:47 +0400 Subject: [PATCH 1/8] Transit cockpit rides: hide the held icon, end a hold with the layer, no ellipsoid height - A held vehicle's icon is hidden through the renderer (setShown, then flushMarkers). The icon sets draw a marker only as last pushed, so the direct marker.show write left a parked vehicle's icon drawn under the view's eye. - disable() ends the hold: turned off and on again, the vehicle shows and clicks and Escape reach the layer. - Far above the ground a vehicle with no floor is drawn on the ellipsoid. Its snapshot now reports groundHeightM null there, as near the ground, instead of -1.5 m. - The uneven-ground test also checks the snapshot mid-segment, where a blend of the two reports' floors would read about 55 m instead of 10 m. --- src/layers/transit/cockpitSubject.js | 21 +++-- src/layers/transit/lifecycle.js | 2 + src/layers/transit/lifecycle.test.mjs | 106 ++++++++++++++++++++++++++ src/layers/transit/rendering.js | 1 + 4 files changed, 123 insertions(+), 7 deletions(-) diff --git a/src/layers/transit/cockpitSubject.js b/src/layers/transit/cockpitSubject.js index 909e4702f6..e135835a95 100644 --- a/src/layers/transit/cockpitSubject.js +++ b/src/layers/transit/cockpitSubject.js @@ -84,12 +84,16 @@ export function createTransitCockpitSubject({ state, parts, services }) { * or held), which near the ground follows the terrain between reports; * else its segment's two reports' floors at the playback fraction. Null * while either floor is unknown, as on cold terrain, so a view waits for - * the surface. Not `entry.heightM`, the floor at the newest report, which - * playback has not reached yet. + * the surface: far above the ground such a marker is drawn on the + * ellipsoid, which is no floor. Not `entry.heightM`, the floor at the + * newest report, which playback has not reached yet. */ function drawnFloorOf(entry) { const segment = entry.segment; if (!segment || entry.heightPending) return null; + const from = segment.from?.h; + const to = segment.to?.h; + if (!Number.isFinite(from) || !Number.isFinite(to)) return null; const placed = entry.surfaceReady === true && entry.hasRendered && @@ -99,9 +103,6 @@ export function createTransitCockpitSubject({ state, parts, services }) { const drawn = toCartographicRadians(entry.marker.position); if (drawn) return drawn.height - liftM; } - const from = segment.from?.h; - const to = segment.to?.h; - if (!Number.isFinite(from) || !Number.isFinite(to)) return null; const f = Number.isFinite(segment.fraction) ? Math.max(0, Math.min(1, segment.fraction)) : 1; @@ -173,11 +174,17 @@ export function createTransitCockpitSubject({ state, parts, services }) { return snapshot; } - /** Show or hide a vehicle's sprite and trail for the hold. */ + /** + * Show or hide a vehicle's sprite and trail for the hold. The sprite goes + * through the renderer (setShown, flushMarkers): its set draws a marker + * only as last pushed. + */ function repaint(entry) { if (!entry?.marker) return; - if (entry.key === state._cockpitSubjectKey) entry.marker.show = false; + if (entry.key === state._cockpitSubjectKey) + parts.rendering.setShown(entry, false); else parts.rendering.placeSample(entry); + parts.rendering.flushMarkers(); parts.rendering.schedulePlayback(entry); parts.trails.update(); state._detectRevision += 1; diff --git a/src/layers/transit/lifecycle.js b/src/layers/transit/lifecycle.js index 5e4428f55b..0f3473ffa5 100644 --- a/src/layers/transit/lifecycle.js +++ b/src/layers/transit/lifecycle.js @@ -165,6 +165,8 @@ export function createLifecycle({ state, services, parts }) { state._visible.clear(); clearTimeout(state._cameraDebounceTimer); state._cameraDebounceTimer = null; + // A hold ends with the layer (cockpitSubject.js). + state._cockpitSubjectKey = null; parts.selection.clearSelection(); state._overlayHost.setVisible(TRANSIT_SELECTED_OVERLAY_SOURCE_ID, false); parts.selection.removeClickHandler(); diff --git a/src/layers/transit/lifecycle.test.mjs b/src/layers/transit/lifecycle.test.mjs index 49a3e7f17a..3fcfa3f9ea 100644 --- a/src/layers/transit/lifecycle.test.mjs +++ b/src/layers/transit/lifecycle.test.mjs @@ -978,6 +978,34 @@ test('a held vehicle with no floor yet tells its view no height', async (t) => { assert.equal(app.layer.getCockpitSubject().position.groundHeightM, null); }); +test('far above the ground, a held vehicle drawn on the ellipsoid tells its view no height', async (t) => { + // Above the height gate a vehicle with no floor is drawn on the ellipsoid + // at once, not held back; the ellipsoid is still no floor to stand a view + // on. + const app = harness(t, { altitude: 100_000, floorAt: () => undefined }); + app.serve('mbta', () => ({ + status: 200, + body: snapshot( + 'mbta', + 'MBTA', + [vehicle('bus-1', 42.36, -71.06, Date.now() / 1000)], + { fetchedAt: Date.now() }, + ), + })); + app.layer.enable(app.viewer); + await app.layer.update(); + app.settle(); + const [entry] = app.vehicles(); + assert.ok(app.layer.setCockpitSubject(entry.key) !== false); + app.frame(); + assert.equal(entry.surfaceReady, true, 'it is drawn'); + const drawnM = Cesium.Cartographic.fromCartesian( + entry.marker.position, + ).height; + assert.ok(Math.abs(drawnM) < 1e-3, `on the ellipsoid, got ${drawnM} m`); + assert.equal(app.layer.getCockpitSubject().position.groundHeightM, null); +}); + test('a vehicle waits for its floor rather than standing on the ellipsoid', async (t) => { // The shared ground-floor system answers from the rendered mesh cell or the // real DEM cell; until one of them is warm there is no honest height to draw @@ -2125,6 +2153,11 @@ test('a segment climbs from the ground it left to the ground it reaches', async Math.abs(height() - 11.5) < 3, `at the corridor floor, got ${height().toFixed(1)} m`, ); + // The two reports' floors blended at the fraction would say about 55 m. + assert.ok( + Math.abs(floor() + 1.5 - height()) < 1, + `its snapshot stands on that floor too, got ${floor().toFixed(1)} m`, + ); app.run(TRANSIT_POLL_MS); assert.ok( Math.abs(height() - 101.5) < 1.5, @@ -4880,3 +4913,76 @@ test('a held vehicle hides, keeps moving out of view, and lets go when it goes', assert.equal(app.state()._cockpitSubjectKey, null); assert.equal(app.layer.getCockpitSubject(), null); }); + +test('turning Transit off ends a hold; on again, Escape deselects and the vehicle shows', async (t) => { + const app = harness(t); + const key = await busRunningNorth(app); + assert.equal(app.layer.setCockpitSubject(key), true); + app.layer.disable(app.viewer); + assert.equal( + app.state()._cockpitSubjectKey, + null, + 'the hold ended with the layer', + ); + // On again, without a release: the same bus is listed again. + app.layer.enable(app.viewer); + await app.layer.update(); + app.settle(); + app.run(TRANSIT_POLL_MS); + await app.layer.update(); + app.settle(); + assert.equal(app.layer.focusVehicle(key), true); + const [entry] = app.vehicles(); + app.frame(); + assert.equal(entry.marker.show, true, 'the vehicle is drawn, not held'); + globalThis.document.dispatchEvent( + Object.assign(new Event('keydown'), { key: 'Escape' }), + ); + assert.equal(app.state()._selectedKey, null, 'Escape deselects'); +}); + +test('a held parked vehicle draws no icon; let go, it draws its icon again', async (t) => { + // A parked bus with no course: nothing moves or turns its icon, so only the + // hold itself can take the icon out of the set that draws it. + const app = harness(t); + app.serve('mbta', () => ({ + status: 200, + body: snapshot( + 'mbta', + 'MBTA', + [vehicle('bus-1', 42.36, -71.06, reported(), { stopId: 'place-1' })], + { fetchedAt: Date.now() }, + ), + })); + app.layer.enable(app.viewer); + await app.layer.update(); + app.settle(); + for (let i = 0; i < 3; i += 1) { + app.run(TRANSIT_POLL_MS); + await app.layer.update(); + app.settle(); + } + const key = 'mbta:bus-1'; + const [entry] = app.vehicles(); + const icon = () => + app.markers('still').get(key) ?? app.markers('moving').get(key); + assert.equal(icon()?.show, true, 'drawn before the hold'); + assert.equal(app.layer.setCockpitSubject(key), true); + // The view rides it for a while: frames, a sweep, a poll. + app.run(2_000, 16); + app.settle(); + app.run(TRANSIT_POLL_MS); + await app.layer.update(); + app.settle(); + assert.equal(entry.marker.show, false, 'its marker is hidden'); + assert.equal( + icon()?.show ?? false, + false, + 'and so is the icon the set draws', + ); + + assert.equal(app.layer.setCockpitSubject(null), true); + app.advance(250); + app.settle(); + assert.equal(icon()?.show, true, 'let go: drawn again'); +}); diff --git a/src/layers/transit/rendering.js b/src/layers/transit/rendering.js index 194d042a3e..8b0ecc1e8e 100644 --- a/src/layers/transit/rendering.js +++ b/src/layers/transit/rendering.js @@ -1225,6 +1225,7 @@ export function createRendering({ state, services, parts }) { setNameOf, markerShown, markDirty, + setShown, flushMarkers, removeMarker, watchCamera, From a7d966ae7e3d43fa9934d88de765bdbd37292445 Mon Sep 17 00:00:00 2001 From: German Khokhlov Date: Tue, 17 Nov 2026 19:30:47 +0400 Subject: [PATCH 2/8] Rail cockpit rides: no height on an unknown floor, a standing train keeps its direction - railHeightM is null while the train is drawn on the ellipsoid (floor quality 0) instead of -1.5 m, so a view waits for the surface. - An arc step between two reports tells which way a train runs only above 15 m, the layer's parked-train jitter (FOLLOW_MIN_MOVE_M). GPS jitter of a standing train no longer flips the direction through the playback segments, which turned a ride 180 degrees every poll. - drawDirection, a copy of direction, becomes a directionPlayed flag. --- src/layers/rail/cockpitSubject.js | 5 +- src/layers/rail/cockpitSubject.test.mjs | 24 ++++++++- src/layers/rail/pathBinding.js | 28 ++++++----- src/layers/rail/pathBinding.test.mjs | 65 ++++++++++++++++++++++++- 4 files changed, 105 insertions(+), 17 deletions(-) diff --git a/src/layers/rail/cockpitSubject.js b/src/layers/rail/cockpitSubject.js index 80cfc1daa6..286160d3aa 100644 --- a/src/layers/rail/cockpitSubject.js +++ b/src/layers/rail/cockpitSubject.js @@ -205,7 +205,10 @@ export function createRailCockpitSubject({ finiteOrNull(drawn?.lat) ?? finiteOrNull(sample?.lat) ?? record.lat; position.longitude = finiteOrNull(drawn?.lon) ?? finiteOrNull(sample?.lon) ?? record.lon; - position.railHeightM = Number.isFinite(drawn?.h) ? drawn.h - liftM : null; + // Quality 0 is the ellipsoid a train is drawn on while no floor is + // known: no height, so a view waits for the surface. + position.railHeightM = + Number.isFinite(drawn?.h) && drawn.q > 0 ? drawn.h - liftM : null; position.heightQuality = Number.isFinite(drawn?.q) ? drawn.q : 0; position.atMs = finiteOrNull(drawn?.at); diff --git a/src/layers/rail/cockpitSubject.test.mjs b/src/layers/rail/cockpitSubject.test.mjs index b439e1eecc..c8c764aad3 100644 --- a/src/layers/rail/cockpitSubject.test.mjs +++ b/src/layers/rail/cockpitSubject.test.mjs @@ -44,6 +44,13 @@ const PACK = Object.freeze({ routes: { R1: [0] }, }); +/** A floor service that knows the ground everywhere, at 12 m. */ +const WARM_GROUND = Object.freeze({ + GROUND_FLOOR_LIFT_M: 1.5, + cachedGroundFloor: () => 12, + warmGroundFloor() {}, +}); + /** Two trains on the line, T1 running east and T2 west, a step a poll. */ async function onTheLine(t, options = {}) { const app = harness(t, { @@ -76,7 +83,7 @@ const T1 = railTrainKey('mbta-rail', 'T1'); const T2 = railTrainKey('mbta-rail', 'T2'); test('the selected train reads as a snapshot of its place, motion and sources', async (t) => { - const app = await onTheLine(t); + const app = await onTheLine(t, { ground: WARM_GROUND }); assert.equal(app.layer.getSelectedTrain(), null, 'nothing selected'); app.parts().selection.selectTrain(T1); const view = app.layer.getSelectedTrain(); @@ -105,6 +112,7 @@ test('the selected train reads as a snapshot of its place, motion and sources', assert.equal(view.provenance.positionSource, 'gps'); assert.equal(view.provenance.timestampSource, 'vehicle'); const drawn = app.entry(T1).drawnHeight; + assert.ok(view.position.heightQuality > 0, 'on a known floor'); assert.equal(view.position.railHeightM, drawn.h - 1.5); assert.ok(Number.isFinite(view.position.latitude)); assert.ok(Array.isArray(view.stops)); @@ -129,6 +137,20 @@ const stopList = (...names) => state: 'upcoming', })); +test('a train drawn on an unknown floor reports no rail height', async (t) => { + // The harness's floor service is always cold: the train is drawn on the + // ellipsoid, which is no floor for a view to stand on. + const app = await onTheLine(t); + app.parts().selection.selectTrain(T1); + const view = app.layer.getSelectedTrain(); + assert.equal(view.position.heightQuality, 0, 'no floor is known'); + assert.equal( + view.position.railHeightM, + null, + 'an unknown floor is no height', + ); +}); + test('a snapshot read again while nothing changed is the one read before', async (t) => { let list = stopList('Alpha', 'Bravo', 'Charlie'); const app = await onTheLine(t, { diff --git a/src/layers/rail/pathBinding.js b/src/layers/rail/pathBinding.js index 9eba452d37..a432095b7a 100644 --- a/src/layers/rail/pathBinding.js +++ b/src/layers/rail/pathBinding.js @@ -47,8 +47,13 @@ export function pathWindowM(dtMs) { return window > PATH_WINDOW_MAX_M ? NaN : window; } -/** Arc moved between two reports before it says which way a train runs (m). */ -const DIRECTION_MIN_M = 1; +/** + * Arc moved between two reports before it says which way a train runs (m). + * A standing train's GPS jitter, a few metres back and forth, stays under it + * (the same parked-train jitter as FOLLOW_MIN_MOVE_M, policy.js) and keeps + * the direction learnt. + */ +const DIRECTION_MIN_M = 15; /** +1 or -1 for an arc step longer than DIRECTION_MIN_M, else `known`. */ function directionOf(step, known) { @@ -65,13 +70,13 @@ function createBinding(shapeIndex, path, via, s, fix) { /** * Which way the drawn train runs along the shape: +1 along it, -1 * against it, 0 until two reports or a playback segment tell. Kept until - * a rebind. Once playback has placed the train, only playback changes - * it: the newest reports run ahead of the drawn train, so a reversal - * they show turns it when playback reaches it. + * a rebind, and while the train stands. Once a playback segment has told + * it (`directionPlayed`), only playback changes it: the newest reports + * run ahead of the drawn train, so a reversal they show turns it when + * playback reaches it. */ direction: 0, - /** The direction the last placed playback segment ran, 0 before one. */ - drawDirection: 0, + directionPlayed: false, /** Arc and time of the newest report. */ fixS: s, fixT: fix.t, @@ -159,7 +164,7 @@ export function followFix(binding, fix) { pathWindowM(fix.t - binding.fixT), ); if (!hit || hit.offsetM > PATH_OFF_TRACK_M) return false; - if (!binding.drawDirection) + if (!binding.directionPlayed) binding.direction = directionOf(hit.s - binding.fixS, binding.direction); binding.fixS = hit.s; binding.fixT = fix.t; @@ -253,11 +258,8 @@ export function placeOnPath(binding, sample, segment, out) { cache.sTo = sTo; cache.ok = Number.isFinite(sFrom) && Number.isFinite(sTo); if (cache.ok) { - binding.drawDirection = directionOf( - sTo - sFrom, - binding.drawDirection || binding.direction || 0, - ); - binding.direction = binding.drawDirection; + binding.direction = directionOf(sTo - sFrom, binding.direction); + if (binding.direction) binding.directionPlayed = true; } } if (!cache.ok) return false; diff --git a/src/layers/rail/pathBinding.test.mjs b/src/layers/rail/pathBinding.test.mjs index 7b9e11c0cc..e257fb86da 100644 --- a/src/layers/rail/pathBinding.test.mjs +++ b/src/layers/rail/pathBinding.test.mjs @@ -209,8 +209,9 @@ test('a binding learns which way its train runs, and keeps it through a stop', ( assert.equal(along.direction, 0, 'one report tells no direction'); assert.ok(followFix(along, fix(10_000, 700, 0))); assert.equal(along.direction, 1); - // Standing still (under a metre) keeps what it learnt. - assert.ok(followFix(along, fix(20_000, 700.4, 0))); + // Standing at a stop, its reports jitter back a few metres: it keeps what + // it learnt. + assert.ok(followFix(along, fix(20_000, 690, 0))); assert.equal(along.direction, 1); const against = bindTrainPath(p, ids, fix(0, 1500, 0)); assert.ok(followFix(against, fix(10_000, 1200, 0))); @@ -262,3 +263,63 @@ test('a report that runs back turns the drawn train only when playback does', () ); assert.equal(binding.direction, -1); }); + +test('jitter segments played back at a standing train keep the direction it learnt', () => { + const p = pack(); + const ids = { tripId: 'full', routeId: 'main' }; + const binding = bindTrainPath(p, ids, fix(0, 1000, 0)); + assert.ok(followFix(binding, fix(15_000, 1600, 0))); + // Playback runs the train east, 1000 m -> 1600 m: direction +1. + const out = {}; + let seq = 0; + const play = (fromM, toM, t0) => { + const segment = { + from: { seq, ...fix(t0, fromM, 0) }, + to: { seq: seq + 1, ...fix(t0 + 15_000, toM, 0) }, + }; + assert.ok( + placeOnPath( + binding, + { fromSeq: seq, toSeq: seq + 1, fraction: 0.5 }, + segment, + out, + ), + ); + seq += 1; + return binding.direction; + }; + assert.equal(play(1000, 1600, 0), 1); + assert.equal( + binding.directionPlayed, + true, + 'playback owns the direction now', + ); + // At the platform: reports 3-5 m apart, back and forth, polled and played. + const learnt = []; + let t0 = 15_000; + for (const [fromM, toM] of [ + [1600, 1597], + [1597, 1600], + [1600, 1596], + [1596, 1601], + ]) { + assert.ok(followFix(binding, fix(t0 + 15_000, toM, 0))); + learnt.push(play(fromM, toM, t0)); + t0 += 15_000; + } + assert.deepEqual(learnt, [1, 1, 1, 1], 'from the played-back segments'); +}); + +test('GPS jitter in the newest reports before playback keeps the direction', () => { + const p = pack(); + const ids = { tripId: 'full', routeId: 'main' }; + const binding = bindTrainPath(p, ids, fix(0, 1000, 0)); + assert.ok(followFix(binding, fix(15_000, 1600, 0))); + assert.equal(binding.direction, 1); + const learnt = []; + [1597, 1600, 1596, 1601].forEach((eastM, i) => { + assert.ok(followFix(binding, fix(30_000 + i * 15_000, eastM, 0))); + learnt.push(binding.direction); + }); + assert.deepEqual(learnt, [1, 1, 1, 1], 'from the newest reports'); +}); From ec9d5c9e060647d3781fe2eb7ce839d5d6d5da34 Mon Sep 17 00:00:00 2001 From: German Khokhlov Date: Tue, 17 Nov 2026 19:30:47 +0400 Subject: [PATCH 3/8] Describe the cockpit ride fixes and add their changelog entry --- changelog.d/0000-cockpit-ride-transit-rail.md | 8 ++++++++ docs/CURRENT-STATE.md | 19 ++++++++++++------- 2 files changed, 20 insertions(+), 7 deletions(-) create mode 100644 changelog.d/0000-cockpit-ride-transit-rail.md diff --git a/changelog.d/0000-cockpit-ride-transit-rail.md b/changelog.d/0000-cockpit-ride-transit-rail.md new file mode 100644 index 0000000000..284b570388 --- /dev/null +++ b/changelog.d/0000-cockpit-ride-transit-rail.md @@ -0,0 +1,8 @@ +- Fix rides on a Rail train or Transit vehicle for an application's Cockpit + subjects. A held parked vehicle no longer leaves its icon drawn under the + view, and turning Transit off ends a hold, so the vehicle shows again when + the layer is back on. A train or vehicle drawn on the ellipsoid while no + floor is known reports no height, so the view waits for the ground instead + of standing on the ellipsoid. A train standing at a platform keeps the way + it runs: GPS jitter of a few metres no longer turns the ride around + (German, @gekh, #0000). diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index 4a5d97da6e..f2a437aea0 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -2768,8 +2768,9 @@ HUD view is. The Rail layer offers a read API for such a view: `getSelectedTrain()` and `getCockpitSubject()` (a snapshot of the train: where it is along its line, -which way it runs (`pathBinding.js` learns it), its rail height, speed as -reported or derived, position source, feed credit and stops, and +which way it runs (`pathBinding.js` learns it), its rail height (null while +no floor is known and it is drawn on the ellipsoid), speed as reported or +derived, position source, feed credit and stops, and `selectedAtMs`, when the user last selected it by a click or `focusTrain`, even again; null after a deselection and for a train only a hold selected), `setCockpitSubject(key)` (its marker, 3D model and card hidden, the selection kept, its @@ -2784,11 +2785,15 @@ offers the same for a vehicle (`getSelectedVehicle`, `getCockpitSubject`, `setCockpitSubject`, `focusVehicle`): a held vehicle keeps playing when it is out of the camera's view, and its sprite, 3D model, card, trail and detection box are hidden; released, it is out of play until a visibility sweep finds it in -view. Its snapshot's `position.groundHeightM` is the floor where playback draws -it (the drawn marker's height while it is placed, else its segment's two -reports' floors at the playback fraction), not the newest report's, and null while that floor is unknown. Rail's `path.direction` is the -way the drawn train runs: once playback has placed it, a report that runs back -turns it only when playback reaches that report. `docs/APPLICATION.md` (Cockpit subjects) shows a minimal provider. `src/ui/cockpitSubjectView.test.mjs`, +view. Turning the layer off ends the hold. Its snapshot's +`position.groundHeightM` is the floor where playback draws it (the drawn +marker's height while it is placed, else its segment's two reports' floors at +the playback fraction), not the newest report's, and null while that floor is +unknown, also far above the ground, where such a vehicle is drawn on the +ellipsoid. Rail's `path.direction` is the way the drawn train runs: once +playback has placed it, a report that runs back turns it only when playback +reaches that report, and a step of at most 15 m between two reports (a standing +train's GPS jitter) keeps the direction it had. `docs/APPLICATION.md` (Cockpit subjects) shows a minimal provider. `src/ui/cockpitSubjectView.test.mjs`, `src/cockpitSubjectProviders.test.mjs`, `src/cockpitProgress.test.mjs`, `src/layers/rail/cockpitSubject.test.mjs` and the Transit lifecycle tests cover them. From ebf2686e2f19009434a5c15f7a2aa22515fcda63 Mon Sep 17 00:00:00 2001 From: German Khokhlov Date: Wed, 18 Nov 2026 00:51:07 +0400 Subject: [PATCH 4/8] Number the changelog fragment for #1786 --- ...t-ride-transit-rail.md => 1786-cockpit-ride-transit-rail.md} | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) rename changelog.d/{0000-cockpit-ride-transit-rail.md => 1786-cockpit-ride-transit-rail.md} (95%) diff --git a/changelog.d/0000-cockpit-ride-transit-rail.md b/changelog.d/1786-cockpit-ride-transit-rail.md similarity index 95% rename from changelog.d/0000-cockpit-ride-transit-rail.md rename to changelog.d/1786-cockpit-ride-transit-rail.md index 284b570388..4e29e30d74 100644 --- a/changelog.d/0000-cockpit-ride-transit-rail.md +++ b/changelog.d/1786-cockpit-ride-transit-rail.md @@ -5,4 +5,4 @@ floor is known reports no height, so the view waits for the ground instead of standing on the ellipsoid. A train standing at a platform keeps the way it runs: GPS jitter of a few metres no longer turns the ride around - (German, @gekh, #0000). + (German, @gekh, #1786). From ee5a6ab317deb49e88181b331642417aa3992684 Mon Sep 17 00:00:00 2001 From: German Khokhlov Date: Wed, 18 Nov 2026 14:32:36 +0400 Subject: [PATCH 5/8] Turn a train that backs away steadily, however small each step The direction now follows how far a train has come back from the farthest point it reached, so a slow reversal of under 15 m per report still turns it, while GPS jitter around one spot does not. Rail policy takes the 15 m figure from pathBinding instead of repeating it. --- docs/CURRENT-STATE.md | 5 ++- src/layers/rail/pathBinding.js | 46 +++++++++++++++------ src/layers/rail/pathBinding.test.mjs | 61 ++++++++++++++++++++++++++++ src/layers/rail/policy.js | 3 +- 4 files changed, 100 insertions(+), 15 deletions(-) diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index f2a437aea0..95b73b39ec 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -2792,8 +2792,9 @@ the playback fraction), not the newest report's, and null while that floor is unknown, also far above the ground, where such a vehicle is drawn on the ellipsoid. Rail's `path.direction` is the way the drawn train runs: once playback has placed it, a report that runs back turns it only when playback -reaches that report, and a step of at most 15 m between two reports (a standing -train's GPS jitter) keeps the direction it had. `docs/APPLICATION.md` (Cockpit subjects) shows a minimal provider. `src/ui/cockpitSubjectView.test.mjs`, +reaches that report. A train turns once it is 15 m back from the farthest point +it reached, however slowly it backs, so a standing train's GPS jitter keeps the +direction it had. `docs/APPLICATION.md` (Cockpit subjects) shows a minimal provider. `src/ui/cockpitSubjectView.test.mjs`, `src/cockpitSubjectProviders.test.mjs`, `src/cockpitProgress.test.mjs`, `src/layers/rail/cockpitSubject.test.mjs` and the Transit lifecycle tests cover them. diff --git a/src/layers/rail/pathBinding.js b/src/layers/rail/pathBinding.js index a432095b7a..4afe9b7872 100644 --- a/src/layers/rail/pathBinding.js +++ b/src/layers/rail/pathBinding.js @@ -48,18 +48,35 @@ export function pathWindowM(dtMs) { } /** - * Arc moved between two reports before it says which way a train runs (m). - * A standing train's GPS jitter, a few metres back and forth, stays under it - * (the same parked-train jitter as FOLLOW_MIN_MOVE_M, policy.js) and keeps - * the direction learnt. + * Arc a train must move before that says which way it runs (m): a standing + * train's GPS jitter, back and forth, stays within it. */ -const DIRECTION_MIN_M = 15; +export const DIRECTION_MIN_M = 15; -/** +1 or -1 for an arc step longer than DIRECTION_MIN_M, else `known`. */ -function directionOf(step, known) { - return Number.isFinite(step) && Math.abs(step) > DIRECTION_MIN_M - ? Math.sign(step) - : known; +/** + * Track one more arc position of a train. `turn.s` is the farthest arc it + * has reached the way it runs (where it was first seen while that is + * unknown); it turns once it is DIRECTION_MIN_M or more back from there, + * however small each step. + * @param {number} direction +1, -1 or 0. + * @param {{s: number}} turn Updated in place. + * @param {number} s + * @returns {number} The direction now. + */ +function steer(direction, turn, s) { + if (!Number.isFinite(s)) return direction; + if (!Number.isFinite(turn.s)) { + turn.s = s; + return direction; + } + const step = s - turn.s; + if (direction && step * direction >= 0) { + turn.s = s; + return direction; + } + if (Math.abs(step) < DIRECTION_MIN_M) return direction; + turn.s = s; + return Math.sign(step); } function createBinding(shapeIndex, path, via, s, fix) { @@ -77,6 +94,9 @@ function createBinding(shapeIndex, path, via, s, fix) { */ direction: 0, directionPlayed: false, + /** How far the reports and the played segments have run (steer). */ + reportTurn: { s }, + playTurn: { s: NaN }, /** Arc and time of the newest report. */ fixS: s, fixT: fix.t, @@ -165,7 +185,7 @@ export function followFix(binding, fix) { ); if (!hit || hit.offsetM > PATH_OFF_TRACK_M) return false; if (!binding.directionPlayed) - binding.direction = directionOf(hit.s - binding.fixS, binding.direction); + binding.direction = steer(binding.direction, binding.reportTurn, hit.s); binding.fixS = hit.s; binding.fixT = fix.t; binding.fixLat = fix.lat; @@ -258,7 +278,9 @@ export function placeOnPath(binding, sample, segment, out) { cache.sTo = sTo; cache.ok = Number.isFinite(sFrom) && Number.isFinite(sTo); if (cache.ok) { - binding.direction = directionOf(sTo - sFrom, binding.direction); + const turn = binding.playTurn; + binding.direction = steer(binding.direction, turn, sFrom); + binding.direction = steer(binding.direction, turn, sTo); if (binding.direction) binding.directionPlayed = true; } } diff --git a/src/layers/rail/pathBinding.test.mjs b/src/layers/rail/pathBinding.test.mjs index e257fb86da..2e01da82c9 100644 --- a/src/layers/rail/pathBinding.test.mjs +++ b/src/layers/rail/pathBinding.test.mjs @@ -323,3 +323,64 @@ test('GPS jitter in the newest reports before playback keeps the direction', () }); assert.deepEqual(learnt, [1, 1, 1, 1], 'from the newest reports'); }); + +/** The direction after each played segment, `[fromM, toM]` 15 s apart. */ +function playDirections(binding, steps) { + return steps.map(([fromM, toM], seq) => { + const { sample, segment } = playback( + seq, + seq + 1, + fix(seq * 15_000, fromM, 0), + fix((seq + 1) * 15_000, toM, 0), + 0.5, + ); + assert.ok(placeOnPath(binding, sample, segment, {})); + return binding.direction; + }); +} + +test('a train that moves under 15 m a report still tells its direction', () => { + const p = pack(); + const ids = { tripId: 'full', routeId: 'main' }; + // It sets off slowly, runs east, then backs out 10 m a report. + const reports = bindTrainPath(p, ids, fix(0, 1000, 0)); + const learnt = [1010, 1020, 1600, 1590, 1580, 1570].map((eastM, i) => { + assert.ok(followFix(reports, fix((i + 1) * 15_000, eastM, 0))); + return reports.direction; + }); + assert.deepEqual(learnt, [0, 1, 1, 1, -1, -1], 'from the newest reports'); + const played = bindTrainPath(p, ids, fix(0, 1000, 0)); + assert.deepEqual( + playDirections(played, [ + [1000, 1600], + [1600, 1590], + [1590, 1580], + [1580, 1570], + ]), + [1, 1, -1, -1], + 'from the played-back segments', + ); +}); + +test('GPS jitter of up to 14 m at a standing train keeps its direction', () => { + const p = pack(); + const ids = { tripId: 'full', routeId: 'main' }; + const reports = bindTrainPath(p, ids, fix(0, 1000, 0)); + const learnt = [1600, 1588, 1600, 1586, 1599, 1587].map((eastM, i) => { + assert.ok(followFix(reports, fix((i + 1) * 15_000, eastM, 0))); + return reports.direction; + }); + assert.deepEqual(learnt, [1, 1, 1, 1, 1, 1], 'from the newest reports'); + const played = bindTrainPath(p, ids, fix(0, 1000, 0)); + assert.deepEqual( + playDirections(played, [ + [1000, 1600], + [1600, 1588], + [1588, 1600], + [1600, 1586], + [1586, 1599], + ]), + [1, 1, 1, 1, 1], + 'from the played-back segments', + ); +}); diff --git a/src/layers/rail/policy.js b/src/layers/rail/policy.js index ecb3121760..57d8598459 100644 --- a/src/layers/rail/policy.js +++ b/src/layers/rail/policy.js @@ -16,6 +16,7 @@ import { import { displayMotion } from '../transit/movement.js'; import { FIX_FLAGS, readFix } from '../../data/contactPlayback.js'; import { roundHeadingDegrees } from '../../data/headingDegrees.js'; +import { DIRECTION_MIN_M } from './pathBinding.js'; import { stopClock, stopLateMinutes, @@ -295,7 +296,7 @@ export function playbackModeFor(railMode) { } /** Two reports closer than this are one place: a parked train's jitter (m). */ -export const FOLLOW_MIN_MOVE_M = 15; +export const FOLLOW_MIN_MOVE_M = DIRECTION_MIN_M; const lastFix = {}; const priorFix = {}; From df4d76384c4715801ac4f99a6a538d0fa85b4f9c Mon Sep 17 00:00:00 2001 From: German Khokhlov Date: Wed, 18 Nov 2026 15:07:06 +0400 Subject: [PATCH 6/8] Tidy the Rail and Transit ride fixes after review - A train first seen standing takes its direction from the operator's course, not from a course drawn out of GPS jitter. - Moving a hold to another vehicle releases the first one the same way as ending the hold. - repaint always goes through placeSample, which hides the held vehicle and puts it on its current segment, so setShown is no longer exported. - Tests cover the icon right after a hold, a segment with one known floor, a known floor at 0 m and selection by click after the layer comes back; shared helpers replace repeated setup. - Comments, CURRENT-STATE and the release note say what the code does without internal figures. --- changelog.d/1786-cockpit-ride-transit-rail.md | 11 +- docs/CURRENT-STATE.md | 20 +-- src/layers/rail/cockpitSubject.js | 17 +- src/layers/rail/cockpitSubject.test.mjs | 33 ++++ src/layers/rail/pathBinding.test.mjs | 37 ++--- src/layers/transit/cockpitSubject.js | 34 ++-- src/layers/transit/lifecycle.test.mjs | 146 +++++++++++++++--- src/layers/transit/rendering.js | 1 - 8 files changed, 209 insertions(+), 90 deletions(-) diff --git a/changelog.d/1786-cockpit-ride-transit-rail.md b/changelog.d/1786-cockpit-ride-transit-rail.md index 4e29e30d74..995e0b491e 100644 --- a/changelog.d/1786-cockpit-ride-transit-rail.md +++ b/changelog.d/1786-cockpit-ride-transit-rail.md @@ -1,8 +1,5 @@ -- Fix rides on a Rail train or Transit vehicle for an application's Cockpit - subjects. A held parked vehicle no longer leaves its icon drawn under the - view, and turning Transit off ends a hold, so the vehicle shows again when - the layer is back on. A train or vehicle drawn on the ellipsoid while no - floor is known reports no height, so the view waits for the ground instead - of standing on the ellipsoid. A train standing at a platform keeps the way - it runs: GPS jitter of a few metres no longer turns the ride around +- Fix application Cockpit rides on Rail trains and Transit vehicles: a held + parked vehicle no longer leaves its icon under the view, turning Transit off + ends a hold, a view waits for the ground instead of standing on the + ellipsoid, and GPS jitter at a platform no longer turns a ride around (German, @gekh, #1786). diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index 95b73b39ec..d83e762add 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -2769,7 +2769,7 @@ HUD view is. The Rail layer offers a read API for such a view: `getSelectedTrain()` and `getCockpitSubject()` (a snapshot of the train: where it is along its line, which way it runs (`pathBinding.js` learns it), its rail height (null while -no floor is known and it is drawn on the ellipsoid), speed as reported or +no floor is known), speed as reported or derived, position source, feed credit and stops, and `selectedAtMs`, when the user last selected it by a click or `focusTrain`, even again; null after a deselection and for a train only a hold selected), @@ -2789,15 +2789,17 @@ view. Turning the layer off ends the hold. Its snapshot's `position.groundHeightM` is the floor where playback draws it (the drawn marker's height while it is placed, else its segment's two reports' floors at the playback fraction), not the newest report's, and null while that floor is -unknown, also far above the ground, where such a vehicle is drawn on the -ellipsoid. Rail's `path.direction` is the way the drawn train runs: once -playback has placed it, a report that runs back turns it only when playback -reaches that report. A train turns once it is 15 m back from the farthest point -it reached, however slowly it backs, so a standing train's GPS jitter keeps the -direction it had. `docs/APPLICATION.md` (Cockpit subjects) shows a minimal provider. `src/ui/cockpitSubjectView.test.mjs`, +unknown, also while the camera is too high for the layer to sample the ground +and such a vehicle is drawn on the ellipsoid. Rail's `path.direction` is the +way the drawn train runs: once playback has placed it, a report that runs back +turns it only when playback starts the segment to that report. A train turns +once it has backed away from the farthest point it reached by more than a +standing train's GPS jitter, however slowly it backs, so that jitter keeps the +direction it had. `docs/APPLICATION.md` (Cockpit subjects) shows a minimal +provider. `src/ui/cockpitSubjectView.test.mjs`, `src/cockpitSubjectProviders.test.mjs`, `src/cockpitProgress.test.mjs`, -`src/layers/rail/cockpitSubject.test.mjs` and the Transit lifecycle tests -cover them. +`src/layers/rail/cockpitSubject.test.mjs`, `src/layers/rail/pathBinding.test.mjs` +and the Transit lifecycle tests cover them. ## Context coordination diff --git a/src/layers/rail/cockpitSubject.js b/src/layers/rail/cockpitSubject.js index 286160d3aa..1d9c02cb39 100644 --- a/src/layers/rail/cockpitSubject.js +++ b/src/layers/rail/cockpitSubject.js @@ -173,14 +173,16 @@ export function createRailCockpitSubject({ /** * Which way the train runs along its shape: as its binding learnt it from - * successive reports, else from its drawn course against the line's - * bearing there; 0 while neither tells. + * successive reports, else from its reported bearing against the line's + * bearing there; 0 while neither tells. Not the drawn course: until the + * binding tells, the train has not moved past GPS jitter, and a course + * drawn between such reports is that jitter. */ function directionOf(entry) { const binding = entry.path; if (binding.direction === 1 || binding.direction === -1) return binding.direction; - const course = finiteOrNull(entry.courseDeg); + const course = finiteOrNull(entry.record?.bearing); const point = pointAtS(binding.path, binding.drawS, scratch); if (course === null || !Number.isFinite(point?.bearingDeg)) return 0; const turn = Math.abs(((course - point.bearingDeg + 540) % 360) - 180); @@ -205,11 +207,12 @@ export function createRailCockpitSubject({ finiteOrNull(drawn?.lat) ?? finiteOrNull(sample?.lat) ?? record.lat; position.longitude = finiteOrNull(drawn?.lon) ?? finiteOrNull(sample?.lon) ?? record.lon; - // Quality 0 is the ellipsoid a train is drawn on while no floor is - // known: no height, so a view waits for the surface. + const quality = Number.isFinite(drawn?.q) ? drawn.q : 0; + // Quality 0: no floor known here, so no height; a view waits for the + // surface. position.railHeightM = - Number.isFinite(drawn?.h) && drawn.q > 0 ? drawn.h - liftM : null; - position.heightQuality = Number.isFinite(drawn?.q) ? drawn.q : 0; + quality > 0 && Number.isFinite(drawn.h) ? drawn.h - liftM : null; + position.heightQuality = quality; position.atMs = finiteOrNull(drawn?.at); let path = null; diff --git a/src/layers/rail/cockpitSubject.test.mjs b/src/layers/rail/cockpitSubject.test.mjs index c8c764aad3..08bf66d15c 100644 --- a/src/layers/rail/cockpitSubject.test.mjs +++ b/src/layers/rail/cockpitSubject.test.mjs @@ -151,6 +151,39 @@ test('a train drawn on an unknown floor reports no rail height', async (t) => { ); }); +test('a train on a known floor at sea level reports a rail height of 0 m', async (t) => { + const app = await onTheLine(t, { + ground: { ...WARM_GROUND, cachedGroundFloor: () => 0 }, + }); + app.parts().selection.selectTrain(T1); + const { position } = app.layer.getSelectedTrain(); + assert.ok(position.heightQuality > 0, 'the floor is known'); + assert.equal(position.railHeightM, 0, 'a height, not none'); +}); + +test('a train first seen standing takes no direction from its GPS jitter', async (t) => { + // Neither reports 13 m apart nor the course drawn between them say which way + // it runs; an operator's bearing does. + const app = harness(t, { paths: { 'mbta-rail': PACK }, at: BOSTON }); + let jitterM = 0; + app.feeds.set('mbta-rail', () => [ + train('T1', LAT, LON0 + (1000 + jitterM) / KX), + train('T2', LAT, LON0 + (3000 + jitterM) / KX, { bearing: 270 }), + ]); + await app.enable(); + const seen = []; + for (const next of [13, 0, 13, 0, 13, 0]) { + jitterM = next; + app.run(RAIL_POLL_MS); + await app.poll(); + app.parts().selection.selectTrain(T1); + const standing = app.layer.getSelectedTrain().path.direction; + app.parts().selection.selectTrain(T2); + seen.push([standing, app.layer.getSelectedTrain().path.direction]); + } + assert.deepEqual(seen, Array(6).fill([0, -1])); +}); + test('a snapshot read again while nothing changed is the one read before', async (t) => { let list = stopList('Alpha', 'Bravo', 'Charlie'); const app = await onTheLine(t, { diff --git a/src/layers/rail/pathBinding.test.mjs b/src/layers/rail/pathBinding.test.mjs index 2e01da82c9..6dcc9fab99 100644 --- a/src/layers/rail/pathBinding.test.mjs +++ b/src/layers/rail/pathBinding.test.mjs @@ -209,8 +209,8 @@ test('a binding learns which way its train runs, and keeps it through a stop', ( assert.equal(along.direction, 0, 'one report tells no direction'); assert.ok(followFix(along, fix(10_000, 700, 0))); assert.equal(along.direction, 1); - // Standing at a stop, its reports jitter back a few metres: it keeps what - // it learnt. + // Standing at a stop, its reports jitter back 10 m: it keeps what it + // learnt. assert.ok(followFix(along, fix(20_000, 690, 0))); assert.equal(along.direction, 1); const against = bindTrainPath(p, ids, fix(0, 1500, 0)); @@ -269,33 +269,22 @@ test('jitter segments played back at a standing train keep the direction it lear const ids = { tripId: 'full', routeId: 'main' }; const binding = bindTrainPath(p, ids, fix(0, 1000, 0)); assert.ok(followFix(binding, fix(15_000, 1600, 0))); - // Playback runs the train east, 1000 m -> 1600 m: direction +1. - const out = {}; let seq = 0; const play = (fromM, toM, t0) => { - const segment = { - from: { seq, ...fix(t0, fromM, 0) }, - to: { seq: seq + 1, ...fix(t0 + 15_000, toM, 0) }, - }; - assert.ok( - placeOnPath( - binding, - { fromSeq: seq, toSeq: seq + 1, fraction: 0.5 }, - segment, - out, - ), + const { sample, segment } = playback( + seq, + seq + 1, + fix(t0, fromM, 0), + fix(t0 + 15_000, toM, 0), + 0.5, ); + assert.ok(placeOnPath(binding, sample, segment, {})); seq += 1; return binding.direction; }; - assert.equal(play(1000, 1600, 0), 1); - assert.equal( - binding.directionPlayed, - true, - 'playback owns the direction now', - ); - // At the platform: reports 3-5 m apart, back and forth, polled and played. - const learnt = []; + // It runs east, then stands at the platform: reports 3-5 m apart, back and + // forth, polled and played. + const learnt = [play(1000, 1600, 0)]; let t0 = 15_000; for (const [fromM, toM] of [ [1600, 1597], @@ -307,7 +296,7 @@ test('jitter segments played back at a standing train keep the direction it lear learnt.push(play(fromM, toM, t0)); t0 += 15_000; } - assert.deepEqual(learnt, [1, 1, 1, 1], 'from the played-back segments'); + assert.deepEqual(learnt, [1, 1, 1, 1, 1], 'from the played-back segments'); }); test('GPS jitter in the newest reports before playback keeps the direction', () => { diff --git a/src/layers/transit/cockpitSubject.js b/src/layers/transit/cockpitSubject.js index e135835a95..ff31f0722f 100644 --- a/src/layers/transit/cockpitSubject.js +++ b/src/layers/transit/cockpitSubject.js @@ -84,9 +84,10 @@ export function createTransitCockpitSubject({ state, parts, services }) { * or held), which near the ground follows the terrain between reports; * else its segment's two reports' floors at the playback fraction. Null * while either floor is unknown, as on cold terrain, so a view waits for - * the surface: far above the ground such a marker is drawn on the - * ellipsoid, which is no floor. Not `entry.heightM`, the floor at the - * newest report, which playback has not reached yet. + * the surface: with the camera above HEIGHT_SAMPLE_MAX_ALTITUDE_M such a + * marker is drawn on the ellipsoid, which is no floor. Not + * `entry.heightM`, the floor at the newest report, which playback has not + * reached yet. */ function drawnFloorOf(entry) { const segment = entry.segment; @@ -175,21 +176,26 @@ export function createTransitCockpitSubject({ state, parts, services }) { } /** - * Show or hide a vehicle's sprite and trail for the hold. The sprite goes - * through the renderer (setShown, flushMarkers): its set draws a marker - * only as last pushed. + * Place a vehicle and show or hide its sprite and trail for the hold now: + * the icon set draws a marker as it was last pushed, not as it is. */ function repaint(entry) { if (!entry?.marker) return; - if (entry.key === state._cockpitSubjectKey) - parts.rendering.setShown(entry, false); - else parts.rendering.placeSample(entry); + parts.rendering.placeSample(entry); parts.rendering.flushMarkers(); parts.rendering.schedulePlayback(entry); parts.trails.update(); state._detectRevision += 1; } + /** A vehicle let go of is out of play until a sweep finds it in view. */ + function release(entry) { + if (!entry) return; + state._visible.delete(entry); + parts.rendering.requestVisibility(); + repaint(entry); + } + const methods = { /** The selected vehicle (see createTransitCockpitSubject), or null. */ getSelectedVehicle() { @@ -209,13 +215,7 @@ export function createTransitCockpitSubject({ state, parts, services }) { const previous = state._vehicles.get(state._cockpitSubjectKey); if (key === null || key === undefined) { state._cockpitSubjectKey = null; - // The hold kept it in play out of view: it leaves until the next - // visibility sweep finds it in view again. - if (previous) { - state._visible.delete(previous); - parts.rendering.requestVisibility(); - } - repaint(previous); + release(previous); parts.selection.refreshSelectedCard(true); return true; } @@ -224,7 +224,7 @@ export function createTransitCockpitSubject({ state, parts, services }) { if (state._selectedKey !== key) parts.selection.selectVehicle(key); state._cockpitSubjectKey = key; state._visible.add(entry); - if (previous && previous !== entry) repaint(previous); + if (previous !== entry) release(previous); repaint(entry); parts.selection.refreshSelectedCard(true); return true; diff --git a/src/layers/transit/lifecycle.test.mjs b/src/layers/transit/lifecycle.test.mjs index 3fcfa3f9ea..4c2e217073 100644 --- a/src/layers/transit/lifecycle.test.mjs +++ b/src/layers/transit/lifecycle.test.mjs @@ -957,45 +957,36 @@ test('disable aborts in-flight work and a response that lands late is ignored', assert.equal(app.vehicles().length, 1); }); -test('a held vehicle with no floor yet tells its view no height', async (t) => { - // Not the ellipsoid: a first-person view waits for the surface instead. - const app = harness(t, { floorAt: () => undefined }); +/** A bus at `place.lat`, read on each poll, polled once and settled; its entry. */ +async function oneBus(app, place = { lat: 42.36 }) { app.serve('mbta', () => ({ status: 200, body: snapshot( 'mbta', 'MBTA', - [vehicle('bus-1', 42.36, -71.06, Date.now() / 1000)], + [vehicle('bus-1', place.lat, -71.06, reported())], { fetchedAt: Date.now() }, ), })); app.layer.enable(app.viewer); await app.layer.update(); app.settle(); - const entry = app.vehicles()[0]; + return app.vehicles()[0]; +} + +test('a held vehicle with no floor yet tells its view no height', async (t) => { + // Not the ellipsoid: a first-person view waits for the surface instead. + const app = harness(t, { floorAt: () => undefined }); + const entry = await oneBus(app); assert.equal(entry.heightPending, true, 'it has nothing to stand on'); assert.ok(app.layer.setCockpitSubject(entry.key) !== false); assert.equal(app.layer.getCockpitSubject().position.groundHeightM, null); }); -test('far above the ground, a held vehicle drawn on the ellipsoid tells its view no height', async (t) => { - // Above the height gate a vehicle with no floor is drawn on the ellipsoid - // at once, not held back; the ellipsoid is still no floor to stand a view - // on. +test('with the camera above the height gate, a held vehicle drawn on the ellipsoid tells its view no height', async (t) => { + // There a vehicle with no floor is drawn on the ellipsoid, which is no floor. const app = harness(t, { altitude: 100_000, floorAt: () => undefined }); - app.serve('mbta', () => ({ - status: 200, - body: snapshot( - 'mbta', - 'MBTA', - [vehicle('bus-1', 42.36, -71.06, Date.now() / 1000)], - { fetchedAt: Date.now() }, - ), - })); - app.layer.enable(app.viewer); - await app.layer.update(); - app.settle(); - const [entry] = app.vehicles(); + const entry = await oneBus(app); assert.ok(app.layer.setCockpitSubject(entry.key) !== false); app.frame(); assert.equal(entry.surfaceReady, true, 'it is drawn'); @@ -1006,6 +997,28 @@ test('far above the ground, a held vehicle drawn on the ellipsoid tells its view assert.equal(app.layer.getCockpitSubject().position.groundHeightM, null); }); +test('with the camera above the height gate, a held vehicle with one floor unknown tells its view no height', async (t) => { + // Drawn between a floor its view could stand on and none. + for (const knownLat of [42.36, 42.361]) { + await t.test(`floor known at ${knownLat}`, async (t) => { + const app = harness(t, { altitude: 100_000, floorAt: () => undefined }); + app.ground._warm.set(app.ground._key(knownLat, -71.06), 12); + const start = Date.now(); + const place = { lat: 42.36 }; + const entry = await oneBus(app, place); + place.lat = 42.361; + app.run(TRANSIT_POLL_MS); + await app.layer.update(); + assert.equal(app.layer.setCockpitSubject(entry.key), true); + app.run(start - AGE_MS + LAG_MS + TRANSIT_POLL_MS / 2 - Date.now()); + const { from, to } = entry.segment; + assert.notEqual(Number.isFinite(from.h), Number.isFinite(to.h)); + assert.equal(entry.surfaceReady, true, 'it is drawn'); + assert.equal(app.layer.getCockpitSubject().position.groundHeightM, null); + }); + } +}); + test('a vehicle waits for its floor rather than standing on the ellipsoid', async (t) => { // The shared ground-floor system answers from the rendered mesh cell or the // real DEM cell; until one of them is warm there is no honest height to draw @@ -2146,7 +2159,8 @@ test('a segment climbs from the ground it left to the ground it reaches', async `its snapshot stands where it is drawn, got ${floor().toFixed(1)} m`, ); - // Halfway along the segment it is halfway up; at the end, on the high ground. + // Halfway along the segment it still follows the low ground it crosses; at + // the end, it is on the high ground. const firstFixAt = start - AGE_MS; app.run(firstFixAt + LAG_MS + TRANSIT_POLL_MS / 2 - Date.now()); assert.ok( @@ -4914,7 +4928,7 @@ test('a held vehicle hides, keeps moving out of view, and lets go when it goes', assert.equal(app.layer.getCockpitSubject(), null); }); -test('turning Transit off ends a hold; on again, Escape deselects and the vehicle shows', async (t) => { +test('turning Transit off ends a hold; on again, the vehicle shows and clicks and Escape select it', async (t) => { const app = harness(t); const key = await busRunningNorth(app); assert.equal(app.layer.setCockpitSubject(key), true); @@ -4931,10 +4945,12 @@ test('turning Transit off ends a hold; on again, Escape deselects and the vehicl app.run(TRANSIT_POLL_MS); await app.layer.update(); app.settle(); - assert.equal(app.layer.focusVehicle(key), true); const [entry] = app.vehicles(); app.frame(); assert.equal(entry.marker.show, true, 'the vehicle is drawn, not held'); + app.viewer.scene.pick = () => app.pickOf(entry); + app.input.click(new Cesium.Cartesian2(500, 400)); + assert.equal(app.state()._selectedKey, key, 'a click selects it'); globalThis.document.dispatchEvent( Object.assign(new Event('keydown'), { key: 'Escape' }), ); @@ -4968,6 +4984,7 @@ test('a held parked vehicle draws no icon; let go, it draws its icon again', asy app.markers('still').get(key) ?? app.markers('moving').get(key); assert.equal(icon()?.show, true, 'drawn before the hold'); assert.equal(app.layer.setCockpitSubject(key), true); + assert.equal(icon()?.show ?? false, false, 'hidden at once'); // The view rides it for a while: frames, a sweep, a poll. app.run(2_000, 16); app.settle(); @@ -4986,3 +5003,82 @@ test('a held parked vehicle draws no icon; let go, it draws its icon again', asy app.settle(); assert.equal(icon()?.show, true, 'let go: drawn again'); }); + +test('a hold moved to another vehicle lets the first go out of view', async (t) => { + const app = harness(t); + app.serve('mbta', () => ({ + status: 200, + body: snapshot( + 'mbta', + 'MBTA', + [ + vehicle('bus-1', 42.36, -71.06, reported()), + vehicle('bus-2', 42.37, -71.05, reported()), + ], + { fetchedAt: Date.now() }, + ), + })); + app.layer.enable(app.viewer); + await app.layer.update(); + app.settle(); + const bus = (id) => app.vehicles().find((entry) => entry.key === id); + const first = bus('mbta:bus-1'); + assert.equal(app.layer.setCockpitSubject(first.key), true); + // The view looks away from both, as a view from inside the first does. + app.lookAt({ west: -70.98, south: 42.3, east: -70.9, north: 42.42 }); + app.advance(250); + app.settle(); + assert.equal(app.state()._visible.has(bus('mbta:bus-2')), false); + assert.equal(app.layer.setCockpitSubject('mbta:bus-2'), true); + assert.equal(app.state()._visible.has(first), false, 'let go, out of play'); + assert.equal(first.marker.show, false, 'and not drawn out of view'); +}); + +test('holding a vehicle out of view tells its view at once the floor it stands on', async (t) => { + // Out of view a vehicle plays on but its marker is not moved: the hold + // places it, so its view reads neither the floor where it was last drawn + // nor nothing. + const app = harness(t, { floorAt: (lat) => (lat > 42.3625 ? 100 : 10) }); + for (const [lat, floorM] of [ + [42.361, 10], + [42.362, 10], + [42.363, 100], + [42.364, 100], + ]) + app.ground._warm.set(app.ground._key(lat, -71.06), floorM); + let lat = 42.36; + app.serve('mbta', () => ({ + status: 200, + body: snapshot( + 'mbta', + 'MBTA', + [vehicle('bus-1', lat, -71.06, reported())], + { + fetchedAt: Date.now(), + }, + ), + })); + app.layer.enable(app.viewer); + await app.layer.update(); + app.settle(); + const [entry] = app.vehicles(); + const drawnM = () => + Cesium.Cartographic.fromCartesian(entry.marker.position).height; + assert.ok(Math.abs(drawnM() - 11.5) < 1, 'drawn on the low ground'); + app.lookAt({ west: -70.98, south: 42.3, east: -70.9, north: 42.42 }); + app.advance(250); + app.settle(); + assert.equal(app.state()._visible.has(entry), false, 'out of view'); + // Unseen, it drives up the hill and stands there. + for (const next of [42.361, 42.362, 42.363, 42.364, 42.364, 42.364]) { + lat = next; + app.run(TRANSIT_POLL_MS); + await app.layer.update(); + } + app.run(LAG_MS); + app.settle(); + assert.ok(drawnM() < 30, 'its marker was left on the low ground'); + assert.equal(app.layer.setCockpitSubject(entry.key), true); + const floorM = app.layer.getCockpitSubject().position.groundHeightM; + assert.ok(Math.abs(floorM - 100) < 1.5, `up the hill, got ${floorM} m`); +}); diff --git a/src/layers/transit/rendering.js b/src/layers/transit/rendering.js index 8b0ecc1e8e..194d042a3e 100644 --- a/src/layers/transit/rendering.js +++ b/src/layers/transit/rendering.js @@ -1225,7 +1225,6 @@ export function createRendering({ state, services, parts }) { setNameOf, markerShown, markDirty, - setShown, flushMarkers, removeMarker, watchCamera, From 58afb169d19c9016967d7e577000ae0dd731e8cd Mon Sep 17 00:00:00 2001 From: German Khokhlov Date: Wed, 18 Nov 2026 20:49:15 +0400 Subject: [PATCH 7/8] Keep a standing train's direction through jitter and missing bearings - GPS jitter under 15 m at a standing train no longer turns it, in reports and in playback; a reversal needs at least 15 m of movement. - A standing train keeps its operator's last bearing through reports that leave it out. - Playback resets its turn point at a break, so a jump to a corrected position is not a reversal. - A train bound while its line is still loading takes its direction from the movement it already made. - A vehicle in view that leaves a Transit hold goes on from its own clock instead of rewinding. - Tests cover the 15 m boundary, the late line, the hold release and the icon after Transit is turned back on; duplicate jitter tests are merged. - FOLLOW_MIN_MOVE_M is gone; comments and CURRENT-STATE match the code. --- docs/CURRENT-STATE.md | 31 +++--- src/layers/rail/cockpitSubject.js | 9 +- src/layers/rail/cockpitSubject.test.mjs | 44 ++++++++- src/layers/rail/ingestion.js | 27 ++++- src/layers/rail/pathBinding.js | 73 +++++++++----- src/layers/rail/pathBinding.test.mjs | 126 +++++++++++++++--------- src/layers/rail/policy.js | 5 +- src/layers/transit/cockpitSubject.js | 14 +-- src/layers/transit/lifecycle.test.mjs | 83 +++++++++++----- src/layers/transit/rendering.js | 6 +- 10 files changed, 291 insertions(+), 127 deletions(-) diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index d83e762add..8e7e94299d 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -2769,8 +2769,8 @@ HUD view is. The Rail layer offers a read API for such a view: `getSelectedTrain()` and `getCockpitSubject()` (a snapshot of the train: where it is along its line, which way it runs (`pathBinding.js` learns it), its rail height (null while -no floor is known), speed as reported or -derived, position source, feed credit and stops, and +no floor is known), speed as reported or derived, position source, feed +credit and stops, and `selectedAtMs`, when the user last selected it by a click or `focusTrain`, even again; null after a deselection and for a train only a hold selected), `setCockpitSubject(key)` (its marker, 3D model and card hidden, the selection kept, its @@ -2788,18 +2788,21 @@ box are hidden; released, it is out of play until a visibility sweep finds it in view. Turning the layer off ends the hold. Its snapshot's `position.groundHeightM` is the floor where playback draws it (the drawn marker's height while it is placed, else its segment's two reports' floors at -the playback fraction), not the newest report's, and null while that floor is -unknown, also while the camera is too high for the layer to sample the ground -and such a vehicle is drawn on the ellipsoid. Rail's `path.direction` is the -way the drawn train runs: once playback has placed it, a report that runs back -turns it only when playback starts the segment to that report. A train turns -once it has backed away from the farthest point it reached by more than a -standing train's GPS jitter, however slowly it backs, so that jitter keeps the -direction it had. `docs/APPLICATION.md` (Cockpit subjects) shows a minimal -provider. `src/ui/cockpitSubjectView.test.mjs`, -`src/cockpitSubjectProviders.test.mjs`, `src/cockpitProgress.test.mjs`, -`src/layers/rail/cockpitSubject.test.mjs`, `src/layers/rail/pathBinding.test.mjs` -and the Transit lifecycle tests cover them. +the playback fraction), not the newest report's, and null while either of +those two floors is unknown. Rail's `path.direction` is the way the drawn +train runs: once playback has placed it, a report that runs back turns it +only when playback starts the segment to that report. A train turns once it +is more than a standing train's GPS jitter back from the last place a longer +move took it, however slowly it backs, so jitter on either side of where it +stands keeps its direction, and so does a jump to a corrected position. +A train bound after it stopped takes its direction from earlier reports in +the same run. While movement gives no direction, the snapshot uses the +operator's last reported bearing. +`docs/APPLICATION.md` (Cockpit subjects) shows a minimal provider. +`src/ui/cockpitSubjectView.test.mjs`, `src/cockpitSubjectProviders.test.mjs`, +`src/cockpitProgress.test.mjs`, `src/layers/rail/cockpitSubject.test.mjs`, +`src/layers/rail/pathBinding.test.mjs` and the Transit lifecycle tests cover +them. ## Context coordination diff --git a/src/layers/rail/cockpitSubject.js b/src/layers/rail/cockpitSubject.js index 1d9c02cb39..2a66d4f28c 100644 --- a/src/layers/rail/cockpitSubject.js +++ b/src/layers/rail/cockpitSubject.js @@ -173,16 +173,15 @@ export function createRailCockpitSubject({ /** * Which way the train runs along its shape: as its binding learnt it from - * successive reports, else from its reported bearing against the line's - * bearing there; 0 while neither tells. Not the drawn course: until the - * binding tells, the train has not moved past GPS jitter, and a course - * drawn between such reports is that jitter. + * successive reports, else from its operator's last reported bearing + * against the line's bearing there; 0 while neither tells. Not the drawn + * course: before the binding tells, that course is GPS jitter. */ function directionOf(entry) { const binding = entry.path; if (binding.direction === 1 || binding.direction === -1) return binding.direction; - const course = finiteOrNull(entry.record?.bearing); + const course = finiteOrNull(binding.bearingDeg); const point = pointAtS(binding.path, binding.drawS, scratch); if (course === null || !Number.isFinite(point?.bearingDeg)) return 0; const turn = Math.abs(((course - point.bearingDeg + 540) % 360) - 180); diff --git a/src/layers/rail/cockpitSubject.test.mjs b/src/layers/rail/cockpitSubject.test.mjs index 08bf66d15c..60f31ba8af 100644 --- a/src/layers/rail/cockpitSubject.test.mjs +++ b/src/layers/rail/cockpitSubject.test.mjs @@ -162,8 +162,8 @@ test('a train on a known floor at sea level reports a rail height of 0 m', async }); test('a train first seen standing takes no direction from its GPS jitter', async (t) => { - // Neither reports 13 m apart nor the course drawn between them say which way - // it runs; an operator's bearing does. + // Reports 13 m apart, and the course drawn between them, do not tell which + // way it runs; an operator's bearing does. const app = harness(t, { paths: { 'mbta-rail': PACK }, at: BOSTON }); let jitterM = 0; app.feeds.set('mbta-rail', () => [ @@ -184,6 +184,46 @@ test('a train first seen standing takes no direction from its GPS jitter', async assert.deepEqual(seen, Array(6).fill([0, -1])); }); +test('a standing train keeps its operator’s bearing through reports that leave it out', async (t) => { + const app = harness(t, { paths: { 'mbta-rail': PACK }, at: BOSTON }); + let bearing = 270; + app.feeds.set('mbta-rail', () => [ + train('T1', LAT, LON0 + 1000 / KX, { bearing }), + ]); + await app.enable(); + const seen = []; + for (const next of [270, 270, 270, null, null, null]) { + bearing = next; + app.run(RAIL_POLL_MS); + await app.poll(); + app.parts().selection.selectTrain(T1); + seen.push(app.layer.getSelectedTrain().path.direction); + } + assert.deepEqual(seen, Array(6).fill(-1)); +}); + +test('a train bound standing, its line late, runs the way its earlier reports went', async (t) => { + t.mock.method(console, 'warn', () => {}); + const paths = { 'mbta-rail': 503 }; + const app = harness(t, { paths, at: BOSTON }); + let eastM = 1600; + app.feeds.set('mbta-rail', () => [train('T1', LAT, LON0 + eastM / KX)]); + await app.enable(); + // No line yet: it runs 300 m west, with no bearing, and stands. + for (const next of [1500, 1400, 1300, 1300, 1300, 1300, 1300, 1300]) { + eastM = next; + app.run(RAIL_POLL_MS); + await app.poll(); + } + assert.equal(app.entry(T1).path, null, 'not bound yet'); + paths['mbta-rail'] = PACK; + const slot = app.state()._pathPacks.get('mbta-rail'); + app.run(Math.max(0, slot.retryAt - Date.now())); + await app.poll(); + app.parts().selection.selectTrain(T1); + assert.equal(app.layer.getSelectedTrain().path.direction, -1); +}); + test('a snapshot read again while nothing changed is the one read before', async (t) => { let list = stopList('Alpha', 'Bravo', 'Charlie'); const app = await onTheLine(t, { diff --git a/src/layers/rail/ingestion.js b/src/layers/rail/ingestion.js index 721e15f2bd..5316134ba8 100644 --- a/src/layers/rail/ingestion.js +++ b/src/layers/rail/ingestion.js @@ -23,7 +23,12 @@ import { railTrainKey, trainReportTimeMs, } from './policy.js'; -import { bindTrainPath, followFix, rebindTrainPath } from './pathBinding.js'; +import { + bindTrainPath, + followFix, + rebindTrainPath, + recallDirection, +} from './pathBinding.js'; import { scheduleRetryDelayMs } from './schedules.js'; import { createDuplicateFilter } from './dedupe.js'; @@ -220,6 +225,23 @@ export function createIngestion({ state, services, parts, source }) { entry.path = rebindTrainPath(pack, ids, entry.path, fix); } + /** + * A track's reports before `newest`, newest first, back to the start of + * its run of playback (a new epoch or a break). + */ + function earlierFixes(track, newest) { + const fixes = []; + let later = newest; + for (let i = track.count - 2; i >= 0; i--) { + if (later.flags & FIX_FLAGS.BREAK) break; + const fix = readFix(track, i); + if (fix.epoch !== later.epoch) break; + fixes.push(fix); + later = fix; + } + return fixes; + } + /** Bind the trains a feed already shows once its pack arrives. */ function bindFeedTrains(feedId) { const newest = {}; @@ -228,6 +250,9 @@ export function createIngestion({ state, services, parts, source }) { if (!entry.track?.count) continue; readFix(entry.track, entry.track.count - 1, newest); followPath(entry, entry.record, newest); + // It may have run, and stopped, before its line came. + if (entry.path) + recallDirection(entry.path, earlierFixes(entry.track, newest)); parts.rendering.schedulePlayback(entry); } governorRequestRender('rail-paths'); diff --git a/src/layers/rail/pathBinding.js b/src/layers/rail/pathBinding.js index 4afe9b7872..b2f34b5200 100644 --- a/src/layers/rail/pathBinding.js +++ b/src/layers/rail/pathBinding.js @@ -1,3 +1,4 @@ +import { FIX_FLAGS } from '../../data/contactPlayback.js'; import { pointAtS, projectOnPath } from '../../data/railPaths.js'; /** @@ -48,32 +49,19 @@ export function pathWindowM(dtMs) { } /** - * Arc a train must move before that says which way it runs (m): a standing - * train's GPS jitter, back and forth, stays within it. + * Arc a train must move before it tells which way it runs (m); a standing + * train's GPS jitter stays within it. */ export const DIRECTION_MIN_M = 15; /** - * Track one more arc position of a train. `turn.s` is the farthest arc it - * has reached the way it runs (where it was first seen while that is - * unknown); it turns once it is DIRECTION_MIN_M or more back from there, - * however small each step. - * @param {number} direction +1, -1 or 0. - * @param {{s: number}} turn Updated in place. - * @param {number} s - * @returns {number} The direction now. + * The direction after one more arc position `s`: once `s` is DIRECTION_MIN_M + * or more from `turn.s`, the sign of that move, and `turn.s` moves to `s`. */ function steer(direction, turn, s) { if (!Number.isFinite(s)) return direction; - if (!Number.isFinite(turn.s)) { - turn.s = s; - return direction; - } + if (!Number.isFinite(turn.s)) turn.s = s; const step = s - turn.s; - if (direction && step * direction >= 0) { - turn.s = s; - return direction; - } if (Math.abs(step) < DIRECTION_MIN_M) return direction; turn.s = s; return Math.sign(step); @@ -86,17 +74,19 @@ function createBinding(shapeIndex, path, via, s, fix) { via, /** * Which way the drawn train runs along the shape: +1 along it, -1 - * against it, 0 until two reports or a playback segment tell. Kept until - * a rebind, and while the train stands. Once a playback segment has told - * it (`directionPlayed`), only playback changes it: the newest reports - * run ahead of the drawn train, so a reversal they show turns it when - * playback reaches it. + * against it, 0 until it has moved DIRECTION_MIN_M (steer, or + * recallDirection). Kept until a rebind, and while the train stands. + * Once a playback segment has told it (`directionPlayed`), only playback + * changes it: the newest reports run ahead of the drawn train, so a + * reversal they show turns it when playback reaches it. */ direction: 0, directionPlayed: false, - /** How far the reports and the played segments have run (steer). */ + /** steer() turn points: one for the reports, one for the played segments. */ reportTurn: { s }, playTurn: { s: NaN }, + /** The newest operator bearing its reports gave (deg), NaN before one. */ + bearingDeg: Number.isFinite(fix.bearingDeg) ? fix.bearingDeg : NaN, /** Arc and time of the newest report. */ fixS: s, fixT: fix.t, @@ -149,7 +139,7 @@ function bestRouteShape(pack, routeId, fix, accept) { * * @param {object} pack From createRailPathPack. * @param {{tripId?: string, routeId?: string}} ids - * @param {{t: number, lat: number, lon: number}} fix The newest report. + * @param {{t: number, lat: number, lon: number, bearingDeg?: number}} fix The newest report. * @returns {object|null} A binding, or null to keep straight-line motion. */ export function bindTrainPath(pack, { tripId, routeId } = {}, fix) { @@ -171,7 +161,7 @@ export function bindTrainPath(pack, { tripId, routeId } = {}, fix) { /** * Follow a new report on the bound shape. * @param {object} binding - * @param {{t: number, lat: number, lon: number}} fix + * @param {{t: number, lat: number, lon: number, bearingDeg?: number}} fix * @returns {boolean} False when the report lies off the line: the binding is wrong. */ export function followFix(binding, fix) { @@ -186,6 +176,7 @@ export function followFix(binding, fix) { if (!hit || hit.offsetM > PATH_OFF_TRACK_M) return false; if (!binding.directionPlayed) binding.direction = steer(binding.direction, binding.reportTurn, hit.s); + if (Number.isFinite(fix.bearingDeg)) binding.bearingDeg = fix.bearingDeg; binding.fixS = hit.s; binding.fixT = fix.t; binding.fixLat = fix.lat; @@ -214,6 +205,32 @@ export function rebindTrainPath(pack, { routeId } = {}, binding, fix) { : null; } +/** + * Which way a train just bound standing ran before: the newest of its + * earlier reports (newest first) DIRECTION_MIN_M or more along the line + * from its newest one tells. Stops at the first report off the line. + * @param {object} binding Just made, from the newest report. + * @param {Array<{t: number, lat: number, lon: number}>} earlier + */ +export function recallDirection(binding, earlier) { + if (!binding || binding.direction) return; + for (const fix of earlier) { + const hit = projectOnPath( + binding.path, + fix.lat, + fix.lon, + binding.fixS, + pathWindowM(binding.fixT - fix.t), + ); + if (!hit || hit.offsetM > PATH_OFF_TRACK_M) return; + const step = binding.fixS - hit.s; + if (Math.abs(step) >= DIRECTION_MIN_M) { + binding.direction = Math.sign(step); + return; + } + } +} + /** Project one playback report, near the last drawn arc when that is useful. */ function projectReport(binding, fix, hintS, hintT) { const path = binding.path; @@ -236,7 +253,7 @@ function projectReport(binding, fix, hintS, hintT) { * * @param {object} binding * @param {{fromSeq: number, toSeq: number, fraction: number}} sample Playback sample. - * @param {{from: {seq:number, t:number, lat:number, lon:number}, + * @param {{from: {seq:number, t:number, lat:number, lon:number, flags?:number}, * to: {seq:number, t:number, lat:number, lon:number}}} segment The sample's two reports. * @param {{lat?: number, lon?: number, bearingDeg?: number}} out * @returns {boolean} False when the train should stay on its straight-line point. @@ -279,6 +296,8 @@ export function placeOnPath(binding, sample, segment, out) { cache.ok = Number.isFinite(sFrom) && Number.isFinite(sTo); if (cache.ok) { const turn = binding.playTurn; + // A break is a corrected position, not a move: steer on from there. + if (from.flags & FIX_FLAGS.BREAK) turn.s = sFrom; binding.direction = steer(binding.direction, turn, sFrom); binding.direction = steer(binding.direction, turn, sTo); if (binding.direction) binding.directionPlayed = true; diff --git a/src/layers/rail/pathBinding.test.mjs b/src/layers/rail/pathBinding.test.mjs index 6dcc9fab99..04d718874b 100644 --- a/src/layers/rail/pathBinding.test.mjs +++ b/src/layers/rail/pathBinding.test.mjs @@ -1,5 +1,6 @@ import test from 'node:test'; import assert from 'node:assert/strict'; +import { FIX_FLAGS } from '../../data/contactPlayback.js'; import { createRailPathPack } from '../../data/railPaths.js'; import { PATH_OFF_TRACK_M, @@ -264,53 +265,41 @@ test('a report that runs back turns the drawn train only when playback does', () assert.equal(binding.direction, -1); }); -test('jitter segments played back at a standing train keep the direction it learnt', () => { - const p = pack(); - const ids = { tripId: 'full', routeId: 'main' }; - const binding = bindTrainPath(p, ids, fix(0, 1000, 0)); - assert.ok(followFix(binding, fix(15_000, 1600, 0))); - let seq = 0; - const play = (fromM, toM, t0) => { - const { sample, segment } = playback( - seq, - seq + 1, - fix(t0, fromM, 0), - fix(t0 + 15_000, toM, 0), - 0.5, +test('a jump to a corrected position in a new playback epoch is no reversal', () => { + const binding = bindTrainPath( + pack(), + { tripId: 'full', routeId: 'main' }, + fix(0, 1000, 0), + ); + const play = (seq, from, to) => + placeOnPath( + binding, + { fromSeq: seq, toSeq: seq + 1, fraction: 0.5 }, + { from: { seq, ...from }, to: { seq: seq + 1, ...to } }, + {}, ); - assert.ok(placeOnPath(binding, sample, segment, {})); - seq += 1; - return binding.direction; - }; - // It runs east, then stands at the platform: reports 3-5 m apart, back and - // forth, polled and played. - const learnt = [play(1000, 1600, 0)]; - let t0 = 15_000; - for (const [fromM, toM] of [ - [1600, 1597], - [1597, 1600], - [1600, 1596], - [1596, 1601], - ]) { - assert.ok(followFix(binding, fix(t0 + 15_000, toM, 0))); - learnt.push(play(fromM, toM, t0)); - t0 += 15_000; - } - assert.deepEqual(learnt, [1, 1, 1, 1, 1], 'from the played-back segments'); -}); - -test('GPS jitter in the newest reports before playback keeps the direction', () => { - const p = pack(); - const ids = { tripId: 'full', routeId: 'main' }; - const binding = bindTrainPath(p, ids, fix(0, 1000, 0)); - assert.ok(followFix(binding, fix(15_000, 1600, 0))); + assert.ok(play(0, fix(0, 1000, 0), fix(60_000, 1600, 0))); assert.equal(binding.direction, 1); - const learnt = []; - [1597, 1600, 1596, 1601].forEach((eastM, i) => { - assert.ok(followFix(binding, fix(30_000 + i * 15_000, eastM, 0))); - learnt.push(binding.direction); - }); - assert.deepEqual(learnt, [1, 1, 1, 1], 'from the newest reports'); + // The source puts it back at 1400 m: a new epoch whose first report is a + // break, and no segment is played from 1600 m to there. + const epoch = { epoch: 1 }; + assert.ok( + play( + 5, + { ...fix(70_000, 1400, 0), ...epoch, flags: FIX_FLAGS.BREAK }, + { ...fix(85_000, 1400, 0), ...epoch }, + ), + ); + assert.equal(binding.direction, 1, 'standing there, it keeps its way'); + // From there, a real move back still turns it. + assert.ok( + play( + 6, + { ...fix(85_000, 1400, 0), ...epoch }, + { ...fix(100_000, 1380, 0), ...epoch }, + ), + ); + assert.equal(binding.direction, -1); }); /** The direction after each played segment, `[fromM, toM]` 15 s apart. */ @@ -351,6 +340,30 @@ test('a train that moves under 15 m a report still tells its direction', () => { ); }); +test('a train turns 15 m back from where it ran to, not 14.9 m', () => { + const p = pack(); + const ids = { tripId: 'full', routeId: 'main' }; + for (const [backM, want, label] of [ + [1100, -1, '15 m back'], + [1100.1, 1, '14.9 m back'], + ]) { + const reports = bindTrainPath(p, ids, fix(0, 1000, 0)); + const learnt = [1115, backM].map((eastM, i) => { + assert.ok(followFix(reports, fix((i + 1) * 15_000, eastM, 0))); + return reports.direction; + }); + assert.deepEqual(learnt, [1, want], `${label}, from the newest reports`); + assert.deepEqual( + playDirections(bindTrainPath(p, ids, fix(0, 1000, 0)), [ + [1000, 1115], + [1115, backM], + ]), + [1, want], + `${label}, from the played-back segments`, + ); + } +}); + test('GPS jitter of up to 14 m at a standing train keeps its direction', () => { const p = pack(); const ids = { tripId: 'full', routeId: 'main' }; @@ -372,4 +385,27 @@ test('GPS jitter of up to 14 m at a standing train keeps its direction', () => { [1, 1, 1, 1, 1], 'from the played-back segments', ); + + // On both sides of where it stopped: 8 m either way, 16 m from end to end. + const both = bindTrainPath(p, ids, fix(0, 600, 0)); + assert.deepEqual( + [1000, 1008, 1000, 992, 1000, 1008].map((eastM, i) => { + assert.ok(followFix(both, fix((i + 1) * 15_000, eastM, 0))); + return both.direction; + }), + [1, 1, 1, 1, 1, 1], + 'both sides, from the newest reports', + ); + assert.deepEqual( + playDirections(bindTrainPath(p, ids, fix(0, 600, 0)), [ + [600, 1000], + [1000, 1008], + [1008, 1000], + [1000, 992], + [992, 1000], + [1000, 1008], + ]), + [1, 1, 1, 1, 1, 1], + 'both sides, from the played-back segments', + ); }); diff --git a/src/layers/rail/policy.js b/src/layers/rail/policy.js index 57d8598459..f367c8f32c 100644 --- a/src/layers/rail/policy.js +++ b/src/layers/rail/policy.js @@ -295,9 +295,6 @@ export function playbackModeFor(railMode) { : 'rail'; } -/** Two reports closer than this are one place: a parked train's jitter (m). */ -export const FOLLOW_MIN_MOVE_M = DIRECTION_MIN_M; - const lastFix = {}; const priorFix = {}; @@ -334,7 +331,7 @@ export function railTrainFollowable(entry) { sample.nextMotionT > sample.displayT ) return true; - return lastReportsApartM(entry.track) >= FOLLOW_MIN_MOVE_M; + return lastReportsApartM(entry.track) >= DIRECTION_MIN_M; } /** diff --git a/src/layers/transit/cockpitSubject.js b/src/layers/transit/cockpitSubject.js index ff31f0722f..521263874f 100644 --- a/src/layers/transit/cockpitSubject.js +++ b/src/layers/transit/cockpitSubject.js @@ -83,11 +83,9 @@ export function createTransitCockpitSubject({ state, parts, services }) { * lift: the drawn marker's height while the frame pass places it (in view, * or held), which near the ground follows the terrain between reports; * else its segment's two reports' floors at the playback fraction. Null - * while either floor is unknown, as on cold terrain, so a view waits for - * the surface: with the camera above HEIGHT_SAMPLE_MAX_ALTITUDE_M such a - * marker is drawn on the ellipsoid, which is no floor. Not - * `entry.heightM`, the floor at the newest report, which playback has not - * reached yet. + * while either of those two floors is unknown, as on cold terrain, so a + * view waits for the surface. Not `entry.heightM`, the floor at the newest + * report, which playback has not reached yet. */ function drawnFloorOf(entry) { const segment = entry.segment; @@ -188,10 +186,14 @@ export function createTransitCockpitSubject({ state, parts, services }) { state._detectRevision += 1; } - /** A vehicle let go of is out of play until a sweep finds it in view. */ + /** + * A vehicle let go of is out of play until a sweep finds it in view. It + * played on while held, so that sweep keeps its clock (rendering.js). + */ function release(entry) { if (!entry) return; state._visible.delete(entry); + entry.releasedFromHold = true; parts.rendering.requestVisibility(); repaint(entry); } diff --git a/src/layers/transit/lifecycle.test.mjs b/src/layers/transit/lifecycle.test.mjs index 4c2e217073..dfc1398982 100644 --- a/src/layers/transit/lifecycle.test.mjs +++ b/src/layers/transit/lifecycle.test.mjs @@ -957,7 +957,10 @@ test('disable aborts in-flight work and a response that lands late is ignored', assert.equal(app.vehicles().length, 1); }); -/** A bus at `place.lat`, read on each poll, polled once and settled; its entry. */ +/** + * Serves one bus at `place.lat` (read on every poll), enables the layer and + * polls once; returns its entry. + */ async function oneBus(app, place = { lat: 42.36 }) { app.serve('mbta', () => ({ status: 200, @@ -984,7 +987,6 @@ test('a held vehicle with no floor yet tells its view no height', async (t) => { }); test('with the camera above the height gate, a held vehicle drawn on the ellipsoid tells its view no height', async (t) => { - // There a vehicle with no floor is drawn on the ellipsoid, which is no floor. const app = harness(t, { altitude: 100_000, floorAt: () => undefined }); const entry = await oneBus(app); assert.ok(app.layer.setCockpitSubject(entry.key) !== false); @@ -4928,7 +4930,7 @@ test('a held vehicle hides, keeps moving out of view, and lets go when it goes', assert.equal(app.layer.getCockpitSubject(), null); }); -test('turning Transit off ends a hold; on again, the vehicle shows and clicks and Escape select it', async (t) => { +test('turning Transit off ends a hold; on again, the vehicle shows, a click selects it and Escape deselects it', async (t) => { const app = harness(t); const key = await busRunningNorth(app); assert.equal(app.layer.setCockpitSubject(key), true); @@ -4948,6 +4950,8 @@ test('turning Transit off ends a hold; on again, the vehicle shows and clicks an const [entry] = app.vehicles(); app.frame(); assert.equal(entry.marker.show, true, 'the vehicle is drawn, not held'); + const icon = app.markers('still').get(key) ?? app.markers('moving').get(key); + assert.equal(icon?.show, true, 'and so is its icon in the set'); app.viewer.scene.pick = () => app.pickOf(entry); app.input.click(new Cesium.Cartesian2(500, 400)); assert.equal(app.state()._selectedKey, key, 'a click selects it'); @@ -5034,10 +5038,59 @@ test('a hold moved to another vehicle lets the first go out of view', async (t) assert.equal(first.marker.show, false, 'and not drawn out of view'); }); +test('a vehicle in view let go of a hold goes on from its own clock', async (t) => { + // Held, it played on; let go, the sweep that finds it in view does not + // set its clock again, though the feed's lag has grown since. + for (const next of ['mbta:b', null]) { + await t.test(`the hold moves to ${next}`, async (t) => { + const app = harness(t, { floorAt: () => 5 }); + let fixAt = Date.now() - AGE_MS; + let north = 42.36; + app.serve('mbta', () => ({ + status: 200, + body: snapshot( + 'mbta', + 'MBTA', + [ + vehicle('a', north, -71.06, fixAt / 1000), + vehicle('b', 42.37, -71.05, reported()), + ], + { fetchedAt: Date.now() }, + ), + })); + app.layer.enable(app.viewer); + await app.layer.update(); + app.settle(); + const a = app.vehicles().find((e) => e.key === 'mbta:a'); + app.layer.setCockpitSubject(a.key); + for (let poll = 1; poll <= 5; poll += 1) { + fixAt += TRANSIT_POLL_MS; + north += 0.001; + app.run(TRANSIT_POLL_MS); + await app.layer.update(); + } + // One late poll: the lag the feed earns grows. + app.run(TRANSIT_POLL_MS + 10_000); + fixAt += TRANSIT_POLL_MS; + north += 0.001; + await app.layer.update(); + app.run(3_000); + const beforeT = a.track.displayT; + const beforeLat = lat(a); + app.layer.setCockpitSubject(next); + app.advance(250); + app.settle(); + assert.equal(app.state()._visible.has(a), true, 'A is in view'); + assert.ok(a.track.displayT >= beforeT, 'its clock did not go back'); + assert.ok(lat(a) >= beforeLat, 'nor did it move back'); + }); + } +}); + test('holding a vehicle out of view tells its view at once the floor it stands on', async (t) => { // Out of view a vehicle plays on but its marker is not moved: the hold - // places it, so its view reads neither the floor where it was last drawn - // nor nothing. + // places it, so its view reads the floor it is on now, not the old one or + // null. const app = harness(t, { floorAt: (lat) => (lat > 42.3625 ? 100 : 10) }); for (const [lat, floorM] of [ [42.361, 10], @@ -5046,22 +5099,8 @@ test('holding a vehicle out of view tells its view at once the floor it stands o [42.364, 100], ]) app.ground._warm.set(app.ground._key(lat, -71.06), floorM); - let lat = 42.36; - app.serve('mbta', () => ({ - status: 200, - body: snapshot( - 'mbta', - 'MBTA', - [vehicle('bus-1', lat, -71.06, reported())], - { - fetchedAt: Date.now(), - }, - ), - })); - app.layer.enable(app.viewer); - await app.layer.update(); - app.settle(); - const [entry] = app.vehicles(); + const place = { lat: 42.36 }; + const entry = await oneBus(app, place); const drawnM = () => Cesium.Cartographic.fromCartesian(entry.marker.position).height; assert.ok(Math.abs(drawnM() - 11.5) < 1, 'drawn on the low ground'); @@ -5071,7 +5110,7 @@ test('holding a vehicle out of view tells its view at once the floor it stands o assert.equal(app.state()._visible.has(entry), false, 'out of view'); // Unseen, it drives up the hill and stands there. for (const next of [42.361, 42.362, 42.363, 42.364, 42.364, 42.364]) { - lat = next; + place.lat = next; app.run(TRANSIT_POLL_MS); await app.layer.update(); } diff --git a/src/layers/transit/rendering.js b/src/layers/transit/rendering.js index 194d042a3e..0d31053f34 100644 --- a/src/layers/transit/rendering.js +++ b/src/layers/transit/rendering.js @@ -1134,13 +1134,17 @@ export function createRendering({ state, services, parts }) { visibility.noSample = noSample; const wasShown = entry.marker.show; const wasVisible = state._visible.has(entry); + // Let go of a hold, it played on (cockpitSubject.js): its clock stands. + const playedOn = entry.releasedFromHold === true; + entry.releasedFromHold = false; if (visible) state._visible.add(entry); else state._visible.delete(entry); // Turned afresh once back in view: the camera may have moved while it // was out, after the pass that would have turned it. if (visible && !wasVisible) entry.rotationCourse = undefined; if (visible && entry.track?.count) { - if (!wasVisible && !entry.qaFixture) syncPlayback(entry, now); + if (!wasVisible && !playedOn && !entry.qaFixture) + syncPlayback(entry, now); // Re-entry can advance into an unprepared corridor; loaded tiles can // also resolve a cold path without a poll or a render-loop wakeup. if (!wasVisible || entry.surfaceReady === false || entry.heightPending) From e8ef4d1293c4ac99e290d514b5bd2b39dd7a20e8 Mon Sep 17 00:00:00 2001 From: German Khokhlov Date: Thu, 19 Nov 2026 00:26:57 +0400 Subject: [PATCH 8/8] Reset a train's turn point on a new playback epoch - A clock correction starts a new epoch, and playback may first draw its second report. The turn point now resets on a new epoch as well as on a break, so a standing train no longer turns around after a correction. - recallDirection and earlierFixes are gone: comparing each earlier report with the newest turned a standing train on GPS jitter. A train bound when its line arrives late shows no direction until it has moved 15 m. - Tests share reportDirections, iconOf and the playback helper. - Comments and CURRENT-STATE match the code. --- docs/CURRENT-STATE.md | 21 +++-- src/layers/rail/cockpitSubject.test.mjs | 22 ------ src/layers/rail/ingestion.js | 27 +------ src/layers/rail/pathBinding.js | 39 ++------- src/layers/rail/pathBinding.test.mjs | 100 +++++++++++++++++------- src/layers/transit/cockpitSubject.js | 3 +- src/layers/transit/lifecycle.test.mjs | 24 +++--- src/layers/transit/rendering.js | 3 +- 8 files changed, 108 insertions(+), 131 deletions(-) diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index 8e7e94299d..ee3569c8b4 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -2770,9 +2770,9 @@ The Rail layer offers a read API for such a view: `getSelectedTrain()` and `getCockpitSubject()` (a snapshot of the train: where it is along its line, which way it runs (`pathBinding.js` learns it), its rail height (null while no floor is known), speed as reported or derived, position source, feed -credit and stops, and -`selectedAtMs`, when the user last selected it by a click or `focusTrain`, -even again; null after a deselection and for a train only a hold selected), +credit and stops, and `selectedAtMs`, when the user last selected it by a +click or `focusTrain`, even again; null after a deselection and for a train +only a hold selected), `setCockpitSubject(key)` (its marker, 3D model and card hidden, the selection kept, its feed held, clicks and Escape left to the view; the held copy stays the one drawn of its train while held, another feed's copy hidden, and it keeps @@ -2790,14 +2790,13 @@ view. Turning the layer off ends the hold. Its snapshot's marker's height while it is placed, else its segment's two reports' floors at the playback fraction), not the newest report's, and null while either of those two floors is unknown. Rail's `path.direction` is the way the drawn -train runs: once playback has placed it, a report that runs back turns it -only when playback starts the segment to that report. A train turns once it -is more than a standing train's GPS jitter back from the last place a longer -move took it, however slowly it backs, so jitter on either side of where it -stands keeps its direction, and so does a jump to a corrected position. -A train bound after it stopped takes its direction from earlier reports in -the same run. While movement gives no direction, the snapshot uses the -operator's last reported bearing. +train runs: once playback has told its direction, a report that runs back +turns it only when playback starts the segment to that report. A train turns +once it is more than a standing train's GPS jitter back from the last place a +longer move took it, however slowly it backs, so jitter on either side of +where it stands keeps its direction, and so does playback's jump to a +corrected position (a break, or a new clock epoch). While movement gives no +direction, the snapshot uses the operator's last reported bearing. `docs/APPLICATION.md` (Cockpit subjects) shows a minimal provider. `src/ui/cockpitSubjectView.test.mjs`, `src/cockpitSubjectProviders.test.mjs`, `src/cockpitProgress.test.mjs`, `src/layers/rail/cockpitSubject.test.mjs`, diff --git a/src/layers/rail/cockpitSubject.test.mjs b/src/layers/rail/cockpitSubject.test.mjs index 60f31ba8af..44043f7012 100644 --- a/src/layers/rail/cockpitSubject.test.mjs +++ b/src/layers/rail/cockpitSubject.test.mjs @@ -202,28 +202,6 @@ test('a standing train keeps its operator’s bearing through reports that leave assert.deepEqual(seen, Array(6).fill(-1)); }); -test('a train bound standing, its line late, runs the way its earlier reports went', async (t) => { - t.mock.method(console, 'warn', () => {}); - const paths = { 'mbta-rail': 503 }; - const app = harness(t, { paths, at: BOSTON }); - let eastM = 1600; - app.feeds.set('mbta-rail', () => [train('T1', LAT, LON0 + eastM / KX)]); - await app.enable(); - // No line yet: it runs 300 m west, with no bearing, and stands. - for (const next of [1500, 1400, 1300, 1300, 1300, 1300, 1300, 1300]) { - eastM = next; - app.run(RAIL_POLL_MS); - await app.poll(); - } - assert.equal(app.entry(T1).path, null, 'not bound yet'); - paths['mbta-rail'] = PACK; - const slot = app.state()._pathPacks.get('mbta-rail'); - app.run(Math.max(0, slot.retryAt - Date.now())); - await app.poll(); - app.parts().selection.selectTrain(T1); - assert.equal(app.layer.getSelectedTrain().path.direction, -1); -}); - test('a snapshot read again while nothing changed is the one read before', async (t) => { let list = stopList('Alpha', 'Bravo', 'Charlie'); const app = await onTheLine(t, { diff --git a/src/layers/rail/ingestion.js b/src/layers/rail/ingestion.js index 5316134ba8..721e15f2bd 100644 --- a/src/layers/rail/ingestion.js +++ b/src/layers/rail/ingestion.js @@ -23,12 +23,7 @@ import { railTrainKey, trainReportTimeMs, } from './policy.js'; -import { - bindTrainPath, - followFix, - rebindTrainPath, - recallDirection, -} from './pathBinding.js'; +import { bindTrainPath, followFix, rebindTrainPath } from './pathBinding.js'; import { scheduleRetryDelayMs } from './schedules.js'; import { createDuplicateFilter } from './dedupe.js'; @@ -225,23 +220,6 @@ export function createIngestion({ state, services, parts, source }) { entry.path = rebindTrainPath(pack, ids, entry.path, fix); } - /** - * A track's reports before `newest`, newest first, back to the start of - * its run of playback (a new epoch or a break). - */ - function earlierFixes(track, newest) { - const fixes = []; - let later = newest; - for (let i = track.count - 2; i >= 0; i--) { - if (later.flags & FIX_FLAGS.BREAK) break; - const fix = readFix(track, i); - if (fix.epoch !== later.epoch) break; - fixes.push(fix); - later = fix; - } - return fixes; - } - /** Bind the trains a feed already shows once its pack arrives. */ function bindFeedTrains(feedId) { const newest = {}; @@ -250,9 +228,6 @@ export function createIngestion({ state, services, parts, source }) { if (!entry.track?.count) continue; readFix(entry.track, entry.track.count - 1, newest); followPath(entry, entry.record, newest); - // It may have run, and stopped, before its line came. - if (entry.path) - recallDirection(entry.path, earlierFixes(entry.track, newest)); parts.rendering.schedulePlayback(entry); } governorRequestRender('rail-paths'); diff --git a/src/layers/rail/pathBinding.js b/src/layers/rail/pathBinding.js index b2f34b5200..a07cf1b20f 100644 --- a/src/layers/rail/pathBinding.js +++ b/src/layers/rail/pathBinding.js @@ -74,8 +74,8 @@ function createBinding(shapeIndex, path, via, s, fix) { via, /** * Which way the drawn train runs along the shape: +1 along it, -1 - * against it, 0 until it has moved DIRECTION_MIN_M (steer, or - * recallDirection). Kept until a rebind, and while the train stands. + * against it, 0 until it has moved DIRECTION_MIN_M (steer). Kept until + * a rebind, and while the train stands. * Once a playback segment has told it (`directionPlayed`), only playback * changes it: the newest reports run ahead of the drawn train, so a * reversal they show turns it when playback reaches it. @@ -84,7 +84,7 @@ function createBinding(shapeIndex, path, via, s, fix) { directionPlayed: false, /** steer() turn points: one for the reports, one for the played segments. */ reportTurn: { s }, - playTurn: { s: NaN }, + playTurn: { s: NaN, epoch: NaN }, /** The newest operator bearing its reports gave (deg), NaN before one. */ bearingDeg: Number.isFinite(fix.bearingDeg) ? fix.bearingDeg : NaN, /** Arc and time of the newest report. */ @@ -205,32 +205,6 @@ export function rebindTrainPath(pack, { routeId } = {}, binding, fix) { : null; } -/** - * Which way a train just bound standing ran before: the newest of its - * earlier reports (newest first) DIRECTION_MIN_M or more along the line - * from its newest one tells. Stops at the first report off the line. - * @param {object} binding Just made, from the newest report. - * @param {Array<{t: number, lat: number, lon: number}>} earlier - */ -export function recallDirection(binding, earlier) { - if (!binding || binding.direction) return; - for (const fix of earlier) { - const hit = projectOnPath( - binding.path, - fix.lat, - fix.lon, - binding.fixS, - pathWindowM(binding.fixT - fix.t), - ); - if (!hit || hit.offsetM > PATH_OFF_TRACK_M) return; - const step = binding.fixS - hit.s; - if (Math.abs(step) >= DIRECTION_MIN_M) { - binding.direction = Math.sign(step); - return; - } - } -} - /** Project one playback report, near the last drawn arc when that is useful. */ function projectReport(binding, fix, hintS, hintT) { const path = binding.path; @@ -296,8 +270,11 @@ export function placeOnPath(binding, sample, segment, out) { cache.ok = Number.isFinite(sFrom) && Number.isFinite(sTo); if (cache.ok) { const turn = binding.playTurn; - // A break is a corrected position, not a move: steer on from there. - if (from.flags & FIX_FLAGS.BREAK) turn.s = sFrom; + // A break or a new epoch is a corrected position, not a move: steer + // on from there. + if (from.flags & FIX_FLAGS.BREAK || from.epoch !== turn.epoch) + turn.s = sFrom; + turn.epoch = from.epoch; binding.direction = steer(binding.direction, turn, sFrom); binding.direction = steer(binding.direction, turn, sTo); if (binding.direction) binding.directionPlayed = true; diff --git a/src/layers/rail/pathBinding.test.mjs b/src/layers/rail/pathBinding.test.mjs index 04d718874b..7f3f9e707e 100644 --- a/src/layers/rail/pathBinding.test.mjs +++ b/src/layers/rail/pathBinding.test.mjs @@ -1,6 +1,13 @@ import test from 'node:test'; import assert from 'node:assert/strict'; -import { FIX_FLAGS } from '../../data/contactPlayback.js'; +import { + FIX_FLAGS, + advance, + createSample, + createTrack, + insertFix, + readFix, +} from '../../data/contactPlayback.js'; import { createRailPathPack } from '../../data/railPaths.js'; import { PATH_OFF_TRACK_M, @@ -271,13 +278,10 @@ test('a jump to a corrected position in a new playback epoch is no reversal', () { tripId: 'full', routeId: 'main' }, fix(0, 1000, 0), ); - const play = (seq, from, to) => - placeOnPath( - binding, - { fromSeq: seq, toSeq: seq + 1, fraction: 0.5 }, - { from: { seq, ...from }, to: { seq: seq + 1, ...to } }, - {}, - ); + const play = (seq, from, to) => { + const { sample, segment } = playback(seq, seq + 1, from, to, 0.5); + return placeOnPath(binding, sample, segment, {}); + }; assert.ok(play(0, fix(0, 1000, 0), fix(60_000, 1600, 0))); assert.equal(binding.direction, 1); // The source puts it back at 1400 m: a new epoch whose first report is a @@ -302,6 +306,42 @@ test('a jump to a corrected position in a new playback epoch is no reversal', () assert.equal(binding.direction, -1); }); +test('a clock correction played from past its break is no reversal', () => { + const binding = bindTrainPath( + pack(), + { tripId: 'full', routeId: 'main' }, + fix(0, 600, 0), + ); + const track = createTrack(); + const sample = createSample(); + const segment = { from: {}, to: {} }; + let now = 0; + /** One report at `t`, then 15 s of frames; the direction after each. */ + const report = (t, eastM) => { + insertFix(track, fix(t, eastM, 0), { receivedAt: now, wallNowMs: now }); + return [1, 2, 3].map(() => { + now += 5000; + advance(track, { wallNowMs: now, monoNowMs: now }, sample); + if (sample.fromSeq >= 0) { + readFix(track, sample.fromSeq - track.baseSeq, segment.from); + readFix(track, sample.toSeq - track.baseSeq, segment.to); + placeOnPath(binding, sample, segment, {}); + } + return binding.direction; + }); + }; + for (const eastM of [600, 750, 900, 1050, 1200, 1200, 1200, 1200]) + report(now, eastM); + assert.equal(binding.direction, 1); + assert.ok(binding.directionPlayed); + // Its source's clock falls 120 s behind and puts it at 1000 m. The third + // such report starts a new epoch, and playback starts at the newest one, + // past the break. + const seen = [0, 1, 2].flatMap(() => report(now - 120_000, 1000)); + assert.equal(track.resetReason, 'out-of-order'); + assert.deepEqual(seen, Array(9).fill(1)); +}); + /** The direction after each played segment, `[fromM, toM]` 15 s apart. */ function playDirections(binding, steps) { return steps.map(([fromM, toM], seq) => { @@ -317,15 +357,22 @@ function playDirections(binding, steps) { }); } +/** The direction after each report, `eastMs` 15 s apart. */ +function reportDirections(binding, eastMs) { + return eastMs.map((eastM, i) => { + assert.ok(followFix(binding, fix((i + 1) * 15_000, eastM, 0))); + return binding.direction; + }); +} + test('a train that moves under 15 m a report still tells its direction', () => { const p = pack(); const ids = { tripId: 'full', routeId: 'main' }; // It sets off slowly, runs east, then backs out 10 m a report. - const reports = bindTrainPath(p, ids, fix(0, 1000, 0)); - const learnt = [1010, 1020, 1600, 1590, 1580, 1570].map((eastM, i) => { - assert.ok(followFix(reports, fix((i + 1) * 15_000, eastM, 0))); - return reports.direction; - }); + const learnt = reportDirections( + bindTrainPath(p, ids, fix(0, 1000, 0)), + [1010, 1020, 1600, 1590, 1580, 1570], + ); assert.deepEqual(learnt, [0, 1, 1, 1, -1, -1], 'from the newest reports'); const played = bindTrainPath(p, ids, fix(0, 1000, 0)); assert.deepEqual( @@ -347,11 +394,10 @@ test('a train turns 15 m back from where it ran to, not 14.9 m', () => { [1100, -1, '15 m back'], [1100.1, 1, '14.9 m back'], ]) { - const reports = bindTrainPath(p, ids, fix(0, 1000, 0)); - const learnt = [1115, backM].map((eastM, i) => { - assert.ok(followFix(reports, fix((i + 1) * 15_000, eastM, 0))); - return reports.direction; - }); + const learnt = reportDirections(bindTrainPath(p, ids, fix(0, 1000, 0)), [ + 1115, + backM, + ]); assert.deepEqual(learnt, [1, want], `${label}, from the newest reports`); assert.deepEqual( playDirections(bindTrainPath(p, ids, fix(0, 1000, 0)), [ @@ -367,11 +413,10 @@ test('a train turns 15 m back from where it ran to, not 14.9 m', () => { test('GPS jitter of up to 14 m at a standing train keeps its direction', () => { const p = pack(); const ids = { tripId: 'full', routeId: 'main' }; - const reports = bindTrainPath(p, ids, fix(0, 1000, 0)); - const learnt = [1600, 1588, 1600, 1586, 1599, 1587].map((eastM, i) => { - assert.ok(followFix(reports, fix((i + 1) * 15_000, eastM, 0))); - return reports.direction; - }); + const learnt = reportDirections( + bindTrainPath(p, ids, fix(0, 1000, 0)), + [1600, 1588, 1600, 1586, 1599, 1587], + ); assert.deepEqual(learnt, [1, 1, 1, 1, 1, 1], 'from the newest reports'); const played = bindTrainPath(p, ids, fix(0, 1000, 0)); assert.deepEqual( @@ -387,12 +432,11 @@ test('GPS jitter of up to 14 m at a standing train keeps its direction', () => { ); // On both sides of where it stopped: 8 m either way, 16 m from end to end. - const both = bindTrainPath(p, ids, fix(0, 600, 0)); assert.deepEqual( - [1000, 1008, 1000, 992, 1000, 1008].map((eastM, i) => { - assert.ok(followFix(both, fix((i + 1) * 15_000, eastM, 0))); - return both.direction; - }), + reportDirections( + bindTrainPath(p, ids, fix(0, 600, 0)), + [1000, 1008, 1000, 992, 1000, 1008], + ), [1, 1, 1, 1, 1, 1], 'both sides, from the newest reports', ); diff --git a/src/layers/transit/cockpitSubject.js b/src/layers/transit/cockpitSubject.js index 521263874f..70cd6ecbfd 100644 --- a/src/layers/transit/cockpitSubject.js +++ b/src/layers/transit/cockpitSubject.js @@ -188,7 +188,8 @@ export function createTransitCockpitSubject({ state, parts, services }) { /** * A vehicle let go of is out of play until a sweep finds it in view. It - * played on while held, so that sweep keeps its clock (rendering.js). + * played on while held, so the next sweep keeps its clock if it finds it in + * view (rendering.js). */ function release(entry) { if (!entry) return; diff --git a/src/layers/transit/lifecycle.test.mjs b/src/layers/transit/lifecycle.test.mjs index dfc1398982..68ae7a9110 100644 --- a/src/layers/transit/lifecycle.test.mjs +++ b/src/layers/transit/lifecycle.test.mjs @@ -958,8 +958,8 @@ test('disable aborts in-flight work and a response that lands late is ignored', }); /** - * Serves one bus at `place.lat` (read on every poll), enables the layer and - * polls once; returns its entry. + * Serves one bus at `place.lat` (read on every poll), enables the layer, polls + * once and settles; returns its entry. */ async function oneBus(app, place = { lat: 42.36 }) { app.serve('mbta', () => ({ @@ -4930,6 +4930,11 @@ test('a held vehicle hides, keeps moving out of view, and lets go when it goes', assert.equal(app.layer.getCockpitSubject(), null); }); +/** A vehicle's icon in the set that draws it, still or moving. */ +function iconOf(app, key) { + return app.markers('still').get(key) ?? app.markers('moving').get(key); +} + test('turning Transit off ends a hold; on again, the vehicle shows, a click selects it and Escape deselects it', async (t) => { const app = harness(t); const key = await busRunningNorth(app); @@ -4950,8 +4955,7 @@ test('turning Transit off ends a hold; on again, the vehicle shows, a click sele const [entry] = app.vehicles(); app.frame(); assert.equal(entry.marker.show, true, 'the vehicle is drawn, not held'); - const icon = app.markers('still').get(key) ?? app.markers('moving').get(key); - assert.equal(icon?.show, true, 'and so is its icon in the set'); + assert.equal(iconOf(app, key)?.show, true, 'and so is its icon in the set'); app.viewer.scene.pick = () => app.pickOf(entry); app.input.click(new Cesium.Cartesian2(500, 400)); assert.equal(app.state()._selectedKey, key, 'a click selects it'); @@ -4984,11 +4988,9 @@ test('a held parked vehicle draws no icon; let go, it draws its icon again', asy } const key = 'mbta:bus-1'; const [entry] = app.vehicles(); - const icon = () => - app.markers('still').get(key) ?? app.markers('moving').get(key); - assert.equal(icon()?.show, true, 'drawn before the hold'); + assert.equal(iconOf(app, key)?.show, true, 'drawn before the hold'); assert.equal(app.layer.setCockpitSubject(key), true); - assert.equal(icon()?.show ?? false, false, 'hidden at once'); + assert.equal(iconOf(app, key)?.show ?? false, false, 'hidden at once'); // The view rides it for a while: frames, a sweep, a poll. app.run(2_000, 16); app.settle(); @@ -4997,7 +4999,7 @@ test('a held parked vehicle draws no icon; let go, it draws its icon again', asy app.settle(); assert.equal(entry.marker.show, false, 'its marker is hidden'); assert.equal( - icon()?.show ?? false, + iconOf(app, key)?.show ?? false, false, 'and so is the icon the set draws', ); @@ -5005,7 +5007,7 @@ test('a held parked vehicle draws no icon; let go, it draws its icon again', asy assert.equal(app.layer.setCockpitSubject(null), true); app.advance(250); app.settle(); - assert.equal(icon()?.show, true, 'let go: drawn again'); + assert.equal(iconOf(app, key)?.show, true, 'let go: drawn again'); }); test('a hold moved to another vehicle lets the first go out of view', async (t) => { @@ -5069,7 +5071,7 @@ test('a vehicle in view let go of a hold goes on from its own clock', async (t) app.run(TRANSIT_POLL_MS); await app.layer.update(); } - // One late poll: the lag the feed earns grows. + // One late poll raises the feed's target lag. app.run(TRANSIT_POLL_MS + 10_000); fixAt += TRANSIT_POLL_MS; north += 0.001; diff --git a/src/layers/transit/rendering.js b/src/layers/transit/rendering.js index 0d31053f34..4a54dfb6ff 100644 --- a/src/layers/transit/rendering.js +++ b/src/layers/transit/rendering.js @@ -1134,7 +1134,8 @@ export function createRendering({ state, services, parts }) { visibility.noSample = noSample; const wasShown = entry.marker.show; const wasVisible = state._visible.has(entry); - // Let go of a hold, it played on (cockpitSubject.js): its clock stands. + // Just let go of a hold (cockpitSubject.js): it played on, so keep + // its clock. const playedOn = entry.releasedFromHold === true; entry.releasedFromHold = false; if (visible) state._visible.add(entry);