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

package/src/discontinuous/elastic/geometry.ts

@@ -0,0 +1,172 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import type {Position} from '../math';
+import type {MapSamplingOptions} from '../map-layout';
+export type Polygons = Position[][][];
+export const rectangle = (w: number, s: number, e: number, n: number): Position[][] => [
+  [
+    [w, s],
+    [e, s],
+    [e, n],
+    [w, n],
+    [w, s]
+  ]
+];
+export function onSegment(p: readonly number[], a: readonly number[], b: readonly number[]) {
+  const dx = b[0] - a[0],
+    dy = b[1] - a[1],
+    l = Math.hypot(dx, dy);
+  return (
+    l > 0 &&
+    Math.abs((p[0] - a[0]) * dy - (p[1] - a[1]) * dx) <= 1e-8 * l &&
+    (p[0] - a[0]) * (p[0] - b[0]) + (p[1] - a[1]) * (p[1] - b[1]) <= 1e-8
+  );
+}
+export function inRing(
+  p: readonly number[],
+  ring: readonly (readonly number[])[],
+  includeBoundary = true
+) {
+  let inside = false;
+  for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+    const a = ring[j],
+      b = ring[i];
+    if (onSegment(p, a, b)) return includeBoundary;
+    if (
+      a[1] > p[1] !== b[1] > p[1] &&
+      p[0] < ((b[0] - a[0]) * (p[1] - a[1])) / (b[1] - a[1]) + a[0]
+    )
+      inside = !inside;
+  }
+  return inside;
+}
+export const contains = (polygons: Polygons, p: readonly number[]) =>
+  polygons.some(rings => inRing(p, rings[0]) && !rings.slice(1).some(r => inRing(p, r, false)));
+export const lerp = (a: readonly number[], b: readonly number[], t: number): Position => [
+  a[0] + (b[0] - a[0]) * t,
+  a[1] + (b[1] - a[1]) * t
+];
+/** Split a sampled source segment at every domain edge, including narrow lobes. */
+export function clipSegment(a: Position, b: Position, polygons: Polygons): Position[][] {
+  const ts = [0, 1],
+    dx = b[0] - a[0],
+    dy = b[1] - a[1];
+  for (const rings of polygons)
+    for (const ring of rings)
+      for (let i = 1; i < ring.length; i++) {
+        const c = ring[i - 1],
+          d = ring[i],
+          ex = d[0] - c[0],
+          ey = d[1] - c[1],
+          det = dx * ey - dy * ex;
+        if (Math.abs(det) < 1e-14) continue;
+        const t = ((c[0] - a[0]) * ey - (c[1] - a[1]) * ex) / det;
+        const u = ((c[0] - a[0]) * dy - (c[1] - a[1]) * dx) / det;
+        if (t > 0 && t < 1 && u >= -1e-10 && u <= 1 + 1e-10) ts.push(t);
+      }
+  ts.sort((a, b) => a - b);
+  const result: Position[][] = [];
+  for (let i = 1; i < ts.length; i++)
+    if (ts[i] - ts[i - 1] > 1e-12 && contains(polygons, lerp(a, b, (ts[i] + ts[i - 1]) / 2)))
+      result.push([lerp(a, b, ts[i - 1]), lerp(a, b, ts[i])]);
+  return result;
+}
+export function sampling(options: MapSamplingOptions) {
+  const step = options.maxAngularStep ?? 2,
+    tolerance = options.tolerance ?? 1e-4;
+  if (
+    !Number.isFinite(step) ||
+    step <= 0 ||
+    step > 90 ||
+    !Number.isFinite(tolerance) ||
+    tolerance <= 0
+  )
+    throw new Error('Invalid map sampling options');
+  return {step, tolerance};
+}
+export function sample(
+  line: Position[],
+  project: (p: Position) => Position | null,
+  options: MapSamplingOptions,
+  cellStep: number
+) {
+  const {step, tolerance} = sampling(options),
+    source: Position[] = [],
+    xy: Position[] = [];
+  const emit = (p: Position, q: Position) => {
+    if (source.length >= 100000) throw new Error('Elastic sampling limit exceeded');
+    source.push(p);
+    xy.push(q);
+  };
+  const at = (p: Position) => {
+    const q = project(p);
+    if (!q) throw new Error('Elastic grid is undefined inside its coverage');
+    return q;
+  };
+  const visit = (a: Position, b: Position, qa: Position, qb: Position, depth: number) => {
+    const mid = lerp(a, b, 0.5),
+      qm = at(mid),
+      chord = lerp(qa, qb, 0.5);
+    if (
+      Math.hypot(b[0] - a[0], b[1] - a[1]) > Math.min(step, cellStep / 2) ||
+      Math.hypot(qm[0] - chord[0], qm[1] - chord[1]) > tolerance
+    ) {
+      if (depth >= 24) throw new Error('Elastic sampling limit exceeded');
+      visit(a, mid, qa, qm, depth + 1);
+      visit(mid, b, qm, qb, depth + 1);
+    } else emit(b, qb);
+  };
+  if (line.length) {
+    emit(line[0], at(line[0]));
+    for (let i = 1; i < line.length; i++)
+      visit(line[i - 1], line[i], at(line[i - 1]), at(line[i]), 0);
+  }
+  return {source, xy};
+}
+
+/** Latitude buckets accelerate repeated coverage queries without approximating
+ * the published boundary. Narrow cuts retain every original segment. */
+export function indexDomain(polygons: Polygons): (p: readonly number[]) => boolean {
+  const compiled = polygons.map(rings =>
+    rings.map(ring => {
+      let minX = Infinity,
+        maxX = -Infinity,
+        minY = Infinity,
+        maxY = -Infinity;
+      for (const [x, y] of ring) {
+        minX = Math.min(minX, x);
+        maxX = Math.max(maxX, x);
+        minY = Math.min(minY, y);
+        maxY = Math.max(maxY, y);
+      }
+      const bins: Position[][][] = Array.from({length: 64}, () => []);
+      const index = (y: number) => Math.max(0, Math.min(63, Math.floor(((y + 90) / 180) * 64)));
+      for (let i = 1; i < ring.length; i++) {
+        const a = ring[i - 1],
+          b = ring[i];
+        for (
+          let j = index(Math.min(a[1], b[1]) - 1e-8);
+          j <= index(Math.max(a[1], b[1]) + 1e-8);
+          j++
+        )
+          bins[j].push([a, b]);
+      }
+      return (p: readonly number[], inclusive: boolean) => {
+        if (p[0] < minX - 1e-8 || p[0] > maxX + 1e-8 || p[1] < minY - 1e-8 || p[1] > maxY + 1e-8)
+          return false;
+        let inside = false;
+        for (const [a, b] of bins[index(p[1])]) {
+          if (onSegment(p, a, b)) return inclusive;
+          if (
+            a[1] > p[1] !== b[1] > p[1] &&
+            p[0] < ((b[0] - a[0]) * (p[1] - a[1])) / (b[1] - a[1]) + a[0]
+          )
+            inside = !inside;
+        }
+        return inside;
+      };
+    })
+  );
+  return p => compiled.some(rings => rings[0](p, true) && !rings.slice(1).some(r => r(p, false)));
+}

package/src/discontinuous/elastic/grid.ts

@@ -0,0 +1,194 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import type {ElasticSection} from './data';
+import type {Position} from '../math';
+
+type Cell = {x: number; y: number; p: Position[]; bounds: number[]};
+/** Bilinear forward interpolation and cell-local inversion. No interpolation
+ * across missing nodes or section cuts; inverse candidates are residual checked. */
+export class ElasticGrid {
+  private cells: Cell[] = [];
+  constructor(
+    readonly section: ElasticSection,
+    private scale: number
+  ) {
+    if (!Number.isFinite(scale) || scale <= 0)
+      throw new Error('Elastic output scale is not representable');
+    const {rows, columns, values} = section;
+    if (
+      !Number.isInteger(rows) ||
+      !Number.isInteger(columns) ||
+      rows < 2 ||
+      columns < 2 ||
+      rows * columns > 1_000_000 ||
+      values.length !== rows * columns * 2 ||
+      values.some(v => v !== null && !Number.isFinite(v))
+    )
+      throw new Error('Invalid Elastic grid');
+    for (let i = 0; i < values.length; i += 2)
+      if ((values[i] === null) !== (values[i + 1] === null))
+        throw new Error('Incomplete Elastic node');
+    for (let y = 0; y < rows - 1; y++)
+      for (let x = 0; x < columns - 1; x++) {
+        const indices = [
+          y * columns + x,
+          y * columns + x + 1,
+          (y + 1) * columns + x,
+          (y + 1) * columns + x + 1
+        ];
+        if (indices.some(i => values[2 * i] === null)) continue;
+        const p = indices.map(
+          i => [values[2 * i]! * scale, values[2 * i + 1]! * scale] as Position
+        );
+        if (!p.flat().every(Number.isFinite))
+          throw new Error('Elastic output coordinates are not representable');
+        this.cells.push({
+          x,
+          y,
+          p,
+          bounds: [
+            Math.min(...p.map(v => v[0])),
+            Math.min(...p.map(v => v[1])),
+            Math.max(...p.map(v => v[0])),
+            Math.max(...p.map(v => v[1]))
+          ]
+        });
+      }
+    if (!this.cells.length) throw new Error('Elastic section has no defined cells');
+  }
+  project([lon, lat]: readonly number[]): Position | null {
+    const {rows, columns, values} = this.section;
+    const x = ((lon + 180) / 360) * (columns - 1),
+      y = ((lat + 90) / 180) * (rows - 1);
+    if (x < -1e-9 || x > columns - 1 + 1e-9 || y < -1e-9 || y > rows - 1 + 1e-9) return null;
+    const i = Math.max(0, Math.min(columns - 2, Math.floor(x))),
+      j = Math.max(0, Math.min(rows - 2, Math.floor(y)));
+    const u = x - i,
+      v = y - j;
+    const indices = [
+      j * columns + i,
+      j * columns + i + 1,
+      (j + 1) * columns + i,
+      (j + 1) * columns + i + 1
+    ];
+    const weights = [(1 - u) * (1 - v), u * (1 - v), (1 - u) * v, u * v];
+    const result: Position = [0, 0];
+    for (let k = 0; k < 4; k++) {
+      if (Math.abs(weights[k]) < 1e-14) continue;
+      if (values[indices[k] * 2] === null) return null;
+      for (let axis = 0; axis < 2; axis++)
+        result[axis] += weights[k] * values[indices[k] * 2 + axis]! * this.scale;
+    }
+    return result;
+  }
+  /** Every interpolation node needed for this geographic rectangle is defined. */
+  covers([w, s, e, n]: readonly number[]): boolean {
+    const {rows, columns, values} = this.section;
+    const left = Math.max(0, Math.floor(((w + 180) / 360) * (columns - 1))),
+      right = Math.min(columns - 1, Math.ceil(((e + 180) / 360) * (columns - 1)));
+    const bottom = Math.max(0, Math.floor(((s + 90) / 180) * (rows - 1))),
+      top = Math.min(rows - 1, Math.ceil(((n + 90) / 180) * (rows - 1)));
+    for (let y = bottom; y <= top; y++)
+      for (let x = left; x <= right; x++) if (values[2 * (y * columns + x)] === null) return false;
+    return true;
+  }
+  inverse(target: readonly number[]): Position[] {
+    const results: Position[] = [];
+    const epsilon = Math.max(this.scale * 1e-5, Math.hypot(...target) * 1e-10);
+    for (const {x, y, p, bounds: b} of this.cells) {
+      if (
+        target[0] < b[0] - epsilon ||
+        target[0] > b[2] + epsilon ||
+        target[1] < b[1] - epsilon ||
+        target[1] > b[3] + epsilon
+      )
+        continue;
+      for (const [u, v] of invertCell(p, target)) {
+        const point: Position = [
+          -180 + (360 * (x + u)) / (this.section.columns - 1),
+          -90 + (180 * (y + v)) / (this.section.rows - 1)
+        ];
+        if (!results.some(r => Math.hypot(r[0] - point[0], r[1] - point[1]) < 1e-7))
+          results.push(point);
+      }
+    }
+    return results;
+  }
+}
+
+const cross2 = (a: readonly number[], b: readonly number[]) => a[0] * b[1] - a[1] * b[0];
+/** Eliminate either parameter to solve the bilinear patch's quadratic. Solving
+ * both directions also handles affine cells and a vanishing elimination axis.
+ * Normalize locally so output radius does not change inverse conditioning. */
+function invertCell(p: Position[], target: readonly number[]): Position[] {
+  const scale = Math.max(...p.slice(1).flatMap(q => q.map((v, i) => Math.abs(v - p[0][i]))));
+  if (!(scale > 0))
+    return target.every((v, i) => v === p[0][i])
+      ? [
+          [0, 0],
+          [1, 0],
+          [0, 1],
+          [1, 1],
+          [0.5, 0.5]
+        ]
+      : [];
+  const b = p[1].map((v, i) => (v - p[0][i]) / scale),
+    c = p[2].map((v, i) => (v - p[0][i]) / scale);
+  const d = p[3].map((v, i) => (v - p[0][i]) / scale - b[i] - c[i]);
+  const h = target.map((v, i) => (v - p[0][i]) / scale);
+  const roots = (a: number, b: number, c: number) => {
+    if (Math.abs(a) < 1e-14) return Math.abs(b) < 1e-14 ? [] : [-c / b];
+    const discriminant = b * b - 4 * a * c;
+    if (discriminant < -1e-14) return [];
+    const q = -0.5 * (b + (b < 0 ? -1 : 1) * Math.sqrt(Math.max(0, discriminant)));
+    return q === 0 ? [-b / (2 * a)] : [q / a, c / q];
+  };
+  const output: Position[] = [];
+  const accept = (xy: Position) => {
+    if (!xy.every(v => Number.isFinite(v) && v >= -1e-9 && v <= 1 + 1e-9)) return;
+    const [x, y] = xy.map(v => Math.max(0, Math.min(1, v)));
+    if (Math.hypot(...h.map((v, i) => b[i] * x + c[i] * y + d[i] * x * y - v)) > 1e-9) return;
+    if (!output.some(p => Math.hypot(p[0] - x, p[1] - y) < 1e-8)) output.push([x, y]);
+  };
+  // Elimination loses solutions when a whole edge collapses (notably poles).
+  // Test edge restrictions directly, retaining residual-checked representatives
+  // of a collapsed edge rather than treating its zero denominator as no solution.
+  const corners: Position[] = [
+    [0, 0],
+    [1, 0],
+    [1, 1],
+    [0, 1]
+  ];
+  const value = ([x, y]: Position) => b.map((v, i) => v * x + c[i] * y + d[i] * x * y);
+  for (let i = 0; i < 4; i++) {
+    const start = corners[i],
+      end = corners[(i + 1) % 4],
+      a = value(start),
+      z = value(end);
+    const delta = z.map((v, j) => v - a[j]);
+    const axis = Math.abs(delta[0]) > Math.abs(delta[1]) ? 0 : 1;
+    const parameters =
+      Math.abs(delta[axis]) < 1e-14 ? [0, 0.5, 1] : [(h[axis] - a[axis]) / delta[axis]];
+    for (const t of parameters)
+      accept([start[0] + t * (end[0] - start[0]), start[1] + t * (end[1] - start[1])]);
+  }
+  for (const swap of [false, true]) {
+    const first = swap ? c : b,
+      second = swap ? b : c;
+    for (const u of roots(
+      -cross2(first, d),
+      cross2(h, d) - cross2(first, second),
+      cross2(h, second)
+    )) {
+      const denominator = second.map((v, i) => v + d[i] * u),
+        numerator = h.map((v, i) => v - first[i] * u);
+      const axis = Math.abs(denominator[0]) > Math.abs(denominator[1]) ? 0 : 1;
+      if (Math.abs(denominator[axis]) < 1e-14) continue;
+      const v = numerator[axis] / denominator[axis];
+      const xy: Position = swap ? [v, u] : [u, v];
+      accept(xy);
+    }
+  }
+  return output;
+}

package/src/discontinuous/elastic/map.ts

@@ -0,0 +1,317 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import polygonClipping from 'polygon-clipping';
+import {createKernelMap} from '../world-map';
+import {geographic, coordinates, unit, add, angle, RAD, type Position} from '../math';
+import type {
+  MapRegion,
+  MapSeam,
+  MapPoint,
+  MapLine,
+  MapPolygon,
+  MapSamplingOptions,
+  GeographicPosition,
+  MapSurface
+} from '../map-layout';
+import type {ElasticMapData} from './data';
+import {ElasticGrid} from './grid';
+import {indexDomain, rectangle, clipSegment, sample, sampling, type Polygons} from './geometry';
+
+// This chart splitter retains directional pole limits and antimeridian sides.
+const kernel = Object.assign((x: number, y: number) => [x, y], {
+  invert: (x: number, y: number) => [x, y]
+});
+const splitter = createKernelMap({kernel, radius: 1 / RAD});
+type Chart = {
+  region: MapRegion;
+  domain: Polygons;
+  grid: ElasticGrid;
+  baseId: string;
+  section: string;
+  contains: (p: readonly number[]) => boolean;
+};
+
+/** Compile a sampled Elastic dataset. Output units are radius-scaled, matching
+ * other MapEngine maps. Dataset tables remain explicit, optional imports. */
+export function createElasticMap(
+  data: ElasticMapData,
+  options: {radius?: number} = {}
+): MapSurface {
+  return new ElasticMap(data, options.radius ?? 1);
+}
+class ElasticMap implements MapSurface {
+  readonly regions: readonly MapRegion[];
+  readonly seams: readonly MapSeam[];
+  private charts: Chart[] = [];
+  constructor(data: ElasticMapData, radius: number) {
+    if (
+      data.version !== 1 ||
+      typeof data.name !== 'string' ||
+      !data.name ||
+      !Number.isFinite(data.radius) ||
+      data.radius <= 0 ||
+      !Number.isFinite(radius) ||
+      radius <= 0 ||
+      !data.sections?.length ||
+      data.sections.length > 64
+    )
+      throw new Error('Invalid Elastic dataset');
+    const ids = new Set<string>();
+    for (const section of data.sections) {
+      if (typeof section.id !== 'string' || !section.id || ids.has(section.id))
+        throw new Error('Elastic section IDs must be unique');
+      ids.add(section.id);
+      if (section.complement !== undefined && typeof section.complement !== 'boolean')
+        throw new Error('Invalid Elastic complement flag');
+      if (section.boundary.length < 4 || section.boundary.length > 100000)
+        throw new Error('Invalid Elastic section boundary');
+      const boundary = section.boundary.map(p => {
+        geographic(p);
+        if (Math.abs(p[0]) > 180) throw new Error('Elastic boundaries must be in [-180,180]');
+        return [...p] as Position;
+      });
+      if (boundary[0].some((v, i) => v !== boundary[boundary.length - 1][i]))
+        throw new Error('Elastic boundaries must be closed');
+      const values = Object.freeze([...section.values]);
+      const grid = new ElasticGrid({...section, values}, radius / data.radius);
+      const world = rectangle(-180, -90, 180, 90);
+      const domain = (
+        section.complement
+          ? polygonClipping.difference(world, [boundary])
+          : polygonClipping.intersection(world, [boundary])
+      ) as Polygons;
+      for (const base of splitter.regions) {
+        const [lon, lat] = base.interior,
+          w = lon - 45,
+          e = lon + 45,
+          s = lat < 0 ? -90 : 0,
+          n = lat < 0 ? 0 : 90;
+        const clipped = polygonClipping.intersection(domain, rectangle(w, s, e, n)) as Polygons;
+        if (!clipped.length) continue;
+        const id = `${section.id}/${base.id}`;
+        const owns = indexDomain(clipped);
+        const project = (p: GeographicPosition) =>
+          grid.project([Math.max(w, Math.min(e, lon + wrap(p[0] - lon))), p[1]]);
+        const region: MapRegion = Object.freeze({
+          ...base,
+          id,
+          layout: Object.freeze({label: `${data.name} · ${section.id}`, kind: 'panel' as const}),
+          placement: Object.freeze([1, 0, 0, 1, 0, 0]) as MapRegion['placement'],
+          project: (p: GeographicPosition) => project(p) ?? [NaN, NaN],
+          unproject: (p: GeographicPosition) => grid.inverse(p).find(p => owns(p)) ?? null
+        });
+        this.charts.push({
+          region,
+          domain: clipped,
+          grid,
+          baseId: base.id,
+          section: section.id,
+          contains: owns
+        });
+      }
+    }
+    if (!this.charts.length) throw new Error('Elastic dataset has empty coverage');
+    this.regions = Object.freeze(this.charts.map(c => c.region));
+    this.seams = Object.freeze(this.makeSeams());
+  }
+  private select(id?: string) {
+    if (id === undefined) return this.charts;
+    const c = this.charts.find(c => c.region.id === id);
+    if (!c) throw new Error(`Unknown map region: ${id}`);
+    return [c];
+  }
+  private local(c: Chart, p: GeographicPosition): Position {
+    const center = c.region.interior[0];
+    return [center + wrap(p[0] - center), p[1]];
+  }
+  findRegions(p: GeographicPosition) {
+    geographic(p);
+    return this.charts.filter(c => c.contains(this.local(c, p))).map(c => c.region.id);
+  }
+  containsConvexPolygon(ring: readonly GeographicPosition[], id: string) {
+    const c = this.select(id)[0];
+    if (!splitter.containsConvexPolygon(ring, c.baseId)) return false;
+    const points = ring.map(geographic),
+      center = unit(points.reduce(add, [0, 0, 0]));
+    const [lon, lat] = coordinates(center),
+      radius = Math.max(...points.map(p => angle(center, p)));
+    // A spherical cap enclosing the convex ring encloses its entire interior.
+    // Bound that cap in longitude/latitude, then reject every boundary contact.
+    if (radius >= Math.PI / 2 || Math.abs(lat) + radius / RAD >= 90) return false;
+    const dx = Math.asin(Math.min(1, Math.sin(radius) / Math.cos(lat * RAD))) / RAD;
+    const box = [lon - dx, lat - radius / RAD, lon + dx, lat + radius / RAD];
+    if (box[0] < -180 || box[2] > 180 || !c.contains([lon, lat])) return false;
+    for (const polygon of c.domain)
+      for (const edge of polygon)
+        for (let i = 1; i < edge.length; i++) {
+          const a = edge[i - 1],
+            b = edge[i];
+          if (
+            Math.max(a[0], b[0]) >= box[0] - 1e-7 &&
+            Math.min(a[0], b[0]) <= box[2] + 1e-7 &&
+            Math.max(a[1], b[1]) >= box[1] - 1e-7 &&
+            Math.min(a[1], b[1]) <= box[3] + 1e-7
+          )
+            return false;
+        }
+    return c.grid.covers(box);
+  }
+  projectPoint(p: GeographicPosition, id?: string): MapPoint | null {
+    geographic(p);
+    for (const c of this.select(id)) {
+      const q = this.local(c, p);
+      if (c.contains(q)) {
+        const xy = c.grid.project(q);
+        if (xy) return {regionId: c.region.id, position: xy};
+      }
+    }
+    return null;
+  }
+  unprojectPoint(p: GeographicPosition, id?: string): MapPoint[] {
+    if (p.length !== 2 || !p.every(Number.isFinite))
+      throw new Error('Expected finite XY coordinates');
+    const results: MapPoint[] = [];
+    const candidates = new Map<ElasticGrid, Position[]>();
+    for (const c of this.select(id)) {
+      if (!candidates.has(c.grid)) candidates.set(c.grid, c.grid.inverse(p));
+      for (const q of candidates.get(c.grid)!)
+        if (c.contains(q)) results.push({regionId: c.region.id, position: q});
+    }
+    return results;
+  }
+  private sourceOptions(options: MapSamplingOptions) {
+    const {step} = sampling(options);
+    return {maxAngularStep: Math.min(step, 1), tolerance: 1e-5};
+  }
+  private sampled(c: Chart, line: Position[], options: MapSamplingOptions) {
+    return sample(
+      line,
+      p => c.grid.project(p),
+      options,
+      Math.min(180 / (c.grid.section.rows - 1), 360 / (c.grid.section.columns - 1))
+    );
+  }
+  projectLine(line: readonly GeographicPosition[], options: MapSamplingOptions = {}): MapLine[] {
+    const out: MapLine[] = [];
+    for (const part of splitter.projectLine(line, this.sourceOptions(options)))
+      for (const c of this.charts.filter(c => c.baseId === part.regionId)) {
+        let current: Position[] = [];
+        const flush = () => {
+          if (current.length > 1) {
+            const {source, xy} = this.sampled(c, current, options);
+            out.push({regionId: c.region.id, coordinates: xy, sourceCoordinates: source});
+          }
+          current = [];
+        };
+        for (let i = 1; i < part.coordinates.length; i++)
+          for (const [a, b] of clipSegment(
+            part.coordinates[i - 1],
+            part.coordinates[i],
+            c.domain
+          )) {
+            if (
+              current.length &&
+              Math.hypot(
+                current[current.length - 1][0] - a[0],
+                current[current.length - 1][1] - a[1]
+              ) > 1e-8
+            )
+              flush();
+            if (!current.length) current.push(a);
+            current.push(b);
+          }
+        flush();
+      }
+    return out;
+  }
+  projectPolygon(
+    rings: readonly (readonly GeographicPosition[])[],
+    options: MapSamplingOptions = {}
+  ): MapPolygon[] {
+    const out: MapPolygon[] = [];
+    for (const part of splitter.projectPolygon(rings, this.sourceOptions(options)))
+      for (const c of this.charts.filter(c => c.baseId === part.regionId)) {
+        const clipped = polygonClipping.intersection(
+          snapPolygon(part.coordinates),
+          c.domain.map(snapPolygon)
+        ) as Polygons;
+        for (const polygon of clipped) {
+          const samples = polygon.map(r => this.sampled(c, r, options));
+          out.push({
+            regionId: c.region.id,
+            coordinates: samples.map(s => s.xy),
+            sourceCoordinates: samples.map(s => s.source)
+          });
+        }
+      }
+    return out;
+  }
+  getRegionOutlines(id: string, options: MapSamplingOptions = {}): Position[][] {
+    const c = this.select(id)[0];
+    return c.domain.flatMap(p => p.map(r => this.sampled(c, r, options).xy));
+  }
+  private makeSeams(): MapSeam[] {
+    const groups = new Map<string, {c: Chart; a: Position; b: Position; edge: number}[]>();
+    const key = (p: Position) =>
+      [Math.abs(p[0]) === 180 ? -180 : p[0], p[1]].map(v => Math.round(v * 1e7)).join(',');
+    for (const c of this.charts) {
+      let edge = 0;
+      for (const polygon of c.domain)
+        for (const ring of polygon)
+          for (let i = 1; i < ring.length; i++, edge++) {
+            const a = ring[i - 1],
+              b = ring[i],
+              k = [key(a), key(b)].sort().join('/'),
+              group = groups.get(k) ?? [];
+            group.push({c, a, b, edge});
+            groups.set(k, group);
+          }
+    }
+    return [...groups.values()]
+      .flatMap(group => {
+        if (group.length === 1)
+          return [
+            {regions: [group[0].c.region.id], edges: [group[0].edge], kind: 'boundary' as const}
+          ];
+        return group.slice(1).map(other => {
+          const first = group[0];
+          const samples = [
+            first.a,
+            [(first.a[0] + first.b[0]) / 2, (first.a[1] + first.b[1]) / 2] as Position,
+            first.b
+          ];
+          const joined = samples.every(p => {
+            const a = first.c.grid.project(this.local(first.c, p)),
+              b = other.c.grid.project(this.local(other.c, p));
+            return (
+              a &&
+              b &&
+              Math.hypot(a[0] - b[0], a[1] - b[1]) <=
+                1e-8 * Math.max(Number.MIN_VALUE, Math.hypot(...a), Math.hypot(...b))
+            );
+          });
+          const kind = joined ? 'join' : 'cut';
+          return {
+            regions: [first.c.region.id, other.c.region.id],
+            edges: [first.edge, other.edge],
+            kind
+          } as MapSeam;
+        });
+      })
+      .map(s =>
+        Object.freeze({...s, regions: Object.freeze(s.regions), edges: Object.freeze(s.edges)})
+      );
+  }
+}
+function wrap(lon: number) {
+  const x = lon % 360;
+  return x > 180 ? x - 360 : x < -180 ? x + 360 : x;
+}
+
+// Spherical chart clipping leaves sub-ulp variations along coincident chart
+// edges. Quantize only Boolean operands, far below source sampling tolerance,
+// so the sweep-line operation sees identical endpoints on shared boundaries.
+function snapPolygon(rings: readonly (readonly GeographicPosition[])[]): Position[][] {
+  return rings.map(ring => ring.map(p => p.map(v => Math.round(v * 1e10) / 1e10) as Position));
+}