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

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/polygon-constraints.ts

@@ -0,0 +1,184 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import {angle, geographic, type Position} from './math';
+import type {MapPolygonEdge} from './map-layout';
+export type ConstraintOwner = readonly [ring: number, edge: number] | null;
+/** Attribute boolean output to indexed input constraints before final map
+ * projection/resampling. Restore vertices erased by collinear-edge merging.
+ * Ambiguous ancestry rejects; target rendering coordinates never identify an
+ * original source segment. The caller owns this computational clipping chart.
+ */
+export function tracePolygonConstraints(
+  input: Position[][],
+  output: Position[][],
+  tolerance = 1e-10,
+  priorities?: MapPolygonEdge[][],
+  accept?: (point: Position) => boolean,
+  degenerate?: (a: Position, b: Position) => boolean
+) {
+  const constraints = input.flatMap((ring, r) =>
+    ring.slice(0, -1).map((a, i) => ({a, b: ring[i + 1], r, i}))
+  );
+  let work = 0;
+  const tick = () => {
+    if (++work > 20000000) throw new Error('Polygon constraint work limit exceeded');
+  };
+  const fraction = (p: Position, a: Position, b: Position) => {
+    const dx = b[0] - a[0],
+      dy = b[1] - a[1],
+      l = dx * dx + dy * dy;
+    return l ? ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / l : NaN;
+  };
+  const on = (p: Position, a: Position, b: Position) => {
+    tick();
+    const t = fraction(p, a, b),
+      length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+    return (
+      length > 0 &&
+      t >= -tolerance &&
+      t <= 1 + tolerance &&
+      Math.hypot(p[0] - a[0] - t * (b[0] - a[0]), p[1] - a[1] - t * (b[1] - a[1])) <=
+        tolerance * Math.max(1, length)
+    );
+  };
+  type Box = readonly [number, number, number, number];
+  type Node = {box: Box; ids?: number[]; left?: Node; right?: Node};
+  const boxes: Box[] = constraints.map(c => [
+    Math.min(c.a[0], c.b[0]),
+    Math.min(c.a[1], c.b[1]),
+    Math.max(c.a[0], c.b[0]),
+    Math.max(c.a[1], c.b[1])
+  ]);
+  const build = (ids: number[]): Node => {
+    const box: [number, number, number, number] = [Infinity, Infinity, -Infinity, -Infinity];
+    for (const id of ids) {
+      tick();
+      const b = boxes[id];
+      box[0] = Math.min(box[0], b[0]);
+      box[1] = Math.min(box[1], b[1]);
+      box[2] = Math.max(box[2], b[2]);
+      box[3] = Math.max(box[3], b[3]);
+    }
+    if (ids.length <= 16) return {box, ids};
+    const axis = box[2] - box[0] >= box[3] - box[1] ? 0 : 1;
+    ids.sort((a, b) => {
+      tick();
+      return boxes[a][axis] + boxes[a][axis + 2] - boxes[b][axis] - boxes[b][axis + 2];
+    });
+    const middle = Math.floor(ids.length / 2);
+    return {box, left: build(ids.slice(0, middle)), right: build(ids.slice(middle))};
+  };
+  const root = build(constraints.map((_, i) => i));
+  const padding = tolerance * Math.max(1, root.box[2] - root.box[0], root.box[3] - root.box[1]);
+  const query = (a: Position, b: Position) => {
+    const box: Box = [
+        Math.min(a[0], b[0]) - padding,
+        Math.min(a[1], b[1]) - padding,
+        Math.max(a[0], b[0]) + padding,
+        Math.max(a[1], b[1]) + padding
+      ],
+      ids: number[] = [];
+    const overlaps = (b: Box) =>
+      b[0] <= box[2] && b[2] >= box[0] && b[1] <= box[3] && b[3] >= box[1];
+    const visit = (node: Node) => {
+      tick();
+      if (!overlaps(node.box)) return;
+      if (node.ids) {
+        for (const id of node.ids) {
+          tick();
+          if (overlaps(boxes[id])) ids.push(id);
+        }
+      } else {
+        visit(node.left!);
+        visit(node.right!);
+      }
+    };
+    visit(root);
+    return ids.map(id => constraints[id]);
+  };
+  const rings: Position[][] = [],
+    owners: ConstraintOwner[][] = [];
+  for (const ring of output) {
+    const points: Position[] = [];
+    for (let i = 1; i < ring.length; i++) {
+      const a = ring[i - 1],
+        b = ring[i];
+      if (a.every((v, k) => v === b[k])) continue;
+      const breaks: {t: number; p: Position}[] = [{t: 0, p: a}];
+      for (const c of query(a, b))
+        if (on(c.a, a, b) && (!accept || accept(c.a))) {
+          const t = fraction(c.a, a, b);
+          if (t > 1e-12 && t < 1 - 1e-12) breaks.push({t, p: c.a});
+        }
+      breaks.sort((a, b) => a.t - b.t);
+      for (const item of breaks)
+        if (
+          !points.length ||
+          Math.hypot(...points[points.length - 1].map((v, k) => v - item.p[k])) > 1e-14
+        )
+          points.push([...item.p]);
+    }
+    if (points.length < 3) continue;
+    points.push([...points[0]]);
+    const tags: ConstraintOwner[] = [];
+    for (let i = 1; i < points.length; i++) {
+      const a = points[i - 1],
+        b = points[i];
+      if (degenerate?.(a, b)) {
+        tags.push(null);
+        continue;
+      }
+      let candidates = query(a, b).filter(c => on(a, c.a, c.b) && on(b, c.a, c.b));
+      const same = (p: Position, q: Position) =>
+        Math.hypot(...p.map((v, k) => v - q[k])) <=
+        64 * Number.EPSILON * Math.max(1, ...p.map(Math.abs), ...q.map(Math.abs));
+      const exact = candidates.filter(
+        c => (same(a, c.a) && same(b, c.b)) || (same(a, c.b) && same(b, c.a))
+      );
+      if (exact.length) candidates = exact;
+      if (candidates.some(c => priorities?.[c.r]?.[c.i]?.kind === 'source-boundary'))
+        candidates = candidates.filter(c => priorities?.[c.r]?.[c.i]?.kind === 'source-boundary');
+      if (candidates.length > 1) {
+        const score = (c: (typeof candidates)[number]) =>
+          Math.max(
+            ...[a, b].map(p => {
+              const t = Math.min(1, Math.max(0, fraction(p, c.a, c.b)));
+              return Math.hypot(
+                p[0] - c.a[0] - t * (c.b[0] - c.a[0]),
+                p[1] - c.a[1] - t * (c.b[1] - c.a[1])
+              );
+            })
+          );
+        candidates.sort((a, b) => score(a) - score(b));
+        const epsilon = 64 * Number.EPSILON * Math.max(1, ...a.map(Math.abs), ...b.map(Math.abs));
+        if (score(candidates[1]) - score(candidates[0]) > epsilon) candidates = [candidates[0]];
+        else if (Math.hypot(a[0] - b[0], a[1] - b[1]) <= 2 * epsilon) candidates = [];
+        else throw new Error('Ambiguous polygon clipping constraint ancestry');
+      }
+      tags.push(candidates.length ? [candidates[0].r, candidates[0].i] : null);
+    }
+    rings.push(points);
+    owners.push(tags);
+  }
+  return {rings, owners};
+}
+/** Compose directed fractions through a known parent edge; never search raw
+ * input geometry for an original segment after resampling or projection. */
+export function composePolygonEdge(
+  parent: MapPolygonEdge,
+  a: Position,
+  b: Position,
+  start: Position,
+  end: Position
+): MapPolygonEdge {
+  if (parent.kind !== 'source-boundary') return {...parent};
+  const v = geographic(a),
+    length = angle(v, geographic(b));
+  const parameter = (p: Position) => (length ? Math.min(1, angle(v, geographic(p)) / length) : 0);
+  return {
+    ...parent,
+    t0: parent.t0 + parameter(start) * (parent.t1 - parent.t0),
+    t1: parent.t0 + parameter(end) * (parent.t1 - parent.t0)
+  };
+}

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]})));
+}