Merge origin/main into the renderer-contract branch: the procedural fleet models drawn through the renderer's model sets

Aircraft, military, local ADS-B, vessel, transit and rail models come from
the fleet model set, loaded up front and drawn life size through the draw
port's models sets; no layer touches the viewer or Cesium outside
src/render/cesium/. The models capability gains glTF bytes (gltf), a
per-axis stretch (axisScale), a colour for tinted parts (maskColor) and a
cut below the origin (clip: 'belowOrigin'), with conformance checks.

Main's rail layer and Data Library are ported to the ports; the CCTV
footprint probe keeps the globe-terrain clamp through the query port.
This commit is contained in:
Sameh Khamis committed 2026-11-13 14:14:42 -08:00
commit e3865f462f
533 files changed
+55738 -2518

No files matched your search

+73
View File
@@ -0,0 +1,73 @@
/**
* "Zoom to layer" for Data Library layers. Callers run this inside the
* shell's immediate navigation (`runImmediateNavigation('layer', …)`), so
* Cockpit can refuse it and the current follow owner is released first.
* The flight goes through the renderer's camera port.
*/
import { cancelCameraArrival } from '../data/cameraArrival.js';
import { findCamera } from '../render/rendererOf.js';
import { isWorldScale, padExtent } from './extent.js';
/** Camera height for a world-scale layer: the whole globe in view. */
const WORLD_HEIGHT_M = 20_000_000;
/** Where a view-bounded zoom lands, as a share of the layer's altitude. */
const VIEW_LANDING_FRACTION = 0.6;
/**
* Fly the camera to frame an extent, looking straight down, north up.
* @param {object} viewer
* @param {{ west: number, south: number, east: number, north: number, maxAltitudeM?: number }} extent
* `maxAltitudeM` marks a view-bounded layer's limit.
* @param {{ reducedMotion?: boolean }} [options]
* @returns {boolean} Whether a flight started.
*/
export function flyToLibraryExtent(
viewer,
extent,
{
reducedMotion = globalThis.matchMedia?.('(prefers-reduced-motion: reduce)')
?.matches === true,
} = {},
) {
const camera = findCamera(viewer);
if (!camera?.flyTo || !extent) return false;
cancelCameraArrival(viewer);
const box = padExtent(extent);
const options = { durationS: reducedMotion ? 0 : 1.6 };
// A view-bounded layer loads only below its altitude: land straight above
// its sample area, low enough for the layer to load.
if (Number.isFinite(extent.maxAltitudeM)) {
camera.flyTo(
{
lon: (extent.west + extent.east) / 2,
lat: (extent.south + extent.north) / 2,
height: extent.maxAltitudeM * VIEW_LANDING_FRACTION,
},
options,
);
return true;
}
if (isWorldScale(box)) {
const lon = (box.west + box.east) / 2;
const lat = (box.south + box.north) / 2;
camera.flyTo(
{ lon: lon > 180 ? lon - 360 : lon, lat, height: WORLD_HEIGHT_M },
options,
);
return true;
}
// A rectangle whose west is east of its east crosses the antimeridian.
const wrap = (lon) => (lon > 180 ? lon - 360 : lon < -180 ? lon + 360 : lon);
camera.flyTo(
{
rect: {
west: wrap(box.west),
south: box.south,
east: wrap(box.east),
north: box.north,
},
},
options,
);
return true;
}
+66
View File
@@ -0,0 +1,66 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import { bindRenderer } from '../render/rendererOf.js';
import { flyToLibraryExtent } from './camera.js';
function flyingViewer(t) {
const viewer = {};
const flights = [];
const unbind = bindRenderer(viewer, {
camera: {
flyTo(destination, options) {
flights.push({ destination, options });
return { done: Promise.resolve('complete'), cancel() {} };
},
},
});
t.after(unbind);
return { viewer, flights };
}
test('Zoom to layer flies to the extent through the camera port', (t) => {
const { viewer, flights } = flyingViewer(t);
const extent = { west: 10, south: 50, east: 12, north: 51 };
assert.equal(
flyToLibraryExtent(viewer, extent, { reducedMotion: false }),
true,
);
const [{ destination, options }] = flights;
assert.equal(options.durationS, 1.6);
// Already wide enough: the box itself.
assert.deepEqual(destination, { rect: extent });
});
test('a view-bounded layer lands straight above its sample, below its altitude', (t) => {
const { viewer, flights } = flyingViewer(t);
flyToLibraryExtent(
viewer,
{
west: -77.04,
south: 38.885,
east: -77.02,
north: 38.9,
maxAltitudeM: 4000,
},
{ reducedMotion: true },
);
const [{ destination, options }] = flights;
assert.equal(options.durationS, 0);
assert.ok(Math.abs(destination.lon - -77.03) < 1e-9);
assert.ok(Math.abs(destination.lat - 38.8925) < 1e-9);
assert.equal(destination.height, 2400);
});
test('a world-scale layer shows the whole globe; no camera, no flight', (t) => {
const { viewer, flights } = flyingViewer(t);
flyToLibraryExtent(
viewer,
{ west: -180, south: -85, east: 180, north: 85 },
{ reducedMotion: true },
);
assert.equal(flights[0].destination.height, 20_000_000);
assert.equal(
flyToLibraryExtent({}, { west: 0, south: 0, east: 1, north: 1 }),
false,
);
});
+228
View File
@@ -0,0 +1,228 @@
/**
* The Data Library catalog: every manifest in `src/library/entries/`.
*
* Adding an entry is one JSON file plus one import line here, and a share
* token in `ledger.json` when the entry can be switched on (datasets and
* tiles). `npm run library:check` fails when a file, import or token is
* missing. Manifests are validated when this module loads, so an invalid
* entry fails the unit suite rather than reaching a page.
*/
import { validateLibraryCatalog } from './manifest.js';
import ledgerRows from './ledger.json' with { type: 'json' };
import akStatewideImagery from './entries/ak-statewide-imagery.json' with { type: 'json' };
import arStatewideImagery from './entries/ar-statewide-imagery.json' with { type: 'json' };
import azStatewideImagery from './entries/az-statewide-imagery.json' with { type: 'json' };
import amsterdamTrafficCameras from './entries/amsterdam-traffic-cameras.json' with { type: 'json' };
import bayernDop40 from './entries/bayern-dop40.json' with { type: 'json' };
import bismarckMandanNd from './entries/bismarck-mandan-nd.json' with { type: 'json' };
import bkgTopplusOpen from './entries/bkg-topplus-open.json' with { type: 'json' };
import cctvFloridaFl511 from './entries/cctv-florida-fl511.json' with { type: 'json' };
import cctvLithuania from './entries/cctv-lithuania.json' with { type: 'json' };
import cctvNycDot from './entries/cctv-nyc-dot.json' with { type: 'json' };
import ctStatewideImagery from './entries/ct-statewide-imagery.json' with { type: 'json' };
import dakotaCountyMn from './entries/dakota-county-mn.json' with { type: 'json' };
import dcStatewideImagery from './entries/dc-statewide-imagery.json' with { type: 'json' };
import deStatewideImagery from './entries/de-statewide-imagery.json' with { type: 'json' };
import eeMaaAmetOrtofoto from './entries/ee-maa-amet-ortofoto.json' with { type: 'json' };
import eiaPowerPlants from './entries/eia-power-plants.json' with { type: 'json' };
import epaSuperfundSites from './entries/epa-superfund-sites.json' with { type: 'json' };
import epaToxicReleaseFacilities from './entries/epa-toxic-release-facilities.json' with { type: 'json' };
import epcEnglandWales from './entries/epc-england-wales.json' with { type: 'json' };
import femaUsaStructures from './entries/fema-usa-structures.json' with { type: 'json' };
import gbifOccurrenceDensity from './entries/gbif-occurrence-density.json' with { type: 'json' };
import gdacsDisasterAlerts from './entries/gdacs-disaster-alerts.json' with { type: 'json' };
import grandForksNd from './entries/grand-forks-nd.json' with { type: 'json' };
import gsiJapanMap from './entries/gsi-japan-map.json' with { type: 'json' };
import gsiJapanPhoto from './entries/gsi-japan-photo.json' with { type: 'json' };
import gvpHoloceneVolcanoes from './entries/gvp-holocene-volcanoes.json' with { type: 'json' };
import iaStatewideImagery from './entries/ia-statewide-imagery.json' with { type: 'json' };
import idStatewideImagery from './entries/id-statewide-imagery.json' with { type: 'json' };
import ignOrthophotosFrance from './entries/ign-orthophotos-france.json' with { type: 'json' };
import ilStatewideImagery from './entries/il-statewide-imagery.json' with { type: 'json' };
import imfPortwatchChokepoints from './entries/imf-portwatch-chokepoints.json' with { type: 'json' };
import imfPortwatchDisruptions from './entries/imf-portwatch-disruptions.json' with { type: 'json' };
import inStatewideImagery from './entries/in-statewide-imagery.json' with { type: 'json' };
import jrcSurfaceWater from './entries/jrc-surface-water.json' with { type: 'json' };
import kartverketAdminUnits from './entries/kartverket-admin-units.json' with { type: 'json' };
import kartverketCadastre from './entries/kartverket-cadastre.json' with { type: 'json' };
import kartverketDepth from './entries/kartverket-depth.json' with { type: 'json' };
import kartverketHillshade from './entries/kartverket-hillshade.json' with { type: 'json' };
import kartverketNauticalCharts from './entries/kartverket-nautical-charts.json' with { type: 'json' };
import kartverketTerrainRelief from './entries/kartverket-terrain-relief.json' with { type: 'json' };
import kartverketTopoGrey from './entries/kartverket-topo-grey.json' with { type: 'json' };
import kartverketTopo from './entries/kartverket-topo.json' with { type: 'json' };
import kartverketToporaster from './entries/kartverket-toporaster.json' with { type: 'json' };
import ksStatewideImagery from './entries/ks-statewide-imagery.json' with { type: 'json' };
import kyStatewideImagery from './entries/ky-statewide-imagery.json' with { type: 'json' };
import lakeCountyIn from './entries/lake-county-in.json' with { type: 'json' };
import lawrenceKs from './entries/lawrence-ks.json' with { type: 'json' };
import leeCountyFl from './entries/lee-county-fl.json' with { type: 'json' };
import loudounCountyVa from './entries/loudoun-county-va.json' with { type: 'json' };
import louisvilleLojicKy from './entries/louisville-lojic-ky.json' with { type: 'json' };
import maStatewideImagery from './entries/ma-statewide-imagery.json' with { type: 'json' };
import macrostratGeology from './entries/macrostrat-geology.json' with { type: 'json' };
import mapterhornTerrain from './entries/mapterhorn-terrain.json' with { type: 'json' };
import marisMs from './entries/maris-ms.json' with { type: 'json' };
import mdStatewideImagery from './entries/md-statewide-imagery.json' with { type: 'json' };
import meStatewideImagery from './entries/me-statewide-imagery.json' with { type: 'json' };
import miStatewideImagery from './entries/mi-statewide-imagery.json' with { type: 'json' };
import mountainVillageCo from './entries/mountain-village-co.json' with { type: 'json' };
import msStatewideImagery from './entries/ms-statewide-imagery.json' with { type: 'json' };
import mtStatewideImagery from './entries/mt-statewide-imagery.json' with { type: 'json' };
import naip from './entries/naip.json' with { type: 'json' };
import nasaBlackMarble from './entries/nasa-black-marble.json' with { type: 'json' };
import nasaEonetEvents from './entries/nasa-eonet-events.json' with { type: 'json' };
import ncStatewideImagery from './entries/nc-statewide-imagery.json' with { type: 'json' };
import nctcogTx from './entries/nctcog-tx.json' with { type: 'json' };
import ndStatewideImagery from './entries/nd-statewide-imagery.json' with { type: 'json' };
import newOrleansRpcLa from './entries/new-orleans-rpc-la.json' with { type: 'json' };
import nhStatewideImagery from './entries/nh-statewide-imagery.json' with { type: 'json' };
import njStatewideImagery from './entries/nj-statewide-imagery.json' with { type: 'json' };
import noaaTideStations from './entries/noaa-tide-stations.json' with { type: 'json' };
import nrwDop from './entries/nrw-dop.json' with { type: 'json' };
import nswImagery from './entries/nsw-imagery.json' with { type: 'json' };
import ntadNationalBridges from './entries/ntad-national-bridges.json' with { type: 'json' };
import nwaBentonWashingtonAr from './entries/nwa-benton-washington-ar.json' with { type: 'json' };
import nwsActiveAlerts from './entries/nws-active-alerts.json' with { type: 'json' };
import nyStatewideImagery from './entries/ny-statewide-imagery.json' with { type: 'json' };
import oaklandCountyMi from './entries/oakland-county-mi.json' with { type: 'json' };
import ohStatewideImagery from './entries/oh-statewide-imagery.json' with { type: 'json' };
import orStatewideImagery from './entries/or-statewide-imagery.json' with { type: 'json' };
import paStatewideImagery from './entries/pa-statewide-imagery.json' with { type: 'json' };
import plOrtofotomapa from './entries/pl-ortofotomapa.json' with { type: 'json' };
import pnoaMa from './entries/pnoa-ma.json' with { type: 'json' };
import portlandMetroOr from './entries/portland-metro-or.json' with { type: 'json' };
import ptDgtOrtos from './entries/pt-dgt-ortos.json' with { type: 'json' };
import riStatewideImagery from './entries/ri-statewide-imagery.json' with { type: 'json' };
import swisstopoSwissimage from './entries/swisstopo-swissimage.json' with { type: 'json' };
import txStatewideImagery from './entries/tx-statewide-imagery.json' with { type: 'json' };
import unionCountyOh from './entries/union-county-oh.json' with { type: 'json' };
import usgsHydrography from './entries/usgs-hydrography.json' with { type: 'json' };
import usgsTopo from './entries/usgs-topo.json' with { type: 'json' };
import vaStatewideImagery from './entries/va-statewide-imagery.json' with { type: 'json' };
import vtStatewideImagery from './entries/vt-statewide-imagery.json' with { type: 'json' };
import wallonieOrtho from './entries/wallonie-ortho.json' with { type: 'json' };
import wiStatewideImagery from './entries/wi-statewide-imagery.json' with { type: 'json' };
import wriGlobalPowerPlants from './entries/wri-global-power-plants.json' with { type: 'json' };
import wvStatewideImagery from './entries/wv-statewide-imagery.json' with { type: 'json' };
/** Raw manifests in file-name order; the validated form is below. */
export const LIBRARY_MANIFESTS = Object.freeze([
akStatewideImagery,
amsterdamTrafficCameras,
arStatewideImagery,
azStatewideImagery,
bayernDop40,
bismarckMandanNd,
bkgTopplusOpen,
cctvFloridaFl511,
cctvLithuania,
cctvNycDot,
ctStatewideImagery,
dakotaCountyMn,
dcStatewideImagery,
deStatewideImagery,
eeMaaAmetOrtofoto,
eiaPowerPlants,
epaSuperfundSites,
epaToxicReleaseFacilities,
epcEnglandWales,
femaUsaStructures,
gbifOccurrenceDensity,
gdacsDisasterAlerts,
grandForksNd,
gsiJapanMap,
gsiJapanPhoto,
gvpHoloceneVolcanoes,
iaStatewideImagery,
idStatewideImagery,
ignOrthophotosFrance,
ilStatewideImagery,
imfPortwatchChokepoints,
imfPortwatchDisruptions,
inStatewideImagery,
jrcSurfaceWater,
kartverketAdminUnits,
kartverketCadastre,
kartverketDepth,
kartverketHillshade,
kartverketNauticalCharts,
kartverketTerrainRelief,
kartverketTopoGrey,
kartverketTopo,
kartverketToporaster,
ksStatewideImagery,
kyStatewideImagery,
lakeCountyIn,
lawrenceKs,
leeCountyFl,
loudounCountyVa,
louisvilleLojicKy,
maStatewideImagery,
macrostratGeology,
mapterhornTerrain,
marisMs,
mdStatewideImagery,
meStatewideImagery,
miStatewideImagery,
mountainVillageCo,
msStatewideImagery,
mtStatewideImagery,
naip,
nasaBlackMarble,
nasaEonetEvents,
ncStatewideImagery,
nctcogTx,
ndStatewideImagery,
newOrleansRpcLa,
nhStatewideImagery,
njStatewideImagery,
noaaTideStations,
nrwDop,
nswImagery,
ntadNationalBridges,
nwaBentonWashingtonAr,
nwsActiveAlerts,
nyStatewideImagery,
oaklandCountyMi,
ohStatewideImagery,
orStatewideImagery,
paStatewideImagery,
plOrtofotomapa,
pnoaMa,
portlandMetroOr,
ptDgtOrtos,
riStatewideImagery,
swisstopoSwissimage,
txStatewideImagery,
unionCountyOh,
usgsHydrography,
usgsTopo,
vaStatewideImagery,
vtStatewideImagery,
wallonieOrtho,
wiStatewideImagery,
wriGlobalPowerPlants,
wvStatewideImagery,
]);
const validated = validateLibraryCatalog(LIBRARY_MANIFESTS);
if (!validated.ok)
throw new TypeError(
`Invalid Data Library manifests:\n${validated.errors.join('\n')}`,
);
/** Validated, frozen entries with defaults filled. */
export const LIBRARY_ENTRIES = Object.freeze(validated.entries);
const BY_ID = new Map(LIBRARY_ENTRIES.map((entry) => [entry.id, entry]));
/** One entry by id, or undefined. */
export function libraryEntry(id) {
return BY_ID.get(id);
}
/** The share-link ledger rows, `[entryId, token]`, append-only. */
export const LIBRARY_LEDGER = Object.freeze(
ledgerRows.map((row) => Object.freeze([...row])),
);
+47
View File
@@ -0,0 +1,47 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import { readdirSync, readFileSync } from 'node:fs';
import { fileURLToPath } from 'node:url';
import path from 'node:path';
import {
LIBRARY_ENTRIES,
LIBRARY_LEDGER,
LIBRARY_MANIFESTS,
} from './catalog.js';
import { readLibraryLedger } from './selection.js';
const here = path.dirname(fileURLToPath(import.meta.url));
test('every manifest file is imported, named after its id', () => {
const files = readdirSync(path.join(here, 'entries'))
.filter((name) => name.endsWith('.json'))
.sort();
assert.deepEqual(
files,
LIBRARY_MANIFESTS.map(({ id }) => `${id}.json`).sort(),
);
for (const file of files) {
const raw = JSON.parse(
readFileSync(path.join(here, 'entries', file), 'utf8'),
);
assert.equal(`${raw.id}.json`, file);
}
});
test('every switchable entry owns a permanent share token', () => {
const ledger = readLibraryLedger(LIBRARY_LEDGER);
assert.deepEqual(ledger.errors, []);
for (const entry of LIBRARY_ENTRIES.filter(({ kind }) => kind !== 'pack'))
assert.ok(ledger.tokenById.has(entry.id), `${entry.id} has no token`);
// Packs are switched by their host, never by a share link.
for (const entry of LIBRARY_ENTRIES.filter(({ kind }) => kind === 'pack'))
assert.equal(ledger.tokenById.has(entry.id), false, entry.id);
});
test('nothing in the library is bundled: every source is a live https upstream', () => {
for (const entry of LIBRARY_ENTRIES) {
assert.match(entry.source.url, /^https:\/\//, entry.id);
assert.ok(entry.licence.name && entry.licence.url, entry.id);
assert.ok(entry.attribution.text, entry.id);
}
});
+547
View File
@@ -0,0 +1,547 @@
/**
* The Data Library controller: which entries this instance offers, which the
* viewer has added, and the lifetime of their layers.
*
* Core layers are registered once and sealed; library layers register only
* when a viewer adds them (`LayerLifecycle.registerLibraryLayer`), so the
* default panel stays the curated set and an unused entry costs nothing.
*/
import { LIBRARY_ENTRIES, LIBRARY_LEDGER } from './catalog.js';
import { libraryEntryIdOf, libraryLayerId } from './manifest.js';
import {
MAX_SELECTED,
decodeLibraryParam,
encodeLibraryParam,
normalizeLibrarySelection,
readLibraryLedger,
readStoredLibrarySelection,
writeStoredLibrarySelection,
} from './selection.js';
import { createLibrarySource } from './source.js';
import {
createLibraryDatasetLayer,
createLibraryTileLayer,
createLibraryViewLayer,
} from './layers.js';
import { isExplicitLayerStateOrigin } from '../data/layerState.js';
function safeLocalStorage() {
try {
return globalThis.localStorage ?? null;
} catch {
return null;
}
}
/**
* @param {object} options
* @param {object} options.dataManager The sealed LayerLifecycle.
* @param {object} options.services Local GeoJSON layer services.
* @param {() => object|null} [options.getTileset] Photoreal tileset reader.
* @param {object} [options.mapStackController]
* @param {object} [options.shareLink] ShareLinkManager.
* @param {string} [options.initialHash] The page hash at startup.
* @param {(reason: string) => void} [options.requestRender]
* @param {(extent: object) => boolean} [options.zoomTo] Fly to an extent
* through the shell's navigation authority; false when refused.
*/
export function createDataLibrary({
entries = LIBRARY_ENTRIES,
ledger = LIBRARY_LEDGER,
dataManager,
services,
getTileset = () => null,
mapStackController = null,
shareLink = null,
initialHash = globalThis.location?.hash ?? '',
requestRender = () => {},
zoomTo = null,
storage = safeLocalStorage(),
source = createLibrarySource({ entries }),
}) {
if (!dataManager?.registerLibraryLayer)
throw new TypeError('A sealed layer manager is required');
const byId = new Map(entries.map((entry) => [entry.id, entry]));
const switchable = new Set(
entries.filter(({ kind }) => kind !== 'pack').map(({ id }) => id),
);
const tokens = readLibraryLedger(ledger);
let availability = new Map();
let serverPresent = false;
let selection = { added: [], on: [] };
// What this browser remembers as on. Like core layer state, a share
// decides what is on for the session but never rewrites it: only the
// viewer's explicit choices and a local restore do.
let savedOn = [];
let started = false;
// Set once availability is known; a share navigated to before then waits.
let loaded = false;
let queuedShare = null;
let destroyed = false;
const listeners = new Set();
const pending = new Map();
const notify = () => {
for (const listener of [...listeners]) {
try {
listener();
} catch (error) {
console.warn('[Library] listener error:', error);
}
}
};
const persist = () => {
selection = normalizeLibrarySelection(selection, switchable);
savedOn = savedOn.filter((id) => selection.added.includes(id));
writeStoredLibrarySelection(storage, {
added: selection.added,
on: savedOn,
});
shareLink?.onLibraryStateChange?.();
notify();
};
function createLayer(entry) {
// No navigation owner, no Zoom chip: never a button that does nothing.
const onZoom =
typeof zoomTo === 'function'
? () => {
zoom(entry.id).catch((error) =>
console.warn(`[Library] ${entry.id} zoom failed:`, error),
);
}
: null;
const onRemove = () => {
remove(entry.id).catch((error) =>
console.warn(`[Library] ${entry.id} remove failed:`, error),
);
};
if (entry.kind === 'dataset' && entry.source.view)
return createLibraryViewLayer(entry, {
source,
onZoom,
onRemove,
requestRender,
});
if (entry.kind === 'dataset')
return createLibraryDatasetLayer(entry, {
services,
source,
onZoom,
onRemove,
});
return createLibraryTileLayer(entry, {
source,
getTileset,
mapStackController,
requestRender,
onZoom,
onRemove,
});
}
function isRegistered(id) {
return dataManager.layers.has(libraryLayerId(id));
}
function register(entry) {
if (isRegistered(entry.id)) return true;
try {
dataManager.registerLibraryLayer(createLayer(entry));
return true;
} catch (error) {
console.warn(`[Library] ${entry.id} could not register:`, error);
return false;
}
}
function addable(id) {
return switchable.has(id) && availability.get(id)?.available === true;
}
const unsubscribeManager = dataManager.subscribe?.((change) => {
if (change?.type !== 'visibility') return;
const id = libraryEntryIdOf(change.layerId);
if (!id || !selection.added.includes(id)) return;
// Like core layer state: only explicit choices are remembered, never a
// Context session's temporary changes or a restore.
if (!isExplicitLayerStateOrigin(change.origin)) {
notify();
return;
}
const on = new Set(selection.on);
const saved = new Set(savedOn);
if (change.enabled) {
on.add(id);
saved.add(id);
} else {
on.delete(id);
saved.delete(id);
}
selection = { ...selection, on: [...on] };
savedOn = [...saved];
persist();
});
/**
* The library after a share's entries join it. A share always fits: in a
* full library the oldest entries it leaves off make room for it, so a
* link opened into a full library still shows what it shares.
*/
function withShared(added, linked) {
const kept = [...new Set(added)].filter((id) => switchable.has(id));
const incoming = [...new Set(linked)].filter(
(id) => switchable.has(id) && !kept.includes(id),
);
let room = MAX_SELECTED - kept.length - incoming.length;
const result = [];
for (const id of kept) {
if (room < 0 && !linked.includes(id)) {
room += 1;
continue;
}
result.push(id);
}
return [...result, ...incoming];
}
/** Entry ids for share tokens; unknown tokens are skipped. */
const idsForTokens = (list) =>
(list || []).map((token) => tokens.idByToken.get(token)).filter(Boolean);
/**
* The share this page opened with: null without one, else the entry ids it
* switches on ([] for a share that switches none on).
*/
function openingShare() {
if (shareLink && shareLink.initialLibraryTokens !== undefined) {
const linked = shareLink.initialLibraryTokens;
return linked === null ? null : idsForTokens(linked);
}
const hash = String(initialHash || '').replace(/^#/, '');
if (!hash) return null;
const params = new URLSearchParams(hash);
const linked = decodeLibraryParam(params, tokens.idByToken);
// Any share (a camera position) decides what is on; no `lib`, nothing.
if (linked === null && params.has('lat') && params.has('lon')) return [];
return linked;
}
/**
* Apply a selection: register and switch on what `on` names, switch off
* every other added entry that is on. `origin` marks it as a restore so it
* is never remembered as the viewer's own choice.
*/
function applySelection(next, origin) {
const before = selection.added;
selection = normalizeLibrarySelection(next, switchable);
// Entries a share made room for leave with their layers.
for (const id of before) {
if (selection.added.includes(id) || !isRegistered(id)) continue;
dataManager
.unregisterLibraryLayer(libraryLayerId(id))
.catch((error) =>
console.warn(`[Library] ${id} could not be removed:`, error),
);
}
for (const id of selection.added) {
const entry = byId.get(id);
if (!entry || !addable(id)) continue;
const wanted = selection.on.includes(id);
if (wanted && !register(entry)) continue;
if (!isRegistered(id)) continue;
const layerId = libraryLayerId(id);
// Compare with the newest request, not settled state: a layer still
// switching on for an earlier share must be switched off by this one.
const current =
dataManager.isEffectivelyEnabled?.(layerId) ??
dataManager.isEnabled?.(layerId);
if (wanted === (current === true)) continue;
dataManager
.setEnabled(layerId, wanted, { origin })
.catch((error) =>
console.warn(`[Library] ${id} restore failed:`, error),
);
}
// A share's entries join the library; only a local restore sets what
// is remembered as on.
if (origin !== 'share-restore') savedOn = selection.on;
persist();
}
/**
* A share opened in this tab after start-up: its entries join the library
* and it alone decides which are on.
* @param {string[]} shareTokens
*/
function applyShare(shareTokens) {
if (destroyed) return;
if (!loaded) {
queuedShare = [...(shareTokens || [])];
return;
}
const linked = idsForTokens(shareTokens);
applySelection(
{ added: withShared(selection.added, linked), on: linked },
'share-restore',
);
}
shareLink?.setLibraryShareListener?.(applyShare);
// The URL carries what is on. Until availability loads (or when it never
// does) that is still what the page opened with, so a hash write in the
// meantime keeps it; an entry this instance cannot serve stays in it too.
shareLink?.setLibraryParamsEncoder?.((params) =>
encodeLibraryParam(
params,
loaded
? selection.on
: ((queuedShare ? idsForTokens(queuedShare) : openingShare()) ??
readStoredLibrarySelection(storage, switchable).on),
tokens.tokenById,
),
);
/**
* Read what this instance serves, then restore this browser's selection and
* any `lib=` entries in the opening link.
* @param {{ signal?: AbortSignal }} [options]
*/
async function start({ signal } = {}) {
if (started || destroyed) return;
started = true;
const answer = await source.getAvailability({ signal });
if (destroyed) return;
availability = answer.availability;
serverPresent = answer.server;
const stored = readStoredLibrarySelection(storage, switchable);
savedOn = stored.on;
// A share opened in this tab while availability loaded wins over the
// opening one.
const linked = queuedShare ? idsForTokens(queuedShare) : openingShare();
queuedShare = null;
loaded = true;
// A link's entries join the viewer's library and open switched on; with a
// link, it alone decides what is on, as it does for core layers, so a
// share with every library entry off switches the stored ones off.
// Added entries register even while off, so their rows show.
// Only what the selection keeps registers: past its cap an entry would
// be a row the library no longer knows.
const next = normalizeLibrarySelection(
{
added: linked ? withShared(stored.added, linked) : stored.added,
on: linked ?? stored.on,
},
switchable,
);
for (const id of next.added) {
const entry = byId.get(id);
if (entry && addable(id)) register(entry);
}
applySelection(next, linked ? 'share-restore' : 'local-restore');
}
/**
* Add an entry to the panel and switch it on.
* @param {string} id
* @returns {Promise<boolean>}
*/
async function add(id) {
if (destroyed || !addable(id) || pending.has(id)) return false;
// A full library refuses the entry before its layer exists.
if (!selection.added.includes(id) && selection.added.length >= MAX_SELECTED)
return false;
const entry = byId.get(id);
const work = (async () => {
if (!register(entry)) return false;
selection = {
added: [...selection.added.filter((other) => other !== id), id],
on: selection.on,
};
persist();
await dataManager.setEnabled(libraryLayerId(id), true, {
origin: 'user',
});
return true;
})();
pending.set(id, work);
notify();
try {
return await work;
} finally {
pending.delete(id);
notify();
}
}
/**
* Remove an entry from the panel and destroy its layer.
* @param {string} id
* @returns {Promise<boolean>}
*/
async function remove(id) {
if (destroyed || pending.has(id)) return false;
const work = (async () => {
// A layer that would not tear down is still there: keep it in the
// library so its row, Remove and Remove all still reach it.
if (
isRegistered(id) &&
!(await dataManager.unregisterLibraryLayer(libraryLayerId(id)))
) {
// Switched off before teardown failed: it is no longer on, so the
// link and what is remembered must not say it is.
if (!dataManager.isEnabled?.(libraryLayerId(id))) {
selection = {
...selection,
on: selection.on.filter((other) => other !== id),
};
savedOn = savedOn.filter((other) => other !== id);
persist();
}
return false;
}
selection = {
added: selection.added.filter((other) => other !== id),
on: selection.on.filter((other) => other !== id),
};
persist();
return true;
})();
pending.set(id, work);
notify();
try {
return await work;
} finally {
pending.delete(id);
notify();
}
}
/**
* Remove every added entry at once (the Browse dialog's reset).
* @returns {Promise<number>} How many entries were removed.
*/
async function reset() {
if (destroyed) return 0;
const ids = [...selection.added];
let removed = 0;
for (const id of ids) if (await remove(id)) removed += 1;
return removed;
}
/** The area an added entry's layer covers, or null. */
function extentOf(id) {
return (
dataManager.layers.get(libraryLayerId(id))?.module?.getExtent?.() ?? null
);
}
/**
* Fly to an added entry's layer, switching it on first when it is off: a
* dataset only knows where its features are once loaded, and an off layer
* has nothing to show at the destination.
* @param {string} id
* @returns {Promise<boolean>} Whether the flight started.
*/
async function zoom(id) {
if (destroyed || typeof zoomTo !== 'function' || !isRegistered(id))
return false;
const layerId = libraryLayerId(id);
if (!dataManager.isEnabled?.(layerId))
await dataManager.setEnabled(layerId, true, { origin: 'user' });
const extent = extentOf(id);
if (destroyed || !extent) return false;
return zoomTo(extent) !== false;
}
/**
* Everything the Browse view shows, in catalog order.
* @returns {Array<{ entry: object, available: boolean, reason: string|null, added: boolean, on: boolean, busy: boolean }>}
*/
function list() {
return entries.map((entry) => {
const state = availability.get(entry.id) || {
available: false,
reason: started ? 'server-unavailable' : null,
};
return {
entry,
available: state.available,
reason: state.reason,
// An entry this instance cannot serve now stays added (and can be
// removed) without a layer: it still holds a place in the library.
added: selection.added.includes(entry.id),
on: dataManager.isEnabled?.(libraryLayerId(entry.id)) === true,
busy: pending.has(entry.id),
canZoom: typeof zoomTo === 'function' && isRegistered(entry.id),
};
});
}
/**
* The library at a glance, for the Browse dialog's stats strip.
* `features` sums the features currently loaded by dataset layers that are
* on; tiles are drapes and have no count.
* @returns {{ entries: number, kinds: { dataset: number, tiles: number, pack: number }, themes: string[], available: number, unavailable: number, added: number, on: number, features: number, featureLayers: number }}
*/
function summary() {
const rows = list();
const kinds = { dataset: 0, tiles: 0, pack: 0 };
let features = 0;
let featureLayers = 0;
for (const row of rows) {
kinds[row.entry.kind] += 1;
if (!row.on || row.entry.kind !== 'dataset') continue;
const count = dataManager.layers
.get(libraryLayerId(row.entry.id))
?.module?.getStats?.()?.count;
if (Number.isFinite(count) && count > 0) {
features += count;
featureLayers += 1;
}
}
const available = rows.filter((row) => row.available).length;
return {
entries: rows.length,
kinds,
// Distinct themes (manifest families) the entries cover, sorted.
themes: [...new Set(rows.map((row) => row.entry.family))].sort(),
available,
unavailable: rows.length - available,
added: rows.filter((row) => row.added).length,
on: rows.filter((row) => row.on).length,
features,
featureLayers,
};
}
return {
start,
add,
remove,
summary,
reset,
zoom,
list,
get ready() {
return started && availability.size > 0;
},
get serverPresent() {
return serverPresent;
},
subscribe(listener) {
if (typeof listener !== 'function') return () => {};
listeners.add(listener);
return () => listeners.delete(listener);
},
destroy() {
if (destroyed) return;
destroyed = true;
unsubscribeManager?.();
shareLink?.setLibraryParamsEncoder?.(null);
shareLink?.setLibraryShareListener?.(null);
listeners.clear();
},
};
}
+774
View File
@@ -0,0 +1,774 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import { LayerLifecycle } from '../data/lifecycle.js';
import { createDataLibrary } from './controller.js';
import { LIBRARY_ENTRIES, LIBRARY_LEDGER } from './catalog.js';
import { validateLibraryCatalog } from './manifest.js';
import { LIBRARY_STORAGE_KEY } from './selection.js';
const base = {
family: 'imagery',
provider: 'Fixture',
description: 'Fixture entry.',
maintainer: 'test',
coverage: { global: true },
licence: { name: 'Public domain', url: 'https://example.org/licence' },
attribution: { text: 'Fixture' },
status: 'community',
};
const tiles = (id) => ({
...base,
id,
kind: 'tiles',
title: id,
source: {
format: 'xyz',
url: 'https://tiles.example.org/{z}/{x}/{y}.png',
fetch: 'browser-direct',
},
});
const { entries } = validateLibraryCatalog([
tiles('night-lights'),
tiles('sea-marks'),
{
...base,
id: 'fixture-pack',
kind: 'pack',
family: 'cameras',
title: 'Pack',
source: { format: 'host', url: 'https://cams.example.org/' },
pack: { host: 'cctv', env: 'CCTV_FIXTURE_ENABLED' },
licence: { ...base.licence, operatorOptIn: true },
},
]);
const ledger = [
['night-lights', '00'],
['sea-marks', '01'],
];
function sealedManager(t) {
const manager = new LayerLifecycle({});
manager.finalizeRegistrations([]);
// Enabled layers arm refresh timers; release them with the test.
t.after(() => manager.destroyAll());
return manager;
}
function memoryStorage(initial) {
const store = new Map(initial ? [[LIBRARY_STORAGE_KEY, initial]] : []);
return {
store,
getItem: (key) => store.get(key) ?? null,
setItem: (key, value) => store.set(key, value),
};
}
const source = (availability) => ({
async getAvailability() {
return {
server: true,
availability: new Map(
entries.map(({ id }) => [
id,
availability[id] ?? { available: true, reason: null },
]),
),
};
},
async loadDataset() {
return { features: [], truncated: false };
},
tileTemplate: (entry) => entry.source.url,
});
function shareLinkDouble() {
return {
encoder: null,
changes: 0,
setLibraryParamsEncoder(encoder) {
this.encoder = encoder;
},
onLibraryStateChange() {
this.changes += 1;
},
encode() {
const params = new URLSearchParams();
this.encoder?.(params);
return params.get('lib');
},
};
}
test('nothing registers until a viewer adds an entry; add turns it on and persists', async (t) => {
const manager = sealedManager(t);
const storage = memoryStorage();
const shareLink = shareLinkDouble();
const library = createDataLibrary({
entries,
ledger,
dataManager: manager,
services: {},
storage,
shareLink,
initialHash: '',
source: source({}),
});
await library.start();
assert.equal(manager.layers.size, 0);
assert.equal(await library.add('night-lights'), true);
assert.equal(manager.isEnabled('lib-night-lights'), true);
assert.equal(manager.getAll()[0].libraryEntryId, 'night-lights');
assert.deepEqual(JSON.parse(storage.store.get(LIBRARY_STORAGE_KEY)), {
added: ['night-lights'],
on: ['night-lights'],
});
assert.equal(shareLink.encode(), '00');
await manager.setEnabled('lib-night-lights', false, { origin: 'user' });
assert.deepEqual(JSON.parse(storage.store.get(LIBRARY_STORAGE_KEY)).on, []);
assert.equal(shareLink.encode(), null);
assert.equal(await library.remove('night-lights'), true);
assert.equal(manager.layers.has('lib-night-lights'), false);
assert.deepEqual(JSON.parse(storage.store.get(LIBRARY_STORAGE_KEY)), {
added: [],
on: [],
});
});
test('packs and unavailable entries cannot be added', async (t) => {
const manager = sealedManager(t);
const library = createDataLibrary({
entries,
ledger,
dataManager: manager,
services: {},
storage: memoryStorage(),
initialHash: '',
source: source({
'sea-marks': { available: false, reason: 'operator-opt-in' },
}),
});
await library.start();
assert.equal(await library.add('fixture-pack'), false);
assert.equal(await library.add('sea-marks'), false);
assert.equal(manager.layers.size, 0);
const row = library.list().find(({ entry }) => entry.id === 'sea-marks');
assert.deepEqual(
{ available: row.available, reason: row.reason, added: row.added },
{ available: false, reason: 'operator-opt-in', added: false },
);
});
test('a stored selection restores; a non-explicit change is not remembered', async (t) => {
const manager = sealedManager(t);
const storage = memoryStorage(
JSON.stringify({ added: ['night-lights', 'sea-marks'], on: ['sea-marks'] }),
);
const library = createDataLibrary({
entries,
ledger,
dataManager: manager,
services: {},
storage,
initialHash: '',
source: source({}),
});
await library.start();
await manager.waitForLayerSettled?.('lib-sea-marks');
assert.equal(manager.layers.has('lib-night-lights'), true);
assert.equal(manager.isEnabled('lib-night-lights'), false);
assert.equal(manager.isEnabled('lib-sea-marks'), true);
await manager.setEnabled('lib-sea-marks', false, { origin: 'context' });
assert.deepEqual(JSON.parse(storage.store.get(LIBRARY_STORAGE_KEY)).on, [
'sea-marks',
]);
});
test('a link decides what is on and adds its entries to the library', async (t) => {
const manager = sealedManager(t);
const storage = memoryStorage(
JSON.stringify({ added: ['night-lights'], on: ['night-lights'] }),
);
const library = createDataLibrary({
entries,
ledger,
dataManager: manager,
services: {},
storage,
initialHash: '#lat=1&lon=2&lib=01.zz',
source: source({}),
});
await library.start();
await manager.waitForLayerSettled?.('lib-sea-marks');
assert.equal(manager.isEnabled('lib-sea-marks'), true);
assert.equal(manager.isEnabled('lib-night-lights'), false);
// The link's entry joins the library; what is remembered as on stays
// the viewer's own.
assert.deepEqual(JSON.parse(storage.store.get(LIBRARY_STORAGE_KEY)), {
added: ['night-lights', 'sea-marks'],
on: ['night-lights'],
});
});
test('a share never rewrites what this browser remembers as on', async (t) => {
const saved = JSON.stringify({
added: ['night-lights', 'sea-marks'],
on: ['night-lights'],
});
const storage = memoryStorage(saved);
const manager = sealedManager(t);
const shareLink = fakeShareLink([]);
const library = createDataLibrary({
entries,
ledger,
dataManager: manager,
services: {},
storage,
shareLink,
source: source({}),
});
await library.start();
assert.equal(manager.isEnabled('lib-night-lights'), false);
shareLink.listener(['01']);
await manager.waitForLayerSettled?.('lib-sea-marks');
assert.equal(manager.isEnabled('lib-sea-marks'), true);
assert.deepEqual(JSON.parse(storage.store.get(LIBRARY_STORAGE_KEY)), {
added: ['night-lights', 'sea-marks'],
on: ['night-lights'],
});
// An explicit choice is remembered, and only that one.
await manager.setEnabled('lib-sea-marks', false, { origin: 'user' });
await manager.setEnabled('lib-night-lights', true, { origin: 'user' });
await manager.setEnabled('lib-night-lights', false, { origin: 'user' });
assert.deepEqual(JSON.parse(storage.store.get(LIBRARY_STORAGE_KEY)).on, []);
library.destroy();
});
/** A ShareLinkManager stand-in: the opening share and in-tab navigation. */
function fakeShareLink(initialLibraryTokens) {
const link = {
initialLibraryTokens,
listener: null,
setLibraryShareListener(listener) {
link.listener = listener;
},
setLibraryParamsEncoder() {},
onLibraryStateChange() {},
};
return link;
}
test('a share with every library entry off keeps the stored ones off', async (t) => {
const manager = sealedManager(t);
const storage = memoryStorage(
JSON.stringify({
added: ['night-lights', 'sea-marks'],
on: ['night-lights', 'sea-marks'],
}),
);
// A compact /share/<code> link with no library field, and a long-form link
// with no lib=: both are shares that switch no library entry on.
for (const options of [
{ shareLink: fakeShareLink([]) },
{ initialHash: '#lat=1&lon=2&l=' },
]) {
const library = createDataLibrary({
entries,
ledger,
dataManager: manager,
services: {},
storage,
source: source({}),
...options,
});
await library.start();
assert.equal(manager.isEnabled('lib-night-lights'), false);
assert.equal(manager.isEnabled('lib-sea-marks'), false);
// The recipient's entries stay in their panel, off.
assert.deepEqual(
library
.list()
.filter((row) => row.added)
.map((row) => row.entry.id),
['night-lights', 'sea-marks'],
);
library.destroy();
}
});
test('the opening share link restores its library tokens', async (t) => {
const manager = sealedManager(t);
const storage = memoryStorage(
JSON.stringify({ added: ['night-lights'], on: ['night-lights'] }),
);
const library = createDataLibrary({
entries,
ledger,
dataManager: manager,
services: {},
storage,
shareLink: fakeShareLink(['01']),
source: source({}),
});
await library.start();
await manager.waitForLayerSettled?.('lib-sea-marks');
assert.equal(manager.isEnabled('lib-sea-marks'), true);
assert.equal(manager.isEnabled('lib-night-lights'), false);
});
test('navigating between shares switches library entries on and off', async (t) => {
const manager = sealedManager(t);
const shareLink = fakeShareLink(['00']);
const library = createDataLibrary({
entries,
ledger,
dataManager: manager,
services: {},
storage: memoryStorage(),
shareLink,
source: source({}),
});
// A share navigated to before availability loads waits for it and wins.
const started = library.start();
shareLink.listener(['01']);
await started;
const settle = () =>
Promise.all(
['lib-night-lights', 'lib-sea-marks'].map((id) =>
manager.waitForLayerSettled?.(id),
),
);
await settle();
assert.equal(manager.isEnabled('lib-sea-marks'), true);
assert.equal(manager.isEnabled('lib-night-lights'), false);
shareLink.listener(['00']);
await settle();
assert.equal(manager.isEnabled('lib-night-lights'), true);
assert.equal(manager.isEnabled('lib-sea-marks'), false);
shareLink.listener([]);
await settle();
assert.equal(manager.isEnabled('lib-night-lights'), false);
assert.equal(manager.isEnabled('lib-sea-marks'), false);
library.destroy();
assert.equal(shareLink.listener, null);
});
test('a share opened while an earlier one is still switching on wins', async (t) => {
const manager = sealedManager(t);
const shareLink = fakeShareLink(null);
const library = createDataLibrary({
entries,
ledger,
dataManager: manager,
services: {},
storage: memoryStorage(),
shareLink,
source: source({}),
});
await library.start();
const settle = () =>
Promise.all(
['lib-night-lights', 'lib-sea-marks'].map((id) =>
manager.waitForLayerSettled?.(id),
),
);
// Neither share waits for the one before it to settle.
shareLink.listener(['00']);
assert.equal(manager.isEnabled('lib-night-lights'), false, 'still enabling');
shareLink.listener(['01']);
await settle();
assert.equal(manager.isEnabled('lib-night-lights'), false);
assert.equal(manager.isEnabled('lib-sea-marks'), true);
library.destroy();
});
test('a full library refuses another entry before its layer exists', async (t) => {
const many = validateLibraryCatalog(
Array.from({ length: 66 }, (_, index) => tiles(`entry-${index}`)),
).entries;
const manyLedger = many.map(({ id }, index) => [
id,
index.toString(36).padStart(2, '0'),
]);
const availability = {
async getAvailability() {
return {
server: true,
availability: new Map(
many.map(({ id }) => [id, { available: true, reason: null }]),
),
};
},
tileTemplate: (entry) => entry.source.url,
};
const full = JSON.stringify({
added: many.slice(0, 64).map(({ id }) => id),
on: [],
});
const manager = sealedManager(t);
const library = createDataLibrary({
entries: many,
ledger: manyLedger,
dataManager: manager,
services: {},
storage: memoryStorage(full),
shareLink: fakeShareLink(null),
source: availability,
});
await library.start();
assert.equal(manager.layers.size, 64);
assert.equal(await library.add('entry-64'), false);
assert.equal(manager.layers.size, 64, 'no layer outside the selection');
library.destroy();
});
test('a share opened into a full library still shows what it shares', async (t) => {
const many = validateLibraryCatalog(
Array.from({ length: 67 }, (_, index) => tiles(`entry-${index}`)),
).entries;
const manyLedger = many.map(({ id }, index) => [
id,
index.toString(36).padStart(2, '0'),
]);
const availability = {
async getAvailability() {
return {
server: true,
availability: new Map(
many.map(({ id }) => [id, { available: true, reason: null }]),
),
};
},
tileTemplate: (entry) => entry.source.url,
};
const full = JSON.stringify({
added: many.slice(0, 64).map(({ id }) => id),
on: ['entry-0'],
});
const manager = sealedManager(t);
const shareLink = {
...shareLinkDouble(),
initialLibraryTokens: [manyLedger[64][1]],
listener: null,
setLibraryShareListener(listener) {
this.listener = listener;
},
};
const library = createDataLibrary({
entries: many,
ledger: manyLedger,
dataManager: manager,
services: {},
storage: memoryStorage(full),
shareLink,
source: availability,
});
await library.start();
await manager.waitForLayerSettled?.('lib-entry-64');
assert.equal(manager.isEnabled('lib-entry-64'), true);
// The oldest entry the share leaves off made room.
assert.equal(manager.layers.has('lib-entry-0'), false);
assert.equal(manager.layers.size, 64);
assert.equal(shareLink.encode(), manyLedger[64][1]);
// A share navigated to in this tab makes room the same way, and the
// entry it evicts leaves with its layer.
shareLink.listener([manyLedger[65][1]]);
await manager.waitForLayerSettled?.('lib-entry-65');
await new Promise((resolve) => setImmediate(resolve));
assert.equal(manager.isEnabled('lib-entry-65'), true);
assert.equal(manager.layers.has('lib-entry-1'), false);
assert.equal(manager.layers.size, 64);
library.destroy();
});
test('entries this instance cannot serve still show as added and can be removed', async (t) => {
const manager = sealedManager(t);
const storage = memoryStorage(
JSON.stringify({ added: ['night-lights'], on: ['night-lights'] }),
);
const library = createDataLibrary({
entries,
ledger,
dataManager: manager,
services: {},
storage,
shareLink: fakeShareLink(null),
source: source({
'night-lights': { available: false, reason: 'disabled' },
}),
});
await library.start();
assert.equal(manager.layers.size, 0);
const row = library.list().find(({ entry }) => entry.id === 'night-lights');
assert.equal(row.added, true);
assert.equal(library.summary().added, 1);
assert.equal(await library.remove('night-lights'), true);
assert.deepEqual(JSON.parse(storage.store.get(LIBRARY_STORAGE_KEY)).added, []);
library.destroy();
});
test('a layer that fails to tear down stays in the library', async (t) => {
const manager = sealedManager(t);
const storage = memoryStorage();
const library = createDataLibrary({
entries,
ledger,
dataManager: manager,
services: {},
storage,
shareLink: fakeShareLink(null),
source: source({}),
});
await library.start();
await library.add('night-lights');
const { module } = manager.layers.get('lib-night-lights');
const disable = module.disable;
module.disable = async () => {
throw new Error('stuck');
};
t.mock.method(console, 'warn', () => {});
try {
assert.equal(await library.remove('night-lights'), false);
assert.equal(await library.reset(), 0);
assert.equal(manager.layers.has('lib-night-lights'), true);
assert.deepEqual(
JSON.parse(storage.store.get(LIBRARY_STORAGE_KEY)).added,
['night-lights'],
);
assert.equal(
library.list().find((row) => row.entry.id === 'night-lights').added,
true,
);
} finally {
// Once it tears down, Remove works (and the manager can shut down).
module.disable = disable;
}
assert.equal(await library.remove('night-lights'), true);
assert.equal(manager.layers.has('lib-night-lights'), false);
library.destroy();
});
test('the URL keeps the opening lib= before availability loads and for entries it cannot serve', async (t) => {
const manager = sealedManager(t);
const shareLink = shareLinkDouble();
let answer;
const pending = new Promise((resolve) => {
answer = resolve;
});
const library = createDataLibrary({
entries,
ledger,
dataManager: manager,
services: {},
storage: memoryStorage(),
shareLink,
initialHash: '#lat=1&lon=2&lib=00.01',
source: { ...source({}), getAvailability: () => pending },
});
const started = library.start();
// A camera move rewrites the hash before the catalog answers.
assert.equal(shareLink.encode(), '00.01');
answer({
server: false,
availability: new Map([
['night-lights', { available: false, reason: 'server-unavailable' }],
['sea-marks', { available: true, reason: null }],
]),
});
await started;
await manager.waitForLayerSettled?.('lib-sea-marks');
assert.equal(manager.layers.has('lib-night-lights'), false);
assert.equal(shareLink.encode(), '00.01');
library.destroy();
});
test('a layer switched off before its teardown failed is no longer shared as on', async (t) => {
const manager = sealedManager(t);
const storage = memoryStorage();
const shareLink = shareLinkDouble();
const library = createDataLibrary({
entries,
ledger,
dataManager: manager,
services: {},
storage,
shareLink,
initialHash: '',
source: source({}),
});
await library.start();
await library.add('night-lights');
assert.equal(shareLink.encode(), '00');
const { module } = manager.layers.get('lib-night-lights');
const destroy = module.destroy;
module.destroy = async () => {
throw new Error('stuck');
};
t.mock.method(console, 'warn', () => {});
try {
assert.equal(await library.remove('night-lights'), false);
assert.equal(manager.isEnabled('lib-night-lights'), false);
assert.equal(shareLink.encode(), null);
const saved = JSON.parse(storage.store.get(LIBRARY_STORAGE_KEY));
assert.deepEqual(saved, { added: ['night-lights'], on: [] });
} finally {
module.destroy = destroy;
}
library.destroy();
});
test('zoom flies to an added layer through the caller, reset removes everything', async (t) => {
const manager = sealedManager(t);
const storage = memoryStorage();
const flights = [];
const library = createDataLibrary({
entries,
ledger,
dataManager: manager,
services: {},
storage,
initialHash: '',
source: source({}),
zoomTo: (extent) => {
flights.push(extent);
return true;
},
});
await library.start();
assert.equal(await library.zoom('night-lights'), false, 'not added yet');
await library.add('night-lights');
await library.add('sea-marks');
const row = library.list().find(({ entry }) => entry.id === 'night-lights');
assert.equal(row.canZoom, true);
// Off: zoom switches the layer on, then flies.
await manager.setEnabled('lib-night-lights', false, { origin: 'user' });
assert.equal(await library.zoom('night-lights'), true);
assert.equal(manager.isEnabled('lib-night-lights'), true);
assert.deepEqual(flights[0], {
west: -180,
south: -85,
east: 180,
north: 85,
});
const chips = manager.layers
.get('lib-night-lights')
.module.getRowControls().chips;
assert.equal(chips[0].id, 'zoom');
chips[0].onClick();
await new Promise((resolve) => setTimeout(resolve, 0));
assert.equal(flights.length, 2);
assert.deepEqual(
chips.map(({ id, icon, action, whileOff }) => [id, icon, action, whileOff]),
[
['zoom', 'zoom_in_map', true, true],
['remove', 'delete', true, true],
],
);
// The row's delete icon removes that entry from the library.
chips[1].onClick();
await manager.waitForLayerSettled?.('lib-night-lights');
await new Promise((resolve) => setTimeout(resolve, 0));
for (
let tries = 0;
manager.layers.has('lib-night-lights') && tries < 50;
tries++
)
await new Promise((resolve) => setTimeout(resolve, 10));
assert.equal(manager.layers.has('lib-night-lights'), false);
assert.deepEqual(JSON.parse(storage.store.get(LIBRARY_STORAGE_KEY)).added, [
'sea-marks',
]);
assert.equal(await library.reset(), 1);
assert.equal(manager.layers.size, 0);
assert.deepEqual(JSON.parse(storage.store.get(LIBRARY_STORAGE_KEY)), {
added: [],
on: [],
});
});
test('without a navigation owner the zoom control is disabled', async (t) => {
const manager = sealedManager(t);
const library = createDataLibrary({
entries,
ledger,
dataManager: manager,
services: {},
storage: memoryStorage(),
initialHash: '',
source: source({}),
});
await library.start();
await library.add('night-lights');
assert.equal(await library.zoom('night-lights'), false);
assert.deepEqual(
manager.layers
.get('lib-night-lights')
.module.getRowControls()
.chips.map(({ id }) => id),
['remove'],
);
});
test('the summary counts entries by kind, availability and what is added and on', async (t) => {
const manager = sealedManager(t);
const library = createDataLibrary({
entries,
ledger,
dataManager: manager,
services: {},
storage: memoryStorage(),
initialHash: '',
source: source({
'sea-marks': { available: false, reason: 'operator-opt-in' },
}),
});
await library.start();
await library.add('night-lights');
assert.deepEqual(library.summary(), {
entries: 3,
kinds: { dataset: 0, tiles: 2, pack: 1 },
themes: ['cameras', 'imagery'],
// The pack is available because the fixture source says so.
available: 2,
unavailable: 1,
added: 1,
on: 1,
// Tiles are drapes: no feature count.
features: 0,
featureLayers: 0,
});
});
test('every shipped entry kind registers, view-bounded datasets included', async (t) => {
const manager = sealedManager(t);
const library = createDataLibrary({
entries: LIBRARY_ENTRIES,
ledger: LIBRARY_LEDGER,
dataManager: manager,
services: {},
storage: memoryStorage(),
initialHash: '',
source: {
async getAvailability() {
return {
server: true,
availability: new Map(
LIBRARY_ENTRIES.map(({ id }) => [
id,
{ available: true, reason: null },
]),
),
};
},
async loadDataset() {
return { features: [], truncated: false };
},
tileTemplate: (entry) => entry.source.url,
},
});
await library.start();
assert.equal(await library.add('fema-usa-structures'), true);
const module = manager.layers.get('lib-fema-usa-structures').module;
// No camera to read: the layer waits for one rather than loading.
assert.equal(module.getDiagnostics().tooHigh, true);
assert.equal(await library.add('nasa-black-marble'), true);
});
+353
View File
@@ -0,0 +1,353 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import { localGeoJsonServices } from '../app/localGeojsonServices.js';
import {
getContextStore,
getSelectedEntityContext,
selectEntityContext,
} from '../data/contextStore.js';
import { bindFakeGroundRenderer } from '../testSupport/fakeGroundRenderer.mjs';
import { createLibraryDatasetLayer } from './layers.js';
const entry = {
id: 'test-alerts',
kind: 'dataset',
title: 'Test alerts',
icon: '!',
provider: 'Test',
display: { color: '#ff0000' },
source: { cacheSeconds: 60 },
attribution: { text: 'Test' },
licence: { name: 'CC0', url: 'https://example.org/licence' },
};
// One small triangle per name, each in its own place.
const point = (name) => {
const x = name.charCodeAt(0) / 100;
return {
type: 'Feature',
properties: { name },
geometry: {
type: 'Polygon',
coordinates: [
[
[x, 0],
[x + 0.01, 0],
[x, 0.01],
[x, 0],
],
],
},
};
};
// A clock that is never 0, which reads as "never loaded".
const START = 1_000_000;
const deferred = () => {
let resolve;
let reject;
const promise = new Promise((done, fail) => {
resolve = done;
reject = fail;
});
return { promise, resolve, reject };
};
function harness(t, loads) {
const previousWindow = globalThis.window;
globalThis.window = { dispatchEvent() {} };
const viewer = {};
const fake = bindFakeGroundRenderer(viewer, {
eye: { lon: 0.6, lat: 0, height: 50_000 },
});
let calls = 0;
const source = {
async loadDataset(_entry, { signal }) {
const answer = loads[calls++];
return typeof answer === 'function' ? answer(signal) : answer;
},
};
const layer = createLibraryDatasetLayer(entry, {
services: {
...localGeoJsonServices,
overlayHost: { setVisible() {}, setEntries() {}, clearSource() {} },
},
source,
inputFor: () => ({ onClick: () => () => {}, onPointer: () => () => {} }),
});
t.after(() => {
layer.destroy(viewer);
fake.unbind();
if (previousWindow === undefined) delete globalThis.window;
else globalThis.window = previousWindow;
});
// The fill sets drawn now: one per build still in the scene.
const builds = () =>
fake.liveSets().filter((set) => set.spec.id.endsWith(':fills'));
return { layer, viewer, fake, builds, calls: () => calls };
}
const result = (...names) => ({
features: names.map(point),
truncated: false,
});
test('a library dataset refreshes on the manager tick once older than cacheSeconds', async (t) => {
t.mock.timers.enable({ apis: ['Date'], now: START });
const env = harness(t, [result('a'), result('b', 'c')]);
assert.equal(env.layer.refreshInterval, 60_000);
await env.layer.enable(env.viewer);
assert.equal(env.layer.getStats().count, 1);
await env.layer.update(env.viewer);
assert.equal(env.calls(), 1, 'fresh data is not refetched');
t.mock.timers.tick(60_000);
await env.layer.update(env.viewer);
assert.equal(env.calls(), 2);
assert.equal(env.layer.getStats().count, 2);
assert.equal(env.builds().length, 1, 'the old build is replaced, not kept');
});
test('a slow upstream still refreshes on every tick, not every other one', async (t) => {
t.mock.timers.enable({ apis: ['Date'], now: START });
// Each request takes two seconds to answer.
const slow = (value) => async () => {
t.mock.timers.tick(2000);
return value;
};
const env = harness(t, [
slow(result('a')),
slow(result('b')),
slow(result('c')),
]);
await env.layer.enable(env.viewer);
// The manager ticks every refreshInterval from when the layer came on.
t.mock.timers.setTime(START + 60_000);
await env.layer.update(env.viewer);
t.mock.timers.setTime(START + 120_000);
await env.layer.update(env.viewer);
assert.equal(env.calls(), 3);
});
test('a failed first load is not retried by the tick that follows enable', async (t) => {
t.mock.timers.enable({ apis: ['Date'], now: START });
t.mock.method(console, 'error', () => {});
const env = harness(t, [
() => Promise.reject(new Error('HTTP 503')),
result('a'),
]);
await env.layer.enable(env.viewer);
assert.ok(env.layer.getStats().error);
// Resolving (not rejecting) keeps the manager from failing the switch-on.
await env.layer.update(env.viewer);
assert.equal(env.calls(), 1);
});
test('a refresh keeps the old features drawn until the new ones are in, and the selection', async (t) => {
t.mock.timers.enable({ apis: ['Date'], now: START });
const env = harness(t, [result('a', 'b'), result('a', 'c')]);
await env.layer.enable(env.viewer);
const [first] = env.builds();
const carrierOf = (set, name) =>
[...set.items.values()].find(
(item) => item.meta.record.properties.name === name,
).meta;
selectEntityContext(carrierOf(first, 'a'));
// Drawn while the new build is made: watch the shapes sets made.
const shapes = env.fake.draw.shapes;
const drawnWhileBuilding = [];
env.fake.draw.shapes = (spec) => {
drawnWhileBuilding.push(first.disposed === false);
return shapes(spec);
};
t.mock.timers.tick(60_000);
await env.layer.update(env.viewer);
assert.ok(drawnWhileBuilding.length > 0);
assert.ok(drawnWhileBuilding.every(Boolean), 'the old build was still drawn');
assert.equal(first.disposed, true);
const [next] = env.builds();
assert.notEqual(next, first);
assert.equal(next.show, true);
const selected = getSelectedEntityContext();
assert.equal(selected?.entity, carrierOf(next, 'a'));
assert.equal(selected.properties.name, 'a');
// Only the new set's features keep a context.
const labels = [...getContextStore().entities.values()]
.filter((record) => record.layerId === env.layer.id)
.map((record) => record.label)
.sort();
assert.deepEqual(labels, ['a', 'c']);
});
test('a selected feature without an id stays selected by its place and label', async (t) => {
t.mock.timers.enable({ apis: ['Date'], now: START });
// Without ids, a feature's part id is its index: 'a' moves from 1 to 0.
const env = harness(t, [result('b', 'a'), result('a', 'c')]);
await env.layer.enable(env.viewer);
const [first] = env.builds();
const carrier = [...first.items.values()].find(
(item) => item.meta.record.properties.name === 'a',
).meta;
selectEntityContext(carrier);
t.mock.timers.tick(60_000);
await env.layer.update(env.viewer);
const selected = getSelectedEntityContext();
assert.equal(selected?.properties.name, 'a');
assert.notEqual(selected.entity, carrier);
});
test('a refresh whose rebuild fails keeps the drawn features', async (t) => {
t.mock.timers.enable({ apis: ['Date'], now: START });
t.mock.method(console, 'error', () => {});
const env = harness(t, [result('a'), result('b', 'c')]);
await env.layer.enable(env.viewer);
const [first] = env.builds();
env.fake.draw.shapes = () => {
throw new Error('scene full');
};
t.mock.timers.tick(60_000);
await assert.rejects(env.layer.update(env.viewer), /scene full/);
assert.deepEqual(env.builds(), [first]);
assert.equal(first.show, true);
assert.equal(env.layer.getStats().count, 1);
assert.equal(env.layer.getStats().error, null);
// The kept features keep their contexts.
assert.ok(
[...getContextStore().entities.values()].some(
(record) => record.layerId === env.layer.id && record.label === 'a',
),
);
});
test('a stale library dataset reloads on the next enable', async (t) => {
t.mock.timers.enable({ apis: ['Date'], now: START });
const env = harness(t, [result('a'), result('b', 'c')]);
await env.layer.enable(env.viewer);
env.layer.disable(env.viewer);
await env.layer.enable(env.viewer);
assert.equal(
env.calls(),
1,
'a re-enable within cacheSeconds reuses the data',
);
env.layer.disable(env.viewer);
t.mock.timers.tick(60_000);
await env.layer.enable(env.viewer);
assert.equal(env.calls(), 2);
assert.equal(env.layer.getStats().count, 2);
});
test('a failed refresh keeps the drawn features', async (t) => {
t.mock.timers.enable({ apis: ['Date'], now: START });
const env = harness(t, [
result('a'),
() => Promise.reject(new Error('HTTP 503')),
]);
await env.layer.enable(env.viewer);
t.mock.timers.tick(60_000);
await assert.rejects(env.layer.update(env.viewer), /HTTP 503/);
assert.equal(env.layer.getStats().count, 1);
assert.equal(env.builds().length, 1);
});
test('disable during a refresh cancels it and draws nothing late', async (t) => {
t.mock.timers.enable({ apis: ['Date'], now: START });
const pending = deferred();
let refreshSignal = null;
const env = harness(t, [
result('a'),
(signal) => {
refreshSignal = signal;
return pending.promise;
},
]);
await env.layer.enable(env.viewer);
t.mock.timers.tick(60_000);
const refreshing = env.layer.update(env.viewer);
env.layer.disable(env.viewer);
assert.equal(refreshSignal.aborted, true);
pending.resolve(result('b', 'c'));
await refreshing;
assert.equal(env.builds().length, 0);
});
test('a refresh that drops the selected feature clears the selection', async (t) => {
t.mock.timers.enable({ apis: ['Date'], now: START });
const env = harness(t, [result('b', 'a'), result('c', 'd')]);
await env.layer.enable(env.viewer);
const [first] = env.builds();
selectEntityContext(
[...first.items.values()].find(
(item) => item.meta.record.properties.name === 'a',
).meta,
);
t.mock.timers.tick(60_000);
await env.layer.update(env.viewer);
assert.equal(getSelectedEntityContext(), null);
});
test('colorBy colours each feature’s fill, stem, dot and label accent', async (t) => {
const previousWindow = globalThis.window;
globalThis.window = { dispatchEvent() {} };
const viewer = {};
const fake = bindFakeGroundRenderer(viewer, {
eye: { lon: 0.6, lat: 0, height: 50_000 },
});
const colored = {
...entry,
display: {
color: '#ff0000',
colorBy: { field: 'kind', colors: { hot: '#00ff00' } },
},
};
const entries = [];
const features = [point('a'), point('b')];
features[0].properties.__gevColorKey = 'hot';
// A manifest rank raises a label's priority, at most by 600.
features[1].properties.__gevRank = 9999;
const layer = createLibraryDatasetLayer(colored, {
services: {
...localGeoJsonServices,
overlayHost: {
setVisible() {},
setEntries: (_source, next) => entries.push(...next),
clearSource() {},
},
},
source: { loadDataset: async () => ({ features, truncated: false }) },
inputFor: () => ({ onClick: () => () => {}, onPointer: () => () => {} }),
});
t.after(() => {
layer.destroy(viewer);
fake.unbind();
if (previousWindow === undefined) delete globalThis.window;
else globalThis.window = previousWindow;
});
await layer.enable(viewer);
const byName = (role, name) =>
[...fake.set(role).items.values()].find(
(item) => item.meta.record.properties.name === name,
);
assert.deepEqual(byName('fills', 'a').fill, [0, 1, 0, 0.3]);
assert.deepEqual(byName('fills', 'b').fill, [1, 0, 0, 0.3]);
assert.deepEqual(byName('stems', 'a').style.color, [0, 1, 0, 1]);
assert.deepEqual(byName('dots', 'b').color, [1, 0, 0, 1]);
assert.equal(byName('fills', 'a').meta.record.entry.accent, '#00ff00');
assert.equal(byName('fills', 'b').meta.record.entry.accent, '#ff0000');
assert.equal(
byName('fills', 'b').meta.record.priority -
byName('fills', 'a').meta.record.priority,
600,
);
});
test('library card lines reach the label copy, the first two only', async () => {
const { localInfrastructureOverlayCopy } =
await import('../data/localGeojsonCore.js');
assert.deepEqual(
localInfrastructureOverlayCopy(
{ name: 'Dam', __gevDetails: ['River: Nile', ' ', 'Height: 111 m', 'x'] },
'lib-test',
),
{ title: 'Dam', details: ['River: Nile'] },
);
});
@@ -0,0 +1,47 @@
{
"id": "ak-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "Alaska Statewide Imagery (2023)",
"provider": "Alaska Geospatial Council",
"description": "Aerial orthophotos: Statewide coverage of Alaska.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-170, 51.2, -129, 71.4551]
},
"source": {
"format": "bbox",
"url": "https://apps.geo.fpac.usda.gov/nrcs-imagery/rest/services/ortho_imagery/alaska_vivid_2023_30cm/ImageServer/exportImage?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 19,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "30 cm",
"resolutionM": 0.3,
"trueOrtho": false,
"vintage": "2023–present",
"updateCycle": "Periodic statewide refresh",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Public Domain (U.S. Government work)",
"url": "https://www.usgs.gov/information-policies-and-instructions/copyrights-and-credits"
},
"attribution": {
"text": "USDA / Alaska Geospatial Council",
"url": "https://gis.data.alaska.gov/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,39 @@
{
"id": "amsterdam-traffic-cameras",
"kind": "dataset",
"family": "cameras",
"title": "Amsterdam traffic and ANPR camera positions",
"provider": "Gemeente Amsterdam",
"description": "Where the City of Amsterdam's traffic and ANPR cameras stand (about 500), from its traffic information systems register. Positions and camera type only: the city publishes no pictures.",
"icon": "◉",
"maintainer": "github:Maher-Reven",
"coverage": { "countries": ["NL"], "bbox": [4.72, 52.27, 5.08, 52.44] },
"source": {
"format": "geojson",
"url": "https://api.data.amsterdam.nl/v1/verkeersinformatiesystemen/verkeersinformatiesystemen/",
"query": {
"objectSoort": "Camera",
"_format": "geojson",
"_pageSize": "1000"
},
"fetch": "browser-direct",
"cacheSeconds": 86400,
"maxFeatures": 1000
},
"display": {
"color": "#e53e3e",
"label": "standplaats",
"fields": ["typeGedetailleerd", "objectnummer"]
},
"licence": {
"name": "Gemeente Amsterdam open data: public unless stated otherwise; no named licence",
"url": "https://schemas.data.amsterdam.nl/datasets/verkeersinformatiesystemen/dataset",
"operatorOptIn": true
},
"attribution": {
"text": "Gemeente Amsterdam, verkeersinformatiesystemen register (entry contributed by @Maher-Reven)",
"url": "https://api.data.amsterdam.nl/v1/docs/"
},
"status": "community",
"reviewed": "2026-11-07"
}
@@ -0,0 +1,47 @@
{
"id": "ar-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "Arkansas Statewide Imagery (2023)",
"provider": "Arkansas GIS Office (GeoStor)",
"description": "Aerial orthophotos: Statewide coverage of Arkansas.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-94.642, 32.9545, -89.584, 36.5414]
},
"source": {
"format": "bbox",
"url": "https://gis.arkansas.gov/arcgis/rest/services/ImageServices/IMAGERY_9IN_2023/ImageServer/exportImage?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 19,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "9 in / 6 in urban",
"resolutionM": 0.2286,
"trueOrtho": false,
"vintage": "2023–present",
"updateCycle": "Multi-year statewide cycles",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Public domain — Arkansas GIS Office open data",
"url": "https://gis.arkansas.gov/"
},
"attribution": {
"text": "Arkansas GIS Office",
"url": "https://gis.arkansas.gov/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,48 @@
{
"id": "az-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "Arizona Statewide Imagery (2017)",
"provider": "AZGeo",
"description": "Aerial orthophotos: Statewide coverage of Arizona.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-115.1014, 31.2527, -108.8553, 37.1065]
},
"source": {
"format": "xyz",
"url": "https://azgeo.az.gov/arcgis/rest/services/imagery/NAIP2017/MapServer/tile/{z}/{y}/{x}",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 19,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "1 m (NAIP)",
"resolutionM": 1,
"trueOrtho": false,
"vintage": "2017–present",
"updateCycle": "NAIP 2-year cycle",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Open state geodata — attribution requested",
"url": "https://azgeo.az.gov/",
"operatorOptIn": true
},
"attribution": {
"text": "AZGEO",
"url": "https://azgeo.az.gov/"
},
"status": "community",
"reviewed": "2026-10-23"
}
+48
View File
@@ -0,0 +1,48 @@
{
"id": "bayern-dop40",
"kind": "tiles",
"family": "imagery",
"title": "Digitales Orthophoto Bayern (DOP 40 cm, open)",
"provider": "LDBV Bayern",
"description": "Aerial orthophotos: 100% of Bavaria (~70,550 km²).",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["DE"],
"bbox": [8.97, 47.27, 13.84, 50.56]
},
"source": {
"format": "bbox",
"url": "https://geoservices.bayern.de/od/wms/dop/v1/dop40?service=WMS&request=GetMap&version=1.3.0&layers=by_dop40c&styles=&crs=EPSG:3857&bbox={bbox-epsg-3857}&width=256&height=256&format=image/jpeg",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 8,
"maxZoom": 20,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true,
"noDataColor": "#ffffff"
},
"imagery": {
"type": "ortho",
"resolution": "40 cm (20 cm is paid)",
"resolutionM": 0.4,
"trueOrtho": false,
"vintage": "2021–present",
"updateCycle": "Biennial (rolling)",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "CC BY 4.0",
"url": "https://geodaten.bayern.de/opengeodata/"
},
"attribution": {
"text": "© Bayerische Vermessungsverwaltung",
"url": "https://geodaten.bayern.de/opengeodata/OpenDataDetail.html?pn=dop40"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,48 @@
{
"id": "bismarck-mandan-nd",
"kind": "tiles",
"family": "imagery",
"title": "Bismarck–Mandan, North Dakota Aerial Photography",
"provider": "North Dakota GIS Hub",
"description": "Aerial orthophotos: Bismarck–Mandan, North Dakota jurisdiction.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-101.0948, 46.6527, -100.5815, 46.9844]
},
"source": {
"format": "bbox",
"url": "https://ndgishub.nd.gov/arcgis/rest/services/Imagery/AerialImage_BisMan_2023/ImageServer/exportImage?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 11,
"maxZoom": 20,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "sub-foot to 1 ft (local program)",
"resolutionM": 0.15,
"trueOrtho": false,
"vintage": "2023–present",
"updateCycle": "Local flight cycle (typically annual to 3-yearly)",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Local government open data — see publisher terms",
"url": "https://www.gis.nd.gov/",
"operatorOptIn": true
},
"attribution": {
"text": "95West Aerial Mapping",
"url": "https://www.gis.nd.gov/"
},
"status": "community",
"reviewed": "2026-10-23"
}
+34
View File
@@ -0,0 +1,34 @@
{
"id": "bkg-topplus-open",
"kind": "tiles",
"family": "imagery",
"title": "TopPlusOpen basemap (BKG)",
"provider": "BKG",
"description": "Germany's federal topographic basemap, detailed for Germany and Europe and generalised worldwide.",
"icon": "⛰",
"maintainer": "github:asturksever",
"coverage": {
"global": true
},
"source": {
"format": "xyz",
"url": "https://sgx.geodatenzentrum.de/wmts_topplus_open/tile/1.0.0/web/default/WEBMERCATOR/{z}/{y}/{x}.png",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 0,
"maxZoom": 18
},
"display": {
"opacity": 1
},
"licence": {
"name": "Datenlizenz Deutschland – Namensnennung 2.0",
"url": "https://www.govdata.de/dl-de/by-2-0"
},
"attribution": {
"text": "© BKG, dl-de/by-2-0",
"url": "https://gdz.bkg.bund.de/"
},
"status": "community",
"reviewed": "2026-10-22"
}
@@ -0,0 +1,24 @@
{
"id": "cctv-florida-fl511",
"kind": "pack",
"family": "cameras",
"title": "Florida cameras (FL511)",
"provider": "FL511",
"description": "Statewide FL511 traffic camera stills, added to the CCTV layer. Individual personal use only; other use needs FDOT's written consent.",
"icon": "◉",
"maintainer": "core",
"coverage": { "countries": ["US"], "bbox": [-87.64, 24.4, -79.97, 31.0] },
"source": { "format": "host", "url": "https://fl511.com/" },
"pack": { "host": "cctv", "env": "CCTV_FLORIDA_ENABLED" },
"licence": {
"name": "FL511 content: individual personal use only",
"url": "https://fl511.com/privacy#disclaimer",
"operatorOptIn": true
},
"attribution": {
"text": "Florida DOT — FL511.com",
"url": "https://fl511.com/"
},
"status": "verified",
"reviewed": "2026-10-21"
}
+24
View File
@@ -0,0 +1,24 @@
{
"id": "cctv-lithuania",
"kind": "pack",
"family": "cameras",
"title": "Lithuania road cameras (Via Lietuva)",
"provider": "Via Lietuva",
"description": "Eismoinfo road-camera stills across Lithuania, added to the CCTV layer. Off until Via Lietuva confirms the photo licence.",
"icon": "◉",
"maintainer": "core",
"coverage": { "countries": ["LT"], "bbox": [20.9, 53.89, 26.84, 56.45] },
"source": { "format": "host", "url": "https://eismoinfo.lt/" },
"pack": { "host": "cctv", "env": "CCTV_LITHUANIA_ENABLED" },
"licence": {
"name": "Via Lietuva open-data statement; camera photo coverage unconfirmed",
"url": "https://eismoinfo.lt/eismoinfo-backend/content?id=44",
"operatorOptIn": true
},
"attribution": {
"text": "Via Lietuva / eismoinfo.lt",
"url": "https://eismoinfo.lt/"
},
"status": "verified",
"reviewed": "2026-10-21"
}
+24
View File
@@ -0,0 +1,24 @@
{
"id": "cctv-nyc-dot",
"kind": "pack",
"family": "cameras",
"title": "New York City cameras (NYC DOT TMC)",
"provider": "NYC DOT",
"description": "About 980 NYC DOT traffic cameras across the five boroughs, added to the CCTV layer. Needs your own NYC DOT data-sharing agreement.",
"icon": "◉",
"maintainer": "core",
"coverage": { "countries": ["US"], "bbox": [-74.26, 40.49, -73.69, 40.92] },
"source": {
"format": "host",
"url": "https://webcams.nyctmc.org/api/cameras"
},
"pack": { "host": "cctv", "env": "CCTV_NYC_ENABLED" },
"licence": {
"name": "NYC DOT camera feed: data-sharing agreement required",
"url": "https://www.nyc.gov/html/dot/html/about/datafeeds.shtml",
"operatorOptIn": true
},
"attribution": { "text": "NYC DOT Traffic Management Center" },
"status": "verified",
"reviewed": "2026-10-21"
}
@@ -0,0 +1,48 @@
{
"id": "ct-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "Connecticut Statewide Imagery (2019)",
"provider": "CT ECO (UConn / CT DEEP)",
"description": "Aerial orthophotos: Statewide coverage of Connecticut.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-73.7389, 40.9738, -71.7784, 42.0598]
},
"source": {
"format": "bbox",
"url": "https://cteco.uconn.edu/ctraster/rest/services/images/Ortho_2019_tiled/ImageServer/exportImage?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 19,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "6 in",
"resolutionM": 0.1524,
"trueOrtho": false,
"vintage": "2019–present",
"updateCycle": "Roughly every 3 years",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Open state geodata — attribution requested",
"url": "https://ct-deep-gis-open-data-website-ctdeep.hub.arcgis.com/",
"operatorOptIn": true
},
"attribution": {
"text": "CT ECO — UConn CLEAR / CT DEEP",
"url": "https://ct-deep-gis-open-data-website-ctdeep.hub.arcgis.com/"
},
"status": "community",
"reviewed": "2026-10-23"
}
+48
View File
@@ -0,0 +1,48 @@
{
"id": "dakota-county-mn",
"kind": "tiles",
"family": "imagery",
"title": "Dakota County, Minnesota Air Photo",
"provider": "Dakota County GIS",
"description": "Aerial orthophotos: Dakota County, Minnesota jurisdiction.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-93.3479, 44.4582, -92.7129, 44.9358]
},
"source": {
"format": "bbox",
"url": "https://gisimg.co.dakota.mn.us/arcgis/rest/services/AerialPhotography/2025AirPhotoLeafOff6Inch_Spring/ImageServer/exportImage?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 11,
"maxZoom": 20,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "6 in",
"resolutionM": 0.1524,
"trueOrtho": false,
"vintage": "2025–present",
"updateCycle": "Local flight cycle (typically annual to 3-yearly)",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Local government open data — see publisher terms",
"url": "https://gis.co.dakota.mn.us/",
"operatorOptIn": true
},
"attribution": {
"text": "Dakota County GIS",
"url": "https://gis.co.dakota.mn.us/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,47 @@
{
"id": "dc-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "District of Columbia Statewide Imagery (2025)",
"provider": "DC GIS (OCTO)",
"description": "Aerial orthophotos: Statewide coverage of District of Columbia.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-77.1224, 38.7855, -76.9007, 39.0018]
},
"source": {
"format": "bbox",
"url": "https://imagery.dcgis.dc.gov/dcgis/rest/services/Ortho/Ortho_2025/ImageServer/exportImage?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 19,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "3 in",
"resolutionM": 0.0762,
"trueOrtho": false,
"vintage": "2025–present",
"updateCycle": "Annual",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Open data — DC public domain terms",
"url": "https://opendata.dc.gov/pages/terms-of-use"
},
"attribution": {
"text": "Office of the Chief Technology Officer",
"url": "https://opendata.dc.gov/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,48 @@
{
"id": "de-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "Delaware Statewide Imagery (2024)",
"provider": "Delaware FirstMap",
"description": "Aerial orthophotos: Statewide coverage of Delaware.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-75.8081, 38.4498, -75.0334, 39.8439]
},
"source": {
"format": "bbox",
"url": "https://imagery.firstmap.delaware.gov/imagery/rest/services/DE_Imagery_SP/DE_Imagery_2024/ImageServer/exportImage?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 19,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "3–6 in",
"resolutionM": 0.1524,
"trueOrtho": false,
"vintage": "2024–present",
"updateCycle": "Roughly every 2 years",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Open state geodata — attribution requested",
"url": "https://firstmap.delaware.gov/",
"operatorOptIn": true
},
"attribution": {
"text": "This data is meant for use by requested parties. This data cannot be used without express consent.This data is meant for use by requested parties. This data cannot be used without express consent.",
"url": "https://firstmap.delaware.gov/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,47 @@
{
"id": "ee-maa-amet-ortofoto",
"kind": "tiles",
"family": "imagery",
"title": "Eesti ortofoto (Maa-amet)",
"provider": "Estonian Land Board (Maa-amet)",
"description": "Aerial orthophotos: 100% of Estonia (2-year cycle; cities yearly).",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["EE"],
"bbox": [21.76, 57.51, 28.21, 59.68]
},
"source": {
"format": "xyz",
"url": "https://tiles.maaamet.ee/tm/tms/1.0.0/foto@GMC/{z}/{x}/{reverseY}.png",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 18,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "coverage",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "10–25 cm",
"resolutionM": 0.1,
"trueOrtho": false,
"vintage": "2021–present",
"updateCycle": "Biennial (annual in cities)",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Maa-amet open data licence (attribution)",
"url": "https://geoportaal.maaamet.ee/eng/Spatial-Data/Orthophotos-p309.html"
},
"attribution": {
"text": "© Maa-amet (Estonian Land Board)",
"url": "https://geoportaal.maaamet.ee/eng/Download-p609.html"
},
"status": "community",
"reviewed": "2026-10-23"
}
+68
View File
@@ -0,0 +1,68 @@
{
"id": "eia-power-plants",
"kind": "dataset",
"family": "infrastructure",
"title": "US power plants, 100 MW and up (EIA)",
"provider": "EIA",
"description": "Operating US power plants with at least 100 MW of capacity, with their primary energy source, from the EIA's US Energy Atlas.",
"icon": "ϟ",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-180, 13, -64, 72]
},
"source": {
"format": "arcgis",
"url": "https://services2.arcgis.com/FiaPA4ga0iQKduv3/arcgis/rest/services/Power_Plants_in_the_US/FeatureServer/0",
"query": {
"where": "Total_MW >= 100",
"outFields": "Plant_Name,Utility_Na,PrimSource,Total_MW,State"
},
"fetch": "browser-direct",
"cacheSeconds": 86400,
"maxFeatures": 4000,
"maxPages": 3
},
"display": {
"color": "#a0aec0",
"label": "Plant_Name",
"fields": ["PrimSource", "Total_MW"],
"rank": {
"field": "Total_MW",
"order": "desc"
},
"colorBy": {
"field": "PrimSource",
"colors": {
"coal": "#d55181",
"natural gas": "#d55181",
"petroleum": "#d55181",
"nuclear": "#c98500",
"hydroelectric": "#3987e5",
"pumped storage": "#3987e5",
"wind": "#008300",
"solar": "#008300"
},
"labels": {
"coal": "Fossil (coal, gas, oil)",
"natural gas": "Fossil (coal, gas, oil)",
"petroleum": "Fossil (coal, gas, oil)",
"nuclear": "Nuclear",
"hydroelectric": "Hydro",
"pumped storage": "Hydro",
"wind": "Wind and solar",
"solar": "Wind and solar"
}
}
},
"licence": {
"name": "U.S. Energy Information Administration data: public domain",
"url": "https://www.eia.gov/about/copyrights_reuse.php"
},
"attribution": {
"text": "U.S. Energy Information Administration (EIA-860, EIA-860M, EIA-923)",
"url": "https://atlas.eia.gov/"
},
"status": "community",
"reviewed": "2026-10-21"
}
@@ -0,0 +1,40 @@
{
"id": "epa-superfund-sites",
"kind": "dataset",
"family": "environment",
"title": "Superfund sites (US EPA)",
"provider": "US EPA",
"description": "The about 1,400 hazardous waste sites on the EPA's Superfund list, from the Facility Registry Service.",
"icon": "☢",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-180, 13, -64, 72]
},
"source": {
"format": "arcgis",
"url": "https://geopub.epa.gov/arcgis/rest/services/EMEF/efpoints/MapServer/0",
"query": {
"outFields": "primary_name,city_name,state_code"
},
"fetch": "browser-direct",
"cacheSeconds": 86400,
"maxFeatures": 2000,
"maxPages": 1
},
"display": {
"color": "#d69e2e",
"label": "primary_name",
"fields": ["city_name", "state_code"]
},
"licence": {
"name": "U.S. EPA data: public domain",
"url": "https://www.epa.gov/web-policies-and-procedures/epa-disclaimers"
},
"attribution": {
"text": "U.S. Environmental Protection Agency — Facility Registry Service (EnviroMapper)",
"url": "https://www.epa.gov/frs"
},
"status": "community",
"reviewed": "2026-10-22"
}
@@ -0,0 +1,45 @@
{
"id": "epa-toxic-release-facilities",
"kind": "dataset",
"family": "environment",
"title": "Toxic release facilities (US EPA TRI)",
"provider": "US EPA",
"description": "The about 64,500 facilities that report releases to the EPA's Toxics Release Inventory. Loads the facilities in view below 15 km.",
"icon": "☣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-180, 13, -64, 72]
},
"source": {
"format": "arcgis",
"url": "https://geopub.epa.gov/arcgis/rest/services/EMEF/efpoints/MapServer/1",
"query": {
"outFields": "primary_name,city_name,state_code"
},
"fetch": "browser-direct",
"view": {
"maxAltitudeM": 15000,
"sample": [-95.2, 29.7, -95.1, 29.76]
},
"cacheSeconds": 86400,
"maxBytes": 8388608,
"maxFeatures": 2000,
"maxPages": 1
},
"display": {
"color": "#ed8936",
"label": "primary_name",
"fields": ["city_name", "state_code"]
},
"licence": {
"name": "U.S. EPA data: public domain",
"url": "https://www.epa.gov/web-policies-and-procedures/epa-disclaimers"
},
"attribution": {
"text": "U.S. Environmental Protection Agency — Toxics Release Inventory via the Facility Registry Service",
"url": "https://www.epa.gov/toxics-release-inventory-tri-program"
},
"status": "community",
"reviewed": "2026-10-22"
}
@@ -0,0 +1,66 @@
{
"id": "epc-england-wales",
"kind": "dataset",
"family": "infrastructure",
"title": "Home energy ratings, England and Wales (EPC)",
"provider": "Addresscloud / DLUHC",
"description": "Every domestic Energy Performance Certificate in England and Wales at its UPRN, coloured by current rating A–G. Loads the homes in view once you zoom in below 4 km.",
"icon": "⌂",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["GB"],
"bbox": [-5.8, 49.8, 1.8, 55.9]
},
"source": {
"format": "geoparquet",
"url": "https://s3.us-west-2.amazonaws.com/us-west-2.opendata.source.coop/addresscloud/epc/geoparquet-local-authority/",
"partitions": {
"listUrl": "https://s3.us-west-2.amazonaws.com/us-west-2.opendata.source.coop?list-type=2&prefix=addresscloud/epc/geoparquet-local-authority/",
"keyBase": "https://s3.us-west-2.amazonaws.com/us-west-2.opendata.source.coop/"
},
"fetch": "browser-direct",
"view": {
"maxAltitudeM": 4000,
"sample": [-3.19, 51.47, -3.16, 51.49]
},
"cacheSeconds": 86400,
"maxBytes": 8388608,
"maxFeatures": 6000
},
"display": {
"color": "#a0aec0",
"label": "UPRN",
"fields": ["CURRENT_ENERGY_RATING", "POTENTIAL_ENERGY_RATING"],
"colorBy": {
"field": "CURRENT_ENERGY_RATING",
"colors": {
"A": "#008054",
"B": "#19b459",
"C": "#8dce46",
"D": "#ffd500",
"E": "#fcaa65",
"F": "#ef8023",
"G": "#e9153b"
},
"labels": {
"A": "A · 92–100",
"B": "B · 81–91",
"C": "C · 69–80",
"D": "D · 55–68",
"E": "E · 39–54",
"F": "F · 21–38",
"G": "G · 1–20"
}
}
},
"licence": {
"name": "Open Government Licence v3.0 (EPC data); OS Open UPRN under OGL",
"url": "https://epc.opendatacommunities.org/docs/copyright"
},
"attribution": {
"text": "Energy Performance of Buildings Data, DLUHC; geocoded by Addresscloud with OS Open UPRN — contains OS data © Crown copyright and database right; via Source Cooperative",
"url": "https://source.coop/addresscloud/epc"
},
"status": "community",
"reviewed": "2026-10-22"
}
@@ -0,0 +1,65 @@
{
"id": "fema-usa-structures",
"kind": "dataset",
"family": "infrastructure",
"title": "US building footprints (FEMA USA Structures)",
"provider": "FEMA / ORNL",
"description": "Footprints of every US structure over 450 sq ft, about 135 million, with occupancy class. Loads the buildings in view once you zoom in below 4 km.",
"icon": "▦",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US", "PR", "GU", "VI", "AS", "MP"]
},
"source": {
"format": "arcgis",
"url": "https://services2.arcgis.com/FiaPA4ga0iQKduv3/arcgis/rest/services/USA_Structures_View/FeatureServer/0",
"query": {
"outFields": "OCC_CLS,PRIM_OCC,HEIGHT,SQFEET"
},
"fetch": "browser-direct",
"view": {
"maxAltitudeM": 4000,
"sample": [-77.04, 38.885, -77.02, 38.9]
},
"cacheSeconds": 86400,
"maxBytes": 8388608,
"maxFeatures": 2000,
"maxPages": 1
},
"display": {
"color": "#a0aec0",
"label": "PRIM_OCC",
"fields": ["OCC_CLS", "HEIGHT"],
"colorBy": {
"field": "OCC_CLS",
"colors": {
"Residential": "#3987e5",
"Commercial": "#c98500",
"Industrial": "#d55181",
"Utility and Misc": "#d55181",
"Government": "#008300",
"Education": "#008300",
"Assembly": "#008300"
},
"labels": {
"Residential": "Residential",
"Commercial": "Commercial",
"Industrial": "Industrial and utility",
"Utility and Misc": "Industrial and utility",
"Government": "Public (government, education, assembly)",
"Education": "Public (government, education, assembly)",
"Assembly": "Public (government, education, assembly)"
}
}
},
"licence": {
"name": "CC BY 4.0",
"url": "https://creativecommons.org/licenses/by/4.0/"
},
"attribution": {
"text": "FEMA Response Geospatial Office and Oak Ridge National Laboratory — USA Structures",
"url": "https://www.arcgis.com/home/item.html?id=0ec8512ad21e4bb987d7e848d14e7e24"
},
"status": "community",
"reviewed": "2026-10-22"
}
@@ -0,0 +1,60 @@
{
"id": "gbif-occurrence-density",
"kind": "tiles",
"family": "environment",
"title": "Biodiversity records (GBIF)",
"provider": "GBIF",
"description": "Where more than two billion plant, animal and fungus observations have been recorded, as a hexagon density map.",
"icon": "❦",
"maintainer": "github:asturksever",
"coverage": {
"global": true
},
"source": {
"format": "xyz",
"url": "https://api.gbif.org/v2/map/occurrence/density/{z}/{x}/{y}@1x.png?style=classic.poly&bin=hex",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 0,
"maxZoom": 14
},
"display": {
"opacity": 0.8,
"legend": [
{
"label": "≤ 10 records",
"color": "#ffff00"
},
{
"label": "11–100 records",
"color": "#ffcc00"
},
{
"label": "101–1,000 records",
"color": "#ff9900"
},
{
"label": "1,001–10,000 records",
"color": "#ff6600"
},
{
"label": "10,001–100,000 records",
"color": "#d60a00"
},
{
"label": "> 100,000 records",
"color": "#c2002d"
}
]
},
"licence": {
"name": "GBIF data use agreement (records under CC0, CC BY or CC BY-NC)",
"url": "https://www.gbif.org/terms"
},
"attribution": {
"text": "GBIF.org — Global Biodiversity Information Facility",
"url": "https://www.gbif.org/"
},
"status": "community",
"reviewed": "2026-10-22"
}
@@ -0,0 +1,56 @@
{
"id": "gdacs-disaster-alerts",
"kind": "dataset",
"family": "events",
"title": "Disaster alerts (GDACS)",
"provider": "GDACS",
"description": "Current earthquakes, tropical cyclones, floods, volcanoes, droughts and wildfires with UN–EC GDACS alert levels.",
"icon": "⚑",
"maintainer": "github:asturksever",
"coverage": {
"global": true
},
"source": {
"format": "geojson",
"url": "https://www.gdacs.org/gdacsapi/api/events/geteventlist/SEARCH",
"query": {
"eventlist": "EQ;TC;FL;VO;DR;WF"
},
"fetch": "browser-direct",
"cacheSeconds": 900,
"maxBytes": 8388608,
"maxFeatures": 2000
},
"display": {
"color": "#a0aec0",
"label": "name",
"fields": ["alertlevel", "country"],
"rank": {
"field": "fromdate",
"order": "desc"
},
"colorBy": {
"field": "alertlevel",
"colors": {
"Red": "#d03b3b",
"Orange": "#ec835a",
"Green": "#0ca30c"
},
"labels": {
"Red": "Red alert",
"Orange": "Orange alert",
"Green": "Green alert"
}
}
},
"licence": {
"name": "GDACS terms of use (free, attribution required)",
"url": "https://www.gdacs.org/About/termofuse.aspx"
},
"attribution": {
"text": "GDACS — Global Disaster Alert and Coordination System (UN, European Commission)",
"url": "https://www.gdacs.org/"
},
"status": "community",
"reviewed": "2026-10-22"
}
+48
View File
@@ -0,0 +1,48 @@
{
"id": "grand-forks-nd",
"kind": "tiles",
"family": "imagery",
"title": "Grand Forks, North Dakota Aerial Photography",
"provider": "North Dakota GIS Hub",
"description": "Aerial orthophotos: Grand Forks, North Dakota jurisdiction.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-97.2308, 47.8072, -96.92, 48.0153]
},
"source": {
"format": "bbox",
"url": "https://ndgishub.nd.gov/arcgis/rest/services/Imagery/AerialImage_GrandForks_2025/ImageServer/exportImage?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 11,
"maxZoom": 20,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "sub-foot to 1 ft (local program)",
"resolutionM": 0.15,
"trueOrtho": false,
"vintage": "2025–present",
"updateCycle": "Local flight cycle (typically annual to 3-yearly)",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Local government open data — see publisher terms",
"url": "https://www.gis.nd.gov/",
"operatorOptIn": true
},
"attribution": {
"text": "Grand Forks/East Grand Forks Metropolitan Planning Organization (MPO)",
"url": "https://www.gis.nd.gov/"
},
"status": "community",
"reviewed": "2026-10-23"
}
+35
View File
@@ -0,0 +1,35 @@
{
"id": "gsi-japan-map",
"kind": "tiles",
"family": "imagery",
"title": "Japan standard map (GSI)",
"provider": "GSI",
"description": "The Geospatial Information Authority of Japan's standard map tiles.",
"icon": "⛰",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["JP"],
"bbox": [122, 20, 154, 46]
},
"source": {
"format": "xyz",
"url": "https://cyberjapandata.gsi.go.jp/xyz/std/{z}/{x}/{y}.png",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 2,
"maxZoom": 18
},
"display": {
"opacity": 1
},
"licence": {
"name": "GSI Tiles terms (free use with attribution)",
"url": "https://maps.gsi.go.jp/development/ichiran.html"
},
"attribution": {
"text": "Geospatial Information Authority of Japan (GSI Tiles)",
"url": "https://maps.gsi.go.jp/"
},
"status": "community",
"reviewed": "2026-10-22"
}
+48
View File
@@ -0,0 +1,48 @@
{
"id": "gsi-japan-photo",
"kind": "tiles",
"family": "imagery",
"title": "Japan aerial photos (GSI)",
"provider": "GSI",
"description": "Seamless aerial and satellite photography of Japan from the Geospatial Information Authority of Japan.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["JP"],
"bbox": [122, 20, 154, 46]
},
"source": {
"format": "xyz",
"url": "https://cyberjapandata.gsi.go.jp/xyz/seamlessphoto/{z}/{x}/{y}.jpg",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 2,
"maxZoom": 18,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "countries",
"aerial": true,
"noDataColor": "#343434"
},
"imagery": {
"type": "ortho",
"resolution": "20 cm (cities) – 40 cm",
"resolutionM": 0.2,
"trueOrtho": false,
"vintage": "2007–present",
"updateCycle": "Rolling",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "GSI Tiles terms (free use with attribution)",
"url": "https://maps.gsi.go.jp/development/ichiran.html"
},
"attribution": {
"text": "Geospatial Information Authority of Japan (GSI Tiles)",
"url": "https://maps.gsi.go.jp/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,47 @@
{
"id": "gvp-holocene-volcanoes",
"kind": "dataset",
"family": "environment",
"title": "Holocene volcanoes (Smithsonian GVP)",
"provider": "Smithsonian GVP",
"description": "The roughly 1,200 volcanoes with eruptions in the last 12,000 years, from the Smithsonian Global Volcanism Program's Volcanoes of the World.",
"icon": "▲",
"maintainer": "github:asturksever",
"coverage": {
"global": true
},
"source": {
"format": "geojson",
"url": "https://webservices.volcano.si.edu/geoserver/GVP-VOTW/ows",
"query": {
"service": "WFS",
"version": "2.0.0",
"request": "GetFeature",
"typeName": "GVP-VOTW:Smithsonian_VOTW_Holocene_Volcanoes",
"outputFormat": "application/json"
},
"fetch": "proxied",
"cacheSeconds": 86400,
"maxBytes": 8388608,
"maxFeatures": 2000
},
"display": {
"color": "#ff3d6b",
"label": "Volcano_Name",
"fields": ["Primary_Volcano_Type", "Last_Eruption_Year"],
"rank": {
"field": "Last_Eruption_Year",
"order": "desc"
}
},
"licence": {
"name": "Smithsonian Terms of Use (personal, educational, non-commercial use; cite the Global Volcanism Program)",
"url": "https://www.si.edu/termsofuse"
},
"attribution": {
"text": "Global Volcanism Program, Smithsonian Institution — Volcanoes of the World",
"url": "https://volcano.si.edu/"
},
"status": "community",
"reviewed": "2026-10-21"
}
@@ -0,0 +1,48 @@
{
"id": "ia-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "Iowa Statewide Imagery (2023)",
"provider": "Iowa State Univ. GIS / Iowa DNR",
"description": "Aerial orthophotos: Statewide coverage of Iowa.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-96.7456, 40.3273, -90.0366, 43.5847]
},
"source": {
"format": "bbox",
"url": "https://ortho.gis.iastate.edu/arcgis/rest/services/ortho/naip_2023_cir/ImageServer/exportImage?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 19,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "1 m / 60 cm (NAIP)",
"resolutionM": 0.6,
"trueOrtho": false,
"vintage": "2023–present",
"updateCycle": "NAIP 2-year cycle",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Open state geodata — attribution requested",
"url": "https://geodata.iowa.gov/",
"operatorOptIn": true
},
"attribution": {
"text": "USDA NAIP, Iowa State University GIS Facility",
"url": "https://geodata.iowa.gov/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,47 @@
{
"id": "id-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "Idaho Statewide Imagery (2023)",
"provider": "INSIDE Idaho",
"description": "Aerial orthophotos: Statewide coverage of Idaho.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-117.5533, 41.8913, -110.597, 49.0918]
},
"source": {
"format": "bbox",
"url": "https://insideidaho.org/arcgis/rest/services/imagery/idaho_2023/ImageServer/exportImage?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 19,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "60 cm (NAIP)",
"resolutionM": 0.6,
"trueOrtho": false,
"vintage": "2023–present",
"updateCycle": "NAIP 2-year cycle",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Public domain / open — INSIDE Idaho terms",
"url": "https://insideidaho.org/"
},
"attribution": {
"text": "United States Department of Agriculture, Farm Production and Conservation Business Center, Geospatial Enterprise Operations (FPAC-BC-GEO)",
"url": "https://insideidaho.org/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,48 @@
{
"id": "ign-orthophotos-france",
"kind": "tiles",
"family": "imagery",
"title": "France aerial photos (IGN)",
"provider": "IGN",
"description": "IGN's national orthophotography of metropolitan France and Corsica.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["FR"],
"bbox": [-5.5, 41.2, 9.8, 51.2]
},
"source": {
"format": "xyz",
"url": "https://data.geopf.fr/wmts?SERVICE=WMTS&REQUEST=GetTile&VERSION=1.0.0&LAYER=ORTHOIMAGERY.ORTHOPHOTOS&STYLE=normal&TILEMATRIXSET=PM&TILEMATRIX={z}&TILEROW={y}&TILECOL={x}&FORMAT=image/jpeg",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 19,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "coverage",
"aerial": true,
"noDataColor": "#0a3b59"
},
"imagery": {
"type": "ortho",
"resolution": "20 cm",
"resolutionM": 0.2,
"trueOrtho": false,
"vintage": "2018–present",
"updateCycle": "3-year rolling refresh",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Licence Ouverte / Etalab 2.0",
"url": "https://www.etalab.gouv.fr/licence-ouverte-open-licence/"
},
"attribution": {
"text": "© IGN — Géoplateforme",
"url": "https://geoservices.ign.fr/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,48 @@
{
"id": "il-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "Illinois Statewide Imagery",
"provider": "ISGS / IDOT",
"description": "Aerial orthophotos: Statewide coverage of Illinois.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-91.3996, 36.97, -87.469, 41.0314]
},
"source": {
"format": "bbox",
"url": "https://data.isgs.illinois.edu/arcgis/rest/services/Imagery/IDOT_2017/ImageServer/exportImage?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 19,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "1 ft",
"resolutionM": 0.3048,
"trueOrtho": false,
"vintage": "2015–present",
"updateCycle": "Multi-year cycles",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Open state geodata — attribution requested",
"url": "https://clearinghouse.isgs.illinois.edu/",
"operatorOptIn": true
},
"attribution": {
"text": "Illinois State Geological Survey / IDOT",
"url": "https://clearinghouse.isgs.illinois.edu/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,39 @@
{
"id": "imf-portwatch-chokepoints",
"kind": "dataset",
"family": "infrastructure",
"title": "Maritime chokepoints (IMF PortWatch)",
"provider": "IMF PortWatch",
"description": "The 28 maritime chokepoints IMF PortWatch tracks, such as Suez and Hormuz, with their annual vessel transits and top cargo.",
"icon": "⧗",
"maintainer": "github:asturksever",
"coverage": { "global": true },
"source": {
"format": "arcgis",
"url": "https://services9.arcgis.com/weJ1QsnbMYJlCHdG/arcgis/rest/services/PortWatch_chokepoints_database/FeatureServer/0",
"query": {
"outFields": "portname,vessel_count_total,vessel_count_tanker,industry_top1"
},
"fetch": "browser-direct",
"cacheSeconds": 86400,
"maxFeatures": 100,
"maxPages": 1
},
"display": {
"color": "#4fd1c5",
"label": "portname",
"fields": ["vessel_count_total", "industry_top1"],
"rank": { "field": "vessel_count_total", "order": "desc" }
},
"licence": {
"name": "IMF PortWatch terms; attribution required (reuse terms under review)",
"url": "https://www.imf.org/external/terms.htm",
"operatorOptIn": true
},
"attribution": {
"text": "IMF PortWatch (portwatch.imf.org)",
"url": "https://portwatch.imf.org/"
},
"status": "incubating",
"reviewed": "2026-10-22"
}
@@ -0,0 +1,57 @@
{
"id": "imf-portwatch-disruptions",
"kind": "dataset",
"family": "events",
"title": "Port disruptions (IMF PortWatch)",
"provider": "IMF PortWatch",
"description": "Areas of natural-hazard events that disrupted ports since 2019, such as cyclones and floods, with the ports affected, from IMF PortWatch and GDACS.",
"icon": "◌",
"maintainer": "github:asturksever",
"coverage": {
"global": true
},
"source": {
"format": "arcgis",
"url": "https://services9.arcgis.com/weJ1QsnbMYJlCHdG/arcgis/rest/services/PortWatch_disruptions_database/FeatureServer/0",
"query": {
"outFields": "htmlname,alertlevel,country,fromdate,n_affectedports"
},
"fetch": "browser-direct",
"cacheSeconds": 86400,
"maxFeatures": 500,
"maxPages": 1
},
"display": {
"color": "#a0aec0",
"label": "htmlname",
"fields": ["alertlevel", "n_affectedports"],
"rank": {
"field": "fromdate",
"order": "desc"
},
"colorBy": {
"field": "alertlevel",
"colors": {
"RED": "#d03b3b",
"ORANGE": "#ec835a",
"GREEN": "#0ca30c"
},
"labels": {
"RED": "Red alert",
"ORANGE": "Orange alert",
"GREEN": "Green alert"
}
}
},
"licence": {
"name": "IMF PortWatch terms; attribution required (reuse terms under review)",
"url": "https://www.imf.org/external/terms.htm",
"operatorOptIn": true
},
"attribution": {
"text": "IMF PortWatch (portwatch.imf.org), with GDACS event data",
"url": "https://portwatch.imf.org/"
},
"status": "incubating",
"reviewed": "2026-10-22"
}
@@ -0,0 +1,47 @@
{
"id": "in-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "Indiana Statewide Imagery (2016)",
"provider": "IndianaMap",
"description": "Aerial orthophotos: Statewide coverage of Indiana.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-88.1, 37.77, -84.78, 41.76]
},
"source": {
"format": "bbox",
"url": "https://di-ingov.img.arcgis.com/arcgis/rest/services/DynamicWebMercator/Indiana_2016_2019_Imagery/ImageServer/exportImage?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 19,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "6 in – 1 ft",
"resolutionM": 0.1524,
"trueOrtho": false,
"vintage": "2016–present",
"updateCycle": "4-year statewide cycle (counties in 3 groups)",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "CC0 1.0 Universal (public domain dedication)",
"url": "https://creativecommons.org/publicdomain/zero/1.0/legalcode"
},
"attribution": {
"text": "Indiana Geographic Information Office (CC0)",
"url": "https://registry.opendata.aws/in-imagery/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,48 @@
{
"id": "jrc-surface-water",
"kind": "tiles",
"family": "environment",
"title": "Surface water occurrence (JRC)",
"provider": "EC JRC",
"description": "How often each place was covered by water between 1984 and 2021, from 38 years of Landsat imagery.",
"icon": "≋",
"maintainer": "github:asturksever",
"coverage": {
"global": true
},
"source": {
"format": "xyz",
"url": "https://storage.googleapis.com/global-surface-water/tiles2021/occurrence/{z}/{x}/{y}.png",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 0,
"maxZoom": 13
},
"display": {
"opacity": 0.85,
"legend": [
{
"label": "Sometimes water (> 0%)",
"color": "#ffffff"
},
{
"label": "Half the time (50%)",
"color": "#bf7fbf"
},
{
"label": "Always water (100%)",
"color": "#0000ff"
}
]
},
"licence": {
"name": "Copernicus programme: free, without restriction of use",
"url": "https://global-surface-water.appspot.com/download"
},
"attribution": {
"text": "Source: EC JRC/Google — Pekel et al. (2016), Global Surface Water",
"url": "https://global-surface-water.appspot.com/"
},
"status": "community",
"reviewed": "2026-10-22"
}
@@ -0,0 +1,46 @@
{
"id": "kartverket-admin-units",
"kind": "tiles",
"family": "infrastructure",
"title": "Norway counties and municipalities (Kartverket)",
"provider": "Kartverket",
"description": "Current county (fylke) and municipality (kommune) boundaries from Kartverket's administrative units.",
"icon": "⌗",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["NO"],
"bbox": [3.7, 57.6, 32, 71.6]
},
"source": {
"format": "bbox",
"url": "https://wms.geonorge.no/skwms1/wms.adm_enheter2?service=WMS&request=GetMap&version=1.3.0&layers=fylker_gjel,kommuner_gjel&styles=&crs=EPSG:3857&bbox={bbox-epsg-3857}&width=256&height=256&format=image/png&transparent=true",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 4,
"maxZoom": 20,
"bounded": true
},
"display": {
"opacity": 1,
"legend": [
{
"label": "County boundary",
"color": "#6464ff"
},
{
"label": "Municipality boundary",
"color": "#8a3e4e"
}
]
},
"licence": {
"name": "CC BY 4.0 (Kartverket free products)",
"url": "https://www.kartverket.no/api-og-data/vilkar-for-bruk"
},
"attribution": {
"text": "© Kartverket",
"url": "https://www.kartverket.no/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,36 @@
{
"id": "kartverket-cadastre",
"kind": "tiles",
"family": "infrastructure",
"title": "Norway cadastral map (Kartverket)",
"provider": "Kartverket",
"description": "Property boundaries, parcel numbers and building outlines from the Norwegian cadastre (Matrikkelen), shown at street scale.",
"icon": "⌗",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["NO"],
"bbox": [3.7, 57.6, 32, 71.6]
},
"source": {
"format": "bbox",
"url": "https://wms.geonorge.no/skwms1/wms.matrikkelkart?service=WMS&request=GetMap&version=1.3.0&layers=matrikkelkart&styles=&crs=EPSG:3857&bbox={bbox-epsg-3857}&width=256&height=256&format=image/png&transparent=true",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 14,
"maxZoom": 20,
"bounded": true
},
"display": {
"opacity": 1
},
"licence": {
"name": "CC BY 4.0 (Kartverket free products)",
"url": "https://www.kartverket.no/api-og-data/vilkar-for-bruk"
},
"attribution": {
"text": "© Kartverket",
"url": "https://www.kartverket.no/"
},
"status": "community",
"reviewed": "2026-10-23"
}
+102
View File
@@ -0,0 +1,102 @@
{
"id": "kartverket-depth",
"kind": "tiles",
"family": "environment",
"title": "Norway sea depths (Kartverket)",
"provider": "Kartverket",
"description": "Kartverket's depth areas and depth contours of Norwegian waters, shown from coastal scale (zoom in to see them).",
"icon": "≋",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["NO"],
"bbox": [3.7, 57.6, 32, 71.6]
},
"source": {
"format": "bbox",
"url": "https://wms.geonorge.no/skwms1/wms.dybdedata2?service=WMS&request=GetMap&version=1.3.0&layers=Dybdelag,Dybdekontur&styles=&crs=EPSG:3857&bbox={bbox-epsg-3857}&width=256&height=256&format=image/png&transparent=true",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 11,
"maxZoom": 20,
"bounded": true
},
"display": {
"opacity": 1,
"legend": [
{
"label": "Minimum depth 0–5 m",
"color": "#e6ffff"
},
{
"label": "Minimum depth 5–10 m",
"color": "#dbfaff"
},
{
"label": "Minimum depth 10–20 m",
"color": "#d1f5ff"
},
{
"label": "Minimum depth 20–30 m",
"color": "#c7f2ff"
},
{
"label": "Minimum depth 30–40 m",
"color": "#c3f1ff"
},
{
"label": "Minimum depth 40–50 m",
"color": "#bdefff"
},
{
"label": "Minimum depth 50–100 m",
"color": "#b8edff"
},
{
"label": "Minimum depth 100–150 m",
"color": "#abe8ff"
},
{
"label": "Minimum depth 150–200 m",
"color": "#a6e5ff"
},
{
"label": "Minimum depth 200–250 m",
"color": "#a1e5ff"
},
{
"label": "Minimum depth 250–300 m",
"color": "#9ce3ff"
},
{
"label": "Minimum depth 300–350 m",
"color": "#96e3ff"
},
{
"label": "Minimum depth 350–400 m",
"color": "#91e0ff"
},
{
"label": "Minimum depth 400–450 m",
"color": "#8ce0ff"
},
{
"label": "Minimum depth 450–500 m",
"color": "#89deff"
},
{
"label": "Minimum depth 500–2,000 m",
"color": "#87dcff"
}
]
},
"licence": {
"name": "CC BY 4.0 (Kartverket free products)",
"url": "https://www.kartverket.no/api-og-data/vilkar-for-bruk"
},
"attribution": {
"text": "© Kartverket",
"url": "https://www.kartverket.no/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,36 @@
{
"id": "kartverket-hillshade",
"kind": "tiles",
"family": "environment",
"title": "Norway hillshade (Kartverket)",
"provider": "Kartverket",
"description": "Kartverket's hillshade of Norway's terrain, a translucent shading to lay over imagery or maps.",
"icon": "⛰",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["NO"],
"bbox": [3.7, 57.6, 32, 71.6]
},
"source": {
"format": "bbox",
"url": "https://wms.geonorge.no/skwms1/wms.fjellskygge?service=WMS&request=GetMap&version=1.3.0&layers=fjellskygge&styles=&crs=EPSG:3857&bbox={bbox-epsg-3857}&width=256&height=256&format=image/png&transparent=true",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 3,
"maxZoom": 20,
"bounded": true
},
"display": {
"opacity": 1
},
"licence": {
"name": "CC BY 4.0 (Kartverket free products)",
"url": "https://www.kartverket.no/api-og-data/vilkar-for-bruk"
},
"attribution": {
"text": "© Kartverket",
"url": "https://www.kartverket.no/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,36 @@
{
"id": "kartverket-nautical-charts",
"kind": "tiles",
"family": "movement",
"title": "Norway nautical charts (Kartverket)",
"provider": "Kartverket",
"description": "Kartverket's official raster nautical charts of the Norwegian coast and waters. Not for navigation.",
"icon": "⚓",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["NO"],
"bbox": [3.7, 57.6, 32, 71.6]
},
"source": {
"format": "xyz",
"url": "https://cache.kartverket.no/v1/wmts/1.0.0/sjokartraster/default/webmercator/{z}/{y}/{x}.png",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 3,
"maxZoom": 18,
"bounded": true
},
"display": {
"opacity": 1
},
"licence": {
"name": "CC BY 4.0 (Kartverket free products)",
"url": "https://www.kartverket.no/api-og-data/vilkar-for-bruk"
},
"attribution": {
"text": "© Kartverket",
"url": "https://www.kartverket.no/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,36 @@
{
"id": "kartverket-terrain-relief",
"kind": "tiles",
"family": "environment",
"title": "Norway terrain relief (Kartverket DTM)",
"provider": "Kartverket",
"description": "Shaded colour relief of Kartverket's national terrain model, built from laser scanning.",
"icon": "⛰",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["NO"],
"bbox": [3.7, 57.6, 32, 71.6]
},
"source": {
"format": "bbox",
"url": "https://wms.geonorge.no/skwms1/wms.terrengmodell?service=WMS&request=GetMap&version=1.3.0&layers=relieff&styles=&crs=EPSG:3857&bbox={bbox-epsg-3857}&width=256&height=256&format=image/png&transparent=true",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 3,
"maxZoom": 20,
"bounded": true
},
"display": {
"opacity": 1
},
"licence": {
"name": "CC BY 4.0 (Kartverket free products)",
"url": "https://www.kartverket.no/api-og-data/vilkar-for-bruk"
},
"attribution": {
"text": "© Kartverket",
"url": "https://www.kartverket.no/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,36 @@
{
"id": "kartverket-topo-grey",
"kind": "tiles",
"family": "imagery",
"title": "Norway topographic map, greyscale (Kartverket)",
"provider": "Kartverket",
"description": "Kartverket's topographic map of Norway in greyscale, a quiet base for other layers.",
"icon": "⛰",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["NO"],
"bbox": [3.7, 57.6, 32, 71.6]
},
"source": {
"format": "xyz",
"url": "https://cache.kartverket.no/v1/wmts/1.0.0/topograatone/default/webmercator/{z}/{y}/{x}.png",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 3,
"maxZoom": 18,
"bounded": true
},
"display": {
"opacity": 1
},
"licence": {
"name": "CC BY 4.0 (Kartverket free products)",
"url": "https://www.kartverket.no/api-og-data/vilkar-for-bruk"
},
"attribution": {
"text": "© Kartverket",
"url": "https://www.kartverket.no/"
},
"status": "community",
"reviewed": "2026-10-23"
}
+36
View File
@@ -0,0 +1,36 @@
{
"id": "kartverket-topo",
"kind": "tiles",
"family": "imagery",
"title": "Norway topographic map (Kartverket)",
"provider": "Kartverket",
"description": "Kartverket's national topographic map of Norway, from overview scale down to buildings and paths.",
"icon": "⛰",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["NO"],
"bbox": [3.7, 57.6, 32, 71.6]
},
"source": {
"format": "xyz",
"url": "https://cache.kartverket.no/v1/wmts/1.0.0/topo/default/webmercator/{z}/{y}/{x}.png",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 3,
"maxZoom": 18,
"bounded": true
},
"display": {
"opacity": 1
},
"licence": {
"name": "CC BY 4.0 (Kartverket free products)",
"url": "https://www.kartverket.no/api-og-data/vilkar-for-bruk"
},
"attribution": {
"text": "© Kartverket",
"url": "https://www.kartverket.no/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,36 @@
{
"id": "kartverket-toporaster",
"kind": "tiles",
"family": "imagery",
"title": "Norway topographic raster map (Kartverket)",
"provider": "Kartverket",
"description": "Kartverket's raster topographic map series of Norway, in the style of the printed maps.",
"icon": "⛰",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["NO"],
"bbox": [3.7, 57.6, 32, 71.6]
},
"source": {
"format": "xyz",
"url": "https://cache.kartverket.no/v1/wmts/1.0.0/toporaster/default/webmercator/{z}/{y}/{x}.png",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 3,
"maxZoom": 18,
"bounded": true
},
"display": {
"opacity": 1
},
"licence": {
"name": "CC BY 4.0 (Kartverket free products)",
"url": "https://www.kartverket.no/api-og-data/vilkar-for-bruk"
},
"attribution": {
"text": "© Kartverket",
"url": "https://www.kartverket.no/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,48 @@
{
"id": "ks-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "Kansas Statewide Imagery (2021)",
"provider": "Kansas DASC / KGS",
"description": "Aerial orthophotos: Statewide coverage of Kansas.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-102.472, 36.738, -94.035, 40.211]
},
"source": {
"format": "bbox",
"url": "https://services.kgs.ku.edu/arcgis7/rest/services/IMAGERY_STATEWIDE/FSA_NAIP_2021_Color/ImageServer/exportImage?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 19,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "60 cm",
"resolutionM": 0.6,
"trueOrtho": false,
"vintage": "2021–present",
"updateCycle": "NAIP 2-year cycle",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Open state geodata — attribution requested",
"url": "https://www.kansasgis.org/",
"operatorOptIn": true
},
"attribution": {
"text": "FSA, USDA,",
"url": "https://www.kansasgis.org/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,47 @@
{
"id": "ky-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "Kentucky Statewide Imagery",
"provider": "KyFromAbove",
"description": "Aerial orthophotos: Statewide coverage of Kentucky.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-89.7044, 36.457, -81.8842, 39.1519]
},
"source": {
"format": "bbox",
"url": "https://kyraster.ky.gov/arcgis/rest/services/ImageServices/Ky_KYAPED_Phase3_3IN_IR/ImageServer/exportImage?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 19,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "6 in (statewide), 3 in (urban)",
"resolutionM": 0.1524,
"trueOrtho": false,
"vintage": "2015–present",
"updateCycle": "Annual partial; full refresh every 3 years",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Public domain with attribution",
"url": "https://kygeonet.ky.gov/"
},
"attribution": {
"text": "KyFromAbove",
"url": "https://registry.opendata.aws/kyfromabove/"
},
"status": "community",
"reviewed": "2026-10-23"
}
+48
View File
@@ -0,0 +1,48 @@
{
"id": "lake-county-in",
"kind": "tiles",
"family": "imagery",
"title": "Lake County, Indiana Aerial Imagery",
"provider": "Lake County GIS",
"description": "Aerial orthophotos: Lake County, Indiana jurisdiction.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-87.5421, 41.1501, -87.2023, 41.7204]
},
"source": {
"format": "xyz",
"url": "https://tiles.arcgis.com/tiles/8CXRnvSfSpwdf0R6/arcgis/rest/services/LakeIN2023Aerial/MapServer/tile/{z}/{y}/{x}",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 11,
"maxZoom": 22,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "sub-foot to 1 ft (local program)",
"resolutionM": 0.15,
"trueOrtho": false,
"vintage": "2023–present",
"updateCycle": "Local flight cycle (typically annual to 3-yearly)",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Local government open data — see publisher terms",
"url": "https://www.lakecountyin.org/",
"operatorOptIn": true
},
"attribution": {
"text": "Lake County Surveyor's Office",
"url": "https://www.lakecountyin.org/"
},
"status": "community",
"reviewed": "2026-10-23"
}
+48
View File
@@ -0,0 +1,48 @@
{
"id": "lawrence-ks",
"kind": "tiles",
"family": "imagery",
"title": "Lawrence, Kansas Aerial Photos",
"provider": "City of Lawrence GIS",
"description": "Aerial orthophotos: Lawrence, Kansas jurisdiction.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-95.3997, 38.8881, -95.113, 39.0507]
},
"source": {
"format": "xyz",
"url": "https://tiles.arcgis.com/tiles/8O9UlSTnqjKptoda/arcgis/rest/services/LAWRENCE_KS_AERIAL_2022/MapServer/tile/{z}/{y}/{x}",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 11,
"maxZoom": 22,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "sub-foot to 1 ft (local program)",
"resolutionM": 0.15,
"trueOrtho": false,
"vintage": "2022–present",
"updateCycle": "Local flight cycle (typically annual to 3-yearly)",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Local government open data — see publisher terms",
"url": "https://gis-lawrenceks.opendata.arcgis.com/",
"operatorOptIn": true
},
"attribution": {
"text": "City of Lawrence GIS",
"url": "https://gis-lawrenceks.opendata.arcgis.com/"
},
"status": "community",
"reviewed": "2026-10-23"
}
+48
View File
@@ -0,0 +1,48 @@
{
"id": "lee-county-fl",
"kind": "tiles",
"family": "imagery",
"title": "Lee County, Florida Aerial Imagery",
"provider": "Lee County GIS",
"description": "Aerial orthophotos: Lee County, Florida jurisdiction.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-82.3101, 26.3138, -81.5591, 26.796]
},
"source": {
"format": "bbox",
"url": "https://gisimageserver.leegov.com/imageserver/rest/services/Aerials/Aerials2025/ImageServer/exportImage?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 11,
"maxZoom": 20,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "sub-foot to 1 ft (local program)",
"resolutionM": 0.15,
"trueOrtho": false,
"vintage": "2025–present",
"updateCycle": "Local flight cycle (typically annual to 3-yearly)",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Local government open data — see publisher terms",
"url": "https://www.leegov.com/gis",
"operatorOptIn": true
},
"attribution": {
"text": "Eagle View, Lee County Property Appraiser, Lee County GIS",
"url": "https://www.leegov.com/gis"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,48 @@
{
"id": "loudoun-county-va",
"kind": "tiles",
"family": "imagery",
"title": "Loudoun County, Virginia Imagery",
"provider": "Loudoun County GIS",
"description": "Aerial orthophotos: Loudoun County, Virginia jurisdiction.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-77.9661, 38.823, -77.2907, 39.3358]
},
"source": {
"format": "bbox",
"url": "https://logis.loudoun.gov/image/rest/services/Aerial/COLOR_2025/ImageServer/exportImage?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 11,
"maxZoom": 20,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "sub-foot to 1 ft (local program)",
"resolutionM": 0.15,
"trueOrtho": false,
"vintage": "2025–present",
"updateCycle": "Local flight cycle (typically annual to 3-yearly)",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Local government open data — see publisher terms",
"url": "https://geohub-loudoungis.opendata.arcgis.com/",
"operatorOptIn": true
},
"attribution": {
"text": "Loudoun County GIS",
"url": "https://geohub-loudoungis.opendata.arcgis.com/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,49 @@
{
"id": "louisville-lojic-ky",
"kind": "tiles",
"family": "imagery",
"title": "Louisville / LOJIC, Kentucky Imagery",
"provider": "LOJIC",
"description": "Aerial orthophotos: Louisville / LOJIC, Kentucky jurisdiction.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-86.5156, 37.4289, -84.8574, 38.7994]
},
"source": {
"format": "bbox",
"url": "https://services.lojic.org/arcgis/rest/services/Lojic/Imagery/MapServer/export?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 11,
"maxZoom": 20,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true,
"noDataColor": "#ffffff"
},
"imagery": {
"type": "ortho",
"resolution": "sub-foot to 1 ft (local program)",
"resolutionM": 0.15,
"trueOrtho": false,
"vintage": "2020–present",
"updateCycle": "Local flight cycle (typically annual to 3-yearly)",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Local government open data — see publisher terms",
"url": "https://www.lojic.org/",
"operatorOptIn": true
},
"attribution": {
"text": "LOJIC, USDA-NAIP",
"url": "https://www.lojic.org/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,48 @@
{
"id": "ma-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "Massachusetts Statewide Imagery",
"provider": "MassGIS (EOTSS)",
"description": "Aerial orthophotos: Statewide coverage of Massachusetts.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-73.51, 41.24, -69.93, 42.89]
},
"source": {
"format": "xyz",
"url": "https://tiles.arcgis.com/tiles/hGdibHYSPO59RG1h/arcgis/rest/services/orthos2021/MapServer/tile/{z}/{y}/{x}",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 22,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "15–30 cm",
"resolutionM": 0.3,
"trueOrtho": false,
"vintage": "2015–present",
"updateCycle": "Roughly every 3 years",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Open state geodata — attribution requested",
"url": "https://gis.data.mass.gov/",
"operatorOptIn": true
},
"attribution": {
"text": "MassGIS, Commonwealth of Massachusetts",
"url": "https://gis.data.mass.gov/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,88 @@
{
"id": "macrostrat-geology",
"kind": "tiles",
"family": "environment",
"title": "Geologic map (Macrostrat)",
"provider": "Macrostrat",
"description": "Bedrock geology worldwide, harmonised from hundreds of published geologic maps and coloured by rock age on the international (ICS) time-scale colours.",
"icon": "◒",
"maintainer": "github:asturksever",
"coverage": {
"global": true
},
"source": {
"format": "xyz",
"url": "https://tiles.macrostrat.org/carto/{z}/{x}/{y}.png",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 0,
"maxZoom": 14
},
"display": {
"opacity": 0.7,
"legend": [
{
"label": "Quaternary",
"color": "#f9f97f"
},
{
"label": "Neogene",
"color": "#ffe619"
},
{
"label": "Paleogene",
"color": "#fd9a52"
},
{
"label": "Cretaceous",
"color": "#7fc64e"
},
{
"label": "Jurassic",
"color": "#34b2c9"
},
{
"label": "Triassic",
"color": "#812b92"
},
{
"label": "Permian",
"color": "#f04028"
},
{
"label": "Carboniferous",
"color": "#67a599"
},
{
"label": "Devonian",
"color": "#cb8c37"
},
{
"label": "Silurian",
"color": "#b3e1b6"
},
{
"label": "Ordovician",
"color": "#009270"
},
{
"label": "Cambrian",
"color": "#7fa056"
},
{
"label": "Precambrian",
"color": "#f74370"
}
]
},
"licence": {
"name": "CC BY 4.0 (Macrostrat; source maps credited by their publishers)",
"url": "https://macrostrat.org/about"
},
"attribution": {
"text": "Macrostrat — geologic maps from their original publishers",
"url": "https://macrostrat.org/"
},
"status": "community",
"reviewed": "2026-10-22"
}
@@ -0,0 +1,32 @@
{
"id": "mapterhorn-terrain",
"kind": "tiles",
"family": "environment",
"title": "Global terrain shaded relief (Mapterhorn)",
"provider": "Mapterhorn",
"description": "Elevation of the whole land surface from Mapterhorn's open terrain tiles (Copernicus and national elevation models), coloured by height and hill-shaded.",
"icon": "⛰",
"maintainer": "github:asturksever",
"coverage": { "global": true },
"source": {
"format": "xyz",
"url": "https://tiles.mapterhorn.com/{z}/{x}/{y}.webp",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"encoding": "terrarium",
"tileSize": 512,
"minZoom": 0,
"maxZoom": 15
},
"display": { "opacity": 0.85 },
"licence": {
"name": "Open data, per source (mostly CC BY 4.0 and public domain)",
"url": "https://mapterhorn.com/attribution"
},
"attribution": {
"text": "© Mapterhorn and its open elevation sources",
"url": "https://mapterhorn.com/attribution"
},
"status": "community",
"reviewed": "2026-10-23"
}
+48
View File
@@ -0,0 +1,48 @@
{
"id": "maris-ms",
"kind": "tiles",
"family": "imagery",
"title": "MARIS Imagery, Mississippi",
"provider": "MARIS",
"description": "Aerial orthophotos: MARIS Imagery, Mississippi jurisdiction.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-89.5658, 34.3427, -89.5141, 34.3953]
},
"source": {
"format": "xyz",
"url": "https://tiles.arcgis.com/tiles/EAeOFj04EVkIaWLk/arcgis/rest/services/OleMiss_Basemap_ZL2/MapServer/tile/{z}/{y}/{x}",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 13,
"maxZoom": 22,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "sub-foot to 1 ft (local program)",
"resolutionM": 0.15,
"trueOrtho": false,
"vintage": "2020–present",
"updateCycle": "Local flight cycle (typically annual to 3-yearly)",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Local government open data — see publisher terms",
"url": "https://www.gis.ms.gov/",
"operatorOptIn": true
},
"attribution": {
"text": "MARIS",
"url": "https://www.gis.ms.gov/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,48 @@
{
"id": "md-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "Maryland Statewide Imagery",
"provider": "Maryland iMAP / MD DoIT",
"description": "Aerial orthophotos: Statewide coverage of Maryland.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-79.5157, 37.8702, -74.9964, 39.778]
},
"source": {
"format": "bbox",
"url": "https://mdgeodata.md.gov/imagery/rest/services/NAIP/MD_NAIPImagery/ImageServer/exportImage?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 19,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "3 in – 1 m",
"resolutionM": 0.0762,
"trueOrtho": false,
"vintage": "2015–present",
"updateCycle": "Annual/biennial by region",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Open state geodata — attribution requested",
"url": "https://imap.maryland.gov/",
"operatorOptIn": true
},
"attribution": {
"text": "Maryland iMAP",
"url": "https://imap.maryland.gov/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,48 @@
{
"id": "me-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "Maine Statewide Imagery",
"provider": "Maine GeoLibrary / MEGIS",
"description": "Aerial orthophotos: Statewide coverage of Maine.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-71.08, 42.98, -66.95, 47.46]
},
"source": {
"format": "bbox",
"url": "https://gis.maine.gov/image/rest/services/NAIP/orthoNaip2006/ImageServer/exportImage?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 19,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "30 cm – 1 m",
"resolutionM": 0.3,
"trueOrtho": false,
"vintage": "2015–present",
"updateCycle": "Rolling regional",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Open state geodata — attribution requested",
"url": "https://www.maine.gov/geolib/",
"operatorOptIn": true
},
"attribution": {
"text": "USDA Aerial Photography Field Office",
"url": "https://www.maine.gov/geolib/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,48 @@
{
"id": "mi-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "Michigan Statewide Imagery (2024)",
"provider": "MiSAIL / DTMB",
"description": "Aerial orthophotos: Statewide coverage of Michigan (preview bounds cover the Lower Peninsula; service covers both peninsulas).",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-86.5, 41.7, -82.41, 45.9]
},
"source": {
"format": "bbox",
"url": "https://imagery.michigan.gov/server/rest/services/Michigan_imagery_2024/ImageServer/exportImage?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 19,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "30 cm – 1 m",
"resolutionM": 0.3,
"trueOrtho": false,
"vintage": "2024–present",
"updateCycle": "Rolling",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Open state geodata — attribution requested",
"url": "https://gis-michigan.opendata.arcgis.com/",
"operatorOptIn": true
},
"attribution": {
"text": "State of Michigan",
"url": "https://gis-michigan.opendata.arcgis.com/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,48 @@
{
"id": "mountain-village-co",
"kind": "tiles",
"family": "imagery",
"title": "Mountain Village, Colorado Orthoimagery",
"provider": "Town of Mountain Village",
"description": "Aerial orthophotos: Mountain Village, Colorado jurisdiction.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-107.8864, 37.9114, -107.8244, 37.9537]
},
"source": {
"format": "xyz",
"url": "https://tiles.arcgis.com/tiles/Nefdxa42x2DnAd5Z/arcgis/rest/services/Mountain_Village_Orthos/MapServer/tile/{z}/{y}/{x}",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 13,
"maxZoom": 22,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "sub-foot to 1 ft (local program)",
"resolutionM": 0.15,
"trueOrtho": false,
"vintage": "2024–present",
"updateCycle": "Local flight cycle (typically annual to 3-yearly)",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Local government open data — see publisher terms",
"url": "https://www.townofmountainvillage.com/",
"operatorOptIn": true
},
"attribution": {
"text": "Town of Mountain Village",
"url": "https://www.townofmountainvillage.com/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,48 @@
{
"id": "ms-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "Mississippi Statewide Imagery",
"provider": "MARIS",
"description": "Aerial orthophotos: Statewide coverage of Mississippi.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-91.66, 30.17, -88.1, 35]
},
"source": {
"format": "xyz",
"url": "https://tiles.arcgis.com/tiles/LLVEmB8Lsae3Um4s/arcgis/rest/services/ms_napp2/MapServer/tile/{z}/{y}/{x}",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 16,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "1 m (NAPP/NAIP)",
"resolutionM": 1,
"trueOrtho": false,
"vintage": "2015–present",
"updateCycle": "Periodic",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Open state geodata — attribution requested",
"url": "https://www.gis.ms.gov/",
"operatorOptIn": true
},
"attribution": {
"text": "USDA-FSA-APFO",
"url": "https://www.gis.ms.gov/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,47 @@
{
"id": "mt-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "Montana Statewide Imagery (2023)",
"provider": "Montana State Library (MSDI)",
"description": "Aerial orthophotos: Statewide coverage of Montana.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-116.0637, 44.3115, -103.9988, 49.064]
},
"source": {
"format": "bbox",
"url": "https://gisservice.mt.gov/arcgis/rest/services/MSDI_Framework/NAIP_2023/ImageServer/exportImage?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 19,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "60 cm (NAIP)",
"resolutionM": 0.6,
"trueOrtho": false,
"vintage": "2023–present",
"updateCycle": "NAIP 2-year cycle",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Public domain — Montana State Library open data",
"url": "https://msl.mt.gov/geoinfo/"
},
"attribution": {
"text": "Montana State Library",
"url": "https://msl.mt.gov/geoinfo/"
},
"status": "community",
"reviewed": "2026-10-23"
}
+47
View File
@@ -0,0 +1,47 @@
{
"id": "naip",
"kind": "tiles",
"family": "imagery",
"title": "NAIP — National Agriculture Imagery Program",
"provider": "USDA FSA / USGS",
"description": "Aerial orthophotos: Conterminous US, each state every 2–3 years.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-125, 24, -66.9, 49.4]
},
"source": {
"format": "bbox",
"url": "https://imagery.nationalmap.gov/arcgis/rest/services/USGSNAIPImagery/ImageServer/exportImage?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 19,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "coverage",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "60 cm (30 cm in some states)",
"resolutionM": 0.3,
"trueOrtho": false,
"vintage": "2003–present",
"updateCycle": "2–3 year state cycles",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Public Domain (U.S. Government work)",
"url": "https://naip-usdaonline.hub.arcgis.com/"
},
"attribution": {
"text": "USDA NAIP",
"url": "https://naip-usdaonline.hub.arcgis.com/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,30 @@
{
"id": "nasa-black-marble",
"kind": "tiles",
"family": "imagery",
"title": "Earth at night (NASA Black Marble 2016)",
"provider": "NASA GIBS",
"description": "VIIRS night lights composite: where people light the planet after dark. Drapes on globe maps and on Google 3D tiles.",
"icon": "☾",
"maintainer": "github:asturksever",
"coverage": { "global": true },
"source": {
"format": "xyz",
"url": "https://gibs.earthdata.nasa.gov/wmts/epsg3857/best/VIIRS_Black_Marble/default/2016-01-01/GoogleMapsCompatible_Level8/{z}/{y}/{x}.png",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 0,
"maxZoom": 8
},
"display": { "opacity": 0.85 },
"licence": {
"name": "NASA data: U.S. public domain; no endorsement implied",
"url": "https://www.earthdata.nasa.gov/engage/open-data-services-software-policies"
},
"attribution": {
"text": "NASA Earth Observatory / GIBS — VIIRS Black Marble",
"url": "https://earthobservatory.nasa.gov/features/NightLights"
},
"status": "community",
"reviewed": "2026-10-21"
}
@@ -0,0 +1,58 @@
{
"id": "nasa-eonet-events",
"kind": "dataset",
"family": "events",
"title": "NASA EONET open natural events",
"provider": "NASA EONET",
"description": "Wildfires, severe storms, volcanoes, sea and lake ice and other natural events NASA's Earth Observatory is tracking now.",
"icon": "✦",
"maintainer": "github:asturksever",
"coverage": {
"global": true
},
"source": {
"format": "geojson",
"url": "https://eonet.gsfc.nasa.gov/api/v3/events/geojson",
"query": {
"status": "open",
"limit": "1000"
},
"fetch": "browser-direct",
"cacheSeconds": 900,
"maxFeatures": 2000
},
"display": {
"color": "#a0aec0",
"label": "title",
"fields": ["date", "magnitudeValue"],
"rank": {
"field": "date",
"order": "desc"
},
"colorBy": {
"field": "categories.0.title",
"colors": {
"Wildfires": "#c98500",
"Severe Storms": "#d55181",
"Sea and Lake Ice": "#3987e5",
"Volcanoes": "#008300"
},
"labels": {
"Wildfires": "Wildfires",
"Severe Storms": "Severe storms",
"Sea and Lake Ice": "Sea and lake ice",
"Volcanoes": "Volcanoes"
}
}
},
"licence": {
"name": "NASA data: U.S. public domain; no endorsement implied",
"url": "https://www.nasa.gov/nasa-brand-center/images-and-media/"
},
"attribution": {
"text": "NASA Earth Observatory Natural Event Tracker (EONET)",
"url": "https://eonet.gsfc.nasa.gov/"
},
"status": "community",
"reviewed": "2026-10-21"
}
@@ -0,0 +1,47 @@
{
"id": "nc-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "North Carolina Statewide Imagery (2023)",
"provider": "NC OneMap",
"description": "Aerial orthophotos: Statewide coverage of North Carolina.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-84.452, 33.6938, -75.4041, 36.6379]
},
"source": {
"format": "bbox",
"url": "https://services.nconemap.gov/secure/rest/services/Imagery/Orthoimagery_2020_2023/ImageServer/exportImage?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 19,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "6 in – 1 ft",
"resolutionM": 0.1524,
"trueOrtho": false,
"vintage": "2023–present",
"updateCycle": "Statewide 4-year cycle (quarterly regions)",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Public domain — NC OneMap terms of use",
"url": "https://www.nconemap.gov/pages/terms"
},
"attribution": {
"text": "NC911, NCCGIA",
"url": "https://www.nconemap.gov/pages/imagery"
},
"status": "community",
"reviewed": "2026-10-23"
}
+48
View File
@@ -0,0 +1,48 @@
{
"id": "nctcog-tx",
"kind": "tiles",
"family": "imagery",
"title": "North Central Texas (NCTCOG) Ortho",
"provider": "NCTCOG",
"description": "Aerial orthophotos: North Central Texas (NCTCOG) jurisdiction.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-97.5865, 32.5326, -96.9946, 33.0056]
},
"source": {
"format": "bbox",
"url": "https://mapitimage.tarrantcounty.com/arcgis/rest/services/Aerials/2011_NCTCOG_Ortho/ImageServer/exportImage?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 11,
"maxZoom": 20,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "sub-foot to 1 ft (local program)",
"resolutionM": 0.15,
"trueOrtho": false,
"vintage": "2011–present",
"updateCycle": "Local flight cycle (typically annual to 3-yearly)",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Local government open data — see publisher terms",
"url": "https://www.nctcog.org/",
"operatorOptIn": true
},
"attribution": {
"text": "North Central Texas Council of Governments",
"url": "https://www.nctcog.org/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,48 @@
{
"id": "nd-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "North Dakota Statewide Imagery (2013)",
"provider": "North Dakota GIS Hub",
"description": "Aerial orthophotos: Statewide coverage of North Dakota.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-104.3616, 45.7993, -96.3961, 49.1166]
},
"source": {
"format": "xyz",
"url": "https://ndgishub.nd.gov/arcgis/rest/services/Imagery/AerialImage_DES_BaseMap_Cached/MapServer/tile/{z}/{y}/{x}",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 21,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "1 ft – 1 m",
"resolutionM": 0.3048,
"trueOrtho": false,
"vintage": "2013–present",
"updateCycle": "Periodic",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Open state geodata — attribution requested",
"url": "https://www.gis.nd.gov/",
"operatorOptIn": true
},
"attribution": {
"text": "ND Dept. of Transportation, ND Dept. of Emergency Services, and the ND GIS Hub",
"url": "https://www.gis.nd.gov/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,48 @@
{
"id": "new-orleans-rpc-la",
"kind": "tiles",
"family": "imagery",
"title": "New Orleans Regional Planning Commission Imagery",
"provider": "New Orleans RPC",
"description": "Aerial orthophotos: New Orleans Regional Planning Commission jurisdiction.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-90.0974, 29.8415, -89.9951, 29.9701]
},
"source": {
"format": "xyz",
"url": "https://tiles.arcgis.com/tiles/3OuwdDUqRzQS6PA4/arcgis/rest/services/RPC2022imagery/MapServer/tile/{z}/{y}/{x}",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 11,
"maxZoom": 22,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "sub-foot to 1 ft (local program)",
"resolutionM": 0.15,
"trueOrtho": false,
"vintage": "2020–present",
"updateCycle": "Local flight cycle (typically annual to 3-yearly)",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Local government open data — see publisher terms",
"url": "https://www.norpc.org/",
"operatorOptIn": true
},
"attribution": {
"text": "Regional Planning Commission for Jefferson, Orleans, Plaquemines, St. Bernard, St. Charles, St. John the Baptist, St. Tammany, and Tangipahoa Parishes (RPC)",
"url": "https://www.norpc.org/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,48 @@
{
"id": "nh-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "New Hampshire Statewide Imagery (2022)",
"provider": "NH GRANIT",
"description": "Aerial orthophotos: Statewide coverage of New Hampshire.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-72.6173, 42.6862, -70.5548, 45.3128]
},
"source": {
"format": "bbox",
"url": "https://nhgeodata.unh.edu/image/rest/services/ImageServices/NH_2021_2022_6in_RGB/ImageServer/exportImage?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 19,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "6 in",
"resolutionM": 0.1524,
"trueOrtho": false,
"vintage": "2022–present",
"updateCycle": "Multi-year cycles",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Open — NH GRANIT terms",
"url": "https://www.granit.unh.edu/",
"operatorOptIn": true
},
"attribution": {
"text": "NH GRANIT, University of New Hampshire",
"url": "https://www.granit.unh.edu/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,48 @@
{
"id": "nj-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "New Jersey Statewide Imagery (2015)",
"provider": "NJ Office of GIS (NJOGIS)",
"description": "Aerial orthophotos: Statewide coverage of New Jersey.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-75.56, 38.93, -73.89, 41.36]
},
"source": {
"format": "xyz",
"url": "https://maps.nj.gov/arcgis/rest/services/Basemap/Orthos_Natural_2015_NJ_WM/MapServer/tile/{z}/{y}/{x}",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 20,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "1 ft",
"resolutionM": 0.3048,
"trueOrtho": false,
"vintage": "2015–present",
"updateCycle": "Roughly every 3 years",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Open — State of New Jersey provides data 'as is'",
"url": "https://njgin.nj.gov/",
"operatorOptIn": true
},
"attribution": {
"text": "Project definition, funding requests, and data distribution by NJ Office of Information Technology, Office of Geographic Information Systems (NJOIT - OGIS). Funding for the imagery project provided by",
"url": "https://registry.opendata.aws/nj-imagery/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,37 @@
{
"id": "noaa-tide-stations",
"kind": "dataset",
"family": "environment",
"title": "US tide stations (NOAA CO-OPS)",
"provider": "NOAA CO-OPS",
"description": "About 300 NOAA water-level stations on US coasts, the Great Lakes and Pacific islands, with their tide type.",
"icon": "≈",
"maintainer": "github:asturksever",
"coverage": { "countries": ["US"], "bbox": [-180, -15, 180, 72] },
"source": {
"format": "json",
"url": "https://api.tidesandcurrents.noaa.gov/mdapi/prod/webapi/stations.json",
"query": { "type": "waterlevels" },
"records": "stations",
"columns": { "lat": "lat", "lon": "lng" },
"fetch": "browser-direct",
"cacheSeconds": 86400,
"maxBytes": 4194304,
"maxFeatures": 1000
},
"display": {
"color": "#63b3ed",
"label": "name",
"fields": ["state", "tideType"]
},
"licence": {
"name": "NOAA data: U.S. public domain",
"url": "https://tidesandcurrents.noaa.gov/disclaimers.html"
},
"attribution": {
"text": "NOAA Center for Operational Oceanographic Products and Services (CO-OPS)",
"url": "https://tidesandcurrents.noaa.gov/"
},
"status": "community",
"reviewed": "2026-10-22"
}
+48
View File
@@ -0,0 +1,48 @@
{
"id": "nrw-dop",
"kind": "tiles",
"family": "imagery",
"title": "Digitale Orthophotos NRW (DOP 10 cm)",
"provider": "Geobasis NRW",
"description": "Aerial orthophotos: 100% of North Rhine-Westphalia (~34,100 km²).",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["DE"],
"bbox": [5.86, 50.32, 9.46, 52.53]
},
"source": {
"format": "bbox",
"url": "https://www.wms.nrw.de/geobasis/wms_nw_dop?service=WMS&request=GetMap&version=1.3.0&layers=nw_dop_rgb&styles=&crs=EPSG:3857&bbox={bbox-epsg-3857}&width=256&height=256&format=image/jpeg",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 8,
"maxZoom": 20,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true,
"noDataColor": "#ffffff"
},
"imagery": {
"type": "ortho",
"resolution": "10 cm",
"resolutionM": 0.1,
"trueOrtho": false,
"vintage": "2021–present",
"updateCycle": "Biennial per zone (rolling)",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Datenlizenz Deutschland – Zero (public-domain-like)",
"url": "https://www.govdata.de/dl-de/zero-2-0"
},
"attribution": {
"text": "Geobasis NRW (dl-de/zero-2-0)",
"url": "https://www.opengeodata.nrw.de/produkte/geobasis/lusat/akt/dop/"
},
"status": "community",
"reviewed": "2026-10-23"
}
+47
View File
@@ -0,0 +1,47 @@
{
"id": "nsw-imagery",
"kind": "tiles",
"family": "imagery",
"title": "NSW Imagery (Six Maps)",
"provider": "Spatial Services NSW (DCS)",
"description": "Aerial orthophotos: New South Wales (~801,000 km²).",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["AU"],
"bbox": [140.9, -37.6, 153.7, -28.1]
},
"source": {
"format": "xyz",
"url": "https://maps.six.nsw.gov.au/arcgis/rest/services/public/NSW_Imagery/MapServer/tile/{z}/{y}/{x}",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 4,
"maxZoom": 19,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "7.5 cm (metro) – 50 cm",
"resolutionM": 0.075,
"trueOrtho": false,
"vintage": "2015–present",
"updateCycle": "Rolling (metro yearly)",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "CC BY 4.0",
"url": "https://www.spatial.nsw.gov.au/products_and_services/web_services"
},
"attribution": {
"text": "© Spatial Services NSW",
"url": "https://portal.spatial.nsw.gov.au/portal/home/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,57 @@
{
"id": "ntad-national-bridges",
"kind": "dataset",
"family": "infrastructure",
"title": "US bridges and their condition (NBI)",
"provider": "USDOT BTS",
"description": "All of the about 624,000 highway bridges in the National Bridge Inventory, coloured by condition. Loads the bridges in view below 15 km.",
"icon": "⌒",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US", "PR"]
},
"source": {
"format": "arcgis",
"url": "https://services.arcgis.com/xOi1kZaI0eWDREZv/arcgis/rest/services/NTAD_National_Bridge_Inventory/FeatureServer/0",
"query": {
"outFields": "BRIDGE_CONDITION,FACILITY_CARRIED_007,FEATURES_DESC_006A,YEAR_BUILT_027,ADT_029"
},
"fetch": "browser-direct",
"view": {
"maxAltitudeM": 15000,
"sample": [-80.02, 40.43, -79.98, 40.46]
},
"cacheSeconds": 86400,
"maxBytes": 8388608,
"maxFeatures": 2000,
"maxPages": 1
},
"display": {
"color": "#a0aec0",
"label": "FACILITY_CARRIED_007",
"fields": ["BRIDGE_CONDITION", "YEAR_BUILT_027"],
"colorBy": {
"field": "BRIDGE_CONDITION",
"colors": {
"G": "#0ca30c",
"F": "#fab219",
"P": "#d03b3b"
},
"labels": {
"G": "Good",
"F": "Fair",
"P": "Poor"
}
}
},
"licence": {
"name": "U.S. government work: unrestricted public use",
"url": "https://www.bts.gov/ntad"
},
"attribution": {
"text": "USDOT Bureau of Transportation Statistics — National Transportation Atlas Database, National Bridge Inventory",
"url": "https://www.bts.gov/ntad"
},
"status": "community",
"reviewed": "2026-10-22"
}
@@ -0,0 +1,48 @@
{
"id": "nwa-benton-washington-ar",
"kind": "tiles",
"family": "imagery",
"title": "Northwest Arkansas (Benton & Washington County) Imagery",
"provider": "Northwest Arkansas regional GIS",
"description": "Aerial orthophotos: Northwest Arkansas (Benton & Washington County) jurisdiction.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-94.6282, 35.7407, -93.7939, 36.5179]
},
"source": {
"format": "xyz",
"url": "https://tiles.arcgis.com/tiles/G4bYaaas92zuKaUR/arcgis/rest/services/BentWashImg2024Pack/MapServer/tile/{z}/{y}/{x}",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 11,
"maxZoom": 22,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "sub-foot to 1 ft (local program)",
"resolutionM": 0.15,
"trueOrtho": false,
"vintage": "2024–present",
"updateCycle": "Local flight cycle (typically annual to 3-yearly)",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Local government open data — see publisher terms",
"url": "https://www.nwarpc.org/",
"operatorOptIn": true
},
"attribution": {
"text": "NWARPC; Washington County; Benton County",
"url": "https://www.nwarpc.org/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,56 @@
{
"id": "nws-active-alerts",
"kind": "dataset",
"family": "weather",
"title": "US weather alerts with drawn areas (NWS)",
"provider": "NWS",
"description": "Active National Weather Service alerts that carry their own polygon, such as storm-based warnings. Zone-wide alerts have no drawn area and are left out.",
"icon": "⚠",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-180, 13, -64, 72]
},
"source": {
"format": "geojson",
"url": "https://api.weather.gov/alerts/active",
"fetch": "browser-direct",
"cacheSeconds": 300,
"maxBytes": 8388608,
"maxFeatures": 2000
},
"display": {
"color": "#a0aec0",
"label": "event",
"fields": ["severity", "areaDesc"],
"rank": {
"field": "onset",
"order": "desc"
},
"colorBy": {
"field": "severity",
"colors": {
"Extreme": "#d03b3b",
"Severe": "#ec835a",
"Moderate": "#fab219",
"Minor": "#0ca30c"
},
"labels": {
"Extreme": "Extreme",
"Severe": "Severe",
"Moderate": "Moderate",
"Minor": "Minor"
}
}
},
"licence": {
"name": "NWS data: U.S. public domain",
"url": "https://www.weather.gov/disclaimer"
},
"attribution": {
"text": "NOAA National Weather Service",
"url": "https://www.weather.gov/"
},
"status": "community",
"reviewed": "2026-10-22"
}
@@ -0,0 +1,47 @@
{
"id": "ny-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "New York Statewide Imagery (2019)",
"provider": "NYS GIS Program Office (ITS)",
"description": "Aerial orthophotos: Statewide coverage of New York.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-80.1606, 40.2704, -71.2889, 45.1325]
},
"source": {
"format": "xyz",
"url": "https://orthos.its.ny.gov/arcgis/rest/services/wms/NAIP_2019/MapServer/tile/{z}/{y}/{x}",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 18,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "3 in – 1 ft",
"resolutionM": 0.0762,
"trueOrtho": false,
"vintage": "2019–present",
"updateCycle": "Statewide 3-year cycle",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Public domain — NYS open data",
"url": "https://data.gis.ny.gov/"
},
"attribution": {
"text": "USDA; NYS ITS Geospatial Services",
"url": "https://data.gis.ny.gov/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,48 @@
{
"id": "oakland-county-mi",
"kind": "tiles",
"family": "imagery",
"title": "Oakland County, Michigan Ortho Imagery",
"provider": "Oakland County GIS",
"description": "Aerial orthophotos: Oakland County, Michigan jurisdiction.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-83.7199, 42.4077, -83.0521, 42.9141]
},
"source": {
"format": "bbox",
"url": "https://gisservices.oakgov.com/arcgis/rest/services/ImageServices/EnterpriseOrthoTC2025ImageService/ImageServer/exportImage?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 11,
"maxZoom": 20,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "sub-foot to 1 ft (local program)",
"resolutionM": 0.15,
"trueOrtho": false,
"vintage": "2025–present",
"updateCycle": "Local flight cycle (typically annual to 3-yearly)",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Local government open data — see publisher terms",
"url": "https://oakgov.maps.arcgis.com/",
"operatorOptIn": true
},
"attribution": {
"text": "Oakland County GIS",
"url": "https://oakgov.maps.arcgis.com/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,47 @@
{
"id": "oh-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "Ohio Statewide Imagery",
"provider": "Ohio OGRIP (OSIP)",
"description": "Aerial orthophotos: Statewide coverage of Ohio.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-84.9418, 38.3739, -80.4714, 42.0065]
},
"source": {
"format": "xyz",
"url": "https://maps.ohio.gov/image/rest/services/osip_most_current_cache/MapServer/tile/{z}/{y}/{x}",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 22,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "6 in – 1 ft",
"resolutionM": 0.1524,
"trueOrtho": false,
"vintage": "2015–present",
"updateCycle": "Rolling statewide (OSIP)",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Public domain — Ohio open data",
"url": "https://maps.ohio.gov/"
},
"attribution": {
"text": "Ohio Geographically Referenced Information Program (OGRIP)",
"url": "https://maps.ohio.gov/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,47 @@
{
"id": "or-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "Oregon Statewide Imagery (2000)",
"provider": "Oregon OSIP (DAS GEO)",
"description": "Aerial orthophotos: Statewide coverage of Oregon.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-124.8956, 41.7968, -116.3087, 46.4332]
},
"source": {
"format": "bbox",
"url": "https://imagery.oregonexplorer.info/arcgis/rest/services/NAIP_2000/NAIP_2000_SL/ImageServer/exportImage?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 19,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "6 in – 1 ft",
"resolutionM": 0.1524,
"trueOrtho": false,
"vintage": "2000–present",
"updateCycle": "OSIP cycles (~3 years)",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Public domain — Oregon open data",
"url": "https://www.oregon.gov/geo/"
},
"attribution": {
"text": "Oregon, GEO, DAS",
"url": "https://www.oregon.gov/geo/Pages/imagery.aspx"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,48 @@
{
"id": "pa-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "Pennsylvania Statewide Imagery",
"provider": "PASDA / PAMAP (Penn State)",
"description": "Aerial orthophotos: Statewide coverage of Pennsylvania.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-80.52, 39.72, -74.69, 42.27]
},
"source": {
"format": "bbox",
"url": "https://imagery.pasda.psu.edu/arcgis/rest/services/pasda/Aerials0306StateWide/MapServer/export?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 19,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true,
"noDataColor": "#fdfdfd"
},
"imagery": {
"type": "ortho",
"resolution": "1 ft – 2 ft",
"resolutionM": 0.3048,
"trueOrtho": false,
"vintage": "2015–present",
"updateCycle": "PAMAP multi-year cycles",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Public domain — PASDA open data",
"url": "https://www.pasda.psu.edu/"
},
"attribution": {
"text": "PASDA / PAMAP, Commonwealth of Pennsylvania",
"url": "https://www.pasda.psu.edu/"
},
"status": "community",
"reviewed": "2026-10-23"
}
+48
View File
@@ -0,0 +1,48 @@
{
"id": "pl-ortofotomapa",
"kind": "tiles",
"family": "imagery",
"title": "Ortofotomapa Polski (GUGiK)",
"provider": "GUGiK / geoportal.gov.pl",
"description": "Aerial orthophotos: 100% of Poland (rolling; cities at 5 cm).",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["PL"],
"bbox": [14.12, 49, 24.15, 54.84]
},
"source": {
"format": "bbox",
"url": "https://mapy.geoportal.gov.pl/wss/service/PZGIK/ORTO/WMS/StandardResolution?service=WMS&request=GetMap&version=1.3.0&layers=Raster&styles=default&crs=EPSG:3857&bbox={bbox-epsg-3857}&width=256&height=256&format=image/jpeg",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 7,
"maxZoom": 20,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "coverage",
"aerial": true,
"noDataColor": "#ffffff"
},
"imagery": {
"type": "ortho",
"resolution": "5–25 cm",
"resolutionM": 0.05,
"trueOrtho": false,
"vintage": "2019–present",
"updateCycle": "Rolling (1–3 years per zone)",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Polish open geodata (free reuse, Prawo geodezyjne art. 40a)",
"url": "https://www.geoportal.gov.pl/"
},
"attribution": {
"text": "© GUGiK / geoportal.gov.pl",
"url": "https://mapy.geoportal.gov.pl/imap/Imgp_2.html"
},
"status": "community",
"reviewed": "2026-10-23"
}
+48
View File
@@ -0,0 +1,48 @@
{
"id": "pnoa-ma",
"kind": "tiles",
"family": "imagery",
"title": "PNOA Máxima Actualidad",
"provider": "IGN España / CNIG",
"description": "Aerial orthophotos: Mainland Spain and Balearic Islands (Canary Islands served by a separate PNOA service).",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["ES"],
"bbox": [-9.3, 36, 3.35, 43.8]
},
"source": {
"format": "bbox",
"url": "https://www.ign.es/wms-inspire/pnoa-ma?service=WMS&request=GetMap&version=1.3.0&layers=OI.OrthoimageCoverage&styles=&crs=EPSG:3857&bbox={bbox-epsg-3857}&width=256&height=256&format=image/jpeg",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 20,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "coverage",
"aerial": true,
"noDataColor": "#ffffff"
},
"imagery": {
"type": "ortho",
"resolution": "15–25 cm",
"resolutionM": 0.15,
"trueOrtho": false,
"vintage": "2020–present",
"updateCycle": "2–3 year refresh per zone",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "CC BY 4.0 (compatible) — Orden FOM/2807/2015",
"url": "https://www.scne.es/productos.html"
},
"attribution": {
"text": "PNOA © Instituto Geográfico Nacional de España",
"url": "https://centrodedescargas.cnig.es/CentroDescargas/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,48 @@
{
"id": "portland-metro-or",
"kind": "tiles",
"family": "imagery",
"title": "Portland Metro (RLIS), Oregon Aerial Photos",
"provider": "Oregon Metro RLIS",
"description": "Aerial orthophotos: Portland Metro (RLIS), Oregon jurisdiction.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-123.1535, 45.234, -122.3675, 45.7026]
},
"source": {
"format": "xyz",
"url": "https://utility.arcgis.com/usrsvcs/servers/41cd821260944a668ef228f671b3ff46/rest/services/photo/2023aerialphoto/MapServer/tile/{z}/{y}/{x}",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 11,
"maxZoom": 22,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "sub-foot to 1 ft (local program)",
"resolutionM": 0.15,
"trueOrtho": false,
"vintage": "2023–present",
"updateCycle": "Local flight cycle (typically annual to 3-yearly)",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Local government open data — see publisher terms",
"url": "https://rlisdiscovery.oregonmetro.gov/",
"operatorOptIn": true
},
"attribution": {
"text": "Oregon Metro RLIS",
"url": "https://rlisdiscovery.oregonmetro.gov/"
},
"status": "community",
"reviewed": "2026-10-23"
}
+48
View File
@@ -0,0 +1,48 @@
{
"id": "pt-dgt-ortos",
"kind": "tiles",
"family": "imagery",
"title": "Ortofotos de Portugal Continental (DGT)",
"provider": "Direção-Geral do Território",
"description": "Aerial orthophotos: Portugal Continental.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["PT"],
"bbox": [-9.52, 36.96, -6.19, 42.15]
},
"source": {
"format": "bbox",
"url": "https://ortos.dgterritorio.gov.pt/wms/ortosat2023?service=WMS&request=GetMap&version=1.3.0&layers=ortoSat2023-CorVerdadeira&styles=&crs=EPSG:3857&bbox={bbox-epsg-3857}&width=256&height=256&format=image/jpeg",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 7,
"maxZoom": 18,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "coverage",
"aerial": true,
"noDataColor": "#ffffff"
},
"imagery": {
"type": "ortho",
"resolution": "25–30 cm",
"resolutionM": 0.25,
"trueOrtho": false,
"vintage": "2021–present",
"updateCycle": "Multi-year campaigns",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "CC BY 4.0",
"url": "https://www.dgterritorio.gov.pt/"
},
"attribution": {
"text": "© Direção-Geral do Território",
"url": "https://snig.dgterritorio.gov.pt/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,48 @@
{
"id": "ri-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "Rhode Island Statewide Imagery (2019)",
"provider": "RIGIS",
"description": "Aerial orthophotos: Statewide coverage of Rhode Island.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-71.9065, 41.1437, -71.1078, 42.0276]
},
"source": {
"format": "xyz",
"url": "https://tiles.arcgis.com/tiles/S8zZg9pg23JUEexQ/arcgis/rest/services/RI_201811_RGB_3in_web/MapServer/tile/{z}/{y}/{x}",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 22,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "3–6 in",
"resolutionM": 0.1524,
"trueOrtho": false,
"vintage": "2019–present",
"updateCycle": "Periodic",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Open — RIGIS terms",
"url": "https://www.rigis.org/",
"operatorOptIn": true
},
"attribution": {
"text": "URI EDC, RIGIS",
"url": "https://www.rigis.org/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,49 @@
{
"id": "swisstopo-swissimage",
"kind": "tiles",
"family": "imagery",
"title": "Switzerland aerial photos (SWISSIMAGE 10 cm)",
"provider": "swisstopo",
"description": "swisstopo's orthophoto mosaic of Switzerland and Liechtenstein: 10 cm in the lowlands and main Alpine valleys, 25 cm over the Alps, renewed every three years.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["CH", "LI"],
"bbox": [5.9, 45.8, 10.5, 47.9]
},
"source": {
"format": "xyz",
"url": "https://wmts.geo.admin.ch/1.0.0/ch.swisstopo.swissimage/default/current/3857/{z}/{x}/{y}.jpeg",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 7,
"maxZoom": 20,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "countries",
"aerial": true,
"noDataColor": "#ffffff"
},
"imagery": {
"type": "ortho",
"resolution": "10 cm (plains) / 25 cm (Alps)",
"resolutionM": 0.1,
"trueOrtho": false,
"vintage": "2021–present",
"updateCycle": "3-year rolling refresh",
"orthoQuality": "±0.15 m (1σ) plains / ±0.25 m Alps, DTM-orthorectified",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "swisstopo free geodata (OGD): free use, including commercial, with source credit",
"url": "https://www.swisstopo.admin.ch/en/terms-of-use-free-geodata-and-geoservices"
},
"attribution": {
"text": "©swisstopo — SWISSIMAGE 10 cm",
"url": "https://www.swisstopo.admin.ch/en/orthoimage-swissimage-10"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,47 @@
{
"id": "tx-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "Texas Statewide Imagery (2022)",
"provider": "TxGIO / TNRIS",
"description": "Aerial orthophotos: Statewide coverage of Texas.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-106.65, 25.84, -93.51, 36.5]
},
"source": {
"format": "bbox",
"url": "https://imagery.geographic.texas.gov/server/rest/services/NAIP/NAIP22_NCCIR_60cm/ImageServer/exportImage?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 19,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "60 cm",
"resolutionM": 0.6,
"trueOrtho": false,
"vintage": "2022–present",
"updateCycle": "NAIP 2-year; StratMap regional",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Public domain — TxGIO open data",
"url": "https://geographic.texas.gov/"
},
"attribution": {
"text": "Texas Geographic Information Office (TxGIO)",
"url": "https://data.geographic.texas.gov/"
},
"status": "community",
"reviewed": "2026-10-23"
}
+49
View File
@@ -0,0 +1,49 @@
{
"id": "union-county-oh",
"kind": "tiles",
"family": "imagery",
"title": "Union County, Ohio Aerial Imagery",
"provider": "Union County GIS",
"description": "Aerial orthophotos: Union County, Ohio jurisdiction.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-83.6732, 39.9845, -83.0745, 40.5493]
},
"source": {
"format": "bbox",
"url": "https://www7.co.union.oh.us/unioncountyohio/rest/services/AerialPhoto2023/MapServer/export?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 11,
"maxZoom": 20,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true,
"noDataColor": "#fdfdfd"
},
"imagery": {
"type": "ortho",
"resolution": "sub-foot to 1 ft (local program)",
"resolutionM": 0.15,
"trueOrtho": false,
"vintage": "2023–present",
"updateCycle": "Local flight cycle (typically annual to 3-yearly)",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Local government open data — see publisher terms",
"url": "https://union-county-auditor-unionco.hub.arcgis.com/",
"operatorOptIn": true
},
"attribution": {
"text": "Union County / City of Marysville GIS",
"url": "https://union-county-auditor-unionco.hub.arcgis.com/"
},
"status": "community",
"reviewed": "2026-10-23"
}
+35
View File
@@ -0,0 +1,35 @@
{
"id": "usgs-hydrography",
"kind": "tiles",
"family": "environment",
"title": "US rivers and lakes (USGS)",
"provider": "USGS",
"description": "The National Hydrography Dataset's rivers, streams and water bodies, drawn over any map.",
"icon": "≋",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-180, 13, -64, 72]
},
"source": {
"format": "xyz",
"url": "https://basemap.nationalmap.gov/arcgis/rest/services/USGSHydroCached/MapServer/tile/{z}/{y}/{x}",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 0,
"maxZoom": 16
},
"display": {
"opacity": 1
},
"licence": {
"name": "USGS The National Map: U.S. public domain",
"url": "https://www.usgs.gov/information-policies-and-instructions/copyrights-and-credits"
},
"attribution": {
"text": "USGS The National Map — National Hydrography Dataset",
"url": "https://www.usgs.gov/national-hydrography"
},
"status": "community",
"reviewed": "2026-10-22"
}
+35
View File
@@ -0,0 +1,35 @@
{
"id": "usgs-topo",
"kind": "tiles",
"family": "imagery",
"title": "US topographic map (USGS)",
"provider": "USGS",
"description": "The National Map's topographic basemap of the United States: contours, roads, places and land cover.",
"icon": "⛰",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-180, 13, -64, 72]
},
"source": {
"format": "xyz",
"url": "https://basemap.nationalmap.gov/arcgis/rest/services/USGSTopo/MapServer/tile/{z}/{y}/{x}",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 0,
"maxZoom": 16
},
"display": {
"opacity": 1
},
"licence": {
"name": "USGS The National Map: U.S. public domain",
"url": "https://www.usgs.gov/information-policies-and-instructions/copyrights-and-credits"
},
"attribution": {
"text": "USGS The National Map",
"url": "https://www.usgs.gov/programs/national-geospatial-program/national-map"
},
"status": "community",
"reviewed": "2026-10-22"
}
@@ -0,0 +1,48 @@
{
"id": "va-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "Virginia Statewide Imagery",
"provider": "VGIN / VDEM",
"description": "Aerial orthophotos: Statewide coverage of Virginia.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-83.68, 36.54, -75.24, 39.47]
},
"source": {
"format": "xyz",
"url": "https://vginmaps.vdem.virginia.gov/arcgis/rest/services/VBMP_Imagery/MostRecentImagery_WGS/MapServer/tile/{z}/{y}/{x}",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 22,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "1 ft (VBMP)",
"resolutionM": 0.3048,
"trueOrtho": false,
"vintage": "2015–present",
"updateCycle": "VBMP 3-year statewide cycle",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Open — VGIN VBMP terms",
"url": "https://vgin.vdem.virginia.gov/",
"operatorOptIn": true
},
"attribution": {
"text": "Virginia Geographic Information Network (VGIN)",
"url": "https://vgin.vdem.virginia.gov/"
},
"status": "community",
"reviewed": "2026-10-23"
}
@@ -0,0 +1,47 @@
{
"id": "vt-statewide-imagery",
"kind": "tiles",
"family": "imagery",
"title": "Vermont Statewide Imagery",
"provider": "VCGI",
"description": "Aerial orthophotos: Statewide coverage of Vermont.",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["US"],
"bbox": [-73.5011, 42.6871, -71.4363, 45.0631]
},
"source": {
"format": "bbox",
"url": "https://maps.vcgi.vermont.gov/arcgis/rest/services/EGC_services/IMG_VCGI_CIR_WM_CACHE/ImageServer/exportImage?bbox={bbox-epsg-3857}&bboxSR=3857&imageSR=3857&size=256,256&format=jpgpng&f=image",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 6,
"maxZoom": 19,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true
},
"imagery": {
"type": "ortho",
"resolution": "30 cm",
"resolutionM": 0.3,
"trueOrtho": false,
"vintage": "2015–present",
"updateCycle": "Statewide roughly every 2 years",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Public domain — Vermont open data",
"url": "https://vcgi.vermont.gov/"
},
"attribution": {
"text": "Vermont Center for Geographic Information (VCGI)",
"url": "https://registry.opendata.aws/vt-opendata/"
},
"status": "community",
"reviewed": "2026-10-23"
}
+48
View File
@@ -0,0 +1,48 @@
{
"id": "wallonie-ortho",
"kind": "tiles",
"family": "imagery",
"title": "Orthophotos de Wallonie",
"provider": "Service public de Wallonie (SPW)",
"description": "Aerial orthophotos: Wallonia (~16,900 km²).",
"icon": "▣",
"maintainer": "github:asturksever",
"coverage": {
"countries": ["BE"],
"bbox": [2.84, 49.49, 6.41, 50.85]
},
"source": {
"format": "bbox",
"url": "https://geoservices.wallonie.be/arcgis/services/IMAGERIE/ORTHO_LAST/MapServer/WMSServer?service=WMS&request=GetMap&version=1.3.0&layers=0&styles=&crs=EPSG:3857&bbox={bbox-epsg-3857}&width=256&height=256&format=image/jpeg",
"fetch": "browser-direct",
"cacheSeconds": 86400,
"minZoom": 8,
"maxZoom": 20,
"bounded": true
},
"display": {
"opacity": 1,
"outline": "bbox",
"aerial": true,
"noDataColor": "#ffffff"
},
"imagery": {
"type": "ortho",
"resolution": "25 cm",
"resolutionM": 0.25,
"trueOrtho": false,
"vintage": "2021–present",
"updateCycle": "Annual",
"registry": "https://imagery-registry.netlify.app/"
},
"licence": {
"name": "Conditions ouvertes SPW (attribution)",
"url": "https://geoportail.wallonie.be/catalogue-donnees"
},
"attribution": {
"text": "© Service public de Wallonie",
"url": "https://geoportail.wallonie.be/"
},
"status": "community",
"reviewed": "2026-10-23"
}
Loaded 100 of 533 files, more files were not shown because too many files have changed in this diff. Show more