mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-21 02:32:18 +00:00
Main gained three imagery providers (Google Street View, KartaView,
Panoramax), shared line-coverage, cone and photo-viewer modules, one source
lit at a time and the translated interface. Their shared modules still
carried what this branch removes, so the merge ports them onto it:
- lineCoverage.js is this branch's coverage.js made provider-neutral
(draped lines near the ground only, the selection drawn over them, key
and rate-limit blocking); sequenceCones.js is sequences.js the same way.
Mapillary, KartaView and Panoramax all build on them; Mapillary moves
back to providers/mapillary/ beside the others.
- No ground casting, mesh sampling, surface modes, FOLLOW, legend, prewarm,
orbit overview points (Panoramax's density dots included), stale-tile
swaps or water-filled point budget come back.
- Kept from main because the new providers need them: requiresMapStack and
attachMapStackController (Street View on Google 3D only), ground clicks,
openNearest with an optional provider nearestImage, openImage {frame},
reportError, the view-cone marker (now an SVG glyph), filters /
coverageLabel / sinceBasis, OPEN STREET VIEW, keyAlternatives and i18n.
- photoViewer.js treats the viewer as expanded when its wrap is full screen
or the iPhone popover, as EXPAND now is.
- The fixture browser gate keeps its 8 steps and adds one each for
KartaView and Panoramax; catalogs, docs, boundaries and format scope
follow.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
218 lines
7.1 KiB
JavaScript
218 lines
7.1 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import * as Cesium from 'cesium';
|
|
import { resolveFilter } from './filter.js';
|
|
import { createSequenceCones, thinImages } from './sequenceCones.js';
|
|
|
|
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();
|
|
/** Every highlight asked of the coverage: a sequence id, or null for none. */
|
|
const highlights = [];
|
|
const state = {
|
|
services: {},
|
|
viewer: {},
|
|
filter: { pano: 'all', sinceDays: 0 },
|
|
context: {
|
|
getFilter: () => resolveFilter(state.filter),
|
|
notify() {},
|
|
},
|
|
sequence: {
|
|
selectedId: null,
|
|
images: [],
|
|
collection: cones(),
|
|
loading: false,
|
|
error: null,
|
|
abort: null,
|
|
},
|
|
};
|
|
const sequences = createSequenceCones({
|
|
state,
|
|
async loadImages(sequenceId, { signal }) {
|
|
const list = await source.getSequenceImages(sequenceId, { signal });
|
|
return thinImages(
|
|
list.map((record) => ({
|
|
id: String(record.id),
|
|
lon: record.geometry.coordinates[0],
|
|
lat: record.geometry.coordinates[1],
|
|
compassAngle: Number(record.compass_angle) || 0,
|
|
capturedAt: Number(record.captured_at) || 0,
|
|
isPano: record.is_pano === true,
|
|
})),
|
|
);
|
|
},
|
|
colors: { coverage: '#05cb63' },
|
|
pickPrefix: 'mly:img:',
|
|
spriteId: 'street-level:test-cones',
|
|
renderKey: 'test-sequence',
|
|
onHighlight: (id) => highlights.push(id),
|
|
});
|
|
const drawn = () =>
|
|
state.sequence.collection.items.map((cone) => cone.id.split(':').at(-1));
|
|
return { state, source, sequences, highlights, drawn };
|
|
}
|
|
|
|
test('a failed sequence load leaves no stale cones and can be retried', async () => {
|
|
const { state, source, sequences, highlights, 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.equal(highlights.at(-1), null);
|
|
assert.equal(state.sequence.error, 'Sequence images unavailable');
|
|
|
|
// Clicking B again asks again, without the old error.
|
|
sequences.select('B');
|
|
assert.equal(source.calls.filter((c) => c.sequenceId === 'B').length, 2);
|
|
assert.equal(state.sequence.error, null, 'not shown while B loads again');
|
|
source.last('B').resolve(records('B'));
|
|
await settle();
|
|
assert.deepEqual(drawn(), ['B-0', 'B-1']);
|
|
assert.equal(state.sequence.selectedId, 'B');
|
|
assert.equal(state.sequence.error, null, 'cleared once B loads');
|
|
});
|
|
|
|
test('a late answer for a superseded sequence draws nothing', 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.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('clearSelection cancels the lookup and drops the highlight', async () => {
|
|
const { state, source, sequences, highlights, drawn } = setup();
|
|
sequences.select('A');
|
|
sequences.clearSelection();
|
|
assert.equal(source.last('A').signal.aborted, true);
|
|
assert.deepEqual(highlights, ['A', null]);
|
|
assert.equal(state.sequence.selectedId, null);
|
|
assert.equal(state.sequence.loading, false);
|
|
assert.equal(state.sequence.error, null, 'an error about it goes too');
|
|
source.last('A').resolve(records('A'));
|
|
await settle();
|
|
assert.deepEqual(drawn(), [], 'the late answer draws nothing');
|
|
});
|
|
|
|
test('cones are clamped to the ground and turned to their compass angle', async () => {
|
|
const { state, source, sequences } = setup();
|
|
sequences.select('A');
|
|
source.last('A').resolve(records('A', 2));
|
|
await settle();
|
|
const items = state.sequence.collection.items;
|
|
assert.equal(items.length, 2);
|
|
for (const cone of items) {
|
|
assert.equal(cone.heightReference, Cesium.HeightReference.CLAMP_TO_GROUND);
|
|
assert.equal(cone.rotation, -Cesium.Math.toRadians(90));
|
|
}
|
|
});
|
|
|
|
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');
|
|
});
|