perf(shipwrecks): draw the wreck markers from one billboard collection, on the wreck, and rebuild them only on new data

- The ~8,000 markers were one Cesium entity each; they are now one
  BillboardCollection (as FIRMS, vessels and wildlife sightings do), ordered
  at the bottom of the shared sprite stack so moving traffic draws over it.
- eyeOffset.z was the death toll in metres, so a 1,500-death wreck's marker
  sat 1.5 km toward the camera and clipped or drifted when close. It is gone;
  markers are added by rising toll, so a bigger toll still draws on top.
- The page asks every 6 h but the proxy changes data at most daily: the proxy
  now sends a version that changes with either source's data, and the layer
  rebuilds only when it does.
- Adds a controller test: enable/disable, teardown, draw order, unchanged
  snapshots, a late response after turning off, and the period closing an
  open card.
This commit is contained in:
Sameh Khamis committed 2026-11-10 13:25:03 -08:00
1 parent 3b52e24140
commit 38ba8a3b59
7 files changed
+275 -34

No files matched your search

+210
View File
@@ -0,0 +1,210 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import * as Cesium from 'cesium';
import * as picking from '../../data/pickRegistry.js';
import { createShipwrecksLayer, markerPixelSize } from './index.js';
const wreck = (id, extra = {}) => ({
id,
source: 'wikidata',
name: id,
lat: 50,
lon: -1,
year: 1912,
date: null,
casualties: null,
...extra,
});
const snapshot = (records, version = 'v1') => ({
records,
fetchedAt: 1,
stale: false,
version,
sources: { emodnet: true, wikidata: true },
});
function deferred() {
let resolve;
const promise = new Promise((done) => {
resolve = done;
});
return { promise, resolve };
}
/** A fake billboard collection that records what the layer adds. */
function fakeMarkers() {
const collection = {
show: true,
billboards: [],
rebuilds: 0,
add(options) {
const billboard = { show: true, ...options };
collection.billboards.push(billboard);
return billboard;
},
removeAll() {
collection.rebuilds++;
collection.billboards = [];
},
};
return collection;
}
function harness({ snapshots } = {}) {
const markers = fakeMarkers();
const primitives = [];
const cards = [];
const handlers = [];
const opened = [];
let pickResult = null;
const viewer = {
camera: { positionWC: Cesium.Cartesian3.fromDegrees(-1, 50, 2e6) },
scene: {
canvas: {},
requestRender() {},
pick: () => pickResult,
preRender: { addEventListener: () => () => {} },
primitives: {
add: (primitive) => primitives.push(primitive),
remove: (primitive) =>
primitives.splice(primitives.indexOf(primitive), 1),
raiseToTop() {},
contains: (primitive) => primitives.includes(primitive),
},
},
};
const queue = [...(snapshots || [])];
const requests = [];
const layer = createShipwrecksLayer({
source: {
getSnapshot({ signal }) {
requests.push(signal);
const next = queue.shift();
return next instanceof Promise ? next : Promise.resolve(next);
},
},
createMarkers: () => markers,
overlayHost: {
setEntries: (_source, entries) => cards.push(entries),
setVisible() {},
hitTest: () => null,
},
screenSpaceEventHandlerFactory: () => {
const handler = {
setInputAction(callback) {
handler.click = callback;
},
destroy() {
handler.destroyed = true;
},
};
handlers.push(handler);
return handler;
},
picking,
pointer: { isPointerFree: () => true },
openExternal: (url) => opened.push(url),
});
layer.init(viewer);
return {
layer,
markers,
primitives,
cards,
handlers,
requests,
opened,
pick(id) {
pickResult = id ? { id: `shipwreck:${id}` } : null;
},
lastCard: () => cards.at(-1),
};
}
test('markers live in one collection, shown only while the layer is on', async () => {
const h = harness({ snapshots: [snapshot([wreck('a'), wreck('b')])] });
assert.deepEqual(h.primitives, [h.markers]);
assert.equal(h.markers.show, false);
h.layer.enable();
assert.equal(h.markers.show, true);
assert.equal(await h.layer.update(), true);
assert.equal(h.markers.billboards.length, 2);
assert.equal(h.layer.getStats().count, 2);
h.layer.disable();
assert.equal(h.markers.show, false);
assert.equal(h.handlers[0].destroyed, true);
h.layer.destroy();
assert.deepEqual(h.primitives, [], 'the collection leaves the scene');
});
test('markers sit on the wreck: no eye offset, bigger toll drawn last', async () => {
const h = harness({
snapshots: [
snapshot([
wreck('big', { casualties: 1500 }),
wreck('none'),
wreck('small', { casualties: 3 }),
]),
],
});
h.layer.enable();
await h.layer.update();
const ids = h.markers.billboards.map((billboard) => billboard.id);
assert.deepEqual(ids, ['shipwreck:none', 'shipwreck:small', 'shipwreck:big']);
for (const billboard of h.markers.billboards)
assert.equal(billboard.eyeOffset, undefined);
assert.equal(h.markers.billboards[2].width, markerPixelSize(1500));
});
test('an unchanged snapshot does not rebuild the markers', async () => {
const records = [wreck('a')];
const h = harness({
snapshots: [
snapshot(records, 'v1'),
snapshot(records, 'v1'),
snapshot([wreck('a'), wreck('b')], 'v2'),
],
});
h.layer.enable();
await h.layer.update();
await h.layer.update();
assert.equal(h.markers.rebuilds, 1);
await h.layer.update();
assert.equal(h.markers.rebuilds, 2);
assert.equal(h.markers.billboards.length, 2);
});
test('a response that arrives after the layer is turned off is ignored', async () => {
const late = deferred();
const h = harness({ snapshots: [late.promise] });
h.layer.enable();
const pending = h.layer.update();
h.layer.disable();
assert.equal(h.requests[0].aborted, true);
late.resolve(snapshot([wreck('a')]));
assert.equal(await pending, false);
assert.equal(h.markers.billboards.length, 0);
});
test('a click opens the card; a period that excludes the wreck closes it', async () => {
const h = harness({
snapshots: [
snapshot([wreck('old', { year: 1850 }), wreck('new', { year: 1990 })]),
],
});
h.layer.enable();
await h.layer.update();
h.pick('old');
h.handlers[0].click({ position: { x: 1, y: 1 } });
const [card] = h.lastCard();
assert.equal(card.id, 'shipwreck-card:old');
h.layer.setParams({ from: 1900, to: 1990 });
assert.deepEqual(h.lastCard(), [], 'the hidden wreck loses its card');
const shown = h.markers.billboards.filter((billboard) => billboard.show);
assert.deepEqual(
shown.map((billboard) => billboard.id),
['shipwreck:new'],
);
assert.equal(h.layer.getStats().count, 1);
});