Files
gods-eye-view/src/layers/traffic/source.js
T
manjunath d4434aa6d7 feat(outlines): restore voice outlines without public Overpass
use bundled place boundaries and shared OpenFreeMap tiles before a guarded Nominatim fallback

preserve multipart shapes, holes and cancellation,
and keep pending annotations visible while ground sampling finishes across frames

keep non-Latin name distinctions when selecting provider results,
and retain an outline anchor only when it lies in filled geometry
2026-10-27 13:24:02 +00:00

382 lines
13 KiB
JavaScript

import {
createHybridFill,
flowSegmentsToRoads,
resolveRoadMode,
ROAD_SOURCE_LABELS,
} from './roadModes.js';
import { phaseTiming } from '../../sources/phaseTiming.js';
import { createFlowTileSource } from './flowSource.js';
import { tileToBBox, tilesForBounds } from '../../data/tomtomTiles.js';
import { clipTileLine } from '../../sources/openFreeMap.js';
import { createOpenFreeMapSource } from '../../sources/openFreeMap.js';
import { validTileBounds } from '../../sources/vectorTiles.js';
export { normalizeOverpassRoads } from '../../sources/overpassRoads.js';
/** Shrink only the detail footprint, centered on the look-at fetch box, to fit 16 tiles. */
export function trafficDetailBounds(box) {
const center = {
lat: (box.north + box.south) / 2,
lon: (box.east + box.west) / 2,
};
let detail = { ...box };
while (tilesForBounds(detail, 14, { maxTiles: 17 }).length > 16) {
detail = {
south: center.lat + (detail.south - center.lat) * 0.9,
north: center.lat + (detail.north - center.lat) * 0.9,
west: center.lon + (detail.west - center.lon) * 0.9,
east: center.lon + (detail.east - center.lon) * 0.9,
};
}
return detail;
}
/** Keep coarse roads only outside the detailed tile cores. */
export function outsideDetailTiles(roads, tiles) {
return roads.flatMap((road) => {
let lines = [road.coordinates];
for (const tile of tiles) {
const box = tileToBBox(tile.z, tile.x, tile.y);
const regions = [
{ west: -180, east: box.west, south: -85, north: 85 },
{ west: box.east, east: 180, south: -85, north: 85 },
{ west: box.west, east: box.east, south: -85, north: box.south },
{ west: box.west, east: box.east, south: box.north, north: 85 },
];
lines = lines.flatMap((line) =>
regions.flatMap((region) => clipTileLine(line, region)),
);
}
return lines.map((coordinates) => ({ ...road, coordinates }));
});
}
/** A classified road failure with a display-safe reason and machine-readable status. */
export class RoadRequestError extends Error {
constructor(message, { status = null, cause } = {}) {
super(message, { cause });
this.name = 'RoadRequestError';
this.status = status;
}
}
// AI tool services import this module, so it marks its English with a local
// msg(); the traffic panel translates the message (controls.js).
const msg = (text) => text;
/** Name the road upstream without exposing raw transport errors or missing codes. */
export function roadRequestError(status, cause) {
const code = Number.isFinite(status) ? status : null;
const message =
code === 429
? msg('OpenFreeMap tiles rate-limited')
: code === 504 || cause?.name === 'TimeoutError'
? msg('OpenFreeMap tiles timed out')
: code === null
? msg('OpenFreeMap tiles unavailable')
: `OpenFreeMap tiles unavailable (HTTP ${code})`;
return Object.assign(new RoadRequestError(message, { status: code, cause }), {
retryable: cause?.retryable !== false,
code: cause?.code,
});
}
/** Supply tile-derived road geometry and flow availability without Overpass queries. */
export function createTrafficSource({
fetchImpl = (...args) => globalThis.fetch(...args),
tileFetchImpl = (...args) => globalThis.fetch(...args),
mapTiles = createOpenFreeMapSource({
fetchImpl: tileFetchImpl,
selectDecoded: ({ roads }) => ({ roads }),
}),
} = {}) {
const flow = createFlowTileSource({ fetchImpl });
const api = {
...flow,
prefetch: () => mapTiles.getMetadata().catch(() => {}),
resetFlowTileCache() {
flow.resetFlowTileCache();
mapTiles.clear();
},
async requestOsmRoads(
box,
{ majorOnly = false, signal, onTile, coverage = box.coverage } = {},
) {
if (
!validTileBounds(box) ||
box.north - box.south > 10 ||
box.east - box.west > 10
)
throw new TypeError('A bounded road viewport is required');
if (coverage) {
try {
const tileSnapshot = (tile) =>
onTile?.({
roads: tile.roads,
roadSource: 'OpenStreetMap',
roadMode: 'osm',
});
// Start nearest detail tiles before the coarse pass consumes workers.
const detailJob =
!majorOnly && coverage.detail.length
? mapTiles
.fetchBounds(box, {
zoom: 14,
tiles: coverage.detail,
signal,
onTile: onTile ? tileSnapshot : undefined,
})
.catch((error) => {
signal?.throwIfAborted();
if (
error?.name === 'AbortError' ||
error?.retryable === false
)
throw error;
return { tiles: [], loadedTiles: [], partial: true };
})
: null;
const coarseJob = mapTiles.fetchBounds(box, {
zoom: 12,
tiles: coverage.coarse,
signal,
onTile: majorOnly && onTile ? tileSnapshot : undefined,
});
const [detail, coarse] = await Promise.all([detailJob, coarseJob]);
signal?.throwIfAborted();
let roads = coarse.tiles.flatMap((tile) => tile.roads),
partial = coarse.partial;
if (detail) {
roads = [
...detail.tiles.flatMap((tile) => tile.roads),
...outsideDetailTiles(
roads,
detail.loadedTiles || (detail.partial ? [] : coverage.detail),
),
];
partial ||= detail.partial;
}
const data = {
roads,
roadSource: 'OpenStreetMap',
roadMode: 'osm',
partial,
detailLimited: false,
replace: true,
};
if (!majorOnly) onTile?.(data);
return {
ok: true,
status: 200,
headers: new Headers(),
json: async () => data,
};
} catch (error) {
signal?.throwIfAborted();
if (error?.name === 'AbortError') throw error;
throw roadRequestError(error?.status, error);
}
}
const area = majorOnly ? box : trafficDetailBounds(box);
const snapshot = (tiles, partial = false) => ({
roads: tiles
.flatMap((tile) => tile.roads)
.flatMap((road) =>
clipTileLine(road.coordinates, area).map((coordinates) => ({
...road,
coordinates,
})),
),
roadSource: 'OpenStreetMap',
roadMode: 'osm',
partial,
detailLimited:
!majorOnly && (area.north !== box.north || area.east !== box.east),
detailBounds: majorOnly ? null : area,
});
let result;
try {
result = await mapTiles.fetchBounds(area, {
zoom: majorOnly ? 12 : 14,
signal,
onTile: onTile ? (tile) => onTile(snapshot([tile])) : undefined,
});
} catch (error) {
signal?.throwIfAborted();
if (error?.name === 'AbortError') throw error;
throw roadRequestError(error?.status, error);
}
const data = snapshot(result.tiles, result.partial);
signal?.throwIfAborted();
return {
ok: true,
status: 200,
headers: new Headers(),
async json() {
return data;
},
};
},
async getStatus({ signal } = {}) {
const start = performance.now();
const timeout = AbortSignal.timeout(8000);
const response = await fetchImpl('/api/tomtom/status', {
signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
});
if (!response.ok)
throw Object.assign(new Error('TomTom status unavailable'), {
status: Number.isFinite(response.status) ? response.status : null,
});
const status = await response.json();
signal?.throwIfAborted();
if (typeof status?.hasKey !== 'boolean')
throw new Error('Malformed traffic status');
phaseTiming('status', start);
return status;
},
};
/**
* Request roads for the selected road source.
*
* `osm` streams OpenFreeMap tiles exactly as before. `tomtom` and `hybrid`
* wait for the flow snapshot the layer started alongside road acquisition;
* OpenFreeMap tiles stream meanwhile (Hybrid) and are drawn unfiltered until
* flow arrives, then one replacing snapshot swaps in TomTom lines and drops
* the duplicated OpenFreeMap stretches. Later tiles publish only their own
* fill, so parsing stays incremental. TomTom never requests OpenFreeMap
* unless the missing key forces the OpenStreetMap fallback.
*
* @param {{south:number, west:number, north:number, east:number}} box
* @param {Object} [options]
* @param {'tomtom'|'osm'|'hybrid'|null} [options.roadMode] - Requested mode (null = default).
* @param {Promise<{segments:Array, hasKey:boolean, error?:string, partial?:boolean}>} [options.flowSnapshot]
* @param {() => boolean} [options.liveModeHint] - Key state if the snapshot misses the pass deadline.
* @param {number} [options.timeoutSec=20] - Pass deadline, also bounding the snapshot wait.
* @param {(data:Object) => void} [options.onTile] - Incremental snapshots; `replace` resets.
*/
api.requestRoads = async (
box,
{
roadMode = null,
flowSnapshot,
liveModeHint = () => false,
onTile,
...options
} = {},
) => {
if (
!validTileBounds(box) ||
box.north - box.south > 10 ||
box.east - box.west > 10
)
throw new TypeError('A bounded road viewport is required');
if (roadMode === 'osm' || !flowSnapshot)
return api.requestOsmRoads(box, { ...options, onTile });
const signal = options.signal;
const osm = [];
let live = null,
mode = null,
metadata = {},
osmError = null,
tomtom = [],
fillFor = null;
const fillMemo = new Map();
const fill = (roads) =>
mode === 'hybrid'
? roads.flatMap((road) => {
if (!fillMemo.has(road)) fillMemo.set(road, fillFor(road));
return fillMemo.get(road);
})
: roads;
// Hybrid without any TomTom line (flow failed, or none here) draws only
// OpenStreetMap roads, and says so.
const source = () =>
!mode || (mode === 'hybrid' && !tomtom.length)
? ROAD_SOURCE_LABELS.osm
: ROAD_SOURCE_LABELS[mode];
const snapshot = (roads, replace) => ({
...metadata,
roads,
roadSource: source(),
roadMode: mode,
replace,
partial: Boolean(metadata.partial || osmError || live?.partial),
roadWarning: osmError && mode !== 'osm' ? osmError.message : null,
});
const publish = (roads, replace = false) => {
if (!signal?.aborted) onTile?.(snapshot(roads, replace));
};
const composed = () =>
mode === 'tomtom' ? tomtom : [...tomtom, ...fill(osm)];
const loadOsm = async () => {
try {
const response = await api.requestOsmRoads(box, {
...options,
onTile: (data) => {
if (data.replace) osm.splice(0, osm.length, ...data.roads);
else osm.push(...data.roads);
metadata = { ...data, roads: undefined };
// Before flow settles the tile is drawn as plain OpenStreetMap.
publish(
data.replace ? composed() : fill(data.roads),
Boolean(data.replace),
);
},
});
const data = await response.json();
metadata = { ...data, roads: undefined };
// Every tile streams through onTile; adopt the final list if not.
if (osm.length !== data.roads.length)
osm.splice(0, osm.length, ...data.roads);
} catch (error) {
if (error?.name === 'AbortError' || signal?.aborted) throw error;
osmError = error;
}
};
const osmJob = roadMode === 'tomtom' ? null : loadOsm();
osmJob?.catch(() => {});
// The snapshot waits on the status probe and flow tiles; never let it
// hold the road pass past its own deadline. A late snapshot counts as a
// flow failure: TomTom mode reports it, Hybrid falls back to OSM roads.
let deadline;
live = await Promise.race([
flowSnapshot,
new Promise((resolve) => {
deadline = setTimeout(
() =>
resolve({
segments: [],
hasKey: Boolean(liveModeHint()),
error: 'TomTom flow timed out',
}),
(options.timeoutSec ?? 20) * 1000,
);
}),
]).finally(() => clearTimeout(deadline));
signal?.throwIfAborted();
if (!live)
throw new TypeError(
'Road selection requires a flow availability snapshot',
);
mode = resolveRoadMode(roadMode, live.hasKey);
if (mode === 'tomtom' && live.error) throw new RoadRequestError(live.error);
if (mode !== 'osm') {
tomtom = flowSegmentsToRoads(live.segments);
fillFor = createHybridFill(live.segments);
publish(composed(), true);
}
if (osmJob) await osmJob;
else if (mode === 'osm') await loadOsm();
signal?.throwIfAborted();
if (osmError && (mode === 'osm' || !tomtom.length)) throw osmError;
const data = snapshot(composed(), true);
publish(data.roads, true);
return {
ok: true,
status: 200,
headers: new Headers(),
json: async () => data,
};
};
return api;
}