mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-20 18:22:25 +00:00
Merge branch 'main' into feat/alpr-model-specs
This commit is contained in:
164 files changed
+8418
-1082
No files matched your search
@@ -229,7 +229,7 @@ export function createCards({ state: layerState, services, parts, source }) {
|
||||
let rank = 0;
|
||||
const push = (id, { pinned = false, active = false } = {}) => {
|
||||
const record = layerState._recordById.get(id);
|
||||
if (!record?.position) return;
|
||||
if (!record?.position || (!active && record.viewGrouped)) return;
|
||||
entries.push(
|
||||
createCctvThumbnailOverlayEntry({
|
||||
id,
|
||||
|
||||
Vendored
+2
-1
@@ -219,7 +219,8 @@ export function createControls({ state: layerState, services, parts, source }) {
|
||||
for (let i = start; i < records.length; i += stride) {
|
||||
const camera = records[i].camera;
|
||||
objects.push({
|
||||
position: records[i].position,
|
||||
// A camera sharing its mount is drawn beside its mates.
|
||||
position: records[i].spreadPosition ?? records[i].position,
|
||||
sourceId: camera.id,
|
||||
// Short semantic code where the id is opaque (see cameraDisplayCode).
|
||||
id: `CAM-${camera.code || camera.id}`,
|
||||
|
||||
@@ -0,0 +1,430 @@
|
||||
import {
|
||||
cellCenter,
|
||||
cellLonLat,
|
||||
formatCameraCount,
|
||||
mergeCountCells,
|
||||
withoutLoneCameras,
|
||||
} from '../../data/cctvCellCounts.js';
|
||||
import { WORLD_OVERLAY_STYLE } from '../../overlays/worldOverlayTokens.js';
|
||||
import {
|
||||
CAMERA_GREEN,
|
||||
COUNT_CAMERA_ICON,
|
||||
CAMERA_ICON_PX,
|
||||
COUNT_MERGE_GAP_PX,
|
||||
} from './policy.js';
|
||||
import { liftedForHorizon } from '../../geo/horizon.js';
|
||||
|
||||
// Diameter at one camera before applying the size limits, in CSS pixels.
|
||||
const COUNT_BASE_PX = 38;
|
||||
|
||||
// Extra diameter for each tenfold increase in camera count.
|
||||
const COUNT_PX_PER_DECADE = 5;
|
||||
|
||||
// Minimum height of a count marker in CSS pixels.
|
||||
const COUNT_MIN_HEIGHT_PX = 40;
|
||||
|
||||
// Maximum height of a count marker in CSS pixels.
|
||||
const COUNT_MAX_HEIGHT_PX = 58;
|
||||
|
||||
// Clear fill between the count and the inside of the ring, in CSS pixels.
|
||||
const COUNT_TEXT_PADDING_PX = 6;
|
||||
|
||||
// Height of the camera glyph in the smallest and the largest marker.
|
||||
const COUNT_GLYPH_MIN_PX = 7.5;
|
||||
const COUNT_GLYPH_MAX_PX = 10;
|
||||
|
||||
// Clear fill above the glyph in the smallest and the largest marker.
|
||||
const COUNT_GLYPH_TOP_MIN_PX = 3;
|
||||
const COUNT_GLYPH_TOP_MAX_PX = 4;
|
||||
|
||||
// Clear fill between the glyph's top corners and the inside of the ring.
|
||||
const COUNT_GLYPH_PADDING_PX = 2;
|
||||
|
||||
// The middle of the digits sits this share of the inner radius below the
|
||||
// marker's centre, which leaves the glyph clear of the count.
|
||||
const COUNT_LABEL_DROP = 0.2;
|
||||
|
||||
// Merge passes per view. A merged centre and wider label can reach a further
|
||||
// marker. The cap bounds work on motion ticks.
|
||||
const COUNT_MERGE_PASSES = 3;
|
||||
const FONT = WORLD_OVERLAY_STYLE.fontTitle;
|
||||
// Reserve the camera's landscape slot even while the map sprite is loading.
|
||||
const GLYPH_ASPECT = 1.5;
|
||||
const RING_PX = 2;
|
||||
const RIM_PX = 1;
|
||||
const STROKE_INSET = RIM_PX + RING_PX / 2;
|
||||
// Painted bounds of the camera art, scaled from its viewBox to source pixels.
|
||||
const GLYPH_SOURCE = [3.4, 13.4, 28.1, 19.5].map((v) => (v * 48) / 36);
|
||||
const GLYPH_SOURCE_ASPECT = 28.1 / 19.5;
|
||||
|
||||
/** Merged camera groups and their last painted hit rectangles in CSS pixels. */
|
||||
export function createCountMarkers(
|
||||
registerPaintLane,
|
||||
id,
|
||||
refreshView,
|
||||
keyholeAlpha,
|
||||
) {
|
||||
let hardUi = null;
|
||||
let sprite = null;
|
||||
let spriteReady = false;
|
||||
const markers = [];
|
||||
const hits = [];
|
||||
const textMetrics = new Map();
|
||||
const fonts = globalThis.document?.fonts;
|
||||
let measureCtx;
|
||||
let hitCount = 0;
|
||||
const lane = registerPaintLane?.('ambient-label', paint, {
|
||||
id,
|
||||
active: false,
|
||||
target: 'shared',
|
||||
});
|
||||
function loadSprite() {
|
||||
if (sprite || typeof Image === 'undefined') return;
|
||||
sprite = new Image();
|
||||
sprite.onload = () => {
|
||||
spriteReady = true;
|
||||
if (markers.length) lane?.requestPaint();
|
||||
};
|
||||
sprite.src = COUNT_CAMERA_ICON;
|
||||
}
|
||||
fonts?.addEventListener?.('loadingdone', fontsLoaded);
|
||||
|
||||
/** Font changes can widen a pill enough to merge it with its neighbor. */
|
||||
function fontsLoaded() {
|
||||
textMetrics.clear();
|
||||
if (!markers.length) return;
|
||||
refreshView();
|
||||
lane?.requestPaint();
|
||||
}
|
||||
|
||||
/** Seat the glyph under the top of the ring and the count just below centre. */
|
||||
function sizeFor(count) {
|
||||
const text = formatCameraCount(count);
|
||||
let metrics = textMetrics.get(text);
|
||||
if (!metrics) {
|
||||
measureCtx ??= globalThis.document
|
||||
.createElement('canvas')
|
||||
.getContext('2d');
|
||||
measureCtx.font = FONT;
|
||||
measureCtx.textBaseline = 'middle';
|
||||
metrics = measureCtx.measureText(text);
|
||||
textMetrics.set(text, metrics);
|
||||
}
|
||||
const diameter = COUNT_BASE_PX + COUNT_PX_PER_DECADE * Math.log10(count);
|
||||
const clamped = Math.max(
|
||||
COUNT_MIN_HEIGHT_PX,
|
||||
Math.min(COUNT_MAX_HEIGHT_PX, diameter),
|
||||
);
|
||||
const height = 2 * Math.round(clamped / 2);
|
||||
const grown =
|
||||
(height - COUNT_MIN_HEIGHT_PX) /
|
||||
(COUNT_MAX_HEIGHT_PX - COUNT_MIN_HEIGHT_PX);
|
||||
const glyphHeight =
|
||||
COUNT_GLYPH_MIN_PX + (COUNT_GLYPH_MAX_PX - COUNT_GLYPH_MIN_PX) * grown;
|
||||
const radius = height / 2 - RIM_PX - RING_PX;
|
||||
const glyphTop =
|
||||
COUNT_GLYPH_TOP_MIN_PX +
|
||||
(COUNT_GLYPH_TOP_MAX_PX - COUNT_GLYPH_TOP_MIN_PX) * grown -
|
||||
radius;
|
||||
const ascent = metrics.actualBoundingBoxAscent;
|
||||
const descent = metrics.actualBoundingBoxDescent;
|
||||
const labelY = COUNT_LABEL_DROP * radius + (ascent - descent) / 2;
|
||||
// Each row must clear the ring at the edge where the circle is narrowest.
|
||||
const chordAt = (y) => 2 * Math.sqrt(Math.max(0, radius ** 2 - y ** 2));
|
||||
const extra = Math.max(
|
||||
0,
|
||||
Math.ceil(
|
||||
Math.max(
|
||||
metrics.width + 2 * COUNT_TEXT_PADDING_PX - chordAt(labelY + descent),
|
||||
glyphHeight * GLYPH_ASPECT +
|
||||
2 * COUNT_GLYPH_PADDING_PX -
|
||||
chordAt(glyphTop),
|
||||
),
|
||||
),
|
||||
);
|
||||
return {
|
||||
text,
|
||||
width: height + extra,
|
||||
height,
|
||||
glyphHeight,
|
||||
glyphBottom: glyphTop + glyphHeight,
|
||||
labelY,
|
||||
};
|
||||
}
|
||||
|
||||
/** Keep covered icons in the restored count if its new label clears the HUD. */
|
||||
function retainCoveredCameras(group, core, project) {
|
||||
const anchor = cellCenter(core);
|
||||
const at = project(anchor);
|
||||
if (!at) return core;
|
||||
const { x, y } = at; // The projector reuses its result.
|
||||
const size = sizeFor(core.count);
|
||||
const halfSegment = (size.width - size.height) / 2;
|
||||
const covered = group.lone.filter((lone) => {
|
||||
const p = project(cellCenter(lone));
|
||||
if (!p) return false;
|
||||
// The pill outline that merging measures, without its gap.
|
||||
const dx = Math.max(
|
||||
0,
|
||||
Math.abs(p.x + (lone.offsetPx ?? 0) - x) - halfSegment,
|
||||
);
|
||||
const reach = (size.height + (lone.iconPx ?? CAMERA_ICON_PX)) / 2;
|
||||
return dx * dx + (p.y - y) ** 2 < reach * reach;
|
||||
});
|
||||
if (!covered.length) return core;
|
||||
const { width, height } = sizeFor(core.count + covered.length);
|
||||
if (hardUi({ x: x - width / 2, y: y - height / 2, w: width, h: height }))
|
||||
return core;
|
||||
const held = withoutLoneCameras(group, covered);
|
||||
held.anchor = anchor;
|
||||
held.groundM = core.groundM;
|
||||
for (const lone of covered) lone.absorbed = true;
|
||||
return held;
|
||||
}
|
||||
|
||||
/**
|
||||
* Reuse marker slots in ground-key order, and invalidate only changed frames.
|
||||
* `groundHeight(lon, lat)` gives the drawn terrain in metres, or a non-finite
|
||||
* value where it has not loaded. A count stands on that ground when available
|
||||
* and otherwise uses its cameras' mean mount height.
|
||||
*/
|
||||
function update(cells, project, groundHeight = null) {
|
||||
// Lone cameras take part so that one beside a count joins it.
|
||||
let visible = cells.slice().sort((a, b) => a.key.localeCompare(b.key));
|
||||
const footprint = (count, cell) => {
|
||||
if (count > 1) return sizeFor(count);
|
||||
const px = cell.iconPx ?? CAMERA_ICON_PX;
|
||||
return { width: px, height: px };
|
||||
};
|
||||
/** A lone camera keeps its icon's own position; a count goes to ground. */
|
||||
const ground = (list) => {
|
||||
if (!groundHeight) return;
|
||||
for (const cell of list) {
|
||||
if (cell.count === 1 || cell.groundM !== undefined) continue;
|
||||
const { lon, lat } = cellLonLat(cell);
|
||||
const height = groundHeight(lon, lat);
|
||||
cell.groundM = Number.isFinite(height) ? Math.round(height) : null;
|
||||
}
|
||||
};
|
||||
for (
|
||||
let pass = 0;
|
||||
pass < COUNT_MERGE_PASSES &&
|
||||
visible.length > 1 &&
|
||||
visible.some((cell) => cell.count > 1);
|
||||
pass++
|
||||
) {
|
||||
ground(visible);
|
||||
const merged = mergeCountCells(
|
||||
visible,
|
||||
project,
|
||||
footprint,
|
||||
COUNT_MERGE_GAP_PX,
|
||||
);
|
||||
if (merged.length === visible.length) break;
|
||||
visible = merged;
|
||||
}
|
||||
// A lone camera that is no longer its own entry now counts in a marker.
|
||||
const apart = new Set(visible);
|
||||
for (const cell of cells)
|
||||
if (cell.count === 1) cell.absorbed = !apart.has(cell);
|
||||
visible = visible.filter((cell) => cell.count > 1);
|
||||
ground(visible);
|
||||
let changed = visible.length !== markers.length;
|
||||
for (let i = 0; i < visible.length; i++) {
|
||||
let cell = visible[i];
|
||||
// If the merged count is under the HUD, restore the count and its lone icons.
|
||||
if (hardUi && cell.lone?.length) {
|
||||
const at = project(cellCenter(cell));
|
||||
const { width, height } = sizeFor(cell.count);
|
||||
const rect = at && {
|
||||
x: at.x - width / 2,
|
||||
y: at.y - height / 2,
|
||||
w: width,
|
||||
h: height,
|
||||
};
|
||||
if (rect && hardUi(rect)) {
|
||||
for (const lone of cell.lone) lone.absorbed = false;
|
||||
const core = withoutLoneCameras(cell);
|
||||
if (core) {
|
||||
ground([core]);
|
||||
cell = retainCoveredCameras(cell, core, project);
|
||||
cell.releasedAt = rect;
|
||||
}
|
||||
}
|
||||
}
|
||||
const marker = (markers[i] ??= { focus: 1 });
|
||||
const last = marker.cell;
|
||||
const size = sizeFor(cell.count);
|
||||
if (
|
||||
!last ||
|
||||
last.count !== cell.count ||
|
||||
last.latSum !== cell.latSum ||
|
||||
last.lonSum !== cell.lonSum ||
|
||||
last.heightSum !== cell.heightSum ||
|
||||
last.groundM !== cell.groundM ||
|
||||
last.anchor?.x !== cell.anchor?.x ||
|
||||
last.anchor?.y !== cell.anchor?.y ||
|
||||
last.anchor?.z !== cell.anchor?.z
|
||||
) {
|
||||
marker.pos = cell.anchor ?? cellCenter(cell);
|
||||
marker.cullPos = liftedForHorizon(marker.pos);
|
||||
marker.hudHidden = undefined;
|
||||
changed = true;
|
||||
}
|
||||
changed ||=
|
||||
size.text !== marker.text ||
|
||||
size.width !== marker.width ||
|
||||
size.glyphBottom !== marker.glyphBottom ||
|
||||
size.labelY !== marker.labelY;
|
||||
marker.cell = cell;
|
||||
Object.assign(marker, size);
|
||||
// Paint never grows the hit buffer, even when a pan reveals every group.
|
||||
hits[i] ??= {};
|
||||
}
|
||||
markers.length = visible.length;
|
||||
if (markers.length) loadSprite();
|
||||
// Keep the last frame pickable until the host clears its pixels.
|
||||
lane?.setActive(markers.length > 0 || hitCount > 0);
|
||||
if (changed) lane?.requestPaint();
|
||||
}
|
||||
|
||||
/** Draw at device density using the host's CSS-pixel transform and projection. */
|
||||
function paint(frame) {
|
||||
hardUi = frame.overlapsHardUi ?? hardUi;
|
||||
if (!markers.length) {
|
||||
// Deactivating invalidates the host, so finish the shared frame first.
|
||||
if (hitCount) queueMicrotask(deactivateIfEmpty);
|
||||
hitCount = 0;
|
||||
return;
|
||||
}
|
||||
hitCount = 0;
|
||||
const { ctx, occluder, viewProjectionMatrix: m } = frame;
|
||||
let refresh = false;
|
||||
ctx.save();
|
||||
try {
|
||||
ctx.font = FONT;
|
||||
ctx.textAlign = 'center';
|
||||
ctx.textBaseline = 'middle';
|
||||
for (let i = 0; i < markers.length; i++) {
|
||||
const marker = markers[i];
|
||||
// The core can stay visible while the HUD uncovers the merged count.
|
||||
if (marker.cell.releasedAt) refresh ||= !hardUi(marker.cell.releasedAt);
|
||||
const { height } = marker;
|
||||
const { x: px, y: py, z: pz } = marker.pos;
|
||||
const w = m[3] * px + m[7] * py + m[11] * pz + m[15];
|
||||
if (!(w > 0) || (occluder && !occluder.isPointVisible(marker.cullPos)))
|
||||
continue;
|
||||
const x =
|
||||
(0.5 + (0.5 * (m[0] * px + m[4] * py + m[8] * pz + m[12])) / w) *
|
||||
frame.width;
|
||||
const y =
|
||||
(0.5 - (0.5 * (m[1] * px + m[5] * py + m[9] * pz + m[13])) / w) *
|
||||
frame.height;
|
||||
const rect = hits[hitCount];
|
||||
rect.x = x - marker.width / 2;
|
||||
rect.y = y - height / 2;
|
||||
rect.w = marker.width;
|
||||
rect.h = height;
|
||||
if (
|
||||
rect.x >= frame.width ||
|
||||
rect.y >= frame.height ||
|
||||
rect.x + rect.w <= 0 ||
|
||||
rect.y + rect.h <= 0
|
||||
)
|
||||
continue;
|
||||
const hidden = Boolean(hardUi?.(rect));
|
||||
const previous = marker.hudHidden;
|
||||
if (previous !== hidden) {
|
||||
marker.hudHidden = hidden;
|
||||
// The active icon steps aside only for visible counts beside it.
|
||||
refresh ||=
|
||||
((hidden || previous !== undefined) && marker.besideActive) ||
|
||||
marker.cell.lone?.some((cell) => cell.absorbed === hidden);
|
||||
}
|
||||
if (hidden) continue;
|
||||
const fade =
|
||||
frame.keyhole && keyholeAlpha ? keyholeAlpha(x, y, frame.keyhole) : 1;
|
||||
if (!(fade > 0)) continue;
|
||||
ctx.globalAlpha = marker.focus * fade;
|
||||
ctx.beginPath();
|
||||
ctx.roundRect(
|
||||
rect.x + STROKE_INSET,
|
||||
rect.y + STROKE_INSET,
|
||||
rect.w - 2 * STROKE_INSET,
|
||||
height - 2 * STROKE_INSET,
|
||||
height / 2 - STROKE_INSET,
|
||||
);
|
||||
ctx.strokeStyle = 'rgba(8, 14, 20, 0.85)';
|
||||
ctx.lineWidth = RING_PX + 2 * RIM_PX;
|
||||
ctx.stroke();
|
||||
ctx.fillStyle = '#0e1720';
|
||||
ctx.fill();
|
||||
ctx.strokeStyle = CAMERA_GREEN;
|
||||
ctx.lineWidth = RING_PX;
|
||||
ctx.stroke();
|
||||
ctx.fillStyle = CAMERA_GREEN;
|
||||
if (spriteReady) {
|
||||
const width = marker.glyphHeight * GLYPH_SOURCE_ASPECT;
|
||||
ctx.drawImage(
|
||||
sprite,
|
||||
...GLYPH_SOURCE,
|
||||
x - width / 2,
|
||||
y + marker.glyphBottom - marker.glyphHeight,
|
||||
width,
|
||||
marker.glyphHeight,
|
||||
);
|
||||
}
|
||||
ctx.fillText(marker.text, x, y + marker.labelY);
|
||||
rect.cell = marker.cell;
|
||||
hitCount++;
|
||||
}
|
||||
} finally {
|
||||
ctx.restore();
|
||||
}
|
||||
if (refresh) queueMicrotask(refreshView);
|
||||
}
|
||||
|
||||
/** Resolve the topmost group actually painted at this screen position. */
|
||||
function pickedCell(point) {
|
||||
if (!point) return null;
|
||||
for (let i = hitCount - 1; i >= 0; i--) {
|
||||
const rect = hits[i];
|
||||
const radius = rect.h / 2;
|
||||
// Distance from the pill's horizontal centre segment.
|
||||
const dx = Math.max(
|
||||
0,
|
||||
Math.abs(point.x - (rect.x + rect.w / 2)) - (rect.w - rect.h) / 2,
|
||||
);
|
||||
const dy = point.y - (rect.y + radius);
|
||||
if (dx * dx + dy * dy <= radius * radius) return rect.cell;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/** A new group may already have arrived since the empty frame. */
|
||||
function deactivateIfEmpty() {
|
||||
if (!markers.length) lane?.setActive(false);
|
||||
}
|
||||
|
||||
/** Release the visible groups and clear their hit targets immediately. */
|
||||
function hide() {
|
||||
markers.length = hits.length = hitCount = 0;
|
||||
lane?.setActive(false);
|
||||
}
|
||||
|
||||
/** Unhook this viewer's painter and its font listener. */
|
||||
function dispose() {
|
||||
hide();
|
||||
fonts?.removeEventListener?.('loadingdone', fontsLoaded);
|
||||
lane?.unregister();
|
||||
}
|
||||
|
||||
return {
|
||||
markers,
|
||||
update,
|
||||
pickedCell,
|
||||
hide,
|
||||
dispose,
|
||||
requestPaint: () => lane?.requestPaint(),
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,179 @@
|
||||
import { test, beforeEach, afterEach } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { createCountMarkers } from './countMarkers.js';
|
||||
import { addCellCamera, createCameraCell } from '../../data/cctvCellCounts.js';
|
||||
import { fromDegrees } from '../../geo/ellipsoid.js';
|
||||
import { horizonFrom } from '../../geo/horizon.js';
|
||||
|
||||
const W = 800;
|
||||
const H = 600;
|
||||
const A = 6378137;
|
||||
// Screen x = W/2 + ecefY/30, y = H/2 - ecefZ/30 (as the view-thinning fixture).
|
||||
const project = (p) => ({ x: W / 2 + p.y / 30, y: H / 2 - p.z / 30 });
|
||||
const lonFor = (x) => (Math.asin(((x - W / 2) * 30) / A) * 180) / Math.PI;
|
||||
const matrix = new Float64Array([
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
2 / (30 * W),
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
2 / (30 * H),
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
1,
|
||||
]);
|
||||
|
||||
function cellAt(key, x, count, height = 0) {
|
||||
const cell = createCameraCell(key);
|
||||
for (let i = 0; i < count; i++)
|
||||
addCellCamera(cell, { lon: lonFor(x), lat: 0, absoluteHeightM: height });
|
||||
return cell;
|
||||
}
|
||||
|
||||
let painter;
|
||||
function makeCtx() {
|
||||
return {
|
||||
labels: [],
|
||||
globalAlpha: 1,
|
||||
save() {},
|
||||
restore() {},
|
||||
beginPath() {},
|
||||
roundRect() {},
|
||||
stroke() {},
|
||||
fill() {},
|
||||
drawImage() {},
|
||||
fillText(text, x, y) {
|
||||
this.labels.push({ text, x, y, alpha: this.globalAlpha });
|
||||
},
|
||||
};
|
||||
}
|
||||
function paint(overrides = {}) {
|
||||
const ctx = makeCtx();
|
||||
painter({
|
||||
ctx,
|
||||
width: W,
|
||||
height: H,
|
||||
dpr: 1,
|
||||
viewProjectionMatrix: matrix,
|
||||
occluder: { isPointVisible: () => true },
|
||||
overlapsHardUi: () => false,
|
||||
...overrides,
|
||||
});
|
||||
return ctx.labels;
|
||||
}
|
||||
function counts(refresh = () => {}, keyholeAlpha) {
|
||||
return createCountMarkers(
|
||||
(_lane, paintFn) => {
|
||||
painter = paintFn;
|
||||
return { requestPaint() {}, setActive() {}, unregister() {} };
|
||||
},
|
||||
'counts',
|
||||
refresh,
|
||||
keyholeAlpha,
|
||||
);
|
||||
}
|
||||
|
||||
beforeEach(() => {
|
||||
globalThis.document = {
|
||||
createElement: () => ({
|
||||
getContext: () => ({
|
||||
measureText: (text) => ({
|
||||
width: text.length * 7,
|
||||
actualBoundingBoxAscent: 4,
|
||||
actualBoundingBoxDescent: 4,
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
};
|
||||
});
|
||||
afterEach(() => {
|
||||
delete globalThis.document;
|
||||
});
|
||||
test('a count on ground below the ellipsoid stays painted while its mounts are above the horizon', () => {
|
||||
const m = counts();
|
||||
m.update([cellAt('a', 400, 2, -20)], project, () => -30);
|
||||
const eye = fromDegrees(-0.009, 0, 30); // about 1 km away, 30 m above the ellipsoid
|
||||
const horizon = horizonFrom(eye);
|
||||
assert.equal(horizon.isPointVisible(fromDegrees(lonFor(400), 0, -20)), true);
|
||||
assert.equal(paint({ occluder: horizon }).length, 1);
|
||||
});
|
||||
|
||||
test('a lone camera clear of the HUD keeps its icon when the count beside it is hidden', async () => {
|
||||
const hud = { overlapsHardUi: (rect) => rect.x < 200 };
|
||||
for (const paintedFirst of [true, false]) {
|
||||
const cells = [cellAt('a', 200, 2), cellAt('b', 234, 1)];
|
||||
const m = counts(() => m.update(cells, project));
|
||||
if (paintedFirst) paint(hud);
|
||||
m.update(cells, project);
|
||||
const labels = paint(hud);
|
||||
await Promise.resolve();
|
||||
assert.ok(!cells[1].absorbed || labels.length > 0);
|
||||
// Moving the HUD at rest also changes whether the lone icon is needed.
|
||||
paint();
|
||||
await Promise.resolve();
|
||||
assert.equal(cells[1].absorbed, true);
|
||||
paint(hud);
|
||||
await Promise.resolve();
|
||||
assert.equal(cells[1].absorbed, false);
|
||||
m.dispose();
|
||||
}
|
||||
});
|
||||
|
||||
test('a count stays visible when a lone camera would move it under the HUD', async () => {
|
||||
const cells = [cellAt('a', 200, 2), cellAt('b', 234, 1)];
|
||||
const hud = { overlapsHardUi: (rect) => rect.x + rect.w > 225 };
|
||||
const m = counts(() => m.update(cells, project));
|
||||
paint(hud);
|
||||
m.update(cells, project);
|
||||
assert.equal(paint(hud)[0]?.text, '2');
|
||||
assert.equal(cells[1].absorbed, false);
|
||||
await Promise.resolve();
|
||||
paint(hud);
|
||||
await Promise.resolve();
|
||||
|
||||
paint();
|
||||
await Promise.resolve();
|
||||
assert.equal(cells[1].absorbed, true);
|
||||
assert.equal(paint()[0]?.text, '3');
|
||||
m.dispose();
|
||||
});
|
||||
|
||||
test('a restored count includes the lone camera it still covers at the HUD edge', async () => {
|
||||
const cells = [cellAt('a', 200, 2), cellAt('b', 206, 1)];
|
||||
const hud = { overlapsHardUi: (rect) => rect.x + rect.w > 221 };
|
||||
const scratch = {};
|
||||
const update = () =>
|
||||
m.update(cells, (p) => Object.assign(scratch, project(p)));
|
||||
const m = counts(update);
|
||||
update();
|
||||
assert.equal(Math.round(paint()[0].x), 202);
|
||||
|
||||
paint(hud);
|
||||
await Promise.resolve();
|
||||
const [marker] = paint(hud);
|
||||
assert.equal(marker?.text, '3');
|
||||
assert.equal(Math.round(marker.x), 200);
|
||||
assert.equal(cells[1].absorbed, true);
|
||||
assert.ok(m.pickedCell({ x: 206, y: 300 }).parts.includes(cells[1]));
|
||||
|
||||
paint();
|
||||
await Promise.resolve();
|
||||
assert.equal(Math.round(paint()[0].x), 202);
|
||||
m.dispose();
|
||||
});
|
||||
|
||||
test('counts fade with the Scope keyhole like the callouts', () => {
|
||||
const m = counts(undefined, (_x, _y, keyhole) => keyhole.alpha);
|
||||
m.update([cellAt('a', 400, 2)], project);
|
||||
assert.equal(paint({ keyhole: { alpha: 0.25 } })[0].alpha, 0.25);
|
||||
assert.deepEqual(paint({ keyhole: { alpha: 0 } }), []);
|
||||
assert.equal(m.pickedCell({ x: 400, y: 300 }), null);
|
||||
assert.equal(paint()[0].alpha, 1);
|
||||
});
|
||||
@@ -0,0 +1,76 @@
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { bindRenderer } from '../../render/rendererOf.js';
|
||||
import { fromDegrees, toLonLatH } from '../../geo/ellipsoid.js';
|
||||
import {
|
||||
addCellCamera,
|
||||
createCameraCell,
|
||||
mergeCountCells,
|
||||
} from '../../data/cctvCellCounts.js';
|
||||
import { createNavigation } from './navigation.js';
|
||||
|
||||
const M = 111_320;
|
||||
|
||||
// Cesium's default 60 degree field of view spans the wider side, so a 4:3
|
||||
// window has a vertical fovy of about 46.8 degrees. Two pairs 50 km and 80 km
|
||||
// east of an eye 800 m up merge into one count. At half the distance all four
|
||||
// fit in the frame (the group is wide, not tall), so the flight must keep all
|
||||
// four in frame instead of approaching only the near pair.
|
||||
test('a count click on an east-west group that fits keeps every member in the frame', () => {
|
||||
const viewer = {};
|
||||
const flights = [];
|
||||
const aspectRatio = 800 / 600;
|
||||
const fovy = 2 * Math.atan(Math.tan(Math.PI / 6) / aspectRatio);
|
||||
const unbind = bindRenderer(viewer, {
|
||||
camera: {
|
||||
pose: () => ({ fovy, aspectRatio, position: fromDegrees(0, 0, 800) }),
|
||||
flyToBounds: (bounds, options) => flights.push({ bounds, options }),
|
||||
},
|
||||
canvas: { clientHeight: 600, clientWidth: 800 },
|
||||
});
|
||||
try {
|
||||
const members = [];
|
||||
const cells = [50_000, 80_000].map((start) => {
|
||||
const cell = createCameraCell(String(start));
|
||||
for (const eastM of [start, start + 10]) {
|
||||
const lon = eastM / M;
|
||||
addCellCamera(cell, { lat: 0, lon, absoluteHeightM: 8 });
|
||||
members.push(lon);
|
||||
}
|
||||
return cell;
|
||||
});
|
||||
const screens = [
|
||||
{ x: 400, y: 300 },
|
||||
{ x: 433, y: 300 },
|
||||
];
|
||||
const groups = mergeCountCells(
|
||||
cells,
|
||||
() => screens.shift(),
|
||||
() => ({ width: 40, height: 40 }),
|
||||
2,
|
||||
);
|
||||
assert.equal(groups.length, 1);
|
||||
assert.equal(groups[0].count, 4);
|
||||
// Reference: a north-up top-down frame at half the distance holds all four.
|
||||
const halfwayM = 65_005 / 2;
|
||||
const refHalfX = halfwayM * Math.tan(fovy / 2) * aspectRatio;
|
||||
assert.ok(members.every((lon) => Math.abs(lon * M - 65_005) <= refHalfX));
|
||||
createNavigation({ state: { _viewer: viewer }, parts: {} }).zoomToCell(
|
||||
groups[0],
|
||||
);
|
||||
assert.equal(flights.length, 1);
|
||||
const { range } = flights[0].options.offset;
|
||||
const center = toLonLatH(flights[0].bounds.center);
|
||||
const halfX = range * Math.tan(fovy / 2) * aspectRatio;
|
||||
const inFrame = members.filter(
|
||||
(lon) => Math.abs((lon - center.lon) * M) <= halfX,
|
||||
);
|
||||
assert.equal(
|
||||
inFrame.length,
|
||||
4,
|
||||
`only ${inFrame.length} of 4 members in frame (range ${Math.round(range)} m)`,
|
||||
);
|
||||
} finally {
|
||||
unbind();
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,67 @@
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { bindRenderer } from '../../render/rendererOf.js';
|
||||
import { fromDegrees } from '../../geo/ellipsoid.js';
|
||||
import { distance } from '../../geo/vector.js';
|
||||
import {
|
||||
addCellCamera,
|
||||
createCameraCell,
|
||||
mergeCountCells,
|
||||
} from '../../data/cctvCellCounts.js';
|
||||
import { createNavigation } from './navigation.js';
|
||||
|
||||
// A count of four merged in a tilted view: two pairs 10 km and 40 km north of
|
||||
// an eye 800 m up. After the click, at least one member must be in frame.
|
||||
test('a count click from a tilted view keeps the group members in the frame', () => {
|
||||
const viewer = {};
|
||||
const flights = [];
|
||||
const fovy = Math.PI / 3;
|
||||
const aspectRatio = 800 / 600;
|
||||
const unbind = bindRenderer(viewer, {
|
||||
camera: {
|
||||
pose: () => ({ fovy, aspectRatio, position: fromDegrees(0, 0, 800) }),
|
||||
flyToBounds: (bounds, options) => flights.push({ bounds, options }),
|
||||
},
|
||||
canvas: { clientHeight: 600, clientWidth: 800 },
|
||||
});
|
||||
try {
|
||||
const metresPerDegree = 111_320;
|
||||
const members = [];
|
||||
const cells = [10_000, 40_000].map((start) => {
|
||||
const cell = createCameraCell(String(start));
|
||||
for (const northM of [start, start + 10]) {
|
||||
const lat = northM / metresPerDegree;
|
||||
addCellCamera(cell, { lat, lon: 0, absoluteHeightM: 8 });
|
||||
members.push(fromDegrees(0, lat, 8));
|
||||
}
|
||||
return cell;
|
||||
});
|
||||
const screens = [
|
||||
{ x: 400, y: 300 },
|
||||
{ x: 433, y: 300 },
|
||||
];
|
||||
const groups = mergeCountCells(
|
||||
cells,
|
||||
() => screens.shift(),
|
||||
() => ({ width: 40, height: 40 }),
|
||||
2,
|
||||
);
|
||||
assert.equal(groups.length, 1);
|
||||
assert.equal(groups[0].count, 4);
|
||||
const state = { _viewer: viewer };
|
||||
const navigation = createNavigation({ state, parts: {} });
|
||||
navigation.zoomToCell(groups[0]);
|
||||
assert.equal(flights.length, 1);
|
||||
const { range, pitch } = flights[0].options.offset;
|
||||
assert.equal(pitch, -Math.PI / 2);
|
||||
const { center } = flights[0].bounds;
|
||||
const halfSpanM = range * Math.tan(fovy / 2);
|
||||
assert.ok(
|
||||
members.some((point) => distance(point, center) <= halfSpanM),
|
||||
'no member of the group is in the final frame',
|
||||
);
|
||||
assert.ok(range < distance(fromDegrees(0, 0, 800), center));
|
||||
} finally {
|
||||
unbind();
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,69 @@
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { bindRenderer } from '../../render/rendererOf.js';
|
||||
import { fromDegrees, toLonLatH } from '../../geo/ellipsoid.js';
|
||||
import {
|
||||
addCellCamera,
|
||||
createCameraCell,
|
||||
mergeCountCells,
|
||||
} from '../../data/cctvCellCounts.js';
|
||||
import { createNavigation } from './navigation.js';
|
||||
|
||||
const M = 111_320;
|
||||
|
||||
// A count of 40 cameras 40 km north of an eye 800 m up takes in a lone camera
|
||||
// 10 km north that is drawn just below it. The click must not land on the lone
|
||||
// camera alone: at least one of the 40 counted cameras must be in the frame.
|
||||
test('a count click does not fly to a lone camera that joined the count', () => {
|
||||
const viewer = {};
|
||||
const flights = [];
|
||||
const fovy = Math.PI / 3;
|
||||
const aspectRatio = 800 / 600;
|
||||
const unbind = bindRenderer(viewer, {
|
||||
camera: {
|
||||
pose: () => ({ fovy, aspectRatio, position: fromDegrees(0, 0, 800) }),
|
||||
flyToBounds: (bounds, options) => flights.push({ bounds, options }),
|
||||
},
|
||||
canvas: { clientHeight: 600, clientWidth: 800 },
|
||||
});
|
||||
try {
|
||||
const crowd = createCameraCell('crowd');
|
||||
const counted = [];
|
||||
for (let i = 0; i < 40; i++) {
|
||||
const lat = (40_000 + i / 4) / M;
|
||||
addCellCamera(crowd, { lat, lon: 0, absoluteHeightM: 8 });
|
||||
counted.push(lat);
|
||||
}
|
||||
const lone = createCameraCell('lone');
|
||||
addCellCamera(lone, { lat: 10_000 / M, lon: 0, absoluteHeightM: 8 });
|
||||
const screens = [
|
||||
{ x: 400, y: 300 },
|
||||
{ x: 400, y: 330 },
|
||||
];
|
||||
const groups = mergeCountCells(
|
||||
[crowd, lone],
|
||||
() => screens.shift(),
|
||||
(count) =>
|
||||
count > 1 ? { width: 40, height: 40 } : { width: 24, height: 24 },
|
||||
2,
|
||||
);
|
||||
assert.equal(groups.length, 1);
|
||||
assert.equal(groups[0].count, 41);
|
||||
createNavigation({ state: { _viewer: viewer }, parts: {} }).zoomToCell(
|
||||
groups[0],
|
||||
);
|
||||
assert.equal(flights.length, 1);
|
||||
const { range } = flights[0].options.offset;
|
||||
const center = toLonLatH(flights[0].bounds.center);
|
||||
const halfY = range * Math.tan(fovy / 2);
|
||||
const inFrame = counted.filter(
|
||||
(lat) => Math.abs((lat - center.lat) * M) <= halfY,
|
||||
);
|
||||
assert.ok(
|
||||
inFrame.length > 0,
|
||||
`none of the 40 counted cameras is in the frame (range ${Math.round(range)} m, centre ${Math.round(center.lat * M)} m north)`,
|
||||
);
|
||||
} finally {
|
||||
unbind();
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,65 @@
|
||||
import * as picking from '../../data/pickRegistry.js';
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { createSelection } from './selection.js';
|
||||
|
||||
function setup() {
|
||||
let zooms = 0,
|
||||
clicks = 0;
|
||||
const selection = createSelection({
|
||||
services: { activation: {}, picking },
|
||||
state: {
|
||||
_enabled: true,
|
||||
_counts: { pickedCell: () => ({}) },
|
||||
_cctvOverlayHost: { hitTest: () => null },
|
||||
},
|
||||
parts: {
|
||||
navigation: { zoomToCell: () => zooms++ },
|
||||
rendering: { extractPickedCameraId: () => null },
|
||||
},
|
||||
});
|
||||
const click = selection.bindCctvWorldClickGesture(
|
||||
{ onClick: (fn) => fn },
|
||||
() => clicks++,
|
||||
);
|
||||
return { click, counts: () => [zooms, clicks] };
|
||||
}
|
||||
|
||||
test('a click a painted overlay target took (Space Missions label) does not fly to the count', () => {
|
||||
const { click, counts } = setup();
|
||||
// What the dispatcher hands subscribers after an onOverlayClick handler returned true.
|
||||
click({
|
||||
screenPosition: { x: 20, y: 26 },
|
||||
overlay: true,
|
||||
topHit: { set: '', id: null, surface: false },
|
||||
drawHit: null,
|
||||
gesture: { travelPx: 0, durationMs: 20 },
|
||||
});
|
||||
assert.equal(
|
||||
counts()[0],
|
||||
0,
|
||||
'count flight ran although an overlay target handled the click',
|
||||
);
|
||||
});
|
||||
|
||||
test("another layer's world-overlay card on top (clickCard) takes the click from the count", () => {
|
||||
const { click, counts } = setup();
|
||||
picking.setClickCardHitTest(() => ({
|
||||
sourceId: 'earthquakes',
|
||||
entryId: 'eq-1',
|
||||
}));
|
||||
try {
|
||||
click({
|
||||
screenPosition: { x: 20, y: 26 },
|
||||
topHit: null,
|
||||
drawHit: null,
|
||||
gesture: { travelPx: 0, durationMs: 20 },
|
||||
});
|
||||
assert.ok(
|
||||
picking.isUnderOtherCard({ screenPosition: { x: 1, y: 1 } }, ['cctv']),
|
||||
);
|
||||
assert.equal(counts()[0], 0, 'count flight ran under another layer card');
|
||||
} finally {
|
||||
picking.setClickCardHitTest(null);
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,96 @@
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { bindRenderer } from '../../render/rendererOf.js';
|
||||
import { fromDegrees, toLonLatH } from '../../geo/ellipsoid.js';
|
||||
import {
|
||||
addCellCamera,
|
||||
createCameraCell,
|
||||
mergeCountCells,
|
||||
} from '../../data/cctvCellCounts.js';
|
||||
import { createNavigation } from './navigation.js';
|
||||
|
||||
const M = 111_320;
|
||||
|
||||
function run({ aspectRatio, fovy, eye, pairs, groundM }) {
|
||||
const viewer = {};
|
||||
const flights = [];
|
||||
const unbind = bindRenderer(viewer, {
|
||||
camera: {
|
||||
pose: () => ({ fovy, aspectRatio, position: eye }),
|
||||
flyToBounds: (bounds, options) => flights.push({ bounds, options }),
|
||||
},
|
||||
canvas: { clientHeight: 600, clientWidth: Math.round(600 * aspectRatio) },
|
||||
});
|
||||
try {
|
||||
const members = [];
|
||||
const cells = pairs.map(({ eastM = 0, northM = 0, h }, i) => {
|
||||
const cell = createCameraCell(String(i));
|
||||
for (const d of [0, 10]) {
|
||||
const m = { lon: (eastM + d) / M, lat: northM / M, h };
|
||||
addCellCamera(cell, { lat: m.lat, lon: m.lon, absoluteHeightM: h });
|
||||
members.push(m);
|
||||
}
|
||||
cell.groundM = h;
|
||||
return cell;
|
||||
});
|
||||
const screens = [
|
||||
{ x: 400, y: 300 },
|
||||
{ x: 420, y: 300 },
|
||||
];
|
||||
const groups = mergeCountCells(
|
||||
cells,
|
||||
() => screens.shift(),
|
||||
() => ({ width: 40, height: 40 }),
|
||||
2,
|
||||
);
|
||||
assert.equal(groups.length, 1);
|
||||
groups[0].groundM = groundM;
|
||||
createNavigation({ state: { _viewer: viewer }, parts: {} }).zoomToCell(
|
||||
groups[0],
|
||||
);
|
||||
const { range } = flights[0].options.offset;
|
||||
const c = toLonLatH(flights[0].bounds.center);
|
||||
const eyeH = c.height + range;
|
||||
const tanY = Math.tan(fovy / 2);
|
||||
const inFrame = members.filter((m) => {
|
||||
const depth = eyeH - m.h;
|
||||
if (!(depth > 0)) return false;
|
||||
return (
|
||||
Math.abs((m.lon - c.lon) * M) <= depth * tanY * aspectRatio &&
|
||||
Math.abs((m.lat - c.lat) * M) <= depth * tanY
|
||||
);
|
||||
});
|
||||
return { range, inFrame: inFrame.length, centerH: c.height };
|
||||
} finally {
|
||||
unbind();
|
||||
}
|
||||
}
|
||||
|
||||
test('a count click on pairs 300 m above the ground under the group centre keeps a member in the frame', () => {
|
||||
const aspectRatio = 4 / 3;
|
||||
const fovy = 2 * Math.atan(Math.tan(Math.PI / 6) / aspectRatio);
|
||||
const r = run({
|
||||
aspectRatio,
|
||||
fovy,
|
||||
eye: fromDegrees(0, 0, 900),
|
||||
pairs: [
|
||||
{ eastM: 3000, h: 800 },
|
||||
{ eastM: 5000, h: 800 },
|
||||
],
|
||||
groundM: 500,
|
||||
});
|
||||
|
||||
const flat = run({
|
||||
aspectRatio,
|
||||
fovy,
|
||||
eye: fromDegrees(0, 0, 900),
|
||||
pairs: [
|
||||
{ eastM: 3000, h: 500 },
|
||||
{ eastM: 5000, h: 500 },
|
||||
],
|
||||
groundM: 500,
|
||||
});
|
||||
|
||||
assert.equal(flat.inFrame, 4);
|
||||
assert.ok(r.inFrame > 0, `no member in frame: ${JSON.stringify(r)}`);
|
||||
});
|
||||
@@ -0,0 +1,84 @@
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { bindRenderer } from '../../render/rendererOf.js';
|
||||
import { fromDegrees, toLonLatH } from '../../geo/ellipsoid.js';
|
||||
import {
|
||||
addCellCamera,
|
||||
createCameraCell,
|
||||
mergeCountCells,
|
||||
} from '../../data/cctvCellCounts.js';
|
||||
import { createNavigation } from './navigation.js';
|
||||
|
||||
const M = 111_320;
|
||||
|
||||
function run({ aspectRatio, fovy, eye, pairs, groundM }) {
|
||||
const viewer = {};
|
||||
const flights = [];
|
||||
const unbind = bindRenderer(viewer, {
|
||||
camera: {
|
||||
pose: () => ({ fovy, aspectRatio, position: eye }),
|
||||
flyToBounds: (bounds, options) => flights.push({ bounds, options }),
|
||||
},
|
||||
canvas: { clientHeight: 600, clientWidth: Math.round(600 * aspectRatio) },
|
||||
});
|
||||
try {
|
||||
const members = [];
|
||||
const cells = pairs.map(({ eastM = 0, northM = 0, h }, i) => {
|
||||
const cell = createCameraCell(String(i));
|
||||
for (const d of [0, 10]) {
|
||||
const m = { lon: (eastM + d) / M, lat: northM / M, h };
|
||||
addCellCamera(cell, { lat: m.lat, lon: m.lon, absoluteHeightM: h });
|
||||
members.push(m);
|
||||
}
|
||||
cell.groundM = h;
|
||||
return cell;
|
||||
});
|
||||
const screens = [
|
||||
{ x: 400, y: 300 },
|
||||
{ x: 420, y: 300 },
|
||||
];
|
||||
const groups = mergeCountCells(
|
||||
cells,
|
||||
() => screens.shift(),
|
||||
() => ({ width: 40, height: 40 }),
|
||||
2,
|
||||
);
|
||||
assert.equal(groups.length, 1);
|
||||
groups[0].groundM = groundM;
|
||||
createNavigation({ state: { _viewer: viewer }, parts: {} }).zoomToCell(
|
||||
groups[0],
|
||||
);
|
||||
const { range } = flights[0].options.offset;
|
||||
const c = toLonLatH(flights[0].bounds.center);
|
||||
const eyeH = c.height + range;
|
||||
const tanY = Math.tan(fovy / 2);
|
||||
const inFrame = members.filter((m) => {
|
||||
const depth = eyeH - m.h;
|
||||
if (!(depth > 0)) return false;
|
||||
return (
|
||||
Math.abs((m.lon - c.lon) * M) <= depth * tanY * aspectRatio &&
|
||||
Math.abs((m.lat - c.lat) * M) <= depth * tanY
|
||||
);
|
||||
});
|
||||
return { range, inFrame: inFrame.length, centerH: c.height };
|
||||
} finally {
|
||||
unbind();
|
||||
}
|
||||
}
|
||||
|
||||
test('a count click on a north-south group in a 32:9 window keeps every member in the frame', () => {
|
||||
const aspectRatio = 32 / 9;
|
||||
const fovy = 2 * Math.atan(Math.tan(Math.PI / 6) / aspectRatio);
|
||||
const r = run({
|
||||
aspectRatio,
|
||||
fovy,
|
||||
eye: fromDegrees(0, 0, 800),
|
||||
pairs: [
|
||||
{ northM: 15_000, h: 8 },
|
||||
{ northM: 17_000, h: 8 },
|
||||
],
|
||||
groundM: 8,
|
||||
});
|
||||
|
||||
assert.equal(r.inFrame, 4, JSON.stringify(r));
|
||||
});
|
||||
@@ -0,0 +1,145 @@
|
||||
import { test, beforeEach, afterEach } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { createCountMarkers } from './countMarkers.js';
|
||||
import { addCellCamera, createCameraCell } from '../../data/cctvCellCounts.js';
|
||||
import { fromDegrees } from '../../geo/ellipsoid.js';
|
||||
import { horizonFrom } from '../../geo/horizon.js';
|
||||
|
||||
const W = 800;
|
||||
const H = 600;
|
||||
const A = 6378137;
|
||||
// Screen x = W/2 + ecefY/30, y = H/2 - ecefZ/30 (as the view-thinning fixture).
|
||||
const project = (p) => ({ x: W / 2 + p.y / 30, y: H / 2 - p.z / 30 });
|
||||
const lonFor = (x) => (Math.asin(((x - W / 2) * 30) / A) * 180) / Math.PI;
|
||||
const matrix = new Float64Array([
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
2 / (30 * W),
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
2 / (30 * H),
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
1,
|
||||
]);
|
||||
|
||||
function cellAt(key, x, count, height = 0, y = H / 2) {
|
||||
const cell = createCameraCell(key);
|
||||
for (let i = 0; i < count; i++)
|
||||
addCellCamera(cell, {
|
||||
lon: lonFor(x),
|
||||
lat: (Math.asin(((H / 2 - y) * 30) / A) * 180) / Math.PI,
|
||||
absoluteHeightM: height,
|
||||
});
|
||||
return cell;
|
||||
}
|
||||
|
||||
let painter;
|
||||
function makeCtx() {
|
||||
return {
|
||||
labels: [],
|
||||
globalAlpha: 1,
|
||||
save() {},
|
||||
restore() {},
|
||||
beginPath() {},
|
||||
roundRect() {},
|
||||
stroke() {},
|
||||
fill() {},
|
||||
drawImage() {},
|
||||
fillText(text, x, y) {
|
||||
this.labels.push({ text, x, y, alpha: this.globalAlpha });
|
||||
},
|
||||
};
|
||||
}
|
||||
function paint(overrides = {}) {
|
||||
const ctx = makeCtx();
|
||||
painter({
|
||||
ctx,
|
||||
width: W,
|
||||
height: H,
|
||||
dpr: 1,
|
||||
viewProjectionMatrix: matrix,
|
||||
occluder: { isPointVisible: () => true },
|
||||
overlapsHardUi: () => false,
|
||||
...overrides,
|
||||
});
|
||||
return ctx.labels;
|
||||
}
|
||||
function counts(refresh = () => {}, keyholeAlpha) {
|
||||
return createCountMarkers(
|
||||
(_lane, paintFn) => {
|
||||
painter = paintFn;
|
||||
return { requestPaint() {}, setActive() {}, unregister() {} };
|
||||
},
|
||||
'counts',
|
||||
refresh,
|
||||
keyholeAlpha,
|
||||
);
|
||||
}
|
||||
|
||||
beforeEach(() => {
|
||||
globalThis.document = {
|
||||
createElement: () => ({
|
||||
getContext: () => ({
|
||||
measureText: (text) => ({
|
||||
width: text.length * 7,
|
||||
actualBoundingBoxAscent: 4,
|
||||
actualBoundingBoxDescent: 4,
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
};
|
||||
});
|
||||
afterEach(() => {
|
||||
delete globalThis.document;
|
||||
});
|
||||
|
||||
// 75 counts in five staggered rows, no lone cameras and no active camera,
|
||||
// pan right 7 CSS px per frame for 60 frames past a left HUD rail. Counts must
|
||||
// still hide and reappear at the rail, but the paint must not start a full
|
||||
// view pass on almost every frame: the motion timer passes the view every
|
||||
// 250 ms, about 4 times in these 60 frames at 60 Hz.
|
||||
test('a pan past the HUD edge does not pass the view on every frame', async () => {
|
||||
const run = async (hud) => {
|
||||
const cells = [];
|
||||
for (let row = 0; row < 5; row++)
|
||||
for (let col = 0; col < 15; col++)
|
||||
cells.push(
|
||||
cellAt(
|
||||
`r${row}c${String(col).padStart(2, '0')}`,
|
||||
30 + col * 50 + row * 10,
|
||||
2,
|
||||
0,
|
||||
120 + row * 60,
|
||||
),
|
||||
);
|
||||
let refreshes = 0;
|
||||
let hiddenFrames = 0;
|
||||
const m = counts(() => refreshes++);
|
||||
m.update(cells, project);
|
||||
for (let f = 0; f < 60; f++) {
|
||||
const panned = matrix.slice();
|
||||
panned[12] = (2 * (f * 7)) / W;
|
||||
const labels = paint({ ...hud, viewProjectionMatrix: panned });
|
||||
if (labels.length < 75) hiddenFrames++;
|
||||
await Promise.resolve();
|
||||
}
|
||||
m.dispose();
|
||||
return { refreshes, hiddenFrames };
|
||||
};
|
||||
const control = await run({});
|
||||
const withHud = await run({ overlapsHardUi: (rect) => rect.x < 150 });
|
||||
assert.equal(control.refreshes, 0);
|
||||
assert.ok(withHud.hiddenFrames > 0, 'the HUD hides no count');
|
||||
assert.ok(
|
||||
withHud.refreshes <= 4,
|
||||
`${withHud.refreshes} full view passes from paint in 60 frames`,
|
||||
);
|
||||
});
|
||||
@@ -0,0 +1,59 @@
|
||||
import * as picking from '../../data/pickRegistry.js';
|
||||
import { CCTV_COUNT_CARD_SOURCE_ID } from '../../data/cctvCards.js';
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { createSelection } from './selection.js';
|
||||
|
||||
// Earthquake discs (like fire perimeters and drone airspace) are deliberately
|
||||
// unowned background fills. A clean tap on a count painted over a disc must
|
||||
// zoom to the count and be the card on top for every layer, so Earthquakes
|
||||
// opens no card. An owned scene object (an aircraft) still takes the click.
|
||||
test('a count over an earthquake disc takes the click', () => {
|
||||
let zooms = 0;
|
||||
let clicks = 0;
|
||||
const selection = createSelection({
|
||||
services: { activation: {}, picking },
|
||||
state: {
|
||||
_enabled: true,
|
||||
_counts: { pickedCell: () => ({ key: 'g' }) },
|
||||
_cctvOverlayHost: { hitTest: () => null },
|
||||
},
|
||||
parts: {
|
||||
navigation: { zoomToCell: () => zooms++ },
|
||||
rendering: {
|
||||
extractPickedCameraId: (hit) =>
|
||||
hit?.set === 'cctv-icons' ? hit.id : null,
|
||||
},
|
||||
},
|
||||
});
|
||||
const click = selection.bindCctvWorldClickGesture(
|
||||
{ onClick: (fn) => fn },
|
||||
() => clicks++,
|
||||
);
|
||||
const event = (hit) => ({
|
||||
screenPosition: { x: 20, y: 26 },
|
||||
topHit: hit,
|
||||
drawHit: hit,
|
||||
hit,
|
||||
gesture: { travelPx: 0, durationMs: 20 },
|
||||
});
|
||||
picking.registerClickClaim('cctv', selection.countClickCard);
|
||||
picking.registerPickOwner('flights', (id) => id.startsWith('aircraft:'));
|
||||
try {
|
||||
const disc = event({ set: 'earthquakes:1:discs', id: 'earthquake:abc' });
|
||||
assert.deepEqual(picking.clickCard(disc), {
|
||||
sourceId: CCTV_COUNT_CARD_SOURCE_ID,
|
||||
entryId: 'g',
|
||||
});
|
||||
click(disc);
|
||||
assert.deepEqual([zooms, clicks], [1, 0]);
|
||||
|
||||
const aircraft = event({ set: 'flights:icons', id: 'aircraft:abc' });
|
||||
assert.equal(picking.clickCard(aircraft), null);
|
||||
click(aircraft);
|
||||
assert.deepEqual([zooms, clicks], [1, 1]);
|
||||
} finally {
|
||||
picking.unregisterClickClaim('cctv');
|
||||
picking.unregisterPickOwner('flights');
|
||||
}
|
||||
});
|
||||
+77
-47
@@ -1,4 +1,4 @@
|
||||
import { fromDegrees } from '../../geo/ellipsoid.js';
|
||||
import { fromDegreesInto } from '../../geo/ellipsoid.js';
|
||||
import { findGlobe } from '../../render/rendererOf.js';
|
||||
import {
|
||||
SUPPORT_KEYS,
|
||||
@@ -22,11 +22,12 @@ export function createGround({ state: layerState, services, parts, source }) {
|
||||
* - `google-3d` — photoreal stack: globe hidden, the visible Google 3D
|
||||
* tileset IS the surface → one-shot scene sampling refines.
|
||||
* - `terrain-globe` — any globe stack: the Re:Earth point-height prior IS the
|
||||
* resolution (zero scene queries).
|
||||
* resolution. A camera the batch left unanswered takes the
|
||||
* drawn terrain from the view pass (`adoptDrawnGround`).
|
||||
*
|
||||
* Only an explicit `false` (the photoreal stack hides the globe) selects
|
||||
* `google-3d`; undefined/null (no viewer / torn down) must fall to the regime
|
||||
* that never touches the scene. Pure — exported for the unit suite.
|
||||
* that never samples the scene's tiles. Pure — exported for the unit suite.
|
||||
* @param {boolean|undefined|null} globeShow - Whether the renderer shows the
|
||||
* globe (`globe.isGlobeVisible()`).
|
||||
* @returns {'google-3d'|'terrain-globe'}
|
||||
@@ -214,56 +215,84 @@ export function createGround({ state: layerState, services, parts, source }) {
|
||||
let applied = 0;
|
||||
let moved = 0;
|
||||
for (let i = 0; i < records.length && i < priors.length; i++) {
|
||||
const record = records[i];
|
||||
const prior = priors[i];
|
||||
if (!record || !prior || !Number.isFinite(prior.ellipsoid)) continue;
|
||||
// Stale-record guard: init() may have re-run (destroy/init cycle) while
|
||||
// the batch was in flight — only touch records still live in the map.
|
||||
if (layerState._recordById.get(record.camera.id) !== record) continue;
|
||||
record.groundPrior = prior;
|
||||
// Keep the cheap pre-enable altitude consistent for records whose
|
||||
// geometry hasn't been applied yet (applyFrustumGeometry overwrites it).
|
||||
if (!record.frustumPositions) {
|
||||
record.camera.absoluteHeightM =
|
||||
prior.ellipsoid + record.camera.mountHeightM;
|
||||
}
|
||||
// Cameras without geometry only move their icon onto the prior, so the
|
||||
// view pass projects the right point; their frustums are built when
|
||||
// they enter the view, as recomputing the whole catalog here would
|
||||
// stall a large one.
|
||||
if (!record.frustumGeometry) {
|
||||
if (record.position) {
|
||||
// In place: the record keeps its position object.
|
||||
const { x, y, z } = fromDegrees(
|
||||
record.camera.lon,
|
||||
record.camera.lat,
|
||||
record.camera.absoluteHeightM,
|
||||
);
|
||||
record.position.x = x;
|
||||
record.position.y = y;
|
||||
record.position.z = z;
|
||||
parts.rendering.moveCameraIcon(record);
|
||||
moved += 1;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
const regime = currentSurfaceRegime();
|
||||
if (regime === 'terrain-globe') {
|
||||
// Prior IS the resolution — re-latch onto the fresh value.
|
||||
parts.geometry.updateRecordGeometry(record, { sampleGround: false });
|
||||
applied += 1;
|
||||
} else if (!Number.isFinite(record.groundSamples['google-3d'])) {
|
||||
// Still awaiting the shared floor: snap interim geometry onto the exact
|
||||
// prior (pure recompute; the shared cell may refine later).
|
||||
parts.geometry.applyFrustumGeometry(record, prior.ellipsoid);
|
||||
applied += 1;
|
||||
}
|
||||
const outcome = applyGroundPrior(records[i], priors[i]);
|
||||
if (outcome === 'moved') moved += 1;
|
||||
else if (outcome === 'applied') applied += 1;
|
||||
}
|
||||
if (moved && parts.rendering.refreshHorizonCulling())
|
||||
parts.geometryQueue.enqueueViewGeometry();
|
||||
if (applied || moved) parts.presentation.notifyListeners();
|
||||
}
|
||||
|
||||
/**
|
||||
* Gives one live record a ground prior: `'moved'` when only its icon went
|
||||
* onto the prior in place, `'applied'` when its geometry was recomputed,
|
||||
* null when nothing changed. Pure recomputes, no scene queries.
|
||||
*/
|
||||
function applyGroundPrior(record, prior) {
|
||||
if (!record || !prior || !Number.isFinite(prior.ellipsoid)) return null;
|
||||
// Stale-record guard: init() may have re-run (destroy/init cycle) while
|
||||
// the batch was in flight — only touch records still live in the map.
|
||||
if (layerState._recordById.get(record.camera.id) !== record) return null;
|
||||
// The drawn terrain beats a fallback. Only a real batch answer replaces it.
|
||||
if (
|
||||
prior.source === 'geoid-fallback' &&
|
||||
record.groundPrior?.source === 'drawn-terrain'
|
||||
)
|
||||
return null;
|
||||
record.groundPrior = prior;
|
||||
// Keep the cheap pre-enable altitude consistent for records whose
|
||||
// geometry hasn't been applied yet (applyFrustumGeometry overwrites it).
|
||||
if (!record.frustumPositions) {
|
||||
record.camera.absoluteHeightM =
|
||||
prior.ellipsoid + record.camera.mountHeightM;
|
||||
}
|
||||
// Cameras without geometry only move their icon onto the prior, so the
|
||||
// view pass projects the right point; their frustums are built when
|
||||
// they enter the view, as recomputing the whole catalog here would
|
||||
// stall a large one.
|
||||
if (!record.frustumGeometry) {
|
||||
if (!record.position) return null;
|
||||
// In place: the record keeps its position object.
|
||||
fromDegreesInto(
|
||||
record.camera.lon,
|
||||
record.camera.lat,
|
||||
record.camera.absoluteHeightM,
|
||||
record.position,
|
||||
);
|
||||
parts.rendering.moveCameraIcon(record);
|
||||
return 'moved';
|
||||
}
|
||||
const regime = currentSurfaceRegime();
|
||||
if (regime === 'terrain-globe') {
|
||||
// Prior IS the resolution — re-latch onto the fresh value.
|
||||
parts.geometry.updateRecordGeometry(record, { sampleGround: false });
|
||||
return 'applied';
|
||||
}
|
||||
if (!Number.isFinite(record.groundSamples['google-3d'])) {
|
||||
// Still awaiting the shared floor: snap interim geometry onto the exact
|
||||
// prior (pure recompute; the shared cell may refine later).
|
||||
parts.geometry.applyFrustumGeometry(record, prior.ellipsoid);
|
||||
return 'applied';
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Applies drawn terrain as a drawn-terrain prior. The read records the eye
|
||||
* distance (rangeM), globe surface version (surface) and whether terrain
|
||||
* loading had finished (settled). Reading from under half that range or
|
||||
* receiving a later Re:Earth answer replaces the height.
|
||||
* @returns {'moved'|'applied'|null} As `applyGroundPrior`.
|
||||
*/
|
||||
function adoptDrawnGround(record, heightM, read) {
|
||||
return applyGroundPrior(record, {
|
||||
ellipsoid: heightM,
|
||||
source: 'drawn-terrain',
|
||||
...read,
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Task 5: surface-regime change handler ('gev:map-stack-changed'
|
||||
* CustomEvent, dispatched by main.js from MapStackController.onChange). The
|
||||
@@ -399,6 +428,7 @@ export function createGround({ state: layerState, services, parts, source }) {
|
||||
resolveCommittedGroundAnchor,
|
||||
resolveGroundPriors,
|
||||
applyLateGroundPriors,
|
||||
adoptDrawnGround,
|
||||
handleMapStackChanged,
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { createGround } from './ground.js';
|
||||
import { fromDegrees } from '../../geo/ellipsoid.js';
|
||||
|
||||
function setup(record) {
|
||||
const calls = { culling: 0, geometry: [], notify: 0 };
|
||||
const state = {
|
||||
_viewer: null,
|
||||
_recordById: new Map([[record.camera.id, record]]),
|
||||
};
|
||||
const parts = {
|
||||
rendering: {
|
||||
refreshHorizonCulling: () => (calls.culling++, true),
|
||||
moveCameraIcon() {},
|
||||
},
|
||||
geometryQueue: { enqueueViewGeometry() {} },
|
||||
presentation: { notifyListeners: () => calls.notify++ },
|
||||
geometry: {
|
||||
// Same choice as geometry.updateRecordGeometry on a globe with a cold floor cell.
|
||||
updateRecordGeometry(r) {
|
||||
calls.geometry.push(
|
||||
ground.groundPriorAltFor(r) + r.camera.mountHeightM,
|
||||
);
|
||||
},
|
||||
},
|
||||
};
|
||||
const ground = createGround({
|
||||
state,
|
||||
services: {
|
||||
ground: { resolveGroundFloorCells: async () => {} },
|
||||
terrain: { resolveEllipsoidalGround: async () => [] },
|
||||
},
|
||||
parts,
|
||||
});
|
||||
return { ground, calls };
|
||||
}
|
||||
|
||||
test('a late geoid fallback leaves a drawn-terrain height in place', () => {
|
||||
const camera = {
|
||||
id: 'a',
|
||||
lat: 42,
|
||||
lon: -118,
|
||||
mountHeightM: 8,
|
||||
absoluteHeightM: 1880,
|
||||
};
|
||||
const record = {
|
||||
camera,
|
||||
position: fromDegrees(camera.lon, camera.lat, 1880),
|
||||
frustumGeometry: {},
|
||||
frustumPositions: {},
|
||||
groundSamples: {},
|
||||
groundResolved: {},
|
||||
groundPrior: { ellipsoid: 1872, source: 'drawn-terrain', rangeM: 2000 },
|
||||
};
|
||||
const { ground, calls } = setup(record);
|
||||
ground.applyLateGroundPriors(
|
||||
[record],
|
||||
[{ ellipsoid: 0, source: 'geoid-fallback' }],
|
||||
);
|
||||
|
||||
assert.equal(record.groundPrior.source, 'drawn-terrain');
|
||||
assert.ok(!calls.geometry.includes(8), 'mount not lowered to the fallback');
|
||||
});
|
||||
@@ -1,6 +1,6 @@
|
||||
import { fromDegrees } from '../../geo/ellipsoid.js';
|
||||
import { distance, dot } from '../../geo/vector.js';
|
||||
import { canvasOf, findCamera } from '../../render/rendererOf.js';
|
||||
import { canvasOf, findCamera, findGlobe } from '../../render/rendererOf.js';
|
||||
import { viewshedColors, cameraHue } from '../../data/cctvViewshed.js';
|
||||
import { CCTV_OVERLAY_SOURCE_ID } from '../../data/cctvCards.js';
|
||||
import { GIZMO_ID_PREFIX } from '../../data/cctvGizmo.js';
|
||||
@@ -23,8 +23,14 @@ export function createLifecycle({
|
||||
source,
|
||||
}) {
|
||||
const { activateCctvCameraFromWorldClick } = services.activation;
|
||||
const { resolvePickId, registerPickOwner, unregisterPickOwner, clickCard } =
|
||||
services.picking;
|
||||
const {
|
||||
resolvePickId,
|
||||
registerPickOwner,
|
||||
unregisterPickOwner,
|
||||
clickCard,
|
||||
registerClickClaim,
|
||||
unregisterClickClaim,
|
||||
} = services.picking;
|
||||
const { onFocusTargetAppear } = services.focus;
|
||||
const { releaseContinuousRender } = services.render;
|
||||
|
||||
@@ -103,6 +109,30 @@ export function createLifecycle({
|
||||
* listeners to its camera; one against the same viewer keeps them.
|
||||
*/
|
||||
function attachViewListeners() {
|
||||
const globe = findGlobe(layerState._viewer);
|
||||
if (layerState._surfaceListenerGlobe !== globe) {
|
||||
layerState._surfaceListener?.();
|
||||
layerState._surfaceListener = null;
|
||||
layerState._surfaceListenerGlobe = globe;
|
||||
}
|
||||
if (!layerState._surfaceListener && globe?.on) {
|
||||
// Refresh drawn heights when terrain finishes loading or the surface changes.
|
||||
let version = globe.surfaceVersion?.();
|
||||
let terrainPending = globe.isSettled?.('terrain') === false ? 1 : 0;
|
||||
layerState._surfaceListener = globe.on('progress', (progress) => {
|
||||
const next = globe.surfaceVersion?.();
|
||||
const loaded = progress?.terrainPending === 0 && terrainPending !== 0;
|
||||
const swapped = next !== version;
|
||||
version = next;
|
||||
terrainPending = progress?.terrainPending ?? terrainPending;
|
||||
if (
|
||||
(loaded || swapped) &&
|
||||
layerState._enabled &&
|
||||
!layerState._cameraMoving
|
||||
)
|
||||
settleView();
|
||||
});
|
||||
}
|
||||
const viewCamera = findCamera(layerState._viewer);
|
||||
if (
|
||||
layerState._viewListenerCamera &&
|
||||
@@ -140,6 +170,9 @@ export function createLifecycle({
|
||||
|
||||
/** Drop the move listeners; nothing reports the end of a move after it. */
|
||||
function detachViewListeners() {
|
||||
layerState._surfaceListener?.();
|
||||
layerState._surfaceListener = null;
|
||||
layerState._surfaceListenerGlobe = null;
|
||||
layerState._horizonCullListener?.();
|
||||
layerState._horizonCullListener = null;
|
||||
layerState._moveStartListener?.();
|
||||
@@ -163,9 +196,11 @@ export function createLifecycle({
|
||||
layerState._records = [];
|
||||
layerState._recordById = new Map();
|
||||
layerState._viewRecords = [];
|
||||
layerState._pickerRecords = [];
|
||||
layerState._cameraIndexCache = null;
|
||||
layerState._coverageVisibleIds = new Set();
|
||||
layerState._neighborCountCache = null;
|
||||
layerState._coverageCohort = null;
|
||||
layerState._viewUnpublished = false;
|
||||
layerState._viewPose = null;
|
||||
layerState._viewMotionPass = null;
|
||||
@@ -285,9 +320,8 @@ export function createLifecycle({
|
||||
coverageEntities: [],
|
||||
projection: null,
|
||||
// Task 5 (height-datum fix): regime-aware ground resolution state.
|
||||
// groundPrior — { ellipsoid, source } from the Re:Earth batch
|
||||
// (null until a late batch lands). The prior applies in EVERY
|
||||
// regime and is the terrain-globe resolution outright.
|
||||
// groundPrior — { ellipsoid, source } from the Re:Earth batch, or
|
||||
// drawn-terrain with its read conditions for an unanswered camera.
|
||||
// groundResolved — PER-REGIME one-shot latch (regime key →
|
||||
// boolean): true once this record's resolution completed for that
|
||||
// regime; such records are excluded from the completion pass so
|
||||
@@ -386,6 +420,7 @@ export function createLifecycle({
|
||||
parts.rendering.refreshHorizonCulling();
|
||||
|
||||
const input = inputFor(layerState._viewer);
|
||||
layerState._clickSubscription?.();
|
||||
const unsubscribeClick = parts.selection.bindCctvWorldClickGesture(
|
||||
input,
|
||||
(event) => {
|
||||
@@ -481,6 +516,7 @@ export function createLifecycle({
|
||||
);
|
||||
return Boolean(coverage && layerState._recordById.has(coverage[1]));
|
||||
});
|
||||
registerClickClaim?.('cctv', parts.selection.countClickCard);
|
||||
if (!layerState._activeCameraId && layerState._records.length) {
|
||||
layerState._activeCameraId = parts.navigation.openingCameraId();
|
||||
layerState._autoHopSuspended = false;
|
||||
@@ -517,6 +553,7 @@ export function createLifecycle({
|
||||
services.credits?.hideOsmCredit?.(layerState._viewer, 'cctv');
|
||||
layerState._enabled = false;
|
||||
unregisterPickOwner('cctv');
|
||||
unregisterClickClaim?.('cctv');
|
||||
// ADJUST mode does not survive a layer toggle — predictable re-entry.
|
||||
layerState._calibrationMode = false;
|
||||
releaseContinuousRender('cctv-adjust');
|
||||
@@ -532,6 +569,7 @@ export function createLifecycle({
|
||||
parts.rendering.hideCctvVisuals();
|
||||
// Nothing is in view while the layer is off.
|
||||
layerState._viewRecords = [];
|
||||
layerState._pickerRecords = [];
|
||||
layerState._cameraIndexCache = null;
|
||||
parts.presentation.notifyListeners();
|
||||
},
|
||||
@@ -550,6 +588,7 @@ export function createLifecycle({
|
||||
parts.cards.handleVisibilityChange,
|
||||
);
|
||||
unregisterPickOwner('cctv');
|
||||
unregisterClickClaim?.('cctv');
|
||||
if (layerState._mapStackListener && typeof window !== 'undefined') {
|
||||
window.removeEventListener(
|
||||
'gev:map-stack-changed',
|
||||
|
||||
@@ -77,6 +77,40 @@ test('the view listeners follow the camera port and let go on teardown', () => {
|
||||
assert.equal(state._viewListenerCamera, null);
|
||||
});
|
||||
|
||||
test('terrain loading and surface changes rerun the view pass', () => {
|
||||
const viewer = {};
|
||||
let version = 1,
|
||||
progress,
|
||||
removed = false;
|
||||
bindRenderer(viewer, {
|
||||
camera: fakeCameraPort().port,
|
||||
globe: {
|
||||
surfaceVersion: () => version,
|
||||
on(event, cb) {
|
||||
assert.equal(event, 'progress');
|
||||
progress = cb;
|
||||
return () => {
|
||||
removed = true;
|
||||
};
|
||||
},
|
||||
},
|
||||
});
|
||||
const { lifecycle, passes } = lifecycleFor({
|
||||
_viewer: viewer,
|
||||
_enabled: true,
|
||||
});
|
||||
lifecycle.attachViewListeners();
|
||||
progress({ terrainPending: 2 });
|
||||
assert.equal(passes.length, 0);
|
||||
progress({ terrainPending: 0 });
|
||||
assert.equal(passes.length, 1);
|
||||
version++;
|
||||
progress({ terrainPending: 0 });
|
||||
assert.equal(passes.length, 2);
|
||||
lifecycle.detachViewListeners();
|
||||
assert.ok(removed);
|
||||
});
|
||||
|
||||
/** A part whose members are `own`'s, and any other a function that does
|
||||
* nothing. */
|
||||
const inert = (own = {}) =>
|
||||
|
||||
@@ -1,6 +1,14 @@
|
||||
import { distance } from '../../geo/vector.js';
|
||||
import { toLonLatH } from '../../geo/ellipsoid.js';
|
||||
import { rangeForBoundingSphere } from '../../data/cameraFraming.js';
|
||||
import { isFollowing } from '../../data/followed.js';
|
||||
import { CCTV_FOCUS_RESULT } from './policy.js';
|
||||
import { cameraOf } from '../../render/rendererOf.js';
|
||||
import {
|
||||
cellBounds,
|
||||
cellCenter,
|
||||
cellHalfExtents,
|
||||
} from '../../data/cctvCellCounts.js';
|
||||
import { CCTV_FOCUS_RESULT, VIEW_CELL_PX, VIEW_MIN_CELL_M } from './policy.js';
|
||||
import { cameraOf, canvasOf } from '../../render/rendererOf.js';
|
||||
|
||||
export function createNavigation({
|
||||
state: layerState,
|
||||
@@ -79,6 +87,16 @@ export function createNavigation({
|
||||
return true;
|
||||
}
|
||||
|
||||
/** What holds the view instead of a CCTV flight, or null when it is free. */
|
||||
function viewHeldBy(viewer) {
|
||||
if (
|
||||
typeof document !== 'undefined' &&
|
||||
document.body?.classList.contains('cockpit-mode')
|
||||
)
|
||||
return CCTV_FOCUS_RESULT.COCKPIT_ACTIVE;
|
||||
return isFollowing(viewer) ? CCTV_FOCUS_RESULT.TRACKING_HOLDS_VIEW : null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Flies the viewer's camera to frame the specified CCTV camera,
|
||||
* looking along its heading from above.
|
||||
@@ -90,14 +108,12 @@ export function createNavigation({
|
||||
|
||||
function focusCctvRecord(viewer, record, duration = 2.2) {
|
||||
if (!viewer || !record) return CCTV_FOCUS_RESULT.NO_ACTIVE_CAMERA;
|
||||
if (
|
||||
typeof document !== 'undefined' &&
|
||||
document.body?.classList.contains('cockpit-mode')
|
||||
) {
|
||||
const held = viewHeldBy(viewer);
|
||||
if (held === CCTV_FOCUS_RESULT.COCKPIT_ACTIVE) {
|
||||
console.debug('[Data:CCTV] focus ignored while cockpit owns the camera');
|
||||
return CCTV_FOCUS_RESULT.COCKPIT_ACTIVE;
|
||||
}
|
||||
if (isFollowing(viewer)) {
|
||||
if (held === CCTV_FOCUS_RESULT.TRACKING_HOLDS_VIEW) {
|
||||
console.debug(
|
||||
'[Data:CCTV] focus ignored while a tracked entity owns the camera',
|
||||
);
|
||||
@@ -120,6 +136,68 @@ export function createNavigation({
|
||||
return CCTV_FOCUS_RESULT.FOCUSED;
|
||||
}
|
||||
|
||||
/** The nearest ground cell with two or more cameras, or the group itself if unmerged. */
|
||||
function nearestPart(cell, eye) {
|
||||
let nearest = cell;
|
||||
let best = Infinity;
|
||||
for (const part of cell.parts ?? []) {
|
||||
if (part.count < 2) continue;
|
||||
const d = distance(eye, cellCenter(part));
|
||||
if (d < best) {
|
||||
best = d;
|
||||
nearest = part;
|
||||
}
|
||||
}
|
||||
return nearest;
|
||||
}
|
||||
|
||||
/** Frame a group's padded bounds from above, including coincident mounts. */
|
||||
function zoomToCell(cell) {
|
||||
const viewer = layerState._viewer;
|
||||
if (!viewer || viewHeldBy(viewer)) return;
|
||||
const camera = cameraOf(viewer);
|
||||
const pose = camera.pose();
|
||||
const tanHalfY = Math.tan((pose.fovy || Math.PI / 3) / 2);
|
||||
const canvas = canvasOf(viewer);
|
||||
const height = canvas?.clientHeight || canvas?.height || 1;
|
||||
// Half the range where cells stop grouping, so even coincident mounts split.
|
||||
const closeRange =
|
||||
(VIEW_MIN_CELL_M * height) / (4 * VIEW_CELL_PX * tanHalfY);
|
||||
const tanHalfX = tanHalfY * (pose.aspectRatio || 1);
|
||||
// Range where a cell's ground extent, times `pad`, fits the frame at the
|
||||
// depth of its highest mount above the bounds centre.
|
||||
const extentRange = (target, bounds, pad = 1) => {
|
||||
const { halfWidthM, halfHeightM } = cellHalfExtents(target);
|
||||
const rise = Math.max(0, target.high - toLonLatH(bounds.center).height);
|
||||
return (
|
||||
rise + pad * Math.max(halfWidthM / tanHalfX, halfHeightM / tanHalfY)
|
||||
);
|
||||
};
|
||||
// The sphere fit spans the wider side, so a very wide window also needs the extent.
|
||||
const fitRange = (target, bounds) =>
|
||||
Math.max(
|
||||
closeRange,
|
||||
rangeForBoundingSphere(viewer, bounds.radius),
|
||||
extentRange(target, bounds, 1.2),
|
||||
);
|
||||
// Approach long groups in halves so every click gets closer.
|
||||
const halfway = (bounds) =>
|
||||
pose.position ? distance(pose.position, bounds.center) / 2 : Infinity;
|
||||
let bounds = cellBounds(cell);
|
||||
let range = Math.min(halfway(bounds), fitRange(cell, bounds));
|
||||
// If the group overflows the frame at that range, approach its nearest counted cell.
|
||||
if (range < extentRange(cell, bounds)) {
|
||||
const part = nearestPart(cell, pose.position);
|
||||
bounds = cellBounds(part);
|
||||
range = Math.min(halfway(bounds), fitRange(part, bounds));
|
||||
}
|
||||
camera.flyToBounds(bounds, {
|
||||
offset: { heading: 0, pitch: -Math.PI / 2, range },
|
||||
durationS: 1.2,
|
||||
easing: 'cubicInOut',
|
||||
});
|
||||
}
|
||||
|
||||
function focusCamera(cameraId, duration = 2.2) {
|
||||
return focusCctvRecord(
|
||||
layerState._viewer,
|
||||
@@ -196,6 +274,7 @@ export function createNavigation({
|
||||
openingCameraId,
|
||||
reopenNearestCamera,
|
||||
focusCctvRecord,
|
||||
zoomToCell,
|
||||
focusCamera,
|
||||
maybeAutoHop,
|
||||
cctvCycleIndex,
|
||||
|
||||
+66
-18
@@ -60,17 +60,38 @@ export const GEO_PROGRESS_NOTIFY_INTERVAL_MS = 300;
|
||||
|
||||
export const GEO_PROGRESS_NOTIFY_BATCH_LIMIT = 10;
|
||||
|
||||
// View thinning: camera icons show only on or near the screen, and each
|
||||
// camera competes for a world-anchored grid cell sized to about VIEW_CELL_PX
|
||||
// at its distance from the viewer (in power-of-two metre steps, so a pan
|
||||
// keeps the same winners until a camera's distance crosses a step). Cells
|
||||
// smaller than VIEW_MIN_CELL_M do not thin:
|
||||
// close up every camera shows, co-located ones included.
|
||||
// View thinning groups cameras into world-anchored cells of about VIEW_CELL_PX
|
||||
// at their distance. Power-of-two metre steps keep cells stable during a pan.
|
||||
// A cell with several cameras draws one count. Its best-ranked camera represents
|
||||
// it in the picker. Cells smaller than VIEW_MIN_CELL_M do not group, so
|
||||
// every camera shows close up.
|
||||
|
||||
export const VIEW_CELL_PX = 40;
|
||||
|
||||
export const VIEW_MIN_CELL_M = 60;
|
||||
|
||||
// Cameras within this horizontal distance in metres share a mount.
|
||||
export const VIEW_SITE_M = 1.5;
|
||||
|
||||
// Cameras on one mount (VIEW_SITE_M) draw side by side,
|
||||
// this many pixels apart, once they show as icons.
|
||||
export const VIEW_SITE_SPREAD_PX = 30;
|
||||
|
||||
// Drawn-terrain reads per view pass for unanswered cameras and for re-reads
|
||||
// of drawn heights. Off-screen cameras can use at most half of the budget.
|
||||
// Remaining reads wait for the next pass.
|
||||
export const VIEW_GROUND_READS = 300;
|
||||
|
||||
/**
|
||||
* The camera icon's drawn size (px). Its SVG is 48 px: 1.25×
|
||||
* near scale on a 2× display draws it at 60 device px, so it is rasterised
|
||||
* past the drawn size to stay sharp there.
|
||||
*/
|
||||
export const CAMERA_ICON_PX = 24;
|
||||
|
||||
// Minimum gap between the outer rims of two separate markers.
|
||||
export const COUNT_MERGE_GAP_PX = 4;
|
||||
|
||||
// Icons this far past the screen edge (fraction of its size) still show, so
|
||||
// a pan does not reveal empty ground before the next view pass.
|
||||
|
||||
@@ -182,28 +203,51 @@ export const DEFAULT_CAMERA_CALIBRATION = Object.freeze({
|
||||
/**
|
||||
* Base64-encoded SVG camera icon for the camera icons. Icons rasterise an
|
||||
* SVG at its own size, so it is 48 px: drawn at 24 px, 1.25× near scale on a
|
||||
* 2× display draws it at 60 device px, and it stays sharp there.
|
||||
* 2× display draws it at 60 device px, and it stays sharp there. Active and
|
||||
* live cameras use cyan art with a billboard tint. Idle cameras use white
|
||||
* and gray art so the billboard green shows true. The overlay draws the
|
||||
* green variant directly.
|
||||
*/
|
||||
|
||||
export const CAMERA_ICON = (() => {
|
||||
function cameraIcon(tint = null) {
|
||||
function tone(original, gray) {
|
||||
if (!tint) return original;
|
||||
const shade = parseInt(gray.slice(1, 3), 16) / 255;
|
||||
return (
|
||||
'#' +
|
||||
tint
|
||||
.slice(1)
|
||||
.match(/../g)
|
||||
.map((channel) =>
|
||||
Math.round(parseInt(channel, 16) * shade)
|
||||
.toString(16)
|
||||
.padStart(2, '0'),
|
||||
)
|
||||
.join('')
|
||||
);
|
||||
}
|
||||
const stroke = tone('#75e7ff', '#ffffff');
|
||||
const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="48" height="48" viewBox="0 0 36 36">
|
||||
<defs>
|
||||
<linearGradient id="lens" x1="0" y1="0" x2="1" y2="1">
|
||||
<stop offset="0%" stop-color="#c9f6ff"/>
|
||||
<stop offset="45%" stop-color="#6fd9ff"/>
|
||||
<stop offset="100%" stop-color="#1a5f78"/>
|
||||
<stop offset="0%" stop-color="${tone('#c9f6ff', '#ffffff')}"/>
|
||||
<stop offset="45%" stop-color="${tone('#6fd9ff', '#dddddd')}"/>
|
||||
<stop offset="100%" stop-color="${tone('#1a5f78', '#666666')}"/>
|
||||
</linearGradient>
|
||||
</defs>
|
||||
<g transform="translate(4 6)">
|
||||
<rect x="0" y="8" width="20" height="9" rx="2.5" fill="#0e1720" stroke="#75e7ff" stroke-width="1.2"/>
|
||||
<rect x="17" y="10" width="10" height="5" rx="1.5" fill="#132433" stroke="#75e7ff" stroke-width="1"/>
|
||||
<circle cx="24" cy="12.5" r="3.1" fill="url(#lens)" stroke="#dbfbff" stroke-width="0.8"/>
|
||||
<rect x="6.4" y="17" width="4.2" height="8.5" rx="1.2" fill="#10212d" stroke="#75e7ff" stroke-width="1"/>
|
||||
<rect x="4.2" y="24" width="8.6" height="2.5" rx="1.1" fill="#0b151d" stroke="#4ecde7" stroke-width="0.8"/>
|
||||
<rect x="0" y="8" width="20" height="9" rx="2.5" fill="${tone('#0e1720', '#181818')}" stroke="${stroke}" stroke-width="1.2"/>
|
||||
<rect x="17" y="10" width="10" height="5" rx="1.5" fill="${tone('#132433', '#222222')}" stroke="${stroke}" stroke-width="1"/>
|
||||
<circle cx="24" cy="12.5" r="3.1" fill="url(#lens)" stroke="${tone('#dbfbff', '#ffffff')}" stroke-width="0.8"/>
|
||||
<rect x="6.4" y="17" width="4.2" height="8.5" rx="1.2" fill="${tone('#10212d', '#202020')}" stroke="${stroke}" stroke-width="1"/>
|
||||
<rect x="4.2" y="24" width="8.6" height="2.5" rx="1.1" fill="${tone('#0b151d', '#151515')}" stroke="${tone('#4ecde7', '#cccccc')}" stroke-width="0.8"/>
|
||||
</g>
|
||||
</svg>`;
|
||||
return 'data:image/svg+xml;base64,' + btoa(svg);
|
||||
})();
|
||||
}
|
||||
|
||||
export const CAMERA_ICON = cameraIcon();
|
||||
export const IDLE_CAMERA_ICON = cameraIcon('#ffffff');
|
||||
|
||||
/**
|
||||
* Seed camera definitions used when no live sources are available.
|
||||
@@ -441,7 +485,11 @@ export const CAMERA_SEEDS = [
|
||||
// Visual style constants: renderer colours, [r, g, b, a] in 0..1
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export const IDLE_CAMERA_COLOR = hexColor('#6be8ff', 0.88);
|
||||
/** Shared accent for idle still cameras and grouped cameras. */
|
||||
export const CAMERA_GREEN = '#5dff8f';
|
||||
export const COUNT_CAMERA_ICON = cameraIcon(CAMERA_GREEN);
|
||||
|
||||
export const IDLE_CAMERA_COLOR = hexColor(CAMERA_GREEN);
|
||||
|
||||
export const ACTIVE_CAMERA_COLOR = hexColor('#ffd97a', 0.95);
|
||||
|
||||
|
||||
@@ -229,9 +229,12 @@ export function createPresentation({
|
||||
// separately from the currently applied frustum ground. Google-3D may
|
||||
// legitimately refine the latter to the rendered mesh, so callers must
|
||||
// not infer the prior by subtracting mount height from live geometry.
|
||||
groundPriorM: Number.isFinite(record.groundPrior?.ellipsoid)
|
||||
? record.groundPrior.ellipsoid
|
||||
: null,
|
||||
// A height read from drawn terrain is unavailable as a Re:Earth prior.
|
||||
groundPriorM:
|
||||
Number.isFinite(record.groundPrior?.ellipsoid) &&
|
||||
record.groundPrior.source !== 'drawn-terrain'
|
||||
? record.groundPrior.ellipsoid
|
||||
: null,
|
||||
intrinsics: camera.intrinsics ? { ...camera.intrinsics } : null,
|
||||
extrinsics: camera.extrinsics ? { ...camera.extrinsics } : null,
|
||||
anchor: camera.anchor ? { ...camera.anchor } : null,
|
||||
@@ -310,16 +313,16 @@ export function createPresentation({
|
||||
}
|
||||
|
||||
/**
|
||||
* `{ id, city, name }` for the active camera, then every camera the view
|
||||
* pass shows: what the camera picker lists. A whole catalog would put tens
|
||||
* of thousands of options in the DOM and slow every layout. The same array
|
||||
* is returned until the view or the active camera changes, so a consumer
|
||||
* can compare it by identity.
|
||||
* `{ id, city, name }` for the active camera, then each camera shown as an
|
||||
* icon and the best-ranked camera of each visible group. A whole catalog
|
||||
* would put tens of thousands of options in the DOM and slow every layout.
|
||||
* Consumers can compare the array by identity until the picker records or
|
||||
* active camera change.
|
||||
* @returns {{id: string, city: string, name: string}[]}
|
||||
*/
|
||||
|
||||
function cameraIndex() {
|
||||
const view = layerState._viewRecords;
|
||||
const view = layerState._pickerRecords;
|
||||
const active = parts.selection.getActiveRecord();
|
||||
const cached = layerState._cameraIndexCache;
|
||||
if (cached?.view === view && cached.active === active) return cached.list;
|
||||
|
||||
+416
-87
@@ -1,7 +1,13 @@
|
||||
import { createCountMarkers } from './countMarkers.js';
|
||||
import { addCellCamera, createCameraCell } from '../../data/cctvCellCounts.js';
|
||||
import { isHeadingEstimated } from './headingConfidence.js';
|
||||
import {
|
||||
ACTIVE_CAMERA_COLOR,
|
||||
CAMERA_ICON,
|
||||
CAMERA_ICON_PX,
|
||||
COUNT_MERGE_GAP_PX,
|
||||
VIEW_SITE_M,
|
||||
IDLE_CAMERA_ICON,
|
||||
IDLE_CAMERA_COLOR,
|
||||
LIVE_CAMERA_COLOR,
|
||||
ACTIVE_COVERAGE_CENTER,
|
||||
@@ -14,6 +20,8 @@ import {
|
||||
VIEW_CELL_PX,
|
||||
VIEW_ICON_MARGIN,
|
||||
VIEW_MIN_CELL_M,
|
||||
VIEW_SITE_SPREAD_PX,
|
||||
VIEW_GROUND_READS,
|
||||
} from './policy.js';
|
||||
import { createIconBook } from '../../render/motion/iconBook.js';
|
||||
import { frustumVolumeGeometryData } from '../../data/cctvViewshed.js';
|
||||
@@ -24,11 +32,21 @@ import {
|
||||
findGlobe,
|
||||
findQuery,
|
||||
} from '../../render/rendererOf.js';
|
||||
import { fromDegrees, WGS84 } from '../../geo/ellipsoid.js';
|
||||
import { heightsOf } from '../../queries/heights.js';
|
||||
import {
|
||||
fromDegrees,
|
||||
fromDegreesInto,
|
||||
toLonLatH,
|
||||
WGS84,
|
||||
} from '../../geo/ellipsoid.js';
|
||||
import { eastNorthUp } from '../../geo/frames.js';
|
||||
import { poseProjector } from '../../geo/frustum.js';
|
||||
import { horizonFrom } from '../../geo/horizon.js';
|
||||
import { distance } from '../../geo/vector.js';
|
||||
import { add, distance, dot, scale, sub } from '../../geo/vector.js';
|
||||
|
||||
const IDLE_ICON_STYLE = { image: IDLE_CAMERA_ICON, color: IDLE_CAMERA_COLOR };
|
||||
const ACTIVE_ICON_STYLE = { image: CAMERA_ICON, color: ACTIVE_CAMERA_COLOR };
|
||||
const LIVE_ICON_STYLE = { image: CAMERA_ICON, color: LIVE_CAMERA_COLOR };
|
||||
|
||||
/** An RGBA colour with another alpha. */
|
||||
const withAlpha = (color, alpha) => [color[0], color[1], color[2], alpha];
|
||||
@@ -46,12 +64,6 @@ const samePoint = (a, b) =>
|
||||
/** Degrees to radians. */
|
||||
const toRadians = (degrees) => (degrees * Math.PI) / 180;
|
||||
|
||||
/**
|
||||
* The camera icon's drawn size (px). Its SVG is 48 px (policy.js): 1.25×
|
||||
* near scale on a 2× display draws it at 60 device px, so it is rasterised
|
||||
* past the drawn size to stay sharp there.
|
||||
*/
|
||||
const CAMERA_ICON_PX = 24;
|
||||
const CAMERA_SCALE_BY_DISTANCE = Object.freeze({
|
||||
near: 350,
|
||||
nearValue: 1.25,
|
||||
@@ -139,6 +151,12 @@ export function createRendering({
|
||||
// with its first camera.
|
||||
set.setColumns?.({ ids: [] });
|
||||
layerState._icons = createIconBook(set);
|
||||
layerState._counts = createCountMarkers(
|
||||
services.overlays?.registerWorldOverlayPaintLane,
|
||||
`cctv:${iconSets}:counts`,
|
||||
refreshViewFromCounts,
|
||||
services.overlays?.keyholeAlpha,
|
||||
);
|
||||
return set.id;
|
||||
}
|
||||
|
||||
@@ -146,6 +164,8 @@ export function createRendering({
|
||||
function destroyCameraIcons() {
|
||||
layerState._icons?.dispose();
|
||||
layerState._icons = null;
|
||||
layerState._counts?.dispose();
|
||||
layerState._counts = null;
|
||||
}
|
||||
|
||||
/** The icon item a camera record draws, idle and shown, at its position. */
|
||||
@@ -153,10 +173,9 @@ export function createRendering({
|
||||
const id = record.camera.id;
|
||||
return {
|
||||
id,
|
||||
pos: copyPoint(record.position),
|
||||
image: CAMERA_ICON,
|
||||
pos: copyPoint(record.spreadPosition ?? record.position),
|
||||
...cameraIconStyleFor(record),
|
||||
size: [CAMERA_ICON_PX, CAMERA_ICON_PX],
|
||||
color: cameraColorFor(record),
|
||||
scale: 1,
|
||||
scaleByDistance: CAMERA_SCALE_BY_DISTANCE,
|
||||
disableDepthTest: Infinity,
|
||||
@@ -195,22 +214,26 @@ export function createRendering({
|
||||
function moveCameraIcon(record) {
|
||||
const icons = layerState._icons;
|
||||
if (!icons || !record.position) return;
|
||||
// A camera drawn beside its mount mates keeps its offset from the mount.
|
||||
if (record.spreadOffset)
|
||||
record.spreadPosition = add(record.position, record.spreadOffset);
|
||||
const pos = record.spreadPosition ?? record.position;
|
||||
const item = icons.item(record.camera.id);
|
||||
// A camera whose icon waited for a position is drawn now.
|
||||
if (!item) {
|
||||
icons.put(cameraIconItem(record));
|
||||
return;
|
||||
}
|
||||
if (samePoint(item.pos, record.position)) return;
|
||||
icons.put({ ...item, pos: copyPoint(record.position) });
|
||||
if (samePoint(item.pos, pos)) return;
|
||||
icons.put({ ...item, pos: copyPoint(pos) });
|
||||
}
|
||||
|
||||
/** Icon color: active wins, then live-capable video feeds, then idle stills. */
|
||||
function cameraColorFor(record) {
|
||||
/** Select the sprite and tint together when a camera changes state. */
|
||||
function cameraIconStyleFor(record) {
|
||||
if (record.camera.id === layerState._activeCameraId)
|
||||
return ACTIVE_CAMERA_COLOR;
|
||||
if (parts.model.isVideoFeedCamera(record.camera)) return LIVE_CAMERA_COLOR;
|
||||
return IDLE_CAMERA_COLOR;
|
||||
return ACTIVE_ICON_STYLE;
|
||||
if (parts.model.isVideoFeedCamera(record.camera)) return LIVE_ICON_STYLE;
|
||||
return IDLE_ICON_STYLE;
|
||||
}
|
||||
|
||||
const {
|
||||
@@ -219,11 +242,14 @@ export function createRendering({
|
||||
focusPassIsNeeded,
|
||||
advanceSpriteFocus,
|
||||
focusAlphaNeedsWrite,
|
||||
nearFarScalarValueAtDistance,
|
||||
} = services.focus;
|
||||
const iconScaleAt = (range) =>
|
||||
nearFarScalarValueAtDistance?.(CAMERA_SCALE_BY_DISTANCE, range) ?? 1;
|
||||
|
||||
/**
|
||||
* Focus modulation rides the layer's existing animation loop; no additional
|
||||
* scene listener is installed. Only camera-icon alpha changes here — coverage
|
||||
* scene listener is installed. Camera and count icons share the fade. Coverage
|
||||
* geometry and monitor-plane styling retain their established cadence.
|
||||
*/
|
||||
|
||||
@@ -276,61 +302,76 @@ export function createRendering({
|
||||
let writes = 0;
|
||||
let transitioning = false;
|
||||
let activeCount = 0;
|
||||
for (const record of records || []) {
|
||||
const id = record.camera?.id;
|
||||
const item = icons?.item(id);
|
||||
if (!item) continue;
|
||||
const position = record.position;
|
||||
const scale = item.scale ?? 1;
|
||||
// CCTV never publishes a tracked focus target, so every icon is ambient.
|
||||
const focus = advanceSpriteFocus(item.meta, {
|
||||
// Keep hidden icons in the state/release pass so the active count cannot
|
||||
// drop while a stale dim alpha remains waiting to reappear.
|
||||
screenPosition:
|
||||
item.show === false || !position ? null : screenPositionFor(position),
|
||||
/**
|
||||
* A changed focus factor for an icon or count. CCTV publishes no tracked
|
||||
* focus target, so every icon is ambient.
|
||||
*/
|
||||
function changedFocus(owner, position, shown, width, height, current) {
|
||||
const focus = advanceSpriteFocus(owner, {
|
||||
// Keep hidden owners in the active count until their dim alpha clears,
|
||||
// so the focus pass keeps running while they recover.
|
||||
screenPosition: shown && position ? screenPositionFor(position) : null,
|
||||
cameraDistance: position ? cameraDistanceFor(position) : Number.NaN,
|
||||
nowMs,
|
||||
target,
|
||||
params,
|
||||
spriteHalfWidthPx: item.size[0] * scale * 0.5,
|
||||
spriteHalfHeightPx: item.size[1] * scale * 0.5,
|
||||
spriteHalfWidthPx: width / 2,
|
||||
spriteHalfHeightPx: height / 2,
|
||||
});
|
||||
transitioning ||= focus.transitioning;
|
||||
if (focus.active) activeCount += 1;
|
||||
// Order-independent narrow amendment to always-visible icons: CCTV
|
||||
// contacts retain a non-zero floor while yielding near the tracked target.
|
||||
if (focusAlphaNeedsWrite(icons.focus(id), focus.factor, params)) {
|
||||
icons.setFocus(id, focus.factor);
|
||||
writes += 1;
|
||||
}
|
||||
if (focus.active) activeCount++;
|
||||
if (!focusAlphaNeedsWrite(current, focus.factor, params)) return null;
|
||||
writes++;
|
||||
return focus.factor;
|
||||
}
|
||||
for (const record of records || []) {
|
||||
const id = record.camera?.id;
|
||||
const item = icons?.item(id);
|
||||
if (!item) continue;
|
||||
const scale = item.scale ?? 1;
|
||||
const factor = changedFocus(
|
||||
item.meta,
|
||||
record.position,
|
||||
item.show !== false,
|
||||
item.size[0] * scale,
|
||||
item.size[1] * scale,
|
||||
icons.focus(id),
|
||||
);
|
||||
if (factor !== null) icons.setFocus(id, factor);
|
||||
}
|
||||
const counts = layerState._counts;
|
||||
const iconWrites = writes;
|
||||
for (const marker of counts?.markers ?? []) {
|
||||
const factor = changedFocus(
|
||||
marker,
|
||||
marker.pos,
|
||||
true,
|
||||
marker.width,
|
||||
marker.height,
|
||||
marker.focus,
|
||||
);
|
||||
if (factor !== null) marker.focus = factor;
|
||||
}
|
||||
if (writes > iconWrites) counts.requestPaint();
|
||||
return { writes, transitioning, activeCount, ran: true };
|
||||
}
|
||||
|
||||
/** During camera motion the timer and settle pass refresh the counts. */
|
||||
function refreshViewFromCounts() {
|
||||
if (!layerState._cameraMoving) refreshHorizonCulling();
|
||||
}
|
||||
|
||||
/**
|
||||
* Updates visual styles (colors, widths, visibility) for all camera icons,
|
||||
* coverage polylines, viewshed volumes, and projection entities based on which
|
||||
* camera is active, whether the layer is enabled, and the current
|
||||
* coverage-mode/projection toggle states.
|
||||
*/
|
||||
/**
|
||||
* Field-test fix (2026-07-06): horizon-culls camera icons on the CPU as the
|
||||
* icon shader does on the GPU. With the globe hidden (Google-3D
|
||||
* regime) nothing writes far-side depth and the icons are always-on-top, so
|
||||
* the shown set (cards, geometry, the picker) must not include London's
|
||||
* cluster from a US viewpoint.
|
||||
*
|
||||
* The same pass thins the view so a large catalog stays readable and cheap:
|
||||
* icons well off screen hide, and each camera competes for a world-anchored
|
||||
* cell sized to VIEW_CELL_PX at its distance (healthiest first, then a stable
|
||||
* id order). The active camera shows whenever it is above the horizon
|
||||
* and near the screen, even in a crowded cell. The shown records become
|
||||
* `_viewRecords`, the working set for geometry, cards and the camera picker;
|
||||
* the array keeps its identity while the shown set is unchanged.
|
||||
* Cull far-side cameras on the CPU because the hidden globe writes no depth.
|
||||
* Group the rest by ground cell. _viewRecords holds the active camera and
|
||||
* every nearby icon outside a count for geometry and cards. Cells smaller
|
||||
* than VIEW_MIN_CELL_M do not form groups. _pickerRecords adds the
|
||||
* best-ranked camera of each visible cell. Both arrays keep their identity
|
||||
* while their contents are unchanged.
|
||||
*
|
||||
* Runs on camera settle, throttled during motion, on resize, enable and
|
||||
* activation changes — never per frame.
|
||||
* @returns {boolean} Whether the shown set changed.
|
||||
* @returns {boolean} Whether the shown set or the picker list changed.
|
||||
*/
|
||||
|
||||
function refreshHorizonCulling() {
|
||||
@@ -365,7 +406,30 @@ export function createRendering({
|
||||
const project = screenProjector(pose, width, height);
|
||||
const pass = (layerState._viewPassId = (layerState._viewPassId || 0) + 1);
|
||||
const shown = [];
|
||||
const picker = [];
|
||||
const cells = new Map();
|
||||
const visibleCells = [];
|
||||
// Drawn terrain where the globe is the surface. The photoreal stack has
|
||||
// no reader, and unloaded tiles return a non-finite height.
|
||||
const heights = heightsOf(layerState._viewer);
|
||||
const globe = findGlobe(layerState._viewer);
|
||||
const groundHeight =
|
||||
findQuery(layerState._viewer) && globe?.isGlobeVisible?.() === true
|
||||
? (lon, lat) => heights.now({ lon, lat }, { against: 'terrain' })
|
||||
: null;
|
||||
const surface = globe?.surfaceVersion?.() ?? 0;
|
||||
const terrainSettled = globe?.isSettled?.('terrain') ?? true;
|
||||
let groundReads = groundHeight ? VIEW_GROUND_READS : 0;
|
||||
let offscreenReads = groundReads / 2;
|
||||
let eyeGround;
|
||||
const column = { x: 0, y: 0, z: 0 };
|
||||
const inReadWindow = (s) =>
|
||||
s &&
|
||||
s.x >= -width &&
|
||||
s.x <= 2 * width &&
|
||||
s.y >= -height &&
|
||||
s.y <= 2 * height;
|
||||
const regrounded = [];
|
||||
for (const record of layerState._records) {
|
||||
const position = record.position;
|
||||
if (!position) continue;
|
||||
@@ -380,48 +444,307 @@ export function createRendering({
|
||||
(vtDotVc * vtDotVc) / (vx * vx + vy * vy + vz * vz) > limbSquared
|
||||
)
|
||||
continue;
|
||||
const screen = project(position);
|
||||
let screen = project(position);
|
||||
let range = distance(position, viewer);
|
||||
// Missing, unresolved and fallback priors can put a mount kilometres
|
||||
// below the terrain, shifting its projection and inflating its cell.
|
||||
// Read nearby mounts again from under half the range, on finer terrain
|
||||
// after loading, or on a different surface.
|
||||
const prior = record.groundPrior;
|
||||
const drawn = prior?.source === 'drawn-terrain';
|
||||
const unanswered =
|
||||
!Number.isFinite(prior?.ellipsoid) || prior.source === 'geoid-fallback';
|
||||
if (
|
||||
!screen ||
|
||||
!(screen.x >= minX && screen.x <= maxX) ||
|
||||
!(screen.y >= minY && screen.y <= maxY)
|
||||
)
|
||||
continue;
|
||||
const dx = position.x - viewer.x;
|
||||
const dy = position.y - viewer.y;
|
||||
const dz = position.z - viewer.z;
|
||||
const cellM =
|
||||
VIEW_CELL_PX *
|
||||
metresPerPixelPerMetre *
|
||||
Math.sqrt(dx * dx + dy * dy + dz * dz);
|
||||
if (record.camera.id === activeId || !(cellM >= VIEW_MIN_CELL_M)) {
|
||||
record.viewPass = pass;
|
||||
groundReads > 0 &&
|
||||
!record.regroundPending &&
|
||||
(unanswered ||
|
||||
(drawn &&
|
||||
(prior.rangeM > 2 * range ||
|
||||
prior.surface !== surface ||
|
||||
(!prior.settled && terrainSettled))))
|
||||
) {
|
||||
let probe = inReadWindow(screen) ? screen : null;
|
||||
if (!probe && unanswered) {
|
||||
// Its height is a guess. Try the ground under the eye instead.
|
||||
if (eyeGround === undefined) {
|
||||
const eye = toLonLatH(viewer);
|
||||
eyeGround = eye ? (groundHeight(eye.lon, eye.lat) ?? null) : null;
|
||||
groundReads--;
|
||||
}
|
||||
if (Number.isFinite(eyeGround)) {
|
||||
fromDegreesInto(
|
||||
record.camera.lon,
|
||||
record.camera.lat,
|
||||
eyeGround + (record.camera.mountHeightM || 0),
|
||||
column,
|
||||
);
|
||||
const at = project(column);
|
||||
if (inReadWindow(at)) probe = at;
|
||||
}
|
||||
}
|
||||
const onScreen =
|
||||
probe &&
|
||||
probe.x >= 0 &&
|
||||
probe.x <= width &&
|
||||
probe.y >= 0 &&
|
||||
probe.y <= height;
|
||||
if (probe && groundReads > 0 && (onScreen || offscreenReads > 0)) {
|
||||
groundReads--;
|
||||
if (!onScreen) offscreenReads--;
|
||||
const ground = groundHeight(record.camera.lon, record.camera.lat);
|
||||
if (Number.isFinite(ground)) {
|
||||
const read = { rangeM: range, surface, settled: terrainSettled };
|
||||
if (drawn && Math.abs(ground - prior.ellipsoid) < 1)
|
||||
Object.assign(prior, read);
|
||||
else if (record.frustumGeometry) {
|
||||
// Recomputing geometry writes draw sets after this pass.
|
||||
record.regroundPending = true;
|
||||
regrounded.push([record, ground, read]);
|
||||
} else parts.ground.adoptDrawnGround(record, ground, read);
|
||||
}
|
||||
}
|
||||
// The probe reuses the projector's result, and the mount may have moved.
|
||||
screen = project(position);
|
||||
range = distance(position, viewer);
|
||||
}
|
||||
const nearScreen =
|
||||
screen &&
|
||||
screen.x >= minX &&
|
||||
screen.x <= maxX &&
|
||||
screen.y >= minY &&
|
||||
screen.y <= maxY;
|
||||
const cellM = VIEW_CELL_PX * metresPerPixelPerMetre * range;
|
||||
if (record.camera.id === activeId) {
|
||||
if (!nearScreen) continue;
|
||||
record.viewPass = record.pickerPass = pass;
|
||||
shown.push(record);
|
||||
picker.push(record);
|
||||
continue;
|
||||
}
|
||||
if (!(cellM >= VIEW_MIN_CELL_M)) {
|
||||
if (!nearScreen) continue;
|
||||
// Too close to group, but a count beside it can still take it in.
|
||||
const cell = createCameraCell(`near:${record.camera.id}`);
|
||||
addCellCamera(cell, record.camera);
|
||||
cell.iconPx = CAMERA_ICON_PX * iconScaleAt(range);
|
||||
cell.winner = record;
|
||||
cell.rank = 0;
|
||||
record.viewCell = cell;
|
||||
visibleCells.push(cell);
|
||||
continue;
|
||||
}
|
||||
const key = worldCellKey(record, cellM);
|
||||
let cell = cells.get(key);
|
||||
if (!cell) {
|
||||
cell = createCameraCell(key);
|
||||
cells.set(key, cell);
|
||||
}
|
||||
addCellCamera(cell, record.camera);
|
||||
if (cell.count === 1) cell.iconPx = CAMERA_ICON_PX * iconScaleAt(range);
|
||||
record.viewCell = cell;
|
||||
if (!nearScreen) continue;
|
||||
// The picker ranks only candidates that were in its padded viewport.
|
||||
if (!cell.winner) visibleCells.push(cell);
|
||||
const rank = viewRank(record);
|
||||
const holder = cells.get(key);
|
||||
if (!holder || rank < holder.rank) cells.set(key, { record, rank });
|
||||
if (rank < cell.rank) {
|
||||
cell.winner = record;
|
||||
cell.rank = rank;
|
||||
}
|
||||
}
|
||||
for (const { record } of cells.values()) {
|
||||
record.viewPass = pass;
|
||||
shown.push(record);
|
||||
// Check each mount mate against counts where its icon will be drawn.
|
||||
const lone = visibleCells.filter((cell) => cell.count === 1);
|
||||
spreadSharedMounts(
|
||||
shown.concat(lone.map((cell) => cell.winner)),
|
||||
pose,
|
||||
metresPerPixelPerMetre,
|
||||
pass,
|
||||
);
|
||||
for (const cell of lone)
|
||||
cell.offsetPx =
|
||||
cell.winner.spreadPass === pass ? cell.winner.spreadPx : 0;
|
||||
// A count stands on the drawn terrain too: its cell may be too far for
|
||||
// its cameras to have been read. Marks each lone camera that a count
|
||||
// marker beside it has taken in.
|
||||
layerState._counts?.update(visibleCells, project, groundHeight);
|
||||
for (const cell of visibleCells) {
|
||||
const record = cell.winner;
|
||||
picker.push(record);
|
||||
record.pickerPass = pass;
|
||||
if (cell.count === 1 && !cell.absorbed) {
|
||||
record.viewPass = pass;
|
||||
shown.push(record);
|
||||
}
|
||||
}
|
||||
clearActiveOfCounts(project, pose, metresPerPixelPerMetre, pass);
|
||||
const writes = [];
|
||||
let coverageChanged = false;
|
||||
let cardsChanged = false;
|
||||
for (const record of layerState._records) {
|
||||
const item = patchedCameraIcon(record.camera.id, {
|
||||
show: record.viewPass === pass,
|
||||
});
|
||||
const cell = record.viewCell;
|
||||
record.viewCell = null;
|
||||
const grouped = Boolean(
|
||||
cell?.winner && (cell.count > 1 || cell.absorbed),
|
||||
);
|
||||
if (grouped !== !!record.viewGrouped) {
|
||||
const id = record.camera.id;
|
||||
coverageChanged ||= layerState._coverageCohort?.has(id);
|
||||
cardsChanged ||=
|
||||
layerState._cardIds?.has(id) || layerState._hoverCardId === id;
|
||||
}
|
||||
record.viewGrouped = grouped;
|
||||
const fields = { show: record.viewPass === pass };
|
||||
if (record.spreadPass === pass) {
|
||||
const drawn = layerState._icons?.item(record.camera.id)?.pos;
|
||||
if (!drawn || !samePoint(drawn, record.spreadPosition))
|
||||
fields.pos = copyPoint(record.spreadPosition);
|
||||
} else if (record.spreadPosition) {
|
||||
// No longer beside a mount mate: back onto its own position.
|
||||
record.spreadOffset = null;
|
||||
record.spreadPosition = null;
|
||||
fields.pos = copyPoint(record.position);
|
||||
}
|
||||
const item = patchedCameraIcon(record.camera.id, fields);
|
||||
if (item) writes.push(item);
|
||||
}
|
||||
writeCameraIcons(writes);
|
||||
if (regrounded.length) queueMicrotask(() => reground(regrounded));
|
||||
const previous = layerState._viewRecords;
|
||||
const changed =
|
||||
previous.length !== shown.length ||
|
||||
previous.some((record) => record.viewPass !== pass);
|
||||
if (changed) layerState._viewRecords = shown;
|
||||
return changed;
|
||||
const oldPicker = layerState._pickerRecords ?? [];
|
||||
const pickerChanged =
|
||||
picker.length !== oldPicker.length ||
|
||||
oldPicker.some((record) => record.pickerPass !== pass);
|
||||
if (pickerChanged) layerState._pickerRecords = picker;
|
||||
if (coverageChanged) refreshCoverageStyles();
|
||||
if (cardsChanged) parts.cards.pushAmbientCardEntries();
|
||||
return changed || pickerChanged;
|
||||
}
|
||||
|
||||
/**
|
||||
* Cameras that have geometry take the drawn terrain after the pass that
|
||||
* read it, then the view is passed again from their new positions.
|
||||
*/
|
||||
function reground(entries) {
|
||||
let changed = false;
|
||||
for (const [record, ground, read] of entries) {
|
||||
record.regroundPending = false;
|
||||
changed =
|
||||
parts.ground.adoptDrawnGround(record, ground, read) !== null || changed;
|
||||
}
|
||||
if (!changed) return;
|
||||
if (refreshHorizonCulling()) parts.geometryQueue.enqueueViewGeometry();
|
||||
parts.presentation.notifyListeners();
|
||||
}
|
||||
|
||||
/**
|
||||
* Cameras on one mount would draw as one icon with several callouts. Among
|
||||
* icon candidates, those within VIEW_SITE_M horizontally get draw positions
|
||||
* side by side in id order, `VIEW_SITE_SPREAD_PX` apart on screen. A mate
|
||||
* absorbed by a count keeps its place in the row. Geometry and cards stay
|
||||
* on the mount.
|
||||
*/
|
||||
function spreadSharedMounts(shown, pose, metresPerPixelPerMetre, pass) {
|
||||
const { right, direction, position: eye } = pose;
|
||||
if (!right || !direction || shown.length < 2) return;
|
||||
const grid = new Map();
|
||||
const mounts = [];
|
||||
const axes = eastNorthUp(eye);
|
||||
for (const record of shown) {
|
||||
// Sea-level coordinates compare horizontal distance across longitude
|
||||
// and latitude boundaries, including the antimeridian.
|
||||
const p = fromDegrees(record.camera.lon, record.camera.lat, 0);
|
||||
const col = Math.floor(dot(p, axes.x) / VIEW_SITE_M);
|
||||
const row = Math.floor(dot(p, axes.y) / VIEW_SITE_M);
|
||||
let mount;
|
||||
for (let i = col - 1; !mount && i <= col + 1; i++)
|
||||
for (let j = row - 1; !mount && j <= row + 1; j++)
|
||||
mount = grid
|
||||
.get(`${i}:${j}`)
|
||||
?.find((site) => distance(p, site.p) <= VIEW_SITE_M);
|
||||
if (!mount) {
|
||||
mount = { p, mates: [] };
|
||||
mounts.push(mount);
|
||||
const key = `${col}:${row}`;
|
||||
if (!grid.has(key)) grid.set(key, []);
|
||||
grid.get(key).push(mount);
|
||||
}
|
||||
mount.mates.push(record);
|
||||
}
|
||||
for (const { mates } of mounts) {
|
||||
if (mates.length < 2) continue;
|
||||
mates.sort((a, b) => a.camera.id.localeCompare(b.camera.id));
|
||||
for (let i = 0; i < mates.length; i++) {
|
||||
const record = mates[i];
|
||||
const p = record.position;
|
||||
// A pixel's width on the ground grows with depth along the view.
|
||||
const depth =
|
||||
(p.x - eye.x) * direction.x +
|
||||
(p.y - eye.y) * direction.y +
|
||||
(p.z - eye.z) * direction.z;
|
||||
const px = (i - (mates.length - 1) / 2) * VIEW_SITE_SPREAD_PX;
|
||||
record.spreadPx = px;
|
||||
const metres = px * metresPerPixelPerMetre * depth;
|
||||
record.spreadOffset = scale(right, metres);
|
||||
record.spreadPosition = add(p, record.spreadOffset);
|
||||
record.spreadPass = pass;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Only counts visible outside the HUD push the active icon aside. */
|
||||
function clearActiveOfCounts(project, pose, metresPerPixelPerMetre, pass) {
|
||||
const markers = layerState._counts?.markers;
|
||||
for (const marker of markers ?? []) marker.besideActive = false;
|
||||
if (!layerState._activeCameraId) return;
|
||||
const record = layerState._recordById.get(layerState._activeCameraId);
|
||||
if (
|
||||
record?.viewPass !== pass ||
|
||||
!markers?.length ||
|
||||
!pose.right ||
|
||||
!pose.direction
|
||||
)
|
||||
return;
|
||||
const spread = record.spreadPass === pass;
|
||||
const p = spread ? record.spreadPosition : record.position;
|
||||
const screen = project(p);
|
||||
if (!screen) return;
|
||||
const { x, y } = screen;
|
||||
const half =
|
||||
(CAMERA_ICON_PX * 1.25 * iconScaleAt(distance(p, pose.position))) / 2;
|
||||
const spans = [];
|
||||
for (const marker of markers) {
|
||||
const at = project(marker.pos);
|
||||
if (
|
||||
!at ||
|
||||
Math.abs(y - at.y) >= marker.height / 2 + half + COUNT_MERGE_GAP_PX
|
||||
)
|
||||
continue;
|
||||
marker.besideActive = true;
|
||||
if (marker.hudHidden) continue;
|
||||
const reach = marker.width / 2 + half + COUNT_MERGE_GAP_PX;
|
||||
spans.push([at.x - reach, at.x + reach]);
|
||||
}
|
||||
// Leave the entire overlapping interval, including an adjacent count.
|
||||
spans.sort((a, b) => a[0] - b[0]);
|
||||
let left = Infinity,
|
||||
right = -Infinity;
|
||||
for (const [start, end] of spans) {
|
||||
if (start >= right) {
|
||||
if (left < x && x < right) break;
|
||||
left = start;
|
||||
right = end;
|
||||
} else right = Math.max(right, end);
|
||||
}
|
||||
if (!(left < x && x < right)) return;
|
||||
const shift = x - left < right - x ? left - x : right - x;
|
||||
const depth = dot(sub(p, pose.position), pose.direction);
|
||||
const offset = scale(pose.right, shift * metresPerPixelPerMetre * depth);
|
||||
record.spreadOffset = spread ? add(record.spreadOffset, offset) : offset;
|
||||
record.spreadPosition = add(record.position, record.spreadOffset);
|
||||
record.spreadPass = pass;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -526,6 +849,7 @@ export function createRendering({
|
||||
);
|
||||
parts.projection.clearProjectionOverlay();
|
||||
if (layerState._icons) layerState._icons.show = false;
|
||||
layerState._counts?.hide();
|
||||
parts.projection.pauseInactiveProjectionFeeds(null);
|
||||
}
|
||||
|
||||
@@ -535,8 +859,12 @@ export function createRendering({
|
||||
const activeRecord = parts.selection.getActiveRecord();
|
||||
parts.geometry.ensureActiveCoverageEntities(activeRecord);
|
||||
const activeId = activeRecord?.camera.id || null;
|
||||
const coverageVisible =
|
||||
parts.geometry.buildCoverageVisibleSet(activeRecord);
|
||||
const cohort = parts.geometry.buildCoverageVisibleSet(activeRecord);
|
||||
layerState._coverageCohort = cohort;
|
||||
const coverageVisible = new Set();
|
||||
for (const id of cohort) {
|
||||
if (!layerState._recordById.get(id)?.viewGrouped) coverageVisible.add(id);
|
||||
}
|
||||
// Drawn coverage needs geometry too (geometryQueue's working set).
|
||||
layerState._coverageVisibleIds = coverageVisible;
|
||||
const coverageOn = layerState._coverageMode !== 'off';
|
||||
@@ -553,7 +881,7 @@ export function createRendering({
|
||||
for (const record of layerState._records) {
|
||||
const isActive = record.camera.id === activeId;
|
||||
const icon = patchedCameraIcon(record.camera.id, {
|
||||
color: cameraColorFor(record),
|
||||
...cameraIconStyleFor(record),
|
||||
scale: isActive ? 1.25 : 1.0,
|
||||
});
|
||||
if (icon) restyled.push(icon);
|
||||
@@ -865,6 +1193,7 @@ export function createRendering({
|
||||
* @returns {string|null}
|
||||
*/
|
||||
function pickCameraIdAt(position) {
|
||||
if (layerState._counts?.pickedCell(position)) return null;
|
||||
let hit = null;
|
||||
try {
|
||||
hit = findQuery(layerState._viewer)?.pick(position.x, position.y) ?? null;
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
// src/layers/cctv/rendering.test.mjs
|
||||
// Icon colors under focus de-emphasis (#1200): the focus pass fades each icon
|
||||
// from the same base color the coverage refresh assigns, so a video-feed camera
|
||||
// stays violet while it dims instead of falling back to the idle cyan.
|
||||
// stays violet while it dims instead of falling back to the idle green.
|
||||
// Teardown lets go of the icon set of the viewer that drew it.
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
@@ -114,29 +114,80 @@ test('focus de-emphasis fades each icon from its own color', () => {
|
||||
}
|
||||
});
|
||||
|
||||
test('focus uses the painted half-width and half-height of each count', () => {
|
||||
const markers = [
|
||||
{ width: 40, height: 40 },
|
||||
{ width: 72, height: 58 },
|
||||
];
|
||||
const sizes = [];
|
||||
const rendering = createRendering({
|
||||
state: { _counts: { markers } },
|
||||
services: {
|
||||
focus: {
|
||||
focusPassIsNeeded: () => true,
|
||||
advanceSpriteFocus(_owner, { spriteHalfWidthPx, spriteHalfHeightPx }) {
|
||||
sizes.push([spriteHalfWidthPx, spriteHalfHeightPx]);
|
||||
return { factor: 1 };
|
||||
},
|
||||
focusAlphaNeedsWrite: () => false,
|
||||
},
|
||||
},
|
||||
});
|
||||
rendering.applyCctvFocusDeemphasis({});
|
||||
assert.deepEqual(sizes, [
|
||||
[20, 20],
|
||||
[36, 29],
|
||||
]);
|
||||
});
|
||||
|
||||
test('the icons go with the viewer that drew them, whichever tears down', () => {
|
||||
const first = {};
|
||||
const second = {};
|
||||
const one = bindFakeDraw(first);
|
||||
const two = bindFakeDraw(second);
|
||||
const state = { _viewer: first };
|
||||
const lanes = [];
|
||||
const overlays = {
|
||||
registerWorldOverlayPaintLane(name, paint, options) {
|
||||
const lane = {
|
||||
name,
|
||||
paint,
|
||||
options,
|
||||
setActive() {},
|
||||
unregister() {
|
||||
this.disposed = true;
|
||||
},
|
||||
};
|
||||
lanes.push(lane);
|
||||
return lane;
|
||||
},
|
||||
};
|
||||
const { createCameraIcons, destroyCameraIcons } = createRendering({
|
||||
state,
|
||||
services: { focus: {} },
|
||||
services: { focus: {}, overlays },
|
||||
parts: {},
|
||||
source: {},
|
||||
});
|
||||
try {
|
||||
const old = createCameraIcons(first);
|
||||
assert.equal(one.draw.sets.size, 1);
|
||||
assert.equal(lanes[0].name, 'ambient-label');
|
||||
assert.equal(lanes[0].options.target, 'shared');
|
||||
assert.equal(lanes[0].options.active, false);
|
||||
state._viewer = second;
|
||||
const current = createCameraIcons(second);
|
||||
assert.notEqual(old, current);
|
||||
assert.equal(one.draw.sets.get(old).disposed, true, 'a re-init lets go');
|
||||
assert.equal(two.draw.sets.get(current).disposed, false);
|
||||
assert.equal(lanes[0].disposed, true);
|
||||
lanes[0].paint({});
|
||||
|
||||
destroyCameraIcons();
|
||||
assert.equal(two.draw.sets.get(current).disposed, true);
|
||||
assert.equal(state._icons, null);
|
||||
assert.equal(lanes[1].disposed, true);
|
||||
lanes[1].paint({});
|
||||
assert.equal(state._counts, null);
|
||||
} finally {
|
||||
one.unbind();
|
||||
two.unbind();
|
||||
@@ -376,3 +427,35 @@ test('a pose with no perspective field of view is projected by the renderer', ()
|
||||
unbind();
|
||||
}
|
||||
});
|
||||
|
||||
test('hover picks the underlying camera only outside a painted count', () => {
|
||||
const viewer = {};
|
||||
const icon = { set: 'icons', id: 'camera' };
|
||||
let picks = 0;
|
||||
const unbind = bindRenderer(viewer, {
|
||||
query: {
|
||||
pick() {
|
||||
picks++;
|
||||
return icon;
|
||||
},
|
||||
},
|
||||
});
|
||||
try {
|
||||
const state = {
|
||||
_viewer: viewer,
|
||||
_counts: { pickedCell: ({ x }) => (x <= 17 ? {} : null) },
|
||||
_icons: { setId: icon.set, has: () => true },
|
||||
_recordById: new Map([[icon.id, {}]]),
|
||||
};
|
||||
const rendering = createRendering({
|
||||
state,
|
||||
services: { focus: {} },
|
||||
parts: {},
|
||||
});
|
||||
assert.equal(rendering.pickCameraIdAt({ x: 17, y: 0 }), null);
|
||||
assert.equal(picks, 0);
|
||||
assert.equal(rendering.pickCameraIdAt({ x: 18, y: 0 }), icon.id);
|
||||
} finally {
|
||||
unbind();
|
||||
}
|
||||
});
|
||||
@@ -1,3 +1,7 @@
|
||||
import {
|
||||
CCTV_COUNT_CARD_SOURCE_ID,
|
||||
CCTV_OVERLAY_SOURCE_ID,
|
||||
} from '../../data/cctvCards.js';
|
||||
import { isTrackingClickGesture } from '../../data/trackingClickGesture.js';
|
||||
|
||||
export function createSelection({
|
||||
@@ -7,7 +11,13 @@ export function createSelection({
|
||||
source,
|
||||
}) {
|
||||
const { CCTV_ACTIVATION_RESULT } = services.activation;
|
||||
const { resolvePickId } = services.picking;
|
||||
const {
|
||||
resolvePickId,
|
||||
findPickOwner,
|
||||
isOwnedByOtherLayer,
|
||||
isUnderOtherCard,
|
||||
} = services.picking;
|
||||
const OWN_CARD_SOURCES = [CCTV_OVERLAY_SOURCE_ID, CCTV_COUNT_CARD_SOURCE_ID];
|
||||
|
||||
/**
|
||||
* Returns the camera record for the currently active camera. A stale ID falls
|
||||
@@ -29,6 +39,49 @@ export function createSelection({
|
||||
return fallback;
|
||||
}
|
||||
|
||||
/** Whether another layer's scene object owns the click at this count. */
|
||||
function sceneTakesCountClick(event) {
|
||||
const top = event.topHit;
|
||||
if (!top) return false;
|
||||
const drawHit = event.drawHit;
|
||||
if (drawHit) {
|
||||
// Unowned fills, such as earthquake discs, let the count take the click.
|
||||
if (parts.rendering.extractPickedCameraId(drawHit)) return false;
|
||||
const id = resolvePickId(drawHit);
|
||||
return id !== null && Boolean(isOwnedByOtherLayer?.('cctv', id));
|
||||
}
|
||||
const id = resolvePickId(top);
|
||||
return id !== null && findPickOwner?.(id) !== 'cctv';
|
||||
}
|
||||
|
||||
/** Leave other layers' cards to the caller since clickCard also calls this. */
|
||||
function clickedCount(event) {
|
||||
if (
|
||||
!isTrackingClickGesture(event.gesture) ||
|
||||
!layerState._enabled ||
|
||||
event.overlay
|
||||
)
|
||||
return null;
|
||||
const cell = layerState._counts?.pickedCell(event.screenPosition);
|
||||
if (!cell) return null;
|
||||
const { x, y } = event.screenPosition;
|
||||
if (
|
||||
layerState._cctvOverlayHost?.hitTest(x, y, {
|
||||
sourceId: CCTV_OVERLAY_SOURCE_ID,
|
||||
})?.entryId
|
||||
)
|
||||
return null;
|
||||
return sceneTakesCountClick(event) ? null : cell;
|
||||
}
|
||||
|
||||
/** The count marker as the card on top of a click it takes, for every layer's clickCard. */
|
||||
function countClickCard(event) {
|
||||
const cell = clickedCount(event);
|
||||
return cell
|
||||
? { sourceId: CCTV_COUNT_CARD_SOURCE_ID, entryId: String(cell.key ?? '') }
|
||||
: null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Bind CCTV activation to clean taps. Drag-like and long-press gestures do
|
||||
* not reach camera activation or focus dispatch.
|
||||
@@ -41,6 +94,12 @@ export function createSelection({
|
||||
function bindCctvWorldClickGesture(input, onClick) {
|
||||
return input.onClick((event) => {
|
||||
if (!isTrackingClickGesture(event.gesture)) return;
|
||||
const cell = clickedCount(event);
|
||||
// Another layer's card or label painted above the count takes the click.
|
||||
if (cell && !isUnderOtherCard?.(event, OWN_CARD_SOURCES)) {
|
||||
parts.navigation.zoomToCell(cell);
|
||||
return;
|
||||
}
|
||||
onClick(event);
|
||||
});
|
||||
}
|
||||
@@ -139,11 +198,11 @@ export function createSelection({
|
||||
// is looking at ever asks.
|
||||
void parts.ground.resolveFootprintGround(record);
|
||||
record.activationDone = true;
|
||||
parts.rendering.refreshCoverageStyles();
|
||||
// The active camera's icon always shows; the previously active one
|
||||
// competes for its cell again. Its coverage neighbours join the working
|
||||
// set and are queued for grounding.
|
||||
// The active icon always shows and the previous one rejoins its cell.
|
||||
// Restyle coverage after the view pass sets grouping. Its coverage
|
||||
// neighbours join the working set and are queued for grounding.
|
||||
parts.rendering.refreshHorizonCulling();
|
||||
parts.rendering.refreshCoverageStyles();
|
||||
parts.geometryQueue.enqueueViewGeometry();
|
||||
// The newly active camera leaves the ambient ring (its monitor plane takes
|
||||
// over); the freed slot re-fills on this same pass.
|
||||
@@ -218,6 +277,7 @@ export function createSelection({
|
||||
return {
|
||||
getActiveRecord,
|
||||
bindCctvWorldClickGesture,
|
||||
countClickCard,
|
||||
setActiveCamera,
|
||||
deactivateActiveCamera,
|
||||
cctvEmptyClickDeselects,
|
||||
|
||||
@@ -1,6 +1,10 @@
|
||||
import * as picking from '../../data/pickRegistry.js';
|
||||
import { CCTV_COUNT_CARD_SOURCE_ID } from '../../data/cctvCards.js';
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { CCTV_ACTIVATION_RESULT } from '../../cctvFocusRequest.js';
|
||||
import { bindRenderer } from '../../render/rendererOf.js';
|
||||
import { createNavigation } from './navigation.js';
|
||||
import { createSelection } from './selection.js';
|
||||
|
||||
function makeSelection(sourceKind) {
|
||||
@@ -52,3 +56,162 @@ test('same-camera selection notifies browser-overlay feeds so playback can retry
|
||||
assert.equal(fixture.state._activeCameraReselection, 1);
|
||||
assert.equal(fixture.notifications(), 1);
|
||||
});
|
||||
|
||||
test('a count click preserves the provisional opening pick until the view settles', () => {
|
||||
const viewer = {};
|
||||
const flights = [];
|
||||
const unbind = bindRenderer(viewer, {
|
||||
camera: {
|
||||
pose: () => ({ fovy: Math.PI / 3, aspectRatio: 1 }),
|
||||
flyToBounds: (bounds) => flights.push(bounds),
|
||||
},
|
||||
canvas: { height: 600 },
|
||||
});
|
||||
try {
|
||||
const cell = { west: 1, east: 2, south: 0, north: 0, low: 0, high: 0 };
|
||||
const state = {
|
||||
_enabled: true,
|
||||
_viewer: viewer,
|
||||
_openingCameraProvisional: true,
|
||||
_activeCameraId: 'opening',
|
||||
_counts: {
|
||||
pickedCell: (point) => (point?.x === 14 && point.y === 26 ? cell : null),
|
||||
},
|
||||
};
|
||||
const parts = {};
|
||||
parts.navigation = createNavigation({ state, parts });
|
||||
const selection = createSelection({
|
||||
state,
|
||||
parts,
|
||||
services: { activation: {}, picking: {} },
|
||||
});
|
||||
const click = selection.bindCctvWorldClickGesture(
|
||||
{ onClick: (fn) => fn },
|
||||
() => {
|
||||
assert.fail('a count click reached activation or deselection');
|
||||
},
|
||||
);
|
||||
click({
|
||||
screenPosition: { x: 14, y: 26 },
|
||||
get drawHit() {
|
||||
assert.fail('the camera underneath was picked');
|
||||
},
|
||||
gesture: { travelPx: 0, durationMs: 20 },
|
||||
});
|
||||
assert.equal(flights.length, 1);
|
||||
assert.equal(state._activeCameraId, 'opening');
|
||||
assert.equal(state._openingCameraProvisional, true);
|
||||
} finally {
|
||||
unbind();
|
||||
}
|
||||
});
|
||||
|
||||
test("a count click yields to a card above it and to another layer's object, not to a CCTV icon", () => {
|
||||
let zooms = 0,
|
||||
clicks = 0;
|
||||
const selection = createSelection({
|
||||
services: { activation: {}, picking },
|
||||
state: {
|
||||
_enabled: true,
|
||||
_counts: { pickedCell: () => ({}) },
|
||||
_cctvOverlayHost: {
|
||||
hitTest: (x) => (x === 14 ? { entryId: 'cam-1' } : null),
|
||||
},
|
||||
},
|
||||
parts: {
|
||||
navigation: { zoomToCell: () => zooms++ },
|
||||
rendering: {
|
||||
extractPickedCameraId: (hit) =>
|
||||
hit?.set === 'cctv-icons' ? hit.id : null,
|
||||
},
|
||||
},
|
||||
});
|
||||
const click = selection.bindCctvWorldClickGesture(
|
||||
{ onClick: (fn) => fn },
|
||||
() => clicks++,
|
||||
);
|
||||
picking.registerPickOwner('cctv', (id) => id.startsWith('cam-'));
|
||||
picking.registerPickOwner('flights', (id) => id === 'abc' || id === 'cam-2');
|
||||
try {
|
||||
for (const [x, topHit, expected] of [
|
||||
[14, null, [0, 1]],
|
||||
[20, { set: 'flights', id: 'abc' }, [0, 2]],
|
||||
[20, { set: 'cctv-icons', id: 'cam-2' }, [1, 2]],
|
||||
[20, null, [2, 2]],
|
||||
[20, { set: 'flights', id: 'cam-2' }, [2, 3]],
|
||||
]) {
|
||||
click({
|
||||
screenPosition: { x, y: 26 },
|
||||
topHit,
|
||||
drawHit: topHit,
|
||||
gesture: { travelPx: 0, durationMs: 20 },
|
||||
});
|
||||
assert.deepEqual([zooms, clicks], expected);
|
||||
}
|
||||
} finally {
|
||||
picking.unregisterPickOwner('cctv');
|
||||
picking.unregisterPickOwner('flights');
|
||||
}
|
||||
});
|
||||
|
||||
test('a count click is the card on top for every layer, unless the count yields', () => {
|
||||
let zooms = 0;
|
||||
let clicks = 0;
|
||||
const selection = createSelection({
|
||||
services: { activation: {}, picking },
|
||||
state: {
|
||||
_enabled: true,
|
||||
_counts: { pickedCell: (p) => (p?.x === 20 ? { key: 'g' } : null) },
|
||||
_cctvOverlayHost: { hitTest: () => null },
|
||||
},
|
||||
parts: {
|
||||
navigation: { zoomToCell: () => zooms++ },
|
||||
rendering: {
|
||||
extractPickedCameraId: (hit) =>
|
||||
hit?.set === 'cctv-icons' ? hit.id : null,
|
||||
},
|
||||
},
|
||||
});
|
||||
const click = selection.bindCctvWorldClickGesture(
|
||||
{ onClick: (fn) => fn },
|
||||
() => clicks++,
|
||||
);
|
||||
const event = (topHit = null, x = 20, durationMs = 20) => ({
|
||||
screenPosition: { x, y: 26 },
|
||||
topHit,
|
||||
drawHit: topHit,
|
||||
gesture: { travelPx: 0, durationMs },
|
||||
});
|
||||
picking.registerClickClaim('cctv', selection.countClickCard);
|
||||
picking.registerPickOwner('flights', (id) => id === 'abc');
|
||||
try {
|
||||
const aircraftFirst = event();
|
||||
assert.equal(picking.isUnderOtherCard(aircraftFirst), true);
|
||||
assert.deepEqual(picking.clickCard(aircraftFirst), {
|
||||
sourceId: CCTV_COUNT_CARD_SOURCE_ID,
|
||||
entryId: 'g',
|
||||
});
|
||||
click(aircraftFirst);
|
||||
assert.deepEqual([zooms, clicks], [1, 0]);
|
||||
|
||||
const cctvFirst = event();
|
||||
click(cctvFirst);
|
||||
assert.equal(picking.isUnderOtherCard(cctvFirst), true);
|
||||
assert.deepEqual([zooms, clicks], [2, 0]);
|
||||
|
||||
for (const [e, claimed, expected] of [
|
||||
[event({ set: 'flights', id: 'abc' }), false, [2, 1]],
|
||||
[event({ set: 'cctv-icons', id: 'cam-2' }), true, [3, 1]],
|
||||
[event(null, 20, 1000), false, [3, 1]],
|
||||
[event(null, 60), false, [3, 2]],
|
||||
[{ ...event(), overlay: true }, false, [3, 3]],
|
||||
]) {
|
||||
assert.equal(picking.isUnderOtherCard(e), claimed);
|
||||
click(e);
|
||||
assert.deepEqual([zooms, clicks], expected);
|
||||
}
|
||||
} finally {
|
||||
picking.unregisterClickClaim('cctv');
|
||||
picking.unregisterPickOwner('flights');
|
||||
}
|
||||
});
|
||||
@@ -15,6 +15,7 @@ export function createState({ services }) {
|
||||
|
||||
/** The catalog's camera icons: the icon book over their draw set. */
|
||||
layerState._icons = null;
|
||||
layerState._counts = null;
|
||||
|
||||
layerState._records = [];
|
||||
|
||||
@@ -95,10 +96,14 @@ export function createState({ services }) {
|
||||
// work over these, not the whole catalog.
|
||||
|
||||
layerState._viewRecords = [];
|
||||
// The view records plus the best-ranked camera of each visible cell.
|
||||
layerState._pickerRecords = [];
|
||||
|
||||
// Coverage ids refreshCoverageStyles last drew: part of the geometry
|
||||
// working set even when their icons are thinned out.
|
||||
|
||||
// The active camera's coverage neighbours, including grouped ones. A
|
||||
// grouping change in this cohort requires a coverage refresh.
|
||||
layerState._coverageCohort = null;
|
||||
// The cohort minus grouped cameras, last drawn by refreshCoverageStyles.
|
||||
// These belong to the geometry working set even off screen.
|
||||
layerState._coverageVisibleIds = new Set();
|
||||
|
||||
// View pass triggers besides camera settle: an interval while the camera
|
||||
@@ -113,6 +118,9 @@ export function createState({ services }) {
|
||||
// The camera port the moveStart/moveEnd listeners are on.
|
||||
|
||||
layerState._viewListenerCamera = null;
|
||||
// Reruns the view pass when terrain loads or the surface changes.
|
||||
layerState._surfaceListener = null;
|
||||
layerState._surfaceListenerGlobe = null;
|
||||
|
||||
// A motion pass changed the shown set and the settle pass has not yet told
|
||||
// subscribers; the camera pose the last view pass ran at.
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
import { createCountMarkers } from './countMarkers.js';
|
||||
import { createIconBook } from '../../render/motion/iconBook.js';
|
||||
|
||||
/** A draw set that draws nothing, for the icon book the tests read. */
|
||||
@@ -90,6 +91,7 @@ export function createTesting({ state: layerState, services, parts, source }) {
|
||||
* @param {'off'|'on'|'viewshed'} [options.coverageMode='on'] Coverage mode.
|
||||
* @param {boolean} [options.showProjection=false] Projection visibility.
|
||||
* @param {Map<string, Object>} [options.healthById] Health rows by camera id.
|
||||
* @param {Function} [options.registerPaintLane] Receives the count painter.
|
||||
* @returns {void}
|
||||
*/
|
||||
|
||||
@@ -102,6 +104,7 @@ export function createTesting({ state: layerState, services, parts, source }) {
|
||||
showProjection = false,
|
||||
healthById = new Map(),
|
||||
openingCameraProvisional = false,
|
||||
registerPaintLane,
|
||||
} = {}) {
|
||||
layerState._viewer = viewer;
|
||||
layerState._records = Array.isArray(records) ? records : [];
|
||||
@@ -123,12 +126,20 @@ export function createTesting({ state: layerState, services, parts, source }) {
|
||||
layerState._showProjection = !!showProjection;
|
||||
layerState._healthById = healthById;
|
||||
layerState._viewRecords = [];
|
||||
layerState._pickerRecords = [];
|
||||
layerState._cameraIndexCache = null;
|
||||
layerState._coverageVisibleIds = new Set();
|
||||
layerState._neighborCountCache = null;
|
||||
layerState._coverageCohort = null;
|
||||
// A real book (over a set that draws nothing): every record gets its
|
||||
// icon as init adds it.
|
||||
layerState._icons = createIconBook(testIconSet());
|
||||
layerState._counts?.dispose();
|
||||
layerState._counts = createCountMarkers(
|
||||
registerPaintLane,
|
||||
'cctv:test:counts',
|
||||
parts.rendering.refreshHorizonCulling,
|
||||
);
|
||||
for (const record of layerState._records)
|
||||
if (record?.camera?.id) parts.rendering.addCameraIcon(record);
|
||||
}
|
||||
@@ -148,6 +159,7 @@ export function createTesting({ state: layerState, services, parts, source }) {
|
||||
for (const runtime of layerState._projectionEntities)
|
||||
if (runtime?.plane) planes[runtime.plane.id] = runtime.plane;
|
||||
return {
|
||||
counts: layerState._counts,
|
||||
gizmo: layerState._gizmo?.partsForTest() ?? {},
|
||||
coverage,
|
||||
planes,
|
||||
|
||||
@@ -5,6 +5,7 @@ import { createCredits } from './credits.js';
|
||||
import { createPickRouter } from './pickRouter.js';
|
||||
import { createSelection } from './selection.js';
|
||||
import { createViewerHost } from './viewerHost.js';
|
||||
import { subscribePhotoViewers } from './photoViewers.js';
|
||||
import { filtersOf, requiresKeyIdFor, validateProviders } from './registry.js';
|
||||
import { normalizeFilter, resolveFilter, sameFilter } from './filter.js';
|
||||
import { worldTimeFor } from '../../time/worldClock.js';
|
||||
@@ -703,6 +704,22 @@ export function createStreetLevelLayer({
|
||||
attachViewerHost(element) {
|
||||
parts.viewerHost.attach(element);
|
||||
},
|
||||
/**
|
||||
* Receive every presentation of the photo viewer the providers whose
|
||||
* photos are plain files (KartaView, Panoramax) mount in the viewer
|
||||
* host, the one mounted last (see photoViewers.js), starting with the
|
||||
* current one; null while none is mounted. A view draws it (see
|
||||
* photoViewer.js); with nobody subscribed, those providers' photos
|
||||
* cannot open.
|
||||
* @param {(view: ?object) => void} listener
|
||||
* @returns {() => void} Unsubscribe.
|
||||
*/
|
||||
subscribePhotoViewer(listener) {
|
||||
return subscribePhotoViewers(
|
||||
[...state.providers.values()].map((entry) => entry.instance.viewer),
|
||||
listener,
|
||||
);
|
||||
},
|
||||
setProviderEnabled,
|
||||
openImage,
|
||||
/**
|
||||
|
||||
@@ -2176,3 +2176,41 @@ test('proceed() is asked after the lookup: false loads nothing and clears the sp
|
||||
true,
|
||||
);
|
||||
});
|
||||
|
||||
test('subscribePhotoViewer hands on the photo viewer a provider presents, the later mount’s while two overlap', async (t) => {
|
||||
const presenting = (id, pickPrefix) => {
|
||||
const provider = fakeProvider({ id, pickPrefix });
|
||||
const create = provider.create;
|
||||
const listeners = new Set();
|
||||
provider.present = (view) => {
|
||||
for (const listener of [...listeners]) listener(view);
|
||||
};
|
||||
provider.create = (context) => {
|
||||
const instance = create(context);
|
||||
instance.viewer.subscribeView = (listener) => {
|
||||
listeners.add(listener);
|
||||
listener(null);
|
||||
return () => listeners.delete(listener);
|
||||
};
|
||||
return instance;
|
||||
};
|
||||
return provider;
|
||||
};
|
||||
const a = presenting('mapillary', 'mly:');
|
||||
const b = presenting('other', 'oth:');
|
||||
const { layer } = await enabledLayer(t, [a, b]);
|
||||
const shown = [];
|
||||
const unsubscribe = layer.subscribePhotoViewer((view) => shown.push(view));
|
||||
assert.deepEqual(shown, [null], 'the current one first');
|
||||
const supersede = () => {};
|
||||
const viewA = { host: 'a', mountKey: 1, actions: { supersede } };
|
||||
const viewB = { host: 'b', mountKey: 2, actions: { supersede } };
|
||||
a.present(viewA);
|
||||
b.present(viewB);
|
||||
a.present(null);
|
||||
b.present(null);
|
||||
assert.deepEqual(shown, [null, viewA, viewB, null]);
|
||||
unsubscribe();
|
||||
a.present(viewA);
|
||||
assert.equal(shown.length, 4, 'unsubscribed');
|
||||
});
|
||||
@@ -36,6 +36,14 @@ function tooManyPixels(width, height) {
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Keys for each mount's and each canvas's elements, never reused by any
|
||||
* viewer: a view that sees one viewer unmount and another mount in the same
|
||||
* tick still draws them fresh elements (a destroyed renderer leaves its
|
||||
* canvas's context lost).
|
||||
*/
|
||||
let viewKeys = 0;
|
||||
|
||||
/** Panorama texture widths: enough for a docked viewer, and for an expanded one. */
|
||||
const PANO_MID_SIZE = Object.freeze([2048, 1024]);
|
||||
export const PANO_FULL_SIZE = Object.freeze([4096, 2048]);
|
||||
@@ -213,6 +221,21 @@ export function panoSizeFor(canvasPixels, fovDeg) {
|
||||
* or pinch to zoom), and ‹ › to step along the sequence (also ← →). Poses
|
||||
* follow the view direction.
|
||||
*
|
||||
* The adapter draws nothing itself. It presents the viewer through
|
||||
* `subscribeView()` (the street-level layer's `subscribePhotoViewer()`): a
|
||||
* fresh `{host, mountKey, providerId, label, alt, kind, src, fit, canvasKey,
|
||||
* dragging, prevLabel, prevDisabled, nextLabel, nextDisabled, actions}` on
|
||||
* each change,
|
||||
* or null while unmounted. A view draws it into `host` (the application's is
|
||||
* `StreetLevelPhotoViewer`), forwards its events to `actions` and hands each
|
||||
* element back through `actions.attach(name, element)`: the panorama canvas
|
||||
* to draw on, the frame and picture to measure, the root and buttons to
|
||||
* keep focus. Each mount has its own `mountKey`, and a new `canvasKey` asks
|
||||
* for a fresh canvas (a lost WebGL context): neither is ever reused.
|
||||
* `actions.supersede()` tells a viewer another one is drawn in its place:
|
||||
* it unmounts, and a mount still waiting to be drawn fails as closed.
|
||||
* Mounting with no view subscribed fails.
|
||||
*
|
||||
* Photos are normalized by the provider: `{id, sequenceId, lon, lat,
|
||||
* heading, isPano, capturedAt}` plus whatever its `sources` read.
|
||||
*
|
||||
@@ -249,11 +272,18 @@ export function createPhotoViewer({
|
||||
}) {
|
||||
const LOAD_FAILED = `The ${name} photo could not be loaded`;
|
||||
const listeners = new Set();
|
||||
/** The elements the view handed back. */
|
||||
let root = null;
|
||||
let picture = null;
|
||||
let canvas = null;
|
||||
let prevButton = null;
|
||||
let nextButton = null;
|
||||
/** What the view draws; null while unmounted. */
|
||||
let presented = null;
|
||||
const viewListeners = new Set();
|
||||
/** Waiting for the view's root (a mount), or its canvas: a fresh one, or the next draw. */
|
||||
const rootWaiters = new Set();
|
||||
const canvasWaiters = new Set();
|
||||
let renderer = null;
|
||||
/** WebGL failed once: 360° photos show their front view instead. */
|
||||
let rendererFailed = false;
|
||||
@@ -265,8 +295,6 @@ export function createPhotoViewer({
|
||||
let drag = null;
|
||||
let poseFrame = 0;
|
||||
let removeListeners = [];
|
||||
/** The document the viewer was built in (new canvases come from it). */
|
||||
let documentOf = null;
|
||||
/** A context loss's look direction, for the reopen of that photo. */
|
||||
let restoreView = null;
|
||||
/** The panel's viewer box, where Esc is listened for (null: the root). */
|
||||
@@ -354,44 +382,71 @@ export function createPhotoViewer({
|
||||
});
|
||||
}
|
||||
|
||||
/** Present the viewer with `patch` applied (null: nothing to draw). */
|
||||
function present(patch) {
|
||||
if (patch === null) presented = null;
|
||||
else if (presented) presented = { ...presented, ...patch };
|
||||
else return;
|
||||
for (const listener of [...viewListeners]) listener(presented);
|
||||
}
|
||||
|
||||
/** Settle everything waiting on the view (it drew, or it went). */
|
||||
function wake(waiters) {
|
||||
for (const resolve of waiters) resolve();
|
||||
waiters.clear();
|
||||
}
|
||||
|
||||
/** The panorama canvas once the view has drawn it, or the open stopped. */
|
||||
function canvasReady(signal) {
|
||||
if (canvas || !presented || signal?.aborted) return Promise.resolve();
|
||||
return new Promise((resolve) => {
|
||||
canvasWaiters.add(resolve);
|
||||
signal?.addEventListener?.('abort', resolve, { once: true });
|
||||
});
|
||||
}
|
||||
|
||||
/** The view's next draw (it hands the canvas back each time), or none coming. */
|
||||
function nextDraw(signal) {
|
||||
if (!presented || signal?.aborted) return Promise.resolve();
|
||||
return new Promise((resolve) => {
|
||||
canvasWaiters.add(resolve);
|
||||
signal?.addEventListener?.('abort', resolve, { once: true });
|
||||
});
|
||||
}
|
||||
|
||||
function syncButtons() {
|
||||
const enabled = Boolean(photo?.sequenceId) && showing !== null;
|
||||
if (prevButton) prevButton.disabled = !enabled;
|
||||
if (nextButton) nextButton.disabled = !enabled;
|
||||
present({ prevDisabled: !enabled, nextDisabled: !enabled });
|
||||
if (enabled) checkEnds(photo);
|
||||
}
|
||||
|
||||
/** Disable ‹ or › at once where the sequence ends (it also warms the neighbours). */
|
||||
function checkEnds(target) {
|
||||
for (const [delta, button] of [
|
||||
[-1, prevButton],
|
||||
[1, nextButton],
|
||||
])
|
||||
for (const delta of [-1, 1])
|
||||
step(target, delta).then(
|
||||
(id) => {
|
||||
if (photo === target && button && !id) disable(button);
|
||||
if (photo === target && presented && !id) disable(delta);
|
||||
},
|
||||
() => {},
|
||||
);
|
||||
}
|
||||
|
||||
/** Disable a step button, keeping keyboard focus in the viewer. */
|
||||
function disable(button) {
|
||||
if (button.ownerDocument?.activeElement === button) root?.focus?.();
|
||||
button.disabled = true;
|
||||
function disable(delta) {
|
||||
const button = delta < 0 ? prevButton : nextButton;
|
||||
if (button && button.ownerDocument?.activeElement === button)
|
||||
root?.focus?.();
|
||||
present(delta < 0 ? { prevDisabled: true } : { nextDisabled: true });
|
||||
}
|
||||
|
||||
function show(kind) {
|
||||
showing = kind;
|
||||
if (picture) picture.hidden = kind !== 'flat';
|
||||
if (canvas) canvas.hidden = kind !== 'pano';
|
||||
if (root) root.dataset.kind = kind || '';
|
||||
present({ kind: kind || '' });
|
||||
syncButtons();
|
||||
}
|
||||
|
||||
function applyRenderMode() {
|
||||
if (picture)
|
||||
picture.style.objectFit = renderMode === 'fill' ? 'cover' : 'contain';
|
||||
present({ fit: renderMode === 'fill' ? 'cover' : 'contain' });
|
||||
}
|
||||
|
||||
function ensureRenderer() {
|
||||
@@ -410,6 +465,9 @@ export function createPhotoViewer({
|
||||
* with it: drop the renderer, and show the photo again on a new one.
|
||||
*/
|
||||
function onContextLost(event) {
|
||||
// Only the canvas on screen: a replaced one has nothing left to lose.
|
||||
const from = event?.currentTarget ?? event?.target;
|
||||
if (from && from !== canvas) return;
|
||||
event.preventDefault?.();
|
||||
const lost = renderer;
|
||||
renderer = null;
|
||||
@@ -421,11 +479,10 @@ export function createPhotoViewer({
|
||||
} catch {
|
||||
/* already gone */
|
||||
}
|
||||
// A lost canvas hands back its lost context: draw on a new element.
|
||||
const fresh = makeCanvas(documentOf);
|
||||
fresh.hidden = canvas.hidden;
|
||||
canvas.replaceWith?.(fresh);
|
||||
canvas = fresh;
|
||||
// A lost canvas hands back its lost context: the view draws a new
|
||||
// element in its place and hands it back.
|
||||
canvas = null;
|
||||
present({ canvasKey: ++viewKeys });
|
||||
// Show the photo again through the core, unless a newer one is opening.
|
||||
if (showing === 'pano' && photo && openingId === null) {
|
||||
const again = photo.id;
|
||||
@@ -435,20 +492,6 @@ export function createPhotoViewer({
|
||||
}
|
||||
}
|
||||
|
||||
/** The panorama canvas, wired for drag, pinch, wheel and context loss. */
|
||||
function makeCanvas(doc) {
|
||||
const element = doc.createElement('canvas');
|
||||
element.className = 'sl-photo-pano';
|
||||
element.hidden = true;
|
||||
listen(element, 'pointerdown', onPointerDown);
|
||||
listen(element, 'pointermove', onPointerMove);
|
||||
listen(element, 'pointerup', onPointerUp);
|
||||
listen(element, 'pointercancel', onPointerUp);
|
||||
listen(element, 'wheel', onWheel, { passive: false });
|
||||
listen(element, 'webglcontextlost', onContextLost);
|
||||
return element;
|
||||
}
|
||||
|
||||
/**
|
||||
* Step along the sequence from the photo showing, or from the one on its
|
||||
* way after an earlier press, and open it through the core.
|
||||
@@ -469,8 +512,7 @@ export function createPhotoViewer({
|
||||
// Closed, or another photo was opened meanwhile.
|
||||
if ((openingId ?? photo?.id) !== fromId) return;
|
||||
if (!nextId) {
|
||||
const button = delta < 0 ? prevButton : nextButton;
|
||||
if (button && photo?.id === fromId) disable(button);
|
||||
if (presented && photo?.id === fromId) disable(delta);
|
||||
return;
|
||||
}
|
||||
openingId = nextId;
|
||||
@@ -504,7 +546,7 @@ export function createPhotoViewer({
|
||||
y: event.clientY,
|
||||
view: renderer.getView(),
|
||||
};
|
||||
canvas.classList.add('sl-photo-dragging');
|
||||
present({ dragging: true });
|
||||
}
|
||||
|
||||
function onPointerMove(event) {
|
||||
@@ -532,7 +574,7 @@ export function createPhotoViewer({
|
||||
if (pointers.size < 2) pinch = null;
|
||||
if (!drag || event.pointerId !== drag.id) return;
|
||||
drag = null;
|
||||
canvas.classList.remove('sl-photo-dragging');
|
||||
present({ dragging: false });
|
||||
}
|
||||
|
||||
function onWheel(event) {
|
||||
@@ -603,51 +645,67 @@ export function createPhotoViewer({
|
||||
);
|
||||
}
|
||||
|
||||
/** The elements the view hands back, by name. */
|
||||
const ELEMENTS = {
|
||||
root: (element) => (root = element),
|
||||
picture: (element) => (picture = element),
|
||||
canvas: (element) => (canvas = element),
|
||||
prev: (element) => (prevButton = element),
|
||||
next: (element) => (nextButton = element),
|
||||
};
|
||||
|
||||
/** Present the viewer in `host`; its view draws it and hands back its elements. */
|
||||
function build(host) {
|
||||
const doc = host.ownerDocument;
|
||||
documentOf = doc;
|
||||
root = doc.createElement('div');
|
||||
root.className = 'sl-photo-viewer';
|
||||
root.dataset.provider = providerId;
|
||||
root.tabIndex = 0;
|
||||
root.setAttribute('role', 'group');
|
||||
root.setAttribute(
|
||||
'aria-label',
|
||||
t(
|
||||
// Events from a view drawn for an earlier mount are not this one's.
|
||||
const current =
|
||||
(handler) =>
|
||||
(...args) => {
|
||||
if (presented?.actions === actions) handler(...args);
|
||||
};
|
||||
const actions = {
|
||||
attach(name, element) {
|
||||
if (presented?.actions !== actions || !element) return;
|
||||
ELEMENTS[name]?.(element);
|
||||
if (name === 'root') wake(rootWaiters);
|
||||
if (name === 'canvas') wake(canvasWaiters);
|
||||
},
|
||||
keydown: current(onKeyDown),
|
||||
pointerdown: current(onPointerDown),
|
||||
pointermove: current(onPointerMove),
|
||||
pointerup: current(onPointerUp),
|
||||
wheel: current(onWheel),
|
||||
contextLost: current(onContextLost),
|
||||
supersede: current(() => adapter.unmount()),
|
||||
step: current((delta, event) => {
|
||||
event?.stopPropagation?.();
|
||||
stepBy(delta);
|
||||
}),
|
||||
};
|
||||
presented = {
|
||||
host,
|
||||
mountKey: ++viewKeys,
|
||||
providerId,
|
||||
label: t(
|
||||
'{name} photo. ← and → step along the sequence. On a 360° photo, drag or use Shift+← →, ↑ ↓ to look around, and + − to zoom',
|
||||
{ name },
|
||||
),
|
||||
);
|
||||
picture = doc.createElement('img');
|
||||
picture.className = 'sl-photo-flat';
|
||||
picture.alt = t('{name} street-level photo', { name });
|
||||
picture.draggable = false;
|
||||
picture.hidden = true;
|
||||
canvas = makeCanvas(doc);
|
||||
const nav = (label, glyph, delta) => {
|
||||
const button = doc.createElement('button');
|
||||
button.type = 'button';
|
||||
button.className = `sl-photo-step sl-photo-step-${delta < 0 ? 'prev' : 'next'}`;
|
||||
button.textContent = glyph;
|
||||
button.title = label;
|
||||
button.setAttribute('aria-label', label);
|
||||
button.disabled = true;
|
||||
listen(button, 'click', (event) => {
|
||||
event.stopPropagation();
|
||||
stepBy(delta);
|
||||
});
|
||||
return button;
|
||||
alt: t('{name} street-level photo', { name }),
|
||||
kind: undefined,
|
||||
src: null,
|
||||
fit: renderMode === 'fill' ? 'cover' : 'contain',
|
||||
canvasKey: ++viewKeys,
|
||||
dragging: false,
|
||||
prevLabel: t('Previous photo in this sequence (←)'),
|
||||
prevDisabled: true,
|
||||
nextLabel: t('Next photo in this sequence (→)'),
|
||||
nextDisabled: true,
|
||||
actions,
|
||||
};
|
||||
prevButton = nav(t('Previous photo in this sequence (←)'), '‹', -1);
|
||||
nextButton = nav(t('Next photo in this sequence (→)'), '›', 1);
|
||||
root.append(picture, canvas, prevButton, nextButton);
|
||||
host.append(root);
|
||||
listen(root, 'keydown', onKeyDown);
|
||||
present({});
|
||||
// The viewer's box in the panel; without one, the root's own handler
|
||||
// takes Esc (one listener per element and type).
|
||||
escapeTarget = host.closest?.('.sl-viewer-wrap') ?? null;
|
||||
if (escapeTarget) listen(escapeTarget, 'keydown', onEscapeKey);
|
||||
applyRenderMode();
|
||||
}
|
||||
|
||||
function teardown() {
|
||||
@@ -655,13 +713,17 @@ export function createPhotoViewer({
|
||||
pinch = null;
|
||||
for (const remove of removeListeners) remove();
|
||||
removeListeners = [];
|
||||
escapeTarget = null;
|
||||
if (poseFrame) cancelAnimationFrame(poseFrame);
|
||||
poseFrame = 0;
|
||||
drag = null;
|
||||
renderer?.destroy();
|
||||
renderer = null;
|
||||
root?.remove();
|
||||
// The view takes its elements away.
|
||||
present(null);
|
||||
root = picture = canvas = prevButton = nextButton = null;
|
||||
wake(rootWaiters);
|
||||
wake(canvasWaiters);
|
||||
showing = null;
|
||||
photo = null;
|
||||
}
|
||||
@@ -738,7 +800,7 @@ export function createPhotoViewer({
|
||||
try {
|
||||
const image = await loadAs(url, { crossOrigin: false, signal });
|
||||
if (seq !== openSeq || photo !== target || showing !== 'flat') return;
|
||||
picture.src = image.src;
|
||||
present({ src: image.src });
|
||||
sharp.shown = url;
|
||||
requestRender();
|
||||
} catch {
|
||||
@@ -770,7 +832,8 @@ export function createPhotoViewer({
|
||||
/** The sharp panorama this viewer needs now: 2,048 docked, 4,096 expanded. */
|
||||
function panoSizeNow() {
|
||||
const ratio = Math.min(globalThis.devicePixelRatio || 1, 2);
|
||||
const width = (canvas?.clientWidth || 0) * ratio;
|
||||
// The canvas fills the frame; until the view shows it, it measures 0.
|
||||
const width = (canvas?.clientWidth || root?.clientWidth || 0) * ratio;
|
||||
return panoSizeFor(width, renderer?.getView().fov ?? PANO_FOV_DEFAULT_DEG);
|
||||
}
|
||||
|
||||
@@ -801,8 +864,15 @@ export function createPhotoViewer({
|
||||
else if (!keepView || showing !== 'pano')
|
||||
renderer.setView({ yaw: 0, pitch: 0, fov: PANO_FOV_DEFAULT_DEG });
|
||||
photo = target;
|
||||
// Shown first: a hidden canvas measures 0 and would be sized 1×1.
|
||||
// Shown first: a hidden canvas measures 0 and would be sized 1×1. The
|
||||
// view draws it shown on a microtask, and hands the canvas back then.
|
||||
show('pano');
|
||||
await nextDraw(signal);
|
||||
if (seq !== openSeq || !renderer) {
|
||||
image.close?.();
|
||||
if (seq !== openSeq) return false;
|
||||
throw new Error(LOAD_FAILED);
|
||||
}
|
||||
renderer.setImage(image);
|
||||
panoWidth = first.width || 0;
|
||||
// A sharper version of the photo before was dropped by `open`; one of
|
||||
@@ -827,7 +897,7 @@ export function createPhotoViewer({
|
||||
}
|
||||
if (!image) throw failure || new Error(LOAD_FAILED);
|
||||
if (seq !== openSeq) return false;
|
||||
picture.src = image.src;
|
||||
present({ src: image.src });
|
||||
flatSharp = { shown: null, loading: null };
|
||||
photo = target;
|
||||
show('flat');
|
||||
@@ -837,6 +907,11 @@ export function createPhotoViewer({
|
||||
async function openPhoto(id, seq, keepView, signal) {
|
||||
const target = await getPhoto(id, { signal });
|
||||
if (seq !== openSeq) return;
|
||||
// A canvas lost moments ago: the view is drawing its replacement.
|
||||
if (sources.hasPano(target) && !rendererFailed) {
|
||||
await canvasReady(signal);
|
||||
if (seq !== openSeq) return;
|
||||
}
|
||||
let shown = false;
|
||||
if (sources.hasPano(target) && ensureRenderer()) {
|
||||
try {
|
||||
@@ -857,10 +932,17 @@ export function createPhotoViewer({
|
||||
const adapter = {
|
||||
async mount(host) {
|
||||
if (!host) throw new Error('Street Level viewer has no host element');
|
||||
if (root && root.parentNode === host) return;
|
||||
if (root && presented?.host === host) return;
|
||||
teardown();
|
||||
rendererFailed = false;
|
||||
if (!viewListeners.size)
|
||||
throw new Error('Street Level photo viewer has no view to draw it');
|
||||
// Resolves once the view drew the viewer, or it was unmounted meanwhile.
|
||||
const drawn = new Promise((resolve) => rootWaiters.add(resolve));
|
||||
build(host);
|
||||
if (!root) await drawn;
|
||||
// Unmounted or superseded before the view drew it.
|
||||
if (!root) throw new Error('Street-level viewer was closed');
|
||||
},
|
||||
|
||||
/** Resolves once the photo is on screen and its pose was emitted. */
|
||||
@@ -896,7 +978,7 @@ export function createPhotoViewer({
|
||||
photo = null;
|
||||
flatSharp = { shown: null, loading: null };
|
||||
show(null);
|
||||
if (picture) picture.removeAttribute('src');
|
||||
present({ src: null });
|
||||
renderer?.clear?.();
|
||||
},
|
||||
|
||||
@@ -937,6 +1019,18 @@ export function createPhotoViewer({
|
||||
listeners.add(listener);
|
||||
return () => listeners.delete(listener);
|
||||
},
|
||||
|
||||
/**
|
||||
* Receive every presentation of the viewer, starting with the current
|
||||
* one (null while unmounted).
|
||||
* @param {(view: ?object) => void} listener
|
||||
* @returns {() => void} Unsubscribe.
|
||||
*/
|
||||
subscribeView(listener) {
|
||||
viewListeners.add(listener);
|
||||
listener(presented);
|
||||
return () => viewListeners.delete(listener);
|
||||
},
|
||||
};
|
||||
return adapter;
|
||||
}
|
||||
@@ -56,7 +56,7 @@ function setup() {
|
||||
pending.get(url).reject(new Error('gone'));
|
||||
pending.delete(url);
|
||||
};
|
||||
return { viewer, loads, images, release, fail, host: fakeHost() };
|
||||
return { viewer, loads, images, release, fail, host: fakeHost(viewer) };
|
||||
}
|
||||
|
||||
const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
|
||||
@@ -146,7 +146,7 @@ test('Esc: the docked viewer offers it to the provider first; expanded, it is th
|
||||
onEscape: () => ++asked > 0,
|
||||
load: async (url) => ({ src: url }),
|
||||
});
|
||||
const host = fakeHost();
|
||||
const host = fakeHost(viewer);
|
||||
await viewer.mount(host);
|
||||
const root = host.children[0];
|
||||
const press = () => {
|
||||
@@ -195,7 +195,7 @@ test('a sharp panorama still downloading when another photo opens is aborted', a
|
||||
});
|
||||
t.after(() => delete globalThis.devicePixelRatio);
|
||||
globalThis.devicePixelRatio = 1;
|
||||
const host = fakeHost();
|
||||
const host = fakeHost(viewer);
|
||||
await viewer.mount(host);
|
||||
parts(host).canvas.clientWidth = 1800;
|
||||
await viewer.open('a');
|
||||
@@ -235,7 +235,7 @@ test('a lost WebGL context while the first panorama loads releases its bitmap',
|
||||
};
|
||||
},
|
||||
});
|
||||
const host = fakeHost();
|
||||
const host = fakeHost(viewer);
|
||||
await viewer.mount(host);
|
||||
const opening = viewer.open('a');
|
||||
assert.ok(await until(() => land !== null), 'the panorama is loading');
|
||||
@@ -262,7 +262,7 @@ test('docked, Esc anywhere in the viewer’s box (toolbar, caption) is offered t
|
||||
onEscape: () => ++asked > 0,
|
||||
load: async (url) => ({ src: url }),
|
||||
});
|
||||
const host = fakeHost();
|
||||
const host = fakeHost(viewer);
|
||||
const wrap = fakeHost();
|
||||
host.closest = (selector) => (selector === '.sl-viewer-wrap' ? wrap : null);
|
||||
await viewer.mount(host);
|
||||
@@ -363,7 +363,7 @@ function heldViewer() {
|
||||
pending.get(url).resolve({ src: url });
|
||||
pending.delete(url);
|
||||
};
|
||||
return { viewer, pending, signals, loads, release, host: fakeHost() };
|
||||
return { viewer, pending, signals, loads, release, host: fakeHost(viewer) };
|
||||
}
|
||||
|
||||
test('a new open, a close or an unmount stops the downloads of the open before it', async () => {
|
||||
@@ -439,7 +439,6 @@ test('a resize while another photo opens does not upgrade the photo still shown'
|
||||
});
|
||||
|
||||
test('a panorama is always decoded at a bounded size', async () => {
|
||||
const env = heldViewer();
|
||||
const options = [];
|
||||
const viewer = createPhotoViewer({
|
||||
providerId: 'test',
|
||||
@@ -461,7 +460,7 @@ test('a panorama is always decoded at a bounded size', async () => {
|
||||
destroy() {},
|
||||
}),
|
||||
});
|
||||
await viewer.mount(env.host);
|
||||
await viewer.mount(fakeHost(viewer));
|
||||
await viewer.open('a');
|
||||
// SOURCES' panoFirst names no size: the viewer still bounds it.
|
||||
assert.deepEqual(options[0].resize, [2048, 1024]);
|
||||
@@ -549,7 +548,7 @@ test('a browser without :fullscreen / :popover-open (Safari < 16.4) still opens
|
||||
onEscape: () => ++asked > 0,
|
||||
load: async (url) => ({ src: url }),
|
||||
});
|
||||
const host = fakeHost();
|
||||
const host = fakeHost(viewer);
|
||||
await viewer.mount(host);
|
||||
const root = host.children[0];
|
||||
// Safari 16.0–16.3: neither pseudo-class parses, so closest() throws.
|
||||
@@ -571,3 +570,69 @@ test('a browser without :fullscreen / :popover-open (Safari < 16.4) still opens
|
||||
assert.doesNotThrow(() => root.fire('keydown', event), 'Esc does not throw');
|
||||
assert.equal(asked, 1, 'Esc reaches the provider');
|
||||
});
|
||||
|
||||
test('a panorama reopened after a lost context waits for the view’s fresh canvas', async () => {
|
||||
const canvases = [];
|
||||
const reopened = [];
|
||||
const viewer = createPhotoViewer({
|
||||
providerId: 'test',
|
||||
name: 'Test',
|
||||
sources: SOURCES,
|
||||
getPhoto: async (id) => PHOTOS[id],
|
||||
step: async () => null,
|
||||
onStep() {},
|
||||
onReopen: (id) => reopened.push(id),
|
||||
load: async (url) => ({ src: url }),
|
||||
createRenderer: (canvas) => {
|
||||
canvases.push(canvas);
|
||||
return {
|
||||
setImage() {},
|
||||
setView() {},
|
||||
getView: () => ({ yaw: 0, pitch: 0, fov: 80 }),
|
||||
resize() {},
|
||||
clear() {},
|
||||
destroy() {},
|
||||
};
|
||||
},
|
||||
});
|
||||
// A view that draws on a microtask, as Vue does, handing its canvas back
|
||||
// each time, but draws a replacement canvas only a while after it is
|
||||
// asked.
|
||||
let shown = null;
|
||||
let canvas = { name: 'canvas', clientWidth: 400 };
|
||||
let late = null;
|
||||
viewer.subscribeView((view) => {
|
||||
const first = view && !shown;
|
||||
const replaced = view && shown && view.canvasKey !== shown.canvasKey;
|
||||
shown = view;
|
||||
if (!view) return;
|
||||
queueMicrotask(() => {
|
||||
if (first)
|
||||
for (const name of ['root', 'picture', 'prev', 'next'])
|
||||
view.actions.attach(name, { name, clientWidth: 400 });
|
||||
if (replaced) {
|
||||
canvas = null;
|
||||
late = () => {
|
||||
canvas = { name: 'canvas again', clientWidth: 400 };
|
||||
shown.actions.attach('canvas', canvas);
|
||||
};
|
||||
}
|
||||
if (canvas) view.actions.attach('canvas', canvas);
|
||||
});
|
||||
});
|
||||
await viewer.mount({});
|
||||
await viewer.open('a');
|
||||
assert.equal(shown.kind, 'pano');
|
||||
shown.actions.contextLost({ preventDefault() {} });
|
||||
assert.deepEqual(reopened, ['a']);
|
||||
const opening = viewer.open('a');
|
||||
await tick();
|
||||
assert.equal(canvases.length, 1, 'no renderer without a canvas');
|
||||
late();
|
||||
await opening;
|
||||
assert.deepEqual(
|
||||
canvases.map((canvas) => canvas.name),
|
||||
['canvas', 'canvas again'],
|
||||
);
|
||||
assert.equal(shown.kind, 'pano', 'not the front view');
|
||||
});
|
||||
@@ -0,0 +1,45 @@
|
||||
/**
|
||||
* Receive the photo viewer to draw, out of several photo viewers mounting
|
||||
* in one host (see photoViewer.js): the one mounted last, by its mount key,
|
||||
* whatever order they present in. One view draws one viewer, so a viewer
|
||||
* still mounting when a later one presents is superseded: it settles its
|
||||
* mount as closed and stops presenting. Starts with the current one (null
|
||||
* while none is mounted).
|
||||
* @param {Iterable<{subscribeView?: Function}>} viewers
|
||||
* @param {(view: ?object) => void} listener
|
||||
* @returns {() => void} Unsubscribe.
|
||||
*/
|
||||
export function subscribePhotoViewers(viewers, listener) {
|
||||
// Each viewer's current presentation.
|
||||
const shown = new Map();
|
||||
let ready = false;
|
||||
let last;
|
||||
const publish = () => {
|
||||
let next = null;
|
||||
for (const view of shown.values())
|
||||
if (!next || view.mountKey > next.mountKey) next = view;
|
||||
if (!ready || next === last) return;
|
||||
last = next;
|
||||
listener(next);
|
||||
// The others are not drawn: a mount still waiting on the view never
|
||||
// would be.
|
||||
if (next)
|
||||
for (const view of [...shown.values()])
|
||||
if (view.mountKey < next.mountKey) view.actions.supersede();
|
||||
};
|
||||
const unsubscribes = [];
|
||||
for (const viewer of viewers) {
|
||||
const unsubscribe = viewer?.subscribeView?.((view) => {
|
||||
if (view) shown.set(viewer, view);
|
||||
else shown.delete(viewer);
|
||||
publish();
|
||||
});
|
||||
if (typeof unsubscribe === 'function') unsubscribes.push(unsubscribe);
|
||||
}
|
||||
ready = true;
|
||||
publish();
|
||||
if (last === undefined) listener((last = null));
|
||||
return () => {
|
||||
for (const unsubscribe of unsubscribes.splice(0)) unsubscribe();
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
import assert from 'node:assert/strict';
|
||||
import test from 'node:test';
|
||||
import { subscribePhotoViewers } from './photoViewers.js';
|
||||
|
||||
/**
|
||||
* A photo viewer whose presentations the test sends; `superseded` counts.
|
||||
* Unlike photoViewer.js it keeps presenting once superseded, so the order
|
||||
* is seen to come from the mount keys alone.
|
||||
*/
|
||||
function fakeViewer() {
|
||||
const listeners = new Set();
|
||||
const viewer = {
|
||||
superseded: 0,
|
||||
view(mountKey) {
|
||||
return {
|
||||
mountKey,
|
||||
actions: { supersede: () => viewer.superseded++ },
|
||||
};
|
||||
},
|
||||
present(view) {
|
||||
for (const listener of [...listeners]) listener(view);
|
||||
},
|
||||
subscribeView(listener) {
|
||||
listeners.add(listener);
|
||||
listener(null);
|
||||
return () => listeners.delete(listener);
|
||||
},
|
||||
};
|
||||
return viewer;
|
||||
}
|
||||
|
||||
test('the later mount is drawn, whatever order the viewers present in', () => {
|
||||
const a = fakeViewer();
|
||||
const b = fakeViewer();
|
||||
const shown = [];
|
||||
const unsubscribe = subscribePhotoViewers([a, b], (view) => shown.push(view));
|
||||
assert.deepEqual(shown, [null], 'the current one first');
|
||||
const first = a.view(1);
|
||||
a.present(first);
|
||||
const later = b.view(2);
|
||||
b.present(later);
|
||||
assert.equal(shown.at(-1), later);
|
||||
assert.equal(a.superseded, 1, 'the earlier mount is told it is not drawn');
|
||||
// The earlier viewer presents again: it does not take the view back.
|
||||
a.present({ ...first, kind: 'flat' });
|
||||
assert.equal(shown.at(-1), later);
|
||||
assert.equal(shown.length, 3);
|
||||
b.present(null);
|
||||
assert.equal(shown.at(-1).mountKey, 1, 'the only one presenting');
|
||||
a.present(null);
|
||||
assert.equal(shown.at(-1), null);
|
||||
unsubscribe();
|
||||
a.present(first);
|
||||
assert.equal(shown.length, 5, 'unsubscribed');
|
||||
});
|
||||
@@ -13,7 +13,11 @@ import {
|
||||
TOO_HIGH_HINT,
|
||||
} from './policy.js';
|
||||
import { validateProviders } from '../../registry.js';
|
||||
import { fakeHost, until } from '../../../../testSupport/kartaViewFakes.mjs';
|
||||
import {
|
||||
drawn,
|
||||
fakeHost,
|
||||
until,
|
||||
} from '../../../../testSupport/kartaViewFakes.mjs';
|
||||
import {
|
||||
bindStreetViewer,
|
||||
coverageViewer,
|
||||
@@ -190,7 +194,7 @@ test('the nearest photo is the closest within 50 m, and opening it asks nothing
|
||||
});
|
||||
const id = await instance.nearestImage({ lat: 42.3314, lon: -83.0458 });
|
||||
assert.equal(id, 'near');
|
||||
const host = fakeHost();
|
||||
const host = fakeHost(instance.viewer);
|
||||
await instance.viewer.mount(host);
|
||||
await instance.viewer.open(id);
|
||||
assert.deepEqual(source.calls.photo, [], 'the lookup filled the cache');
|
||||
@@ -285,7 +289,7 @@ const press = async (button, opened) => {
|
||||
|
||||
async function mounted(sourceOptions, contextOptions) {
|
||||
const env = setup(sourceOptions, contextOptions);
|
||||
const host = fakeHost();
|
||||
const host = fakeHost(env.instance.viewer);
|
||||
await env.instance.viewer.mount(host);
|
||||
const poses = [];
|
||||
env.instance.viewer.onPose((pose) => poses.push(pose.imageId));
|
||||
@@ -970,7 +974,7 @@ test('after a GPU reset the photo is drawn again by the viewer, not through the
|
||||
context.actions.reportError = (message) => errors.push(message);
|
||||
const instance = definition.create(context);
|
||||
actions.instance = instance;
|
||||
const host = fakeHost();
|
||||
const host = fakeHost(instance.viewer);
|
||||
await instance.viewer.mount(host);
|
||||
const poses = [];
|
||||
instance.viewer.onPose((pose) => poses.push(pose.imageId));
|
||||
@@ -978,6 +982,7 @@ test('after a GPU reset the photo is drawn again by the viewer, not through the
|
||||
const canvas = () => host.children[0].children[1];
|
||||
const kind = () => host.children[0].dataset.kind;
|
||||
canvas().fire('webglcontextlost');
|
||||
await drawn();
|
||||
assert.equal(kind(), '', 'cleared while it is drawn again');
|
||||
assert.ok(await until(() => kind() === 'pano'), 'drawn again');
|
||||
assert.ok(poses.length >= 2);
|
||||
@@ -1010,7 +1015,7 @@ test('the marker is KartaView’s own cone, and it points along the drive, not a
|
||||
photos: page.photos.map((record) => ({ ...record, heading: '200' })),
|
||||
};
|
||||
};
|
||||
const host = fakeHost();
|
||||
const host = fakeHost(env.instance.viewer);
|
||||
await env.instance.viewer.mount(host);
|
||||
const bearings = [];
|
||||
env.instance.viewer.onPose((pose) => bearings.push(pose.bearing));
|
||||
@@ -1101,7 +1106,7 @@ test('a sequence page that lands while a lost GPU context recovers still draws i
|
||||
const instance = definition.create(context);
|
||||
actions.instance = instance;
|
||||
const cones = await withCones(t, { instance });
|
||||
const host = fakeHost();
|
||||
const host = fakeHost(instance.viewer);
|
||||
await instance.viewer.mount(host);
|
||||
await instance.viewer.open('p-0');
|
||||
// › to the next panorama; the GPU resets while it loads.
|
||||
|
||||
@@ -1,7 +1,11 @@
|
||||
import assert from 'node:assert/strict';
|
||||
import test from 'node:test';
|
||||
import { createKartaViewViewer, loadImage, panoSizeFor } from './viewer.js';
|
||||
import { fakeHost, until } from '../../../../testSupport/kartaViewFakes.mjs';
|
||||
import {
|
||||
drawn,
|
||||
fakeHost,
|
||||
until,
|
||||
} from '../../../../testSupport/kartaViewFakes.mjs';
|
||||
|
||||
const PHOTOS = {
|
||||
flat1: {
|
||||
@@ -148,7 +152,7 @@ function setup({
|
||||
});
|
||||
const poses = [];
|
||||
viewer.onPose((pose) => poses.push(pose));
|
||||
const host = fakeHost();
|
||||
const host = fakeHost(viewer);
|
||||
return {
|
||||
viewer,
|
||||
poses,
|
||||
@@ -223,6 +227,7 @@ test('a flat photo shows its 1280 px version, then the sharp one, with a pose fa
|
||||
assert.equal(picture.src, loads[1].url, 'upgraded to the sharp version');
|
||||
assert.equal(viewer.supportsRenderModes(), true);
|
||||
viewer.setRenderMode('fill');
|
||||
await drawn();
|
||||
assert.equal(picture.style.objectFit, 'cover');
|
||||
});
|
||||
|
||||
@@ -357,12 +362,14 @@ test('a newer open wins; close hides the photo; unmount tears down the panorama'
|
||||
assert.equal(renderers.length, 0, 'nor built a WebGL context');
|
||||
await viewer.open('pano1');
|
||||
viewer.close();
|
||||
await drawn();
|
||||
const { picture, canvas, root } = parts(host);
|
||||
assert.equal(canvas.hidden, true);
|
||||
assert.equal(picture.hidden, true);
|
||||
assert.equal(root.dataset.kind, '');
|
||||
await assert.rejects(viewer.open('nope'), /no such photo/);
|
||||
viewer.unmount();
|
||||
await drawn();
|
||||
assert.equal(host.children.length, 0);
|
||||
assert.equal(renderers[0].destroyed, true);
|
||||
await assert.rejects(viewer.open('flat1'), /not mounted/);
|
||||
@@ -463,12 +470,14 @@ test('a lost WebGL context drops the panorama and shows the photo again on a new
|
||||
const lost = parts(host).canvas;
|
||||
lost.fire('webglcontextlost');
|
||||
assert.equal(renderers[0].destroyed, true);
|
||||
await drawn();
|
||||
// A lost canvas only ever gives back its lost context: a new element.
|
||||
assert.notEqual(parts(host).canvas, lost);
|
||||
assert.deepEqual(stepped, ['pano1'], 'reopened through the core');
|
||||
assert.ok(await until(() => renderers.length === 2), 'a new renderer');
|
||||
assert.equal(renderers[1].canvas, parts(host).canvas);
|
||||
assert.equal(poses.at(-1).imageId, 'pano1');
|
||||
await drawn();
|
||||
assert.equal(parts(host).canvas.hidden, false);
|
||||
});
|
||||
|
||||
@@ -498,7 +507,7 @@ test('a WebGL failure only lasts until the viewer is mounted again', async () =>
|
||||
return renderer;
|
||||
},
|
||||
});
|
||||
const host = fakeHost();
|
||||
const host = fakeHost(viewer);
|
||||
await viewer.mount(host);
|
||||
await viewer.open('pano1');
|
||||
assert.equal(parts(host).picture.hidden, false, 'front view');
|
||||
@@ -589,7 +598,7 @@ function heldSetup({ slowSteps = false } = {}) {
|
||||
});
|
||||
const poses = [];
|
||||
viewer.onPose((pose) => poses.push(pose.imageId));
|
||||
const host = fakeHost();
|
||||
const host = fakeHost(viewer);
|
||||
/** Let the load showing `what` (e.g. 'a@1280') finish. */
|
||||
const release = async (what) => {
|
||||
assert.ok(
|
||||
@@ -798,7 +807,7 @@ function heldPanoSetup(held) {
|
||||
});
|
||||
const poses = [];
|
||||
viewer.onPose((pose) => poses.push(pose));
|
||||
return { viewer, renderers, stepped, poses, host: fakeHost(), release };
|
||||
return { viewer, renderers, stepped, poses, host: fakeHost(viewer), release };
|
||||
}
|
||||
|
||||
const pano2Preview = Buffer.from(
|
||||
@@ -931,7 +940,7 @@ test('a docked viewer keeps the 1,280 px photo; expanding it brings the 2,560 px
|
||||
viewer.resize();
|
||||
assert.ok(await until(() => loads.length === 2));
|
||||
assert.match(loads[1].url, /rs:fit:2560:2560/);
|
||||
assert.equal(parts(host).picture.src, loads[1].url);
|
||||
assert.ok(await until(() => parts(host).picture.src === loads[1].url));
|
||||
viewer.resize();
|
||||
for (let i = 0; i < 4; i++) await settle();
|
||||
assert.equal(loads.length, 2, 'once only');
|
||||
|
||||
@@ -14,7 +14,11 @@ import {
|
||||
} from './policy.js';
|
||||
import { validateProviders } from '../../registry.js';
|
||||
import { tileBounds } from '../../tileMath.js';
|
||||
import { fakeHost, until } from '../../../../testSupport/kartaViewFakes.mjs';
|
||||
import {
|
||||
drawn,
|
||||
fakeHost,
|
||||
until,
|
||||
} from '../../../../testSupport/kartaViewFakes.mjs';
|
||||
import {
|
||||
bindStreetViewer,
|
||||
coverageViewer,
|
||||
@@ -284,7 +288,7 @@ async function mounted(sourceOptions, contextOptions) {
|
||||
const env = setup(sourceOptions, contextOptions);
|
||||
const poses = [];
|
||||
env.instance.viewer.onPose((pose) => poses.push(pose.imageId));
|
||||
const host = fakeHost();
|
||||
const host = fakeHost(env.instance.viewer);
|
||||
await env.instance.viewer.mount(host);
|
||||
const [, , prev, next] = host.children[0].children;
|
||||
return { ...env, poses, prev, next };
|
||||
@@ -320,7 +324,7 @@ test('one lookup for a picture asked twice at once', async () => {
|
||||
await gate;
|
||||
return getItem(id);
|
||||
};
|
||||
const host = fakeHost();
|
||||
const host = fakeHost(instance.viewer);
|
||||
await instance.viewer.mount(host);
|
||||
const first = instance.viewer.open('s-0');
|
||||
const second = instance.viewer.open('s-0');
|
||||
@@ -985,7 +989,7 @@ test('after a GPU reset the viewer draws the same picture itself, leaving the co
|
||||
const { context, actions } = fakeContext();
|
||||
const instance = definition.create(context);
|
||||
actions.instance = instance;
|
||||
const host = fakeHost();
|
||||
const host = fakeHost(instance.viewer);
|
||||
await instance.viewer.mount(host);
|
||||
const poses = [];
|
||||
instance.viewer.onPose((pose) => poses.push(pose.imageId));
|
||||
@@ -994,6 +998,8 @@ test('after a GPU reset the viewer draws the same picture itself, leaving the co
|
||||
const kind = () => host.children[0].dataset.kind;
|
||||
assert.equal(kind(), 'pano');
|
||||
canvas().fire('webglcontextlost');
|
||||
await drawn();
|
||||
assert.equal(kind(), '', 'cleared while it is drawn again');
|
||||
assert.ok(await until(() => kind() === 'pano'), 'drawn again');
|
||||
assert.deepEqual(poses, ['p-0', 'p-0']);
|
||||
assert.deepEqual(actions.opened, [], 'not through the core');
|
||||
|
||||
@@ -59,7 +59,7 @@ function setup() {
|
||||
});
|
||||
const poses = [];
|
||||
viewer.onPose((pose) => poses.push(pose));
|
||||
return { viewer, poses, loads, renderers, stepped, host: fakeHost() };
|
||||
return { viewer, poses, loads, renderers, stepped, host: fakeHost(viewer) };
|
||||
}
|
||||
|
||||
const parts = (host) => {
|
||||
@@ -252,7 +252,7 @@ test('without WebGL a 360° picture shows its whole equirectangular image flat',
|
||||
throw new Error('no WebGL');
|
||||
},
|
||||
});
|
||||
const host = fakeHost();
|
||||
const host = fakeHost(viewer);
|
||||
await viewer.mount(host);
|
||||
await viewer.open('pano');
|
||||
const { picture } = parts(host);
|
||||
@@ -272,7 +272,7 @@ test('a picture whose SD fails falls back to the thumbnail; the original only fo
|
||||
return { src: url };
|
||||
},
|
||||
});
|
||||
const host = fakeHost();
|
||||
const host = fakeHost(viewer);
|
||||
await viewer.mount(host);
|
||||
await viewer.open('flat');
|
||||
assert.deepEqual(tried, [PHOTOS.flat.urls.sd, PHOTOS.flat.urls.thumb]);
|
||||
@@ -326,7 +326,7 @@ test('an SD panorama refused for its size is not fetched again as a flat photo',
|
||||
destroy() {},
|
||||
}),
|
||||
});
|
||||
const host = fakeHost();
|
||||
const host = fakeHost(viewer);
|
||||
await viewer.mount(host);
|
||||
await viewer.open('pano');
|
||||
const sdLoads = loads.filter((l) => l.url === PHOTOS.pano.urls.sd);
|
||||
|
||||
@@ -63,6 +63,9 @@ export function filtersOf(provider) {
|
||||
* @property {(mode: 'letterbox'|'fill') => void} [setRenderMode]
|
||||
* @property {() => boolean} [supportsRenderModes] False while the image has no frame to fit (a panorama): FIT / FILL hide.
|
||||
* @property {(listener: (pose: StreetPose) => void) => () => void} onPose
|
||||
* @property {(listener: (view: ?object) => void) => () => void} [subscribeView]
|
||||
* An adapter that draws nothing itself presents its viewer here, for the
|
||||
* layer's `subscribePhotoViewer()` (see photoViewer.js).
|
||||
*
|
||||
* @typedef {object} StreetPose
|
||||
* @property {string} providerId
|
||||
|
||||
Reference in new issue
Block a user