mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
Trim the doc text this PR adds (README, CHANGELOG, CURRENT-STATE, KNOWN-ISSUES, SECURITY, DATA_SOURCES, .env.example, the CI job comment), drop code comments that restate the code, cut design-note JSDoc to a line or two, and drop review tags from test names. Comments only; no code changes. Also: README key count (seven keys, two metered), CURRENT-STATE's gate paragraph (CI runs a production build with a dummy token), the stacked doc above meshBoxInRange and the orphaned inMeshRange line in coverage.js, and a duplicate ALPR row in DATA_SOURCES that a merge had brought back. Co-Authored-By: Claude Opus 5.5 <[email protected]>
326 lines
10 KiB
JavaScript
326 lines
10 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import * as Cesium from 'cesium';
|
|
import { MESH_CELL_DEG } from '../../meshSampler.js';
|
|
import { createSequences } from './sequences.js';
|
|
|
|
// The cone glyphs draw on a canvas; Node has none, so any drawing is a no-op.
|
|
const noop = () => {};
|
|
const context2d = new Proxy({}, { get: () => noop, set: () => true });
|
|
globalThis.document ??= {
|
|
createElement: () => ({ getContext: () => context2d }),
|
|
};
|
|
|
|
const settle = () => new Promise((resolve) => setTimeout(resolve, 0));
|
|
|
|
/** A billboard collection that remembers the cones on the globe. */
|
|
function cones() {
|
|
const items = [];
|
|
return {
|
|
items,
|
|
show: true,
|
|
add(options) {
|
|
items.push(options);
|
|
return options;
|
|
},
|
|
removeAll() {
|
|
items.length = 0;
|
|
},
|
|
};
|
|
}
|
|
|
|
/** A source whose sequence lookups the test answers, one call at a time. */
|
|
function deferredSource() {
|
|
const calls = [];
|
|
return {
|
|
calls,
|
|
getSequenceImages(sequenceId, { signal } = {}) {
|
|
return new Promise((resolve, reject) => {
|
|
calls.push({ sequenceId, signal, resolve, reject });
|
|
});
|
|
},
|
|
/** The latest lookup for a sequence. */
|
|
last(sequenceId) {
|
|
return calls.filter((call) => call.sequenceId === sequenceId).at(-1);
|
|
},
|
|
};
|
|
}
|
|
|
|
/** Graph image records for a sequence, a few metres apart. */
|
|
function records(sequenceId, count = 2) {
|
|
return Array.from({ length: count }, (_, i) => ({
|
|
id: `${sequenceId}-${i}`,
|
|
geometry: { coordinates: [-121.49 + i * 0.001, 38.58] },
|
|
compass_angle: 90,
|
|
captured_at: 1_700_000_000_000 + i,
|
|
}));
|
|
}
|
|
|
|
function setup() {
|
|
const source = deferredSource();
|
|
const colours = [];
|
|
const errors = [];
|
|
const state = {
|
|
services: {},
|
|
viewer: {},
|
|
context: {
|
|
notify() {},
|
|
getFilter: () => ({ pano: 'all', sinceMs: null }),
|
|
getSurface: () => 'draped',
|
|
groundCaster: null,
|
|
meshSampler: null,
|
|
actions: { reportError: (message) => errors.push(message) },
|
|
},
|
|
sequence: {
|
|
selectedId: null,
|
|
images: [],
|
|
cache: new Map(),
|
|
collection: cones(),
|
|
loading: false,
|
|
abort: null,
|
|
},
|
|
};
|
|
const parts = {
|
|
coverage: {
|
|
recolorSequence: (id, selected) => colours.push([id, selected]),
|
|
},
|
|
};
|
|
const sequences = createSequences({ state, source, parts });
|
|
const drawn = () =>
|
|
state.sequence.collection.items.map((cone) => cone.id.split(':').at(-1));
|
|
return { state, source, sequences, colours, errors, drawn };
|
|
}
|
|
|
|
test('a failed sequence load leaves no stale cones and can be retried', async () => {
|
|
const { state, source, sequences, colours, errors, drawn } = setup();
|
|
sequences.select('A');
|
|
source.last('A').resolve(records('A'));
|
|
await settle();
|
|
assert.deepEqual(drawn(), ['A-0', 'A-1']);
|
|
|
|
sequences.select('B');
|
|
assert.deepEqual(drawn(), [], "A's cones go while B loads");
|
|
source.last('B').reject(new Error('Sequence images unavailable'));
|
|
await settle();
|
|
assert.deepEqual(drawn(), [], 'nothing of A is left to click');
|
|
assert.equal(state.sequence.loading, false);
|
|
assert.equal(state.sequence.selectedId, null, 'B is not left highlighted');
|
|
assert.deepEqual(colours.at(-1), ['B', false]);
|
|
assert.deepEqual(errors, [null, 'Sequence images unavailable']);
|
|
|
|
// Clicking B again asks again.
|
|
sequences.select('B');
|
|
assert.equal(source.calls.filter((c) => c.sequenceId === 'B').length, 2);
|
|
source.last('B').resolve(records('B'));
|
|
await settle();
|
|
assert.deepEqual(drawn(), ['B-0', 'B-1']);
|
|
assert.equal(state.sequence.selectedId, 'B');
|
|
assert.equal(errors.at(-1), null, 'the error is cleared once B loads');
|
|
});
|
|
|
|
test('a late answer for a superseded sequence neither draws nor is cached', async () => {
|
|
const { state, source, sequences, drawn } = setup();
|
|
sequences.select('A');
|
|
sequences.select('B');
|
|
assert.equal(source.last('A').signal.aborted, true, 'A was cancelled');
|
|
source.last('B').resolve(records('B'));
|
|
await settle();
|
|
source.last('A').resolve(records('A'));
|
|
await settle();
|
|
assert.deepEqual(drawn(), ['B-0', 'B-1']);
|
|
assert.equal(state.sequence.selectedId, 'B');
|
|
assert.equal(state.sequence.cache.has('A'), false);
|
|
assert.equal(state.sequence.loading, false);
|
|
});
|
|
|
|
test('a second click on a loading sequence does not start another lookup', async () => {
|
|
const { source, sequences } = setup();
|
|
sequences.select('A');
|
|
sequences.select('A');
|
|
assert.equal(source.calls.length, 1);
|
|
assert.equal(source.calls[0].signal.aborted, false);
|
|
});
|
|
|
|
test('a cached sequence is re-selected without a lookup', async () => {
|
|
const { state, source, sequences, drawn } = setup();
|
|
sequences.select('A');
|
|
source.last('A').resolve(records('A'));
|
|
await settle();
|
|
sequences.select('B');
|
|
source.last('B').resolve(records('B'));
|
|
await settle();
|
|
sequences.select('A');
|
|
assert.equal(source.calls.length, 2, 'A came from the cache');
|
|
assert.deepEqual(drawn(), ['A-0', 'A-1'], 'drawn at once');
|
|
assert.equal(state.sequence.loading, false);
|
|
assert.equal(state.sequence.selectedId, 'A');
|
|
});
|
|
|
|
test('clearSelection cancels the lookup and uncolours the sequence', async () => {
|
|
const { state, source, sequences, colours, errors, drawn } = setup();
|
|
sequences.select('A');
|
|
sequences.clearSelection();
|
|
assert.equal(source.last('A').signal.aborted, true);
|
|
assert.deepEqual(colours, [
|
|
['A', true],
|
|
['A', false],
|
|
]);
|
|
assert.equal(state.sequence.selectedId, null);
|
|
assert.equal(state.sequence.loading, false);
|
|
assert.equal(errors.at(-1), null, 'an error about it goes too');
|
|
source.last('A').resolve(records('A'));
|
|
await settle();
|
|
assert.deepEqual(drawn(), [], 'the late answer draws nothing');
|
|
});
|
|
|
|
/**
|
|
* Terrain mode with bare earth at 10 m, a mesh sampler the test drives, and
|
|
* cones that log every change made to them.
|
|
*/
|
|
function terrainSetup() {
|
|
const context = setup();
|
|
const { state } = context;
|
|
const mesh = new Map();
|
|
const cell = (lon, lat) =>
|
|
`${Math.round(lon / MESH_CELL_DEG)},${Math.round(lat / MESH_CELL_DEG)}`;
|
|
let announce = null;
|
|
state.context.getSurface = () => 'terrain';
|
|
state.context.groundCaster = {
|
|
groundAt: () => 10,
|
|
prepare: async () => true,
|
|
};
|
|
state.context.meshSampler = {
|
|
request() {},
|
|
meshAt: (lon, lat) => mesh.get(cell(lon, lat)),
|
|
onSampled: (listener) => {
|
|
announce = listener;
|
|
return () => (announce = null);
|
|
},
|
|
};
|
|
const changes = [];
|
|
const items = [];
|
|
state.sequence.collection = {
|
|
items,
|
|
show: true,
|
|
add(options) {
|
|
changes.push(['add', options.id]);
|
|
const cone = new Proxy(options, {
|
|
set(target, key, value) {
|
|
changes.push([key, target.id]);
|
|
target[key] = value;
|
|
return true;
|
|
},
|
|
});
|
|
items.push(cone);
|
|
return cone;
|
|
},
|
|
removeAll() {
|
|
changes.push(['removeAll']);
|
|
items.length = 0;
|
|
},
|
|
};
|
|
// Created again, so it listens to this sampler.
|
|
const sequences = createSequences({
|
|
state,
|
|
source: context.source,
|
|
parts: { coverage: { recolorSequence() {} } },
|
|
});
|
|
/** Sample the mesh under a point, then announce it as the sampler does. */
|
|
function sample(lon, lat, height) {
|
|
const centre = [
|
|
Math.round(lon / MESH_CELL_DEG) * MESH_CELL_DEG,
|
|
Math.round(lat / MESH_CELL_DEG) * MESH_CELL_DEG,
|
|
];
|
|
mesh.set(cell(lon, lat), height);
|
|
announce([centre]);
|
|
}
|
|
const heightOf = (cone) =>
|
|
Cesium.Cartographic.fromCartesian(cone.position).height;
|
|
return { ...context, sequences, changes, items, sample, heightOf };
|
|
}
|
|
|
|
test('a mesh sample away from the selected sequence changes no cone', async () => {
|
|
const { source, sequences, changes, items, sample } = terrainSetup();
|
|
sequences.select('A');
|
|
source.last('A').resolve(records('A', 3));
|
|
await settle();
|
|
assert.equal(items.length, 3);
|
|
changes.length = 0;
|
|
sample(-121.3, 38.7, 12); // a street elsewhere in the tile
|
|
assert.deepEqual(changes, [], 'nothing rebuilt or moved');
|
|
});
|
|
|
|
test('a mesh sample under a cone moves that cone in place, and no other', async () => {
|
|
const { source, sequences, changes, items, sample, heightOf } =
|
|
terrainSetup();
|
|
sequences.select('A');
|
|
source.last('A').resolve(records('A', 3));
|
|
await settle();
|
|
const before = items.map(heightOf);
|
|
changes.length = 0;
|
|
// The road under the second image is 2.5 m above the bare earth.
|
|
sample(-121.489, 38.58, 12.5);
|
|
assert.ok(
|
|
changes.every(([, id]) => id === 'mly:img:A-1'),
|
|
`only A-1 changed: ${JSON.stringify(changes)}`,
|
|
);
|
|
assert.ok(
|
|
changes.some(([key]) => key === 'position'),
|
|
'A-1 moved',
|
|
);
|
|
assert.equal(
|
|
changes.some(([key]) => key === 'removeAll' || key === 'add'),
|
|
false,
|
|
'the collection is not rebuilt',
|
|
);
|
|
const after = items.map(heightOf);
|
|
assert.ok(
|
|
Math.abs(after[1] - 13.5) < 0.01,
|
|
`A-1 stands on the road (${after[1]})`,
|
|
);
|
|
assert.deepEqual([after[0], after[2]], [before[0], before[2]]);
|
|
});
|
|
|
|
test('cones behind the globe are hidden, and show again from the other side', async () => {
|
|
const { state, source, sequences } = setup();
|
|
const view = { lon: -121.49, lat: 38.58, height: 20_000_000 };
|
|
const preRender = new Set();
|
|
state.viewer = {
|
|
camera: {
|
|
get positionWC() {
|
|
return Cesium.Cartesian3.fromDegrees(view.lon, view.lat, view.height);
|
|
},
|
|
},
|
|
scene: {
|
|
preRender: {
|
|
addEventListener(listener) {
|
|
preRender.add(listener);
|
|
return () => preRender.delete(listener);
|
|
},
|
|
},
|
|
},
|
|
};
|
|
sequences.select('A');
|
|
// One image under the camera, one near its antipode.
|
|
source.last('A').resolve([
|
|
...records('A', 1),
|
|
{
|
|
id: 'A-far',
|
|
geometry: { coordinates: [58.51, -38.58] },
|
|
captured_at: 1_800_000_000_000,
|
|
},
|
|
]);
|
|
await settle();
|
|
const [near, far] = state.sequence.collection.items;
|
|
assert.equal(near.show, true, 'the near side stays visible');
|
|
assert.equal(far.show, false, 'the far side does not show through');
|
|
// Fly round to the other hemisphere: the two swap.
|
|
view.lon = 58.51;
|
|
view.lat = -38.58;
|
|
for (const listener of [...preRender]) listener();
|
|
assert.equal(near.show, false);
|
|
assert.equal(far.show, true);
|
|
sequences.clearSelection();
|
|
assert.equal(preRender.size, 0, 'the cull listener is gone');
|
|
});
|