mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-17 16:52:20 +00:00
- A link's photo step compares with the navigation token its own restore flight owned, so a navigation after the flight landed (while the layers still load) keeps the camera. - A request that switches the source keeps the open photo up until it is replaced (holdViewer), so EXPAND stays across sources. - A lookup given up while it looked leaves the open photo and the panel as they were, also when it found nothing or failed. - A failed replacement shows its error inside the expanded viewer. - A replacing lookup stops a playing Mapillary sequence before the found photo opens. - The action refuses coordinates outside the globe, keeps a name given with coordinates as its label, and fly: false keeps the camera only for coordinates (its test-only entity and query branches are gone). - Numbered entities carry their label; a view's street-level point is a pair. - Mapillary's nearest search always asks for 50 m and 100 images. - Tests: the lifecycle reproductions, PLAY on replacement, out-of-range coordinates, half a point, and the named label; three layer tests share enabledLayer; the second payload digest is gone. - Docs: the tool count, the panel freshness rule, armed: false, the photo replacement, the browser-gate comment and a shorter changelog fragment.
211 lines
7.0 KiB
JavaScript
211 lines
7.0 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import * as Cesium from 'cesium';
|
|
import { createMapillaryProvider } from './index.js';
|
|
import { mapillaryImageUrl } from './policy.js';
|
|
import { sequenceIdFromPick } from '../../lineCoverage.js';
|
|
import { thinImages } from '../../sequenceCones.js';
|
|
import { validateProviders } from '../../registry.js';
|
|
import {
|
|
fakeMapillarySource,
|
|
rayCamera,
|
|
} from '../../../../testSupport/streetLevelFakes.mjs';
|
|
|
|
function fakeContext(filter = { pano: 'all', sinceMs: null }) {
|
|
const opened = [];
|
|
return {
|
|
opened,
|
|
services: {},
|
|
getFilter: () => filter,
|
|
isActive: () => true,
|
|
notify: () => {},
|
|
actions: { openImage: (id) => opened.push(id) },
|
|
};
|
|
}
|
|
|
|
test('the definition satisfies the Street Level provider contract', () => {
|
|
const def = createMapillaryProvider({ source: fakeMapillarySource() });
|
|
assert.doesNotThrow(() => validateProviders([def]));
|
|
assert.equal(def.id, 'mapillary');
|
|
assert.equal(def.label, 'MAPILLARY');
|
|
assert.equal(def.requiresKeyId, 'mapillary');
|
|
assert.equal(def.pickPrefix, 'mly:');
|
|
assert.match(def.credit.html, /CC BY-SA 4\.0/);
|
|
// One colour per source: Mapillary is green everywhere it draws.
|
|
assert.equal(def.colors.coverage, '#05cb63');
|
|
assert.throws(() => createMapillaryProvider({ source: {} }), /source/);
|
|
});
|
|
|
|
test('image deep links match the mapillary.com share format', () => {
|
|
assert.equal(
|
|
mapillaryImageUrl(1814275685699406),
|
|
'https://www.mapillary.com/app/?pKey=1814275685699406&focus=photo',
|
|
);
|
|
assert.equal(mapillaryImageUrl(' '), 'https://www.mapillary.com/app/');
|
|
});
|
|
|
|
test('picks route sequences to selection and images to the core opener', () => {
|
|
const context = fakeContext();
|
|
const instance = createMapillaryProvider({
|
|
source: fakeMapillarySource(),
|
|
}).create(context);
|
|
assert.equal(instance.handlePick('mly:img:77'), true);
|
|
assert.deepEqual(context.opened, ['77']);
|
|
assert.equal(instance.handlePick('cctv:1'), false);
|
|
assert.deepEqual(instance.sequenceStats(), {
|
|
selectedId: null,
|
|
images: 0,
|
|
loading: false,
|
|
error: null,
|
|
});
|
|
});
|
|
|
|
test('a line pick names its sequence; anything else is not a sequence', () => {
|
|
assert.equal(sequenceIdFromPick('mly:seq:abc', 'mly:seq:'), 'abc');
|
|
assert.equal(sequenceIdFromPick('mly:img:abc', 'mly:seq:'), null);
|
|
assert.equal(sequenceIdFromPick(null, 'mly:seq:'), null);
|
|
});
|
|
|
|
test('cone thinning across the date line drops images metres apart', () => {
|
|
const image = (id, lon) => ({ id, lon, lat: 0 });
|
|
// A sequence driving east over ±180° with images ~1 m apart, then ~11 m on.
|
|
const kept = thinImages(
|
|
[
|
|
image('a', 179.99999),
|
|
image('b', -179.99999), // ~2 m from a, across the date line
|
|
image('c', -179.9999), // ~11 m from a
|
|
],
|
|
3,
|
|
);
|
|
assert.deepEqual(
|
|
kept.map(({ id }) => id),
|
|
['a', 'c'],
|
|
);
|
|
});
|
|
|
|
/** A viewer looking straight down on downtown Sacramento from 900 m. */
|
|
function streetViewer() {
|
|
const collection = () => ({
|
|
add: (item) => item,
|
|
remove: () => true,
|
|
contains: () => false,
|
|
get length() {
|
|
return 0;
|
|
},
|
|
});
|
|
const event = () => ({ addEventListener: () => () => {} });
|
|
const camera = Object.assign(
|
|
rayCamera({
|
|
lon: -121.4944,
|
|
lat: 38.5816,
|
|
altitude: 900,
|
|
pitch: -90,
|
|
width: 100,
|
|
height: 100,
|
|
}),
|
|
{ changed: event(), moveEnd: event() },
|
|
);
|
|
return {
|
|
camera,
|
|
scene: {
|
|
canvas: { clientWidth: 100, clientHeight: 100 },
|
|
globe: { show: false, ellipsoid: Cesium.Ellipsoid.WGS84 },
|
|
primitives: collection(),
|
|
groundPrimitives: collection(),
|
|
preRender: event(),
|
|
postRender: event(),
|
|
requestRender() {},
|
|
},
|
|
};
|
|
}
|
|
|
|
test('coverage asks for no tiles before the key status is known, and none without a key', async (t) => {
|
|
// Skip Cesium's one-time terrain table download for draped lines.
|
|
t.mock.method(
|
|
Cesium.GroundPolylinePrimitive,
|
|
'initializeTerrainHeights',
|
|
async () => {},
|
|
);
|
|
for (const configured of [false, true]) {
|
|
let answer;
|
|
const tiles = [];
|
|
const source = fakeMapillarySource({
|
|
hasToken: () => configured,
|
|
getStatus: () => new Promise((resolve) => (answer = resolve)),
|
|
getTile: (...args) => {
|
|
tiles.push(args);
|
|
return new Promise(() => {});
|
|
},
|
|
});
|
|
const instance = createMapillaryProvider({ source }).create(fakeContext());
|
|
const viewer = streetViewer();
|
|
instance.init(viewer);
|
|
const status = instance.status();
|
|
instance.activate(viewer);
|
|
assert.equal(tiles.length, 0, 'nothing before the status answers');
|
|
answer({ configured });
|
|
assert.deepEqual(await status, { configured });
|
|
if (configured)
|
|
assert.ok(tiles.length > 0, 'coverage loads as soon as the key is known');
|
|
else {
|
|
assert.equal(tiles.length, 0, 'a key-less install never asks');
|
|
assert.equal(instance.coverageStats().keyRequired, true);
|
|
}
|
|
instance.destroy(viewer);
|
|
}
|
|
});
|
|
|
|
test('a status the server never answers falls back to the bundled token once the core gives up', async () => {
|
|
const source = fakeMapillarySource({
|
|
hasToken: () => false,
|
|
getStatus: ({ signal } = {}) =>
|
|
new Promise((_, reject) =>
|
|
signal?.addEventListener('abort', () => reject(signal.reason)),
|
|
),
|
|
});
|
|
const instance = createMapillaryProvider({ source }).create(fakeContext());
|
|
const controller = new AbortController();
|
|
const status = instance.status({ signal: controller.signal });
|
|
controller.abort(new Error('timed out'));
|
|
assert.deepEqual(await status, { configured: false });
|
|
assert.equal(instance.coverageStats().keyRequired, true);
|
|
});
|
|
|
|
/** A graph image record at a point. */
|
|
const imageAt = (id, lon, lat, extra = {}) => ({
|
|
id,
|
|
is_pano: false,
|
|
captured_at: 10,
|
|
geometry: { type: 'Point', coordinates: [lon, lat] },
|
|
...extra,
|
|
});
|
|
|
|
test('nearestImage opens the closest image that passes the filter, not the first the API returned', async () => {
|
|
const requests = [];
|
|
const answer = [
|
|
imageAt('far', 2.0004, 1), // ~45 m east
|
|
imageAt('near-pano', 2.00002, 1, { is_pano: true }), // ~2 m, a panorama
|
|
imageAt('near', 2.00005, 1), // ~5 m east
|
|
imageAt('mid', 2, 1.0002), // ~22 m north
|
|
];
|
|
const source = fakeMapillarySource({
|
|
nearestImages: async (query, options) => {
|
|
requests.push({ query, options });
|
|
return answer;
|
|
},
|
|
});
|
|
const { signal } = new AbortController();
|
|
const flat = createMapillaryProvider({ source }).create(
|
|
fakeContext({ pano: 'flat', sinceMs: null }),
|
|
);
|
|
assert.equal(await flat.nearestImage({ lat: 1, lon: 2 }, { signal }), 'near');
|
|
assert.equal(requests[0].options.signal, signal, 'the core can abort it');
|
|
assert.deepEqual(requests[0].query, { lat: 1, lon: 2 });
|
|
const any = createMapillaryProvider({ source }).create(fakeContext());
|
|
assert.equal(await any.nearestImage({ lat: 1, lon: 2 }), 'near-pano');
|
|
const tooOld = createMapillaryProvider({ source }).create(
|
|
fakeContext({ pano: 'all', sinceMs: 100 }),
|
|
);
|
|
assert.equal(await tooOld.nearestImage({ lat: 1, lon: 2 }), null);
|
|
});
|