@math.gl/geospatial 5.0.0-alpha.2 → 5.0.0-alpha.20

package/src/discontinuous/petroff.ts

@@ -0,0 +1,178 @@
+// math.gl
+// SPDX-License-Identifier: MIT AND CC0-1.0
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: 2020 Matthew A. Petroff
+// SPDX-FileComment: Adapted from new_projection.py, Zenodo 4661351 (CC0). See PETROFF-LICENSE.txt. Scalar TypeScript, boundary limits, and MapEngine chart assembly added by math.gl.
+
+import {DiscontinuousMap, type MapRegion} from './map-layout';
+import {RAD, geographic, coordinates, add, unit, angle, type Position} from './math';
+import type {QuincuncialMapOptions} from './quincuncial-star';
+const PI = Math.PI,
+  HALF = PI / 2;
+const clamp = (x: number) => Math.max(-1, Math.min(1, x));
+const acos = (x: number) => Math.acos(clamp(x));
+const asin = (x: number) => Math.asin(clamp(x));
+const sqrt = (x: number) => Math.sqrt(Math.max(0, x));
+const phi0 = (3 * PI) / 8,
+  s0 = Math.sin(phi0),
+  c0 = Math.cos(phi0);
+const psi0 = asin(1 / Math.sqrt(2 - c0 * c0)),
+  psi1 = PI - 2 * psi0;
+const f0 = asin((2 * s0) / Math.sqrt(3 - Math.cos(2 * phi0)));
+const h = (12 / PI) * (psi0 + f0 - HALF);
+const xi = Math.atan(
+  (PI * (h - 3) ** 2) / (Math.sqrt(3) * (PI * (h * h - 2 * h + 45) - 96 * psi0 - 48 * f0))
+);
+const psi0p = Math.atan(Math.sqrt(3) / h),
+  psi1p = (7 * PI) / 6 - psi0p - xi,
+  psi2p = xi - PI / 6;
+const wrap = (x: number) => ((((x + PI) % (2 * PI)) + 2 * PI) % (2 * PI)) - PI;
+function section(theta: number, planar = false) {
+  const index =
+    theta <= (planar ? psi0p : psi0) ? 0 : theta <= (planar ? psi0p + psi1p : psi0 + psi1) ? 1 : 2;
+  return {
+    index,
+    c: index < 2 ? acos(c0 / Math.SQRT2) : HALF - phi0,
+    G: index === 1 ? psi1 : psi0,
+    Gp: [psi0p, psi1p, psi2p][index],
+    F: [f0, HALF - f0, PI / 4][index],
+    ap:
+      index === 0
+        ? h
+        : (Math.sqrt(h * h + 3) * Math.sin(PI / 3 - Math.atan(h / Math.sqrt(3)))) / Math.sin(xi),
+    cp: index < 2 ? Math.sqrt(h * h + 3) : 3 - h,
+    b: [
+      PI / 4,
+      Math.atan(Math.SQRT2 * Math.tan(phi0)),
+      HALF - Math.atan(Math.SQRT2 * Math.tan(phi0))
+    ][index]
+  };
+}
+/** Published polar quincuncial aspect; local longitude is measured from a quadrant's center. */
+export function petroffForward(
+  lambda: number,
+  phi: number,
+  quadrant: number,
+  south: boolean
+): Position {
+  const zeta = PI / 4 + quadrant * HALF;
+  const finish = (xc: number, yc: number): Position => {
+    const yh = (south ? -yc : yc) - 3;
+    return [
+      (xc * Math.cos(zeta) - (yh * Math.sin(zeta)) / Math.sqrt(3)) / Math.sqrt(6),
+      (xc * Math.sin(zeta) + (yh * Math.cos(zeta)) / Math.sqrt(3)) / Math.sqrt(6)
+    ];
+  };
+  if (Math.abs(phi) >= HALF - 1e-14) return finish(0, 3);
+  const delta = wrap(lambda - zeta),
+    latitude = Math.abs(phi);
+  const theta = Math.abs(
+    Math.atan2(
+      Math.cos(latitude) * Math.sin(delta),
+      s0 * Math.cos(latitude) * Math.cos(delta) - c0 * Math.sin(latitude)
+    )
+  );
+  const point = geographic([Math.abs(delta) / RAD, latitude / RAD]);
+  const r = angle(geographic([0, phi0 / RAD]), point);
+  if (r < 1e-14) return finish(0, h);
+  const {index, c, G, Gp, F, ap, cp} = section(theta);
+  const beta = index === 0 ? psi0 - theta : index === 1 ? theta - psi0 : PI - theta;
+  // Great-circle distance is well conditioned even at a section vertex.
+  const vertex = geographic(index < 2 ? [45, 0] : [0, 90]);
+  const x = angle(point, vertex);
+  if (x < 1e-14) {
+    // The section's vertex. Evaluate its known Cartesian limit.
+    const tp = index === 0 ? Gp : index === 1 ? PI - psi2p - Gp : PI - psi2p + Gp;
+    return finish(Math.sign(delta) * cp * Math.sin(tp), h - cp * Math.cos(tp));
+  }
+  const gamma = asin((Math.sin(beta) * Math.sin(r)) / Math.sin(x));
+  const epsilon = acos(Math.sin(G) * Math.sin(gamma) * Math.cos(c) - Math.cos(G) * Math.cos(gamma));
+  const up = (ap * (gamma + G + epsilon - PI)) / (F + G - HALF);
+  const cosxy = sqrt(1 - ((Math.sin(G) * Math.sin(c)) / Math.sin(epsilon)) ** 2);
+  const ratio = (Math.SQRT2 * Math.sin(x / 2)) / sqrt(1 - cosxy);
+  const length = sqrt(up * up + cp * cp - 2 * up * cp * Math.cos(Gp));
+  const sg = (up * Math.sin(Gp)) / length;
+  const cg = (cp - up * Math.cos(Gp)) / length;
+  const xp = length * ratio;
+  const transverse = xp * sg,
+    axial = cp - xp * cg;
+  const rp = Math.hypot(transverse, axial);
+  const alpha = Gp - Math.atan2(transverse, axial);
+  let tp = index === 0 ? alpha : index === 1 ? PI - psi2p - alpha : PI - psi2p + alpha;
+  if (Math.abs(delta) < 1e-14) tp = latitude < phi0 ? 0 : PI;
+  return finish(Math.sign(delta) * rp * Math.sin(tp), h - rp * Math.cos(tp));
+}
+function inverse(x: number, y: number, quadrant: number, south: boolean): Position | null {
+  const zeta = PI / 4 + quadrant * HALF;
+  const xc = Math.sqrt(6) * (x * Math.cos(zeta) + y * Math.sin(zeta));
+  const yc = 3 * Math.SQRT2 * (y * Math.cos(zeta) - x * Math.sin(zeta));
+  const yh = south ? -6 - yc : yc;
+  if (Math.abs(xc) < 1e-12 && Math.abs(yh) < 1e-12) return [zeta, south ? -HALF : HALF];
+  const rp = Math.hypot(xc, h - 3 - yh);
+  if (rp < 1e-12) return [zeta, south ? -phi0 : phi0];
+  const tp = Math.abs(Math.atan2(xc, h - 3 - yh));
+  const {index, c, G, Gp, F, ap, cp, b} = section(tp, true);
+  const alpha = index === 0 ? tp : index === 1 ? PI - psi2p - tp : tp + psi2p - PI;
+  const beta = Gp - alpha;
+  const xp = sqrt(rp * rp + cp * cp - 2 * rp * cp * Math.cos(beta));
+  const gp = xp > 1e-14 ? asin((rp * Math.sin(beta)) / xp) : 0;
+  const ep = PI - Gp - gp;
+  const yp = ep > 1e-14 ? (rp * Math.sin(alpha)) / Math.sin(ep) : 0;
+  const up = sqrt(cp * cp + (xp + yp) ** 2 - 2 * cp * (xp + yp) * Math.cos(gp));
+  const vp = ap - up;
+  const angle = (vp * (F + G - HALF)) / ap;
+  const delta = Math.atan(-Math.sin(angle) / (Math.cos(b) - Math.cos(angle)));
+  const gamma = F - delta;
+  const cosxy = 1 / Math.sqrt(1 + (Math.tan(b) / Math.cos(delta)) ** 2);
+  const arc = acos(1 - (xp / (xp + yp)) ** 2 * (1 - cosxy));
+  // atan2 retains the tiny tangent components near the section center;
+  // acos(cos(r)) rounds to zero there and makes the old sine ratio 0/0.
+  const transverse = Math.sin(arc) * Math.sin(gamma);
+  const axial = Math.cos(arc) * Math.sin(c) - Math.sin(arc) * Math.cos(c) * Math.cos(gamma);
+  const cosine = Math.cos(arc) * Math.cos(c) + Math.sin(arc) * Math.sin(c) * Math.cos(gamma);
+  const r = Math.atan2(Math.hypot(transverse, axial), cosine);
+  const bt = Math.atan2(transverse, axial);
+  const az = index === 0 ? psi0 - bt : index === 1 ? psi0 + bt : PI - bt;
+  const lat = asin(s0 * Math.cos(r) - c0 * Math.sin(r) * Math.cos(az));
+  const lon =
+    zeta +
+    Math.sign(xc) * Math.atan2(Math.sin(az) * Math.sin(r) * c0, Math.cos(r) - s0 * Math.sin(lat));
+  return [lon, south ? -lat : lat];
+}
+
+/** Petroff's 2021 equal-area square, north pole at center and south pole at corners. */
+export function createPetroffMap(options: QuincuncialMapOptions = {}) {
+  const {radius = 1, centralMeridian = 0} = options;
+  if (!Number.isFinite(radius) || radius <= 0 || !Number.isFinite(centralMeridian))
+    throw new Error('Expected positive finite radius and finite centralMeridian');
+  const offset = wrap(centralMeridian * RAD);
+  const rotate = ([lon, lat]: Position, direction: number): Position => [
+    wrap(lon * RAD + offset * direction) / RAD,
+    lat
+  ];
+  const charts: MapRegion[] = [];
+  for (let quadrant = 0; quadrant < 4; quadrant++)
+    for (const south of [false, true]) {
+      const boundary: Position[] = [
+        [quadrant * 90, 0],
+        [(quadrant + 1) * 90, 0],
+        [quadrant * 90 + 45, south ? -90 : 90]
+      ];
+      charts.push({
+        id: `${south ? 'south' : 'north'}-${quadrant}`,
+        boundary: boundary.map(p => rotate(p, 1)),
+        interior: rotate(coordinates(unit(boundary.map(geographic).reduce(add, [0, 0, 0]))), 1),
+        placement: [radius, 0, 0, radius, 0, 0],
+        project: p => {
+          const [lon, lat] = rotate([...p], -1);
+          return petroffForward(lon * RAD, lat * RAD, quadrant, south);
+        },
+        unproject: p => {
+          if (Math.abs(p[0]) > 1 + 1e-9 || Math.abs(p[1]) > 1 + 1e-9) return null;
+          const q = inverse(p[0], p[1], quadrant, south);
+          return q && q.every(Number.isFinite) ? rotate([q[0] / RAD, q[1] / RAD], 1) : null;
+        }
+      });
+    }
+  return new DiscontinuousMap(charts);
+}

package/src/discontinuous/polyhedral.ts

@@ -0,0 +1,138 @@
+// math.gl
+// SPDX-License-Identifier: MIT AND ISC
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright 2013-2021 Mike Bostock
+
+// Octahedral topology, Waterman W5 construction, and parent tree follow
+// d3-geo-projection (Mike Bostock, ISC; see D3-LICENSE.txt). Chart construction
+// and seam handling use math.gl's spherical map pipeline.
+import {DiscontinuousMap, type MapRegion, type MapPlacement} from './map-layout';
+import {
+  add,
+  scale,
+  unit,
+  dot,
+  cross,
+  coordinates,
+  geographic,
+  RAD,
+  type Position,
+  type Vector
+} from './math';
+
+export type PolyhedralMapOptions = {radius?: number};
+export function createButterflyMap(options: PolyhedralMapOptions = {}) {
+  return polyhedral('butterfly', options);
+}
+export function createCollignonButterflyMap(options: PolyhedralMapOptions = {}) {
+  return polyhedral('collignon', options);
+}
+export function createWatermanMap(options: PolyhedralMapOptions = {}) {
+  return polyhedral('waterman', options);
+}
+function polyhedral(
+  kind: 'butterfly' | 'collignon' | 'waterman',
+  {radius = 1}: PolyhedralMapOptions
+) {
+  if (!Number.isFinite(radius) || radius <= 0)
+    throw new Error('Radius must be finite and positive');
+  const vertices: Position[] = [
+    [0, 90],
+    [-90, 0],
+    [0, 0],
+    [90, 0],
+    [180, 0],
+    [0, -90]
+  ];
+  const octahedron = [
+    [0, 2, 1],
+    [0, 3, 2],
+    [5, 1, 2],
+    [5, 2, 3],
+    [0, 1, 4],
+    [0, 4, 3],
+    [5, 4, 1],
+    [5, 3, 4]
+  ].map(face => face.map(i => geographic(vertices[i])));
+  const parents = [-1, 0, 0, 1, 0, 1, 4, 5];
+  let faces = octahedron;
+  if (kind === 'waterman') {
+    faces = octahedron.map(face =>
+      face.flatMap((b, i) => {
+        const a = face[(i + 2) % 3];
+        return [unit(add(scale(a, 3), b)), unit(add(scale(b, 3), a))];
+      })
+    );
+    for (let j = 0; j < 8; j++)
+      for (let i = 0; i < 3; i++) {
+        faces.push([octahedron[j][i], faces[j][(i * 2 + 2) % 6], faces[j][i * 2 + 1]]);
+        parents.push(j);
+      }
+  }
+  const charts = faces.map((face, i): MapRegion => {
+    const center = unit(face.reduce(add, [0, 0, 0]));
+    let project: MapRegion['project'], unproject: MapRegion['unproject'];
+    if (kind === 'collignon') {
+      const [longitude, latitude] = coordinates(center);
+      const sign = Math.sign(latitude);
+      const k = 4 / Math.sqrt(3 * Math.PI);
+      project = ([lon, lat]) => {
+        const delta = (((((lon - longitude + 180) % 360) + 360) % 360) - 180) * RAD;
+        const t = Math.sqrt(Math.max(0, 1 - Math.sin(sign * lat * RAD)));
+        return [k * delta * t, sign * Math.sqrt(Math.PI) * (1 - t)];
+      };
+      unproject = ([x, y]) => {
+        const t = 1 - (sign * y) / Math.sqrt(Math.PI);
+        if (t < -1e-10 || t > Math.SQRT2 + 1e-10) return null;
+        return [
+          longitude + (t > 1e-12 ? x / (k * t * RAD) : 0),
+          (sign * Math.asin(Math.max(-1, Math.min(1, 1 - t * t)))) / RAD
+        ];
+      };
+    } else {
+      const normal = kind === 'waterman' && face.length === 3 ? face[0] : center;
+      const [lon] = coordinates(normal);
+      const east: Vector = [-Math.sin(lon * RAD), Math.cos(lon * RAD), 0];
+      const north = cross(normal, east);
+      project = position => {
+        const p = geographic(position),
+          h = dot(normal, p);
+        return [dot(east, p) / h, dot(north, p) / h];
+      };
+      unproject = ([x, y]) => coordinates(unit(add(normal, add(scale(east, x), scale(north, y)))));
+    }
+    return {
+      id: `face-${i}`,
+      boundary: face.map(coordinates),
+      interior: coordinates(center),
+      project,
+      unproject
+    };
+  });
+  // Align each child to its shared edge with a similarity transform. Local
+  // charts have the same orientation, so adjacent interiors lie on opposite sides.
+  const placements: MapPlacement[] = [];
+  const a = Math.cos(Math.PI / 6) * radius,
+    b = -Math.sin(Math.PI / 6) * radius;
+  placements[0] = [a, b, -b, a, 0, 0];
+  const place = (i: number, [x, y]: Position): Position => {
+    const [a, b, c, d, tx, ty] = placements[i];
+    return [a * x + c * y + tx, b * x + d * y + ty];
+  };
+  for (let i = 1; i < faces.length; i++) {
+    const parent = parents[i];
+    const shared = faces[i].filter(v =>
+      faces[parent].some(w => Math.hypot(...v.map((x, k) => x - w[k])) < 1e-10)
+    );
+    if (shared.length !== 2) throw new Error('Invalid polyhedral join');
+    const [p, q] = shared.map(v => charts[i].project(coordinates(v)));
+    const [u, v] = shared.map(w => place(parent, charts[parent].project(coordinates(w))));
+    const dx = q[0] - p[0],
+      dy = q[1] - p[1],
+      length = dx * dx + dy * dy;
+    const a = ((v[0] - u[0]) * dx + (v[1] - u[1]) * dy) / length;
+    const b = ((v[1] - u[1]) * dx - (v[0] - u[0]) * dy) / length;
+    placements[i] = [a, b, -b, a, u[0] - a * p[0] + b * p[1], u[1] - b * p[0] - a * p[1]];
+  }
+  return new DiscontinuousMap(charts.map((chart, i) => ({...chart, placement: placements[i]})));
+}

package/src/discontinuous/prepare-features.ts

@@ -0,0 +1,239 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import type {MapEngine} from './map-engine';
+import type {GeographicPosition, MapSamplingOptions} from './map-layout';
+
+/** Two-dimensional GeoJSON geometry shapes. Positions are validated as lon/lat pairs. */
+export type MapFeatureGeometry =
+  | {type: 'Point'; coordinates: readonly number[]}
+  | {type: 'MultiPoint' | 'LineString'; coordinates: readonly (readonly number[])[]}
+  | {type: 'MultiLineString' | 'Polygon'; coordinates: readonly (readonly (readonly number[])[])[]}
+  | {type: 'MultiPolygon'; coordinates: readonly (readonly (readonly (readonly number[])[])[])[]}
+  | {type: 'GeometryCollection'; geometries: readonly MapFeatureGeometry[]};
+/** Properties remain with the caller; output parts address this array by featureIndex. */
+export type MapFeature = {
+  type?: 'Feature';
+  id?: string | number;
+  geometry: MapFeatureGeometry | null;
+  properties?: unknown;
+};
+/** Original feature/component identity and the chart owning one generated part. */
+export type PreparedMapPart = {
+  featureIndex: number;
+  /** Indices through GeometryCollection.geometries and multipart coordinates. */
+  geometryPath: number[];
+  regionIndex: number;
+};
+/** Only original line or polygon-boundary segments occur in the path batch. */
+export type PreparedMapPathPart = PreparedMapPart & {
+  role: 'line' | 'polygon-outline';
+  /** Original input ring index (outer = 0), only for polygon outlines. */
+  ringIndex?: number;
+  /** A complete closed ring; cut fragments remain open. */
+  closed: boolean;
+};
+/** XY in map units and corresponding longitude/latitude, both interleaved pairs. */
+export type PreparedMapVertices = {
+  positions: Float64Array;
+  sourcePositions: Float64Array;
+};
+/** Packed, structured-cloneable geometry. All offsets count vertices or rings, not scalars. */
+export type PreparedMapGeometry = {
+  version: 1;
+  mapId: string;
+  /** Optional application IDs; featureIndex remains authoritative, including duplicate IDs. */
+  featureIds: (string | number | null)[];
+  regionIds: string[];
+  /** One vertex per part. Point ownership follows MapEngine.projectPoint(). */
+  points: PreparedMapVertices & {parts: PreparedMapPart[]};
+  paths: PreparedMapVertices & {parts: PreparedMapPathPart[]; pathStarts: Uint32Array};
+  polygons: PreparedMapVertices & {
+    parts: PreparedMapPart[];
+    /** Vertex offsets for all rings, with a terminal sentinel. Rings repeat their first vertex. */
+    ringStarts: Uint32Array;
+    /** Ring offsets for polygon parts, with a terminal sentinel. Outer ring comes first. */
+    polygonStarts: Uint32Array;
+  };
+};
+/** Static preparation controls. This does not triangulate, interpolate attributes or pose meshes. */
+export type MapPrepareFeaturesOptions = {
+  sampling?: MapSamplingOptions;
+  /** Project original polygon boundaries separately; default true. */
+  polygonOutlines?: boolean;
+};
+
+type Vertices = {positions: number[]; sourcePositions: number[]};
+const vertices = (): Vertices => ({positions: [], sourcePositions: []});
+const pack = (v: Vertices): PreparedMapVertices => ({
+  positions: new Float64Array(v.positions),
+  sourcePositions: new Float64Array(v.sourcePositions)
+});
+function append(
+  v: Vertices,
+  xy: readonly GeographicPosition[],
+  source: readonly GeographicPosition[]
+) {
+  if (xy.length !== source.length) throw new Error('Mismatched map source coordinates');
+  if (v.positions.length / 2 + xy.length >= 0xffffffff)
+    throw new Error('Map geometry exceeds Uint32 offsets');
+  for (let i = 0; i < xy.length; i++) {
+    if (!xy[i].every(Number.isFinite) || !source[i].every(Number.isFinite))
+      throw new Error('Non-finite map geometry');
+    v.positions.push(xy[i][0], xy[i][1]);
+    v.sourcePositions.push(source[i][0], source[i][1]);
+  }
+}
+function position(p: readonly number[]): GeographicPosition {
+  if (!Array.isArray(p) || p.length !== 2 || !p.every(Number.isFinite) || Math.abs(p[1]) > 90)
+    throw new Error('Expected two-dimensional longitude/latitude positions');
+  return [p[0], p[1]];
+}
+function closed(line: readonly GeographicPosition[]): boolean {
+  if (line.length < 4) return false;
+  const a = line[0],
+    b = line[line.length - 1];
+  return a[0] === b[0] && a[1] === b[1];
+}
+
+/** Internal implementation of MapEngine.prepareFeatures; no renderer dependencies. */
+export function prepareMapFeatures(
+  map: MapEngine,
+  features: readonly MapFeature[],
+  options: MapPrepareFeaturesOptions = {}
+): PreparedMapGeometry {
+  if (!Array.isArray(features)) throw new Error('Expected a feature array');
+  if (options.polygonOutlines !== undefined && typeof options.polygonOutlines !== 'boolean')
+    throw new Error('polygonOutlines must be boolean');
+  const regionIds = map.regions.map(r => r.id),
+    regionIndices = new Map(regionIds.map((id, i) => [id, i]));
+  const points = vertices(),
+    paths = vertices(),
+    polygons = vertices();
+  const pointParts: PreparedMapPart[] = [],
+    pathParts: PreparedMapPathPart[] = [],
+    polygonParts: PreparedMapPart[] = [];
+  const pathStarts = [0],
+    ringStarts = [0],
+    polygonStarts = [0];
+  const featureIds: PreparedMapGeometry['featureIds'] = [];
+  const part = (
+    featureIndex: number,
+    geometryPath: number[],
+    regionId: string
+  ): PreparedMapPart => {
+    const regionIndex = regionIndices.get(regionId);
+    if (regionIndex === undefined) throw new Error('Unknown prepared map region');
+    return {featureIndex, geometryPath: [...geometryPath], regionIndex};
+  };
+  const addLine = (
+    input: readonly (readonly number[])[],
+    featureIndex: number,
+    geometryPath: number[],
+    ringIndex?: number
+  ) => {
+    const line = input.map(position);
+    if (!line.length) return;
+    if (line.length < 2) throw new Error('A line needs at least two positions');
+    const isRing = ringIndex !== undefined;
+    if (isRing && !closed(line)) line.push([...line[0]]);
+    for (const p of map.projectLine(line, options.sampling)) {
+      append(paths, p.coordinates, p.sourceCoordinates);
+      pathParts.push({
+        ...part(featureIndex, geometryPath, p.regionId),
+        role: isRing ? 'polygon-outline' : 'line',
+        ...(isRing ? {ringIndex} : {}),
+        closed: closed(p.sourceCoordinates) && closed(p.coordinates)
+      });
+      pathStarts.push(paths.positions.length / 2);
+    }
+  };
+  const addPolygon = (
+    input: readonly (readonly (readonly number[])[])[],
+    featureIndex: number,
+    geometryPath: number[]
+  ) => {
+    if (!input.length) return;
+    const rings = input.map(r => r.map(position));
+    for (const p of map.projectPolygon(rings, options.sampling)) {
+      for (let i = 0; i < p.coordinates.length; i++) {
+        append(polygons, p.coordinates[i], p.sourceCoordinates[i]);
+        ringStarts.push(polygons.positions.length / 2);
+      }
+      polygonParts.push(part(featureIndex, geometryPath, p.regionId));
+      polygonStarts.push(ringStarts.length - 1);
+    }
+    if (options.polygonOutlines !== false)
+      rings.forEach((r, i) => addLine(r, featureIndex, geometryPath, i));
+  };
+  const visit = (
+    geometry: MapFeatureGeometry,
+    featureIndex: number,
+    path: number[],
+    depth: number
+  ) => {
+    if (depth > 64) throw new Error('Geometry collections are too deeply nested');
+    if (!geometry || typeof geometry !== 'object') throw new Error('Invalid feature geometry');
+    switch (geometry.type) {
+      case 'Point': {
+        const source = position(geometry.coordinates),
+          hit = map.projectPoint(source);
+        if (hit) {
+          append(points, [hit.position], [source]);
+          pointParts.push(part(featureIndex, path, hit.regionId));
+        }
+        break;
+      }
+      case 'MultiPoint':
+        geometry.coordinates.forEach((p, i) =>
+          visit({type: 'Point', coordinates: p}, featureIndex, [...path, i], depth)
+        );
+        break;
+      case 'LineString':
+        addLine(geometry.coordinates, featureIndex, path);
+        break;
+      case 'MultiLineString':
+        geometry.coordinates.forEach((line, i) => addLine(line, featureIndex, [...path, i]));
+        break;
+      case 'Polygon':
+        addPolygon(geometry.coordinates, featureIndex, path);
+        break;
+      case 'MultiPolygon':
+        geometry.coordinates.forEach((rings, i) => addPolygon(rings, featureIndex, [...path, i]));
+        break;
+      case 'GeometryCollection':
+        if (depth >= 64) throw new Error('Geometry collections are too deeply nested');
+        geometry.geometries.forEach((g, i) => visit(g, featureIndex, [...path, i], depth + 1));
+        break;
+      default:
+        throw new Error('Unsupported feature geometry type');
+    }
+  };
+  for (let i = 0; i < features.length; i++) {
+    const feature = features[i];
+    if (!feature || (feature.type !== undefined && feature.type !== 'Feature'))
+      throw new Error('Expected GeoJSON features');
+    if (
+      feature.id !== undefined &&
+      typeof feature.id !== 'string' &&
+      !(typeof feature.id === 'number' && Number.isFinite(feature.id))
+    )
+      throw new Error('Invalid feature ID');
+    featureIds.push(feature.id ?? null);
+    if (feature.geometry !== null) visit(feature.geometry, i, [], 0);
+  }
+  return {
+    version: 1,
+    mapId: map.description.id,
+    featureIds,
+    regionIds,
+    points: {...pack(points), parts: pointParts},
+    paths: {...pack(paths), parts: pathParts, pathStarts: new Uint32Array(pathStarts)},
+    polygons: {
+      ...pack(polygons),
+      parts: polygonParts,
+      ringStarts: new Uint32Array(ringStarts),
+      polygonStarts: new Uint32Array(polygonStarts)
+    }
+  };
+}