mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-18 01:02:23 +00:00
Merge main into german/i18n-plurals-context
The catalogs conflicted only on neighbouring lines: no key changed on both sides, so they are merged key by key in main's order. Main removed the rail timeline, the other user of plain "Latest", so that entry is pruned and the News test no longer checks the timeline's wording.
This commit is contained in:
commit
49409ba8f1
1502 files changed
+180715
-47887
No files matched your search
@@ -6,6 +6,7 @@ import { createControls as installationControls } from '../layers/installations/
|
||||
import { createQueries as transitQueries } from '../layers/transit/queries.js';
|
||||
import { createCyclonesLayer } from '../layers/cyclones/index.js';
|
||||
import { ANALYST_LAYERS } from '../data/analystEngine.js';
|
||||
import { fakeInput } from '../input/testDoubles.mjs';
|
||||
|
||||
/** Every declared analyst field must be a key the accessor actually emits. */
|
||||
function assertDeclaredFields(layerId, record) {
|
||||
@@ -183,16 +184,7 @@ test('cyclones flatten the storm position and stay empty while off', async () =>
|
||||
fetchedAt: Date.now(),
|
||||
}),
|
||||
},
|
||||
cesium: {
|
||||
ScreenSpaceEventType: { LEFT_CLICK: 'left' },
|
||||
ScreenSpaceEventHandler: class {
|
||||
setInputAction() {}
|
||||
destroy() {}
|
||||
isDestroyed() {
|
||||
return false;
|
||||
}
|
||||
},
|
||||
},
|
||||
cesium: {},
|
||||
createRendering: () => ({
|
||||
setSnapshot: async () => true,
|
||||
setSelection() {},
|
||||
@@ -204,10 +196,12 @@ test('cyclones flatten the storm position and stay empty while off', async () =>
|
||||
}),
|
||||
hitTestOverlay: () => null,
|
||||
});
|
||||
layer.init({
|
||||
const viewer = {
|
||||
scene: { canvas: new EventTarget(), pick: () => null },
|
||||
camera: {},
|
||||
});
|
||||
};
|
||||
const input = fakeInput(viewer);
|
||||
layer.init(viewer);
|
||||
assert.deepEqual(layer.getAnalystRecords(), []);
|
||||
layer.enable();
|
||||
await layer.update();
|
||||
|
||||
@@ -18,6 +18,7 @@
|
||||
*/
|
||||
|
||||
import { createAreaStore, summarizeArea } from '../data/areaStore.js';
|
||||
import { findCamera } from '../render/rendererOf.js';
|
||||
import { createAreaResolver, foldLatinMarks } from '../data/areaResolver.js';
|
||||
import { circleRing, displayParts } from '../data/areaGeometry.js';
|
||||
import { findNaturalRegion } from '../data/naturalEarthRegions.js';
|
||||
@@ -176,12 +177,9 @@ export function createVoiceAreas({
|
||||
const picked = annotationResolver?.pickWorldFromScreen?.(viewer, 0.5, 0.5);
|
||||
if (Number.isFinite(picked?.lat) && Number.isFinite(picked?.lon))
|
||||
return picked;
|
||||
const carto = viewer?.camera?.positionCartographic;
|
||||
return carto
|
||||
? {
|
||||
lat: (carto.latitude * 180) / Math.PI,
|
||||
lon: (carto.longitude * 180) / Math.PI,
|
||||
}
|
||||
const pose = findCamera(viewer)?.pose();
|
||||
return Number.isFinite(pose?.lat) && Number.isFinite(pose?.lon)
|
||||
? { lat: pose.lat, lon: pose.lon }
|
||||
: null;
|
||||
}
|
||||
|
||||
|
||||
@@ -9,6 +9,8 @@ import { createVoiceAreas, spokenArea } from './areaActions.js';
|
||||
import { pointInPreparedArea } from '../data/areaGeometry.js';
|
||||
import { presentResult } from './resultDisplay.js';
|
||||
import { findAdminCandidates as findBundledAdminCandidates } from '../data/adminBoundaries.js';
|
||||
import { bindRenderer } from '../render/rendererOf.js';
|
||||
import { fakeCameraPort } from '../testSupport/fakeCameraPort.mjs';
|
||||
|
||||
const square = (w, s, e, n) => [
|
||||
[w, s],
|
||||
@@ -314,6 +316,41 @@ test('an ambiguous name returns candidates for the model to ask about', async ()
|
||||
assert.equal(picked.display.source, 'Natural Earth');
|
||||
});
|
||||
|
||||
test('an ambiguous name is settled by the view: the ground at mid-screen, else where the camera stands', async () => {
|
||||
// Nothing under mid-screen (open sky, no pick): the camera's own position
|
||||
// over the Indian Punjab chooses it.
|
||||
const viewer = {};
|
||||
const camera = fakeCameraPort({ pose: { lon: 75.5, lat: 31 } });
|
||||
bindRenderer(viewer, { camera: camera.port });
|
||||
const { areas } = makeAreas({ viewer });
|
||||
const byCamera = await areas.resolveAreaAction({ query: 'Punjab' });
|
||||
assert.equal(byCamera.ok, true);
|
||||
assert.equal(byCamera.country, 'India');
|
||||
|
||||
// A camera that cannot say where it is settles nothing: the model asks.
|
||||
camera.setPose({ lon: NaN, lat: NaN });
|
||||
const unknown = await areas.resolveAreaAction({ query: 'Punjab' });
|
||||
assert.equal(unknown.needsClarification, true);
|
||||
|
||||
// The ground at mid-screen wins over the camera's position.
|
||||
const pakistan = PUNJABS[1].polygons[0][0];
|
||||
const lon = (pakistan[0][0] + pakistan[1][0]) / 2;
|
||||
const lat = (pakistan[0][1] + pakistan[2][1]) / 2;
|
||||
camera.setPose({ lon: 75.5, lat: 31 });
|
||||
const ladder = fakeLadder();
|
||||
const { areas: picking } = makeAreas({
|
||||
viewer,
|
||||
annotationResolver: {
|
||||
...ladder,
|
||||
pickWorldFromScreen: (v, x, y) =>
|
||||
v === viewer && x === 0.5 && y === 0.5 ? { lat, lon } : null,
|
||||
},
|
||||
});
|
||||
const byGround = await picking.resolveAreaAction({ query: 'Punjab' });
|
||||
assert.equal(byGround.ok, true);
|
||||
assert.equal(byGround.country, 'Pakistan');
|
||||
});
|
||||
|
||||
test('names reach the annotation outline ladder with the level as entity kind', async () => {
|
||||
const ladder = fakeLadder();
|
||||
const { areas } = makeAreas({ annotationResolver: ladder });
|
||||
|
||||
@@ -16,6 +16,7 @@ after(() => {
|
||||
function viewerFixture() {
|
||||
return {
|
||||
clock: { onTick: { addEventListener: () => () => {} } },
|
||||
canvas: { addEventListener() {}, removeEventListener() {} },
|
||||
scene: { canvas: { addEventListener() {}, removeEventListener() {} } },
|
||||
camera: { moveEnd: { addEventListener() {} } },
|
||||
};
|
||||
|
||||
@@ -14,6 +14,7 @@ import { DataLayerManager } from '../data/manager.js';
|
||||
const viewerFixture = () => ({
|
||||
clock: { onTick: { addEventListener: () => () => {} } },
|
||||
camera: { moveEnd: { addEventListener() {} } },
|
||||
canvas: { addEventListener() {}, removeEventListener() {} },
|
||||
scene: { canvas: { addEventListener() {}, removeEventListener() {} } },
|
||||
});
|
||||
const request = (ws, id, name, args = {}) =>
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
import { bindFakeCesiumCamera } from '../testSupport/fakeCameraPort.mjs';
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import {
|
||||
@@ -47,21 +48,20 @@ const outputs = (ws) =>
|
||||
function fixture({ holdFirst = false } = {}) {
|
||||
const state = { height: 1000, renders: 0, providerWrites: [], panels: [] };
|
||||
const position = { x: 6379137, y: 0, z: 0 };
|
||||
const viewer = {
|
||||
const viewer = bindFakeCesiumCamera({
|
||||
clock: { onTick: { addEventListener: () => () => {} } },
|
||||
camera: {
|
||||
positionWC: position,
|
||||
positionCartographic: { height: 1000 },
|
||||
moveEnd: { addEventListener() {} },
|
||||
cancelFlight() {},
|
||||
zoomIn(n) {
|
||||
position.x -= n;
|
||||
state.height -= n;
|
||||
this.positionCartographic.height = state.height;
|
||||
},
|
||||
zoomOut(n) {
|
||||
position.x += n;
|
||||
state.height += n;
|
||||
// Looking straight down at the surface along -x.
|
||||
directionWC: { x: -1, y: 0, z: 0 },
|
||||
upWC: { x: 0, y: 0, z: 1 },
|
||||
rightWC: { x: 0, y: 1, z: 0 },
|
||||
setView({ destination }) {
|
||||
state.height -= position.x - destination.x;
|
||||
position.x = destination.x;
|
||||
this.positionCartographic.height = state.height;
|
||||
},
|
||||
},
|
||||
@@ -76,7 +76,7 @@ function fixture({ holdFirst = false } = {}) {
|
||||
state.renders++;
|
||||
},
|
||||
},
|
||||
};
|
||||
});
|
||||
const runner = createGevActionRunner({
|
||||
viewer,
|
||||
dataManager: { layers: new Map() },
|
||||
|
||||
+169
-149
@@ -1,3 +1,4 @@
|
||||
import { isFollowing, stopFollowing } from '../data/followed.js';
|
||||
import { interruptGlobeRotation } from '../cameraVerbs.js';
|
||||
import { normalizeDisplayText } from '../data/displayText.js';
|
||||
import {
|
||||
@@ -16,7 +17,22 @@ import { defaultGeospatial } from '../search/defaults.js';
|
||||
import { msg } from '../i18n/index.js';
|
||||
import { useProviderSettingsStore } from '../ui/stores/providerSettings.js';
|
||||
import { applicationPinia } from '../ui/vueRuntime.js';
|
||||
import * as Cesium from 'cesium';
|
||||
import {
|
||||
distance as chordM,
|
||||
fromRadians,
|
||||
toCartographicRadians,
|
||||
toDegrees,
|
||||
toLonLatH,
|
||||
toRadians,
|
||||
} from '../geo/index.js';
|
||||
import { sphereFromPoints } from '../geo/sphere.js';
|
||||
import { eyeZoomed } from '../geo/eyeMoves.js';
|
||||
import {
|
||||
cameraOf,
|
||||
canvasOf,
|
||||
findCamera,
|
||||
findQuery,
|
||||
} from '../render/rendererOf.js';
|
||||
import { CITY_POIS } from '../cityPois.js';
|
||||
import { greatCircleKm } from '../geoDistance.js';
|
||||
import { EXCLUSIVE_SURFACE_CLASSES } from '../exclusiveSurfaces.js';
|
||||
@@ -39,7 +55,7 @@ import {
|
||||
getSelectedEntityContext,
|
||||
isContextRecordActive,
|
||||
} from '../data/contextStore.js';
|
||||
import { CCTV_FOCUS_RESULT } from '../layers/cctv/index.js';
|
||||
import { CCTV_FOCUS_RESULT } from '../layers/cctv/policy.js';
|
||||
import {
|
||||
NEAREST_RADIUS_MAX_M as STREET_LEVEL_WIDE_RADIUS_M,
|
||||
STREET_LEVEL_LAYER_ID,
|
||||
@@ -452,7 +468,7 @@ export function createGevActionRunner({
|
||||
// Explicit navigation while TRACKING supersedes the follow camera —
|
||||
// otherwise the tracker drags the view back and "I flew there but can't
|
||||
// do anything" (field finding). track_entity manages its own handoff.
|
||||
if (name === 'zoom_to_globe' && viewer.trackedEntity) {
|
||||
if (name === 'zoom_to_globe' && isFollowing(viewer)) {
|
||||
stopAllTracking(viewer, dataManager);
|
||||
}
|
||||
|
||||
@@ -1258,7 +1274,7 @@ export function createGevActionRunner({
|
||||
return;
|
||||
}
|
||||
interruptCameraMotion('nav:fly_to_location');
|
||||
if (viewer.trackedEntity) stopAllTracking(viewer, dataManager);
|
||||
if (isFollowing(viewer)) stopAllTracking(viewer, dataManager);
|
||||
}),
|
||||
});
|
||||
// No flight started: nothing to wait for. A lookup that was not found,
|
||||
@@ -2946,7 +2962,7 @@ function stopAllTracking(viewer, dataManager) {
|
||||
failed.add(layerId);
|
||||
}
|
||||
}
|
||||
if (viewer) viewer.trackedEntity = undefined;
|
||||
stopFollowing(viewer);
|
||||
if (failed.size) {
|
||||
const failedLayerIds = [...failed];
|
||||
return {
|
||||
@@ -3017,7 +3033,8 @@ async function frameOverhead(viewer, dataManager, styleManager, args = {}) {
|
||||
? 120
|
||||
: 150;
|
||||
const radiusKm = clampNumber(args.radiusKm, 10, 20000, defaultRadiusKm);
|
||||
const center = getViewTargetCartesian(viewer) || viewer.camera.positionWC;
|
||||
const center =
|
||||
getViewTargetCartesian(viewer) || cameraOf(viewer).pose().position;
|
||||
|
||||
let entries = [];
|
||||
if (typeof module.getNearby === 'function') {
|
||||
@@ -3027,7 +3044,7 @@ async function frameOverhead(viewer, dataManager, styleManager, args = {}) {
|
||||
.filter((entry) => entry.position)
|
||||
.map((entry) => ({
|
||||
...entry,
|
||||
distance: Cesium.Cartesian3.distance(center, entry.position),
|
||||
distance: chordM(center, entry.position),
|
||||
}))
|
||||
.filter((entry) => entry.distance <= radiusKm * 1000)
|
||||
.sort((a, b) => a.distance - b.distance)
|
||||
@@ -3044,24 +3061,26 @@ async function frameOverhead(viewer, dataManager, styleManager, args = {}) {
|
||||
};
|
||||
}
|
||||
|
||||
const sphere = Cesium.BoundingSphere.fromPoints(
|
||||
entries.map((entry) => entry.position),
|
||||
);
|
||||
const sphere = sphereFromPoints(entries.map((entry) => entry.position));
|
||||
sphere.radius = Math.max(sphere.radius * 1.25, 8000);
|
||||
const pitch = Cesium.Math.toRadians(isSatellites ? -35 : -62);
|
||||
const pitch = toRadians(isSatellites ? -35 : -62);
|
||||
return runManagedVoiceNavigation(
|
||||
styleManager,
|
||||
'frame',
|
||||
'frame_overhead',
|
||||
() => {
|
||||
viewer.camera.flyToBoundingSphere(sphere, {
|
||||
duration: 2.0,
|
||||
offset: new Cesium.HeadingPitchRange(
|
||||
viewer.camera.heading,
|
||||
pitch,
|
||||
sphere.radius * 2.4,
|
||||
),
|
||||
});
|
||||
const camera = cameraOf(viewer);
|
||||
camera.flyToBounds(
|
||||
{ center: sphere.center, radius: sphere.radius },
|
||||
{
|
||||
durationS: 2.0,
|
||||
offset: {
|
||||
heading: camera.pose().heading,
|
||||
pitch,
|
||||
range: sphere.radius * 2.4,
|
||||
},
|
||||
},
|
||||
);
|
||||
|
||||
let detectionEnabled = false;
|
||||
try {
|
||||
@@ -3241,10 +3260,11 @@ function runManagedVoiceNavigation(
|
||||
export async function getBasemapLabelContext(
|
||||
viewer,
|
||||
service = defaultGeospatial,
|
||||
{ cachedOnly = false, previous = null } = {},
|
||||
{ cachedOnly = false, previous = null, camera = cameraOf(viewer) } = {},
|
||||
) {
|
||||
const cameraHeightM = viewer.camera.positionCartographic.height;
|
||||
const target = getViewTargetCartographic(viewer);
|
||||
const pose = camera.pose();
|
||||
const cameraHeightM = pose.height;
|
||||
const target = getViewTargetCartographic(viewer, camera);
|
||||
if (!target) {
|
||||
return {
|
||||
placeLabels: [],
|
||||
@@ -3255,14 +3275,14 @@ export async function getBasemapLabelContext(
|
||||
};
|
||||
}
|
||||
|
||||
const latitude = Number(Cesium.Math.toDegrees(target.latitude).toFixed(6));
|
||||
const longitude = Number(Cesium.Math.toDegrees(target.longitude).toFixed(6));
|
||||
const latitude = Number(toDegrees(target.latitude).toFixed(6));
|
||||
const longitude = Number(toDegrees(target.longitude).toFixed(6));
|
||||
const view = placeLookupView({
|
||||
latitude,
|
||||
longitude,
|
||||
rangeM: viewTargetRangeM(viewer, target, cameraHeightM),
|
||||
fovRad: viewer.camera.frustum?.fov,
|
||||
aspectRatio: viewer.camera.frustum?.aspectRatio,
|
||||
rangeM: viewTargetRangeM(pose, target, cameraHeightM),
|
||||
fovRad: widerFov(pose),
|
||||
aspectRatio: pose.aspectRatio,
|
||||
tier: basemapLookupTier(cameraHeightM),
|
||||
});
|
||||
if (
|
||||
@@ -3304,13 +3324,24 @@ function basemapLookupTier(cameraHeightM) {
|
||||
].join(':');
|
||||
}
|
||||
|
||||
/**
|
||||
* The wider of the view's two angles of view, radians: the horizontal one
|
||||
* when the view is wider than tall, else the vertical one.
|
||||
*/
|
||||
function widerFov({ fovy, aspectRatio }) {
|
||||
if (!Number.isFinite(fovy) || !Number.isFinite(aspectRatio)) return undefined;
|
||||
return aspectRatio > 1
|
||||
? 2 * Math.atan(Math.tan(fovy / 2) * aspectRatio)
|
||||
: fovy;
|
||||
}
|
||||
|
||||
/** Camera distance to the view target, or the camera height without one. */
|
||||
function viewTargetRangeM(viewer, target, cameraHeightM) {
|
||||
const position = viewer.camera.positionWC;
|
||||
function viewTargetRangeM(pose, target, cameraHeightM) {
|
||||
const position = pose.position;
|
||||
if (!position) return cameraHeightM;
|
||||
const range = Cesium.Cartesian3.distance(
|
||||
const range = chordM(
|
||||
position,
|
||||
Cesium.Cartographic.toCartesian(target),
|
||||
fromRadians(target.longitude, target.latitude, target.height),
|
||||
);
|
||||
return Number.isFinite(range) ? range : cameraHeightM;
|
||||
}
|
||||
@@ -3380,12 +3411,17 @@ async function basemapLabelsAt(
|
||||
};
|
||||
}
|
||||
|
||||
/** Viewers that already prewarm view targets on camera settle. */
|
||||
const prewarmedViewers = new WeakSet();
|
||||
|
||||
function installViewTargetPrewarm(viewer) {
|
||||
if (viewer.__gevViewTargetPrewarmInstalled) return;
|
||||
viewer.__gevViewTargetPrewarmInstalled = true;
|
||||
if (prewarmedViewers.has(viewer)) return;
|
||||
const camera = findCamera(viewer);
|
||||
if (!camera) return;
|
||||
prewarmedViewers.add(viewer);
|
||||
let timer = null;
|
||||
let reportedPrewarmFailure = false;
|
||||
viewer.camera.moveEnd.addEventListener(() => {
|
||||
camera.on('moveEnd', () => {
|
||||
if (timer) window.clearTimeout(timer);
|
||||
timer = window.setTimeout(() => {
|
||||
timer = null;
|
||||
@@ -3429,19 +3465,20 @@ function adjustCameraZoom(viewer, args) {
|
||||
}[amount];
|
||||
if (!fraction) throw new Error(`Unknown zoom amount: ${args.amount}`);
|
||||
|
||||
const camera = viewer.camera;
|
||||
const beforePosition = Cesium.Cartesian3.clone(camera.positionWC);
|
||||
const beforeHeightM = camera.positionCartographic.height;
|
||||
const camera = cameraOf(viewer);
|
||||
const before = camera.pose();
|
||||
const beforePosition = before.position;
|
||||
const beforeHeightM = before.height;
|
||||
const target = getViewTargetCartesian(viewer);
|
||||
const targetDistanceM = target
|
||||
? Cesium.Cartesian3.distance(beforePosition, target)
|
||||
? chordM(beforePosition, target)
|
||||
: Math.max(100, beforeHeightM);
|
||||
const minimumDistanceM = direction === 'in' ? 20 : 50;
|
||||
const movementM = Math.max(minimumDistanceM, targetDistanceM * fraction);
|
||||
|
||||
camera.cancelFlight();
|
||||
if (direction === 'out') {
|
||||
camera.zoomOut(movementM);
|
||||
camera.setView(eyeZoomed(before, -movementM));
|
||||
} else {
|
||||
const safeMovementM = Math.min(
|
||||
movementM,
|
||||
@@ -3456,13 +3493,12 @@ function adjustCameraZoom(viewer, args) {
|
||||
error: 'Camera is already at the minimum target distance',
|
||||
};
|
||||
}
|
||||
camera.zoomIn(safeMovementM);
|
||||
camera.setView(eyeZoomed(before, safeMovementM));
|
||||
}
|
||||
viewer.scene.requestRender();
|
||||
|
||||
const afterPosition = camera.positionWC;
|
||||
const movedM = Cesium.Cartesian3.distance(beforePosition, afterPosition);
|
||||
const afterHeightM = camera.positionCartographic.height;
|
||||
const after = camera.pose();
|
||||
const movedM = chordM(beforePosition, after.position);
|
||||
const afterHeightM = after.height;
|
||||
const moved = movedM >= 0.5;
|
||||
return {
|
||||
ok: moved,
|
||||
@@ -3504,10 +3540,12 @@ function nextIssPass(viewer, dataManager, args) {
|
||||
let latDeg = Number.isFinite(args.latitude) ? args.latitude : null;
|
||||
let lonDeg = Number.isFinite(args.longitude) ? args.longitude : null;
|
||||
if (latDeg == null || lonDeg == null) {
|
||||
const carto = viewer?.camera?.positionCartographic;
|
||||
if (!carto) throw new Error('Camera position unavailable');
|
||||
latDeg = Cesium.Math.toDegrees(carto.latitude);
|
||||
lonDeg = Cesium.Math.toDegrees(carto.longitude);
|
||||
const pose = findCamera(viewer)?.pose();
|
||||
if (!Number.isFinite(pose?.lat) || !Number.isFinite(pose?.lon)) {
|
||||
throw new Error('Camera position unavailable');
|
||||
}
|
||||
latDeg = pose.lat;
|
||||
lonDeg = pose.lon;
|
||||
}
|
||||
const minElevDeg = Number.isFinite(args.minElevationDeg)
|
||||
? args.minElevationDeg
|
||||
@@ -3731,6 +3769,10 @@ function findDataLayerRow(layerId) {
|
||||
}
|
||||
|
||||
function focusDataLayerRow(row, layerId) {
|
||||
// A row the Data Layers finder hides could not be seen: show every row
|
||||
// again (LAYER_FINDER_CLEAR_EVENT in LayerFinder.vue).
|
||||
if (row.classList.contains('is-filtered'))
|
||||
document.dispatchEvent(new CustomEvent('gev:layer-finder-clear'));
|
||||
row.scrollIntoView({ block: 'center', behavior: 'smooth' });
|
||||
row.classList.remove('gev-voice-focus');
|
||||
void row.offsetWidth;
|
||||
@@ -4411,7 +4453,7 @@ async function getEntityContext(
|
||||
const layerId = normalizeLayerId(args.layerId || args.layer);
|
||||
const limit = Math.round(clampNumber(args.limit, 1, 12, 5));
|
||||
const selected = selectedEntityContext(dataManager);
|
||||
const cameraHeightM = viewer.camera.positionCartographic.height;
|
||||
const cameraHeightM = cameraOf(viewer).pose().height;
|
||||
const viewTarget = getViewTargetCartographic(viewer);
|
||||
const scenePromise = getSceneContext(
|
||||
viewer,
|
||||
@@ -4586,7 +4628,7 @@ async function getTargetContext(
|
||||
}
|
||||
const hasPosition = Number.isFinite(lat) && Number.isFinite(lon);
|
||||
const viewTarget = hasPosition
|
||||
? Cesium.Cartographic.fromDegrees(lon, lat)
|
||||
? { longitude: toRadians(lon), latitude: toRadians(lat), height: 0 }
|
||||
: getViewTargetCartographic(viewer);
|
||||
const selected = describeTargetEntity(dataManager, target);
|
||||
const scene = await getSceneContext(
|
||||
@@ -4605,7 +4647,7 @@ async function getTargetContext(
|
||||
selected,
|
||||
};
|
||||
}
|
||||
const cameraHeightM = viewer.camera.positionCartographic.height;
|
||||
const cameraHeightM = cameraOf(viewer).pose().height;
|
||||
const visible = shouldScanVisibleEntities(cameraHeightM)
|
||||
? visibleEntityContexts(viewer, dataManager, {
|
||||
layerId: normalizeLayerId(args.layerId || args.layer),
|
||||
@@ -4710,11 +4752,10 @@ async function aircraftProximityWindowForQuery(
|
||||
let lat = record?.lat;
|
||||
let lon = record?.lon;
|
||||
if (!Number.isFinite(lat) || !Number.isFinite(lon)) {
|
||||
const carto = item.position
|
||||
? Cesium.Cartographic.fromCartesian(item.position)
|
||||
: null;
|
||||
lat = carto ? Cesium.Math.toDegrees(carto.latitude) : null;
|
||||
lon = carto ? Cesium.Math.toDegrees(carto.longitude) : null;
|
||||
const at = item.position ? toLonLatH(item.position) : null;
|
||||
const known = at && Number.isFinite(at.lat) && Number.isFinite(at.lon);
|
||||
lat = known ? at.lat : null;
|
||||
lon = known ? at.lon : null;
|
||||
}
|
||||
const row = {
|
||||
...(record || {
|
||||
@@ -4873,16 +4914,17 @@ const SUBJECT_CENTER_TOLERANCE_KM = 1;
|
||||
* ~1.5 km away — far enough to be a different place, close enough to slip
|
||||
* through and get answered as the subject's window.
|
||||
* @param {{lat: number, lon: number}} center Requested centre.
|
||||
* @param {Cesium.Cartesian3} subjectPosition Subject's world position.
|
||||
* @param {{x: number, y: number, z: number}} subjectPosition Subject's
|
||||
* world position, ECEF.
|
||||
* @returns {boolean} True when the two are the same place.
|
||||
*/
|
||||
function centerMatchesSubject(center, subjectPosition) {
|
||||
if (!Number.isFinite(center?.lat) || !Number.isFinite(center?.lon))
|
||||
return false;
|
||||
const carto = Cesium.Cartographic.fromCartesian(subjectPosition);
|
||||
if (!carto) return false;
|
||||
const subjectLat = Cesium.Math.toDegrees(carto.latitude);
|
||||
const subjectLon = Cesium.Math.toDegrees(carto.longitude);
|
||||
const at = toLonLatH(subjectPosition);
|
||||
if (!at) return false;
|
||||
const subjectLat = at.lat;
|
||||
const subjectLon = at.lon;
|
||||
return (
|
||||
greatCircleKm(
|
||||
{ lat: subjectLat, lon: subjectLon },
|
||||
@@ -4907,13 +4949,13 @@ function visibleEntityContexts(
|
||||
{ layerId = null, limit = 5, target = null } = {},
|
||||
) {
|
||||
const nearbyRecords = [];
|
||||
const canvas = viewer.scene.canvas;
|
||||
const canvas = canvasOf(viewer);
|
||||
const width = canvas.clientWidth || canvas.width || 0;
|
||||
const height = canvas.clientHeight || canvas.height || 0;
|
||||
const centerX = width / 2;
|
||||
const centerY = height / 2;
|
||||
const targetLat = target ? Cesium.Math.toDegrees(target.latitude) : null;
|
||||
const targetLon = target ? Cesium.Math.toDegrees(target.longitude) : null;
|
||||
const targetLat = target ? toDegrees(target.latitude) : null;
|
||||
const targetLon = target ? toDegrees(target.longitude) : null;
|
||||
const store = getContextStore();
|
||||
const enabledLayerIds = new Set(
|
||||
dataManager
|
||||
@@ -4925,8 +4967,8 @@ function visibleEntityContexts(
|
||||
for (const record of store.entities.values()) {
|
||||
if (layerId && record.layerId !== layerId) continue;
|
||||
if (record.layerId && !enabledLayerIds.has(record.layerId)) continue;
|
||||
if (record.entity?.show === false || record.dataSource?.show === false)
|
||||
continue;
|
||||
// Hidden from the map (its carrier or its source not shown).
|
||||
if (!isContextRecordActive(record)) continue;
|
||||
if (!Number.isFinite(record.latitude) || !Number.isFinite(record.longitude))
|
||||
continue;
|
||||
insertNearestRecord(
|
||||
@@ -4947,13 +4989,11 @@ function visibleEntityContexts(
|
||||
}
|
||||
|
||||
const candidates = [];
|
||||
const query = findQuery(viewer);
|
||||
for (const { record } of nearbyRecords) {
|
||||
const position = record.entity?.__localBaseCartesian;
|
||||
if (!position) continue;
|
||||
const screen = Cesium.SceneTransforms.worldToWindowCoordinates(
|
||||
viewer.scene,
|
||||
position,
|
||||
);
|
||||
const position = record.targetPosition;
|
||||
if (!position || !query) continue;
|
||||
const screen = query.project(position);
|
||||
if (
|
||||
!screen ||
|
||||
screen.x < 0 ||
|
||||
@@ -5004,9 +5044,7 @@ async function getSceneContext(
|
||||
viewTarget = null,
|
||||
service = defaultGeospatial,
|
||||
) {
|
||||
const cartographic = Cesium.Cartographic.fromCartesian(
|
||||
viewer.camera.positionWC,
|
||||
);
|
||||
const cartographic = cameraOf(viewer).pose();
|
||||
const basemap = await getBasemapContext(viewer, viewTarget, service);
|
||||
const enabledLayers = dataManager
|
||||
.getAll()
|
||||
@@ -5019,10 +5057,8 @@ async function getSceneContext(
|
||||
}));
|
||||
return {
|
||||
camera: {
|
||||
latitude: Number(Cesium.Math.toDegrees(cartographic.latitude).toFixed(6)),
|
||||
longitude: Number(
|
||||
Cesium.Math.toDegrees(cartographic.longitude).toFixed(6),
|
||||
),
|
||||
latitude: Number(cartographic.lat.toFixed(6)),
|
||||
longitude: Number(cartographic.lon.toFixed(6)),
|
||||
heightM: Math.round(cartographic.height),
|
||||
},
|
||||
basemap,
|
||||
@@ -5039,10 +5075,7 @@ async function getBasemapContext(
|
||||
const { reverseGeocodeCache, nearbyPlacesCache } = cachesFor(service);
|
||||
const target = viewTarget;
|
||||
const samples = sampleViewportCartographics(viewer);
|
||||
const cameraCartographic = Cesium.Cartographic.fromCartesian(
|
||||
viewer.camera.positionWC,
|
||||
);
|
||||
const cameraHeightM = cameraCartographic.height;
|
||||
const cameraHeightM = cameraOf(viewer).pose().height;
|
||||
const viewScale = classifyViewScale(cameraHeightM);
|
||||
const cachedViewportPlaces = viewportPlacesFromCache(
|
||||
samples,
|
||||
@@ -5069,8 +5102,8 @@ async function getBasemapContext(
|
||||
};
|
||||
}
|
||||
|
||||
const latitude = Number(Cesium.Math.toDegrees(target.latitude).toFixed(6));
|
||||
const longitude = Number(Cesium.Math.toDegrees(target.longitude).toFixed(6));
|
||||
const latitude = Number(toDegrees(target.latitude).toFixed(6));
|
||||
const longitude = Number(toDegrees(target.longitude).toFixed(6));
|
||||
const inferredCountry = inferCountryFromSamples(samples);
|
||||
const knownLandmarks = nearbyKnownLandmarks(
|
||||
latitude,
|
||||
@@ -5221,8 +5254,8 @@ function coarseBasemapPlace(
|
||||
};
|
||||
}
|
||||
|
||||
function getViewTargetCartographic(viewer) {
|
||||
const signature = cameraViewSignature(viewer);
|
||||
function getViewTargetCartographic(viewer, camera = cameraOf(viewer)) {
|
||||
const signature = cameraViewSignature(camera);
|
||||
const cached = viewTargetCache.get(viewer);
|
||||
if (
|
||||
cached?.signature === signature &&
|
||||
@@ -5231,11 +5264,11 @@ function getViewTargetCartographic(viewer) {
|
||||
return cached.target;
|
||||
}
|
||||
const position = getViewTargetCartesian(viewer);
|
||||
// `fromCartesian` still returns undefined for a point too near the ellipsoid
|
||||
// center to project; normalize that to the same "no target" null the callers
|
||||
// already handle for a missed pick.
|
||||
const target = position
|
||||
? Cesium.Cartographic.fromCartesian(position) || null
|
||||
// A point too near the ellipsoid center has no geodetic position: the same
|
||||
// "no target" null the callers already handle for a missed pick.
|
||||
const carto = position ? toCartographicRadians(position) : null;
|
||||
const target = carto
|
||||
? { longitude: carto.lon, latitude: carto.lat, height: carto.height }
|
||||
: null;
|
||||
viewTargetCache.set(viewer, {
|
||||
signature,
|
||||
@@ -5245,15 +5278,14 @@ function getViewTargetCartographic(viewer) {
|
||||
return target;
|
||||
}
|
||||
|
||||
function cameraViewSignature(viewer) {
|
||||
const camera = viewer.camera;
|
||||
const cartographic = camera.positionCartographic;
|
||||
function cameraViewSignature(camera) {
|
||||
const pose = camera.pose();
|
||||
return [
|
||||
Cesium.Math.toDegrees(cartographic.latitude).toFixed(5),
|
||||
Cesium.Math.toDegrees(cartographic.longitude).toFixed(5),
|
||||
Math.round(cartographic.height / 2),
|
||||
camera.heading.toFixed(3),
|
||||
camera.pitch.toFixed(3),
|
||||
pose.lat.toFixed(5),
|
||||
pose.lon.toFixed(5),
|
||||
Math.round(pose.height / 2),
|
||||
pose.heading.toFixed(3),
|
||||
pose.pitch.toFixed(3),
|
||||
].join(':');
|
||||
}
|
||||
|
||||
@@ -5261,46 +5293,38 @@ function cameraViewSignature(viewer) {
|
||||
* World position under the center of the viewport, or null when the view has no
|
||||
* target. Each stage of the cascade is validated before it is accepted: a depth
|
||||
* pick over empty sky can return a NaN or center-of-the-earth Cartesian, and
|
||||
* converting one of those throws deep inside Cesium. A degenerate pick is a
|
||||
* converting one of those throws deep inside the maths. A degenerate pick is a
|
||||
* MISSED pick, so it falls through to the next stage rather than poisoning
|
||||
* every caller downstream.
|
||||
*/
|
||||
function getViewTargetCartesian(viewer) {
|
||||
const scene = viewer.scene;
|
||||
const canvas = scene.canvas;
|
||||
const query = findQuery(viewer);
|
||||
if (!query) return null;
|
||||
const canvas = canvasOf(viewer);
|
||||
const width = canvas.clientWidth || canvas.width || 0;
|
||||
const height = canvas.clientHeight || canvas.height || 0;
|
||||
const center = new Cesium.Cartesian2(width / 2, height / 2);
|
||||
const x = width / 2;
|
||||
const y = height / 2;
|
||||
let position = null;
|
||||
|
||||
if (scene.pickPositionSupported && typeof scene.pickPosition === 'function') {
|
||||
// Depth under the pointer, where the renderer can read it.
|
||||
try {
|
||||
position = query.pickPosition(x, y);
|
||||
} catch {
|
||||
position = null;
|
||||
}
|
||||
|
||||
if (!isPickedWorldPosition(position)) {
|
||||
try {
|
||||
position = scene.pickPosition(center);
|
||||
position = query.pickEllipsoid(x, y);
|
||||
} catch {
|
||||
position = null;
|
||||
}
|
||||
}
|
||||
|
||||
if (
|
||||
!isPickedWorldPosition(position) &&
|
||||
viewer.camera &&
|
||||
typeof viewer.camera.pickEllipsoid === 'function'
|
||||
) {
|
||||
if (!isPickedWorldPosition(position)) {
|
||||
try {
|
||||
position = viewer.camera.pickEllipsoid(center, Cesium.Ellipsoid.WGS84);
|
||||
} catch {
|
||||
position = null;
|
||||
}
|
||||
}
|
||||
|
||||
if (
|
||||
!isPickedWorldPosition(position) &&
|
||||
viewer.camera &&
|
||||
typeof viewer.camera.getPickRay === 'function'
|
||||
) {
|
||||
try {
|
||||
const ray = viewer.camera.getPickRay(center);
|
||||
position = scene.globe?.pick(ray, scene) || null;
|
||||
position = query.pickGlobe(query.pickRay(x, y));
|
||||
} catch {
|
||||
position = null;
|
||||
}
|
||||
@@ -5310,8 +5334,7 @@ function getViewTargetCartesian(viewer) {
|
||||
}
|
||||
|
||||
function sampleViewportCartographics(viewer) {
|
||||
const scene = viewer.scene;
|
||||
const canvas = scene.canvas;
|
||||
const canvas = canvasOf(viewer);
|
||||
const width = canvas.clientWidth || canvas.width || 0;
|
||||
const height = canvas.clientHeight || canvas.height || 0;
|
||||
if (!width || !height) return [];
|
||||
@@ -5326,18 +5349,17 @@ function sampleViewportCartographics(viewer) {
|
||||
[0.5, 0.75],
|
||||
];
|
||||
|
||||
const query = findQuery(viewer);
|
||||
if (!query) return [];
|
||||
const samples = [];
|
||||
for (const [x, y] of points) {
|
||||
const cartesian = viewer.camera.pickEllipsoid(
|
||||
new Cesium.Cartesian2(width * x, height * y),
|
||||
Cesium.Ellipsoid.WGS84,
|
||||
);
|
||||
const cartesian = query.pickEllipsoid(width * x, height * y);
|
||||
if (!isPickedWorldPosition(cartesian)) continue;
|
||||
const carto = Cesium.Cartographic.fromCartesian(cartesian);
|
||||
if (!carto) continue;
|
||||
const at = toLonLatH(cartesian);
|
||||
if (!at) continue;
|
||||
samples.push({
|
||||
latitude: Number(Cesium.Math.toDegrees(carto.latitude).toFixed(4)),
|
||||
longitude: Number(Cesium.Math.toDegrees(carto.longitude).toFixed(4)),
|
||||
latitude: Number(at.lat.toFixed(4)),
|
||||
longitude: Number(at.lon.toFixed(4)),
|
||||
});
|
||||
}
|
||||
return samples;
|
||||
@@ -5599,8 +5621,7 @@ async function resolveWithin(promise, timeoutMs, fallback) {
|
||||
|
||||
function approximateCoordinateDistanceSq(latA, lonA, latB, lonB) {
|
||||
const latDelta = latB - latA;
|
||||
const lonDelta =
|
||||
(lonB - lonA) * Math.cos(Cesium.Math.toRadians((latA + latB) / 2));
|
||||
const lonDelta = (lonB - lonA) * Math.cos(toRadians((latA + latB) / 2));
|
||||
return latDelta * latDelta + lonDelta * lonDelta;
|
||||
}
|
||||
|
||||
@@ -5799,23 +5820,24 @@ function analystProviders(
|
||||
?.module?.getContextSnapshot?.();
|
||||
const subject = snapshot?.subject;
|
||||
if (!subject?.position) return null;
|
||||
const carto = Cesium.Cartographic.fromCartesian(subject.position);
|
||||
if (!carto) return null;
|
||||
const at = toLonLatH(subject.position);
|
||||
if (!at || !Number.isFinite(at.lat) || !Number.isFinite(at.lon))
|
||||
return null;
|
||||
return {
|
||||
lat: Cesium.Math.toDegrees(carto.latitude),
|
||||
lon: Cesium.Math.toDegrees(carto.longitude),
|
||||
lat: at.lat,
|
||||
lon: at.lon,
|
||||
label: subject.label || subject.id || null,
|
||||
};
|
||||
},
|
||||
getViewContext() {
|
||||
const carto = viewer.camera.positionCartographic;
|
||||
const altKm = carto.height / 1000;
|
||||
const pose = cameraOf(viewer).pose();
|
||||
const altKm = pose.height / 1000;
|
||||
// View radius scales with altitude: street-level asks stay local,
|
||||
// country-level asks sweep wide. Clamped so "in view" is never absurd.
|
||||
const viewRadiusKm = Math.max(25, Math.min(2500, altKm * 1.6));
|
||||
return {
|
||||
lat: Cesium.Math.toDegrees(carto.latitude),
|
||||
lon: Cesium.Math.toDegrees(carto.longitude),
|
||||
lat: pose.lat,
|
||||
lon: pose.lon,
|
||||
viewRadiusKm,
|
||||
};
|
||||
},
|
||||
@@ -5824,11 +5846,9 @@ function analystProviders(
|
||||
|
||||
/** The camera's view rectangle as [west, south, east, north] degrees, or null. */
|
||||
function cameraViewBox(viewer) {
|
||||
const rect = viewer?.camera?.computeViewRectangle?.();
|
||||
const rect = findCamera(viewer)?.viewRectangle?.();
|
||||
if (!rect) return null;
|
||||
return [rect.west, rect.south, rect.east, rect.north].map((radians) =>
|
||||
Cesium.Math.toDegrees(radians),
|
||||
);
|
||||
return [rect.west, rect.south, rect.east, rect.north];
|
||||
}
|
||||
|
||||
/** Identity fields every compact analyst item keeps when present. */
|
||||
|
||||
+265
-80
@@ -3,6 +3,7 @@ import { createStandalonePlaceSearch } from '../standalone/placeSearch.js';
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import * as Cesium from 'cesium';
|
||||
import { fromDegrees } from '../geo/index.js';
|
||||
import { CCTV_FOCUS_RESULT } from '../data/cctv.js';
|
||||
import {
|
||||
getContextStore,
|
||||
@@ -33,6 +34,11 @@ import { MAP_STACKS } from '../mapStackController.js';
|
||||
import { KEY_REJECTED_MESSAGE } from '../layers/streetLevel/providers/google/policy.js';
|
||||
import { GEV_REALTIME_TOOLS } from '../../server/providers/openai/tools.js';
|
||||
import { presentResult } from './resultDisplay.js';
|
||||
import { withEntityRecord } from '../data/entityRecords.js';
|
||||
import { bindFakeCesiumCamera } from '../testSupport/fakeCameraPort.mjs';
|
||||
import { fakeSceneQuery } from '../testSupport/fakeCesiumScene.mjs';
|
||||
import { bindRenderer, cameraOf } from '../render/rendererOf.js';
|
||||
import { entityFollowTarget } from '../data/followed.js';
|
||||
|
||||
test('every live basemap is reachable by its own id — no enum value without a voice alias', () => {
|
||||
// B1 regression: a stack added to MAP_STACKS (and the set_map_stack enum)
|
||||
@@ -183,6 +189,7 @@ function createVoiceNavigationHarness({ cockpitActive = false } = {}) {
|
||||
lookAtTransform() {},
|
||||
},
|
||||
};
|
||||
bindFakeCesiumCamera(viewer);
|
||||
const styleManager = {
|
||||
runImmediateNavigation(noun, navigate, releaseOptions = undefined) {
|
||||
return runExplicitNavigation({
|
||||
@@ -1500,7 +1507,6 @@ test('voice Stop Tracking reports exact layers whose active or durable clear fai
|
||||
getAll: () => [],
|
||||
};
|
||||
const viewer = {
|
||||
trackedEntity: { gevTrackedId: 'flights:active' },
|
||||
scene: {
|
||||
canvas: { addEventListener() {}, removeEventListener() {} },
|
||||
preRender: { addEventListener() {} },
|
||||
@@ -1508,6 +1514,18 @@ test('voice Stop Tracking reports exact layers whose active or durable clear fai
|
||||
camera: { moveEnd: { addEventListener() {} } },
|
||||
clock: { onTick: { addEventListener() {} } },
|
||||
};
|
||||
// The camera follows the active aircraft through its port.
|
||||
const camera = {
|
||||
followed: entityFollowTarget(
|
||||
withEntityRecord({}, { trackedId: 'flights:active' }),
|
||||
{},
|
||||
),
|
||||
follow(target) {
|
||||
camera.followed = target;
|
||||
},
|
||||
on: () => () => {},
|
||||
};
|
||||
bindRenderer(viewer, { camera, canvas: viewer.scene.canvas });
|
||||
const runner = createGevActionRunner({
|
||||
viewer,
|
||||
styleManager: {},
|
||||
@@ -1522,8 +1540,8 @@ test('voice Stop Tracking reports exact layers whose active or durable clear fai
|
||||
error: 'Tracking could not be cleared for: flights, military',
|
||||
});
|
||||
assert.equal(
|
||||
viewer.trackedEntity,
|
||||
undefined,
|
||||
camera.followed,
|
||||
null,
|
||||
'camera ownership still releases after partial failure',
|
||||
);
|
||||
});
|
||||
@@ -1648,7 +1666,9 @@ test('a chained orbit preserves its current destination flight while still stamp
|
||||
};
|
||||
const { order, viewer, styleManager } = createVoiceNavigationHarness();
|
||||
viewer.trackedEntity = undefined;
|
||||
viewer.scene.tweens.push({ id: 'destination-flight' });
|
||||
// The destination flight, still in progress.
|
||||
cameraOf(viewer).flyToBounds({ center: { x: 0, y: 0, z: 0 }, radius: 10 });
|
||||
order.length = 0;
|
||||
const runner = createGevActionRunner({
|
||||
viewer,
|
||||
styleManager,
|
||||
@@ -1661,7 +1681,7 @@ test('a chained orbit preserves its current destination flight while still stamp
|
||||
assert.equal(result.ok, true);
|
||||
assert.equal(result.armed, 'waiting-for-arrival');
|
||||
assert.deepEqual(order, ['stamp:camera', 'release']);
|
||||
assert.equal(viewer.scene.tweens.length, 1);
|
||||
assert.equal(cameraOf(viewer).flying, true);
|
||||
interruptCameraMotion('test-cleanup');
|
||||
});
|
||||
|
||||
@@ -1949,23 +1969,38 @@ test('Data Layers voice inventory hides the Context coordinator while current-vi
|
||||
});
|
||||
|
||||
test('showing a layer opens the panel that holds its row: Directions lives in Utilities', async () => {
|
||||
globalThis.window = globalThis.window || { clearTimeout, setTimeout, requestIdleCallback: null };
|
||||
globalThis.window = globalThis.window || {
|
||||
clearTimeout,
|
||||
setTimeout,
|
||||
requestIdleCallback: null,
|
||||
};
|
||||
const previous = { document: globalThis.document, CSS: globalThis.CSS };
|
||||
const focused = [];
|
||||
const rowIn = (panelId) => ({
|
||||
dataset: { layerName: panelId === 'utilities-panel' ? 'Directions' : 'Live Flights' },
|
||||
classList: { add: (name) => focused.push(name), remove() {} },
|
||||
dataset: {
|
||||
layerName: panelId === 'utilities-panel' ? 'Directions' : 'Live Flights',
|
||||
},
|
||||
classList: {
|
||||
add: (name) => focused.push(name),
|
||||
remove() {},
|
||||
contains: () => false,
|
||||
},
|
||||
scrollIntoView() {},
|
||||
closest: (selector) => (selector === '[data-panel-id]' ? { id: panelId } : null),
|
||||
closest: (selector) =>
|
||||
selector === '[data-panel-id]' ? { id: panelId } : null,
|
||||
});
|
||||
const rows = { directions: rowIn('utilities-panel'), flights: rowIn('data-panel') };
|
||||
const rows = {
|
||||
directions: rowIn('utilities-panel'),
|
||||
flights: rowIn('data-panel'),
|
||||
};
|
||||
// Each row is found only inside the list that really holds it.
|
||||
const lists = { directions: '#utilities-toggles', flights: '#data-toggles' };
|
||||
globalThis.CSS = { escape: (value) => value };
|
||||
globalThis.document = {
|
||||
querySelector: (selector) => {
|
||||
for (const part of selector.split(',')) {
|
||||
const [, list, id] = /^\s*(#[\w-]+) \[data-layer-id="([^"]+)"\]\s*$/.exec(part) || [];
|
||||
const [, list, id] =
|
||||
/^\s*(#[\w-]+) \[data-layer-id="([^"]+)"\]\s*$/.exec(part) || [];
|
||||
if (id && lists[id] === list) return rows[id];
|
||||
}
|
||||
return null;
|
||||
@@ -1974,15 +2009,28 @@ test('showing a layer opens the panel that holds its row: Directions lives in Ut
|
||||
try {
|
||||
const opened = [];
|
||||
const layers = [
|
||||
{ id: 'flights', name: 'Live Flights', enabled: false, showInTogglePanel: true, stats: {} },
|
||||
{ id: 'directions', name: 'Directions', enabled: false, showInTogglePanel: true, stats: {} },
|
||||
{
|
||||
id: 'flights',
|
||||
name: 'Live Flights',
|
||||
enabled: false,
|
||||
showInTogglePanel: true,
|
||||
stats: {},
|
||||
},
|
||||
{
|
||||
id: 'directions',
|
||||
name: 'Directions',
|
||||
enabled: false,
|
||||
showInTogglePanel: true,
|
||||
stats: {},
|
||||
},
|
||||
];
|
||||
const dataManager = {
|
||||
layers: new Map(layers.map((layer) => [layer.id, { module: {} }])),
|
||||
getAll: () => layers,
|
||||
};
|
||||
const styleManager = {
|
||||
setPanelCollapsed: (panelId, collapsed) => opened.push([panelId, collapsed]),
|
||||
setPanelCollapsed: (panelId, collapsed) =>
|
||||
opened.push([panelId, collapsed]),
|
||||
};
|
||||
const viewer = {
|
||||
clock: { onTick: { addEventListener: () => () => {} } },
|
||||
@@ -1990,12 +2038,22 @@ test('showing a layer opens the panel that holds its row: Directions lives in Ut
|
||||
camera: { moveEnd: { addEventListener() {} } },
|
||||
};
|
||||
const runner = createGevActionRunner({ viewer, styleManager, dataManager });
|
||||
const directions = await runner('show_data_layers_menu', { layerId: 'directions' });
|
||||
const directions = await runner('show_data_layers_menu', {
|
||||
layerId: 'directions',
|
||||
});
|
||||
assert.equal(directions.panelId, 'utilities-panel');
|
||||
assert.deepEqual(directions.focusedLayer, { id: 'directions', name: 'Directions' });
|
||||
const flights = await runner('show_data_layers_menu', { layerId: 'flights' });
|
||||
assert.deepEqual(directions.focusedLayer, {
|
||||
id: 'directions',
|
||||
name: 'Directions',
|
||||
});
|
||||
const flights = await runner('show_data_layers_menu', {
|
||||
layerId: 'flights',
|
||||
});
|
||||
assert.equal(flights.panelId, 'data-panel');
|
||||
assert.deepEqual(opened, [['utilities-panel', false], ['data-panel', false]]);
|
||||
assert.deepEqual(opened, [
|
||||
['utilities-panel', false],
|
||||
['data-panel', false],
|
||||
]);
|
||||
assert.deepEqual(focused, ['gev-voice-focus', 'gev-voice-focus']);
|
||||
} finally {
|
||||
globalThis.document = previous.document;
|
||||
@@ -2724,7 +2782,7 @@ test('control_cockpit delegates selected-flight adoption to the canonical cockpi
|
||||
scene: { canvas: { addEventListener() {}, removeEventListener() {} } },
|
||||
camera: { moveEnd: { addEventListener() {} } },
|
||||
};
|
||||
const recordCarrier = { __gevContextId: 'selected-flight-for-cockpit-enter' };
|
||||
const recordCarrier = {};
|
||||
const record = registerEntityContext(recordCarrier, {
|
||||
id: 'abc123',
|
||||
layerId: 'flights',
|
||||
@@ -2915,7 +2973,7 @@ test('control_cockpit adopts the newest selection after Contacts settles', async
|
||||
};
|
||||
const contextStore = getContextStore();
|
||||
const first = registerEntityContext(
|
||||
{ __gevContextId: 'cockpit-selection-first' },
|
||||
{},
|
||||
{
|
||||
id: 'first',
|
||||
layerId: 'flights',
|
||||
@@ -2923,7 +2981,7 @@ test('control_cockpit adopts the newest selection after Contacts settles', async
|
||||
},
|
||||
);
|
||||
const second = registerEntityContext(
|
||||
{ __gevContextId: 'cockpit-selection-second' },
|
||||
{},
|
||||
{
|
||||
id: 'second',
|
||||
layerId: 'flights',
|
||||
@@ -3262,7 +3320,7 @@ test('control_cockpit enter skips selected non-flight context', async () => {
|
||||
scene: { canvas: { addEventListener() {}, removeEventListener() {} } },
|
||||
camera: { moveEnd: { addEventListener() {} } },
|
||||
};
|
||||
const recordCarrier = { __gevContextId: 'selected-non-flight-cockpit-enter' };
|
||||
const recordCarrier = {};
|
||||
const record = registerEntityContext(recordCarrier, {
|
||||
id: 'poi-001',
|
||||
layerId: 'local-datacenters',
|
||||
@@ -4410,6 +4468,7 @@ function createPrewarmHarness({ pickPosition, positionCartographic } = {}) {
|
||||
},
|
||||
},
|
||||
};
|
||||
bindFakeCesiumCamera(viewer, { query: fakeSceneQuery(viewer) });
|
||||
return {
|
||||
viewer,
|
||||
calls,
|
||||
@@ -4724,7 +4783,7 @@ test('a nested Cockpit rollback result is translated too', async () => {
|
||||
* analyst's 2 000-record last-fix slice). These pin the unified engine.
|
||||
*/
|
||||
function awarenessSubjectHarness({ subject, flights = [], military = [] }) {
|
||||
const position = subject ? { __subject: true } : null;
|
||||
const position = subject ? fromDegrees(-97.9, 29.9, 9000) : null;
|
||||
const snapshotFlights = flights.slice(0, 20_000);
|
||||
const snapshotMilitary = military.slice(0, 20_000);
|
||||
return {
|
||||
@@ -4775,7 +4834,6 @@ async function withAwareness(harness, run) {
|
||||
aircraftSnapshot: awareness.getAircraftQuerySnapshot,
|
||||
flightsNearby: flightsLayer.getNearby,
|
||||
militaryNearby: militaryLayer.getNearby,
|
||||
cartoFrom: Cesium.Cartographic.fromCartesian,
|
||||
};
|
||||
awareness.getContextSnapshot = () => harness.snapshot;
|
||||
awareness.getAircraftQuerySnapshot = () => {
|
||||
@@ -4808,14 +4866,6 @@ async function withAwareness(harness, run) {
|
||||
};
|
||||
flightsLayer.getNearby = () => harness.flights.slice();
|
||||
militaryLayer.getNearby = () => harness.military.slice();
|
||||
Cesium.Cartographic.fromCartesian = (value) =>
|
||||
value?.__subject
|
||||
? {
|
||||
latitude: Cesium.Math.toRadians(29.9),
|
||||
longitude: Cesium.Math.toRadians(-97.9),
|
||||
height: 9000,
|
||||
}
|
||||
: originals.cartoFrom(value);
|
||||
try {
|
||||
return await run(awareness);
|
||||
} finally {
|
||||
@@ -4823,7 +4873,6 @@ async function withAwareness(harness, run) {
|
||||
awareness.getAircraftQuerySnapshot = originals.aircraftSnapshot;
|
||||
flightsLayer.getNearby = originals.flightsNearby;
|
||||
militaryLayer.getNearby = originals.militaryNearby;
|
||||
Cesium.Cartographic.fromCartesian = originals.cartoFrom;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -5180,7 +5229,10 @@ test('voice Radio: a key that geocodes to nothing still places the station, keyl
|
||||
installKeyedFetch(t, async (url) => {
|
||||
requests.push(String(url));
|
||||
if (String(url).startsWith('/api/google/geocode')) {
|
||||
return { ok: true, json: async () => ({ status: 'ZERO_RESULTS', results: [] }) };
|
||||
return {
|
||||
ok: true,
|
||||
json: async () => ({ status: 'ZERO_RESULTS', results: [] }),
|
||||
};
|
||||
}
|
||||
assert.match(String(url), /^https:\/\/photon\.komoot\.io\/api\/\?/);
|
||||
return {
|
||||
@@ -5211,8 +5263,14 @@ test('voice Radio: a key that geocodes to nothing still places the station, keyl
|
||||
assert.ok(Math.abs(calls[0].criteria.anchor.lat - 20.9101) < 1e-9);
|
||||
assert.ok(Math.abs(calls[0].criteria.anchor.lon - 107.1839) < 1e-9);
|
||||
// Google is asked first and exactly once; Photon answers unbiased, in one call.
|
||||
assert.equal(requests.filter((url) => url.includes('/api/google/geocode')).length, 1);
|
||||
assert.equal(requests.filter((url) => url.includes('photon.komoot.io')).length, 1);
|
||||
assert.equal(
|
||||
requests.filter((url) => url.includes('/api/google/geocode')).length,
|
||||
1,
|
||||
);
|
||||
assert.equal(
|
||||
requests.filter((url) => url.includes('photon.komoot.io')).length,
|
||||
1,
|
||||
);
|
||||
assert.match(requests.at(-1), /[?&]q=H%E1%BA%A1\+Long\+Bay/);
|
||||
assert.doesNotMatch(
|
||||
requests.at(-1),
|
||||
@@ -5228,14 +5286,26 @@ test('voice Radio: the keyless path applies no country filter the keyed path wou
|
||||
// "No Radio station matched" for exactly the places it just resolved, while a
|
||||
// keyed install placed a station. The label may carry it; the filter may not.
|
||||
const { calls, dataManager } = radioSelectionHarness();
|
||||
installKeyedFetch(t, async (url) => (String(url).startsWith('/api/google/geocode')
|
||||
? { ok: true, json: async () => ({ status: 'ZERO_RESULTS', results: [] }) }
|
||||
: {
|
||||
ok: true,
|
||||
json: async () => ({
|
||||
features: [photonFeature({ name: 'Kraków', lat: 50.0614, lon: 19.9366, country: 'Polska' })],
|
||||
}),
|
||||
}));
|
||||
installKeyedFetch(t, async (url) =>
|
||||
String(url).startsWith('/api/google/geocode')
|
||||
? {
|
||||
ok: true,
|
||||
json: async () => ({ status: 'ZERO_RESULTS', results: [] }),
|
||||
}
|
||||
: {
|
||||
ok: true,
|
||||
json: async () => ({
|
||||
features: [
|
||||
photonFeature({
|
||||
name: 'Kraków',
|
||||
lat: 50.0614,
|
||||
lon: 19.9366,
|
||||
country: 'Polska',
|
||||
}),
|
||||
],
|
||||
}),
|
||||
},
|
||||
);
|
||||
|
||||
const result = await controlRadio({}, dataManager, {
|
||||
action: 'select',
|
||||
@@ -5264,8 +5334,15 @@ const testPlaceSearch = () =>
|
||||
createStandalonePlaceSearch({
|
||||
resolveApiKey: () => globalThis.window?.__GOOGLE_MAPS_API_KEY__,
|
||||
});
|
||||
/** Fake viewers with a fake Cesium camera reach the renderer's camera port too. */
|
||||
const withCameraPort = (viewer) =>
|
||||
viewer?.camera ? bindFakeCesiumCamera(viewer) : viewer;
|
||||
function createGevActionRunner(options) {
|
||||
return createActionRunner({ placeSearch: testPlaceSearch(), ...options });
|
||||
return createActionRunner({
|
||||
placeSearch: testPlaceSearch(),
|
||||
...options,
|
||||
viewer: withCameraPort(options?.viewer),
|
||||
});
|
||||
}
|
||||
function controlRadio(viewer, manager, args, options) {
|
||||
return runControlRadio(viewer, manager, args, {
|
||||
@@ -5324,22 +5401,48 @@ test('ALPR common names toggle only the registered camera layer through the norm
|
||||
});
|
||||
|
||||
test('GNSS integrity and interference common names toggle only the GNSS layer through the normal voice action', async () => {
|
||||
globalThis.window = globalThis.window || { clearTimeout, setTimeout, requestIdleCallback: null };
|
||||
const viewer = { clock: { onTick: { addEventListener: () => () => {} } },
|
||||
globalThis.window = globalThis.window || {
|
||||
clearTimeout,
|
||||
setTimeout,
|
||||
requestIdleCallback: null,
|
||||
};
|
||||
const viewer = {
|
||||
clock: { onTick: { addEventListener: () => () => {} } },
|
||||
scene: { canvas: { addEventListener() {}, removeEventListener() {} } },
|
||||
camera: { moveEnd: { addEventListener() {} } } };
|
||||
camera: { moveEnd: { addEventListener() {} } },
|
||||
};
|
||||
const calls = [];
|
||||
let enabled = false;
|
||||
const dataManager = {
|
||||
layers: new Map([['gnss-integrity', { module: {} }]]),
|
||||
getAll: () => [{ id: 'gnss-integrity', name: 'GNSS Integrity' }],
|
||||
isEnabled: () => enabled,
|
||||
setEnabled: async (id, value) => { calls.push([id, value]); enabled = value; return true; },
|
||||
setEnabled: async (id, value) => {
|
||||
calls.push([id, value]);
|
||||
enabled = value;
|
||||
return true;
|
||||
},
|
||||
};
|
||||
const runner = createGevActionRunner({ viewer, styleManager: {}, dataManager });
|
||||
for (const alias of ['gnss-integrity', 'gnss integrity', 'navigation integrity', 'low navigation accuracy', 'gnss interference', 'gps interference', 'gps jamming', 'gnss']) {
|
||||
const runner = createGevActionRunner({
|
||||
viewer,
|
||||
styleManager: {},
|
||||
dataManager,
|
||||
});
|
||||
for (const alias of [
|
||||
'gnss-integrity',
|
||||
'gnss integrity',
|
||||
'navigation integrity',
|
||||
'low navigation accuracy',
|
||||
'gnss interference',
|
||||
'gps interference',
|
||||
'gps jamming',
|
||||
'gnss',
|
||||
]) {
|
||||
for (const value of [true, false]) {
|
||||
const result = await runner('set_layer_visibility', { layerId: alias, enabled: value });
|
||||
const result = await runner('set_layer_visibility', {
|
||||
layerId: alias,
|
||||
enabled: value,
|
||||
});
|
||||
assert.equal(result.ok, true);
|
||||
assert.equal(result.layerId, 'gnss-integrity');
|
||||
assert.deepEqual(calls.at(-1), ['gnss-integrity', value]);
|
||||
@@ -5703,7 +5806,11 @@ test('analyst_query refusals carry their code and the allowed values', async ()
|
||||
});
|
||||
|
||||
test('analyst_query keeps its answer when one record has an out-of-range time', async () => {
|
||||
globalThis.window = globalThis.window || { clearTimeout, setTimeout, requestIdleCallback: null };
|
||||
globalThis.window = globalThis.window || {
|
||||
clearTimeout,
|
||||
setTimeout,
|
||||
requestIdleCallback: null,
|
||||
};
|
||||
const now = Date.now();
|
||||
const earthquakes = {
|
||||
getStats: () => ({ count: 2, lastUpdate: now }),
|
||||
@@ -5712,8 +5819,14 @@ test('analyst_query keeps its answer when one record has an out-of-range time',
|
||||
{ id: 'r', lat: 1, lon: 1, magnitude: 4, timeMs: 8.64e15 + 1 },
|
||||
],
|
||||
};
|
||||
const { runner } = manifestRunner({ earthquakes }, { enabled: ['earthquakes'] });
|
||||
const result = await runner('analyst_query', { layers: ['earthquakes'], scope: { kind: 'anywhere' } });
|
||||
const { runner } = manifestRunner(
|
||||
{ earthquakes },
|
||||
{ enabled: ['earthquakes'] },
|
||||
);
|
||||
const result = await runner('analyst_query', {
|
||||
layers: ['earthquakes'],
|
||||
scope: { kind: 'anywhere' },
|
||||
});
|
||||
assert.equal(result.ok, true);
|
||||
const q = result.items.find((item) => item.id === 'q');
|
||||
assert.match(q.time, /^\d{4}-\d\d-\d\dT/);
|
||||
@@ -6156,14 +6269,30 @@ test('an analyst follow-up on OSM places keeps the area they were found in', asy
|
||||
ok: true,
|
||||
truncated: false,
|
||||
features: [
|
||||
{ id: 'node/1', lat: 0.5, lon: 0.5, tags: { name: 'North Hospital', emergency: 'yes' } },
|
||||
{ id: 'node/2', lat: 0.4, lon: 0.6, tags: { name: 'South Hospital', emergency: 'no' } },
|
||||
{
|
||||
id: 'node/1',
|
||||
lat: 0.5,
|
||||
lon: 0.5,
|
||||
tags: { name: 'North Hospital', emergency: 'yes' },
|
||||
},
|
||||
{
|
||||
id: 'node/2',
|
||||
lat: 0.4,
|
||||
lon: 0.6,
|
||||
tags: { name: 'South Hospital', emergency: 'no' },
|
||||
},
|
||||
],
|
||||
}),
|
||||
});
|
||||
const area = await runner('resolve_area', { query: 'Test Province', level: 'admin1' });
|
||||
const area = await runner('resolve_area', {
|
||||
query: 'Test Province',
|
||||
level: 'admin1',
|
||||
});
|
||||
assert.equal(area.ok, true);
|
||||
const found = await runner('osm_query', { what: 'hospitals', areaId: area.areaId });
|
||||
const found = await runner('osm_query', {
|
||||
what: 'hospitals',
|
||||
areaId: area.areaId,
|
||||
});
|
||||
assert.equal(found.ok, true, found.error);
|
||||
assert.equal(found.count, 2);
|
||||
const followUp = await runner('analyst_query', {
|
||||
@@ -6486,37 +6615,59 @@ test('point-and-ask: only accepted, current results become the referent list', a
|
||||
assert.equal(tracked, 1);
|
||||
});
|
||||
|
||||
|
||||
test('numbered analyst records navigate using the current layer accessor', async () => {
|
||||
globalThis.window = globalThis.window || { clearTimeout, setTimeout, requestIdleCallback: null };
|
||||
globalThis.window = globalThis.window || {
|
||||
clearTimeout,
|
||||
setTimeout,
|
||||
requestIdleCallback: null,
|
||||
};
|
||||
const { viewer, styleManager } = createVoiceNavigationHarness();
|
||||
const referents = createReferentRegistry();
|
||||
let enabled = true;
|
||||
let records = [{ id: 'congress', name: 'Congress station', lat: 30.27, lon: -97.74 }];
|
||||
let records = [
|
||||
{ id: 'congress', name: 'Congress station', lat: 30.27, lon: -97.74 },
|
||||
];
|
||||
const runner = createActionRunner({
|
||||
viewer, styleManager,
|
||||
viewer,
|
||||
styleManager,
|
||||
dataManager: {
|
||||
layers: new Map([['bikeshare', { module: { getAnalystRecords: () => records } }]]),
|
||||
layers: new Map([
|
||||
['bikeshare', { module: { getAnalystRecords: () => records } }],
|
||||
]),
|
||||
isEnabled: () => enabled,
|
||||
getAll: () => [],
|
||||
},
|
||||
deixis: { referents },
|
||||
});
|
||||
referents.recordResult('analyst_query', { ok: true, items: [{ ...records[0], layerKey: 'bikeshare' }] });
|
||||
referents.recordResult('analyst_query', {
|
||||
ok: true,
|
||||
items: [{ ...records[0], layerKey: 'bikeshare' }],
|
||||
});
|
||||
const result = await runner('fly_to_location', { referent: 1 });
|
||||
assert.equal(result.ok, true);
|
||||
assert.equal(result.latitude, 30.27);
|
||||
assert.equal(result.longitude, -97.74);
|
||||
enabled = false;
|
||||
assert.equal((await runner('fly_to_location', { referent: 1 })).ok, false, 'disabled records cannot be revisited');
|
||||
assert.equal(
|
||||
(await runner('fly_to_location', { referent: 1 })).ok,
|
||||
false,
|
||||
'disabled records cannot be revisited',
|
||||
);
|
||||
enabled = true;
|
||||
records = [];
|
||||
assert.equal((await runner('fly_to_location', { referent: 1 })).ok, false, 'removed records are not resurrected');
|
||||
assert.equal(
|
||||
(await runner('fly_to_location', { referent: 1 })).ok,
|
||||
false,
|
||||
'removed records are not resurrected',
|
||||
);
|
||||
});
|
||||
|
||||
|
||||
test('analyst-only lookup distinguishes duplicate names and uses canonical aircraft IDs', async () => {
|
||||
globalThis.window = globalThis.window || { clearTimeout, setTimeout, requestIdleCallback: null };
|
||||
globalThis.window = globalThis.window || {
|
||||
clearTimeout,
|
||||
setTimeout,
|
||||
requestIdleCallback: null,
|
||||
};
|
||||
const { viewer, styleManager } = createVoiceNavigationHarness();
|
||||
const referents = createReferentRegistry();
|
||||
const stations = [
|
||||
@@ -6525,28 +6676,44 @@ test('analyst-only lookup distinguishes duplicate names and uses canonical aircr
|
||||
];
|
||||
const aircraft = [{ id: 'UAL1', icao24: 'abc123', lat: 35, lon: -100 }];
|
||||
const runner = createActionRunner({
|
||||
viewer, styleManager,
|
||||
viewer,
|
||||
styleManager,
|
||||
dataManager: {
|
||||
layers: new Map([
|
||||
['bikeshare', { module: { getAnalystRecords: () => stations } }],
|
||||
['local-adsb', { module: { getAnalystRecords: () => aircraft } }],
|
||||
]),
|
||||
isEnabled: () => true, getAll: () => [],
|
||||
isEnabled: () => true,
|
||||
getAll: () => [],
|
||||
},
|
||||
deixis: { referents },
|
||||
});
|
||||
referents.recordResult('analyst_query', { ok: true, items: stations.map(row => ({ ...row, layerKey: 'bikeshare' })) });
|
||||
referents.recordResult('analyst_query', {
|
||||
ok: true,
|
||||
items: stations.map((row) => ({ ...row, layerKey: 'bikeshare' })),
|
||||
});
|
||||
const station = await runner('fly_to_location', { referent: 2 });
|
||||
assert.equal(station.ok, true);
|
||||
assert.equal(station.latitude, 40);
|
||||
assert.equal(station.longitude, -74);
|
||||
stations.pop();
|
||||
assert.equal((await runner('fly_to_location', { referent: 2 })).ok, false, 'a removed station must not resolve to its remaining namesake');
|
||||
referents.recordResult('analyst_query', { ok: true, items: aircraft.map(row => ({ ...row, layerKey: 'local-adsb' })) });
|
||||
assert.equal(
|
||||
(await runner('fly_to_location', { referent: 2 })).ok,
|
||||
false,
|
||||
'a removed station must not resolve to its remaining namesake',
|
||||
);
|
||||
referents.recordResult('analyst_query', {
|
||||
ok: true,
|
||||
items: aircraft.map((row) => ({ ...row, layerKey: 'local-adsb' })),
|
||||
});
|
||||
aircraft[0].lat = 36;
|
||||
const plane = await runner('fly_to_location', { referent: 1 });
|
||||
assert.equal(plane.ok, true);
|
||||
assert.equal(plane.latitude, 36, 'canonical ID resolves the current position, not old coordinates');
|
||||
assert.equal(
|
||||
plane.latitude,
|
||||
36,
|
||||
'canonical ID resolves the current position, not old coordinates',
|
||||
);
|
||||
});
|
||||
|
||||
/** A Street Level layer stub, a map stack and a data manager for show_street_level. */
|
||||
@@ -7203,10 +7370,17 @@ test('set_panel_open accepts the Authoring name for the scene panel', async () =
|
||||
styleManager: {
|
||||
setPanelCollapsed: (...args) => calls.push(args),
|
||||
},
|
||||
dataManager: { layers: new Map(), isEnabled: () => false, getAll: () => [] },
|
||||
dataManager: {
|
||||
layers: new Map(),
|
||||
isEnabled: () => false,
|
||||
getAll: () => [],
|
||||
},
|
||||
});
|
||||
for (const panel of ['authoring', 'Authoring', 'scenes']) {
|
||||
const result = await runner('set_panel_open', { panelId: panel, open: true });
|
||||
const result = await runner('set_panel_open', {
|
||||
panelId: panel,
|
||||
open: true,
|
||||
});
|
||||
assert.equal(result.panelId, 'scene-panel');
|
||||
}
|
||||
assert.deepEqual(calls.at(-1), ['scene-panel', false, { explicit: true }]);
|
||||
@@ -7226,13 +7400,24 @@ test('set_panel_open reaches the Utilities panel by its name, Draw or Import', a
|
||||
styleManager: {
|
||||
setPanelCollapsed: (...args) => calls.push(args),
|
||||
},
|
||||
dataManager: { layers: new Map(), isEnabled: () => false, getAll: () => [] },
|
||||
dataManager: {
|
||||
layers: new Map(),
|
||||
isEnabled: () => false,
|
||||
getAll: () => [],
|
||||
},
|
||||
});
|
||||
for (const panel of ['utilities-panel', 'utilities', 'drawing', 'import']) {
|
||||
const result = await runner('set_panel_open', { panelId: panel, open: true });
|
||||
const result = await runner('set_panel_open', {
|
||||
panelId: panel,
|
||||
open: true,
|
||||
});
|
||||
assert.equal(result.panelId, 'utilities-panel', panel);
|
||||
}
|
||||
assert.deepEqual(calls.at(-1), ['utilities-panel', false, { explicit: true }]);
|
||||
assert.deepEqual(calls.at(-1), [
|
||||
'utilities-panel',
|
||||
false,
|
||||
{ explicit: true },
|
||||
]);
|
||||
});
|
||||
|
||||
test('a partial analyst card shows one partial chip', () => {
|
||||
|
||||
@@ -5,6 +5,7 @@ import { createVoiceCommands } from './commands.js';
|
||||
import { cameraPoseKey, createPointerTracker } from './pointerContext.js';
|
||||
import { createPointerPicker } from './pointerPick.js';
|
||||
import { createReferentRegistry } from './referents.js';
|
||||
import { canvasOf } from '../render/rendererOf.js';
|
||||
export * from './realtimeController.js';
|
||||
|
||||
const ACTION_NAMES = new Set(GEV_ACTION_SCHEMAS.map((schema) => schema.name));
|
||||
@@ -32,7 +33,7 @@ export function withToolCatalog(runner, loadCatalog) {
|
||||
|
||||
/** Compose the standalone action runner with the voice controls. */
|
||||
export function initGevVoiceCommands(options) {
|
||||
const canvas = options.viewer?.scene?.canvas || null;
|
||||
const canvas = canvasOf(options.viewer);
|
||||
const cameraKey = () => cameraPoseKey(options.viewer);
|
||||
// Point-and-ask: the tracker and referents are shared by the runner (which
|
||||
// resolves 'pointer' and referent:n) and the controls (which snapshot the
|
||||
|
||||
@@ -2,6 +2,8 @@
|
||||
// These helpers are DOM/WebRTC-free so they pin the screenshot down-scaling and
|
||||
// payload-byte estimation that keep an oversized dc.send from stranding a turn.
|
||||
import { test } from 'node:test';
|
||||
import { bindRenderer } from '../render/rendererOf.js';
|
||||
import { fakeSceneFrame } from '../testSupport/fakeCesiumScene.mjs';
|
||||
import assert from 'node:assert/strict';
|
||||
import { DataLayerManager } from '../data/manager.js';
|
||||
import { controlRadio as runControlRadio, createGevActionRunner as createActionRunner } from './gevActions.js';
|
||||
@@ -37,6 +39,14 @@ import { createVoiceCostTracker } from './voiceCost.js';
|
||||
import { createTestVoiceUi } from '../testSupport/voiceUi.mjs';
|
||||
import { setLocale, t } from '../i18n/index.js';
|
||||
|
||||
|
||||
/** A viewer over `scene` whose renderer's frame port is the scene's own loop. */
|
||||
function framed(scene) {
|
||||
const viewer = { scene };
|
||||
bindRenderer(viewer, { frame: fakeSceneFrame(viewer) });
|
||||
return viewer;
|
||||
}
|
||||
|
||||
test('push-to-talk recognizes Space by code or key', () => {
|
||||
assert.equal(PUSH_TO_TALK_HOLD_DELAY_MS, 500);
|
||||
assert.equal(isPushToTalkKey({ code: 'Space', key: 'Unidentified' }), true);
|
||||
@@ -1343,6 +1353,7 @@ test('generic same-response Radio visibility disable supersedes delayed Select',
|
||||
});
|
||||
const viewer = {
|
||||
clock: { onTick: { addEventListener: () => () => {} } },
|
||||
canvas: { addEventListener() {}, removeEventListener() {} },
|
||||
scene: { canvas: { addEventListener() {}, removeEventListener() {} } },
|
||||
camera: { moveEnd: { addEventListener() {} } },
|
||||
};
|
||||
@@ -1595,6 +1606,7 @@ test('Pause and Stop preserve independent dedicated and generic Radio ON across
|
||||
});
|
||||
const viewer = {
|
||||
clock: { onTick: { addEventListener: () => () => {} } },
|
||||
canvas: { addEventListener() {}, removeEventListener() {} },
|
||||
scene: { canvas: { addEventListener() {}, removeEventListener() {} } },
|
||||
camera: { moveEnd: { addEventListener() {} } },
|
||||
};
|
||||
@@ -2846,7 +2858,7 @@ test('hidden document yields no fresh frame — capture must not label a stale c
|
||||
};
|
||||
try {
|
||||
globalThis.document = { hidden: true };
|
||||
const fresh = await renderFreshCesiumFrame({ scene });
|
||||
const fresh = await renderFreshCesiumFrame(framed(scene));
|
||||
assert.equal(fresh, false, 'hidden capture reports non-fresh');
|
||||
assert.equal(requested, 0, 'no secret render restart while hidden');
|
||||
} finally {
|
||||
@@ -2863,7 +2875,7 @@ test('visible document with a rendering scene reports a fresh frame', async () =
|
||||
postRender: { addEventListener(listener) { fire = listener; return () => { fire = null; }; } },
|
||||
requestRender() { queueMicrotask(() => fire?.()); },
|
||||
};
|
||||
const fresh = await renderFreshCesiumFrame({ scene });
|
||||
const fresh = await renderFreshCesiumFrame(framed(scene));
|
||||
assert.equal(fresh, true);
|
||||
} finally {
|
||||
globalThis.document = originalDocument;
|
||||
@@ -2880,7 +2892,7 @@ test('a tab switch during the bounded render wait invalidates freshness', async
|
||||
postRender: { addEventListener(listener) { fire = listener; return () => { fire = null; }; } },
|
||||
requestRender() { doc.hidden = true; queueMicrotask(() => fire?.()); },
|
||||
};
|
||||
const fresh = await renderFreshCesiumFrame({ scene });
|
||||
const fresh = await renderFreshCesiumFrame(framed(scene));
|
||||
assert.equal(fresh, false, 'freshness rechecked after the await');
|
||||
} finally {
|
||||
globalThis.document = originalDocument;
|
||||
|
||||
@@ -5,6 +5,8 @@ import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import * as Cesium from 'cesium';
|
||||
import { getBasemapLabelContext } from './gevActions.js';
|
||||
import { bindFakeCesiumCamera } from '../testSupport/fakeCameraPort.mjs';
|
||||
import { fakeSceneQuery } from '../testSupport/fakeCesiumScene.mjs';
|
||||
import {
|
||||
hudViewportSamples,
|
||||
placeLookupView,
|
||||
@@ -25,7 +27,12 @@ function createViewer({ latitude, longitude, heightM, groundM = 0 }) {
|
||||
const camera = {
|
||||
heading: 0,
|
||||
pitch: -Math.PI / 2,
|
||||
frustum: { fov: Math.PI / 3, aspectRatio: 1.5 },
|
||||
// Cesium's `fov` is the wider angle; `fovy` the vertical one.
|
||||
frustum: {
|
||||
fov: Math.PI / 3,
|
||||
fovy: 2 * Math.atan(Math.tan(Math.PI / 6) / 1.5),
|
||||
aspectRatio: 1.5,
|
||||
},
|
||||
pickEllipsoid(point) {
|
||||
return Cesium.Cartesian3.fromDegrees(
|
||||
state.longitude +
|
||||
@@ -63,7 +70,9 @@ function createViewer({ latitude, longitude, heightM, groundM = 0 }) {
|
||||
state.groundM,
|
||||
),
|
||||
};
|
||||
return { viewer: { camera, scene }, state, degreesPerPixel };
|
||||
const viewer = { camera, scene };
|
||||
bindFakeCesiumCamera(viewer, { query: fakeSceneQuery(viewer) });
|
||||
return { viewer, state, degreesPerPixel };
|
||||
}
|
||||
|
||||
/** Answers every lookup with a label naming the point it was asked about. */
|
||||
|
||||
@@ -302,7 +302,23 @@ const layers = [
|
||||
},
|
||||
{
|
||||
id: 'transit',
|
||||
aliases: ['buses', 'trains', 'public transit', 'trams', 'subway'],
|
||||
aliases: [
|
||||
'buses',
|
||||
'trains',
|
||||
'public transit',
|
||||
'trams',
|
||||
'subway',
|
||||
'trolleybus',
|
||||
'trolleybuses',
|
||||
'gondola',
|
||||
'gondolas',
|
||||
'cable car',
|
||||
'cable cars',
|
||||
'funicular',
|
||||
'funiculars',
|
||||
'monorail',
|
||||
'monorails',
|
||||
],
|
||||
context: false,
|
||||
query: {
|
||||
fields: {
|
||||
|
||||
@@ -542,6 +542,7 @@ async function directActions(
|
||||
const runner = createGevActionRunner({
|
||||
viewer: {
|
||||
clock: { onTick: { addEventListener: () => () => {} } },
|
||||
canvas: { addEventListener() {}, removeEventListener() {} },
|
||||
scene: { canvas: { addEventListener() {}, removeEventListener() {} } },
|
||||
camera: { moveEnd: { addEventListener() {} } },
|
||||
},
|
||||
|
||||
@@ -18,6 +18,7 @@
|
||||
*
|
||||
* Provider-neutral and Cesium-free: the pick is injected.
|
||||
*/
|
||||
import { findCamera } from '../render/rendererOf.js';
|
||||
|
||||
/** Movement below this many CSS pixels is still the same dwell. */
|
||||
const POINTER_DWELL_PX = 12;
|
||||
@@ -55,23 +56,28 @@ const finite = finiteOrNull;
|
||||
|
||||
/**
|
||||
* Camera pose identity: position to 1 m, orientation to about 0.06 degrees.
|
||||
* A pixel read under one key names nothing under another. Reads plain
|
||||
* numbers only, so it needs no Cesium import.
|
||||
* @param {object} viewer Cesium viewer.
|
||||
* A pixel read under one key names nothing under another. Reads the
|
||||
* camera port's pose.
|
||||
* @param {object} viewer The scene object.
|
||||
* @returns {string|null}
|
||||
*/
|
||||
export function cameraPoseKey(viewer) {
|
||||
const camera = viewer?.camera;
|
||||
const p = camera?.positionWC;
|
||||
let pose = null;
|
||||
try {
|
||||
pose = findCamera(viewer)?.pose() ?? null;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
const p = pose?.position;
|
||||
if (!p || !Number.isFinite(p.x)) return null;
|
||||
const angle = (value) => Math.round((Number(value) || 0) * 1000);
|
||||
return [
|
||||
Math.round(p.x),
|
||||
Math.round(p.y),
|
||||
Math.round(p.z),
|
||||
angle(camera.heading),
|
||||
angle(camera.pitch),
|
||||
angle(camera.roll),
|
||||
angle(pose.heading),
|
||||
angle(pose.pitch),
|
||||
angle(pose.roll),
|
||||
].join(',');
|
||||
}
|
||||
|
||||
|
||||
@@ -1,4 +1,6 @@
|
||||
import assert from 'node:assert/strict';
|
||||
import { bindRenderer } from '../render/rendererOf.js';
|
||||
import { fakeSceneFrame } from '../testSupport/fakeCesiumScene.mjs';
|
||||
import test from 'node:test';
|
||||
import {
|
||||
RealtimeViewport,
|
||||
@@ -6,6 +8,14 @@ import {
|
||||
renderFreshPointerFrame,
|
||||
} from './realtimeViewport.js';
|
||||
|
||||
|
||||
/** A viewer over `scene` whose renderer's frame port is the scene's own loop. */
|
||||
function framed(scene) {
|
||||
const viewer = { scene };
|
||||
bindRenderer(viewer, { frame: fakeSceneFrame(viewer) });
|
||||
return viewer;
|
||||
}
|
||||
|
||||
test('crop: a square around the pointer, clamped inside the canvas, in buffer pixels', () => {
|
||||
assert.deepEqual(
|
||||
pointerCropRect({
|
||||
@@ -110,7 +120,7 @@ test('crop: a slow render gets one bounded fresh-frame recovery request', async
|
||||
if (requests === 2) queueMicrotask(() => listener?.());
|
||||
},
|
||||
};
|
||||
assert.equal(await renderFreshPointerFrame({ scene }), true);
|
||||
assert.equal(await renderFreshPointerFrame(framed(scene)), true);
|
||||
assert.equal(requests, 2, 'only the pointer path retries once');
|
||||
assert.equal(listener, null, 'the successful listener is removed');
|
||||
} finally {
|
||||
@@ -129,7 +139,7 @@ test('crop: a hidden document never starts the recovery request', async () => {
|
||||
requests += 1;
|
||||
},
|
||||
};
|
||||
assert.equal(await renderFreshPointerFrame({ scene }), false);
|
||||
assert.equal(await renderFreshPointerFrame(framed(scene)), false);
|
||||
assert.equal(requests, 0);
|
||||
} finally {
|
||||
globalThis.document = originalDocument;
|
||||
|
||||
+18
-13
@@ -1,4 +1,5 @@
|
||||
import * as Cesium from 'cesium';
|
||||
import { pickAt as defaultPickAt } from '../input/dispatcher.js';
|
||||
import { canvasOf, findCamera } from '../render/rendererOf.js';
|
||||
import { resolvePickedContext } from '../data/pickedContext.js';
|
||||
import { cameraPoseKey } from './pointerContext.js';
|
||||
import * as defaultAnnotationResolver from '../annotations/annotationResolver.js';
|
||||
@@ -10,34 +11,38 @@ function pointerRadiusKm(cameraHeightM) {
|
||||
return Math.round(Math.min(400, Math.max(5, heightKm * 0.75)));
|
||||
}
|
||||
|
||||
function cameraHeightM(viewer) {
|
||||
try {
|
||||
return findCamera(viewer)?.pose().height;
|
||||
} catch {
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The Cesium side of point-and-ask: one entity pick and one depth-aware world
|
||||
* The scene side of point-and-ask: one entity pick and one depth-aware world
|
||||
* pick at canvas CSS pixels. Called lazily by the pointer tracker (dwell and
|
||||
* snapshot only), never per mouse move.
|
||||
* @param {object} options
|
||||
* @param {object} options.viewer Cesium viewer.
|
||||
* @param {object} options.viewer The scene object.
|
||||
* @param {object} [options.dataManager] Layer lifecycle.
|
||||
* @param {Function} [options.pickWorldFromScreen] Normalized-pixel world pick.
|
||||
* @param {Function} [options.pickAt] Entity pick at canvas CSS pixels.
|
||||
* @returns {(x: number, y: number) => {entity: object|null, ground: object|null, radiusKm: number}|null}
|
||||
*/
|
||||
export function createPointerPicker({
|
||||
viewer,
|
||||
dataManager = null,
|
||||
pickWorldFromScreen = defaultAnnotationResolver.pickWorldFromScreen,
|
||||
pickAt = defaultPickAt,
|
||||
}) {
|
||||
return function pickPointer(x, y) {
|
||||
const scene = viewer?.scene;
|
||||
const canvas = scene?.canvas;
|
||||
if (!scene || !canvas) return null;
|
||||
const canvas = canvasOf(viewer);
|
||||
if (!canvas) return null;
|
||||
const width = canvas.clientWidth || canvas.width || 0;
|
||||
const height = canvas.clientHeight || canvas.height || 0;
|
||||
if (!width || !height) return null;
|
||||
let picked = null;
|
||||
try {
|
||||
picked = scene.pick(new Cesium.Cartesian2(x, y));
|
||||
} catch {
|
||||
picked = null;
|
||||
}
|
||||
const picked = pickAt(viewer, x, y);
|
||||
const entity = resolvePickedContext(picked, { dataManager });
|
||||
let ground = null;
|
||||
try {
|
||||
@@ -54,7 +59,7 @@ export function createPointerPicker({
|
||||
return {
|
||||
entity,
|
||||
ground,
|
||||
radiusKm: pointerRadiusKm(viewer.camera?.positionCartographic?.height),
|
||||
radiusKm: pointerRadiusKm(cameraHeightM(viewer)),
|
||||
cameraKey: cameraPoseKey(viewer),
|
||||
};
|
||||
};
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
// Imports intentionally target the candidate, never the immutable reference.
|
||||
import { bindFakeCesiumCamera } from '../testSupport/fakeCameraPort.mjs';
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import {
|
||||
@@ -177,22 +178,20 @@ function compositionFixture(
|
||||
const canvas = new EventTarget();
|
||||
Object.assign(canvas, { clientWidth: 800, clientHeight: 600 });
|
||||
const position = { x: 6379137, y: 0, z: 0 };
|
||||
const viewer = {
|
||||
const viewer = bindFakeCesiumCamera({
|
||||
clock: { onTick: { addEventListener: () => () => {} } },
|
||||
camera: {
|
||||
positionWC: position,
|
||||
positionCartographic: { height: state.height },
|
||||
moveEnd: { addEventListener() {} },
|
||||
cancelFlight() {},
|
||||
zoomIn(metres) {
|
||||
position.x -= metres;
|
||||
state.height -= metres;
|
||||
this.positionCartographic.height = state.height;
|
||||
state.zooms++;
|
||||
},
|
||||
zoomOut(metres) {
|
||||
position.x += metres;
|
||||
state.height += metres;
|
||||
// Looking straight down at the surface along -x.
|
||||
directionWC: { x: -1, y: 0, z: 0 },
|
||||
upWC: { x: 0, y: 0, z: 1 },
|
||||
rightWC: { x: 0, y: 1, z: 0 },
|
||||
setView({ destination }) {
|
||||
state.height -= position.x - destination.x;
|
||||
position.x = destination.x;
|
||||
this.positionCartographic.height = state.height;
|
||||
state.zooms++;
|
||||
},
|
||||
@@ -203,7 +202,7 @@ function compositionFixture(
|
||||
state.renders++;
|
||||
},
|
||||
},
|
||||
};
|
||||
});
|
||||
const dataManager = { layers: new Map() };
|
||||
pointer = createPointerTracker({ element: null, now: () => 1000 });
|
||||
const referents = createReferentRegistry();
|
||||
|
||||
+110
-47
@@ -3,6 +3,7 @@ import {
|
||||
hasStructuredViewIdentity,
|
||||
} from './realtimeProtocol.js';
|
||||
import { cameraPoseKey } from './pointerContext.js';
|
||||
import { canvasOf, findFrame, rendererOf } from '../render/rendererOf.js';
|
||||
|
||||
/** The live viewer's camera pose identity (Cesium-free read). */
|
||||
function readViewerCameraKey() {
|
||||
@@ -19,32 +20,28 @@ const VIEWPORT_MAX_ENCODED_BYTES = 200 * 1024;
|
||||
|
||||
export async function captureViewportImage() {
|
||||
const viewer = window.__godsEyeView?.viewer;
|
||||
const source =
|
||||
viewer?.scene?.canvas ||
|
||||
document.querySelector('#cesiumContainer .cesium-widget canvas');
|
||||
const source = canvasOf(viewer);
|
||||
if (!source || !source.width || !source.height) return null;
|
||||
// No fresh frame (hidden, or the bounded render wait timed out) → no
|
||||
// capture. The caller labels this image "Current"; a stale preserved
|
||||
// frame would feed the model old entities as current context. (perf
|
||||
// wave 2 fix)
|
||||
const fresh = await renderFreshCesiumFrame(viewer);
|
||||
if (!fresh) return null;
|
||||
|
||||
// Clamp BOTH dimensions by a total-pixel budget so tall portrait windows are
|
||||
// downscaled too (the old width-only clamp let them through — M13).
|
||||
const { width, height } = computeDownscale(
|
||||
const { width } = computeDownscale(
|
||||
source.width,
|
||||
source.height,
|
||||
VIEWPORT_MAX_PIXELS,
|
||||
);
|
||||
const canvas = document.createElement('canvas');
|
||||
canvas.width = width;
|
||||
canvas.height = height;
|
||||
const ctx = canvas.getContext('2d');
|
||||
// No fresh frame (hidden, or the bounded render wait timed out) → no
|
||||
// capture. The caller labels this image "Current"; a stale preserved
|
||||
// frame would feed the model old entities as current context. (perf
|
||||
// wave 2 fix)
|
||||
const pixels = await readFreshFrame(viewer, renderFreshCesiumFrame, {
|
||||
scale: width / (source.clientWidth || source.width),
|
||||
});
|
||||
if (!pixels) return null;
|
||||
const ctx = canvasWith(pixels);
|
||||
if (!ctx) return null;
|
||||
const canvas = ctx.canvas;
|
||||
try {
|
||||
ctx.drawImage(source, 0, 0, width, height);
|
||||
if (isNearlyBlackFrame(ctx, width, height)) {
|
||||
if (isNearlyBlackFrame(ctx, canvas.width, canvas.height)) {
|
||||
console.warn('[GEV Voice] Skipped black Cesium viewport capture');
|
||||
return null;
|
||||
}
|
||||
@@ -165,38 +162,39 @@ export function pointerCropRect({
|
||||
* @returns {Promise<{dataUrl: string, rect: object}|null>} JPEG data URL and
|
||||
* the crop's normalized bounds in the full canvas, or null.
|
||||
*/
|
||||
async function capturePointerCrop(screenPx) {
|
||||
export async function capturePointerCrop(screenPx) {
|
||||
const viewer = window.__godsEyeView?.viewer;
|
||||
const source = viewer?.scene?.canvas;
|
||||
const source = canvasOf(viewer);
|
||||
if (!source?.width || !source?.height || !screenPx) return null;
|
||||
const fresh = await renderFreshPointerFrame(viewer);
|
||||
if (!fresh) return null;
|
||||
const cssWidth = source.clientWidth || source.width;
|
||||
const cssHeight = source.clientHeight || source.height;
|
||||
const rect = pointerCropRect({
|
||||
x: screenPx.x,
|
||||
y: screenPx.y,
|
||||
cssWidth: source.clientWidth || source.width,
|
||||
cssHeight: source.clientHeight || source.height,
|
||||
cssWidth,
|
||||
cssHeight,
|
||||
pixelWidth: source.width,
|
||||
pixelHeight: source.height,
|
||||
});
|
||||
if (!rect) return null;
|
||||
const canvas = document.createElement('canvas');
|
||||
canvas.width = rect.output;
|
||||
canvas.height = rect.output;
|
||||
const ctx = canvas.getContext('2d');
|
||||
// The crop in CSS pixels, as the renderer reads it.
|
||||
const toCssX = cssWidth / source.width;
|
||||
const toCssY = cssHeight / source.height;
|
||||
const crop = {
|
||||
x: rect.sx * toCssX,
|
||||
y: rect.sy * toCssY,
|
||||
width: rect.sw * toCssX,
|
||||
height: rect.sh * toCssY,
|
||||
};
|
||||
const pixels = await readFreshFrame(viewer, renderFreshPointerFrame, {
|
||||
crop,
|
||||
scale: rect.output / crop.width,
|
||||
});
|
||||
if (!pixels) return null;
|
||||
const ctx = squareOf(canvasWith(pixels), rect.output);
|
||||
if (!ctx) return null;
|
||||
const canvas = ctx.canvas;
|
||||
try {
|
||||
ctx.drawImage(
|
||||
source,
|
||||
rect.sx,
|
||||
rect.sy,
|
||||
rect.sw,
|
||||
rect.sh,
|
||||
0,
|
||||
0,
|
||||
rect.output,
|
||||
rect.output,
|
||||
);
|
||||
if (isNearlyBlackFrame(ctx, rect.output, rect.output)) return null;
|
||||
ctx.strokeStyle = 'rgba(0, 230, 255, 0.95)';
|
||||
ctx.lineWidth = 2;
|
||||
@@ -219,14 +217,70 @@ async function capturePointerCrop(screenPx) {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The renderer's pixels of a fresh frame (`readPixels` with `options`), read
|
||||
* in the frame `render` waits for, so they are the frame just drawn on any
|
||||
* renderer; null with no fresh frame, or no renderer to read.
|
||||
* @param {object} viewer
|
||||
* @param {(viewer: object, onFrame: () => void) => Promise<boolean>} render
|
||||
* @param {{crop?: object, scale?: number}} options
|
||||
* @returns {Promise<ImageData|null>}
|
||||
*/
|
||||
async function readFreshFrame(viewer, render, options) {
|
||||
const renderer = rendererOf(viewer);
|
||||
if (typeof renderer?.readPixels !== 'function') return null;
|
||||
let pixels = null;
|
||||
const fresh = await render(viewer, () => {
|
||||
pixels = renderer.readPixels(options);
|
||||
});
|
||||
return fresh ? pixels : null;
|
||||
}
|
||||
|
||||
/** A 2D canvas holding `pixels`, or null where none can be made. */
|
||||
function canvasWith(pixels) {
|
||||
const canvas = document.createElement('canvas');
|
||||
canvas.width = pixels.width;
|
||||
canvas.height = pixels.height;
|
||||
const ctx = canvas.getContext('2d');
|
||||
if (!ctx) return null;
|
||||
try {
|
||||
ctx.putImageData(
|
||||
typeof ImageData === 'function' && !(pixels instanceof ImageData)
|
||||
? new ImageData(pixels.data, pixels.width, pixels.height)
|
||||
: pixels,
|
||||
0,
|
||||
0,
|
||||
);
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
return ctx;
|
||||
}
|
||||
|
||||
/**
|
||||
* `ctx`'s image as a `side` px square: the crop is read at one scale, so a
|
||||
* canvas stretched unevenly reads it a pixel or so off square.
|
||||
*/
|
||||
function squareOf(ctx, side) {
|
||||
if (!ctx || (ctx.canvas.width === side && ctx.canvas.height === side))
|
||||
return ctx;
|
||||
const canvas = document.createElement('canvas');
|
||||
canvas.width = side;
|
||||
canvas.height = side;
|
||||
const square = canvas.getContext('2d');
|
||||
if (!square) return null;
|
||||
square.drawImage(ctx.canvas, 0, 0, side, side);
|
||||
return square;
|
||||
}
|
||||
|
||||
/**
|
||||
* Pointer crops get one bounded recovery request for a slow render loop.
|
||||
* Full-viewport captures intentionally keep their single 400 ms attempt.
|
||||
*/
|
||||
export async function renderFreshPointerFrame(viewer) {
|
||||
if (await renderFreshCesiumFrame(viewer)) return true;
|
||||
export async function renderFreshPointerFrame(viewer, onFrame) {
|
||||
if (await renderFreshCesiumFrame(viewer, onFrame)) return true;
|
||||
if (typeof document !== 'undefined' && document.hidden) return false;
|
||||
return renderFreshCesiumFrame(viewer);
|
||||
return renderFreshCesiumFrame(viewer, onFrame);
|
||||
}
|
||||
|
||||
// Scale (w, h) down so w*h <= maxPixels while preserving aspect ratio. Never
|
||||
@@ -259,15 +313,18 @@ export function estimateDataUrlBytes(dataUrl) {
|
||||
}
|
||||
|
||||
/**
|
||||
* Ensure the canvas holds a CURRENT frame before capture.
|
||||
* Ensure the canvas holds a CURRENT frame before capture. `onFrame` runs
|
||||
* as that frame is drawn (its `postRender`), where a read sees it.
|
||||
* @param {object} viewer
|
||||
* @param {() => void} [onFrame]
|
||||
* @returns {Promise<boolean>} true only when a fresh frame was presented —
|
||||
* false while hidden (render loop suspended; a capture would be stale) or
|
||||
* when the bounded wait timed out. Callers must not label a non-fresh
|
||||
* canvas as current. (perf wave 2)
|
||||
*/
|
||||
export async function renderFreshCesiumFrame(viewer) {
|
||||
const scene = viewer?.scene;
|
||||
if (!scene) return false;
|
||||
export async function renderFreshCesiumFrame(viewer, onFrame) {
|
||||
const frame = findFrame(viewer);
|
||||
if (!frame) return false;
|
||||
// While the document is hidden the render loop is suspended — don't
|
||||
// secretly restart rendering for an optional screenshot, and don't pass
|
||||
// the stale preserved frame off as current.
|
||||
@@ -277,8 +334,14 @@ export async function renderFreshCesiumFrame(viewer) {
|
||||
// necessarily draw — request a frame and await its postRender (bounded),
|
||||
// which also covers the just-became-visible race.
|
||||
const rendered = new Promise((resolve) => {
|
||||
const remove = scene.postRender.addEventListener(() => {
|
||||
const remove = frame.on('postRender', () => {
|
||||
remove();
|
||||
try {
|
||||
onFrame?.();
|
||||
} catch {
|
||||
resolve(false);
|
||||
return;
|
||||
}
|
||||
resolve(true);
|
||||
});
|
||||
setTimeout(() => {
|
||||
@@ -286,7 +349,7 @@ export async function renderFreshCesiumFrame(viewer) {
|
||||
resolve(false);
|
||||
}, 400);
|
||||
});
|
||||
scene.requestRender?.();
|
||||
frame.requestRender('voice-capture');
|
||||
const fresh = await rendered;
|
||||
// A tab switch during the bounded wait invalidates freshness.
|
||||
if (typeof document !== 'undefined' && document.hidden) return false;
|
||||
|
||||
@@ -0,0 +1,134 @@
|
||||
import assert from 'node:assert/strict';
|
||||
import test from 'node:test';
|
||||
import { bindRenderer } from '../render/rendererOf.js';
|
||||
import {
|
||||
captureViewportImage,
|
||||
capturePointerCrop,
|
||||
} from './realtimeViewport.js';
|
||||
|
||||
/**
|
||||
* A page with a bound renderer whose canvas must never be read directly:
|
||||
* its pixels come only through `readPixels`, as the frame it just drew.
|
||||
*/
|
||||
function page({ cssWidth = 800, cssHeight = 600, dpr = 2, dprY = dpr } = {}) {
|
||||
const canvas = {
|
||||
width: cssWidth * dpr,
|
||||
height: cssHeight * dprY,
|
||||
clientWidth: cssWidth,
|
||||
clientHeight: cssHeight,
|
||||
};
|
||||
let fire = null;
|
||||
const reads = [];
|
||||
let drawn = false;
|
||||
const renderer = {
|
||||
canvas,
|
||||
frame: {
|
||||
on(phase, cb) {
|
||||
if (phase !== 'postRender') return () => {};
|
||||
fire = cb;
|
||||
return () => (fire = null);
|
||||
},
|
||||
requestRender() {
|
||||
queueMicrotask(() => {
|
||||
drawn = true;
|
||||
fire?.();
|
||||
drawn = false;
|
||||
});
|
||||
},
|
||||
},
|
||||
readPixels(options) {
|
||||
reads.push({ ...options, duringFrame: drawn });
|
||||
const width = Math.round(
|
||||
(options.crop?.width ?? cssWidth) * options.scale,
|
||||
);
|
||||
const height = Math.round(
|
||||
(options.crop?.height ?? cssHeight) * options.scale,
|
||||
);
|
||||
return {
|
||||
width,
|
||||
height,
|
||||
data: new Uint8ClampedArray(width * height * 4).fill(200),
|
||||
};
|
||||
},
|
||||
};
|
||||
const viewer = {};
|
||||
bindRenderer(viewer, renderer);
|
||||
const put = [];
|
||||
const encoded = [];
|
||||
const document = {
|
||||
hidden: false,
|
||||
createElement() {
|
||||
const out = {
|
||||
width: 0,
|
||||
height: 0,
|
||||
getContext: () => ctx,
|
||||
toDataURL: (type) => {
|
||||
encoded.push([out.width, out.height]);
|
||||
return `data:${type};base64,AAAA`;
|
||||
},
|
||||
};
|
||||
const ctx = {
|
||||
canvas: out,
|
||||
putImageData: (image, x, y) =>
|
||||
put.push([image.width, image.height, x, y]),
|
||||
drawImage(source) {
|
||||
assert.notEqual(
|
||||
source,
|
||||
canvas,
|
||||
'the renderer’s canvas is never drawn',
|
||||
);
|
||||
},
|
||||
getImageData: (x, y, w, h) => ({
|
||||
data: new Uint8ClampedArray(w * h * 4).fill(200),
|
||||
}),
|
||||
beginPath() {},
|
||||
arc() {},
|
||||
stroke() {},
|
||||
};
|
||||
return out;
|
||||
},
|
||||
querySelector: () => canvas,
|
||||
};
|
||||
return { viewer, reads, put, encoded, document };
|
||||
}
|
||||
|
||||
function withPage(p, fn) {
|
||||
const saved = [globalThis.window, globalThis.document];
|
||||
globalThis.window = { __godsEyeView: { viewer: p.viewer } };
|
||||
globalThis.document = p.document;
|
||||
return Promise.resolve(fn()).finally(() => {
|
||||
[globalThis.window, globalThis.document] = saved;
|
||||
});
|
||||
}
|
||||
|
||||
test('the viewport image is the renderer’s readPixels of the fresh frame, as it is drawn', async () => {
|
||||
const p = page();
|
||||
const image = await withPage(p, () => captureViewportImage());
|
||||
assert.match(image, /^data:image\/jpeg;base64,/);
|
||||
assert.equal(p.reads.length, 1);
|
||||
const [read] = p.reads;
|
||||
assert.equal(read.duringFrame, true, 'read in the frame it waited for');
|
||||
assert.equal(read.crop, undefined, 'the whole canvas');
|
||||
// 1600 × 1200 drawing-buffer pixels, cut to the 1200 × 900 budget.
|
||||
assert.deepEqual(p.put, [[1200, 900, 0, 0]]);
|
||||
});
|
||||
|
||||
test('the pointer crop is the renderer’s readPixels around the pointer, as the frame is drawn', async () => {
|
||||
const p = page();
|
||||
const crop = await withPage(p, () => capturePointerCrop({ x: 400, y: 300 }));
|
||||
assert.ok(crop?.dataUrl);
|
||||
assert.deepEqual(crop.rect, { x: 0.18, y: 44 / 600, w: 0.64, h: 512 / 600 });
|
||||
const [read] = p.reads;
|
||||
assert.equal(read.duringFrame, true);
|
||||
assert.deepEqual(read.crop, { x: 144, y: 44, width: 512, height: 512 });
|
||||
assert.deepEqual(p.put, [[512, 512, 0, 0]]);
|
||||
});
|
||||
|
||||
test('the pointer crop is its full square even where the canvas is stretched unevenly', async () => {
|
||||
// Drawing-buffer pixels three to a CSS pixel across and 0.3 down: the
|
||||
// crop read back is a row taller than it is wide.
|
||||
const p = page({ dpr: 3, dprY: 0.3 });
|
||||
const crop = await withPage(p, () => capturePointerCrop({ x: 400, y: 300 }));
|
||||
assert.ok(crop?.dataUrl);
|
||||
assert.deepEqual(p.encoded, [[512, 512]], 'a 512 px square');
|
||||
});
|
||||
@@ -13,6 +13,7 @@ import {
|
||||
fakeRenderer,
|
||||
fakeThumbnails,
|
||||
} from '../layers/recentImagery/testDoubles.mjs';
|
||||
import { bindFakeCesiumCamera } from '../testSupport/fakeCameraPort.mjs';
|
||||
|
||||
globalThis.window = globalThis.window || {
|
||||
clearTimeout,
|
||||
@@ -148,10 +149,12 @@ export function harness({
|
||||
const enabled = new Set(on);
|
||||
const viewer = {
|
||||
clock: { onTick: { addEventListener: () => () => {} } },
|
||||
canvas: { addEventListener() {}, removeEventListener() {} },
|
||||
scene: { canvas: { addEventListener() {}, removeEventListener() {} } },
|
||||
camera: {
|
||||
moveEnd: { addEventListener() {} },
|
||||
// The view: a box over Kathmandu, in radians.
|
||||
// The view: a box over Kathmandu, in radians, as the fake Cesium
|
||||
// camera gives it; the camera port answers in degrees.
|
||||
computeViewRectangle: () => ({
|
||||
west: (85.2 * Math.PI) / 180,
|
||||
south: (27.6 * Math.PI) / 180,
|
||||
@@ -165,6 +168,8 @@ export function harness({
|
||||
},
|
||||
},
|
||||
};
|
||||
// The actions read the view through the camera port.
|
||||
bindFakeCesiumCamera(viewer);
|
||||
const referents = createReferentRegistry();
|
||||
let snapshot = pointer;
|
||||
const osmCalls = [];
|
||||
|
||||
Reference in new issue
Block a user