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]>
154 lines
5.0 KiB
JavaScript
154 lines
5.0 KiB
JavaScript
/** Web-Mercator tile math for Street Level coverage, without Cesium. */
|
|
|
|
const MAX_LAT = 85.05112878;
|
|
|
|
function clampLat(lat) {
|
|
return Math.max(-MAX_LAT, Math.min(MAX_LAT, lat));
|
|
}
|
|
|
|
/** Wrap a longitude, or a difference of two, into [-180, 180]: the short way round. */
|
|
export function wrapLon(lon) {
|
|
if (lon >= -180 && lon <= 180) return lon;
|
|
return ((((lon + 180) % 360) + 360) % 360) - 180;
|
|
}
|
|
|
|
/** Fractional tile column of a longitude in [-180, 180] at zoom z. */
|
|
function tileXAt(lon, z) {
|
|
return ((lon + 180) / 360) * 2 ** z;
|
|
}
|
|
|
|
/** Fractional tile row of a latitude at zoom z. */
|
|
function tileYAt(lat, z) {
|
|
const rad = (clampLat(lat) * Math.PI) / 180;
|
|
return (
|
|
((1 - Math.log(Math.tan(rad) + 1 / Math.cos(rad)) / Math.PI) / 2) * 2 ** z
|
|
);
|
|
}
|
|
|
|
export function lonToTileX(lon, z) {
|
|
const n = 2 ** z;
|
|
// 180° is the east edge of the last column, not the west edge of the first.
|
|
if (lon >= 180) return n - 1;
|
|
return Math.min(n - 1, Math.max(0, Math.floor(tileXAt(wrapLon(lon), z))));
|
|
}
|
|
|
|
export function latToTileY(lat, z) {
|
|
const n = 2 ** z;
|
|
return Math.min(n - 1, Math.max(0, Math.floor(tileYAt(lat, z))));
|
|
}
|
|
|
|
/** West longitude of tile column x at zoom z. */
|
|
function tileXToLon(x, z) {
|
|
return (x / 2 ** z) * 360 - 180;
|
|
}
|
|
|
|
/** North latitude of tile row y at zoom z. */
|
|
function tileYToLat(y, z) {
|
|
const n = Math.PI - (2 * Math.PI * y) / 2 ** z;
|
|
return (180 / Math.PI) * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n)));
|
|
}
|
|
|
|
/** @returns {{west:number,south:number,east:number,north:number}} degrees */
|
|
export function tileBounds(x, y, z) {
|
|
return {
|
|
west: tileXToLon(x, z),
|
|
east: tileXToLon(x + 1, z),
|
|
north: tileYToLat(y, z),
|
|
south: tileYToLat(y + 1, z),
|
|
};
|
|
}
|
|
|
|
/** A [west, south, east, north] array as finite, ordered bounds; null if unusable. */
|
|
export function normalizeBbox(input) {
|
|
if (!Array.isArray(input) || input.length !== 4) return null;
|
|
const [w, s, e, n] = input.map(Number);
|
|
if (![w, s, e, n].every(Number.isFinite)) return null;
|
|
const west = Math.max(-180, Math.min(w, e));
|
|
const east = Math.min(180, Math.max(w, e));
|
|
const south = Math.max(-MAX_LAT, Math.min(s, n));
|
|
const north = Math.min(MAX_LAT, Math.max(s, n));
|
|
if (east - west <= 0 || north - south <= 0) return null;
|
|
return { west, south, east, north };
|
|
}
|
|
|
|
/**
|
|
* Tiles at zoom z covering a [west, south, east, north] box (west > east
|
|
* crosses the date line), nearest to `from` first (default: the box centre),
|
|
* capped at `limit`. Distances are measured the short way round ±180°.
|
|
* @param {{limit?: number, from?: {lon: number, lat: number}|null}} [options]
|
|
* @returns {Array<{x:number,y:number,z:number}>}
|
|
*/
|
|
export function tilesForBbox(bbox, z, { limit = Infinity, from = null } = {}) {
|
|
const [west, south, east, north] = Array.isArray(bbox)
|
|
? bbox.map(Number)
|
|
: [];
|
|
const across = west > east;
|
|
// A box across the date line is split at ±180°.
|
|
const halves = across
|
|
? [
|
|
[west, south, 180, north],
|
|
[-180, south, east, north],
|
|
]
|
|
: [bbox];
|
|
// The halves share a column when the gap between east and west is
|
|
// narrower than a tile: count it once, so a capped set holds no repeats.
|
|
const grid = [
|
|
...new Map(
|
|
halves
|
|
.map(normalizeBbox)
|
|
.filter(Boolean)
|
|
.flatMap((box) => tileGrid(box, z))
|
|
.map((tile) => [`${tile.x}/${tile.y}`, tile]),
|
|
).values(),
|
|
];
|
|
const n = 2 ** z;
|
|
const centre = from || {
|
|
lon: wrapLon(west + (east - west + (across ? 360 : 0)) / 2),
|
|
lat: (south + north) / 2,
|
|
};
|
|
const cx = tileXAt(wrapLon(centre.lon), z);
|
|
const cy = tileYAt(centre.lat, z);
|
|
// Each tile's distance is computed once; ties keep their row order.
|
|
const ranked = grid
|
|
.map((tile) => {
|
|
const dx = Math.abs(tile.x + 0.5 - cx);
|
|
const d = Math.min(dx, n - dx) ** 2 + (tile.y + 0.5 - cy) ** 2;
|
|
return { tile, d };
|
|
})
|
|
.sort((a, b) => a.d - b.d)
|
|
.map(({ tile }) => tile);
|
|
return ranked.slice(0, limit);
|
|
}
|
|
|
|
/** The tiles at zoom z in a normalized box, row by row. */
|
|
function tileGrid(box, z) {
|
|
const x0 = lonToTileX(box.west, z);
|
|
const x1 = lonToTileX(box.east, z);
|
|
const y0 = latToTileY(box.north, z);
|
|
const y1 = latToTileY(box.south, z);
|
|
const tiles = [];
|
|
for (let y = y0; y <= y1; y++)
|
|
for (let x = x0; x <= x1; x++) tiles.push({ x, y, z });
|
|
return tiles;
|
|
}
|
|
|
|
/** A vector-tile-local coordinate (0..extent) in tile (x, y, z) as [lon, lat]. */
|
|
export function tileLocalToLonLat(px, py, extent, x, y, z) {
|
|
const n = 2 ** z;
|
|
const lon = ((x + px / extent) / n) * 360 - 180;
|
|
const merc = Math.PI - (2 * Math.PI * (y + py / extent)) / n;
|
|
const lat =
|
|
(180 / Math.PI) * Math.atan(0.5 * (Math.exp(merc) - Math.exp(-merc)));
|
|
return [lon, lat];
|
|
}
|
|
|
|
/** Sequence-tile zoom for a camera height above ground (m); Mapillary stops at z14. */
|
|
export function coverageZoomForHeight(heightM) {
|
|
if (!Number.isFinite(heightM)) return null;
|
|
if (heightM > 60_000) return null;
|
|
if (heightM > 12_000) return 11;
|
|
if (heightM > 5_000) return 12;
|
|
if (heightM > 1_800) return 13;
|
|
return 14;
|
|
}
|