From 900c76425c2cc6cd2724f9ec32e44b99a7e2553c Mon Sep 17 00:00:00 2001 From: Sameh Khamis Date: Sat, 14 Nov 2026 20:04:37 -0800 Subject: [PATCH] The timeline marks launches and strong earthquakes, not every weather frame The timeline drew a tick for every registered mark, and the weather clock registered every radar, satellite and lightning frame, which come every few minutes, so the track was a wall of dashes and the arrow keys crept from frame to frame. Weather products now register only the span of their frames (start and end, as before) with no marks. Holds, the gate and the next-frame wait while the world plays are unchanged. A weather row's step param goes to the previous or next weather frame (every shown product's frames, and the row's own while it is suspended) rather than to the timeline's marks. The Earthquakes layer registers with the world clock once, at init, and unregisters on destroy. While on, its quakes of magnitude 6 and up (EARTHQUAKE_MARK_MAGNITUDE) are marks, and its coverage is their own span, or none without any, so it never stretches the timeline beyond the feed. Off, it has none. It tells the clock when the set of marks changes. The map still draws every M2.5+ quake. Launches stay marks. With no mark ahead or behind, the arrow keys step along the track as shown. --- CHANGELOG.md | 9 ++++++ docs/CURRENT-STATE.md | 16 +++++++--- scripts/package-boundaries.json | 3 +- src/layers/earthquakes/index.js | 23 +++++++++++++ src/layers/earthquakes/model.js | 28 ++++++++++++++++ src/layers/earthquakes/ownership.test.mjs | 39 +++++++++++++++++++++++ src/layers/weather/clock.js | 21 +++++++----- src/layers/weather/clock.test.mjs | 19 +++++++---- src/layers/weather/index.js | 29 +++++++++++------ src/layers/weather/weather.test.mjs | 20 +++++++----- src/ui/views/panels/WorldTimeline.vue | 8 ++--- 11 files changed, 174 insertions(+), 41 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3776769f4..6ce362dbb 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,15 @@ ## [Unreleased] +- The timeline marks only events: launches, and earthquakes of magnitude 6 + and up while the Earthquakes layer is on (about one every two days + worldwide). It no longer draws a tick for every weather frame, which came + every few minutes and made the track a wall of dashes; the weather frames + still set the time the timeline covers, and Play still waits at each next + frame until it loads. With no mark ahead, the arrow keys step along the + track. The map still draws every earthquake, and an earthquake layer never + widens the timeline beyond its strong quakes' own times. A weather row's + `step` param goes to the previous or next weather frame (samehkhamis). - The main timeline is the only time control. The Weather panel no longer has a slider, step buttons, Latest or Play of its own; it shows the frame time instead: the newest frame and its age while live, the timeline time diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index 9482cfe83..9c5a6fdbc 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -1704,7 +1704,11 @@ it a Cesium viewer, with no renderer bound, loads the `./render/cesium/unbound` export once first. `depthColor` returns a renderer colour `[r, g, b, a]` and `depthAccent` its CSS. The standalone adapter keeps the existing USGS daily feed, M2.5+ filtering, static discs, magnitude labels and analyst records. Disabling or -destroying the layer cancels pending work and ignores late results. +destroying the layer cancels pending work and ignores late results. While on, +the layer registers its quakes of magnitude 6 and up +(`EARTHQUAKE_MARK_MAGNITUDE`) with the world clock as timeline marks, spanning +only their own times, and none while off; the map still draws every M2.5+ +quake. Air quality (`./layers/air-quality`) draws its station discs as one renderer draw set of ground-clamped fills and reads the view through the camera port; it @@ -8624,9 +8628,13 @@ Weather combines the GFS/ECMWF surface forecast with three observation layers: NOAA Rain radar (CONUS), Satellite clouds (regional GOES or slower global infrared), and 15-minute lightning density (Americas and Pacific). One transient observed clock moves all enabled observation rows with the world clock; the world -timeline is the only time control. Each product's advertised times are marks on -that timeline, which its arrow keys step to; each product selects its nearest -frame at or before the world time, never a future frame or an interpolation. +timeline is the only time control. Each product's advertised times span time on +that timeline but are not marks on it: the timeline marks only events (launches, +and earthquakes of magnitude 6 and up while that layer is on), so its arrow keys +step to those, or along the track where there are none. A weather row's `step` +param goes to the previous or next weather frame. Each product selects its +nearest frame at or before the world time, never a future frame or an +interpolation. The maximum gap is 30 minutes for radar, regional infrared and lightning, and 3 hours for hourly global infrared, but never less than one and a half of the feed's median frame spacing over its latest frames, so a regional feed whose diff --git a/scripts/package-boundaries.json b/scripts/package-boundaries.json index f1cc44093..590f07703 100644 --- a/scripts/package-boundaries.json +++ b/scripts/package-boundaries.json @@ -2423,7 +2423,8 @@ "src/geo/vector.js", "src/layers/earthquakes/model.js", "src/layers/earthquakes/source.js", - "src/layers/earthquakes/records.js" + "src/layers/earthquakes/records.js", + "src/time/worldClock.js" ], "external": ["cesium"] }, diff --git a/src/layers/earthquakes/index.js b/src/layers/earthquakes/index.js index 3db74cf52..c20a05f49 100644 --- a/src/layers/earthquakes/index.js +++ b/src/layers/earthquakes/index.js @@ -1,5 +1,6 @@ import { fromDegrees } from '../../geo/ellipsoid.js'; import { drawOf } from '../../render/rendererOf.js'; +import { worldClock } from '../../time/worldClock.js'; import { EARTHQUAKE_OVERLAY_SOURCE_ID, EARTHQUAKE_OVERLAY_COHORT_LIMIT, @@ -9,6 +10,7 @@ import { createEarthquakeOverlayEntry, selectEarthquakeOverlayCohort, mapAnalystRecord, + earthquakeCoverage, } from './model.js'; export * from './model.js'; export { createUsgsEarthquakeSource } from './source.js'; @@ -45,6 +47,17 @@ export function createEarthquakesLayer({ source, overlayHost } = {}) { let _lastUpdate = null; let _lastError = null; let _enabled = false; + let _uncover = null; + // The marks last told to the clock, so a refresh with the same strong + // quakes does not tell it again. + let _marksKey = null; + const coverage = () => (_enabled ? earthquakeCoverage(_events) : null); + const coverageChanged = () => { + const key = coverage()?.marks.join() ?? null; + if (key === _marksKey) return; + _marksKey = key; + worldClock.coverageChanged(); + }; const layer = { id: 'earthquakes', @@ -60,6 +73,10 @@ export function createEarthquakesLayer({ source, overlayHost } = {}) { show: false, }); _viewer = viewer; + // While on, the strong quakes are marks on the world clock's timeline. + // Registered once; off, the layer has no time to show. + _marksKey = null; + _uncover = worldClock.register({ id: 'earthquakes', coverage }); _count = 0; _lastUpdate = null; _lastError = null; @@ -74,6 +91,7 @@ export function createEarthquakesLayer({ source, overlayHost } = {}) { // layer has no per-frame animator to keep the render loop alive for. if (_discs) _discs.show = true; overlayHost.setVisible(EARTHQUAKE_OVERLAY_SOURCE_ID, true); + coverageChanged(); }, disable(viewer) { @@ -83,6 +101,7 @@ export function createEarthquakesLayer({ source, overlayHost } = {}) { if (_discs) _discs.show = false; overlayHost.clearSource(EARTHQUAKE_OVERLAY_SOURCE_ID); overlayHost.setVisible(EARTHQUAKE_OVERLAY_SOURCE_ID, false); + coverageChanged(); }, async update(viewer) { @@ -146,6 +165,7 @@ export function createEarthquakesLayer({ source, overlayHost } = {}) { _discs.set(nextDiscs); _events = nextEvents; + coverageChanged(); if (_enabled) { overlayHost.setEntries( EARTHQUAKE_OVERLAY_SOURCE_ID, @@ -184,6 +204,9 @@ export function createEarthquakesLayer({ source, overlayHost } = {}) { _discs?.dispose(); _discs = null; _events = []; + _uncover?.(); + _uncover = null; + _marksKey = null; _count = 0; _lastUpdate = null; _lastError = null; diff --git a/src/layers/earthquakes/model.js b/src/layers/earthquakes/model.js index 86eca72d4..93431bfa4 100644 --- a/src/layers/earthquakes/model.js +++ b/src/layers/earthquakes/model.js @@ -2,6 +2,34 @@ export const EARTHQUAKE_OVERLAY_SOURCE_ID = 'earthquakes'; export const EARTHQUAKE_OVERLAY_COHORT_LIMIT = 96; export const EARTHQUAKE_OVERLAY_COLLISION_CAPACITY = 48; +/** + * The smallest magnitude the timeline marks. Most quakes are small shakes; + * M6 and up come about once every two days worldwide, so each is an event + * worth stepping to. The map still draws every quake. + */ +export const EARTHQUAKE_MARK_MAGNITUDE = 6; + +/** + * The time a world clock's timeline can show for `events` (`{mag, time}`, + * time in ms): the span of the quakes of EARTHQUAKE_MARK_MAGNITUDE and up, + * each one a mark, or null with none, so the layer never stretches the + * timeline past what its feed covers. + * @returns {{start: number, end: number, marks: number[]} | null} + */ +export function earthquakeCoverage(events) { + const marks = [ + ...new Set( + events + .filter( + ({ mag, time }) => + mag >= EARTHQUAKE_MARK_MAGNITUDE && Number.isFinite(time), + ) + .map(({ time }) => time), + ), + ].sort((a, b) => a - b); + return marks.length ? { start: marks[0], end: marks.at(-1), marks } : null; +} + // The depth bands' colours: CSS red, orange and yellow, as the renderer's // colour tuples (`[r, g, b, a]`, 0..1) and as CSS for the labels' accent. const SHALLOW = Object.freeze({ rgba: [1, 0, 0, 1], css: 'rgb(255,0,0)' }); diff --git a/src/layers/earthquakes/ownership.test.mjs b/src/layers/earthquakes/ownership.test.mjs index 45fd35dad..b242c3f51 100644 --- a/src/layers/earthquakes/ownership.test.mjs +++ b/src/layers/earthquakes/ownership.test.mjs @@ -2,6 +2,8 @@ import assert from 'node:assert/strict'; import test from 'node:test'; import { createEarthquakesLayer } from './index.js'; import { createUsgsEarthquakeSource } from './source.js'; +import { EARTHQUAKE_MARK_MAGNITUDE } from './model.js'; +import { worldClock } from '../../time/worldClock.js'; import { bindFakeDraw } from '../../testSupport/fakeDrawPort.mjs'; function harness(source) { const events = []; @@ -168,3 +170,40 @@ test('a viewer with nothing to draw with is refused at init, and init can be ret layer.destroy(); unbind(); }); +test('the timeline marks only strong quakes, while the layer is on', async () => { + assert.equal(EARTHQUAKE_MARK_MAGNITUDE, 6); + const rows = [ + { ...row, stableId: 'small', mag: 4.5, time: 1_000 }, + { ...row, stableId: 'strong', mag: 6, time: 5_000 }, + { ...row, stableId: 'great', mag: 7.2, time: 3_000 }, + { ...row, stableId: 'untimed', mag: 6.5, time: null }, + ]; + let snapshot = rows; + const h = harness({ getSnapshot: async () => snapshot }); + assert.equal(worldClock.coverage(), null, 'nothing loaded, no time to show'); + let changes = 0; + const unsubscribe = worldClock.subscribe(() => changes++); + await h.layer.update(h.viewer); + // Every quake is drawn; only M6 and up are marks, spanning their own time. + assert.equal(h.draw.find('earthquakes:').items.size, 4); + assert.deepEqual(worldClock.coverage(), { + start: 3_000, + end: 5_000, + marks: [3_000, 5_000], + }); + const told = changes; + await h.layer.update(h.viewer); + assert.equal(changes, told, 'the same strong quakes are not told again'); + snapshot = rows.slice(0, 1); + await h.layer.update(h.viewer); + assert.equal(worldClock.coverage(), null, 'small shakes alone cover no time'); + snapshot = rows; + await h.layer.update(h.viewer); + h.layer.disable(h.viewer); + assert.equal(worldClock.coverage(), null, 'off, no time to show'); + h.layer.enable(h.viewer); + assert.deepEqual(worldClock.coverage().marks, [3_000, 5_000]); + h.layer.destroy(); + assert.equal(worldClock.coverage(), null); + unsubscribe(); +}); diff --git a/src/layers/weather/clock.js b/src/layers/weather/clock.js index 1c0bb289e..9e0f7c823 100644 --- a/src/layers/weather/clock.js +++ b/src/layers/weather/clock.js @@ -198,11 +198,13 @@ export function createWeatherClock({ throw new Error(`Duplicate weather product: ${product.id}`); const entry = { product, controller: null }; registry.set(product.id, entry); - // The product moves with the world clock, and its frames are time the - // world clock's timeline can show while it is on, suspended or not, so - // the way back to live stays on screen. Both calls notify the world's - // listeners, which may destroy this clock: the release is in place - // first, and anything acquired after a destroy is let go at once. + // The product moves with the world clock, and the span of its frames is + // time the world clock's timeline can show while it is on, suspended or + // not, so the way back to live stays on screen. The frames are not + // marks: they come every few minutes, and the timeline marks only + // events. Both calls notify the world's listeners, which may destroy + // this clock: the release is in place first, and anything acquired + // after a destroy is let go at once. let unhold = null; let uncover = null; const release = () => { @@ -216,9 +218,12 @@ export function createWeatherClock({ uncover = world.register({ id: product.id, coverage: () => { - const marks = timesFor(product).map((time) => Date.parse(time)); - return marks.length - ? { start: marks[0], end: marks.at(-1), marks } + const times = timesFor(product); + return times.length + ? { + start: Date.parse(times[0]), + end: Date.parse(times.at(-1)), + } : null; }, }); diff --git a/src/layers/weather/clock.test.mjs b/src/layers/weather/clock.test.mjs index 5a5c36957..1041f69d4 100644 --- a/src/layers/weather/clock.test.mjs +++ b/src/layers/weather/clock.test.mjs @@ -367,7 +367,7 @@ test('weather clocks sharing a world: the last one destroyed leaves it live', () assert.equal(world.isPlaying(), false); }); -test('each product’s frames are world clock coverage, and support the timeline while shown', (t) => { +test('each product’s frames span world clock coverage, with no marks, and support the timeline while shown', (t) => { const { clock, world } = harness(t); assert.equal(world.coverage(), null); assert.equal(world.getState().supported, false); @@ -377,11 +377,15 @@ test('each product’s frames are world clock coverage, and support the timeline assert.deepEqual(world.coverage(), { start: Date.parse(time(0)), end: Date.parse(time(10)), - marks: [0, 5, 10].map((m) => Date.parse(time(m))), + marks: [], }); assert.equal(world.getState().supported, true); unregister(); - assert.deepEqual(world.coverage().marks, [Date.parse(time(5))]); + assert.deepEqual(world.coverage(), { + start: Date.parse(time(5)), + end: Date.parse(time(5)), + marks: [], + }); clock.destroy(); assert.equal(world.coverage(), null); assert.equal(world.getState().supported, false); @@ -394,10 +398,11 @@ test('a suspended product keeps its coverage, so the way back to live stays', (t radar.suspended = true; void clock.refresh(); assert.equal(world.getState().supported, true); - assert.deepEqual( - world.coverage().marks, - [0, 10].map((m) => Date.parse(time(m))), - ); + assert.deepEqual(world.coverage(), { + start: Date.parse(time(0)), + end: Date.parse(time(10)), + marks: [], + }); }); test('new frames reach the world clock through refresh', (t) => { diff --git a/src/layers/weather/index.js b/src/layers/weather/index.js index 7e2fa0d75..83f52d86e 100644 --- a/src/layers/weather/index.js +++ b/src/layers/weather/index.js @@ -64,11 +64,12 @@ const utc = (value) => /** * Move `world`, the world clock, as its timeline does: `play` toggles play - * (from the start of the covered time when live), `latest` goes live, and - * `step` (-1 or 1) goes to the previous or next mark, a weather frame among - * them, as the timeline's arrow keys do. + * (from the start of the covered time when live) and `latest` goes live. + * `step` (-1 or 1) goes to the previous or next of `frames`, the weather + * frames; the timeline does not mark them, so this is the row's own way to + * step through them. */ -function moveWorldTime(world, { play, latest, step }) { +function moveWorldTime(world, frames, { play, latest, step }) { if (!world) return; if (play === true) { const state = world.getState(); @@ -82,11 +83,14 @@ function moveWorldTime(world, { play, latest, step }) { if (latest === true) world.goLive(); if (step === -1 || step === 1) { const at = world.getState().timeMs; - const marks = world.coverage()?.marks ?? []; + const times = frames + .map((time) => Date.parse(time)) + .filter(Number.isFinite) + .sort((a, b) => a - b); const to = step < 0 - ? marks.findLast((mark) => mark < at) - : marks.find((mark) => mark > at); + ? times.findLast((frame) => frame < at) + : times.find((frame) => frame > at); if (to === undefined) return; world.pause(); world.seek(to); @@ -485,8 +489,15 @@ export function createWeatherLayer({ }); } // Time is the world's: these move the world clock as its timeline - // does, and every layer that follows it moves along. - if (enabled) moveWorldTime(clock.world, params); + // does, and every layer that follows it moves along. A step goes + // through every shown observation's frames, and this row's own even + // while it is suspended. + if (enabled) + moveWorldTime( + clock.world, + [...clock.getTimeline(), ...(manifest?.times ?? [])], + params, + ); notify(); }, getParams() { diff --git a/src/layers/weather/weather.test.mjs b/src/layers/weather/weather.test.mjs index 1280c5d2c..c44f8c177 100644 --- a/src/layers/weather/weather.test.mjs +++ b/src/layers/weather/weather.test.mjs @@ -678,8 +678,12 @@ test('without a clock the layer keeps one of its own on the world clock and lets h.stages[0].finish(); await update; assert.equal(worldClock.follows('weather-radar'), true); - for (const time of times) - assert.ok(worldClock.coverage().marks.includes(Date.parse(time))); + // The frames span the timeline's time; they are not marks on it. + assert.deepEqual(worldClock.coverage(), { + start: Date.parse(times[0]), + end: Date.parse(times.at(-1)), + marks: [], + }); h.layer.setParams({ play: true }); assert.equal(worldClock.isPlaying(), true); assert.equal(worldClock.getState().stepping, false); @@ -702,7 +706,7 @@ test('without a clock the layer keeps one of its own on the world clock and lets assert.ok(h.clears() >= 1); }); -test('reduced motion offers no play; steps still move the world clock from mark to mark', async () => { +test('reduced motion offers no play; steps still move the world clock from frame to frame', async () => { const h = layerHarness({ reducedMotion: true }); const update = h.layer.update(); await flush(); @@ -712,8 +716,8 @@ test('reduced motion offers no play; steps still move the world clock from mark h.layer.getRowControls().chips.some((chip) => chip.id === 'play'), false, ); - // As the timeline's arrow keys do, a step back from live goes to the - // newest frame, and the next one back to the frame before it. + // A step back from live goes to the newest frame, and the next one back + // to the frame before it. h.layer.setParams({ step: -1 }); await flush(); assert.equal(worldClock.now(), Date.parse(times[2])); @@ -742,7 +746,7 @@ test('a row steps forward and plays from a past time through the world clock', a assert.equal( worldClock.now(), Date.parse(times[2]), - 'no mark after the newest frame', + 'no frame after the newest', ); worldClock.seek(Date.parse(times[1])); await flush(); @@ -1866,8 +1870,8 @@ test('a row steps the world clock through every registered observation; missing .chips.filter(({ id }) => ['previous', 'play', 'next', 'latest'].includes(id), ); - // As the timeline's arrow keys do, a step back from live goes to the - // newest frame, and the next one back to the frame before it. + // A step back from live goes to the newest frame, and the next one back + // to the frame before it. radar.layer.setParams({ step: -1 }); await flush(); assert.equal(clock.getState().target, times[2]); diff --git a/src/ui/views/panels/WorldTimeline.vue b/src/ui/views/panels/WorldTimeline.vue index 866380638..2c8e2981b 100644 --- a/src/ui/views/panels/WorldTimeline.vue +++ b/src/ui/views/panels/WorldTimeline.vue @@ -294,10 +294,10 @@ const scrub = (event) => { } store.scrub(Number(event.target.value), viewLength()); }; -// Arrows go to the previous or next mark (a launch, a frame), or a step along -// the track as shown; Page keys take a tenth of it; Home and End go to the -// ends of all of it. Plus and minus zoom, and zero shows it all; with a -// modifier they are the browser's own zoom. +// Arrows go to the previous or next mark (a launch, a strong earthquake), or +// a step along the track as shown where there is none; Page keys take a tenth +// of it; Home and End go to the ends of all of it. Plus and minus zoom, and +// zero shows it all; with a modifier they are the browser's own zoom. const ZOOM_KEYS = ['+', '=', '-', '0']; const onKey = (event) => { if (ZOOM_KEYS.includes(event.key)) {