mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
Main gained three imagery providers (Google Street View, KartaView,
Panoramax), shared line-coverage, cone and photo-viewer modules, one source
lit at a time and the translated interface. Their shared modules still
carried what this branch removes, so the merge ports them onto it:
- lineCoverage.js is this branch's coverage.js made provider-neutral
(draped lines near the ground only, the selection drawn over them, key
and rate-limit blocking); sequenceCones.js is sequences.js the same way.
Mapillary, KartaView and Panoramax all build on them; Mapillary moves
back to providers/mapillary/ beside the others.
- No ground casting, mesh sampling, surface modes, FOLLOW, legend, prewarm,
orbit overview points (Panoramax's density dots included), stale-tile
swaps or water-filled point budget come back.
- Kept from main because the new providers need them: requiresMapStack and
attachMapStackController (Street View on Google 3D only), ground clicks,
openNearest with an optional provider nearestImage, openImage {frame},
reportError, the view-cone marker (now an SVG glyph), filters /
coverageLabel / sinceBasis, OPEN STREET VIEW, keyAlternatives and i18n.
- photoViewer.js treats the viewer as expanded when its wrap is full screen
or the iPhone popover, as EXPAND now is.
- The fixture browser gate keeps its 8 steps and adds one each for
KartaView and Panoramax; catalogs, docs, boundaries and format scope
follow.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
239 lines
7.6 KiB
JavaScript
239 lines
7.6 KiB
JavaScript
import { PbfReader } from 'pbf';
|
||
import { VectorTile } from '@mapbox/vector-tile';
|
||
import { tileLocalToLonLat } from '../../tileMath.js';
|
||
import {
|
||
DECODE_SLICE_MS,
|
||
SIMPLIFY_TOLERANCE_UNITS,
|
||
panoramaxTimeMs,
|
||
} from './policy.js';
|
||
|
||
/**
|
||
* Douglas–Peucker in tile units: the points of `line` ({x, y}) that keep
|
||
* it within `tolerance` of the original (measured to each segment, so
|
||
* dead ends and U-turns stay), first and last always kept.
|
||
* Iterative, so a long track cannot overflow the stack.
|
||
*/
|
||
export function simplifyLine(line, tolerance) {
|
||
if (line.length < 3 || !(tolerance > 0)) return line;
|
||
const keep = new Uint8Array(line.length);
|
||
keep[0] = 1;
|
||
keep[line.length - 1] = 1;
|
||
const spans = [[0, line.length - 1]];
|
||
while (spans.length) {
|
||
const [from, to] = spans.pop();
|
||
const a = line[from];
|
||
const b = line[to];
|
||
const dx = b.x - a.x;
|
||
const dy = b.y - a.y;
|
||
const span2 = dx * dx + dy * dy;
|
||
let far = -1;
|
||
let farthest = tolerance;
|
||
for (let i = from + 1; i < to; i++) {
|
||
const p = line[i];
|
||
// Distance to the segment, not the infinite line: a dead end or a
|
||
// U-turn (a point beyond the chord's ends) is kept.
|
||
const t = span2
|
||
? Math.max(
|
||
0,
|
||
Math.min(1, ((p.x - a.x) * dx + (p.y - a.y) * dy) / span2),
|
||
)
|
||
: 0;
|
||
const d = Math.hypot(p.x - (a.x + t * dx), p.y - (a.y + t * dy));
|
||
if (d > farthest) {
|
||
farthest = d;
|
||
far = i;
|
||
}
|
||
}
|
||
if (far === -1) continue;
|
||
keep[far] = 1;
|
||
spans.push([from, far], [far, to]);
|
||
}
|
||
return line.filter((_, i) => keep[i]);
|
||
}
|
||
|
||
/** Epoch ms of a sequence's day ('2025-08-11'), or 0 when undated. */
|
||
function dayMs(value) {
|
||
return panoramaxTimeMs(typeof value === 'string' ? value : '') ?? 0;
|
||
}
|
||
|
||
/**
|
||
* Decode a Panoramax coverage tile (`/api/map/{z}/{x}/{y}.mvt`).
|
||
*
|
||
* - `sequences` (z7–15): one line per sequence, its parts kept apart so no
|
||
* segment is drawn across a gap, with its day and camera type; longest
|
||
* first, so a cap on lines drawn drops the shortest.
|
||
* - `grid` (z0–6, density cells) is not read: nothing is drawn from orbit.
|
||
* - `pictures` (z15) is left for `decodePictures`.
|
||
*
|
||
* In one go; `decodeCoverageTileSliced` gives the page a turn between
|
||
* slices.
|
||
* @param {Uint8Array} bytes
|
||
* @param {{x: number, y: number, z: number}} address
|
||
* @returns {{sequences: Array<{id: string, parts: Array<Array<[number, number]>>, capturedAt: number, isPano: boolean}>}}
|
||
*/
|
||
export function decodeCoverageTile(bytes, address) {
|
||
const steps = coverageSteps(bytes, address);
|
||
let step = steps.next();
|
||
while (!step.done) step = steps.next();
|
||
return step.value;
|
||
}
|
||
|
||
/** Give the page a turn: input and rendering run before the next slice. */
|
||
function nextTask() {
|
||
if (typeof globalThis.scheduler?.yield === 'function')
|
||
return globalThis.scheduler.yield();
|
||
return new Promise((resolve) => setTimeout(resolve, 0));
|
||
}
|
||
|
||
/**
|
||
* `decodeCoverageTile` in slices of about `sliceMs`, the page getting a
|
||
* turn between them: a 2 MB z10 tile over Paris is ~200 ms of decoding on
|
||
* a fast laptop, more on a phone, and would freeze the globe while the
|
||
* camera approaches. Stops at the next slice once `signal` aborts.
|
||
* @param {Uint8Array} bytes
|
||
* @param {{x: number, y: number, z: number}} address
|
||
* @param {{signal?: AbortSignal, sliceMs?: number, pause?: () => Promise<void>, now?: () => number}} [options]
|
||
*/
|
||
export async function decodeCoverageTileSliced(
|
||
bytes,
|
||
address,
|
||
{
|
||
signal,
|
||
sliceMs = DECODE_SLICE_MS,
|
||
pause = nextTask,
|
||
now = () => performance.now(),
|
||
} = {},
|
||
) {
|
||
const steps = coverageSteps(bytes, address);
|
||
let started = now();
|
||
let step = steps.next();
|
||
while (!step.done) {
|
||
if (now() - started >= sliceMs) {
|
||
await pause();
|
||
signal?.throwIfAborted();
|
||
started = now();
|
||
}
|
||
step = steps.next();
|
||
}
|
||
return step.value;
|
||
}
|
||
|
||
/** The decode, a step a feature (see `decodeCoverageTile`). */
|
||
function* coverageSteps(bytes, address) {
|
||
const result = { sequences: [] };
|
||
if (!bytes || !bytes.length) return result;
|
||
const tile = new VectorTile(new PbfReader(bytes));
|
||
const { x, y, z } = address;
|
||
|
||
const sequences = tile.layers.sequences;
|
||
if (sequences) {
|
||
const measured = [];
|
||
for (let i = 0; i < sequences.length; i++) {
|
||
const feature = sequences.feature(i);
|
||
const props = feature.properties || {};
|
||
const parts = [];
|
||
let length = 0;
|
||
const tolerance = (SIMPLIFY_TOLERANCE_UNITS * sequences.extent) / 4096;
|
||
for (const line of feature.loadGeometry()) {
|
||
if (line.length < 2) continue;
|
||
for (let k = 1; k < line.length; k++)
|
||
length += Math.hypot(
|
||
line[k].x - line[k - 1].x,
|
||
line[k].y - line[k - 1].y,
|
||
);
|
||
// Simplified before anything else: GPS tracks carry a point every
|
||
// few metres, and each becomes ~8 ground-line vertices on the GPU.
|
||
parts.push(
|
||
simplifyLine(line, tolerance).map((point) =>
|
||
tileLocalToLonLat(point.x, point.y, sequences.extent, x, y, z),
|
||
),
|
||
);
|
||
}
|
||
if (!parts.length || props.id == null) continue;
|
||
const sequence = {
|
||
id: String(props.id),
|
||
parts,
|
||
capturedAt: dayMs(props.date),
|
||
// A sequence with no camera type is neither (the filters keep it).
|
||
isPano:
|
||
props.type === 'equirectangular'
|
||
? true
|
||
: props.type === 'flat'
|
||
? false
|
||
: null,
|
||
};
|
||
measured.push({ sequence, length });
|
||
yield;
|
||
}
|
||
// A turn before the sort: over a city it is thousands of lines.
|
||
yield;
|
||
measured.sort((a, b) => b.length - a.length);
|
||
result.sequences = measured.map(({ sequence }) => sequence);
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/** A picture's sequence ids: the tile stores them as a JSON array in a string. */
|
||
function sequenceIdsOf(props) {
|
||
const raw = props.sequences;
|
||
if (typeof raw === 'string' && raw.startsWith('[')) {
|
||
try {
|
||
const ids = JSON.parse(raw);
|
||
if (Array.isArray(ids)) return ids.map(String);
|
||
} catch {
|
||
/* fall through to the first sequence */
|
||
}
|
||
}
|
||
return props.first_sequence != null ? [String(props.first_sequence)] : [];
|
||
}
|
||
|
||
/**
|
||
* The pictures of a z15 tile that belong to `sequenceId`, as cones draw
|
||
* them (unsorted).
|
||
* @param {Uint8Array} bytes
|
||
* @param {{x: number, y: number, z: number}} address
|
||
* @param {string} sequenceId
|
||
* @returns {Array<{id: string, lon: number, lat: number, compassAngle: number, capturedAt: number, isPano: boolean}>}
|
||
*/
|
||
export function decodePictures(bytes, address, sequenceId) {
|
||
if (!bytes || !bytes.length) return [];
|
||
const tile = new VectorTile(new PbfReader(bytes));
|
||
const layer = tile.layers.pictures;
|
||
if (!layer) return [];
|
||
const { x, y, z } = address;
|
||
const wanted = String(sequenceId);
|
||
const out = [];
|
||
for (let i = 0; i < layer.length; i++) {
|
||
const feature = layer.feature(i);
|
||
const props = feature.properties || {};
|
||
// A cheap test first: most pictures in a tile are other sequences'.
|
||
if (
|
||
typeof props.sequences === 'string' &&
|
||
!props.sequences.includes(wanted)
|
||
)
|
||
continue;
|
||
if (!sequenceIdsOf(props).includes(wanted) || props.id == null) continue;
|
||
const point = feature.loadGeometry()?.[0]?.[0];
|
||
if (!point) continue;
|
||
const [lon, lat] = tileLocalToLonLat(
|
||
point.x,
|
||
point.y,
|
||
layer.extent,
|
||
x,
|
||
y,
|
||
z,
|
||
);
|
||
const heading = Number(props.heading);
|
||
out.push({
|
||
id: String(props.id),
|
||
lon,
|
||
lat,
|
||
compassAngle: Number.isFinite(heading) ? heading : 0,
|
||
capturedAt: panoramaxTimeMs(String(props.ts ?? '')) ?? 0,
|
||
isPano: props.type === 'equirectangular',
|
||
});
|
||
}
|
||
return out;
|
||
}
|