Files
gods-eye-view/src/layers/traffic/heatLines.test.mjs
T
Sameh Khamis 26633106fc Traffic surface keys and readiness through the globe port; draped lines fall back to overlay where the scene cannot drape
The traffic layer keys its cached road heights by the globe port's
surfaceVersion() and waits on isSettled('surface') instead of reading the
scene through render/cesium/surfaceState.js, which is gone. Heat-lines are
always asked for draped; the layer no longer checks whether the scene can
drape and drops them. The traffic layer and application/sources no longer
reach Cesium, and src/layers/traffic/rendering.js leaves the Cesium list.

Where the Cesium renderer cannot drape (no depth textures), its draw port
now draws every draped line over the surface, as the contract asks: along
the surface's curve between its positions, in its colour where the surface
hides it, hidden past the horizon (tested along its arc, shown in 2D). A
segmented line runs from its first shown segment to its last, in its style
colour. A line whose positions hold what they held takes a new colour in
place, so pulsing jam lines build nothing per frame; one that moves is
built anew alone.
2026-11-09 03:10:29 -08:00

147 lines
4.9 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import { createRendering } from './rendering.js';
import { fakeDrawPort } from '../../testSupport/fakeDrawPort.mjs';
import {
HEAT_JAM_BASE_ALPHA,
HEAT_JAM_COLOR,
HEAT_JAM_PULSE_ALPHA,
HEAT_LINE_CAP,
HEAT_LINE_JAM_WIDTH,
HEAT_LINE_SLOW_WIDTH,
HEAT_SLOW_COLOR,
} from './policy.js';
/** A road of `length` metres along x, in the flow bucket `level` gives. */
const road = (level, length = 100, x = 0) => ({
flow: { level },
segmentDist: [length],
waypoints: [
{ x, y: 6378137, z: 0 },
{ x: x + length, y: 6378137, z: 0 },
],
});
function setup({ live = true, heatline = true, preset = 'normal' } = {}) {
const draw = fakeDrawPort();
const demand = [];
const state = {
_viewer: {},
_liveMode: live,
_presetDots: 'on',
_stylePreset: preset,
_heatJam: [],
_heatLineCount: 0,
_heatSet: draw.lines({ id: 'traffic:1:heat', clampTo: 'tiles' }),
};
const rendering = createRendering({
state,
services: {},
parts: {
style: { heatlineOn: () => heatline },
animation: { syncRenderDemand: () => demand.push(state._heatLineCount) },
},
source: {},
});
const items = () => [...draw.set('traffic:1:heat').items.values()];
return {
state,
rendering,
items,
demand,
record: draw.set('traffic:1:heat'),
};
}
test('congested roads drape heat-lines on the tiles: jam glowing, slow flat', () => {
const { state, rendering, items, demand } = setup();
rendering.rebuildHeatLines([
road(0.9), // free: none
road(0.2, 50, 1), // jam
road(0.6, 80, 2), // slow
{ ...road(0.2), flow: { level: 0.2, closure: true } }, // closed: none
]);
const lines = items();
assert.equal(lines.length, 2);
const [jam, slow] = lines;
assert.equal(jam.mode, 'draped');
assert.equal(jam.clampTo, 'tiles');
assert.equal(jam.widthPx, HEAT_LINE_JAM_WIDTH);
assert.deepEqual(jam.style, {
kind: 'glow',
color: [...HEAT_JAM_COLOR.slice(0, 3), HEAT_JAM_BASE_ALPHA],
power: 0.25,
});
assert.deepEqual(jam.positions, [
{ x: 1, y: 6378137, z: 0 },
{ x: 51, y: 6378137, z: 0 },
]);
assert.equal(slow.widthPx, HEAT_LINE_SLOW_WIDTH);
assert.deepEqual(slow.style, { kind: 'solid', color: HEAT_SLOW_COLOR });
assert.equal(state._heatLineCount, 2);
assert.equal(rendering.heatPulsing(), true);
assert.deepEqual(demand, [2]);
});
test('the jam heat-lines pulse together, recoloured where they are', () => {
const { rendering, items, record } = setup();
rendering.rebuildHeatLines([road(0.2), road(0.25, 50), road(0.6)]);
const writes = record.writes;
rendering.pulseHeatLines(260 * (Math.PI / 2));
assert.equal(record.writes, writes + 1, 'one upsert a frame');
const alpha = HEAT_JAM_BASE_ALPHA + HEAT_JAM_PULSE_ALPHA;
const [a, b, slow] = items();
assert.ok(Math.abs(a.style.color[3] - alpha) < 1e-12);
assert.equal(b.style, a.style);
assert.equal(slow.style.kind, 'solid', 'slow lines do not pulse');
});
test('heat-lines are capped jam first, longest first', () => {
const { items } = (() => {
const s = setup();
const roads = [];
for (let i = 0; i < HEAT_LINE_CAP; i++) roads.push(road(0.6, 10 + i));
roads.push(road(0.2, 5));
s.rendering.rebuildHeatLines(roads);
return s;
})();
const lines = items();
assert.equal(lines.length, HEAT_LINE_CAP);
assert.equal(lines[0].style.kind, 'glow', 'the jam line kept first');
assert.equal(lines[1].widthPx, HEAT_LINE_SLOW_WIDTH);
assert.equal(lines[1].positions[1].x, 10 + HEAT_LINE_CAP - 1);
});
test('mono presets draw heat-lines in luminance', () => {
const { rendering, items } = setup({ preset: 'surveillance' });
rendering.rebuildHeatLines([road(0.2), road(0.6)]);
const [jam, slow] = items();
assert.deepEqual(jam.style.color, [1, 1, 1, HEAT_JAM_BASE_ALPHA]);
assert.deepEqual(slow.style.color, [0.7, 0.7, 0.7, HEAT_SLOW_COLOR[3]]);
});
test('no heat-lines in simulation or with the mode off, and removal empties the set', () => {
for (const options of [{ live: false }, { heatline: false }]) {
const { rendering, items, record } = setup(options);
rendering.rebuildHeatLines([road(0.2)]);
assert.equal(items().length, 0);
assert.equal(record.writes, 0, 'an empty set is left alone');
assert.equal(rendering.heatPulsing(), false);
}
const { state, rendering, items } = setup();
rendering.rebuildHeatLines([road(0.2)]);
rendering.removeHeatLines();
assert.equal(items().length, 0);
assert.equal(state._heatLineCount, 0);
assert.equal(rendering.heatPulsing(), false);
rendering.pulseHeatLines(0);
assert.equal(items().length, 0, 'nothing to pulse');
});
test('heat-lines are asked for draped whatever the renderer, with no check of their own', () => {
const { rendering, items } = setup();
rendering.rebuildHeatLines([road(0.2)]);
assert.equal(items().length, 1);
assert.equal(items()[0].mode, 'draped');
});