mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-20 18:22:25 +00:00
Merge main and keep both sets of CCTV rendering tests
This commit is contained in:
commit
f10ea2e6b4
190 files changed
+10516
-971
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 = {}) =>
|
||||
|
||||
@@ -456,33 +456,60 @@ const BRAND_ALIASES = {
|
||||
Hikvision: ['hiwatch'],
|
||||
};
|
||||
|
||||
function brandWords(record) {
|
||||
return new Set([
|
||||
...words(record.brand),
|
||||
...(BRAND_ALIASES[record.brand] || []),
|
||||
]);
|
||||
}
|
||||
|
||||
/**
|
||||
* One entry per record name (model + aliases). `required` is every
|
||||
* non-generic word of the name — all must appear in a query, so a generation
|
||||
* or suffix ("Mk II", "7000i" vs "7000") is never dropped. `hasCode` marks
|
||||
* names carrying a letter+digit model code; names without one ("3950",
|
||||
* "01959-004", "AUTODOME 800 Series") match only when the brand does.
|
||||
*/
|
||||
const NAME_INDEX = RECORDS.flatMap((record) => {
|
||||
const brand = brandWords(record);
|
||||
return [record.model, ...(record.aliases || [])].map((name) => {
|
||||
const nameWords = words(name);
|
||||
return {
|
||||
record,
|
||||
brand,
|
||||
allowed: new Set(nameWords),
|
||||
required: nameWords.filter((word) => !isGeneric(word)),
|
||||
hasCode: nameWords.some(isModelCode),
|
||||
};
|
||||
/** A model lookup over `records` with this module's matching rules (see lookupModelSpec). */
|
||||
export function createModelSpecLookup(records) {
|
||||
/**
|
||||
* One entry per record name (model + aliases). `required` is every
|
||||
* non-generic word of the name — all must appear in a query, so a
|
||||
* generation or suffix ("Mk II", "7000i" vs "7000") is never dropped.
|
||||
* `hasCode` marks names carrying a letter+digit model code; names without
|
||||
* one ("3950", "01959-004", "AUTODOME 800 Series") match only when the
|
||||
* brand does.
|
||||
*/
|
||||
const nameIndex = records.flatMap((record) => {
|
||||
const brand = new Set([
|
||||
...words(record.brand),
|
||||
...(BRAND_ALIASES[record.brand] || []),
|
||||
]);
|
||||
return [record.model, ...(record.aliases || [])].map((name) => {
|
||||
const nameWords = words(name);
|
||||
return {
|
||||
record,
|
||||
brand,
|
||||
allowed: new Set(nameWords),
|
||||
required: nameWords.filter((word) => !isGeneric(word)),
|
||||
hasCode: nameWords.some(isModelCode),
|
||||
};
|
||||
});
|
||||
});
|
||||
});
|
||||
return (model, manufacturer) => {
|
||||
const query = words(model).map(stripVariantSuffix);
|
||||
if (!query.length) return null;
|
||||
const maker = words(manufacturer);
|
||||
const found = new Set();
|
||||
for (const entry of nameIndex) {
|
||||
const makerMatches = maker.some((word) => entry.brand.has(word));
|
||||
if (maker.length && !makerMatches) continue;
|
||||
if (
|
||||
!entry.hasCode &&
|
||||
!makerMatches &&
|
||||
!query.some((word) => entry.brand.has(word))
|
||||
)
|
||||
continue;
|
||||
if (!entry.required.length) continue;
|
||||
if (!entry.required.every((word) => query.includes(word))) continue;
|
||||
if (
|
||||
!query.every(
|
||||
(word) =>
|
||||
entry.allowed.has(word) || entry.brand.has(word) || isGeneric(word),
|
||||
)
|
||||
)
|
||||
continue;
|
||||
found.add(entry.record);
|
||||
}
|
||||
return found.size === 1 ? [...found][0] : null;
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Looks up a spec record for a hardware-model string.
|
||||
@@ -502,33 +529,7 @@ const NAME_INDEX = RECORDS.flatMap((record) => {
|
||||
* @param {string} [manufacturer] - The source's manufacturer, when published.
|
||||
* @returns {Object|null} The matched spec record, or null when unknown.
|
||||
*/
|
||||
export function lookupModelSpec(model, manufacturer) {
|
||||
const query = words(model).map(stripVariantSuffix);
|
||||
if (!query.length) return null;
|
||||
const maker = words(manufacturer);
|
||||
const found = new Set();
|
||||
for (const entry of NAME_INDEX) {
|
||||
const makerMatches = maker.some((word) => entry.brand.has(word));
|
||||
if (maker.length && !makerMatches) continue;
|
||||
if (
|
||||
!entry.hasCode &&
|
||||
!makerMatches &&
|
||||
!query.some((word) => entry.brand.has(word))
|
||||
)
|
||||
continue;
|
||||
if (!entry.required.length) continue;
|
||||
if (!entry.required.every((word) => query.includes(word))) continue;
|
||||
if (
|
||||
!query.every(
|
||||
(word) =>
|
||||
entry.allowed.has(word) || entry.brand.has(word) || isGeneric(word),
|
||||
)
|
||||
)
|
||||
continue;
|
||||
found.add(entry.record);
|
||||
}
|
||||
return found.size === 1 ? [...found][0] : null;
|
||||
}
|
||||
export const lookupModelSpec = createModelSpecLookup(RECORDS);
|
||||
|
||||
/**
|
||||
* Datasheet horizontal FOV as the range the hardware can cover. Only
|
||||
@@ -602,13 +603,19 @@ export function specFovCapabilityToken(
|
||||
|
||||
/**
|
||||
* One-line spec summary for HUD meta text.
|
||||
* @param {Object} spec - A record from this module.
|
||||
* @param {Object} spec - A spec record (CCTV or ALPR). Resolution falls back
|
||||
* from label to WxH to NMP.
|
||||
* @param {{withBrand?: boolean}} [options] - `withBrand: false` leaves the
|
||||
* brand out.
|
||||
* @returns {string} e.g. 'Axis Q6135-LE · 1080p · IR 250m · PTZ' ('' for null).
|
||||
*/
|
||||
export function specSummary(spec) {
|
||||
export function specSummary(spec, { withBrand = true } = {}) {
|
||||
if (!spec) return '';
|
||||
const parts = [`${spec.brand} ${spec.model}`];
|
||||
if (spec.resolution?.label) parts.push(spec.resolution.label);
|
||||
const parts = [withBrand ? `${spec.brand} ${spec.model}` : spec.model];
|
||||
const { label, w, h, mp } = spec.resolution || {};
|
||||
if (label) parts.push(label);
|
||||
else if (w && h) parts.push(`${w}x${h}`);
|
||||
else if (mp) parts.push(`${mp}MP`);
|
||||
if (spec.night_vision) {
|
||||
parts.push(
|
||||
`${spec.night_vision.type.toUpperCase()}${spec.night_vision.range_m ? ` ${spec.night_vision.range_m}m` : ''}`,
|
||||
|
||||
@@ -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();
|
||||
@@ -450,3 +501,35 @@ test('focus release restores video hue and alpha after the style throttle', () =
|
||||
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,
|
||||
|
||||
Reference in new issue
Block a user