@math.gl/geospatial 5.0.0-alpha.9 → 5.0.0-beta.2

package/src/geographic-atlas/curves.ts

@@ -0,0 +1,360 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original bounded curve/root certificates over the existing attributed GeographicLib-derived geodesic and rhumb solvers.
+import {Context, root as axisRoot, type Edge} from '../geographic-seams/edge';
+import {GeographicSeamError} from '../geographic-seams/types';
+import {
+  dot,
+  value,
+  slope,
+  valueError,
+  normal,
+  position,
+  scale,
+  add,
+  unit,
+  cross,
+  sincos,
+  TAU,
+  ROUND,
+  ANGULAR,
+  type V,
+  type Circle
+} from './math';
+export type Curve = {
+  sample(t: number): number[];
+  derivative(t: number): V;
+  speed: number;
+  second: number;
+  circular?: {
+    normal: V;
+    offset: number;
+    u: V;
+    v: V;
+    start: number;
+    end: number;
+    fraction(theta: number): number;
+  };
+};
+export function sourceCurve(
+  edge: Edge,
+  context: Context,
+  a: number,
+  b: number,
+  original?: readonly [number[], number[]]
+): Curve {
+  const model = context.options.edgeModel,
+    r = b / a,
+    qmax = Math.max(1, 1 / (r * r)),
+    wmin = Math.min(1, 1 / r),
+    K = qmax / wmin;
+  let initialAzimuth = 0;
+  let length = 0,
+    azimuth = (t: number) => ({azi: 0, longitude: edge.a[0]});
+  if (model === 'geodesic') {
+    const g = context.options.geodesic!;
+    context.tick(2);
+    const first = original?.[0] ?? edge.a,
+      last = original?.[1] ?? edge.b;
+    const inv = g.inverse(first[1], first[0], last[1], last[0]);
+    initialAzimuth = inv.azi1;
+    length = inv.s12 / a;
+    const line = g.line(first[1], first[0], inv.azi1);
+    azimuth = t => {
+      context.tick();
+      const p = line.position(inv.s12 * t);
+      return {azi: p.azi2, longitude: p.lon2};
+    };
+  } else if (model === 'rhumb') {
+    const rh = context.options.rhumb!;
+    context.tick(2);
+    const first = rh.inverse(edge.a[1], edge.a[0], edge.b[1], edge.b[0], {unrollLongitude: true});
+    const turns = Math.round((edge.b[0] - first.lon2) / 360);
+    const inv = turns
+      ? rh.inverse(edge.a[1], edge.a[0], edge.b[1], edge.b[0], {longitudeTurns: turns})
+      : first;
+    length = inv.s12 / a;
+    azimuth = () => ({azi: inv.azi12, longitude: edge.a[0]});
+  }
+  const dp = ((edge.b[1] - edge.a[1]) * Math.PI) / 180,
+    dl = ((edge.b[0] - edge.a[0]) * Math.PI) / 180;
+  const speed = model === 'linear' ? Math.abs(dp) + Math.abs(dl) : length * K;
+  const minCos = Math.min(...[edge.a[1], edge.b[1]].map(x => Math.abs(sincos(x)[1])));
+  // For normalized Q=diag(1,1,1/r²), |Dn| <= K. A unit-speed
+  // geodesic has |x''| <= K and differentiating Qx/|Qx| gives
+  // |n''| <= 4 K². Constant-bearing frame derivatives add a
+  // conservative latitude-dependent bound (rhumbs exclude poles).
+  const second =
+    model === 'linear'
+      ? speed * speed
+      : model === 'geodesic'
+        ? 4 * speed * speed
+        : (100 * K * K * speed * speed) / (minCos * minCos);
+  const curve: Curve = {
+    sample: edge.sample,
+    speed,
+    second,
+    derivative: t => {
+      const p = edge.sample(t),
+        heading = model === 'linear' ? undefined : azimuth(t),
+        longitude = model === 'geodesic' && Math.abs(p[1]) === 90 ? heading!.longitude : p[0],
+        [sp, cp] = sincos(p[1]),
+        [sl, cl] = sincos(longitude);
+      const north: V = [-sp * cl, -sp * sl, cp],
+        east: V = [-sl, cl, 0];
+      if (model === 'linear') return add(scale(north, dp), scale(east, cp * dl));
+      const [sa, ca] = sincos(heading!.azi),
+        w = Math.sqrt(cp * cp + r * r * sp * sp),
+        M = (r * r) / (w * w * w),
+        N = 1 / w;
+      return scale(add(scale(north, ca / M), scale(east, sa / N)), length);
+    }
+  };
+  const axis = (coordinate: 0 | 1, theta: number) => {
+    const target = (theta * 180) / Math.PI;
+    if (Math.abs(target - edge.a[coordinate]) < 1e-13) return 0;
+    if (Math.abs(target - edge.b[coordinate]) < 1e-13) return 1;
+    return axisRoot(edge, coordinate, target, context);
+  };
+  if (
+    edge.a[1] === edge.b[1] &&
+    (model !== 'geodesic' || (edge.a[1] === 0 && Math.abs(initialAzimuth) === 90))
+  ) {
+    curve.circular = {
+      normal: [0, 0, 1],
+      offset: sincos(edge.a[1])[0],
+      u: [1, 0, 0],
+      v: [0, 1, 0],
+      start: (edge.a[0] * Math.PI) / 180,
+      end: (edge.b[0] * Math.PI) / 180,
+      fraction: t => axis(0, t)
+    };
+  } else if (edge.a[0] === edge.b[0]) {
+    const [s, c] = sincos(edge.a[0]);
+    curve.circular = {
+      normal: [s, -c, 0],
+      offset: 0,
+      u: [c, s, 0],
+      v: [0, 0, 1],
+      start: (edge.a[1] * Math.PI) / 180,
+      end: (edge.b[1] * Math.PI) / 180,
+      fraction: t => axis(1, t)
+    };
+  } else if (model === 'geodesic' && a === b && length > 0) {
+    const u = normal(edge.a),
+      v = unit(curve.derivative(0));
+    curve.circular = {
+      normal: unit(cross(u, v)),
+      offset: 0,
+      u,
+      v,
+      start: 0,
+      end: length,
+      fraction: t => t / length
+    };
+  }
+  if (curve.circular && Math.abs(curve.circular.offset) === 1) {
+    curve.speed = 0;
+    curve.second = 0;
+  }
+  return curve;
+}
+export function sliceCurve(c: Curve, lo: number, hi: number): Curve {
+  const d = hi - lo,
+    z = c.circular;
+  const theta = (t: number) => {
+    const n = normal(c.sample(t)),
+      raw = Math.atan2(dot(z!.v, n), dot(z!.u, n)),
+      expected = z!.start + (z!.end - z!.start) * t;
+    return raw + TAU * Math.round((expected - raw) / TAU);
+  };
+  return {
+    sample: t => c.sample(lo + d * t),
+    derivative: t => scale(c.derivative(lo + d * t), d),
+    speed: c.speed * Math.abs(d),
+    second: c.second * d * d,
+    circular: z && {
+      ...z,
+      start: theta(lo),
+      end: theta(hi),
+      fraction: angle => (z.fraction(angle) - lo) / d
+    }
+  };
+}
+export function circleCurve(
+  c: Circle,
+  start: number,
+  end: number,
+  attributesA: readonly number[],
+  attributesB: readonly number[]
+): Curve {
+  const delta = end - start;
+  const sample = (t: number) => {
+    const theta = start + delta * t,
+      n = add(
+        scale(c.normal, c.offset),
+        scale(add(scale(c.u, Math.cos(theta)), scale(c.v, Math.sin(theta))), c.radius)
+      );
+    return position(
+      n,
+      attributesA.map((x, i) => x * (1 - t) + attributesB[i] * t)
+    );
+  };
+  return {
+    sample,
+    derivative: t => {
+      const theta = start + delta * t;
+      return scale(
+        add(scale(c.u, -Math.sin(theta)), scale(c.v, Math.cos(theta))),
+        c.radius * delta
+      );
+    },
+    speed: c.radius * Math.abs(delta),
+    second: c.radius * delta * delta,
+    circular: {
+      normal: c.normal,
+      offset: c.offset,
+      u: c.u,
+      v: c.v,
+      start,
+      end,
+      fraction: theta => (theta - start) / delta
+    }
+  };
+}
+export function roots(
+  c: Curve,
+  b: Circle,
+  context: Context
+): {fractions: number[]; coincident: boolean} {
+  const result: number[] = [];
+  const put = (t: number) => {
+    if (t >= 0 && t <= 1 && !result.includes(t)) {
+      result.push(t);
+      context.addVertices(1);
+    }
+  };
+  const f = (t: number) => {
+    context.tick();
+    return value(b, normal(c.sample(t)));
+  };
+  if (c.circular) {
+    const z = c.circular,
+      radius = Math.sqrt((1 - z.offset) * (1 + z.offset)),
+      A = radius * dot(b.normal, z.u),
+      B = radius * dot(b.normal, z.v),
+      direct = dot(b.normal, z.normal),
+      // Stable cosine of the angle between the two circle normals.
+      d =
+        direct >= 0
+          ? 1 - 0.5 * b.normal.reduce((sum, x, i) => sum + (x - z.normal[i]) ** 2, 0)
+          : -1 + 0.5 * b.normal.reduce((sum, x, i) => sum + (x + z.normal[i]) ** 2, 0),
+      C =
+        d >= 0
+          ? b.offset -
+            z.offset +
+            z.offset * 0.5 * b.normal.reduce((sum, x, i) => sum + (x - z.normal[i]) ** 2, 0)
+          : b.offset +
+            z.offset -
+            z.offset * 0.5 * b.normal.reduce((sum, x, i) => sum + (x + z.normal[i]) ** 2, 0),
+      R = Math.hypot(A, B);
+    if (
+      Math.hypot(...cross(b.normal, z.normal)) <= ROUND &&
+      Math.abs(b.offset - z.offset * (d >= 0 ? 1 : -1)) / radius <= ROUND
+    )
+      return {fractions: [], coincident: true};
+    if (R === 0) return {fractions: [], coincident: false};
+    const phase = Math.atan2(B, A),
+      low = Math.min(z.start, z.end),
+      high = Math.max(z.start, z.end);
+    const evaluate = (theta: number) => A * Math.cos(theta) + B * Math.sin(theta) - C;
+    let minimum = Math.min(evaluate(low), evaluate(high)),
+      maximum = Math.max(evaluate(low), evaluate(high));
+    // Condition the finite arc, not the entire supporting circle. A remote
+    // tangency/near-coincidence cannot make an otherwise separated arc ambiguous.
+    for (let k = Math.ceil((low - phase) / Math.PI); phase + k * Math.PI <= high; k++) {
+      context.tick();
+      const value = (k % 2 === 0 ? R : -R) - C;
+      minimum = Math.min(minimum, value);
+      maximum = Math.max(maximum, value);
+    }
+    const enclosureError =
+      ROUND *
+      (1 + Math.abs(A) + Math.abs(B) + Math.abs(C) + R * Math.max(Math.abs(low), Math.abs(high)));
+    if (minimum > enclosureError || maximum < -enclosureError)
+      return {fractions: [], coincident: false};
+    const sine = Math.hypot(...cross(b.normal, z.normal));
+    // Use a cross product near parallel normals; 1-d*d erases small angles.
+    const left =
+        Math.abs(d) > 0.5
+          ? radius * radius * sine * sine
+          : (1 - b.offset) * (1 + b.offset) * (1 - z.offset) * (1 + z.offset),
+      right = Math.abs(d) > 0.5 ? C * C : (d - b.offset * z.offset) ** 2,
+      D = left - right,
+      error = ROUND * (Math.abs(left) + Math.abs(right));
+    if (D < -error) return {fractions: [], coincident: false};
+    if (D <= error) throw new GeographicSeamError('precision', 'Unresolved circle tangency');
+    if (sine < Math.sqrt(ROUND))
+      throw new GeographicSeamError('precision', 'Unresolved nearly coincident source/cut circles');
+    const delta = Math.atan2(Math.sqrt(D), C);
+    for (const base of [phase - delta, phase + delta])
+      for (let k = Math.ceil((low - base) / TAU); base + TAU * k <= high; k++) {
+        context.tick();
+        const theta = base + TAU * k;
+        // Endpoints are identities of this curve, not proximity-welded source vertices.
+        const t = theta === z.start ? 0 : theta === z.end ? 1 : z.fraction(theta);
+        put(t);
+      }
+    return {fractions: result.sort((x, y) => x - y), coincident: false};
+  }
+  const bisect = (a: number, b1: number, fa: number) => {
+    let lo = a,
+      hi = b1;
+    for (let i = 0; i < context.iterations; i++) {
+      context.tick();
+      const mid = (lo + hi) / 2,
+        fm = f(mid);
+      if (fm === 0) {
+        put(mid);
+        return;
+      }
+      if (hi - lo <= 4 * Number.EPSILON && c.speed * (hi - lo) <= ANGULAR) {
+        put(mid);
+        return;
+      }
+      if (mid === lo || mid === hi) break;
+      if (fm < 0 === fa < 0) {
+        lo = mid;
+        fa = fm;
+      } else hi = mid;
+    }
+    throw new GeographicSeamError('precision', 'Atlas intersection exhausted its root budget');
+  };
+  const visit = (lo: number, hi: number, fl: number, fh: number, depth: number) => {
+    context.tick();
+    const mid = (lo + hi) / 2,
+      h = (hi - lo) / 2,
+      fm = f(mid);
+    const n = normal(c.sample(mid)),
+      d = slope(b, n, c.derivative(mid)),
+      derivativeError = ROUND * Math.max(1, c.speed);
+    const excursion = Math.min(
+      c.speed * h,
+      (Math.abs(d) + derivativeError) * h + 0.5 * c.second * h * h
+    );
+    if (Math.abs(fm) > excursion + valueError(b, n)) return;
+    if (Math.abs(d) > c.second * h + ROUND * Math.max(1, c.speed)) {
+      if (fl === 0) put(lo);
+      if (fh === 0) put(hi);
+      if (fl * fh < 0) bisect(lo, hi, fl);
+      return;
+    }
+    if (depth >= context.iterations || mid === lo || mid === hi)
+      throw new GeographicSeamError('precision', 'Unresolved tangent or coincident source/cut');
+    visit(lo, mid, fl, fm, depth + 1);
+    visit(mid, hi, fm, fh, depth + 1);
+  };
+  visit(0, 1, f(0), f(1), 0);
+  return {fractions: result.sort((x, y) => x - y), coincident: false};
+}

package/src/geographic-atlas/math.ts

@@ -0,0 +1,125 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original surface-normal circle and chart mathematics; no upstream clipping code copied.
+import {GeographicSeamError} from '../geographic-seams/types';
+export type V = [number, number, number];
+export const TAU = 2 * Math.PI;
+export const ANGULAR = 1e-12;
+export const ROUND = 64 * Number.EPSILON;
+export const dot = (a: V, b: V) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+export const cross = (a: V, b: V): V => [
+  a[1] * b[2] - a[2] * b[1],
+  a[2] * b[0] - a[0] * b[2],
+  a[0] * b[1] - a[1] * b[0]
+];
+export const scale = (a: V, s: number): V => a.map(x => x * s) as V;
+export const add = (a: V, b: V): V => a.map((x, i) => x + b[i]) as V;
+export function unit(a: readonly number[]): V {
+  if (a.length !== 3 || !a.every(Number.isFinite))
+    throw new GeographicSeamError('input', 'Expected a finite three-component direction');
+  const m = Math.max(...a.map(Math.abs));
+  if (!m) throw new GeographicSeamError('input', 'Zero direction');
+  const v = a.map(x => x / m) as V;
+  return scale(v, 1 / Math.hypot(...v));
+}
+export function sincos(degrees: number): [number, number] {
+  const q = Math.round(degrees / 90),
+    r = ((degrees - 90 * q) * Math.PI) / 180,
+    s = Math.sin(r),
+    c = Math.cos(r);
+  switch (((q % 4) + 4) % 4) {
+    case 0:
+      return [s, c];
+    case 1:
+      return [c, -s];
+    case 2:
+      return [-s, -c];
+    default:
+      return [-c, s];
+  }
+}
+export function normal(p: readonly number[]): V {
+  const [sp, cp] = sincos(p[1]),
+    [sl, cl] = sincos((((p[0] % 360) + 540) % 360) - 180);
+  return [cp * cl, cp * sl, sp];
+}
+export function position(n: V, attributes: readonly number[] = []): number[] {
+  return [
+    (Math.atan2(n[1], n[0]) * 180) / Math.PI,
+    (Math.atan2(n[2], Math.hypot(n[0], n[1])) * 180) / Math.PI,
+    ...attributes
+  ];
+}
+export function basis(n: V): [V, V] {
+  const axis: V = Math.abs(n[2]) < 0.8 ? [0, 0, 1] : [0, 1, 0];
+  const u = unit(cross(axis, n));
+  return [u, cross(n, u)];
+}
+export type Circle = {id: string; normal: V; offset: number; radius: number; u: V; v: V};
+export function circle(id: string, n: V, c: number): Circle {
+  const [u, v] = basis(n);
+  return {id, normal: n, offset: c, radius: Math.sqrt((1 - c) * (1 + c)), u, v};
+}
+export function onCircle(c: Circle, t: number): V {
+  const [s, k] = sincos((t * 180) / Math.PI);
+  return add(scale(c.normal, c.offset), scale(add(scale(c.u, k), scale(c.v, s)), c.radius));
+}
+export const angle = (c: Circle, n: V) => (Math.atan2(dot(c.v, n), dot(c.u, n)) + TAU) % TAU;
+export function project(c: Circle, n: V): V {
+  const tangent = add(n, scale(c.normal, -dot(c.normal, n)));
+  return add(scale(c.normal, c.offset), scale(unit(tangent), c.radius));
+}
+/** Chord identities avoid dot(n,center)-offset cancellation for small caps. */
+export function value(c: Circle, n: V): number {
+  if (c.offset > 0.5)
+    return 1 - c.offset - 0.5 * n.reduce((sum, x, i) => sum + (x - c.normal[i]) ** 2, 0);
+  if (c.offset < -0.5)
+    return -1 - c.offset + 0.5 * n.reduce((sum, x, i) => sum + (x + c.normal[i]) ** 2, 0);
+  return dot(c.normal, n) - c.offset;
+}
+export function valueError(c: Circle, n: V): number {
+  if (Math.abs(c.offset) > 0.5) {
+    const sign = c.offset > 0 ? 1 : -1;
+    return (
+      ROUND * (1 - Math.abs(c.offset) + Math.hypot(...n.map((x, i) => x - sign * c.normal[i])))
+    );
+  }
+  return ROUND * (Math.abs(c.offset) + n.reduce((sum, x, i) => sum + Math.abs(x * c.normal[i]), 0));
+}
+export function slope(c: Circle, n: V, tangent: V): number {
+  if (c.offset > 0.5) return -n.reduce((sum, x, i) => sum + (x - c.normal[i]) * tangent[i], 0);
+  if (c.offset < -0.5) return n.reduce((sum, x, i) => sum + (x + c.normal[i]) * tangent[i], 0);
+  return dot(c.normal, tangent);
+}
+export function intersections(a: Circle, b: Circle): V[] {
+  const d = dot(a.normal, b.normal),
+    w = cross(a.normal, b.normal),
+    w2 = dot(w, w);
+  if (w2 === 0) return [];
+  if (w2 < ROUND * ROUND)
+    throw new GeographicSeamError('precision', 'Unresolved nearly parallel cut circles');
+  const x = add(
+    scale(a.normal, (a.offset - d * b.offset) / w2),
+    scale(b.normal, (b.offset - d * a.offset) / w2)
+  );
+  const h2 = 1 - dot(x, x);
+  if (h2 < -ROUND) return [];
+  if (Math.abs(h2) <= ROUND)
+    throw new GeographicSeamError('precision', 'Tangent or unresolved cut-circle junction');
+  const z = scale(w, Math.sqrt(h2 / w2));
+  return [unit(add(x, z)), unit(add(x, scale(z, -1)))];
+}
+export type ChartFrame = {center: V; u: V; v: V};
+export function chartPoint(f: ChartFrame, n: V): [number, number] {
+  const d = 1 + dot(f.center, n);
+  if (d < 0.5) throw new GeographicSeamError('precision', 'Point outside the chart hemisphere');
+  return [dot(f.u, n) / d, dot(f.v, n) / d];
+}
+export function chartNormal(f: ChartFrame, x: number, y: number): V {
+  const r = x * x + y * y;
+  return add(
+    scale(f.center, (1 - r) / (1 + r)),
+    scale(add(scale(f.u, x), scale(f.v, y)), 2 / (1 + r))
+  );
+}

package/src/geographic-atlas/sampling.ts

@@ -0,0 +1,146 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original atlas descriptor adapter over the existing adaptive subdivision engine; upstream solver notices retained.
+import {
+  subdividePolyline,
+  type SubdividePolylineOptions,
+  type SubdividedPolyline
+} from '@math.gl/geometry';
+import {Context, same, type Edge} from '../geographic-seams/edge';
+import {GeographicSeamError} from '../geographic-seams/types';
+import type {GeodesicParameters} from '../ellipsoid-geodesic';
+import {circleCurve, sliceCurve, type Curve} from './curves';
+import {normal, position, ANGULAR, type Circle} from './math';
+import type {GeographicAtlasRing, GeographicAtlasEdge, GeographicAtlasSource} from './types';
+export type AtlasSubdivisionOptions = Omit<SubdividePolylineOptions, 'size' | 'createEdgeSampler'>;
+export type SubdividedAtlasPolyline = SubdividedPolyline & {edges: GeographicAtlasSource[]};
+export type SubdividedAtlasRing = SubdividedPolyline & {edges: GeographicAtlasEdge[]};
+export function subdivideAtlasRing(
+  sources: {edge: Edge; curve: Curve}[],
+  boundaries: Circle[],
+  ring: GeographicAtlasRing,
+  options: AtlasSubdivisionOptions,
+  context: Context,
+  axes: GeodesicParameters,
+  closed = true
+): SubdividedAtlasRing {
+  const settings = {...options},
+    size = context.size,
+    points = context.read(ring.positions),
+    descriptors = ring.edges.map(e =>
+      e.kind === 'source' ? {...e, source: {...e.source}} : {...e}
+    );
+  if (
+    (size !== 2 && size !== 3) ||
+    points.length < (closed ? 2 : 1) ||
+    descriptors.length !== points.length - 1 ||
+    (closed && !same(points[0], points[points.length - 1]))
+  )
+    throw new GeographicSeamError(
+      'input',
+      'Invalid atlas path dimensions, closure or descriptor count'
+    );
+  const ratio = axes.semiMinorAxis / axes.semiMajorAxis,
+    Rmax = axes.semiMajorAxis * Math.max(1, ratio * ratio, 1 / ratio);
+  const curves = descriptors.map((e, i) => {
+    let curve: Curve;
+    if (e.kind === 'source') {
+      const s = e.source;
+      if (
+        ![s.startFraction, s.endFraction].every(Number.isFinite) ||
+        Math.min(s.startFraction, s.endFraction) < 0 ||
+        Math.max(s.startFraction, s.endFraction) > 1
+      )
+        throw new GeographicSeamError('input', 'Invalid atlas source interval');
+      const source = sources.find(
+        p =>
+          p.edge.source?.ringIndex === s.ringIndex &&
+          p.edge.source.edgeIndex === s.edgeIndex &&
+          Math.min(s.startFraction, s.endFraction) >= p.edge.source.startFraction &&
+          Math.max(s.startFraction, s.endFraction) <= p.edge.source.endFraction
+      );
+      if (!source)
+        throw new GeographicSeamError(
+          'input',
+          'Atlas source interval is not in the original rings'
+        );
+      const original = source.edge.source!,
+        delta = original.endFraction - original.startFraction;
+      curve = sliceCurve(
+        source.curve,
+        (s.startFraction - original.startFraction) / delta,
+        (s.endFraction - original.startFraction) / delta
+      );
+    } else {
+      const boundary = boundaries.find(b => b.id === e.boundary);
+      if (
+        !boundary ||
+        ![e.startAngle, e.endAngle].every(Number.isFinite) ||
+        Math.abs(e.endAngle - e.startAngle) > 2 * Math.PI
+      )
+        throw new GeographicSeamError('input', 'Invalid atlas boundary interval');
+      curve = circleCurve(
+        boundary,
+        e.startAngle,
+        e.endAngle,
+        points[i].slice(2),
+        points[i + 1].slice(2)
+      );
+    }
+    for (const t of [0, 1])
+      if (
+        Math.hypot(...normal(curve.sample(t)).map((x, j) => x - normal(points[i + t])[j])) > ANGULAR
+      )
+        throw new GeographicSeamError('input', 'Atlas descriptor does not match its endpoints');
+    return curve;
+  });
+  const result = subdividePolyline(new Float64Array(points.flat()), {
+    ...settings,
+    size,
+    transform: p => {
+      context.tick();
+      return settings.transform(p);
+    },
+    createEdgeSampler: (a, b, index) => {
+      const curve = curves[index];
+      return {
+        length: curve.speed * Rmax,
+        sample: t => {
+          context.tick();
+          if (t === 0) return a.slice();
+          if (t === 1) return b.slice();
+          const p = curve.sample(t);
+          return position(normal(p), p.slice(2));
+        }
+      };
+    }
+  });
+  const edges: GeographicAtlasEdge[] = [];
+  for (let i = 1; i < result.segmentIndices.length; i++) {
+    const index = result.segmentIndices[i],
+      edge = descriptors[index],
+      lo = result.segmentIndices[i - 1] === index ? result.segmentFractions[i - 1] : 0,
+      hi = result.segmentFractions[i];
+    if (edge.kind === 'source') {
+      const s = edge.source,
+        d = s.endFraction - s.startFraction;
+      edges.push({
+        kind: 'source',
+        source: {
+          ...s,
+          startFraction: s.startFraction + d * lo,
+          endFraction: s.startFraction + d * hi
+        }
+      });
+    } else {
+      const d = edge.endAngle - edge.startAngle;
+      edges.push({
+        ...edge,
+        startAngle: edge.startAngle + d * lo,
+        endAngle: edge.startAngle + d * hi
+      });
+    }
+  }
+  return {...result, edges};
+}