fix(cctv): keep the Context camera card's still and tidy the visibility port

The still preview gate looked only at the CCTV panel, so the Context
camera card, which reads the same frame, stopped updating while the
panel was collapsed or another phone sheet was open. A mounted card now
counts itself in the CCTV store, and the still is requested while the
panel or a card is shown; live video still follows the panel only.

Review follow-ups in the same area:
- visiblePoints is registered once, in createCesiumPorts, and drops
  checks for input that cannot happen; the contract documents
  horizonMarginM and when it answers false or null.
- The layer passes the mount and the four corners once each and asks
  findCamera for the port.
- Phone sheet names come from a shared module instead of literals.
- Layer tests cover the fetch gate; the geometry cases moved to the
  camera port tests. Comments and CURRENT-STATE match the code.
This commit is contained in:
German Khokhlov committed 2026-11-19 18:28:51 +04:00
1 parent b020a1cd91
commit 99a70a0e0c
18 files changed
+545 -430

No files matched your search

+12 -41
View File
@@ -86,6 +86,9 @@ function sameMatrix(array, matrix) {
return true;
}
const finiteVector = (v) =>
!!v && Number.isFinite(v.x) && Number.isFinite(v.y) && Number.isFinite(v.z);
/** Conservative globe/frustum visibility; null means unknown. */
export function createPointsVisibility(scene, camera) {
const visibilitySphere = new Cesium.BoundingSphere();
@@ -93,47 +96,20 @@ export function createPointsVisibility(scene, camera) {
let visibilityEllipsoid = null;
let visibilityOccluder = null;
return function visiblePoints(points, marginM) {
if (
scene.mode !== Cesium.SceneMode.SCENE3D ||
!points?.length ||
!Number.isFinite(marginM) ||
marginM < 0 ||
typeof camera.frustum?.computeCullingVolume !== 'function'
)
return null;
const radii = Cesium.Ellipsoid.WGS84.radii;
if (marginM >= Math.min(radii.x, radii.y, radii.z)) return null;
const eye = camera.positionWC;
if (
!eye ||
!Number.isFinite(eye.x) ||
!Number.isFinite(eye.y) ||
!Number.isFinite(eye.z)
)
return null;
const direction = camera.directionWC;
const up = camera.upWC;
if (
!direction ||
!up ||
!Number.isFinite(direction.x) ||
!Number.isFinite(direction.y) ||
!Number.isFinite(direction.z) ||
!Number.isFinite(up.x) ||
!Number.isFinite(up.y) ||
!Number.isFinite(up.z)
scene.mode !== Cesium.SceneMode.SCENE3D ||
!points?.length ||
!finiteVector(eye) ||
!finiteVector(direction) ||
!finiteVector(up) ||
!points.every(finiteVector)
)
return null;
for (const p of points) {
if (
!p ||
!Number.isFinite(p.x) ||
!Number.isFinite(p.y) ||
!Number.isFinite(p.z)
)
return null;
}
if (visibilityMargin !== marginM) {
const radii = Cesium.Ellipsoid.WGS84.radii;
visibilityMargin = marginM;
visibilityEllipsoid = new Cesium.Ellipsoid(
radii.x - marginM,
@@ -143,6 +119,7 @@ export function createPointsVisibility(scene, camera) {
visibilityOccluder = new Cesium.EllipsoidalOccluder(visibilityEllipsoid);
}
const inverse = visibilityEllipsoid.oneOverRadii;
// Inside the ellipsoid Cesium's occluder hides nearby points; judge by the frustum alone.
const outside =
Math.hypot(eye.x * inverse.x, eye.y * inverse.y, eye.z * inverse.z) >= 1;
if (outside) {
@@ -156,11 +133,7 @@ export function createPointsVisibility(scene, camera) {
}
if (!visible) return false;
}
const culling = camera.frustum.computeCullingVolume(
eye,
camera.directionWC,
camera.upWC,
);
const culling = camera.frustum.computeCullingVolume(eye, direction, up);
return (
culling.computeVisibility(
Cesium.BoundingSphere.fromPoints(points, visibilitySphere),
@@ -752,8 +725,6 @@ export function createCesiumCamera({
});
// Cesium keeps the eye in `camera.transform`: a tracked entity's frame, a
// `lookAt` target's, or the identity.
if (!capabilities || capabilities.has('pointVisibility'))
cameraPort.visiblePoints = createPointsVisibility(scene, camera);
if (!capabilities || capabilities.has('followFrame'))
cameraPort.followFrame = () => {
if (!lastFollowFrame || !sameMatrix(lastFollowFrame, camera.transform))
+129 -7
View File
@@ -19,7 +19,7 @@ import {
headlessCamera,
withVirtualClock,
} from './cameraGoldens.js';
import { createCesiumCamera } from './camera.js';
import { createCesiumCamera, createPointsVisibility } from './camera.js';
import { createCesiumPorts } from './ports.js';
import { bindRenderer, cameraOf } from '../rendererOf.js';
@@ -337,11 +337,20 @@ test('the camera port gives the clock its own tick back as it goes', () => {
}
});
test('camera visibility is unknown outside 3D and resolves on the globe', () => {
const { scene, camera } = headlessCamera();
scene.postUpdate = new Cesium.Event();
test('visiblePoints is there only with its capability, and unknown outside 3D', (t) => {
const { scene } = headlessCamera();
for (const name of ['preUpdate', 'postUpdate', 'preRender', 'postRender'])
scene[name] = new Cesium.Event();
scene.primitives = { add() {}, remove() {} };
scene.requestRender = () => {};
const { port } = createCesiumCamera({ scene, camera, report: () => {} });
const viewer = { scene, clock: { currentTime: Cesium.JulianDate.now() } };
const without = createCesiumPorts(viewer, { capabilities: new Set() });
assert.equal(without.camera.visiblePoints, undefined);
without.dispose();
const ports = createCesiumPorts(viewer, {
capabilities: new Set(['pointVisibility']),
});
t.after(() => ports.dispose());
const points = [Cesium.Cartesian3.fromDegrees(0, 0, 10)];
for (const mode of [
Cesium.SceneMode.SCENE2D,
@@ -350,10 +359,123 @@ test('camera visibility is unknown outside 3D and resolves on the globe', () =>
undefined,
]) {
scene.mode = mode;
assert.equal(port.visiblePoints(points, 200), null);
assert.equal(ports.camera.visiblePoints(points, 200), null);
}
scene.mode = Cesium.SceneMode.SCENE3D;
assert.equal(typeof port.visiblePoints(points, 200), 'boolean');
assert.equal(typeof ports.camera.visiblePoints(points, 200), 'boolean');
});
const point = (lon, lat, altitude = 20) =>
Cesium.Cartesian3.fromDegrees(lon, lat, altitude);
const down = Cesium.Cartesian3.negate(
Cesium.Cartesian3.UNIT_X,
new Cesium.Cartesian3(),
);
const up = Cesium.Cartesian3.UNIT_Z;
const frustum = new Cesium.PerspectiveFrustum({
fov: Cesium.Math.toRadians(60),
aspectRatio: 16 / 9,
near: 1,
// Cesium's default far plane, as the app uses.
far: 5e8,
});
function visibility(position, direction, up) {
const visiblePoints = createPointsVisibility(
{ mode: Cesium.SceneMode.SCENE3D },
{ positionWC: position, directionWC: direction, upWC: up, frustum },
);
return (points) => visiblePoints(points, 200);
}
function directionTo(position, target) {
return Cesium.Cartesian3.normalize(
Cesium.Cartesian3.subtract(target, position, new Cesium.Cartesian3()),
new Cesium.Cartesian3(),
);
}
function assertInFrustum(points, position, direction) {
const culling = frustum.computeCullingVolume(position, direction, up);
assert.notEqual(
culling.computeVisibility(Cesium.BoundingSphere.fromPoints(points)),
Cesium.Intersect.OUTSIDE,
);
}
test('a plane in front of the camera is visible', () => {
assert.equal(visibility(point(0, 0, 30000), down, up)([point(0, 0)]), true);
});
test('a plane behind the camera is outside the frustum', () => {
assert.equal(
visibility(point(0, 0, 30000), Cesium.Cartesian3.UNIT_X, up)([point(0, 0)]),
false,
);
});
test('a corner can be in view when the mount and centre are outside', () => {
const visible = visibility(point(0, 0, 30000), down, up);
const mount = point(0.3, 0);
const points = [
mount,
point(0.1, 0.0001),
point(0.3, 0.0001),
point(0.3, -0.0001),
point(0.1, -0.0001),
];
assert.equal(visible(points), true);
assert.equal(visible([mount]), false);
assert.equal(visible([point(0.2, 0)]), false);
});
test('a nearby plane below the ellipsoid is visible to low and high viewers', () => {
const cap = point(0.00054, 0, -18);
const points = [point(0, 0, -18), cap];
for (const altitude of [4, 1200]) {
const position = point(0.00135, 0, altitude);
const direction = directionTo(position, cap);
assertInFrustum(points, position, direction);
assert.equal(visibility(position, direction, up)(points), true);
}
});
test('the horizon rejects a negative-height plane on the far side', () => {
const mount = point(0, 0, -18);
const points = [mount, point(0.00054, 0, -18)];
for (const altitude of [4, 30000, 2e7]) {
const position = point(180, 0, altitude);
const direction = directionTo(position, mount);
assertInFrustum(points, position, direction);
assert.equal(visibility(position, direction, up)(points), false);
}
});
test('a low viewer can see a plane beyond the WGS84 horizon', () => {
const mount = point(0, 0, 1);
const position = point(0.2, 0, 4);
assert.equal(
visibility(position, directionTo(position, mount), up)([mount]),
true,
);
});
test('deep viewers do not lose nearby planes to the horizon test', () => {
const mount = point(0, 0, -350);
const position = point(0.00135, 0, -300);
assert.equal(
visibility(position, directionTo(position, mount), up)([mount]),
true,
);
});
test('a non-finite camera direction leaves visibility unknown', () => {
const visible = visibility(
point(0, 0, 30000),
new Cesium.Cartesian3(NaN, 0, 0),
up,
);
assert.equal(visible([point(0, 0)]), null);
});
test('setFov holds the vertical angle across resizes, and waits for a first one', () => {
+1 -1
View File
@@ -485,7 +485,7 @@ export function createCesiumPorts(
: {}),
});
const cameraPort = cameraPart.port;
if (controlled && capabilities.has('pointVisibility'))
if (capabilities.has('pointVisibility'))
cameraPort.visiblePoints = createPointsVisibility(scene, camera);
measureCameraChanged = cameraPart.measureChanged ?? null;
const effectsPart = createCesiumEffects(scene, {
+8 -1
View File
@@ -234,7 +234,14 @@ export type CameraEvent =
'changed' | 'moveStart' | 'moveEnd' | 'followChanged' | 'flightEnd';
export interface CameraPort {
/** Conservative visibility of an ECEF point set, with a horizon margin in metres; null means unknown. */
/**
* Whether any of the ECEF points may be on screen: false only when their
* bounding sphere is outside the view or all of them are below the horizon
* of WGS84 shrunk by `horizonMarginM` metres; null when it cannot tell
* (not a 3D scene, an empty point set, or a non-finite point or camera
* vector), which callers treat as visible. Supply a finite, nonnegative
* margin smaller than the shortest WGS84 radius.
*/
visiblePoints?(points: Ecef[], horizonMarginM: number): boolean | null;
pose(): CameraPose;
/**