mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-21 10:42:22 +00:00
Road waypoints are plain ECEF points from the geo helpers (the same formulas as before, so every waypoint and segment length is unchanged), and the palette is renderer colours. The style part, still on the point primitives, turns those into the points' colours once per colour and owns the dot painting the model used to do itself; the rendering part converts them for the heat lines. The animation keeps its own lerp scratch, and the ingestion's centre height asks with plain degrees. Ingestion, model, policy, state and timing leave the allow-list.
412 lines
15 KiB
JavaScript
412 lines
15 KiB
JavaScript
import { fromDegrees } from '../../geo/ellipsoid.js';
|
||
import { distance } from '../../geo/vector.js';
|
||
import { roadSurfaceChunks } from './surface.js';
|
||
import { t, translateKnown } from '../../i18n/index.js';
|
||
import {
|
||
flowDensityMult,
|
||
flowBucket,
|
||
flowSpeedScale,
|
||
} from '../../data/trafficFlowStyle.js';
|
||
import { DOT_HEIGHT_OFFSET, DENSITY_MULT } from './policy.js';
|
||
|
||
export function createModel({ state: layerState, services, parts, source }) {
|
||
/** Build scene waypoints from source records; thinning and terrain remain rendering policy. */
|
||
function parseRoads(roadData) {
|
||
if (!roadData || !roadData.roads) {
|
||
return [];
|
||
}
|
||
|
||
const roads = [];
|
||
for (const road of roadData.roads) {
|
||
if (!road.coordinates || road.coordinates.length < 2) continue;
|
||
|
||
for (const coords of roadSurfaceChunks(road.coordinates)) {
|
||
const type = road.type;
|
||
const oneway = road.oneway;
|
||
// Pre-compute ECEF waypoints (lon, lat, height) for fast lerp animation
|
||
const waypoints = coords.map(([lng, lat]) => {
|
||
const floor = services.ground?.cachedGroundFloor?.(lat, lng);
|
||
const h =
|
||
(Number.isFinite(floor) && Math.abs(floor) <= 9000
|
||
? floor
|
||
: layerState._viewHeightEstimate || 0) + DOT_HEIGHT_OFFSET;
|
||
return fromDegrees(lng, lat, h);
|
||
});
|
||
|
||
// Pre-compute segment distances in meters for speed-to-t conversion
|
||
const segmentDist = [];
|
||
for (let i = 0; i < waypoints.length - 1; i++) {
|
||
segmentDist.push(distance(waypoints[i], waypoints[i + 1]));
|
||
}
|
||
|
||
for (const direction of oneway ? [oneway] : [1, -1])
|
||
roads.push({
|
||
densityWeight: road.densityWeight ?? (oneway ? 1 : 0.5),
|
||
drivable: road.drivable,
|
||
roadClass: road.roadClass,
|
||
roadProperties: road.roadProperties,
|
||
directFlow: road.directFlow,
|
||
simulatedOnly: road.simulatedOnly,
|
||
coords,
|
||
type,
|
||
oneway: direction,
|
||
waypoints,
|
||
segmentDist,
|
||
flow: road.flow || null,
|
||
});
|
||
}
|
||
}
|
||
|
||
return roads;
|
||
}
|
||
|
||
// ─── Road Length Estimation ────────────────────────────────
|
||
|
||
/**
|
||
* Estimate the total length of a road in meters from its degree-based coordinates.
|
||
*
|
||
* Uses Euclidean distance in degree-space then multiplies by the equatorial
|
||
* approximation of 111 km per degree. Accurate enough for dot density spacing
|
||
* but not for navigation.
|
||
*
|
||
* @param {number[][]} coords - Array of [lon, lat] pairs.
|
||
* @returns {number} Approximate road length in meters.
|
||
*/
|
||
|
||
function estimateRoadLengthDeg(coords) {
|
||
let len = 0;
|
||
for (let i = 0; i < coords.length - 1; i++) {
|
||
const dx = coords[i + 1][0] - coords[i][0];
|
||
const dy = coords[i + 1][1] - coords[i][1];
|
||
len += Math.sqrt(dx * dx + dy * dy);
|
||
}
|
||
// Rough conversion: 1 degree ~ 111,000 meters at equator
|
||
return len * 111000;
|
||
}
|
||
|
||
// ─── Dot Spawning ──────────────────────────────────────────
|
||
|
||
/**
|
||
* Compute the ideal number of dots for a single road at a given camera altitude.
|
||
*
|
||
* Spacing increases with altitude so fewer dots are rendered when zoomed out.
|
||
* The result is further scaled by the road-type density multiplier and the
|
||
* user-adjustable `_densityScale`.
|
||
*
|
||
* @param {{coords:number[][], type:string}} road - Parsed road object.
|
||
* @param {number} altitude - Current camera altitude in meters.
|
||
* @returns {number} Ideal dot count (minimum 1).
|
||
*/
|
||
|
||
function computeDotCount(road, altitude) {
|
||
// Live flow: closed roads carry zero traffic; congestion packs more dots.
|
||
// `road.flow` is only ever set in live mode, so the keyless path is
|
||
// untouched (flow stays undefined → multiplier 1, identical output).
|
||
const flow = layerState._liveMode ? road.flow : null;
|
||
if (flow?.closure) return 0;
|
||
// Strict data-integrity view: uncovered roads spawn nothing when hidden.
|
||
if (layerState._liveMode && !flow && layerState._uncoveredMode === 'hide')
|
||
return 0;
|
||
|
||
const lengthM = estimateRoadLengthDeg(road.coords);
|
||
|
||
// Altitude-adaptive spacing: closer camera = denser dots
|
||
const clearance = Math.max(
|
||
0,
|
||
altitude - (layerState._viewHeightEstimate || 0),
|
||
);
|
||
let spacing;
|
||
if (clearance < 1000) spacing = 30;
|
||
else if (clearance < 3000) spacing = 80;
|
||
else if (clearance < 5000) spacing = 150;
|
||
else spacing = 250;
|
||
|
||
const mult =
|
||
(DENSITY_MULT[road.type] || 1) *
|
||
layerState._densityScale *
|
||
(flow
|
||
? flowDensityMult(flow.level, { jamBoost: parts.style.jamDensityOn() })
|
||
: 1);
|
||
return Math.max(
|
||
1,
|
||
Math.floor((lengthM / spacing) * mult * (road.densityWeight || 1)),
|
||
);
|
||
}
|
||
|
||
/**
|
||
* Distribute a fixed dot budget fairly across all visible roads.
|
||
*
|
||
* Algorithm:
|
||
* 1. Compute ideal dot count per road via `computeDotCount`.
|
||
* 2. Seed one dot to every road that wants at least one (fairness pass).
|
||
* 3. Distribute remaining budget proportionally to each road's ideal count.
|
||
* 4. Assign leftover dots (from floor rounding) to roads with the highest
|
||
* fractional residuals (largest-remainder method).
|
||
*
|
||
* This prevents high-density motorways from starving smaller residential roads
|
||
* when the global MAX_DOTS cap is reached.
|
||
*
|
||
* @param {Array} roads - Parsed road objects.
|
||
* @param {number} altitude - Camera altitude in meters (affects spacing).
|
||
* @param {number} dotCap - Maximum total dots to allocate.
|
||
* @returns {number[]} Per-road dot budgets, same length as `roads`.
|
||
*/
|
||
|
||
function allocateRoadDotBudgets(roads, altitude, dotCap) {
|
||
const planned = roads.map((road) => computeDotCount(road, altitude));
|
||
const budgets = new Array(roads.length).fill(0);
|
||
let remaining = Math.max(0, dotCap);
|
||
|
||
// Pass 1 — fairness seed: give one dot to every road (highest-demand first)
|
||
const firstPassOrder = planned
|
||
.map((count, index) => ({ count, index }))
|
||
.sort((a, b) => b.count - a.count);
|
||
|
||
for (const entry of firstPassOrder) {
|
||
if (remaining <= 0) break;
|
||
if (entry.count <= 0) continue;
|
||
budgets[entry.index] = 1;
|
||
remaining -= 1;
|
||
}
|
||
|
||
if (remaining <= 0) return budgets;
|
||
|
||
// Pass 2 — proportional distribution of the remaining budget
|
||
let totalRemainder = 0;
|
||
for (let i = 0; i < planned.length; i++) {
|
||
totalRemainder += Math.max(0, planned[i] - budgets[i]);
|
||
}
|
||
if (totalRemainder <= 0) return budgets;
|
||
|
||
const residuals = [];
|
||
let assigned = 0;
|
||
for (let i = 0; i < planned.length; i++) {
|
||
const cap = Math.max(0, planned[i] - budgets[i]);
|
||
if (cap <= 0) continue;
|
||
const ideal = (cap / totalRemainder) * remaining;
|
||
const add = Math.min(cap, Math.floor(ideal));
|
||
budgets[i] += add;
|
||
assigned += add;
|
||
residuals.push({ index: i, residual: ideal - add });
|
||
}
|
||
|
||
// Pass 3 — largest-remainder: hand out leftover dots from floor rounding
|
||
let leftover = remaining - assigned;
|
||
if (leftover > 0 && residuals.length > 0) {
|
||
residuals.sort((a, b) => b.residual - a.residual);
|
||
let cursor = 0;
|
||
while (leftover > 0 && residuals.length > 0) {
|
||
const idx = residuals[cursor % residuals.length].index;
|
||
if (budgets[idx] < planned[idx]) {
|
||
budgets[idx] += 1;
|
||
leftover -= 1;
|
||
}
|
||
cursor += 1;
|
||
// Safety valve: avoid infinite loop if all roads are already at their ideal
|
||
if (cursor > residuals.length * 3 && leftover > 0) break;
|
||
}
|
||
}
|
||
|
||
return budgets;
|
||
}
|
||
|
||
/**
|
||
* Derive the layer's honest feed presentation from its live-flow state.
|
||
*
|
||
* The three states a user can be in, and what each must read as:
|
||
* - keyless → `mode:'sim'` (the manager maps that to a FALLBACK chip) with a
|
||
* label that never claims live data;
|
||
* - live and healthy → LIVE with real coverage;
|
||
* - live but flow-down → an `error` string, so the chip degrades and says
|
||
* the colors on screen are simulated. Never a stale "LIVE · N% cov".
|
||
*
|
||
* @param {Object} [input]
|
||
* @param {boolean} [input.liveMode] - `/api/tomtom/status` reported a key.
|
||
* @param {boolean} [input.fetching] - A viewport load is in flight.
|
||
* @param {string|null} [input.flowError] - `deriveTrafficFlowError` result, if any.
|
||
* @param {boolean} [input.stale] - The flow came from cached proxy tiles.
|
||
* @param {number} [input.coveragePct] - Share of shown dots on matched roads, 0–100.
|
||
* @param {boolean} [input.statusUnavailable] - The status probe itself failed.
|
||
* @param {string} [input.roadSource] - Name of the geometry being drawn.
|
||
* @returns {{mode:'live'|'sim', error:string|null, loadingLabel:string}}
|
||
*/
|
||
|
||
function trafficFeedPresentation({
|
||
liveMode = false,
|
||
fetching = false,
|
||
flowError = null,
|
||
stale = false,
|
||
coveragePct = 0,
|
||
statusUnavailable = false,
|
||
roadSource = 'OpenStreetMap',
|
||
} = {}) {
|
||
// `mode` is the CONFIGURED source (live key present vs keyless), not this
|
||
// instant's health — health rides on `error`. The qa-traffic harness pins
|
||
// that meaning.
|
||
const mode = liveMode ? 'live' : 'sim';
|
||
if (liveMode && flowError) {
|
||
// One string for both fields. The manager's meta line renders `error` and
|
||
// drops `loadingLabel` in its error branch, so the owner's SIMULATED copy
|
||
// has to BE the error text or the steady state reverts to a bare
|
||
// "TomTom daily budget reached" that never says what is on screen.
|
||
// The reason is ours (flow.js marks it) or carries an HTTP code.
|
||
const degraded = t('SIMULATED — {reason}', {
|
||
reason: translateKnown(flowError),
|
||
});
|
||
return { mode, error: degraded, loadingLabel: degraded };
|
||
}
|
||
// Cached proxy tiles (TomTom budget spent or upstream failing) are not live.
|
||
if (liveMode && stale && !fetching) {
|
||
return {
|
||
mode,
|
||
error: null,
|
||
loadingLabel: t('STALE · Roads: {source} · Flow: cached TomTom tiles', {
|
||
source: roadSource,
|
||
}),
|
||
};
|
||
}
|
||
// TomTom and Hybrid name their geometry; OpenStreetMap keeps its match copy.
|
||
if (liveMode && roadSource === 'TomTom') {
|
||
return {
|
||
mode,
|
||
error: null,
|
||
loadingLabel: fetching
|
||
? t('Syncing flow · Roads: {source}', { source: roadSource })
|
||
: coveragePct > 0
|
||
? t('LIVE · Roads: {source} · Roads without flow hidden', {
|
||
source: roadSource,
|
||
})
|
||
: t('LIVE · Roads: {source} · No flow roads in view', {
|
||
source: roadSource,
|
||
}),
|
||
};
|
||
}
|
||
if (liveMode && roadSource === 'TomTom + OpenStreetMap') {
|
||
return {
|
||
mode,
|
||
error: null,
|
||
loadingLabel: fetching
|
||
? t('Syncing flow · Roads: {source}', { source: roadSource })
|
||
: coveragePct > 0
|
||
? t('LIVE · Roads: {source} · Flow {percent}%', {
|
||
source: roadSource,
|
||
percent: coveragePct,
|
||
})
|
||
: t('SIMULATED · Roads: {source} · Flow {percent}%', {
|
||
source: roadSource,
|
||
percent: coveragePct,
|
||
}),
|
||
};
|
||
}
|
||
if (liveMode) {
|
||
return {
|
||
mode,
|
||
error: null,
|
||
loadingLabel: fetching
|
||
? t(
|
||
'Syncing flow · Roads: OpenStreetMap · Flow: TomTom · Unmatched: simulated',
|
||
)
|
||
: coveragePct > 0
|
||
? coveragePct < 100
|
||
? t(
|
||
'LIVE · Roads: OpenStreetMap · Flow: TomTom · {percent}% cov · Unmatched: simulated',
|
||
{
|
||
percent: coveragePct,
|
||
},
|
||
)
|
||
: t(
|
||
'LIVE · Roads: OpenStreetMap · Flow: TomTom · {percent}% cov',
|
||
{
|
||
percent: coveragePct,
|
||
},
|
||
)
|
||
: t('SIMULATED · Roads: OpenStreetMap · Flow: TomTom (no matches)'),
|
||
};
|
||
}
|
||
// Keyless simulation — one terse line that names the mode and the remedy
|
||
// (owner's copy shape). The chip's own progress text carries "working";
|
||
// this line must never imply a live feed.
|
||
return {
|
||
mode,
|
||
error: null,
|
||
loadingLabel: statusUnavailable
|
||
? t('SIMULATED — traffic service unreachable')
|
||
: t('SIMULATED — add TomTom key for live'),
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Apply late-arriving flow data to already-rendered dots without a respawn:
|
||
* color, jam size, and speed update in place; closed roads' dots hide.
|
||
* Density bunching intentionally waits for the next natural re-render —
|
||
* color and speed are the live signal, dot count is a refinement.
|
||
* @param {string} label - Render log label (for the console trace).
|
||
*/
|
||
|
||
function recolorDotsInPlace(label) {
|
||
if (!layerState._liveMode || !layerState._dots.length) return;
|
||
layerState._bucketCounts = { free: 0, slow: 0, jam: 0, sim: 0 };
|
||
let closedDots = 0;
|
||
const now = Date.now();
|
||
for (const dot of layerState._dots) {
|
||
const flow = dot.road?.source ? dot.road.source.flow : dot.road?.flow;
|
||
dot.road.flow = flow;
|
||
if (flow?.closure || (!flow && layerState._uncoveredMode === 'hide')) {
|
||
parts.style.showDot(dot, false);
|
||
dot.mps = 0;
|
||
closedDots += 1;
|
||
continue;
|
||
}
|
||
parts.style.showDot(dot, true);
|
||
const bucket = flow ? flowBucket(flow.level) : null;
|
||
dot.bucket = bucket;
|
||
parts.style.paintDot(dot, bucket);
|
||
dot.nominalSize =
|
||
parts.style.baseDotSize(dot.road?.type, bucket) +
|
||
(bucket === 'jam' ? 1 : 0) +
|
||
parts.style.activeSizeDelta(bucket);
|
||
// Late flow can move a dot between buckets — keep the preset halo in
|
||
// step (no-op writes under the normal profile, whose dots have none).
|
||
if (parts.style.presetProfileActive())
|
||
parts.style.applyOutline(dot.point, bucket);
|
||
dot.mps = dot.baseMps * (flow ? flowSpeedScale(flow.level) : 1);
|
||
// Late flow tags/untags stop-and-go creep + city-scale prominence the
|
||
// same way it rescales speed. Queue *positions* wait for the next
|
||
// natural re-render, like density bunching.
|
||
if (bucket === 'jam' && parts.style.jamDensityOn()) {
|
||
if (!dot.creep)
|
||
dot.creep = {
|
||
moving: Math.random() < 0.4,
|
||
until: now + Math.random() * 2000,
|
||
};
|
||
parts.style.emphasizeJamDot(dot);
|
||
} else {
|
||
dot.creep = null;
|
||
}
|
||
layerState._bucketCounts[bucket || 'sim'] += 1;
|
||
}
|
||
layerState._count = layerState._dots.length - closedDots;
|
||
layerState._closedRoads = layerState._roads.reduce(
|
||
(n, r) => n + (r.flow?.closure ? 1 : 0),
|
||
0,
|
||
);
|
||
parts.rendering.rebuildHeatLines(
|
||
parts.rendering.visibleRoadsForAltitude(
|
||
layerState._roads,
|
||
layerState._lastRenderAltitude,
|
||
),
|
||
);
|
||
console.log(
|
||
`[Data:Traffic] Flow recolor (${label}): ${layerState._dots.length} dots, closedDots=${closedDots}`,
|
||
);
|
||
}
|
||
return {
|
||
parseRoads,
|
||
estimateRoadLengthDeg,
|
||
computeDotCount,
|
||
allocateRoadDotBudgets,
|
||
trafficFeedPresentation,
|
||
recolorDotsInPlace,
|
||
};
|
||
}
|