A spy satellite simulator in your browser, except the data is real. Live open source spatial intelligence on a photorealistic 3D globe.
JavaScript 3d-globecesiumflight-trackinggeospatialgeospatial-intelligencegisosintphotogrammetrysatellite-trackingspatial-intelligencewebglworldview
import test from 'node:test';
import assert from 'node:assert/strict';
import {
createOverpassFeatureSource,
geometryOutputBox,
FEATURE_SOURCE_METHODS,
} from './overpassFeatures.js';
import { normalizeOverpassFeatures } from './overpassFeaturesRecords.js';
import { createAnnotationResolver } from '../annotations/resolver.js';
const geometry = [
{ lat: 30, lon: -97 },
{ lat: 30, lon: -96.999 },
{ lat: 30.001, lon: -96.999 },
{ lat: 30.001, lon: -97 },
{ lat: 30, lon: -97 },
];
const raw = {
type: 'way',
id: 42,
tags: { name: 'Fixture Tower', building: 'yes', height: '100 ft' },
geometry,
};
const candidate = {
id: 42,
category: 'feature',
names: { primary: 'Fixture Tower' },
building: true,
heightM: 30.48,
coordinates: geometry,
};
const featureSource = (overrides) =>
Object.assign(
Object.fromEntries(
FEATURE_SOURCE_METHODS.map((method) => [method, async () => []]),
),
overrides,
);
test('Overpass adapter owns all feature query expressions and normalizes returned records', async () => {
const calls = [];
const source = createOverpassFeatureSource({
boundarySource: {
query: async (query, options) => {
calls.push({ query, options });
return [raw, { ...raw, type: 'relation' }];
},
},
});
for (const method of FEATURE_SOURCE_METHODS) {
const records = await source[method](
method === 'getAreaGeometry' ? 3600000042 : { lat: 30, lon: -97 },
);
assert.equal(records[0].names.primary, 'Fixture Tower');
assert.equal(records[0].heightM, 30.48);
assert.deepEqual(records[0].coordinates, geometry);
assert.equal('tags' in records[0], false);
assert.equal(records.length, method === 'getAreaGeometry' ? 1 : 2);
}
assert.equal(calls.length, 9);
assert.ok(
calls.every(
({ query, options }) =>
query.includes('[out:json]') && options.signal instanceof AbortSignal,
),
);
assert.match(calls[1].query, /rel\(pivot.x\)/);
assert.match(calls[4].query, /\["highway"\]/);
assert.match(calls[7].query, /memorial\|monument/);
assert.match(calls[8].query, /around:180,/);
assert.throws(
() => source.getFootprints({ lat: '30);out;', lon: -97 }),
/coordinates/,
);
assert.throws(() => source.getAreaGeometry('1);out;'), /reference/);
assert.equal(calls.length, 9);
});
test('provider preserves empty, transient and throttled responses and rejects late canceled data', async () => {
const lifetime = new AbortController();
let value = [];
const source = createOverpassFeatureSource({
signal: lifetime.signal,
boundarySource: { query: async () => value },
});
assert.deepEqual(await source.getFootprints({ lat: 30, lon: -97 }), []);
value = null;
assert.equal(await source.getFootprints({ lat: 30, lon: -97 }), null);
value = { rateLimited: true, retryAfterMs: 1500 };
assert.deepEqual(await source.getFootprints({ lat: 30, lon: -97 }), value);
let respond, signal;
const pendingSource = createOverpassFeatureSource({
signal: lifetime.signal,
boundarySource: {
query: async (_q, options) => {
signal = options.signal;
return new Promise((resolve) => {
respond = resolve;
});
},
},
});
const pending = pendingSource.getFootprints({ lat: 30, lon: -97 });
lifetime.abort();
respond([raw]);
assert.equal(signal.aborted, true);
assert.equal(await pending, null);
});
test('relation normalization keeps the largest closed outer and rejects a missing boundary', () => {
const relation = {
type: 'relation',
id: 1,
tags: { name: 'Region' },
members: [
{ role: 'outer', geometry: geometry.slice(0, 3) },
{ role: 'outer', geometry: geometry.slice(2) },
{
role: 'inner',
geometry: geometry.map((p) => ({ lat: p.lat + 1, lon: p.lon + 1 })),
},
],
};
assert.deepEqual(
normalizeOverpassFeatures([relation])[0].coordinates,
geometry,
);
relation.members = [{ role: 'outer', geometry: geometry.slice(0, 3) }];
assert.deepEqual(normalizeOverpassFeatures([relation])[0].coordinates, []);
assert.deepEqual(
normalizeOverpassFeatures([{ ...raw, geometry: undefined, members: {} }], {
focus: true,
})[0].coordinates,
[],
);
});
test('annotation selection accepts another feature provider with no query transport', async () => {
let calls = 0;
const resolver = createAnnotationResolver({
featureSource: featureSource({
getFootprints: async () => {
calls++;
return [candidate];
},
}),
});
const args = {
latitude: 30.0005,
longitude: -96.9995,
target: 'Fixture Tower',
entityKind: 'building',
footprint: true,
};
const first = await resolver.resolveAnnotationTarget(args);
const second = await resolver.resolveAnnotationTarget(args);
assert.equal(first.footprintKind, 'building');
assert.equal(first.buildingHeight, 30.48);
assert.deepEqual(
first.ring,
geometry.map((p) => [p.lon, p.lat]),
);
assert.deepEqual(second.ring, first.ring);
assert.equal(
calls,
1,
'ranking cache is independent of the provider implementation',
);
});
test('annotation retries transient feature failures but caches definitive misses', async () => {
let calls = 0;
const resolver = createAnnotationResolver({
featureSource: featureSource({
getFootprints: async () => {
calls++;
return calls === 1 ? null : [];
},
}),
});
const anchor = await resolver.resolveAnnotationTarget({
latitude: 30.0005,
longitude: -96.9995,
target: 'Missing Tower',
entityKind: 'building',
footprint: true,
deferFootprint: true,
});
assert.equal(await anchor.resolveOutline(), undefined);
assert.equal(await anchor.resolveOutline(), null);
assert.equal(await anchor.resolveOutline(), null);
assert.equal(calls, 2);
});
// A multipolygon relation as Overpass prints it with `out geom`: the outer
// boundary split across two ways, an inner ring, and a label node.
const relationRing = [
{ lat: 30, lon: -97 },
{ lat: 30, lon: -96.994 },
{ lat: 30.005, lon: -96.994 },
{ lat: 30.005, lon: -97 },
{ lat: 30, lon: -97 },
];
const relationFixture = (name, tags) => ({
type: 'relation',
id: 7,
bounds: { minlat: 30, minlon: -97, maxlat: 30.005, maxlon: -96.994 },
members: [
{ type: 'way', ref: 71, role: 'outer', geometry: relationRing.slice(0, 3) },
{ type: 'way', ref: 72, role: 'outer', geometry: relationRing.slice(2) },
{
type: 'way',
ref: 73,
role: 'inner',
geometry: relationRing.map((p) => ({ lat: p.lat + 0.001, lon: p.lon })),
},
{ type: 'node', ref: 74, role: 'label', lat: 30.0025, lon: -96.997 },
],
tags: { name, ...tags },
});
// Overpass leaves members out at `tags` verbosity, so `geom` has nothing to
// attach to and a relation keeps only its bounds.
const overpassPrinting = (element) => ({
query: async (text) =>
/\bout\s+tags\b/.test(text)
? [
{
type: element.type,
id: element.id,
bounds: element.bounds,
tags: element.tags,
},
]
: [element],
});
test('neighborhood and street-area lookups keep relation member geometry', async () => {
const calls = [];
const source = createOverpassFeatureSource({
boundarySource: {
query: async (text) => {
calls.push(text);
return overpassPrinting(
relationFixture('Fixture Quarter', { place: 'quarter' }),
).query(text);
},
},
});
for (const method of ['getNeighborhoodAreas', 'getStreetAreas']) {
const [record] = await source[method]({ lat: 30.002, lon: -96.997 });
assert.deepEqual(record.coordinates, relationRing, method);
}
// Member geometry is printed only inside a box around the point.
assert.ok(
calls[0].endsWith(');out geom(29.9481,-97.05924,30.0559,-96.93476);'),
);
assert.ok(
calls[1].endsWith(');out geom(29.97505,-97.02812,30.02895,-96.96588);'),
);
for (const text of calls) assert.doesNotMatch(text, /\bout\s+tags\b/);
});
test('the geometry output box is a bounded square around the point', () => {
const box = geometryOutputBox(30, -97, 6000)
.slice(1, -1)
.split(',')
.map(Number);
const [south, west, north, east] = box;
assert.ok(Math.abs((north - south) * 111320 - 12000) < 2);
assert.ok(
Math.abs((east - west) * 111320 * Math.cos((30 * Math.PI) / 180) - 12000) <
2,
);
assert.equal(geometryOutputBox(89.99, 179.99, 6000).includes('90,180'), true);
});
test('annotations outline a neighborhood or street area mapped as a relation', async () => {
const ring = relationRing.map((p) => [p.lon, p.lat]);
const areas = (tags, name) => {
const source = createOverpassFeatureSource({
boundarySource: overpassPrinting(relationFixture(name, tags)),
});
return (point, options) =>
source[tags.place ? 'getNeighborhoodAreas' : 'getStreetAreas'](
point,
options,
);
};
const neighborhood = await createAnnotationResolver({
featureSource: featureSource({
getNeighborhoodAreas: areas(
{ place: 'neighbourhood' },
'Fixture Heights',
),
}),
}).resolveAnnotationTarget({
latitude: 30.002,
longitude: -96.997,
target: 'Fixture Heights',
entityKind: 'district',
footprint: true,
});
assert.equal(neighborhood.footprintKind, 'area');
assert.deepEqual(neighborhood.ring, ring);
const street = await createAnnotationResolver({
featureSource: featureSource({
getStreetAreas: areas(
{ landuse: 'retail', type: 'multipolygon' },
'Fixture Street Market',
),
}),
}).resolveAnnotationTarget({
latitude: 30.002,
longitude: -96.997,
target: 'Fixture Street',
entityKind: 'street',
footprint: true,
});
assert.equal(street.footprintKind, 'area');
assert.deepEqual(street.ring, ring);
});
test('focus footprints keep relation members and centers', async () => {
let query;
const element = relationFixture('Fixture Building', { building: 'yes' });
const source = createOverpassFeatureSource({
boundarySource: {
query: async (text) => {
query = text;
return overpassPrinting(element).query(text);
},
},
});
const [record] = await source.getFocusFootprints({
lat: 30.002,
lon: -96.997,
});
assert.deepEqual(
record.coordinates,
element.members.flatMap((member) => member.geometry || []),
);
assert.match(query, /out center geom\([-\d.,]+\);/);
assert.doesNotMatch(query, /out tags/);
});