mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
On the photoreal stack the rendered-mesh floor took one probe at each coarse cell's centre (0.001 degrees) and kept it for the session. A centre on a roof passed the +80 m DEM window and lifted every vehicle in the cell to roof height (a Haymarket bus drew 23.5 m above the street, on the garage roof); a centre in the river put Red Line trains on the Longfellow Bridge 6-9 m under the deck. The sampler now probes at the caller's point. A cell with a reading is probed again only at spots about 17 m apart from earlier ones, eight at most, and a spot refused only because the cell's DEM prior was cold is tried again later. The floor keeps each reading that passes the gate at the point it was taken (two within about 5 m keep the lower; sixteen at most per cell) and answers a read from the reading nearest the asked point, so a viaduct and the street beside it in one cell keep their own heights.
317 lines
14 KiB
JavaScript
317 lines
14 KiB
JavaScript
// src/data/meshFloorSampler.test.mjs — the rendered-mesh sampler driven through
|
|
// its REAL validation boundary (2026-08-21).
|
|
//
|
|
// The sampler's acceptance rule was previously covered only through
|
|
// `reportValidatedMeshFloorCell` directly, which proves the gate but not the
|
|
// decision that feeds it. These tests call `sampleMeshFloorCells` with a fake
|
|
// scene whose `sampleHeight` returns exactly what Cesium can return — a number,
|
|
// `undefined`, NaN, or a throw — and assert that a cell latches if and only if
|
|
// a REAL DEM prior exists and the sample fits its window.
|
|
//
|
|
// That requirement is the load-bearing one: this round built a tier that kept
|
|
// the reading when no prior existed, and measured it recording a coarse-LOD
|
|
// 20.6 m for ground that is really ~122 m (see meshFloorSampler.js). Without a
|
|
// prior there is nothing to tell a surface from a mis-hit, and `tilesLoaded`
|
|
// is not that signal.
|
|
//
|
|
// The DEM priors are seeded the same way `terrainHeights.test.mjs` does: a fake
|
|
// `globalThis.fetch` in front of the real resolver, so the module's own
|
|
// real-vs-fallback bookkeeping is exercised rather than stubbed.
|
|
import { test } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import * as Cesium from 'cesium';
|
|
import { sampleMeshFloorCells } from './meshFloorSampler.js';
|
|
import { resolveEllipsoidalGround } from './terrainHeights.js';
|
|
import {
|
|
cachedGroundFloor, cachedMeshFloor, setMeshFloorPreferred,
|
|
_clearMeshFloorCellsForTest, reportValidatedMeshFloorCell,
|
|
} from './groundFloor.js';
|
|
|
|
/** Distinct site per test — terrainHeights' cache is module-global and warm
|
|
* entries are permanent, so tests must not share coordinates. */
|
|
let siteLat = 40.0;
|
|
const nextSite = () => ({ lat: +(siteLat += 0.05).toFixed(3), lon: -97.66 });
|
|
|
|
/** Seeds a REAL ('reearth') DEM prior for a cell through the real resolver. */
|
|
async function seedDem(cell, ellipsoid) {
|
|
const original = globalThis.fetch;
|
|
globalThis.fetch = async () => new Response(
|
|
JSON.stringify({ results: [{ ellipsoid }] }),
|
|
{ status: 200, headers: { 'Content-Type': 'application/json' } },
|
|
);
|
|
try {
|
|
await resolveEllipsoidalGround([{ lat: cell.lat, lon: cell.lon }]);
|
|
} finally {
|
|
globalThis.fetch = original;
|
|
}
|
|
}
|
|
|
|
/** A scene the sampler accepts: low camera, one visible tileset reporting
|
|
* tilesLoaded, and a `sampleHeight` under the test's control. */
|
|
function fakeScene(sampleHeight, { cameraHeightM = 900, tilesLoaded = true, show = true } = {}) {
|
|
// instanceof-compatible without running Cesium's constructor; `tilesLoaded` is
|
|
// a prototype getter, so it has to be shadowed with an own data property.
|
|
const tileset = Object.create(Cesium.Cesium3DTileset.prototype);
|
|
Object.defineProperty(tileset, 'tilesLoaded', { value: tilesLoaded, configurable: true });
|
|
Object.defineProperty(tileset, 'show', { value: show, configurable: true });
|
|
return {
|
|
sampleHeight,
|
|
camera: { positionCartographic: { height: cameraHeightM } },
|
|
primitives: { length: 1, get: () => tileset },
|
|
};
|
|
}
|
|
|
|
function reset() {
|
|
_clearMeshFloorCellsForTest();
|
|
setMeshFloorPreferred(true);
|
|
}
|
|
|
|
test('sampler: a finite sample with NO DEM prior is stored NOWHERE', () => {
|
|
reset();
|
|
const cell = nextSite();
|
|
sampleMeshFloorCells(fakeScene(() => 138.0), [cell], { viewerLat: cell.lat, viewerLon: cell.lon });
|
|
assert.equal(cachedMeshFloor(cell.lat, cell.lon), null, 'nothing may latch without a prior');
|
|
assert.equal(cachedGroundFloor(cell.lat, cell.lon), null, 'the shared choke point stays clean');
|
|
});
|
|
|
|
test('sampler: a finite sample WITH a fitting DEM prior latches and becomes the shared floor', async () => {
|
|
reset();
|
|
const cell = nextSite();
|
|
await seedDem(cell, 120.0);
|
|
const scene = fakeScene(() => 137.0); // +17 m of mesh over bare earth — in window
|
|
sampleMeshFloorCells(scene, [cell], { viewerLat: cell.lat, viewerLon: cell.lon });
|
|
assert.equal(cachedMeshFloor(cell.lat, cell.lon), 137.0);
|
|
assert.equal(cachedGroundFloor(cell.lat, cell.lon), 137.0, 'and it is what every consumer reads');
|
|
});
|
|
|
|
test('sampler: a sample REJECTED against a real prior is stored nowhere', async () => {
|
|
reset();
|
|
const cell = nextSite();
|
|
await seedDem(cell, 120.0);
|
|
const scene = fakeScene(() => 400.0); // a tower hit — far outside the +80 m window
|
|
sampleMeshFloorCells(scene, [cell], { viewerLat: cell.lat, viewerLon: cell.lon });
|
|
assert.equal(cachedMeshFloor(cell.lat, cell.lon), null);
|
|
assert.equal(cachedGroundFloor(cell.lat, cell.lon), 120.0, 'the DEM prior still answers');
|
|
});
|
|
|
|
test('sampler: undefined, NaN and a throwing probe latch nothing and crash nothing', async () => {
|
|
reset();
|
|
const cell = nextSite();
|
|
await seedDem(cell, 120.0);
|
|
for (const bad of [() => undefined, () => Number.NaN, () => { throw new Error('mid-teardown'); }]) {
|
|
sampleMeshFloorCells(fakeScene(bad), [cell], { viewerLat: cell.lat, viewerLon: cell.lon });
|
|
assert.equal(cachedMeshFloor(cell.lat, cell.lon), null, 'no negative latch, no throw');
|
|
}
|
|
sampleMeshFloorCells(fakeScene(() => 133.0), [cell], { viewerLat: cell.lat, viewerLon: cell.lon });
|
|
assert.equal(cachedMeshFloor(cell.lat, cell.lon), 133.0, 'and a later good sample still lands');
|
|
});
|
|
|
|
test('sampler: a high camera or unloaded tiles produce no records at all', async () => {
|
|
reset();
|
|
const cell = nextSite();
|
|
await seedDem(cell, 120.0);
|
|
const opts = { viewerLat: cell.lat, viewerLon: cell.lon };
|
|
sampleMeshFloorCells(fakeScene(() => 138.0, { cameraHeightM: 90_000 }), [cell], opts);
|
|
assert.equal(cachedMeshFloor(cell.lat, cell.lon), null, 'coarse LOD under a high camera');
|
|
sampleMeshFloorCells(fakeScene(() => 138.0, { tilesLoaded: false }), [cell], opts);
|
|
assert.equal(cachedMeshFloor(cell.lat, cell.lon), null, 'mid-stream tiles read coarse');
|
|
});
|
|
|
|
test('sampler: outside the google-3d regime nothing is sampled at all', () => {
|
|
reset();
|
|
const cell = nextSite();
|
|
setMeshFloorPreferred(false);
|
|
let calls = 0;
|
|
sampleMeshFloorCells(fakeScene(() => { calls += 1; return 138.0; }), [cell],
|
|
{ viewerLat: cell.lat, viewerLon: cell.lon });
|
|
assert.equal(calls, 0, 'on a globe stack the DEM IS the rendered surface');
|
|
setMeshFloorPreferred(true);
|
|
assert.equal(cachedMeshFloor(cell.lat, cell.lon), null);
|
|
});
|
|
|
|
test('sampler: a cell just across the antimeridian is still near the viewer', () => {
|
|
reset();
|
|
let calls = 0;
|
|
const scene = fakeScene(() => { calls += 1; return undefined; });
|
|
sampleMeshFloorCells(scene, [{ lat: -16.8, lon: -179.999 }], { viewerLat: -16.8, viewerLon: 179.999 });
|
|
sampleMeshFloorCells(scene, [{ lat: -16.81, lon: 179.999 }], { viewerLat: -16.81, viewerLon: -179.999 });
|
|
assert.equal(calls, 2, 'about 200 m apart, so both cells are probed');
|
|
});
|
|
|
|
test('sampler: the probe goes where the point is, not to the cell centre', async () => {
|
|
reset();
|
|
const cell = nextSite();
|
|
await seedDem(cell, 120.0);
|
|
const asked = [];
|
|
const scene = fakeScene((carto) => {
|
|
asked.push(Cesium.Math.toDegrees(carto.longitude));
|
|
return 122.0;
|
|
});
|
|
const point = { lat: cell.lat + 0.0003, lon: cell.lon + 0.0004 };
|
|
sampleMeshFloorCells(scene, [point], { viewerLat: cell.lat, viewerLon: cell.lon });
|
|
assert.equal(asked.length, 1);
|
|
assert.ok(Math.abs(asked[0] - point.lon) < 1e-9, `probed at ${asked[0]}, not ${point.lon}`);
|
|
});
|
|
|
|
test('sampler: a viaduct and the street beside it in one cell keep their own heights', async () => {
|
|
reset();
|
|
const cell = nextSite();
|
|
await seedDem(cell, 120.0);
|
|
// A viaduct deck 9 m up along one line of the cell, the street elsewhere.
|
|
const deckLat = cell.lat + 0.0003;
|
|
let calls = 0;
|
|
const scene = fakeScene((carto) => {
|
|
calls += 1;
|
|
return Math.abs(Cesium.Math.toDegrees(carto.latitude) - deckLat) < 1e-7 ? 129.0 : 121.0;
|
|
});
|
|
const opts = { viewerLat: cell.lat, viewerLon: cell.lon };
|
|
const onDeck = { lat: deckLat, lon: cell.lon };
|
|
const street = { lat: cell.lat - 0.0003, lon: cell.lon };
|
|
sampleMeshFloorCells(scene, [onDeck], opts);
|
|
sampleMeshFloorCells(scene, [street], opts);
|
|
assert.equal(calls, 2);
|
|
assert.equal(cachedMeshFloor(onDeck.lat, onDeck.lon + 0.0001), 129.0, 'the train stays on the deck');
|
|
assert.equal(cachedMeshFloor(street.lat, street.lon - 0.0001), 121.0, 'the bus stays on the street');
|
|
assert.equal(cachedGroundFloor(street.lat, street.lon), 121.0);
|
|
sampleMeshFloorCells(scene, [{ lat: deckLat, lon: cell.lon + 0.00001 }], opts);
|
|
assert.equal(calls, 2, 'a point next to one already probed is not probed again');
|
|
});
|
|
|
|
test('sampler: a roof over the cell centre does not lift a bus on the street', async () => {
|
|
reset();
|
|
const cell = nextSite();
|
|
await seedDem(cell, 120.0);
|
|
// A roof 22 m up covering the cell's centre; the street 30 m west of it.
|
|
const scene = fakeScene((carto) =>
|
|
Math.abs(Cesium.Math.toDegrees(carto.longitude) - cell.lon) < 0.0001 ? 142.0 : 121.0);
|
|
const bus = { lat: cell.lat, lon: cell.lon - 0.0003 };
|
|
sampleMeshFloorCells(scene, [bus], { viewerLat: cell.lat, viewerLon: cell.lon });
|
|
assert.equal(cachedGroundFloor(bus.lat, bus.lon), 121.0);
|
|
});
|
|
|
|
test('sampler: a second reading at the same spot keeps the lower one', async () => {
|
|
reset();
|
|
const cell = nextSite();
|
|
await seedDem(cell, 120.0);
|
|
assert.equal(reportValidatedMeshFloorCell(cell.lat, cell.lon, 131.0), true);
|
|
assert.equal(reportValidatedMeshFloorCell(cell.lat + 0.00002, cell.lon, 122.0), true);
|
|
assert.equal(cachedMeshFloor(cell.lat, cell.lon), 122.0);
|
|
assert.equal(reportValidatedMeshFloorCell(cell.lat, cell.lon + 0.00002, 140.0), true);
|
|
assert.equal(cachedMeshFloor(cell.lat, cell.lon), 122.0, 'a higher one never raises it');
|
|
});
|
|
|
|
test('sampler: a cell with a reading is probed a few times at most', async () => {
|
|
reset();
|
|
const cell = nextSite();
|
|
await seedDem(cell, 120.0);
|
|
let calls = 0;
|
|
const scene = fakeScene(() => {
|
|
calls += 1;
|
|
return 121.0;
|
|
});
|
|
const opts = { viewerLat: cell.lat, viewerLon: cell.lon };
|
|
for (let i = 0; i < 20; i++)
|
|
sampleMeshFloorCells(
|
|
scene,
|
|
[{ lat: cell.lat - 0.0004 + (i % 5) * 0.0002, lon: cell.lon - 0.00045 + Math.floor(i / 5) * 0.0003 }],
|
|
opts,
|
|
);
|
|
assert.equal(calls, 8);
|
|
});
|
|
|
|
test('sampler: a cell with no accepted reading is probed again on every call', async () => {
|
|
reset();
|
|
const cell = nextSite();
|
|
let calls = 0;
|
|
const scene = fakeScene(() => {
|
|
calls += 1;
|
|
return 138.0;
|
|
});
|
|
const opts = { viewerLat: cell.lat, viewerLon: cell.lon };
|
|
for (let i = 0; i < 3; i++) sampleMeshFloorCells(scene, [cell], opts);
|
|
assert.equal(calls, 3, 'no DEM prior yet, so nothing is kept and the cell is retried');
|
|
await seedDem(cell, 120.0);
|
|
sampleMeshFloorCells(scene, [cell], opts);
|
|
assert.equal(cachedMeshFloor(cell.lat, cell.lon), 138.0, 'and lands once the prior is warm');
|
|
});
|
|
|
|
test('sampler: a spot whose reading is refused does not use up the cell', async () => {
|
|
reset();
|
|
const cell = nextSite();
|
|
await seedDem(cell, 120.0);
|
|
// A tower 260 m up where the first vehicle waits; the street elsewhere and
|
|
// a deck 9 m up along one line of the cell.
|
|
const towerLon = cell.lon + 0.0004;
|
|
const deckLat = cell.lat + 0.0003;
|
|
const scene = fakeScene((carto) => {
|
|
if (Math.abs(Cesium.Math.toDegrees(carto.longitude) - towerLon) < 1e-7) return 380.0;
|
|
return Math.abs(Cesium.Math.toDegrees(carto.latitude) - deckLat) < 1e-7 ? 129.0 : 121.0;
|
|
});
|
|
const opts = { viewerLat: cell.lat, viewerLon: cell.lon };
|
|
for (let i = 0; i < 10; i++) sampleMeshFloorCells(scene, [{ lat: cell.lat, lon: towerLon }], opts);
|
|
assert.equal(cachedMeshFloor(cell.lat, cell.lon), null, 'the tower is refused every time');
|
|
sampleMeshFloorCells(scene, [{ lat: cell.lat - 0.0003, lon: cell.lon }], opts);
|
|
sampleMeshFloorCells(scene, [{ lat: deckLat, lon: cell.lon - 0.0003 }], opts);
|
|
assert.equal(cachedMeshFloor(deckLat, cell.lon - 0.0003), 129.0, 'the deck is still probed');
|
|
});
|
|
|
|
test('ground floor: a cell keeps at most sixteen readings', async () => {
|
|
reset();
|
|
const cell = nextSite();
|
|
await seedDem(cell, 120.0);
|
|
for (let i = 0; i < 40; i++) {
|
|
const lat = cell.lat - 0.00045 + (i % 8) * 0.0001;
|
|
const lon = cell.lon - 0.00045 + Math.floor(i / 8) * 0.0002;
|
|
reportValidatedMeshFloorCell(lat, lon, 121.0 + i);
|
|
}
|
|
// Readings 0..15 are kept; reading 39 (at the far corner) is not, so that
|
|
// spot answers from the nearest kept one.
|
|
assert.equal(cachedMeshFloor(cell.lat - 0.00045, cell.lon - 0.00045), 121.0);
|
|
assert.equal(cachedMeshFloor(cell.lat + 0.00025, cell.lon + 0.00035), 121.0 + 15);
|
|
});
|
|
|
|
test('sampler: a spot refused while the DEM was cold is probed again once it is warm', async () => {
|
|
reset();
|
|
const cell = nextSite();
|
|
const deckLat = cell.lat + 0.0003;
|
|
let calls = 0;
|
|
const scene = fakeScene((carto) => {
|
|
calls += 1;
|
|
return Math.abs(Cesium.Math.toDegrees(carto.latitude) - deckLat) < 1e-7 ? 129.0 : 121.0;
|
|
});
|
|
const opts = { viewerLat: cell.lat, viewerLon: cell.lon };
|
|
const onDeck = { lat: deckLat, lon: cell.lon };
|
|
sampleMeshFloorCells(scene, [onDeck], opts);
|
|
assert.equal(cachedMeshFloor(onDeck.lat, onDeck.lon), null, 'no prior, nothing kept');
|
|
await seedDem(cell, 120.0);
|
|
sampleMeshFloorCells(scene, [{ lat: cell.lat - 0.0003, lon: cell.lon }], opts);
|
|
sampleMeshFloorCells(scene, [onDeck], opts);
|
|
assert.equal(calls, 3);
|
|
assert.equal(cachedMeshFloor(onDeck.lat, onDeck.lon), 129.0);
|
|
});
|
|
|
|
test('sampler: a spot refused while the DEM prior was evicted is probed again', async () => {
|
|
const { createGroundFloor } = await import('../services/groundFloor.js');
|
|
const { createMeshFloorSampler } = await import('../services/meshFloorSampler.js');
|
|
let prior = 120.0;
|
|
const terrain = {
|
|
cachedRealEllipsoidalGround: () => prior,
|
|
resolveEllipsoidalGround: async () => {},
|
|
};
|
|
const groundFloor = createGroundFloor({ terrain });
|
|
const sampler = createMeshFloorSampler({ groundFloor });
|
|
const cell = { lat: 41.5, lon: -97.66 };
|
|
const deckLat = cell.lat + 0.0003;
|
|
const scene = fakeScene((carto) =>
|
|
Math.abs(Cesium.Math.toDegrees(carto.latitude) - deckLat) < 1e-7 ? 129.0 : 121.0);
|
|
const opts = { viewerLat: cell.lat, viewerLon: cell.lon };
|
|
const onDeck = { lat: deckLat, lon: cell.lon };
|
|
sampler.sampleMeshFloorCells(scene, [{ lat: cell.lat - 0.0003, lon: cell.lon }], opts);
|
|
prior = null; // the cell's DEM entry is evicted; the street reading stays
|
|
sampler.sampleMeshFloorCells(scene, [onDeck], opts);
|
|
assert.equal(groundFloor.cachedMeshFloor(onDeck.lat, onDeck.lon), 121.0);
|
|
prior = 120.0;
|
|
sampler.sampleMeshFloorCells(scene, [onDeck], opts);
|
|
assert.equal(groundFloor.cachedMeshFloor(onDeck.lat, onDeck.lon), 129.0);
|
|
});
|