mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
feat(cockpit): ride a tracked satellite in an orbital view
With a satellite tracked and no aircraft tracked, Cockpit can ride the satellite. Entry needs only the Satellites layer; debris can be tracked but not entered, and voice stays aircraft-only. Double-clicking the tracked satellite or the entry buttons (reading ORBIT) enter it. The camera sits on the satellite's per-frame SGP4 position and looks straight down, turned to the ground track (north-up for a satellite with none). The optical zoom steps 1x to 8x with a focus pull, the arrows tilt the view up to 45 degrees off nadir, and Home or 0 returns to nadir. Off nadir the tilt reads its total angle first and the swath readout becomes an approximation marked with ≈. While in orbit the map leases flat Esri imagery, the cloud pass stays off and the view opens in the optical style. The orbital HUD names the satellite with its owner's flag (from the flag-icons package, loaded per country) or an organisation badge, its operator, class, NORAD and COSPAR ids and TLE epoch with the element lines on request, altitude, orbital speed and the sub-satellite point. CURRENTLY OVER names the country and its first-level division, or the sea, and from 8x the most prominent populated place nearby, looked up offline from the bundled Natural Earth packs (populated places are a new pack). The satellites layer hides the ridden satellite's own marks, dims the other orbit rings and ignores scene clicks and Escape while held. Exit restores the camera's field of view and the satellite's follow camera. C no longer enters or leaves Cockpit, bridge or orbit: it is left to the app-wide CCTV shortcut, and Escape or the exit button leave first person.
This commit is contained in:
1 parent
a648c9b665
commit
048293fc2a
67 files changed
+6642
-172
No files matched your search
@@ -10,6 +10,7 @@ range geometry with no network dependency.
|
||||
| `marine.json` | `ne_10m_geography_marine_polys` (seas, gulfs, straits, bays, …) | 292 named |
|
||||
| `countries.json` | `ne_10m_admin_0_countries` (countries) | 256 |
|
||||
| `states_provinces.json` | `ne_10m_admin_1_states_provinces` (states, provinces and other first-level units) | 4,587 named |
|
||||
| `populated_places.json` | `ne_10m_populated_places_simple` (cities and towns, as points) | 7,342 |
|
||||
|
||||
**Source:** Natural Earth 10m physical vectors, via the canonical
|
||||
[nvkelso/natural-earth-vector](https://github.com/nvkelso/natural-earth-vector)
|
||||
@@ -103,3 +104,23 @@ Includes England, Scotland, Wales and Northern Ireland from
|
||||
`ne_10m_admin_0_map_units.geojson` at the same commit (SHA-256
|
||||
`57da82be755f4afccd8f3b14251bb2752f5df1395f47d2d86f817470c4a48862`).
|
||||
Result: 945,843 bytes; 260 features, 2,088 parts, 122,788 vertices.
|
||||
|
||||
## Populated places (`populated_places.json`)
|
||||
|
||||
The orbital view's "near <city>" (`src/data/placeBelow.js`): from 8x it
|
||||
names the most prominent place within half the view's width.
|
||||
|
||||
**Source:** `geojson/ne_10m_populated_places_simple.geojson` at the pinned
|
||||
commit `ca96624a56bd078437bca8184e78163e5039ad19` (SHA-256
|
||||
`fd3fa867a320cbd5c5b6bb5bc550afeec2939fb2cef688e508007282a55ac42f`, the file
|
||||
the admin-1 build already reads), fetched 2026-11-04. Public domain, as above.
|
||||
|
||||
**Regenerate:** `node scripts/build-admin-packs.mjs --only places`.
|
||||
|
||||
**Schema:** `meta` (source, URL, hash, license, curation) and `places[]`, each
|
||||
`[name, latitude, longitude, scalerank, rank_max]`: `scalerank` 0 (most
|
||||
prominent) to 10, `rank_max` the population class (0 to 14, higher is
|
||||
larger). Sorted by `scalerank`, then `rank_max` descending, then name.
|
||||
|
||||
**Curation:** every place kept; all other attributes dropped; coordinates
|
||||
rounded to 3 decimals (~110 m). Result: 229,461 bytes (98,444 with gzip -9).
|
||||
@@ -0,0 +1 @@
|
||||
{"meta":{"title":"Natural Earth populated places","source":"ne_10m_populated_places_simple","url":"https://raw.githubusercontent.com/nvkelso/natural-earth-vector/ca96624a56bd078437bca8184e78163e5039ad19/geojson/ne_10m_populated_places_simple.geojson","sha256":"fd3fa867a320cbd5c5b6bb5bc550afeec2939fb2cef688e508007282a55ac42f","commit":"ca96624a56bd078437bca8184e78163e5039ad19","license":"Public domain (https://www.naturalearthdata.com/about/terms-of-use/)","schema":"places[]: [name, latitude, longitude, scalerank (0 most prominent .. 10), rank_max (population class, 0..14; higher is larger)]","decimals":3,"curation":{"decimals":3},"script":"scripts/build-admin-packs.mjs"},"places":[["Beijing",39.931,116.386,0,14],["Cairo",30.052,31.248,0,14],["Istanbul",41.107,29.008,0,14],["Kolkata",22.497,88.323,0,14],["Los Angeles",33.992,-118.182,0,14],["Mexico City",19.444,-99.133,0,14],["Moscow",55.754,37.614,0,14],["Mumbai",19.019,72.855,0,14],["New York",40.752,-73.982,0,14],["Rio de Janeiro",-22.923,-43.227,0,14],["São Paulo",-23.557,-46.627,0,14],["Shanghai",31.218,121.435,0,14],["Tokyo",35.687,139.749,0,14],["Bogota",4.598,-74.085,0,13],["Hong Kong",22.307,114.183,0,13],["Jakarta",-6.172,106.827,0,13],["Lagos",6.445,3.39,0,13],["London",51.502,-0.119,0,13],["Paris",48.869,2.331,0,13],["Santiago",-33.448,-70.669,0,13],["Singapore",1.295,103.854,0,13],["Cape Town",-33.918,18.433,0,12],["Nairobi",-1.281,36.815,0,12],["Riyadh",24.643,46.771,0,12],["Rome",41.898,12.481,0,12],["Sydney",-33.918,151.183,0,12],["Washington, D.C.",38.901,-77.011,0,12],["Buenos Aires",-34.601,-58.399,1,14],["Manila",14.606,120.98,1,14],["Ōsaka",34.752,135.458,1,14],["Baghdad",33.341,44.392,1,13],["Bangkok",13.752,100.515,1,13],["Bengaluru",12.972,77.558,1,13],["Chicago",41.832,-87.752,1,13],["Kinshasa",-4.328,15.313,1,13],["Lima",-12.046,-77.052,1,13],["Madrid",40.402,-3.685,1,13],["Miami",25.79,-80.226,1,13],["Seoul",37.568,126.998,1,13],["Taipei",25.036,121.568,1,13],["Tehran",35.674,51.422,1,13],["Toronto",43.702,-79.422,1,13],["Addis Ababa",9.035,38.698,1,12],["Amsterdam",52.352,4.915,1,12],["Athens",37.985,23.731,1,12],["Atlanta",33.832,-84.402,1,12],["Auckland",-36.848,174.763,1,12],["Berlin",52.524,13.4,1,12],["Caracas",10.503,-66.919,1,12],["Casablanca",33.602,-7.618,1,12],["Chengdu",30.672,104.068,1,12],["Dakar",14.718,-17.475,1,12],["Denver",39.741,-104.986,1,12],["Dubai",25.232,55.278,1,12],["Geneva",46.21,6.14,1,12],["Houston",29.822,-95.342,1,12],["Johannesburg",-26.168,28.028,1,12],["Kabul",34.519,69.181,1,12],["Kyiv",50.435,30.515,1,12],["Melbourne",-37.818,144.973,1,12],["Monterrey",25.672,-100.332,1,12],["San Francisco",37.769,-122.417,1,12],["Stockholm",59.353,18.095,1,12],["Tashkent",41.314,69.293,1,12],["Ürümqi",43.807,87.573,1,12],["Vancouver",49.275,-123.124,1,12],["Vienna",48.202,16.365,1,12],["New Delhi",28.6,77.2,1,10],["Delhi",28.672,77.228,2,14],["Dhaka",23.725,90.407,2,14],["Karachi",24.872,66.988,2,14],["Ahmedabad",23.032,72.578,2,13],["Chennai",13.092,80.278,2,13],["Chongqing",29.567,106.593,2,13],["Guangzhou",23.147,113.323,2,13],["Ho Chi Minh City",10.782,106.693,2,13],["Hyderabad",17.402,78.478,2,13],["Lahore",31.562,74.348,2,13],["Luanda",-8.836,13.232,2,13],["Philadelphia",40.002,-75.172,2,13],["Shenzhen",22.554,114.12,2,13],["Tianjin",39.132,117.198,2,13],["Wuhan",30.582,114.268,2,13],["Abidjan",5.322,-4.042,2,12],["Accra",5.552,-0.219,2,12],["Aleppo",36.232,37.168,2,12],["Alexandria",31.202,29.948,2,12],["Algiers",36.765,3.049,2,12],["Ankara",39.929,32.862,2,12],["Bandung",-6.948,107.568,2,12],["Baotou",40.654,109.82,2,12],["Barcelona",41.385,2.181,2,12],["Belém",-1.448,-48.482,2,12],["Boston",42.332,-71.072,2,12],["Brasília",-15.781,-47.918,2,12],["Brussels",50.835,4.331,2,12],["Bucharest",44.435,26.098,2,12],["Budapest",47.502,19.081,2,12],["Cali",3.402,-76.502,2,12],["Changchun",43.867,125.338,2,12],["Changsha",28.202,112.968,2,12],["Chattogram",22.332,91.798,2,12],["Curitiba",-25.418,-49.322,2,12],["Dallas",32.822,-96.842,2,12],["Damascus",33.502,36.298,2,12],["Dar es Salaam",-6.798,39.266,2,12],["Detroit",42.332,-83.082,2,12],["Dongguan",23.051,113.743,2,12],["Dublin",53.335,-6.251,2,12],["Durban",-29.863,30.978,2,12],["Edmonton",53.552,-113.502,2,12],["Fortaleza",-3.748,-38.582,2,12],["Frankfurt",50.1,8.675,2,12],["Fuzhou",26.082,119.298,2,12],["Goiânia",-16.718,-49.302,2,12],["Guadalajara",20.672,-103.332,2,12],["Guayaquil",-2.218,-79.922,2,12],["Guiyang",26.582,106.718,2,12],["Hamburg",53.552,9.998,2,12],["Hangzhou",30.252,120.168,2,12],["Hanoi",21.035,105.848,2,12],["Harbin",45.752,126.648,2,12],["Havana",23.134,-82.366,2,12],["Helsinki",60.178,24.932,2,12],["Hiroshima",34.39,132.441,2,12],["Jaipur",26.923,75.808,2,12],["Jeddah",21.519,39.217,2,12],["Jinan",36.677,116.993,2,12],["Kano",12.002,8.518,2,12],["Kanpur",26.462,80.318,2,12],["Khartoum",15.59,32.532,2,12],["København",55.681,12.562,2,12],["Kuala Lumpur",3.169,101.698,2,12],["Kunming",25.072,102.678,2,12],["Kuwait City",29.372,4Line truncated
|
||||
@@ -0,0 +1,369 @@
|
||||
/**
|
||||
* What a ground point is over, offline: on land the country (Natural Earth
|
||||
* admin-0) and its first-level division (admin-1: "Sichuan, China"), plus,
|
||||
* when asked for a radius, the most prominent populated place within it
|
||||
* ("near Chengdu"); else the smallest named sea, gulf, strait, channel,
|
||||
* sound or bay, else the ocean (`marine.json` carries the seven oceans).
|
||||
* Bays narrower than a satellite frame cares about — fjords, lagoons,
|
||||
* inlets, reefs and rivers — are skipped, so a pass reads "Bay of Bengal",
|
||||
* not a harbour.
|
||||
*
|
||||
* PURE data module: no Cesium, node-testable. Each pack loads lazily on the
|
||||
* first lookup that needs it (divisions on the first land hit, places on the
|
||||
* first radius) and is indexed once; a country's division rings are decoded
|
||||
* the first time a point falls inside it. A failed load is retried later
|
||||
* (see `createRetryableLoader`). No network.
|
||||
*/
|
||||
|
||||
import { loadBundledJson } from './bundledJson.js';
|
||||
import { createRetryableLoader } from './retryableLoad.js';
|
||||
import { containsAnchor, decodeRing } from './adminBoundaries.js';
|
||||
import { greatCircleKm } from '../geoDistance.js';
|
||||
|
||||
/** Marine feature classes named as the place below; oceans come last. */
|
||||
const MARINE_KINDS = new Set([
|
||||
'sea',
|
||||
'gulf',
|
||||
'strait',
|
||||
'channel',
|
||||
'sound',
|
||||
'bay',
|
||||
]);
|
||||
|
||||
const PACKS = {
|
||||
countries: new URL(
|
||||
'./local_data/natural_earth/countries.json',
|
||||
import.meta.url,
|
||||
),
|
||||
marine: new URL('./local_data/natural_earth/marine.json', import.meta.url),
|
||||
divisions: new URL(
|
||||
'./local_data/natural_earth/states_provinces.json',
|
||||
import.meta.url,
|
||||
),
|
||||
places: new URL(
|
||||
'./local_data/natural_earth/populated_places.json',
|
||||
import.meta.url,
|
||||
),
|
||||
};
|
||||
|
||||
/** Test seam: count pack loads (lazy-loading contract). */
|
||||
export const placePackLoads = { divisions: 0, places: 0 };
|
||||
|
||||
/** The zoom from which the view names the populated place it shows. */
|
||||
export const NEAR_PLACE_MIN_ZOOM = 8;
|
||||
|
||||
/**
|
||||
* How far from the sub-satellite point a populated place may lie and still
|
||||
* be named: half the view's smaller ground dimension from
|
||||
* NEAR_PLACE_MIN_ZOOM on, so the place is in the picture whichever way it
|
||||
* lies; null below it or without a size.
|
||||
* @param {number} zoom Optical zoom.
|
||||
* @param {number} widthKm The view's ground width, km.
|
||||
* @param {number} [heightKm] The view's ground height, km; the width when
|
||||
* not given.
|
||||
* @returns {number|null}
|
||||
*/
|
||||
export function nearPlaceRadiusKm(zoom, widthKm, heightKm = widthKm) {
|
||||
if (!(zoom >= NEAR_PLACE_MIN_ZOOM)) return null;
|
||||
const smallerKm = Math.min(widthKm, heightKm);
|
||||
return Number.isFinite(smallerKm) && smallerKm > 0 ? smallerKm / 2 : null;
|
||||
}
|
||||
|
||||
/** Shortest wait between two lookups, ms. */
|
||||
export const PLACE_LOOKUP_MIN_MS = 2000;
|
||||
/** Ground travel that makes a fresh lookup worth it, km. */
|
||||
export const PLACE_LOOKUP_MIN_MOVE_KM = 20;
|
||||
|
||||
function boxOf(parts) {
|
||||
let west = Infinity;
|
||||
let south = Infinity;
|
||||
let east = -Infinity;
|
||||
let north = -Infinity;
|
||||
for (const part of parts)
|
||||
for (const ring of part)
|
||||
for (const [lon, lat] of ring) {
|
||||
if (lon < west) west = lon;
|
||||
if (lon > east) east = lon;
|
||||
if (lat < south) south = lat;
|
||||
if (lat > north) north = lat;
|
||||
}
|
||||
return [west, south, east, north];
|
||||
}
|
||||
|
||||
function inBox([west, south, east, north], lat, lon) {
|
||||
return lat >= south && lat <= north && lon >= west && lon <= east;
|
||||
}
|
||||
|
||||
/** Planar ring area in degrees², shrunk by cos(latitude): enough to rank. */
|
||||
function ringRank(ring) {
|
||||
let sum = 0;
|
||||
let latSum = 0;
|
||||
for (let i = 0, j = ring.length - 1; i < ring.length; j = i, i += 1) {
|
||||
sum += (ring[j][0] - ring[i][0]) * (ring[j][1] + ring[i][1]);
|
||||
latSum += ring[i][1];
|
||||
}
|
||||
const meanLat = ring.length ? latSum / ring.length : 0;
|
||||
return (Math.abs(sum) / 2) * Math.cos((meanLat * Math.PI) / 180);
|
||||
}
|
||||
|
||||
const loadPlaces = createRetryableLoader(async () => {
|
||||
const [countries, marine] = await Promise.all([
|
||||
loadBundledJson(PACKS.countries),
|
||||
loadBundledJson(PACKS.marine),
|
||||
]);
|
||||
const decimals = countries.meta?.decimals ?? 3;
|
||||
const land = [];
|
||||
for (const feature of countries.features || []) {
|
||||
const parts = (feature.polygons || []).map((part) =>
|
||||
part.map((ring) => decodeRing(ring, decimals)),
|
||||
);
|
||||
if (!parts.length) continue;
|
||||
land.push({
|
||||
name: feature.name,
|
||||
// Natural Earth writes -99 for units without an ISO code.
|
||||
countryCode: /^[A-Z]{2}$/.test(feature.iso2 || '') ? feature.iso2 : null,
|
||||
parts,
|
||||
box: boxOf(parts),
|
||||
});
|
||||
}
|
||||
const water = [];
|
||||
for (const feature of marine.features || []) {
|
||||
const kind = feature.featurecla;
|
||||
if (kind !== 'ocean' && !MARINE_KINDS.has(kind)) continue;
|
||||
// Marine rings are stored outer-only and plain [lon, lat].
|
||||
const parts = (feature.polygons || []).map((ring) => [ring]);
|
||||
if (!parts.length) continue;
|
||||
water.push({
|
||||
name: feature.name,
|
||||
kind: kind === 'ocean' ? 'ocean' : 'sea',
|
||||
parts,
|
||||
box: boxOf(parts),
|
||||
rank: parts.reduce((sum, [ring]) => sum + ringRank(ring), 0),
|
||||
});
|
||||
}
|
||||
return { land, water };
|
||||
});
|
||||
|
||||
/** Divisions grouped by country code; rings decoded per country on demand. */
|
||||
const loadDivisions = createRetryableLoader(async () => {
|
||||
placePackLoads.divisions += 1;
|
||||
const pack = await loadBundledJson(PACKS.divisions);
|
||||
const decimals = pack.meta?.decimals ?? 3;
|
||||
const byCountry = new Map();
|
||||
for (const feature of pack.features || []) {
|
||||
if (!feature.name || !/^[A-Z]{2}$/.test(feature.iso2 || '')) continue;
|
||||
const list = byCountry.get(feature.iso2) || [];
|
||||
list.push({ feature, decimals: feature.d ?? decimals });
|
||||
byCountry.set(feature.iso2, list);
|
||||
}
|
||||
return { byCountry, decoded: new Map() };
|
||||
});
|
||||
|
||||
/** The first-level division holding a point inside country `code`, or null. */
|
||||
async function divisionAt(code, lat, lon) {
|
||||
if (!code) return null;
|
||||
const { byCountry, decoded } = await loadDivisions();
|
||||
let units = decoded.get(code);
|
||||
if (!units) {
|
||||
units = (byCountry.get(code) || []).map(({ feature, decimals }) => {
|
||||
const parts = (feature.polygons || []).map((part) =>
|
||||
part.map((ring) => decodeRing(ring, decimals)),
|
||||
);
|
||||
return { name: feature.name, parts, box: boxOf(parts) };
|
||||
});
|
||||
decoded.set(code, units);
|
||||
}
|
||||
for (const unit of units)
|
||||
if (inBox(unit.box, lat, lon) && containsAnchor(unit.parts, lat, lon))
|
||||
return unit.name;
|
||||
return null;
|
||||
}
|
||||
|
||||
const loadPopulatedPlaces = createRetryableLoader(async () => {
|
||||
placePackLoads.places += 1;
|
||||
const pack = await loadBundledJson(PACKS.places);
|
||||
return (pack.places || []).filter(
|
||||
(row) =>
|
||||
Array.isArray(row) &&
|
||||
row[0] &&
|
||||
Number.isFinite(row[1]) &&
|
||||
Number.isFinite(row[2]),
|
||||
);
|
||||
});
|
||||
|
||||
/**
|
||||
* The most prominent populated place within `radiusKm` of a point (lowest
|
||||
* Natural Earth scalerank, then the larger population class, then the
|
||||
* nearer), or null.
|
||||
* @returns {Promise<string|null>}
|
||||
*/
|
||||
export async function nearPlace(lat, lon, radiusKm) {
|
||||
if (!(radiusKm > 0) || !Number.isFinite(lat) || !Number.isFinite(lon))
|
||||
return null;
|
||||
const places = await loadPopulatedPlaces();
|
||||
const latSpan = radiusKm / 111;
|
||||
const cosLat = Math.cos((lat * Math.PI) / 180);
|
||||
const lonSpan = cosLat > 0.01 ? latSpan / cosLat : 360;
|
||||
let best = null;
|
||||
for (const [name, pLat, pLon, scalerank, rankMax] of places) {
|
||||
if (Math.abs(pLat - lat) > latSpan) continue;
|
||||
const dLon = Math.abs(((((pLon - lon + 180) % 360) + 360) % 360) - 180);
|
||||
if (dLon > lonSpan) continue;
|
||||
const km = greatCircleKm({ lat, lon }, { lat: pLat, lon: pLon });
|
||||
if (km > radiusKm) continue;
|
||||
if (
|
||||
!best ||
|
||||
scalerank < best.scalerank ||
|
||||
(scalerank === best.scalerank &&
|
||||
(rankMax > best.rankMax || (rankMax === best.rankMax && km < best.km)))
|
||||
)
|
||||
best = { name, scalerank, rankMax, km };
|
||||
}
|
||||
return best ? best.name : null;
|
||||
}
|
||||
|
||||
/** The division and near-place lookups `placeBelow` adds on land. */
|
||||
const DETAIL_LOOKUPS = Object.freeze({ division: divisionAt, near: nearPlace });
|
||||
|
||||
/** A detail lookup's answer, or null when it (its pack) fails. */
|
||||
async function orNull(lookup) {
|
||||
try {
|
||||
return (await lookup()) ?? null;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The place under a ground point.
|
||||
* @param {number} latitude Degrees.
|
||||
* @param {number} longitude Degrees, any wrap.
|
||||
* @param {{nearKm?: number|null, detail?: {division: Function,
|
||||
* near: Function}}} [options] On land, also name the most prominent
|
||||
* populated place within `nearKm` (`nearPlaceRadiusKm`). `detail` replaces
|
||||
* the division and near-place lookups (a test seam).
|
||||
* @returns {Promise<{kind: 'country'|'sea'|'ocean', name: string,
|
||||
* countryCode: string|null, division?: string|null,
|
||||
* near?: string|null}|null>} A country carries its first-level `division`
|
||||
* and the `near` place (each null when none, or when its pack failed to
|
||||
* load: the country still stands); a sea or ocean neither. Null when no
|
||||
* feature holds the point (a coastline gap left by the packs'
|
||||
* simplification) or it is invalid. Rejects only when the country and
|
||||
* marine packs fail.
|
||||
*/
|
||||
export async function placeBelow(
|
||||
latitude,
|
||||
longitude,
|
||||
{ nearKm = null, detail = DETAIL_LOOKUPS } = {},
|
||||
) {
|
||||
if (
|
||||
!Number.isFinite(latitude) ||
|
||||
!Number.isFinite(longitude) ||
|
||||
Math.abs(latitude) > 90
|
||||
)
|
||||
return null;
|
||||
const lon = ((((longitude + 180) % 360) + 360) % 360) - 180;
|
||||
const { land, water } = await loadPlaces();
|
||||
for (const entry of land) {
|
||||
if (
|
||||
inBox(entry.box, latitude, lon) &&
|
||||
containsAnchor(entry.parts, latitude, lon)
|
||||
)
|
||||
return {
|
||||
kind: 'country',
|
||||
name: entry.name,
|
||||
countryCode: entry.countryCode,
|
||||
division: await orNull(() =>
|
||||
detail.division(entry.countryCode, latitude, lon),
|
||||
),
|
||||
near: await orNull(() => detail.near(latitude, lon, nearKm)),
|
||||
};
|
||||
}
|
||||
let best = null;
|
||||
for (const entry of water) {
|
||||
if (best && entry.rank >= best.rank) continue;
|
||||
if (
|
||||
inBox(entry.box, latitude, lon) &&
|
||||
containsAnchor(entry.parts, latitude, lon)
|
||||
)
|
||||
best = entry;
|
||||
}
|
||||
return best ? { kind: best.kind, name: best.name, countryCode: null } : null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Whether two radii ask for the same detail: both off, or within 20% (a
|
||||
* zoom step at least halves the view; altitude drift moves it far less).
|
||||
*/
|
||||
function sameRadius(a, b) {
|
||||
if (a === null || b === null) return a === b;
|
||||
return Math.max(a, b) / Math.min(a, b) < 1.2;
|
||||
}
|
||||
|
||||
/**
|
||||
* Keep the place below a moving ground point current without a lookup per
|
||||
* frame: a new lookup once at least `minIntervalMs` has passed AND the point
|
||||
* has moved `minMoveKm` (a low orbit refreshes about every 2.6 s, a
|
||||
* geostationary one never after the first). A new `nearKm` radius (a zoom
|
||||
* step) looks up again at once. One lookup runs at a time; a result that
|
||||
* arrives after `reset()` is dropped. A failed lookup reports no place (the
|
||||
* old one would name ground the view has left) and lets the next update
|
||||
* look up again at once.
|
||||
* @param {{onPlace: (place: object|null) => void,
|
||||
* lookup?: (lat: number, lon: number,
|
||||
* options: {nearKm: number|null}) => Promise<object|null>,
|
||||
* minIntervalMs?: number, minMoveKm?: number}} options
|
||||
*/
|
||||
export function createPlaceTracker({
|
||||
onPlace,
|
||||
lookup = placeBelow,
|
||||
minIntervalMs = PLACE_LOOKUP_MIN_MS,
|
||||
minMoveKm = PLACE_LOOKUP_MIN_MOVE_KM,
|
||||
}) {
|
||||
let generation = 0;
|
||||
let inFlight = false;
|
||||
let last = null;
|
||||
return {
|
||||
/**
|
||||
* Offer the current ground point and the radius to name a place in.
|
||||
* @returns {boolean} True when a lookup started.
|
||||
*/
|
||||
update(lat, lon, nowMs, nearKm = null) {
|
||||
if (inFlight || !Number.isFinite(lat) || !Number.isFinite(lon))
|
||||
return false;
|
||||
const radius = Number.isFinite(nearKm) && nearKm > 0 ? nearKm : null;
|
||||
if (
|
||||
last &&
|
||||
sameRadius(last.nearKm, radius) &&
|
||||
(nowMs - last.ms < minIntervalMs ||
|
||||
greatCircleKm(last, { lat, lon }) < minMoveKm)
|
||||
)
|
||||
return false;
|
||||
last = { lat, lon, ms: nowMs, nearKm: radius };
|
||||
inFlight = true;
|
||||
const token = generation;
|
||||
Promise.resolve()
|
||||
.then(() => lookup(lat, lon, { nearKm: radius }))
|
||||
.then(
|
||||
(place) => {
|
||||
if (token !== generation) return;
|
||||
inFlight = false;
|
||||
onPlace(place ?? null);
|
||||
},
|
||||
() => {
|
||||
if (token !== generation) return;
|
||||
inFlight = false;
|
||||
last = null;
|
||||
onPlace(null);
|
||||
},
|
||||
);
|
||||
return true;
|
||||
},
|
||||
/** Forget the point and drop any lookup still in flight. */
|
||||
reset() {
|
||||
generation += 1;
|
||||
inFlight = false;
|
||||
last = null;
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,280 @@
|
||||
// src/data/placeBelow.test.mjs — what the ground track is over, offline:
|
||||
// division and country on land (with the populated place in view from 8x),
|
||||
// the smallest named sea, else the ocean; and the tracker that keeps it
|
||||
// current without a lookup per frame.
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { readFileSync } from 'node:fs';
|
||||
import {
|
||||
NEAR_PLACE_MIN_ZOOM,
|
||||
PLACE_LOOKUP_MIN_MOVE_KM,
|
||||
PLACE_LOOKUP_MIN_MS,
|
||||
createPlaceTracker,
|
||||
nearPlaceRadiusKm,
|
||||
placeBelow,
|
||||
placePackLoads,
|
||||
} from './placeBelow.js';
|
||||
|
||||
const PLACES_PACK = new URL(
|
||||
'./local_data/natural_earth/populated_places.json',
|
||||
import.meta.url,
|
||||
);
|
||||
|
||||
// Runs first: the counters are module-wide.
|
||||
test('the division and place packs load only when a lookup needs them', async () => {
|
||||
assert.deepEqual(placePackLoads, { divisions: 0, places: 0 });
|
||||
await placeBelow(42, 51, { nearKm: 50 });
|
||||
assert.deepEqual(placePackLoads, { divisions: 0, places: 0 }, 'at sea');
|
||||
await placeBelow(30.9, 104.2);
|
||||
assert.deepEqual(placePackLoads, { divisions: 1, places: 0 }, 'at 1x');
|
||||
await placeBelow(30.9, 104.2, { nearKm: 60 });
|
||||
await placeBelow(31.2, 104.5, { nearKm: 30 });
|
||||
assert.deepEqual(placePackLoads, { divisions: 1, places: 1 }, 'kept');
|
||||
});
|
||||
|
||||
test('the populated-place pack is compact rows of name, position and rank', () => {
|
||||
const bytes = readFileSync(PLACES_PACK);
|
||||
assert.ok(bytes.length < 300_000, `${bytes.length} bytes`);
|
||||
const pack = JSON.parse(bytes);
|
||||
assert.match(pack.meta.url, /nvkelso\/natural-earth-vector/);
|
||||
assert.match(pack.meta.license, /^Public domain/);
|
||||
assert.ok(pack.places.length > 7000);
|
||||
for (const [name, lat, lon, scalerank, rankMax] of pack.places) {
|
||||
assert.equal(typeof name, 'string');
|
||||
assert.ok(Math.abs(lat) <= 90 && Math.abs(lon) <= 180, name);
|
||||
assert.ok(Number.isInteger(scalerank) && Number.isInteger(rankMax), name);
|
||||
}
|
||||
});
|
||||
|
||||
test('over land the place is the division and country, with its ISO code', async () => {
|
||||
assert.deepEqual(await placeBelow(48.85, 2.35), {
|
||||
kind: 'country',
|
||||
name: 'France',
|
||||
countryCode: 'FR',
|
||||
division: 'Paris',
|
||||
near: null,
|
||||
});
|
||||
// Across the antimeridian, and with a wrapped longitude.
|
||||
assert.equal((await placeBelow(66, -175)).countryCode, 'RU');
|
||||
assert.equal((await placeBelow(-17.8, 178)).countryCode, 'FJ');
|
||||
assert.equal((await placeBelow(48.85, 362.35)).countryCode, 'FR');
|
||||
});
|
||||
|
||||
test('at 1x a point in Sichuan reads Sichuan, China, with no city', async () => {
|
||||
assert.deepEqual(await placeBelow(30.9, 104.2), {
|
||||
kind: 'country',
|
||||
name: 'China',
|
||||
countryCode: 'CN',
|
||||
division: 'Sichuan',
|
||||
near: null,
|
||||
});
|
||||
assert.equal(nearPlaceRadiusKm(1, 1400), null);
|
||||
assert.equal(nearPlaceRadiusKm(NEAR_PLACE_MIN_ZOOM / 2, 300), null);
|
||||
});
|
||||
|
||||
test('from 8x the most prominent populated place in view is named', async () => {
|
||||
assert.equal(NEAR_PLACE_MIN_ZOOM, 8);
|
||||
// An 8x view ~120 km wide: Chengdu lies ~30 km off, inside half of it.
|
||||
const nearKm = nearPlaceRadiusKm(8, 120);
|
||||
assert.equal(nearKm, 60);
|
||||
const place = await placeBelow(30.9, 104.2, { nearKm });
|
||||
assert.equal(place.division, 'Sichuan');
|
||||
assert.equal(place.near, 'Chengdu');
|
||||
// Deyang lies nearer this point; Chengdu still outranks it.
|
||||
assert.equal(
|
||||
(await placeBelow(31.1, 104.35, { nearKm: 60 })).near,
|
||||
'Chengdu',
|
||||
);
|
||||
});
|
||||
|
||||
test('no city is named when none lies within half the view', async () => {
|
||||
// ~100 km west of Chengdu, in the mountains.
|
||||
const place = await placeBelow(30.67, 103.0, { nearKm: 30 });
|
||||
assert.equal(place.division, 'Sichuan');
|
||||
assert.equal(place.near, null);
|
||||
assert.equal(nearPlaceRadiusKm(8, Number.NaN), null);
|
||||
});
|
||||
|
||||
test('at sea the smallest named sea wins over its ocean', async () => {
|
||||
assert.deepEqual(await placeBelow(42, 51), {
|
||||
kind: 'sea',
|
||||
name: 'Caspian Sea',
|
||||
countryCode: null,
|
||||
});
|
||||
// A radius changes nothing at sea.
|
||||
assert.deepEqual(await placeBelow(42, 51, { nearKm: 60 }), {
|
||||
kind: 'sea',
|
||||
name: 'Caspian Sea',
|
||||
countryCode: null,
|
||||
});
|
||||
assert.equal((await placeBelow(15, 88)).name, 'Bay of Bengal');
|
||||
assert.equal((await placeBelow(35, 18)).name, 'Mediterranean Sea');
|
||||
});
|
||||
|
||||
test('open water far from any sea is the ocean', async () => {
|
||||
assert.deepEqual(await placeBelow(0, -150), {
|
||||
kind: 'ocean',
|
||||
name: 'South Pacific Ocean',
|
||||
countryCode: null,
|
||||
});
|
||||
assert.equal((await placeBelow(40, 179.9)).name, 'North Pacific Ocean');
|
||||
assert.equal((await placeBelow(40, -179.9)).name, 'North Pacific Ocean');
|
||||
assert.equal((await placeBelow(40, -40)).name, 'North Atlantic Ocean');
|
||||
});
|
||||
|
||||
test('an invalid point has no place', async () => {
|
||||
assert.equal(await placeBelow(Number.NaN, 0), null);
|
||||
assert.equal(await placeBelow(91, 0), null);
|
||||
});
|
||||
|
||||
/** A lookup whose answers the test releases by hand. */
|
||||
function manualLookup() {
|
||||
const calls = [];
|
||||
const lookup = (lat, lon, options) =>
|
||||
new Promise((resolve) => calls.push({ lat, lon, options, resolve }));
|
||||
return { calls, lookup };
|
||||
}
|
||||
const flush = () => new Promise((resolve) => setTimeout(resolve, 0));
|
||||
|
||||
test('the tracker looks up again only after both time and distance', async () => {
|
||||
const { calls, lookup } = manualLookup();
|
||||
const places = [];
|
||||
const tracker = createPlaceTracker({
|
||||
lookup,
|
||||
onPlace: (place) => places.push(place),
|
||||
});
|
||||
assert.equal(tracker.update(0, 0, 1000), true, 'the first point');
|
||||
await flush();
|
||||
assert.equal(tracker.update(5, 5, 1100), false, 'one lookup at a time');
|
||||
calls[0].resolve({ kind: 'ocean', name: 'A' });
|
||||
await flush();
|
||||
assert.deepEqual(places, [{ kind: 'ocean', name: 'A' }]);
|
||||
// Far enough, but too soon.
|
||||
assert.equal(tracker.update(5, 5, 1000 + PLACE_LOOKUP_MIN_MS - 1), false);
|
||||
// Long enough, but barely moved (a geostationary satellite).
|
||||
assert.equal(tracker.update(0.01, 0, 1000 + PLACE_LOOKUP_MIN_MS * 5), false);
|
||||
// Both: a low orbit ~2.6 s on.
|
||||
const movedDeg = (PLACE_LOOKUP_MIN_MOVE_KM + 1) / 111.2;
|
||||
assert.equal(
|
||||
tracker.update(movedDeg, 0, 1000 + PLACE_LOOKUP_MIN_MS * 5),
|
||||
true,
|
||||
);
|
||||
await flush();
|
||||
calls[1].resolve(null);
|
||||
await flush();
|
||||
assert.deepEqual(places.at(-1), null, 'nothing named there is reported');
|
||||
});
|
||||
|
||||
test('a new radius (a zoom step) looks up again at once', async () => {
|
||||
const { calls, lookup } = manualLookup();
|
||||
const tracker = createPlaceTracker({ lookup, onPlace: () => {} });
|
||||
assert.equal(tracker.update(0, 0, 1000), true);
|
||||
await flush();
|
||||
assert.deepEqual(calls[0].lat, 0);
|
||||
calls[0].resolve(null);
|
||||
await flush();
|
||||
// Same point, a moment later: only the zoom changed.
|
||||
assert.equal(tracker.update(0, 0, 1100, 60), true, 'into 8x');
|
||||
await flush();
|
||||
calls[1].resolve(null);
|
||||
await flush();
|
||||
// Altitude drift barely moves the radius: the gate holds.
|
||||
assert.equal(tracker.update(0, 0, 1200, 62), false);
|
||||
assert.equal(tracker.update(0, 0, 1300, 30), true, 'to 16x');
|
||||
await flush();
|
||||
calls[2].resolve(null);
|
||||
await flush();
|
||||
assert.equal(tracker.update(0, 0, 1400, null), true, 'back below 8x');
|
||||
await flush();
|
||||
assert.deepEqual(
|
||||
calls.map((call) => call.options),
|
||||
[{ nearKm: null }, { nearKm: 60 }, { nearKm: 30 }, { nearKm: null }],
|
||||
);
|
||||
});
|
||||
|
||||
test('a lookup that lands after reset is dropped', async () => {
|
||||
const { calls, lookup } = manualLookup();
|
||||
const places = [];
|
||||
const tracker = createPlaceTracker({
|
||||
lookup,
|
||||
onPlace: (place) => places.push(place),
|
||||
});
|
||||
tracker.update(0, 0, 0);
|
||||
await flush();
|
||||
tracker.reset();
|
||||
// A new session looks up at once.
|
||||
assert.equal(tracker.update(10, 10, 1), true);
|
||||
await flush();
|
||||
calls[0].resolve({ name: 'stale' });
|
||||
calls[1].resolve({ name: 'fresh' });
|
||||
await flush();
|
||||
assert.deepEqual(places, [{ name: 'fresh' }]);
|
||||
});
|
||||
|
||||
test('a failed lookup frees the tracker for the next point', async () => {
|
||||
let fail = true;
|
||||
const places = [];
|
||||
const tracker = createPlaceTracker({
|
||||
lookup: async () => {
|
||||
if (fail) throw new Error('pack failed');
|
||||
return { name: 'ok' };
|
||||
},
|
||||
onPlace: (place) => places.push(place),
|
||||
minIntervalMs: 0,
|
||||
minMoveKm: 0,
|
||||
});
|
||||
tracker.update(0, 0, 0);
|
||||
await flush();
|
||||
assert.deepEqual(places, [null]);
|
||||
fail = false;
|
||||
assert.equal(tracker.update(0, 0, 1), true);
|
||||
await flush();
|
||||
assert.deepEqual(places, [null, { name: 'ok' }]);
|
||||
});
|
||||
|
||||
test('the near-place radius is half the smaller side of the view', () => {
|
||||
assert.equal(nearPlaceRadiusKm(8, 120, 60), 30, 'landscape');
|
||||
assert.equal(nearPlaceRadiusKm(8, 60, 120), 30, 'portrait');
|
||||
assert.equal(nearPlaceRadiusKm(8, 120), 60, 'square without a height');
|
||||
assert.equal(nearPlaceRadiusKm(8, 120, Number.NaN), null);
|
||||
});
|
||||
|
||||
test('a failed division or place pack still names the country', async () => {
|
||||
const fail = async () => {
|
||||
throw new Error('pack failed');
|
||||
};
|
||||
const place = await placeBelow(30.9, 104.2, {
|
||||
nearKm: 60,
|
||||
detail: { division: fail, near: fail },
|
||||
});
|
||||
assert.equal(place.kind, 'country');
|
||||
assert.equal(place.countryCode, 'CN');
|
||||
assert.equal(place.division, null);
|
||||
assert.equal(place.near, null);
|
||||
});
|
||||
|
||||
test('a failed lookup hides the old place and looks again on the next update', async () => {
|
||||
let fail = false;
|
||||
const places = [];
|
||||
const tracker = createPlaceTracker({
|
||||
lookup: async () => {
|
||||
if (fail) throw new Error('pack failed');
|
||||
return { kind: 'sea', name: 'Bay of Biscay' };
|
||||
},
|
||||
onPlace: (place) => places.push(place),
|
||||
});
|
||||
assert.equal(tracker.update(45, -5, 0), true);
|
||||
await flush();
|
||||
assert.deepEqual(places, [{ kind: 'sea', name: 'Bay of Biscay' }]);
|
||||
// Over France the lookup fails: the bay must not stay on the band.
|
||||
fail = true;
|
||||
const movedDeg = (PLACE_LOOKUP_MIN_MOVE_KM + 1) / 111.2;
|
||||
assert.equal(tracker.update(45 + movedDeg, 0, PLACE_LOOKUP_MIN_MS), true);
|
||||
await flush();
|
||||
assert.equal(places.at(-1), null, 'the band hides');
|
||||
// The next tick tries again at once, even without moving (a GEO view).
|
||||
fail = false;
|
||||
assert.equal(tracker.update(45 + movedDeg, 0, PLACE_LOOKUP_MIN_MS + 1), true);
|
||||
await flush();
|
||||
assert.deepEqual(places.at(-1), { kind: 'sea', name: 'Bay of Biscay' });
|
||||
});
|
||||
Reference in new issue
Block a user