map-zero 0.1.0

package/src/3dtiles/gpkg-buildings.js

@@ -0,0 +1,240 @@
+import Database from 'better-sqlite3';
+
+import { decodeGeoPackageGeometry } from '../geometry-read.js';
+import { bboxIntersects, quoteIdentifier } from '../utils.js';
+import { cleanRing } from './extrude.js';
+
+const DEFAULT_LEVEL_HEIGHT = 3;
+
+/**
+ * @typedef {{
+ *   table: string,
+ *   geometryColumn: string,
+ *   rtree: string,
+ *   bbox: [number, number, number, number]
+ * }} BuildingMetadata
+ */
+
+/**
+ * @param {string} gpkgPath
+ * @returns {Database.Database}
+ */
+export function openReadonlyGeoPackage(gpkgPath) {
+  const db = new Database(gpkgPath, { readonly: true, fileMustExist: true });
+  for (const pragma of ['query_only = ON', 'temp_store = MEMORY', 'cache_size = -65536']) {
+    try {
+      db.pragma(pragma);
+    } catch {
+      // Optional read tuning.
+    }
+  }
+  return db;
+}
+
+/**
+ * @param {Database.Database} db
+ * @param {[number, number, number, number]} fallbackBbox
+ * @returns {BuildingMetadata}
+ */
+export function readBuildingsMetadata(db, fallbackBbox) {
+  const geometry = db.prepare(`
+    SELECT column_name
+    FROM gpkg_geometry_columns
+    WHERE table_name = 'buildings'
+  `).get();
+  if (!geometry?.column_name) {
+    throw new Error('GeoPackage does not contain a buildings geometry column');
+  }
+
+  const geometryColumn = String(geometry.column_name);
+  const rtree = `rtree_buildings_${geometryColumn}`;
+  const rtreeRow = db.prepare(`
+    SELECT name
+    FROM sqlite_master
+    WHERE type = 'table' AND name = ?
+  `).get(rtree);
+  if (!rtreeRow) {
+    throw new Error(`GeoPackage does not contain expected RTree table ${rtree}`);
+  }
+
+  const content = db.prepare(`
+    SELECT min_x, min_y, max_x, max_y
+    FROM gpkg_contents
+    WHERE table_name = 'buildings'
+  `).get();
+  const bbox = validBbox([content?.min_x, content?.min_y, content?.max_x, content?.max_y])
+    ? [Number(content.min_x), Number(content.min_y), Number(content.max_x), Number(content.max_y)]
+    : fallbackBbox;
+
+  return {
+    table: 'buildings',
+    geometryColumn,
+    rtree,
+    bbox
+  };
+}
+
+/**
+ * @param {Database.Database} db
+ * @param {BuildingMetadata} metadata
+ * @param {[number, number, number, number]} bbox
+ * @returns {number}
+ */
+export function countBuildings(db, metadata, bbox) {
+  const [minX, minY, maxX, maxY] = bbox;
+  const row = db.prepare(`
+    SELECT COUNT(*) AS count
+    FROM ${quoteIdentifier(metadata.rtree)}
+    WHERE minx <= ?
+      AND maxx >= ?
+      AND miny <= ?
+      AND maxy >= ?
+  `).get(maxX, minX, maxY, minY);
+  return Number(row?.count ?? 0);
+}
+
+/**
+ * @param {Database.Database} db
+ * @param {BuildingMetadata} metadata
+ * @param {[number, number, number, number]} bbox
+ * @param {{ defaultHeight: number, limit?: number, warn?: (message: string) => void }} options
+ * @returns {{ footprints: import('./extrude.js').Footprint[], skipped: number }}
+ */
+export function readBuildingFootprints(db, metadata, bbox, options) {
+  const [minX, minY, maxX, maxY] = bbox;
+  const limitClause = Number.isInteger(options.limit) && options.limit > 0 ? 'LIMIT ?' : '';
+  const params = [maxX, minX, maxY, minY];
+  if (limitClause) {
+    params.push(Number(options.limit));
+  }
+  const rows = db.prepare(`
+    SELECT feature_table.*
+    FROM ${quoteIdentifier(metadata.table)} AS feature_table
+    JOIN ${quoteIdentifier(metadata.rtree)} AS rtree_table
+      ON feature_table.rowid = rtree_table.id
+    WHERE rtree_table.minx <= ?
+      AND rtree_table.maxx >= ?
+      AND rtree_table.miny <= ?
+      AND rtree_table.maxy >= ?
+    ${limitClause}
+  `).all(...params);
+  const footprints = [];
+  let skipped = 0;
+
+  for (const row of rows) {
+    const geometry = decodeGeoPackageGeometry(row[metadata.geometryColumn]);
+    if (!geometry) {
+      skipped++;
+      continue;
+    }
+
+    const polygons = polygonsFromGeometry(geometry);
+    if (polygons.length === 0) {
+      skipped++;
+      continue;
+    }
+
+    const height = buildingHeight(row, options.defaultHeight);
+    for (const polygon of polygons) {
+      const outerRing = cleanRing(polygon[0] ?? []);
+      if (outerRing.length < 3) {
+        skipped++;
+        continue;
+      }
+
+      const footprintBbox = ringBbox(outerRing);
+      if (!bboxIntersects(footprintBbox, bbox)) {
+        continue;
+      }
+
+      footprints.push({
+        coordinates: outerRing,
+        height
+      });
+    }
+  }
+
+  return { footprints, skipped };
+}
+
+/**
+ * @param {{ type: string, coordinates: unknown }} geometry
+ * @returns {Array<Array<Array<[number, number]>>>}
+ */
+function polygonsFromGeometry(geometry) {
+  if (geometry.type === 'Polygon' && Array.isArray(geometry.coordinates)) {
+    return /** @type {Array<Array<Array<[number, number]>>>} */ ([geometry.coordinates]);
+  }
+
+  if (geometry.type === 'MultiPolygon' && Array.isArray(geometry.coordinates)) {
+    return /** @type {Array<Array<Array<[number, number]>>>} */ (geometry.coordinates);
+  }
+
+  return [];
+}
+
+/**
+ * @param {Record<string, unknown>} row
+ * @param {number} defaultHeight
+ * @returns {number}
+ */
+function buildingHeight(row, defaultHeight) {
+  const explicitHeight = parseMeters(row.height);
+  if (explicitHeight !== null) {
+    return explicitHeight;
+  }
+
+  const levels = Number(row['building:levels']);
+  if (Number.isFinite(levels) && levels > 0) {
+    return Math.min(levels * DEFAULT_LEVEL_HEIGHT, 500);
+  }
+
+  return defaultHeight;
+}
+
+/**
+ * @param {unknown} value
+ * @returns {number | null}
+ */
+function parseMeters(value) {
+  if (value === null || value === undefined || value === '') {
+    return null;
+  }
+
+  const match = /^(-?\d+(?:[.,]\d+)?)/.exec(String(value).trim());
+  if (!match) {
+    return null;
+  }
+
+  const height = Number(match[1].replace(',', '.'));
+  return Number.isFinite(height) && height > 0 ? Math.min(height, 500) : null;
+}
+
+/**
+ * @param {Array<[number, number]>} ring
+ * @returns {[number, number, number, number]}
+ */
+function ringBbox(ring) {
+  let minLon = Infinity;
+  let minLat = Infinity;
+  let maxLon = -Infinity;
+  let maxLat = -Infinity;
+  for (const [lon, lat] of ring) {
+    minLon = Math.min(minLon, lon);
+    minLat = Math.min(minLat, lat);
+    maxLon = Math.max(maxLon, lon);
+    maxLat = Math.max(maxLat, lat);
+  }
+  return [minLon, minLat, maxLon, maxLat];
+}
+
+/**
+ * @param {unknown[]} value
+ * @returns {boolean}
+ */
+function validBbox(value) {
+  return value.length === 4 &&
+    value.every((part) => Number.isFinite(Number(part))) &&
+    Number(value[0]) < Number(value[2]) &&
+    Number(value[1]) < Number(value[3]);
+}

package/src/3dtiles/gpkg-features.js

@@ -0,0 +1,157 @@
+import { decodeGeoPackageGeometry } from '../geometry-read.js';
+import { quoteIdentifier } from '../utils.js';
+
+const LAYER_ALIASES = {
+  aviation: 'aip',
+  aip: 'aviation'
+};
+
+/**
+ * @typedef {{
+ *   id: string,
+ *   table: string,
+ *   geometryColumn: string,
+ *   rtree: string,
+ *   bbox: [number, number, number, number]
+ * }} LayerMetadata
+ */
+
+/**
+ * @param {import('better-sqlite3').Database} db
+ * @param {Record<string, unknown>} manifest
+ * @param {string} layerId
+ * @returns {LayerMetadata}
+ */
+export function readLayerMetadata(db, manifest, layerId) {
+  const manifestLayer = Array.isArray(manifest.layers)
+    ? manifest.layers.find((layer) => layer?.id === layerId) ??
+      manifest.layers.find((layer) => layer?.id === LAYER_ALIASES[layerId])
+    : null;
+  if (!manifestLayer?.table) {
+    throw new Error(`manifest does not contain layer: ${layerId}`);
+  }
+
+  const table = String(manifestLayer.table);
+  const geometry = db.prepare(`
+    SELECT column_name
+    FROM gpkg_geometry_columns
+    WHERE table_name = ?
+  `).get(table);
+  if (!geometry?.column_name) {
+    throw new Error(`GeoPackage does not contain a geometry column for ${layerId}`);
+  }
+
+  const geometryColumn = String(geometry.column_name);
+  const rtree = `rtree_${table}_${geometryColumn}`;
+  const rtreeRow = db.prepare(`
+    SELECT name
+    FROM sqlite_master
+    WHERE type = 'table' AND name = ?
+  `).get(rtree);
+  if (!rtreeRow) {
+    throw new Error(`GeoPackage does not contain expected RTree table ${rtree}`);
+  }
+
+  const content = db.prepare(`
+    SELECT min_x, min_y, max_x, max_y
+    FROM gpkg_contents
+    WHERE table_name = ?
+  `).get(table);
+  const fallback = Array.isArray(manifest.bbox) ? manifest.bbox.map(Number) : [-180, -90, 180, 90];
+  const bbox = validBbox([content?.min_x, content?.min_y, content?.max_x, content?.max_y])
+    ? [Number(content.min_x), Number(content.min_y), Number(content.max_x), Number(content.max_y)]
+    : /** @type {[number, number, number, number]} */ (fallback);
+
+  return {
+    id: layerId,
+    table,
+    geometryColumn,
+    rtree,
+    bbox
+  };
+}
+
+/**
+ * @param {import('better-sqlite3').Database} db
+ * @param {LayerMetadata} metadata
+ * @param {[number, number, number, number]} bbox
+ * @returns {number}
+ */
+export function countLayerFeatures(db, metadata, bbox) {
+  const [minX, minY, maxX, maxY] = bbox;
+  const row = db.prepare(`
+    SELECT COUNT(*) AS count
+    FROM ${quoteIdentifier(metadata.rtree)}
+    WHERE minx <= ?
+      AND maxx >= ?
+      AND miny <= ?
+      AND maxy >= ?
+  `).get(maxX, minX, maxY, minY);
+  return Number(row?.count ?? 0);
+}
+
+/**
+ * @param {import('better-sqlite3').Database} db
+ * @param {LayerMetadata} metadata
+ * @param {[number, number, number, number]} bbox
+ * @param {{ limit?: number }} [options]
+ * @returns {Array<{ type: 'Feature', geometry: Record<string, unknown>, properties: Record<string, unknown> }>}
+ */
+export function readLayerFeatures(db, metadata, bbox, options = {}) {
+  const [minX, minY, maxX, maxY] = bbox;
+  const limitClause = Number.isInteger(options.limit) && options.limit > 0 ? 'LIMIT ?' : '';
+  const params = [maxX, minX, maxY, minY];
+  if (limitClause) {
+    params.push(Number(options.limit));
+  }
+
+  const rows = db.prepare(`
+    SELECT feature_table.*
+    FROM ${quoteIdentifier(metadata.table)} AS feature_table
+    JOIN ${quoteIdentifier(metadata.rtree)} AS rtree_table
+      ON feature_table.rowid = rtree_table.id
+    WHERE rtree_table.minx <= ?
+      AND rtree_table.maxx >= ?
+      AND rtree_table.miny <= ?
+      AND rtree_table.maxy >= ?
+    ${limitClause}
+  `).all(...params);
+
+  return rows.map((row) => rowToFeature(row, metadata.geometryColumn)).filter(Boolean);
+}
+
+/**
+ * @param {Record<string, unknown>} row
+ * @param {string} geometryColumn
+ * @returns {{ type: 'Feature', geometry: Record<string, unknown>, properties: Record<string, unknown> } | null}
+ */
+function rowToFeature(row, geometryColumn) {
+  const geometry = decodeGeoPackageGeometry(/** @type {Buffer | null} */ (row[geometryColumn]));
+  if (!geometry) {
+    return null;
+  }
+
+  const properties = {};
+  for (const [key, value] of Object.entries(row)) {
+    if (key !== geometryColumn) {
+      properties[key] = value;
+    }
+  }
+
+  return {
+    type: 'Feature',
+    geometry,
+    properties
+  };
+}
+
+/**
+ * @param {unknown[]} value
+ * @returns {boolean}
+ */
+function validBbox(value) {
+  return value.length === 4 &&
+    value.every((part) => Number.isFinite(Number(part))) &&
+    Number(value[0]) < Number(value[2]) &&
+    Number(value[1]) < Number(value[3]);
+}

package/src/3dtiles/tileset.js

@@ -0,0 +1,75 @@
+/**
+ * @param {[number, number, number, number]} bbox
+ * @param {number} minZ
+ * @param {number} maxZ
+ * @returns {[number, number, number, number, number, number]}
+ */
+export function bboxToRegion(bbox, minZ, maxZ) {
+  return [
+    degToRad(bbox[0]),
+    degToRad(bbox[1]),
+    degToRad(bbox[2]),
+    degToRad(bbox[3]),
+    minZ,
+    maxZ
+  ];
+}
+
+/**
+ * @param {{
+ *   bbox: [number, number, number, number],
+ *   maxHeight: number,
+ *   children: Array<Record<string, unknown>>
+ * }} options
+ * @returns {Record<string, unknown>}
+ */
+export function buildTileset(options) {
+  const region = bboxToRegion(options.bbox, 0, Math.max(1, options.maxHeight));
+  const geometricError = rootGeometricError(options.bbox);
+
+  return {
+    asset: {
+      version: '1.0',
+      gltfUpAxis: 'Z',
+      generator: 'map-zero'
+    },
+    geometricError,
+    root: {
+      boundingVolume: { region },
+      geometricError,
+      refine: 'ADD',
+      children: options.children
+    }
+  };
+}
+
+/**
+ * @param {{ bbox: [number, number, number, number], maxHeight: number, uri: string }} options
+ * @returns {Record<string, unknown>}
+ */
+export function buildContentNode(options) {
+  return {
+    boundingVolume: {
+      region: bboxToRegion(options.bbox, 0, Math.max(1, options.maxHeight))
+    },
+    geometricError: 0,
+    refine: 'ADD',
+    content: {
+      uri: options.uri
+    }
+  };
+}
+
+/**
+ * @param {[number, number, number, number]} bbox
+ * @returns {number}
+ */
+function rootGeometricError(bbox) {
+  const lonSpan = Math.max(0.0001, bbox[2] - bbox[0]);
+  const latSpan = Math.max(0.0001, bbox[3] - bbox[1]);
+  return Math.max(50, Math.max(lonSpan, latSpan) * 111000);
+}
+
+function degToRad(value) {
+  return value * Math.PI / 180;
+}

package/src/build.js

@@ -0,0 +1,134 @@
+import { promises as fs } from 'node:fs';
+import { resolve, join } from 'node:path';
+
+import { createManifest } from './manifest.js';
+import { normalizeLayerId } from './layers.js';
+import { buildOsmGeoPackage, inferOsmBbox } from './osm.js';
+import { createNeonDarkStyle } from './style.js';
+
+/**
+ * Build a .mapzero package folder from an OSM PBF source.
+ *
+ * @param {{
+ *   source: string,
+ *   bbox?: [number, number, number, number],
+ *   layers: string[],
+ *   out: string,
+ *   keepTemp?: boolean,
+ *   batchSize?: number,
+ *   debugBuild?: boolean,
+ *   onProgress?: (event: {
+ *     phase: 'stage' | 'progress' | 'summary',
+ *     step: string,
+ *     label?: string,
+ *     message?: string,
+ *     bytesRead?: number,
+ *     totalBytes?: number,
+ *     entities?: number,
+ *     itemsDone?: number,
+ *     totalItems?: number
+ *   }) => void
+ * }} options
+ * @returns {Promise<{ outDir: string, counts: Record<string, number> }>}
+ */
+export async function buildPackage(options) {
+  const source = resolve(options.source);
+  const outDir = resolve(options.out);
+  const stylesDir = join(outDir, 'styles');
+  const gpkgPath = join(outDir, 'data.gpkg');
+  const layers = [...new Set(options.layers.map(normalizeLayerId))];
+
+  options.onProgress?.({
+    phase: 'stage',
+    step: 'validate',
+    message: 'Validating input and preparing output folder'
+  });
+  const sourceStat = await assertReadableFile(source);
+  await fs.mkdir(stylesDir, { recursive: true });
+
+  const bbox = options.bbox ?? await inferOsmBbox(source, {
+    totalBytes: sourceStat.size,
+    onProgress: options.onProgress
+  });
+
+  options.onProgress?.({
+    phase: 'stage',
+    step: 'write-gpkg',
+    message: 'Writing GeoPackage'
+  });
+  const buildResult = await buildOsmGeoPackage(source, bbox, layers, gpkgPath, {
+    totalBytes: sourceStat.size,
+    batchSize: options.batchSize,
+    keepTemp: options.keepTemp,
+    tempPath: join(outDir, '.mapzero-build-tmp.sqlite'),
+    debugBuild: options.debugBuild,
+    onProgress: options.onProgress
+  });
+
+  options.onProgress?.({
+    phase: 'stage',
+    step: 'write-manifest',
+    message: 'Writing manifest and style'
+  });
+  await fs.writeFile(
+    join(outDir, 'manifest.json'),
+    `${JSON.stringify(createManifest({ outDir, bbox, layers }), null, 2)}\n`
+  );
+
+  await fs.writeFile(
+    join(stylesDir, 'neon-dark.json'),
+    `${JSON.stringify(createNeonDarkStyle(layers), null, 2)}\n`
+  );
+
+  return {
+    outDir,
+    counts: buildResult.counts
+  };
+}
+
+/**
+ * @param {string} filePath
+ * @returns {Promise<import('node:fs').Stats>}
+ */
+async function assertReadableFile(filePath) {
+  const stat = await fs.stat(filePath).catch(() => null);
+
+  if (!stat || !stat.isFile()) {
+    throw new Error(`source file does not exist: ${filePath}`);
+  }
+
+  await assertOsmPbfFile(filePath, stat);
+
+  return stat;
+}
+
+/**
+ * @param {string} filePath
+ * @param {import('node:fs').Stats} stat
+ * @returns {Promise<void>}
+ */
+async function assertOsmPbfFile(filePath, stat) {
+  if (stat.size < 16) {
+    throw new Error(`source file is too small to be an OSM PBF: ${filePath}`);
+  }
+
+  const handle = await fs.open(filePath, 'r');
+  try {
+    const buffer = Buffer.alloc(Math.min(1024, stat.size));
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+    const header = buffer.subarray(0, bytesRead);
+    const textPrefix = header.toString('utf8', 0, Math.min(bytesRead, 128)).trimStart().toLowerCase();
+
+    if (textPrefix.startsWith('<!doctype html') || textPrefix.startsWith('<html')) {
+      throw new Error(
+        `source file is HTML, not an OSM PBF: ${filePath}. Check the download URL and re-download with a .osm.pbf URL`
+      );
+    }
+
+    if (!header.includes(Buffer.from('OSMHeader'))) {
+      throw new Error(`source file does not look like an OSM PBF: ${filePath}`);
+    }
+  } finally {
+    await handle.close();
+  }
+}