mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
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
382 lines
13 KiB
JavaScript
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;
|
|
}
|