map-zero 0.1.0

package/src/3dtiles/flat.js

@@ -0,0 +1,531 @@
+import earcut from 'earcut';
+
+import { cleanRing, wgs84SurfaceNormal, wgs84ToEcef } from './extrude.js';
+
+/**
+ * @typedef {{
+ *   positions: Float32Array,
+ *   normals: Float32Array,
+ *   indices: Uint16Array,
+ *   min: [number, number, number],
+ *   max: [number, number, number],
+ *   bbox: [number, number, number, number],
+ *   maxHeight: number,
+ *   featureCount: number
+ * }} FlatMesh
+ */
+
+const DEFAULT_RIBBON_JOIN = 'round';
+const DEFAULT_RIBBON_CAP = 'round';
+const DEFAULT_MITER_LIMIT = 3.5;
+
+/**
+ * @param {string} layerId
+ * @param {Array<{ geometry: Record<string, unknown>, properties: Record<string, unknown> }>} features
+ * @param {{
+ *   height?: number,
+ *   lineWidthMeters?: number,
+ *   join?: 'miter' | 'bevel' | 'round',
+ *   cap?: 'butt' | 'round',
+ *   roundSegments?: number,
+ *   miterLimit?: number
+ * }} options
+ * @returns {FlatMesh | null}
+ */
+export function buildFlatLayerMesh(layerId, features, options = {}) {
+  if (lineLayer(layerId)) {
+    return buildLineRibbonMesh(features, {
+      height: options.height ?? 0.8,
+      widthMeters: options.lineWidthMeters ?? defaultLineWidth(layerId),
+      join: options.join ?? defaultJoin(layerId),
+      cap: options.cap ?? defaultCap(layerId),
+      roundSegments: options.roundSegments ?? defaultRoundSegments(layerId),
+      miterLimit: options.miterLimit ?? DEFAULT_MITER_LIMIT
+    });
+  }
+
+  return buildPolygonSurfaceMesh(features, {
+    height: options.height ?? 0.2
+  });
+}
+
+/**
+ * @param {Array<{ geometry: Record<string, unknown> }>} features
+ * @param {{
+ *   height: number,
+ *   widthMeters: number,
+ *   join: 'miter' | 'bevel' | 'round',
+ *   cap: 'butt' | 'round',
+ *   roundSegments: number,
+ *   miterLimit: number
+ * }} options
+ * @returns {FlatMesh | null}
+ */
+function buildLineRibbonMesh(features, options) {
+  const positions = [];
+  const normals = [];
+  const bboxes = [];
+  let featureCount = 0;
+
+  for (const feature of features) {
+    const lines = linesFromGeometry(feature.geometry);
+    for (const line of lines) {
+      const clean = cleanLine(line);
+      if (clean.length < 2) {
+        continue;
+      }
+
+      const ribbon = buildContinuousRibbon(clean, options);
+      if (!ribbon) {
+        continue;
+      }
+      addRibbonPolygon(positions, normals, ribbon, options.height);
+
+      bboxes.push(expandBboxMeters(lineBbox(clean), options.widthMeters / 2));
+      featureCount++;
+    }
+  }
+
+  return finishMesh(positions, normals, bboxes, options.height, featureCount);
+}
+
+/**
+ * @param {Array<{ geometry: Record<string, unknown> }>} features
+ * @param {{ height: number }} options
+ * @returns {FlatMesh | null}
+ */
+export function buildPolygonSurfaceMesh(features, options) {
+  const positions = [];
+  const normals = [];
+  const indices = [];
+  const bboxes = [];
+  let featureCount = 0;
+
+  for (const feature of features) {
+    const polygons = polygonsFromGeometry(feature.geometry);
+    for (const polygon of polygons) {
+      const ring = cleanRing(polygon[0] ?? []);
+      if (ring.length < 3) {
+        continue;
+      }
+
+      const centroid = polygonCentroid(ring);
+      const projected = projectRing(ring, centroid);
+      const triangles = earcut(projected.flat, null, 2);
+      if (triangles.length === 0) {
+        continue;
+      }
+
+      const normal = wgs84SurfaceNormal(centroid[0], centroid[1]);
+      const ecef = ring.map(([lon, lat]) => wgs84ToEcef(lon, lat, options.height));
+      const vertexOffset = positions.length / 3;
+      for (const point of ecef) {
+        positions.push(...point);
+        normals.push(...normal);
+      }
+      for (const index of triangles) {
+        indices.push(vertexOffset + index);
+      }
+      bboxes.push(lineBbox(ring));
+      featureCount++;
+    }
+  }
+
+  return finishMesh(positions, normals, bboxes, options.height, featureCount, indices);
+}
+
+/**
+ * @param {number[]} positions
+ * @param {number[]} normals
+ * @param {[number, number][]} ribbon
+ * @param {number} height
+ */
+function addRibbonPolygon(positions, normals, ribbon, height) {
+  if (ribbon.length < 3) {
+    return;
+  }
+
+  const centroid = polygonCentroid(ribbon);
+  const projected = projectRing(ribbon, centroid);
+  const triangles = earcut(projected.flat, null, 2);
+  if (triangles.length === 0) {
+    return;
+  }
+
+  const normal = wgs84SurfaceNormal(centroid[0], centroid[1]);
+  const ecef = ribbon.map(([lon, lat]) => wgs84ToEcef(lon, lat, height));
+  for (let i = 0; i < triangles.length; i += 3) {
+    addTriangle(
+      positions,
+      normals,
+      ecef[triangles[i]],
+      ecef[triangles[i + 1]],
+      ecef[triangles[i + 2]],
+      normal
+    );
+  }
+}
+
+function addTriangle(positions, normals, a, b, c, normal) {
+  positions.push(...a, ...b, ...c);
+  normals.push(...normal, ...normal, ...normal);
+}
+
+function finishMesh(positions, normals, bboxes, height, featureCount, indices = []) {
+  if (positions.length === 0 || featureCount === 0) {
+    return null;
+  }
+
+  const positionArray = new Float32Array(positions);
+  const normalArray = new Float32Array(normals);
+  const indexArray = indices.length > 0
+    ? positionArray.length / 3 > 65535
+      ? new Uint32Array(indices)
+      : new Uint16Array(indices)
+    : new Uint16Array(0);
+  const bounds = minMaxVec3(positionArray);
+  return {
+    positions: positionArray,
+    normals: normalArray,
+    indices: indexArray,
+    min: bounds.min,
+    max: bounds.max,
+    bbox: mergeBboxes(bboxes),
+    maxHeight: height,
+    featureCount
+  };
+}
+
+function linesFromGeometry(geometry) {
+  if (geometry.type === 'LineString' && Array.isArray(geometry.coordinates)) {
+    return [geometry.coordinates];
+  }
+  if (geometry.type === 'MultiLineString' && Array.isArray(geometry.coordinates)) {
+    return geometry.coordinates;
+  }
+  if (geometry.type === 'Polygon' && Array.isArray(geometry.coordinates)) {
+    return [geometry.coordinates[0] ?? []];
+  }
+  if (geometry.type === 'MultiPolygon' && Array.isArray(geometry.coordinates)) {
+    return geometry.coordinates.map((polygon) => polygon[0] ?? []);
+  }
+  return [];
+}
+
+function polygonsFromGeometry(geometry) {
+  if (geometry.type === 'Polygon' && Array.isArray(geometry.coordinates)) {
+    return [geometry.coordinates];
+  }
+  if (geometry.type === 'MultiPolygon' && Array.isArray(geometry.coordinates)) {
+    return geometry.coordinates;
+  }
+  return [];
+}
+
+function cleanLine(line) {
+  return line
+    .map((point) => [Number(point?.[0]), Number(point?.[1])])
+    .filter(([lon, lat]) => Number.isFinite(lon) && Number.isFinite(lat));
+}
+
+function lineLayer(layerId) {
+  return layerId === 'roads' || layerId === 'railways' || layerId === 'boundaries';
+}
+
+function defaultLineWidth(layerId) {
+  if (layerId === 'roads') return 6;
+  if (layerId === 'railways') return 3;
+  return 2;
+}
+
+function defaultJoin(layerId) {
+  return layerId === 'boundaries' ? 'bevel' : DEFAULT_RIBBON_JOIN;
+}
+
+function defaultCap(layerId) {
+  return layerId === 'boundaries' ? 'butt' : DEFAULT_RIBBON_CAP;
+}
+
+function defaultRoundSegments(layerId) {
+  if (layerId === 'roads') return 5;
+  if (layerId === 'railways') return 4;
+  return 0;
+}
+
+/**
+ * @param {[number, number][]} line
+ * @param {{
+ *   widthMeters: number,
+ *   join: 'miter' | 'bevel' | 'round',
+ *   cap: 'butt' | 'round',
+ *   roundSegments: number,
+ *   miterLimit: number
+ * }} options
+ * @returns {[number, number][] | null}
+ */
+function buildContinuousRibbon(line, options) {
+  const local = toLocalLine(line);
+  const closed = local.closed;
+  const points = local.points;
+  if (points.length < 2) {
+    return null;
+  }
+
+  const half = options.widthMeters / 2;
+  /** @type {Array<[number, number]>} */
+  const left = [];
+  /** @type {Array<[number, number]>} */
+  const right = [];
+  const count = points.length;
+
+  for (let i = 0; i < count; i++) {
+    const current = points[i];
+    const prev = i > 0 ? points[i - 1] : closed ? points[count - 1] : null;
+    const next = i < count - 1 ? points[i + 1] : closed ? points[0] : null;
+
+    if (!prev || !next) {
+      const direction = next ? normalize2(sub2(next, current)) : normalize2(sub2(current, prev));
+      const normal = leftNormal(direction);
+      left.push(add2(current, scale2(normal, half)));
+      right.push(add2(current, scale2(normal, -half)));
+      continue;
+    }
+
+    const join = ribbonJoinPoints(prev, current, next, half, options);
+    left.push(...join.left);
+    right.push(...join.right);
+  }
+
+  if (!closed && options.cap === 'round' && options.roundSegments >= 3) {
+    const startArc = capArc(points[0], points[1], half, options.roundSegments, true);
+    const endArc = capArc(points[count - 1], points[count - 2], half, options.roundSegments, false);
+    return localPointsToLonLat([...left, ...endArc, ...right.reverse(), ...startArc], local);
+  }
+
+  return localPointsToLonLat([...left, ...right.reverse()], local);
+}
+
+function ribbonJoinPoints(prev, current, next, half, options) {
+  const inDir = normalize2(sub2(current, prev));
+  const outDir = normalize2(sub2(next, current));
+  if (length2(inDir) === 0 || length2(outDir) === 0) {
+    return {
+      left: [[current[0], current[1] + half]],
+      right: [[current[0], current[1] - half]]
+    };
+  }
+
+  const inNormal = leftNormal(inDir);
+  const outNormal = leftNormal(outDir);
+  const leftPrev = add2(current, scale2(inNormal, half));
+  const leftNext = add2(current, scale2(outNormal, half));
+  const rightPrev = add2(current, scale2(inNormal, -half));
+  const rightNext = add2(current, scale2(outNormal, -half));
+
+  const leftMiter = lineIntersection(leftPrev, inDir, leftNext, outDir);
+  const rightMiter = lineIntersection(rightPrev, inDir, rightNext, outDir);
+  const maxMiter = half * options.miterLimit;
+  const mild = leftMiter && rightMiter &&
+    distance2(leftMiter, current) <= maxMiter &&
+    distance2(rightMiter, current) <= maxMiter;
+
+  if (options.join === 'miter' || (options.join === 'round' && mild)) {
+    if (mild) {
+      return { left: [leftMiter], right: [rightMiter] };
+    }
+  }
+
+  if (options.join === 'round' && options.roundSegments >= 3) {
+    return {
+      left: arcAround(current, leftPrev, leftNext, options.roundSegments),
+      right: arcAround(current, rightNext, rightPrev, options.roundSegments)
+    };
+  }
+
+  return {
+    left: [leftPrev, leftNext],
+    right: [rightNext, rightPrev]
+  };
+}
+
+function capArc(endpoint, neighbor, half, segments, start) {
+  const dir = normalize2(sub2(endpoint, neighbor));
+  const normal = leftNormal(dir);
+  const a = add2(endpoint, scale2(normal, start ? -half : half));
+  const b = add2(endpoint, scale2(normal, start ? half : -half));
+  return arcAround(endpoint, a, b, Math.max(3, segments));
+}
+
+function arcAround(center, from, to, segments) {
+  const start = Math.atan2(from[1] - center[1], from[0] - center[0]);
+  let end = Math.atan2(to[1] - center[1], to[0] - center[0]);
+  while (end < start) {
+    end += Math.PI * 2;
+  }
+  if (end - start > Math.PI) {
+    end -= Math.PI * 2;
+  }
+
+  const steps = Math.max(1, Math.ceil(Math.abs(end - start) / Math.PI * segments));
+  const radius = distance2(from, center);
+  const points = [];
+  for (let i = 0; i <= steps; i++) {
+    const t = i / steps;
+    const angle = start + (end - start) * t;
+    points.push([
+      center[0] + Math.cos(angle) * radius,
+      center[1] + Math.sin(angle) * radius
+    ]);
+  }
+  return points;
+}
+
+function toLocalLine(line) {
+  const closed = line.length > 2 && samePoint(line[0], line[line.length - 1]);
+  const points = closed ? line.slice(0, -1) : line;
+  const origin = polygonCentroid(points);
+  const meanLat = origin[1] * Math.PI / 180;
+  const metersPerLon = Math.max(1, 111320 * Math.cos(meanLat));
+  const metersPerLat = 110540;
+  return {
+    origin,
+    metersPerLon,
+    metersPerLat,
+    closed,
+    points: points.map(([lon, lat]) => [
+      (lon - origin[0]) * metersPerLon,
+      (lat - origin[1]) * metersPerLat
+    ])
+  };
+}
+
+function localPointsToLonLat(points, local) {
+  return points.map(([x, y]) => [
+    local.origin[0] + x / local.metersPerLon,
+    local.origin[1] + y / local.metersPerLat
+  ]);
+}
+
+function lineIntersection(pointA, dirA, pointB, dirB) {
+  const cross = cross2(dirA, dirB);
+  if (Math.abs(cross) < 1e-6) {
+    return null;
+  }
+
+  const diff = sub2(pointB, pointA);
+  const t = cross2(diff, dirB) / cross;
+  return add2(pointA, scale2(dirA, t));
+}
+
+function samePoint(a, b) {
+  return Math.abs(a[0] - b[0]) < 1e-12 && Math.abs(a[1] - b[1]) < 1e-12;
+}
+
+function add2(a, b) {
+  return [a[0] + b[0], a[1] + b[1]];
+}
+
+function sub2(a, b) {
+  return [a[0] - b[0], a[1] - b[1]];
+}
+
+function scale2(a, scale) {
+  return [a[0] * scale, a[1] * scale];
+}
+
+function length2(a) {
+  return Math.hypot(a[0], a[1]);
+}
+
+function distance2(a, b) {
+  return Math.hypot(a[0] - b[0], a[1] - b[1]);
+}
+
+function normalize2(a) {
+  const length = length2(a);
+  return length > 0 ? [a[0] / length, a[1] / length] : [0, 0];
+}
+
+function leftNormal(direction) {
+  return [-direction[1], direction[0]];
+}
+
+function cross2(a, b) {
+  return a[0] * b[1] - a[1] * b[0];
+}
+
+function projectRing(points, centroid) {
+  const meanLat = centroid[1] * Math.PI / 180;
+  const metersPerLon = Math.max(1, 111320 * Math.cos(meanLat));
+  const metersPerLat = 110540;
+  const flat = [];
+  for (const [lon, lat] of points) {
+    flat.push((lon - centroid[0]) * metersPerLon, (lat - centroid[1]) * metersPerLat);
+  }
+  return { flat };
+}
+
+function polygonCentroid(points) {
+  let lon = 0;
+  let lat = 0;
+  for (const point of points) {
+    lon += point[0];
+    lat += point[1];
+  }
+  return [lon / points.length, lat / points.length];
+}
+
+function lineBbox(points) {
+  let minLon = Infinity;
+  let minLat = Infinity;
+  let maxLon = -Infinity;
+  let maxLat = -Infinity;
+  for (const [lon, lat] of points) {
+    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];
+}
+
+function expandBboxMeters(bbox, meters) {
+  const meanLat = ((bbox[1] + bbox[3]) / 2) * Math.PI / 180;
+  const metersPerLon = Math.max(1, 111320 * Math.cos(meanLat));
+  const lonPad = meters / metersPerLon;
+  const latPad = meters / 110540;
+  return [
+    bbox[0] - lonPad,
+    bbox[1] - latPad,
+    bbox[2] + lonPad,
+    bbox[3] + latPad
+  ];
+}
+
+function mergeBboxes(bboxes) {
+  let minLon = Infinity;
+  let minLat = Infinity;
+  let maxLon = -Infinity;
+  let maxLat = -Infinity;
+  for (const bbox of bboxes) {
+    minLon = Math.min(minLon, bbox[0]);
+    minLat = Math.min(minLat, bbox[1]);
+    maxLon = Math.max(maxLon, bbox[2]);
+    maxLat = Math.max(maxLat, bbox[3]);
+  }
+  return [minLon, minLat, maxLon, maxLat];
+}
+
+function minMaxVec3(positions) {
+  const min = [Infinity, Infinity, Infinity];
+  const max = [-Infinity, -Infinity, -Infinity];
+  for (let i = 0; i < positions.length; i += 3) {
+    min[0] = Math.min(min[0], positions[i]);
+    min[1] = Math.min(min[1], positions[i + 1]);
+    min[2] = Math.min(min[2], positions[i + 2]);
+    max[0] = Math.max(max[0], positions[i]);
+    max[1] = Math.max(max[1], positions[i + 1]);
+    max[2] = Math.max(max[2], positions[i + 2]);
+  }
+  return { min, max };
+}

package/src/3dtiles/glb.js

@@ -0,0 +1,178 @@
+/**
+ * @typedef {{
+ *   positions: Float32Array,
+ *   normals?: Float32Array,
+ *   indices: Uint16Array | Uint32Array,
+ *   min: [number, number, number],
+ *   max: [number, number, number]
+ * }} Mesh
+ */
+
+/**
+ * Build a minimal unlit GLB for one merged mesh.
+ *
+ * @param {Mesh} mesh
+ * @param {{ color?: [number, number, number, number], generator?: string, includeNormals?: boolean }} [options]
+ * @returns {Buffer}
+ */
+export function buildGlbFromMesh(mesh, options = {}) {
+  const chunks = [];
+  const bufferViews = [];
+  const accessors = [];
+  const attributes = {};
+
+  const positionView = appendBuffer(chunks, bufferFromTypedArray(mesh.positions), 4);
+  bufferViews.push({ buffer: 0, byteOffset: positionView.byteOffset, byteLength: positionView.byteLength, target: 34962 });
+  attributes.POSITION = accessors.length;
+  accessors.push({
+    bufferView: bufferViews.length - 1,
+    byteOffset: 0,
+    componentType: 5126,
+    count: mesh.positions.length / 3,
+    type: 'VEC3',
+    min: mesh.min,
+    max: mesh.max
+  });
+
+  const includeNormals = options.includeNormals === true
+    && mesh.normals
+    && mesh.normals.length === mesh.positions.length;
+  if (includeNormals) {
+    const normalView = appendBuffer(chunks, bufferFromTypedArray(mesh.normals), 4);
+    bufferViews.push({ buffer: 0, byteOffset: normalView.byteOffset, byteLength: normalView.byteLength, target: 34962 });
+    attributes.NORMAL = accessors.length;
+    accessors.push({
+      bufferView: bufferViews.length - 1,
+      byteOffset: 0,
+      componentType: 5126,
+      count: mesh.normals.length / 3,
+      type: 'VEC3'
+    });
+  }
+
+  const hasIndices = mesh.indices.length > 0;
+  let indexAccessor = null;
+  if (hasIndices) {
+    const indexView = appendBuffer(chunks, bufferFromTypedArray(mesh.indices), 4);
+    bufferViews.push({ buffer: 0, byteOffset: indexView.byteOffset, byteLength: indexView.byteLength, target: 34963 });
+    indexAccessor = accessors.length;
+    accessors.push({
+      bufferView: bufferViews.length - 1,
+      byteOffset: 0,
+      componentType: mesh.indices instanceof Uint32Array ? 5125 : 5123,
+      count: mesh.indices.length,
+      type: 'SCALAR'
+    });
+  }
+
+  const bin = Buffer.concat(chunks);
+  const primitive = {
+    attributes,
+    material: 0
+  };
+  if (indexAccessor !== null) {
+    primitive.indices = indexAccessor;
+  }
+
+  const gltf = {
+    asset: {
+      version: '2.0',
+      generator: options.generator ?? 'map-zero'
+    },
+    extensionsUsed: ['KHR_materials_unlit'],
+    scene: 0,
+    scenes: [{ nodes: [0] }],
+    nodes: [{ mesh: 0 }],
+    meshes: [{
+      primitives: [primitive]
+    }],
+    materials: [{
+      pbrMetallicRoughness: {
+        baseColorFactor: options.color ?? [0, 1, 1, 1],
+        metallicFactor: 0,
+        roughnessFactor: 1
+      },
+      extensions: {
+        KHR_materials_unlit: {}
+      },
+      doubleSided: true
+    }],
+    buffers: [{ byteLength: bin.length }],
+    bufferViews,
+    accessors
+  };
+
+  return buildGlb(gltf, bin);
+}
+
+/**
+ * @param {ArrayBufferView} typedArray
+ * @returns {Buffer}
+ */
+function bufferFromTypedArray(typedArray) {
+  return Buffer.from(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength);
+}
+
+/**
+ * @param {Record<string, unknown>} gltf
+ * @param {Buffer} binBuffer
+ * @returns {Buffer}
+ */
+export function buildGlb(gltf, binBuffer) {
+  const jsonChunk = padBuffer(Buffer.from(JSON.stringify(gltf), 'utf8'), 4, 0x20);
+  const binChunk = padBuffer(binBuffer, 4, 0);
+  const totalLength = 12 + 8 + jsonChunk.length + 8 + binChunk.length;
+  const header = Buffer.alloc(12);
+  header.writeUInt32LE(0x46546c67, 0);
+  header.writeUInt32LE(2, 4);
+  header.writeUInt32LE(totalLength, 8);
+  const jsonHeader = Buffer.alloc(8);
+  jsonHeader.writeUInt32LE(jsonChunk.length, 0);
+  jsonHeader.writeUInt32LE(0x4e4f534a, 4);
+  const binHeader = Buffer.alloc(8);
+  binHeader.writeUInt32LE(binChunk.length, 0);
+  binHeader.writeUInt32LE(0x004e4942, 4);
+  return Buffer.concat([header, jsonHeader, jsonChunk, binHeader, binChunk]);
+}
+
+/**
+ * @param {Buffer[]} chunks
+ * @param {Buffer} buffer
+ * @param {number} alignment
+ * @returns {{ byteOffset: number, byteLength: number }}
+ */
+function appendBuffer(chunks, buffer, alignment) {
+  const byteOffset = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const paddedOffset = align(byteOffset, alignment);
+  if (paddedOffset > byteOffset) {
+    chunks.push(Buffer.alloc(paddedOffset - byteOffset));
+  }
+
+  chunks.push(buffer);
+  return {
+    byteOffset: paddedOffset,
+    byteLength: buffer.length
+  };
+}
+
+/**
+ * @param {Buffer} buffer
+ * @param {number} alignment
+ * @param {number} fill
+ * @returns {Buffer}
+ */
+function padBuffer(buffer, alignment, fill) {
+  const targetLength = align(buffer.length, alignment);
+  return targetLength === buffer.length
+    ? buffer
+    : Buffer.concat([buffer, Buffer.alloc(targetLength - buffer.length, fill)]);
+}
+
+/**
+ * @param {number} value
+ * @param {number} alignment
+ * @returns {number}
+ */
+function align(value, alignment) {
+  return Math.ceil(value / alignment) * alignment;
+}