Follow a local GeoJSON feature on double-click through the camera port

A double-click on a point or polygon of a local GeoJSON layer follows it
again, as the default renderer followed the loader's entities: looking at
the centre of what the feature draws, north up, pitched down 45 degrees,
at the range that fits it in view. A line is zoomed to at once instead.
The layer acts only while the renderer's own double-click follow is on,
stops a follow it started when disabled, and stops listening when
destroyed.
This commit is contained in:
Sameh Khamis committed 2026-11-07 23:47:04 -08:00
1 parent c5fffae09e
commit abef2800fb
5 files changed
+277 -5

No files matched your search

+5 -1
View File
@@ -56,7 +56,11 @@ Cesium viewer with no renderer bound loads
`gods-eye-view/render/cesium/unbound` once first; until then the layer reports `gods-eye-view/render/cesium/unbound` once first; until then the layer reports
an error naming it, as it does for a dataset it cannot load. an error naming it, as it does for a dataset it cannot load.
A selected feature is the context record its draw item carries as `meta`; the A selected feature is the context record its draw item carries as `meta`; the
layer no longer sets the viewer's `selectedEntity`. layer no longer sets the viewer's `selectedEntity`. While the renderer's own
double-click follow is on, a double-click follows a point or polygon through
the camera port, looking at the centre of what it draws (stem included), framed
as the default renderer framed an entity it began following, and zooms to a
line, which has no stem to follow.
Features keep their own simplestyle `fill`, `fill-opacity`, `stroke`, Features keep their own simplestyle `fill`, `fill-opacity`, `stroke`,
`stroke-opacity`, `stroke-width`, `marker-color` and `marker-size`, given as `stroke-opacity`, `stroke-width`, `marker-color` and `marker-size`, given as
hex, `rgb()` or `hsl()` colours or by the CSS colour names the default renderer hex, `rgb()` or `hsl()` colours or by the CSS colour names the default renderer
+1
View File
@@ -207,6 +207,7 @@ test('consumer build includes only infrastructure code and resolves assets under
'drawHit.js', 'drawHit.js',
'ellipsoid.js', 'ellipsoid.js',
'follow.js', 'follow.js',
'frames.js',
'geojsonPins.js', 'geojsonPins.js',
'heights.js', 'heights.js',
'infrastructure.js', 'infrastructure.js',
+128 -1
View File
@@ -8,7 +8,13 @@ import {
findQuery, findQuery,
} from '../render/rendererOf.js'; } from '../render/rendererOf.js';
import { cssColor } from '../render/color.js'; import { cssColor } from '../render/color.js';
import { fromDegrees, fromDegreesInto, toLonLatH } from '../geo/ellipsoid.js'; import {
WGS84,
fromDegrees,
fromDegreesInto,
toLonLatH,
} from '../geo/ellipsoid.js';
import { offsetFromHeadingPitchRange } from '../geo/frames.js';
import { sphereFromPoints } from '../geo/sphere.js'; import { sphereFromPoints } from '../geo/sphere.js';
import { densifyRhumb } from '../geo/rhumb.js'; import { densifyRhumb } from '../geo/rhumb.js';
import { heightsOf } from '../queries/heights.js'; import { heightsOf } from '../queries/heights.js';
@@ -315,6 +321,34 @@ const STEM_WIDTH_PX = 3.5;
const PIN_SIZE_PX = 8; const PIN_SIZE_PX = 8;
const BLACK = Object.freeze([0, 0, 0, 1]); const BLACK = Object.freeze([0, 0, 0, 1]);
/** The range the default renderer frames a sphere of no size from. */
const MINIMUM_FIT_RANGE_M = 100;
/**
* Where the camera frames a part it starts following, as the default
* renderer framed an entity it started following with no view of its own:
* looking at the bounds' centre, heading north, pitched down 45° (steeper
* far from the ground), at the range that fits the bounds in view, within
* the camera's zoom limits. Returned as the eye's offset from the centre,
* east-north-up there; `at` is where the part stands.
*/
function followViewFrom(sphere, at, camera) {
const pose = camera.pose?.();
const fovy = Number.isFinite(pose?.fovy) ? pose.fovy : Math.PI / 3;
const aspect = Number.isFinite(pose?.aspectRatio) ? pose.aspectRatio : 1;
const tanPhi = Math.tan(fovy / 2);
const tanTheta = aspect * tanPhi;
let range =
sphere.radius === 0
? MINIMUM_FIT_RANGE_M
: Math.max(sphere.radius / tanTheta, sphere.radius / tanPhi);
const { minDistance = 0, maxDistance = Infinity } = camera.controls ?? {};
range = Math.min(Math.max(range, minDistance), maxDistance);
const factor =
2 - 1 / Math.max(1, Math.hypot(at.x, at.y, at.z) / WGS84.radii.x);
return offsetFromHeadingPitchRange(0, (-Math.PI / 4) * factor, range);
}
/** The GeoJSON loader's `marker-size` names, in pixels. */ /** The GeoJSON loader's `marker-size` names, in pixels. */
const MARKER_SIZES = Object.freeze({ small: 24, medium: 48, large: 64 }); const MARKER_SIZES = Object.freeze({ small: 24, medium: 48, large: 64 });
/** /**
@@ -544,6 +578,9 @@ export function createLocalGeoJsonLayer(
let _drawn = null; let _drawn = null;
let _enabled = false; let _enabled = false;
let _clickSubscription = null; let _clickSubscription = null;
let _dblclickSubscription = null;
/** The follow a double-click started, while the camera keeps it. */
let _follow = null;
let _count = 0; let _count = 0;
/** @type {number|null} Timestamp of the last successful dataset load. */ /** @type {number|null} Timestamp of the last successful dataset load. */
let _lastUpdate = null; let _lastUpdate = null;
@@ -681,6 +718,9 @@ export function createLocalGeoJsonLayer(
_lastLodBudgetLimit = 0; _lastLodBudgetLimit = 0;
_lodComputed = false; _lodComputed = false;
_lastLodProbeMs = Number.NEGATIVE_INFINITY; _lastLodProbeMs = Number.NEGATIVE_INFINITY;
// Its parts go, and the follow of one with them, as a removed entity
// stopped being followed.
stopFollow(viewer);
releaseDrawn(); releaseDrawn();
_overlayPublisher.hide(); _overlayPublisher.hide();
clearSelectedEntityContextForLayer(id); clearSelectedEntityContextForLayer(id);
@@ -886,6 +926,78 @@ export function createLocalGeoJsonLayer(
if (pins.length) drawn.sets.pins.upsert(pins); if (pins.length) drawn.sets.pins.upsert(pins);
} }
/**
* Follow the part under `position`: a part with a stem by the centre of
* all it draws, stem and all, as the default renderer followed the
* loader's entity by its bounds, framed as that renderer framed an entity
* it started following; a line, which had no position to
* follow, is flown into view instead.
*/
function followAt(viewer, position) {
const hit = findQuery(viewer)?.pick(position.x, position.y);
if (!hit || !hit.set?.startsWith(`${setPrefix}:`)) return;
const part = _drawn?.parts.get(hit.id);
if (!part) return;
const camera = findCamera(viewer);
if (!camera) return;
const points = framedPoints(part);
if (!points.length) return;
const record = part.carrier.record;
try {
if (!record) {
// As the default renderer zoomed to an entity with no position: at
// once, north up, pitched down 45°, at the range that fits it in
// view (the camera port's defaults).
const sphere = sphereFromPoints(points);
// Following nothing then, as that zoom stopped any follow first.
if (camera.followed) camera.follow(null);
camera.flyToBounds(sphere, { durationS: 0 });
return;
}
// The camera looks at the bounds' centre, kept where the stem now
// stands, as the default renderer kept its entity's bounds.
const outline = framedPoints(part, false);
const centre = () =>
sphereFromPoints([...outline, record.base, record.tip]).center;
const target = {
key: `${id}:${record.id}`,
position: centre,
frame: 'enu',
viewFrom: followViewFrom(sphereFromPoints(points), record.tip, camera),
};
camera.follow(target);
_follow = target;
} catch (error) {
// A camera that cannot follow (a viewer without entity tracking)
// leaves the view where it is, as that viewer's double-click did.
console.warn(`${id}: cannot follow`, error);
}
}
/**
* What the default renderer framed for a part: all it drew of it (but
* for its stem, without `withStem`).
*/
function framedPoints(part, withStem = true) {
const record = part.carrier.record;
const points = [];
if (part.kind === 'polygon')
for (const { lon, lat, height } of part.rings[0])
points.push(fromDegrees(lon, lat, height ?? 0));
else if (part.kind === 'line')
for (const [lon, lat] of part.coordinates)
points.push(fromDegrees(lon, lat, 0));
if (record && withStem) points.push(copy(record.base), copy(record.tip));
return points;
}
/** Stop a follow this layer started, if the camera still keeps it. */
function stopFollow(viewer) {
const camera = findCamera(viewer);
if (_follow && camera?.followed === _follow) camera.follow(null);
_follow = null;
}
/** Fly to where a clicked part stands, holding camera input meanwhile. */ /** Fly to where a clicked part stands, holding camera input meanwhile. */
function flyToPart(viewer, input, part) { function flyToPart(viewer, input, part) {
const target = part.carrier.record const target = part.carrier.record
@@ -1064,6 +1176,19 @@ export function createLocalGeoJsonLayer(
flyToPart(viewer, input, part); flyToPart(viewer, input, part);
}); });
} }
// 3. Follow a part on a double-click, as the default renderer's
// own double-click followed the loader's entities.
if (!_dblclickSubscription) {
const input = inputFor(viewer);
_dblclickSubscription =
input.onPointer?.('dblclick', (event) => {
if (!_enabled || !_drawn) return;
// The renderer's own double-click follow, off while a
// tool holds it or on a renderer without one.
if (input.stockEnabled?.('dblclickFollow') !== true) return;
followAt(viewer, event.position);
}) ?? null;
}
})(); })();
try { try {
await _loadPromise; await _loadPromise;
@@ -1305,6 +1430,8 @@ export function createLocalGeoJsonLayer(
removeEntityContextsForLayer(id); removeEntityContextsForLayer(id);
_clickSubscription?.(); _clickSubscription?.();
_clickSubscription = null; _clickSubscription = null;
_dblclickSubscription?.();
_dblclickSubscription = null;
_overlayPublisher.destroy(); _overlayPublisher.destroy();
_cachedFeatures = null; _cachedFeatures = null;
pinMaker.clear(); pinMaker.clear();
+118 -1
View File
@@ -8,6 +8,8 @@ import { localGeoJsonServices } from '../app/localGeojsonServices.js';
import { getContextStore } from './contextStore.js'; import { getContextStore } from './contextStore.js';
import { readEntityRecord } from './entityRecords.js'; import { readEntityRecord } from './entityRecords.js';
import { bindFakeGroundRenderer } from '../testSupport/fakeGroundRenderer.mjs'; import { bindFakeGroundRenderer } from '../testSupport/fakeGroundRenderer.mjs';
import { distance, normalize, sub } from '../geo/vector.js';
import { eastNorthUp, framePoint, inverseFrameVector } from '../geo/frames.js';
const feature = (id, geometry, properties = { name: `Feature ${id}` }) => ({ const feature = (id, geometry, properties = { name: `Feature ${id}` }) => ({
type: 'Feature', type: 'Feature',
@@ -80,6 +82,8 @@ async function enabledLayer(t, features) {
eye: { lon: 0.005, lat: 0.005, height: 50_000 }, eye: { lon: 0.005, lat: 0.005, height: 50_000 },
}); });
let click = null; let click = null;
let dblclick = null;
const stock = { dblclickFollow: true };
const holds = []; const holds = [];
const layer = createLocalGeoJsonLayer( const layer = createLocalGeoJsonLayer(
{ {
@@ -99,6 +103,14 @@ async function enabledLayer(t, features) {
holds.push(reason); holds.push(reason);
return () => holds.push(`release:${reason}`); return () => holds.push(`release:${reason}`);
}, },
onPointer: (type, handler) => {
assert.equal(type, 'dblclick');
dblclick = handler;
return () => {
dblclick = null;
};
},
stockEnabled: (name) => stock[name] === true,
}), }),
}, },
{ {
@@ -117,7 +129,16 @@ async function enabledLayer(t, features) {
if (originalWindow === undefined) delete globalThis.window; if (originalWindow === undefined) delete globalThis.window;
else globalThis.window = originalWindow; else globalThis.window = originalWindow;
}); });
return { layer, viewer, fake, holds, click: (event) => click?.(event) }; return {
layer,
viewer,
fake,
holds,
stock,
click: (event) => click?.(event),
dblclick: (event) => dblclick?.(event),
subscribed: () => dblclick !== null,
};
} }
test('polygons fill the ground, lines drape, points stand on pins, all shown', async (t) => { test('polygons fill the ground, lines drape, points stand on pins, all shown', async (t) => {
@@ -387,3 +408,99 @@ test('a marker-symbol is stamped on its pin: a character as text, a longer one a
assert.match(pins.get('missing').image.svg, /fill="rgba\(255,0,0,1\)"/); assert.match(pins.get('missing').image.svg, /fill="rgba\(255,0,0,1\)"/);
assert.deepEqual(pins.get('missing').image, pins.get('plain').image); assert.deepEqual(pins.get('missing').image, pins.get('plain').image);
}); });
test('a double-click follows a part as the default renderer followed its entity, and zooms to a line', async (t) => {
const env = await enabledLayer(t, [
feature('pt', { type: 'Point', coordinates: [0.002, 0.003] }),
feature('l', {
type: 'LineString',
coordinates: [
[0, 0],
[0.01, 0],
],
}),
]);
const { fake } = env;
const setOf = (role) => fake.set(role).spec.id;
const stem = fake.set('stems').items.get('pt');
const [base, tip] = stem.positions;
let picked = null;
fake.setPick((x, y) => (x === 7 && y === 9 ? picked : null));
// Nothing of this layer's under it: nothing happens.
env.dblclick({ position: { x: 7, y: 9 } });
picked = { set: 'someone-else', id: 'pt' };
env.dblclick({ position: { x: 7, y: 9 } });
assert.equal(fake.follows.length, 0);
// Its pin, its stem or its dot: the camera follows the stem's centre,
// where the default renderer kept the entity's bounds. A tall view, so
// its width is what fits the stem in.
fake.view.aspectRatio = 0.5;
picked = { set: setOf('pins'), id: 'pt' };
env.dblclick({ position: { x: 7, y: 9 } });
const target = fake.follows.at(-1);
assert.equal(target.key, 'local-dams:pt');
assert.equal(target.frame, 'enu');
const center = {
x: (base.x + tip.x) / 2,
y: (base.y + tip.y) / 2,
z: (base.z + tip.z) / 2,
};
assert.ok(distance(target.position(0), center) < 1e-6);
// Looking at it north up, pitched down 45 degrees (a little more for a
// tip above the ellipsoid), at the range that fits the stem in view.
const eye = framePoint(eastNorthUp(center), target.viewFrom);
const radius = distance(base, tip) / 2;
const fit = radius / (0.5 * Math.tan(Math.PI / 6));
assert.ok(Math.abs(distance(eye, center) - fit) < 1e-6);
const look = inverseFrameVector(
eastNorthUp(center),
normalize(sub(center, eye)),
);
const factor = 2 - 1 / Math.max(1, Math.hypot(tip.x, tip.y, tip.z) / 6378137);
assert.ok(factor > 1 + 1e-5, 'the tip stands above the ellipsoid');
assert.ok(Math.abs(look.x) < 1e-9, 'heading north');
assert.ok(look.y > 0);
assert.ok(
Math.abs(Math.asin(-look.z) - (Math.PI / 4) * factor) < 1e-9,
'pitched down 45 degrees, steeper above the ground',
);
fake.view.aspectRatio = 1;
// Off while the renderer's own double-click follow is held off.
env.stock.dblclickFollow = false;
picked = { set: setOf('stems'), id: 'pt' };
env.dblclick({ position: { x: 7, y: 9 } });
assert.equal(fake.follows.length, 1);
env.stock.dblclickFollow = true;
// A line had no position to follow: it is zoomed to instead, at once,
// with the camera's default framing (north, 45 degrees down, fitted).
picked = { set: setOf('lines'), id: 'l' };
env.dblclick({ position: { x: 7, y: 9 } });
const zoom = fake.flights.at(-1);
assert.ok(zoom.sphere.radius > 500);
assert.deepEqual(zoom.options, { durationS: 0 });
// Stopping the follow first, as that zoom did.
assert.equal(fake.follows.length, 2);
assert.equal(fake.follows.at(-1), null);
// Disabled, the layer leaves a follow another started in place of its
// own, and stops its own.
picked = { set: setOf('dots'), id: 'pt' };
env.dblclick({ position: { x: 7, y: 9 } });
assert.equal(fake.follows.at(-1).key, 'local-dams:pt');
const theirs = { key: 'theirs' };
fake.follows.push(theirs);
env.layer.disable(env.viewer);
assert.equal(fake.follows.at(-1), theirs);
await env.layer.enable(env.viewer);
env.dblclick({ position: { x: 7, y: 9 } });
assert.equal(fake.follows.at(-1).key, 'local-dams:pt');
env.layer.disable(env.viewer);
assert.equal(fake.follows.at(-1), null);
// Destroyed, it stops listening.
env.layer.destroy(env.viewer);
assert.equal(env.subscribed(), false);
});
+25 -2
View File
@@ -84,6 +84,12 @@ export function bindFakeGroundRenderer(
const moveEnd = new FakeEvent(); const moveEnd = new FakeEvent();
const capabilities = new Set(sampleHeight ? ['sampleHeight'] : []); const capabilities = new Set(sampleHeight ? ['sampleHeight'] : []);
const flights = []; const flights = [];
/** What the camera has been told to follow, in order; the last is followed. */
const follows = [];
/** The camera's view shape, which a test may change. */
const view = { fovy: Math.PI / 3, aspectRatio: 1 };
/** What a pick answers at a window position; default: nothing drawn. */
let pickAt = () => null;
const renders = []; const renders = [];
let position = fromDegrees(eye.lon, eye.lat, eye.height); let position = fromDegrees(eye.lon, eye.lat, eye.height);
let surfaceHeight = surface; let surfaceHeight = surface;
@@ -114,8 +120,7 @@ export function bindFakeGroundRenderer(
return { return {
...at, ...at,
position: { ...position }, position: { ...position },
fovy: Math.PI / 3, ...view,
aspectRatio: 1,
}; };
}, },
on: (event, cb) => (event === 'moveEnd' ? moveEnd.on(cb) : () => {}), on: (event, cb) => (event === 'moveEnd' ? moveEnd.on(cb) : () => {}),
@@ -123,8 +128,20 @@ export function bindFakeGroundRenderer(
flights.push({ destination, options }); flights.push({ destination, options });
return { done: Promise.resolve('complete'), cancel() {} }; return { done: Promise.resolve('complete'), cancel() {} };
}, },
flyToBounds(sphere, options) {
flights.push({ sphere, options });
return { done: Promise.resolve('complete'), cancel() {} };
},
follow(target) {
follows.push(target);
},
get followed() {
return follows.at(-1) ?? null;
},
controls: { minDistance: 1, maxDistance: Infinity },
}, },
query: { query: {
pick: (x, y) => pickAt(x, y),
project: () => ({ x: canvas.width / 2, y: canvas.height / 2 }), project: () => ({ x: canvas.width / 2, y: canvas.height / 2 }),
isOccluded: (point) => occluded(position, point), isOccluded: (point) => occluded(position, point),
sampleHeightNow(point, options = {}) { sampleHeightNow(point, options = {}) {
@@ -149,6 +166,8 @@ export function bindFakeGroundRenderer(
moveEnd, moveEnd,
globe, globe,
flights, flights,
follows,
view,
renders, renders,
sampleCalls, sampleCalls,
capabilities, capabilities,
@@ -169,6 +188,10 @@ export function bindFakeGroundRenderer(
position = { ...next }; position = { ...next };
}, },
eyePosition: () => ({ ...position }), eyePosition: () => ({ ...position }),
/** Change what a pick answers at a window position. */
setPick(next) {
pickAt = next;
},
/** Change what surface samples answer. */ /** Change what surface samples answer. */
setSurface(next) { setSurface(next) {
surfaceHeight = next; surfaceHeight = next;