mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-21 02:32:18 +00:00
Merge branch 'main' into fix/places-no-store-on-errors
This commit is contained in:
8 files changed
+377
-5
No files matched your search
@@ -0,0 +1,138 @@
|
||||
// An explicit pick of the camera that a settled move just re-opened must end
|
||||
// the opening pick. That pick goes through setActiveCamera's UNCHANGED path
|
||||
// (same camera, already activated); if that path keeps the provisional flag,
|
||||
// the next settled move (a pan, or the landing of NEAREST's own flight)
|
||||
// switches the camera away from the one the user chose.
|
||||
import assert from 'node:assert/strict';
|
||||
import test from 'node:test';
|
||||
import * as Cesium from 'cesium';
|
||||
import cctvLayer, {
|
||||
_setCctvCoverageStateForTest,
|
||||
_setCctvOverlayHostForTest,
|
||||
reopenNearestCamera,
|
||||
} from './cctv.js';
|
||||
import { bindFakeDraw } from '../testSupport/fakeDrawPort.mjs';
|
||||
|
||||
const BASE = {
|
||||
headingDeg: 41,
|
||||
pitchDeg: -5,
|
||||
fovDeg: 56,
|
||||
rangeM: 210,
|
||||
mountHeightM: 100,
|
||||
groundElevationM: 0,
|
||||
city: 'London',
|
||||
};
|
||||
|
||||
function record(id, lat, lon) {
|
||||
return {
|
||||
camera: { ...BASE, id, name: `Camera ${id}`, lat, lon },
|
||||
coverageEntities: [],
|
||||
projection: null,
|
||||
activationDone: true,
|
||||
groundResolved: {},
|
||||
groundSamples: {},
|
||||
groundPrior: 0,
|
||||
frustumGeometry: null,
|
||||
frustumPositions: null,
|
||||
probeClampRangeM: null,
|
||||
position: Cesium.Cartesian3.fromDegrees(lon, lat, 100),
|
||||
};
|
||||
}
|
||||
|
||||
function viewerAt(lat, lon) {
|
||||
const viewer = {
|
||||
isDestroyed: () => false,
|
||||
eye: { lat, lon, height: 300 },
|
||||
scene: {
|
||||
canvas: { clientWidth: 1200, clientHeight: 800 },
|
||||
cartesianToCanvasCoordinates: () => undefined,
|
||||
primitives: { add: (p) => p, remove: () => true },
|
||||
requestRender() {},
|
||||
},
|
||||
};
|
||||
// The layer reads the eye and flies through the renderer's camera port.
|
||||
viewer.draw = bindFakeDraw(viewer, {
|
||||
camera: {
|
||||
pose: () => ({ ...viewer.eye }),
|
||||
on: () => () => {},
|
||||
followed: null,
|
||||
flyToBounds() {},
|
||||
},
|
||||
}).draw;
|
||||
return viewer;
|
||||
}
|
||||
|
||||
function moveViewer(viewer, lat, lon) {
|
||||
viewer.eye = { lat, lon, height: 300 };
|
||||
}
|
||||
|
||||
function withReopenedLayer(fn) {
|
||||
_setCctvOverlayHostForTest({
|
||||
setEntries() {},
|
||||
setVisible() {},
|
||||
clearSource() {},
|
||||
});
|
||||
// Activation builds the projection canvas and frame image.
|
||||
const originalDocument = globalThis.document;
|
||||
const originalImage = globalThis.Image;
|
||||
globalThis.document = { createElement: () => ({ getContext: () => null }) };
|
||||
globalThis.Image = class {};
|
||||
try {
|
||||
const trafalgar = record('a-trafalgar', 51.508, -0.128);
|
||||
const cambridge = record('b-cambridge', 51.513, -0.129);
|
||||
// enable() assigned the opening camera without activating it.
|
||||
trafalgar.activationDone = false;
|
||||
const viewer = viewerAt(51.5081, -0.1281);
|
||||
_setCctvCoverageStateForTest({
|
||||
viewer,
|
||||
records: [trafalgar, cambridge],
|
||||
activeCameraId: 'a-trafalgar',
|
||||
enabled: true,
|
||||
openingCameraProvisional: true,
|
||||
});
|
||||
// A settled move next to Cambridge Circus re-opens there, still as the
|
||||
// opening pick.
|
||||
moveViewer(viewer, 51.5131, -0.1291);
|
||||
assert.equal(reopenNearestCamera(), true);
|
||||
assert.equal(cctvLayer.getUIState().activeCameraId, 'b-cambridge');
|
||||
fn(viewer);
|
||||
} finally {
|
||||
globalThis.document = originalDocument;
|
||||
globalThis.Image = originalImage;
|
||||
_setCctvOverlayHostForTest();
|
||||
_setCctvCoverageStateForTest({ enabled: false });
|
||||
}
|
||||
}
|
||||
|
||||
for (const [name, pick] of [
|
||||
['NEAREST (focusNearest)', () => cctvLayer.focusNearest({ focus: false })],
|
||||
['selectCamera', () => cctvLayer.selectCamera('b-cambridge')],
|
||||
[
|
||||
'setParams({ selectedCameraId })',
|
||||
() => cctvLayer.setParams({ selectedCameraId: 'b-cambridge' }),
|
||||
],
|
||||
[
|
||||
'focusNearestToPoint',
|
||||
() => cctvLayer.focusNearestToPoint(51.513, -0.129, { focus: false }),
|
||||
],
|
||||
]) {
|
||||
test(`an explicit ${name} pick of the re-opened camera ends the opening pick`, () => {
|
||||
withReopenedLayer((viewer) => {
|
||||
pick();
|
||||
assert.equal(cctvLayer.getUIState().activeCameraId, 'b-cambridge');
|
||||
// A later settled move (a pan, or the landing of the pick's own flight)
|
||||
// leaves the explicit choice alone.
|
||||
moveViewer(viewer, 51.5081, -0.1281);
|
||||
assert.equal(reopenNearestCamera(), false);
|
||||
assert.equal(cctvLayer.getUIState().activeCameraId, 'b-cambridge');
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
test('without a pick, the next settled move still follows the view', () => {
|
||||
withReopenedLayer((viewer) => {
|
||||
moveViewer(viewer, 51.5081, -0.1281);
|
||||
assert.equal(reopenNearestCamera(), true);
|
||||
assert.equal(cctvLayer.getUIState().activeCameraId, 'a-trafalgar');
|
||||
});
|
||||
});
|
||||
@@ -81,9 +81,8 @@ export function createNavigation({
|
||||
return false;
|
||||
const nearest = nearestCameraIdToViewer();
|
||||
if (!nearest || nearest === layerState._activeCameraId) return false;
|
||||
parts.selection.setActiveCamera(nearest);
|
||||
// setActiveCamera ends the opening pick; this is still that pick.
|
||||
layerState._openingCameraProvisional = true;
|
||||
// Still the opening pick: later settled moves may replace it.
|
||||
parts.selection.setActiveCamera(nearest, { opening: true });
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
@@ -108,10 +108,13 @@ export function createSelection({
|
||||
* Sets the active camera by ID, initializes its projection runtime, refreshes
|
||||
* its frame, and updates styles.
|
||||
* @param {string} cameraId - ID of the camera to activate.
|
||||
* @param {Object} [options]
|
||||
* @param {boolean} [options.opening=false] - The opening camera following
|
||||
* the view, not someone's pick: settled moves may still replace it.
|
||||
* @returns {'activated'|'unchanged'|'not-found'} Discriminated activation result.
|
||||
*/
|
||||
|
||||
function setActiveCamera(cameraId) {
|
||||
function setActiveCamera(cameraId, { opening = false } = {}) {
|
||||
if (!cameraId || !layerState._recordById.has(cameraId))
|
||||
return CCTV_ACTIVATION_RESULT.NOT_FOUND;
|
||||
const record = layerState._recordById.get(cameraId);
|
||||
@@ -129,6 +132,9 @@ export function createSelection({
|
||||
record,
|
||||
)
|
||||
) {
|
||||
// Picking the camera a settled move re-opened is still a pick: later
|
||||
// settled moves must leave it alone.
|
||||
if (!opening) layerState._openingCameraProvisional = false;
|
||||
// Browser-only feeds have a separate player; a reselect retries it
|
||||
// without re-running activation or touching the projection geometry.
|
||||
if (parts.model.isBrowserOverlayCamera(record.camera)) {
|
||||
@@ -139,7 +145,7 @@ export function createSelection({
|
||||
}
|
||||
layerState._activeCameraId = cameraId;
|
||||
layerState._autoHopSuspended = false;
|
||||
layerState._openingCameraProvisional = false;
|
||||
layerState._openingCameraProvisional = opening;
|
||||
// A real activation creates projection work — wake the self-stopping loop.
|
||||
parts.projection.startProjectionLoop();
|
||||
if (previousActiveRecord && previousActiveRecord !== record) {
|
||||
|
||||
@@ -215,3 +215,16 @@ test('a count click is the card on top for every layer, unless the count yields'
|
||||
picking.unregisterPickOwner('flights');
|
||||
}
|
||||
});
|
||||
|
||||
test('same-camera selection ends the opening pick without notifying snapshot feeds', () => {
|
||||
const fixture = makeSelection('tripcheck-odot');
|
||||
fixture.state._openingCameraProvisional = true;
|
||||
|
||||
assert.equal(
|
||||
fixture.selection.setActiveCamera('same-camera'),
|
||||
CCTV_ACTIVATION_RESULT.UNCHANGED,
|
||||
);
|
||||
assert.equal(fixture.state._openingCameraProvisional, false);
|
||||
assert.equal(fixture.state._activeCameraReselection, 0);
|
||||
assert.equal(fixture.notifications(), 0);
|
||||
});
|
||||
@@ -108,6 +108,7 @@ export function createTesting({ state: layerState, services, parts, source }) {
|
||||
} = {}) {
|
||||
layerState._viewer = viewer;
|
||||
layerState._records = Array.isArray(records) ? records : [];
|
||||
layerState._count = layerState._records.length;
|
||||
layerState._recordById = new Map(
|
||||
layerState._records
|
||||
.filter((record) => record?.camera?.id)
|
||||
|
||||
@@ -0,0 +1,197 @@
|
||||
// src/ui/cctvPickerOpening.test.mjs — the picker and the opening camera.
|
||||
// The opening camera follows the view until someone picks one. The picker
|
||||
// shows it as its own option; a native select fires no change for the
|
||||
// option it already shows, so FOCUS keeps that camera, and leaving the list
|
||||
// without a choice lets it follow the view.
|
||||
import '../testSupport/registerDom.mjs';
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import * as Cesium from 'cesium';
|
||||
import { createPinia } from 'pinia';
|
||||
import { createApp, nextTick } from 'vue';
|
||||
import cctvLayer, {
|
||||
_setCctvCoverageStateForTest,
|
||||
_setCctvOverlayHostForTest,
|
||||
reopenNearestCamera,
|
||||
} from '../data/cctv.js';
|
||||
import { bindFakeDraw } from '../testSupport/fakeDrawPort.mjs';
|
||||
import { CctvControls } from './cctvControls.js';
|
||||
import { useCctvStore } from './stores/cctv.js';
|
||||
import CctvPanel from './views/panels/CctvPanel.vue';
|
||||
|
||||
const TRAFALGAR = [51.508, -0.128];
|
||||
const CAMBRIDGE = [51.513, -0.129];
|
||||
|
||||
function record(id, [lat, lon]) {
|
||||
return {
|
||||
camera: {
|
||||
id,
|
||||
name: `Camera ${id}`,
|
||||
city: 'London',
|
||||
lat,
|
||||
lon,
|
||||
headingDeg: 41,
|
||||
pitchDeg: -5,
|
||||
fovDeg: 56,
|
||||
rangeM: 210,
|
||||
mountHeightM: 100,
|
||||
groundElevationM: 0,
|
||||
},
|
||||
coverageEntities: [],
|
||||
projection: null,
|
||||
activationDone: true,
|
||||
groundResolved: {},
|
||||
groundSamples: {},
|
||||
groundPrior: 0,
|
||||
frustumGeometry: null,
|
||||
frustumPositions: null,
|
||||
probeClampRangeM: null,
|
||||
position: Cesium.Cartesian3.fromDegrees(lon, lat, 100),
|
||||
};
|
||||
}
|
||||
|
||||
function viewerAt([lat, lon]) {
|
||||
const viewer = {
|
||||
isDestroyed: () => false,
|
||||
eye: { lat, lon, height: 300 },
|
||||
scene: {
|
||||
canvas: { clientWidth: 1200, clientHeight: 800 },
|
||||
cartesianToCanvasCoordinates: () => undefined,
|
||||
primitives: { add: (p) => p, remove: () => true },
|
||||
requestRender() {},
|
||||
},
|
||||
};
|
||||
// The layer reads the eye and flies through the renderer's camera port.
|
||||
viewer.draw = bindFakeDraw(viewer, {
|
||||
camera: {
|
||||
pose: () => ({ ...viewer.eye }),
|
||||
on: () => () => {},
|
||||
followed: null,
|
||||
flyToBounds() {},
|
||||
},
|
||||
}).draw;
|
||||
return viewer;
|
||||
}
|
||||
|
||||
/** A settled move: the view is now over `[lat, lon]`. */
|
||||
function settleOver(viewer, [lat, lon]) {
|
||||
viewer.eye = { lat, lon, height: 300 };
|
||||
return reopenNearestCamera();
|
||||
}
|
||||
|
||||
/**
|
||||
* CCTV opened at Trafalgar Square, then a settled move re-opened it at
|
||||
* Cambridge Circus; the panel is connected to the layer.
|
||||
*/
|
||||
async function reopenedAtCambridge(t) {
|
||||
_setCctvOverlayHostForTest({
|
||||
setEntries() {},
|
||||
setVisible() {},
|
||||
clearSource() {},
|
||||
});
|
||||
// Activation builds the frame image and asks for ground heights; this test
|
||||
// has no server. happy-dom's request timeout would hold the run open 30 s.
|
||||
const originalImage = globalThis.Image;
|
||||
const originalFetch = globalThis.fetch;
|
||||
const originalTimeout = AbortSignal.timeout;
|
||||
globalThis.Image = class {};
|
||||
globalThis.fetch = async () => {
|
||||
throw new TypeError('no server in this test');
|
||||
};
|
||||
AbortSignal.timeout = () => new AbortController().signal;
|
||||
const trafalgar = record('a-trafalgar', TRAFALGAR);
|
||||
const cambridge = record('b-cambridge', CAMBRIDGE);
|
||||
// enable() assigned the opening camera without activating it.
|
||||
trafalgar.activationDone = false;
|
||||
const viewer = viewerAt(TRAFALGAR);
|
||||
_setCctvCoverageStateForTest({
|
||||
viewer,
|
||||
records: [trafalgar, cambridge],
|
||||
activeCameraId: 'a-trafalgar',
|
||||
enabled: true,
|
||||
openingCameraProvisional: true,
|
||||
});
|
||||
|
||||
document.body.replaceChildren();
|
||||
const host = document.body.appendChild(document.createElement('div'));
|
||||
const pinia = createPinia();
|
||||
const app = createApp(CctvPanel).use(pinia);
|
||||
app.mount(host);
|
||||
const select = document.getElementById('cctv-camera-select');
|
||||
const controls = new CctvControls({
|
||||
elements: {
|
||||
_cctvPanel: document.getElementById('cctv-panel'),
|
||||
_cctvSelect: select,
|
||||
_cctvFocusBtn: document.getElementById('cctv-focus-btn'),
|
||||
},
|
||||
cctv: cctvLayer,
|
||||
actions: {
|
||||
isEnabled: () => true,
|
||||
toggleEnabled: async () => true,
|
||||
runExplicitFocus(select, focus) {
|
||||
const cameraId = select();
|
||||
if (cameraId) focus(cameraId);
|
||||
},
|
||||
setParams: (params) => cctvLayer.setParams(params),
|
||||
setPanelCollapsed() {},
|
||||
syncViewport() {},
|
||||
},
|
||||
store: useCctvStore(pinia),
|
||||
});
|
||||
controls.connect();
|
||||
t.after(() => {
|
||||
controls.destroy();
|
||||
app.unmount();
|
||||
globalThis.Image = originalImage;
|
||||
globalThis.fetch = originalFetch;
|
||||
AbortSignal.timeout = originalTimeout;
|
||||
_setCctvOverlayHostForTest();
|
||||
_setCctvCoverageStateForTest({ enabled: false });
|
||||
});
|
||||
|
||||
assert.equal(settleOver(viewer, CAMBRIDGE), true);
|
||||
await nextTick();
|
||||
assert.equal(cctvLayer.getUIState().activeCameraId, 'b-cambridge');
|
||||
return { viewer, select };
|
||||
}
|
||||
|
||||
test('the opening camera shows as its own option', async (t) => {
|
||||
const { select } = await reopenedAtCambridge(t);
|
||||
assert.equal(select.value, 'b-cambridge');
|
||||
const shown = select.options[select.selectedIndex];
|
||||
assert.equal(shown.hidden, false);
|
||||
assert.equal(shown.disabled, false);
|
||||
assert.equal(
|
||||
[...select.options].filter((option) => option.value === 'b-cambridge')
|
||||
.length,
|
||||
1,
|
||||
'the list shows the camera once',
|
||||
);
|
||||
assert.ok([...select.options].every((option) => !option.hidden));
|
||||
});
|
||||
|
||||
test('FOCUS on the shown camera keeps it after a pan', async (t) => {
|
||||
const { viewer, select } = await reopenedAtCambridge(t);
|
||||
const focus = document.getElementById('cctv-focus-btn');
|
||||
assert.equal(focus.disabled, false);
|
||||
focus.click();
|
||||
// The click handler waits for the layer switch before it picks.
|
||||
await new Promise((resolve) => setTimeout(resolve, 0));
|
||||
await nextTick();
|
||||
|
||||
assert.equal(settleOver(viewer, TRAFALGAR), false);
|
||||
assert.equal(cctvLayer.getUIState().activeCameraId, 'b-cambridge');
|
||||
assert.equal(select.value, 'b-cambridge');
|
||||
});
|
||||
|
||||
test('leaving the picker without a pick lets the camera follow a pan', async (t) => {
|
||||
const { viewer, select } = await reopenedAtCambridge(t);
|
||||
select.focus();
|
||||
select.blur();
|
||||
await nextTick();
|
||||
|
||||
assert.equal(settleOver(viewer, TRAFALGAR), true);
|
||||
await nextTick();
|
||||
assert.equal(cctvLayer.getUIState().activeCameraId, 'a-trafalgar');
|
||||
assert.equal(select.value, 'a-trafalgar');
|
||||
});
|
||||
Reference in new issue
Block a user