@weasel-js/geom 1.13.0 → 1.14.0

package/dist/warp/index.js

@@ -1,10 +1,10 @@
-import { boundsOfPath, keepCorner, fitPointRun } from '../chunk-STGSBIOL.js';
-import { pathToAnchors, anchorsToPath } from '../chunk-Q66NA2FU.js';
-import '../chunk-CE7IY7TB.js';
-import { nestRings, flattenPolygon, resolveCrossings } from '../chunk-UGE57OTX.js';
-import { pointInPolygon } from '../chunk-2PKPKU4P.js';
+import { boundsOfPath, keepCorner, fitPointRun } from '../chunk-ZOMUTU7J.js';
+import { pathToAnchors, anchorsToPath } from '../chunk-3HQJGI63.js';
+import { nearestOnLine } from '../chunk-2N6OWA7E.js';
+import { nestRings, flattenPolygon, resolveCrossings } from '../chunk-GWSJQSQE.js';
+import { pointInPolygon } from '../chunk-EURWZUNY.js';
 import '../chunk-755Y4YZS.js';
-import { cubicPointAt } from '../chunk-B53BERKG.js';
+import { cubicPointAt, addOrigin } from '../chunk-B3D6KWW3.js';
 import earcut from 'earcut';
 
 // src/warp/quad.ts
@@ -225,6 +225,41 @@ function factorSymmetric(rows) {
       const x = new Float64Array(n);
       for (let k = 0; k < n; k++) x[order[k]] = y[k];
       return x;
+    },
+    solvePair(b) {
+      const y = new Float64Array(2 * n);
+      for (let k = 0; k < n; k++) {
+        y[2 * k] = b[2 * order[k]];
+        y[2 * k + 1] = b[2 * order[k] + 1];
+      }
+      for (let i = 0; i < n; i++) {
+        const fi = first[i], si = start[i];
+        let sx = y[2 * i], sy = y[2 * i + 1];
+        for (let k = fi; k < i; k++) {
+          const l = L[si + k - fi];
+          sx -= l * y[2 * k];
+          sy -= l * y[2 * k + 1];
+        }
+        const d = L[si + i - fi];
+        y[2 * i] = sx / d;
+        y[2 * i + 1] = sy / d;
+      }
+      for (let i = n - 1; i >= 0; i--) {
+        const fi = first[i], si = start[i];
+        const d = L[si + i - fi];
+        const yx = y[2 * i] /= d, yy = y[2 * i + 1] /= d;
+        for (let k = fi; k < i; k++) {
+          const l = L[si + k - fi];
+          y[2 * k] -= l * yx;
+          y[2 * k + 1] -= l * yy;
+        }
+      }
+      const x = new Float64Array(2 * n);
+      for (let k = 0; k < n; k++) {
+        x[2 * order[k]] = y[2 * k];
+        x[2 * order[k] + 1] = y[2 * k + 1];
+      }
+      return x;
     }
   };
 }
@@ -293,10 +328,78 @@ function edgeEnergy(tris, n) {
   return rows;
 }
 
+// src/warp/lbfgs.ts
+var DEPTH = 6;
+function stepMemory() {
+  return { steps: [], turns: [], bentTurns: [], rho: new Float64Array(DEPTH), count: 0, newest: -1, lastGrad: null, lastStep: null, lastBent: null };
+}
+function forget(m) {
+  m.count = 0;
+  m.newest = -1;
+  m.lastGrad = null;
+  m.lastStep = null;
+}
+function dot(a, b) {
+  let s = 0;
+  for (let i = 0; i < a.length; i++) s += a[i] * b[i];
+  return s;
+}
+function remember(m, g, bent) {
+  const { lastGrad, lastStep, lastBent } = m;
+  if (!lastGrad || !lastStep || !lastBent) return;
+  const slot = (m.newest + 1) % DEPTH;
+  if (m.steps.length <= slot || m.steps[slot].length !== g.length) {
+    m.steps[slot] = new Float64Array(g.length);
+    m.turns[slot] = new Float64Array(g.length);
+    m.bentTurns[slot] = new Float64Array(g.length);
+  }
+  const s = m.steps[slot], y = m.turns[slot], py = m.bentTurns[slot];
+  let sy = 0;
+  for (let i = 0; i < g.length; i++) {
+    s[i] = lastStep[i];
+    y[i] = g[i] - lastGrad[i];
+    py[i] = bent[i] - lastBent[i];
+    sy += y[i] * s[i];
+  }
+  if (!(sy > 1e-12)) return;
+  m.rho[slot] = 1 / sy;
+  m.newest = slot;
+  m.count = Math.min(DEPTH, m.count + 1);
+}
+function descent(m, g, precondition, scaled = false) {
+  const r = precondition(Float64Array.from(g));
+  remember(m, g, r);
+  m.lastBent = Float64Array.from(r);
+  const q = Float64Array.from(g);
+  const n = q.length;
+  const alpha = new Float64Array(m.count);
+  for (let k = 0; k < m.count; k++) {
+    const slot = (m.newest - k + DEPTH) % DEPTH;
+    const s = m.steps[slot], y = m.turns[slot], py = m.bentTurns[slot];
+    const a = alpha[k] = m.rho[slot] * dot(s, q);
+    for (let j = 0; j < n; j++) {
+      q[j] -= a * y[j];
+      r[j] -= a * py[j];
+    }
+  }
+  if (scaled && m.count > 0) {
+    const scale = 1 / (m.rho[m.newest] * dot(m.turns[m.newest], m.bentTurns[m.newest]));
+    for (let j = 0; j < n; j++) r[j] *= scale;
+  }
+  for (let k = m.count - 1; k >= 0; k--) {
+    const slot = (m.newest - k + DEPTH) % DEPTH;
+    const s = m.steps[slot], y = m.turns[slot];
+    const c = alpha[k] - m.rho[slot] * dot(y, r);
+    for (let j = 0; j < n; j++) r[j] += c * s[j];
+  }
+  for (let j = 0; j < n; j++) r[j] = -r[j];
+  return r;
+}
+
 // src/warp/injective.ts
 function restFrames(rest, tris) {
   const nt = tris.length / 3;
-  const inv = new Float64Array(4 * nt), area = new Float64Array(nt);
+  const inv = new Float64Array(4 * nt), area = new Float64Array(nt), side = new Int8Array(nt);
   for (let t = 0; t < nt; t++) {
     const a = tris[3 * t], b = tris[3 * t + 1], c = tris[3 * t + 2];
     const ux = rest[2 * b] - rest[2 * a], uy = rest[2 * b + 1] - rest[2 * a + 1];
@@ -305,8 +408,9 @@ function restFrames(rest, tris) {
     if (det === 0) continue;
     inv.set([vy / det, -vx / det, -uy / det, ux / det], 4 * t);
     area[t] = Math.abs(det) / 2;
+    side[t] = Math.sign(det);
   }
-  return { inv, area };
+  return { inv, area, side };
 }
 var FLIP_MARGIN = 0.8;
 var ARMIJO = 1e-4;
@@ -326,11 +430,11 @@ function jacobian(piece, pos, t, J) {
   return true;
 }
 function flipBound(piece, pos, d) {
-  const { tris, rest } = piece;
+  const { tris, frames } = piece;
   let bound = Infinity;
   for (let t = 0; t < tris.length; t += 3) {
     const a = tris[t], b = tris[t + 1], c = tris[t + 2];
-    const side = Math.sign((rest[2 * b] - rest[2 * a]) * (rest[2 * c + 1] - rest[2 * a + 1]) - (rest[2 * b + 1] - rest[2 * a + 1]) * (rest[2 * c] - rest[2 * a]));
+    const side = frames.side[t / 3];
     if (side === 0) continue;
     const ux = pos[2 * b] - pos[2 * a], uy = pos[2 * b + 1] - pos[2 * a + 1];
     const vx = pos[2 * c] - pos[2 * a], vy = pos[2 * c + 1] - pos[2 * a + 1];
@@ -349,23 +453,54 @@ function smallestPositiveRoot(c0, c1, c2) {
   const disc = c1 * c1 - 4 * c2 * c0;
   if (disc < 0) return Infinity;
   const q = -0.5 * (c1 + Math.sign(c1 || 1) * Math.sqrt(disc));
-  const roots = [q / c2, c0 / q].filter((s) => s > 0 && Number.isFinite(s));
-  return roots.length ? Math.min(...roots) : Infinity;
+  const r1 = q / c2, r2 = c0 / q;
+  let least = Infinity;
+  if (r1 > 0 && r1 < least) least = r1;
+  if (r2 > 0 && r2 < least) least = r2;
+  return least;
 }
 var chi = (d, eps) => (d + Math.sqrt(eps * eps + d * d)) / 2;
-function untangleEnergy(piece, pos, eps) {
-  const J = new Float64Array(4);
-  const { area } = piece.frames;
+function energyTerms(piece) {
+  const n = piece.frames.area.length;
+  return { shape: new Float64Array(n), det: new Float64Array(n).fill(Infinity) };
+}
+function untangleEnergy(piece, pos, eps, terms) {
+  const { tris, frames: { area, inv: m } } = piece;
   let E = 0;
   for (let t = 0; t < area.length; t++) {
-    if (!jacobian(piece, pos, t, J)) continue;
-    const d = J[0] * J[3] - J[1] * J[2];
+    if (area[t] === 0) continue;
+    const a = tris[3 * t], b = tris[3 * t + 1], cc = tris[3 * t + 2], i = 4 * t;
+    const ux = pos[2 * b] - pos[2 * a], uy = pos[2 * b + 1] - pos[2 * a + 1];
+    const vx = pos[2 * cc] - pos[2 * a], vy = pos[2 * cc + 1] - pos[2 * a + 1];
+    const j0 = ux * m[i] + vx * m[i + 2], j1 = ux * m[i + 1] + vx * m[i + 3];
+    const j2 = uy * m[i] + vy * m[i + 2], j3 = uy * m[i + 1] + vy * m[i + 3];
+    const d = j0 * j3 - j1 * j2;
     const c = chi(d, eps);
     if (!(c > 0)) return Infinity;
-    E += area[t] * (J[0] * J[0] + J[1] * J[1] + J[2] * J[2] + J[3] * J[3] + AREA * (d * d + 1)) / c;
+    const shape = area[t] * (j0 * j0 + j1 * j1 + j2 * j2 + j3 * j3 + AREA * (d * d + 1));
+    if (terms) {
+      terms.shape[t] = shape;
+      terms.det[t] = d;
+    }
+    E += shape / c;
   }
   return E;
 }
+function energyAt(terms, eps) {
+  let E = 0;
+  for (let t = 0; t < terms.shape.length; t++) if (terms.shape[t] > 0) E += terms.shape[t] / chi(terms.det[t], eps);
+  return E;
+}
+function restEnergy(piece) {
+  let E = 0;
+  for (const a of piece.frames.area) E += a * (2 + 2 * AREA);
+  return E;
+}
+function leastOf(terms) {
+  let least = Infinity;
+  for (let t = 0; t < terms.det.length; t++) if (terms.det[t] < least) least = terms.det[t];
+  return least;
+}
 function leastArea(piece, pos) {
   const J = new Float64Array(4);
   let least = Infinity;
@@ -375,23 +510,25 @@ function leastArea(piece, pos) {
   return least;
 }
 function gradient(piece, pos, eps) {
-  const { tris, frames } = piece;
+  const { tris, frames: { area, inv: m } } = piece;
   const g = new Float64Array(pos.length);
-  const J = new Float64Array(4);
-  for (let t = 0; t < frames.area.length; t++) {
-    if (!jacobian(piece, pos, t, J)) continue;
-    const d = J[0] * J[3] - J[1] * J[2];
+  for (let t = 0; t < area.length; t++) {
+    if (area[t] === 0) continue;
+    const a = tris[3 * t], b = tris[3 * t + 1], cc = tris[3 * t + 2], i = 4 * t;
+    const ux = pos[2 * b] - pos[2 * a], uy = pos[2 * b + 1] - pos[2 * a + 1];
+    const vx = pos[2 * cc] - pos[2 * a], vy = pos[2 * cc + 1] - pos[2 * a + 1];
+    const j0 = ux * m[i] + vx * m[i + 2], j1 = ux * m[i + 1] + vx * m[i + 3];
+    const j2 = uy * m[i] + vy * m[i + 2], j3 = uy * m[i + 1] + vy * m[i + 3];
+    const d = j0 * j3 - j1 * j2;
     const root = Math.sqrt(eps * eps + d * d);
     const c = (d + root) / 2;
-    const A = frames.area[t];
-    const top = J[0] * J[0] + J[1] * J[1] + J[2] * J[2] + J[3] * J[3] + AREA * (d * d + 1);
+    const A = area[t];
+    const top = j0 * j0 + j1 * j1 + j2 * j2 + j3 * j3 + AREA * (d * d + 1);
     const dc = root === 0 ? 0.5 : (1 + d / root) / 2;
     const s = 2 * A / c, r = A * (2 * AREA * d / c - top * dc / (c * c));
-    const g0 = s * J[0] + r * J[3], g1 = s * J[1] - r * J[2], g2 = s * J[2] - r * J[1], g3 = s * J[3] + r * J[0];
-    const m = frames.inv, i = 4 * t;
+    const g0 = s * j0 + r * j3, g1 = s * j1 - r * j2, g2 = s * j2 - r * j1, g3 = s * j3 + r * j0;
     const gux = g0 * m[i] + g1 * m[i + 1], gvx = g0 * m[i + 2] + g1 * m[i + 3];
     const guy = g2 * m[i] + g3 * m[i + 1], gvy = g2 * m[i + 2] + g3 * m[i + 3];
-    const a = tris[3 * t], b = tris[3 * t + 1], cc = tris[3 * t + 2];
     g[2 * b] += gux;
     g[2 * b + 1] += guy;
     g[2 * cc] += gvx;
@@ -407,46 +544,59 @@ function turnedOver(piece, pos) {
 function startingEps(piece, pos) {
   return Math.max(1e-3, 2 * Math.abs(Math.min(0, leastArea(piece, pos))));
 }
-function nextEps(piece, pos, eps, before, after) {
-  const least = leastArea(piece, pos);
-  const sigma = Math.max(1 - after / before, 0.1);
+var SHRINK_TURNED = 0.2;
+var SHRINK_CLEAR = 0.05;
+function nextEps(least, eps, before, after) {
+  const sigma = Math.max(1 - after / before, least > 0 ? SHRINK_CLEAR : SHRINK_TURNED);
   const mu = (1 - sigma) * chi(least, eps);
   return least < mu ? 2 * Math.sqrt(mu * (mu - least)) : 0;
 }
-function untangleRound(piece, pos, eps, energy) {
+function untangleRound(piece, pos, eps, energy, memory) {
   const { pinOf, freeOf, step2 } = piece;
+  const terms = energyTerms(piece);
   const g = gradient(piece, pos, eps);
   const nf = step2.coupling.length;
-  const bx = new Float64Array(nf), by = new Float64Array(nf);
+  const gf = new Float64Array(2 * nf);
   for (let i = 0; i < pinOf.length; i++) {
-    if (freeOf[i] >= 0) {
-      bx[freeOf[i]] = -g[2 * i];
-      by[freeOf[i]] = -g[2 * i + 1];
+    const f = freeOf[i];
+    if (f >= 0) {
+      gf[2 * f] = g[2 * i];
+      gf[2 * f + 1] = g[2 * i + 1];
     }
   }
-  const dx = solveSplit(step2, () => 0, bx);
-  const dy = solveSplit(step2, () => 0, by);
+  const precondition = (q) => step2.factored.solvePair(q);
+  let df = descent(memory, gf, precondition, eps === 0);
+  let slope = dot(gf, df);
+  if (!(slope < 0)) {
+    forget(memory);
+    df = memory.lastBent.map((v) => -v);
+    slope = dot(gf, df);
+  }
   const d = new Float64Array(pos.length);
-  let slope = 0;
   for (let i = 0; i < pinOf.length; i++) {
     const f = freeOf[i];
-    if (f < 0) continue;
-    d[2 * i] = dx[f];
-    d[2 * i + 1] = dy[f];
-    slope += g[2 * i] * dx[f] + g[2 * i + 1] * dy[f];
+    if (f >= 0) {
+      d[2 * i] = df[2 * f];
+      d[2 * i + 1] = df[2 * f + 1];
+    }
   }
   let s = eps > 0 ? 1 : Math.min(1, FLIP_MARGIN * flipBound(piece, pos, d));
   const next = new Float64Array(pos.length);
   for (; s > 1e-12; s /= 2) {
     for (let i = 0; i < next.length; i++) next[i] = pos[i] + s * d[i];
-    const e = untangleEnergy(piece, next, eps);
+    const e = untangleEnergy(piece, next, eps, terms);
     if (e <= energy + ARMIJO * s * slope) {
-      let moved = 0;
-      for (let i = 0; i < d.length; i += 2) moved = Math.max(moved, s * Math.hypot(d[i], d[i + 1]));
-      return { pos: next, energy: e, moved };
+      let far = 0;
+      for (let i = 0; i < d.length; i += 2) far = Math.max(far, d[i] * d[i] + d[i + 1] * d[i + 1]);
+      const moved = s * Math.sqrt(far);
+      memory.lastGrad = gf;
+      memory.lastStep = df.map((v) => s * v);
+      return { pos: next, energy: e, terms, moved };
     }
   }
-  return { pos, energy, moved: 0 };
+  forget(memory);
+  untangleEnergy(piece, pos, eps, terms);
+  return { pos, energy, terms, moved: 0 };
 }
 
 // src/warp/arapPiece.ts
@@ -497,18 +647,18 @@ function rigidRound(piece, targets, pos) {
   const bx = new Float64Array(nf), by = new Float64Array(nf);
   let energy = 0;
   for (let t = 0; t < tris.length; t += 3) {
-    let dot = 0, cross = 0, sq = 0;
+    let dot2 = 0, cross = 0, sq = 0;
     for (let e = 0; e < 3; e++) {
       const i = tris[t + e], j = tris[t + (e + 1) % 3];
       const px = rest[2 * i] - rest[2 * j], py = rest[2 * i + 1] - rest[2 * j + 1];
       const qx = pos[2 * i] - pos[2 * j], qy = pos[2 * i + 1] - pos[2 * j + 1];
-      dot += px * qx + py * qy;
+      dot2 += px * qx + py * qy;
       cross += px * qy - py * qx;
       sq += px * px + py * py + qx * qx + qy * qy;
     }
-    const len = Math.hypot(dot, cross);
+    const len = Math.hypot(dot2, cross);
     energy += sq - 2 * len;
-    const cos = len === 0 ? 1 : dot / len, sin = len === 0 ? 0 : cross / len;
+    const cos = len === 0 ? 1 : dot2 / len, sin = len === 0 ? 0 : cross / len;
     for (let e = 0; e < 3; e++) {
       const i = tris[t + e], j = tris[t + (e + 1) % 3];
       const ex = rest[2 * i] - rest[2 * j], ey = rest[2 * i + 1] - rest[2 * j + 1];
@@ -544,6 +694,8 @@ function placePiece(piece, pos, out) {
 var ARAP_ROUNDS = 5;
 var ARAP_INJECTIVE_ROUNDS = 100;
 var SETTLED = 1e-4;
+var SETTLED_ENERGY = 3e-3;
+var CALM_ROUNDS = 2;
 function piecesOf(mesh) {
   const n = mesh.vertices.length >> 1;
   const parent = Int32Array.from({ length: n }, (_, i) => i);
@@ -594,15 +746,15 @@ function rigidFit(from, to) {
   pcy /= k;
   qcx /= k;
   qcy /= k;
-  let dot = 0, cross = 0;
+  let dot2 = 0, cross = 0;
   for (let i = 0; i < k; i++) {
     const px = from[2 * i] - pcx, py = from[2 * i + 1] - pcy;
     const qx = to[2 * i] - qcx, qy = to[2 * i + 1] - qcy;
-    dot += px * qx + py * qy;
+    dot2 += px * qx + py * qy;
     cross += px * qy - py * qx;
   }
-  const len = Math.hypot(dot, cross);
-  const cos = len === 0 ? 1 : dot / len, sin = len === 0 ? 0 : cross / len;
+  const len = Math.hypot(dot2, cross);
+  const cos = len === 0 ? 1 : dot2 / len, sin = len === 0 ? 0 : cross / len;
   return (x, y) => [cos * (x - pcx) - sin * (y - pcy) + qcx, sin * (x - pcx) + cos * (y - pcy) + qcy];
 }
 function createArapSolver(mesh, pinned) {
@@ -663,22 +815,23 @@ function createArapSolver(mesh, pinned) {
       if (tangled.some(Boolean)) {
         const state = solved.map((piece, k) => {
           const eps = tangled[k] ? startingEps(piece, pos[k]) : 0;
-          return { pos: pos[k], eps, energy: tangled[k] ? untangleEnergy(piece, pos[k], eps) : 0, live: tangled[k] };
+          return { pos: pos[k], eps, energy: tangled[k] ? untangleEnergy(piece, pos[k], eps) : 0, live: tangled[k], memory: stepMemory(), calm: 0, rest: restEnergy(piece) };
         });
         let r = 1;
         for (; r <= injective && state.some((s) => s.live); r++) {
           solved.forEach((piece, k) => {
             const s = state[k];
             if (!s.live) return;
-            const step = untangleRound(piece, s.pos, s.eps, s.energy);
-            const settled = step.moved <= SETTLED * piece.size || s.energy - step.energy <= SETTLED * step.energy;
+            const step = untangleRound(piece, s.pos, s.eps, s.energy, s.memory);
+            const settled = step.moved <= SETTLED * piece.size || s.energy - step.energy <= SETTLED_ENERGY * (step.energy - s.rest);
             s.pos = step.pos;
             if (s.eps > 0) {
-              s.eps = nextEps(piece, s.pos, s.eps, s.energy, step.energy);
-              s.energy = untangleEnergy(piece, s.pos, s.eps);
+              s.eps = nextEps(leastOf(step.terms), s.eps, s.energy, step.energy);
+              s.energy = energyAt(step.terms, s.eps);
             } else {
               s.energy = step.energy;
-              s.live = !settled;
+              s.calm = settled ? s.calm + 1 : 0;
+              s.live = s.calm < CALM_ROUNDS;
             }
             placePiece(piece, s.pos, out);
           });
@@ -1061,6 +1214,7 @@ function refineTriangulation(coords, triangles, firstInner) {
 // src/warp/puppetMesh.ts
 function ringsOf(path, tolerance) {
   const flat = flattenPolygon(path, tolerance);
+  addOrigin(path, flat.coords);
   if (path.fillRule === "evenodd") return { flat, filled: (w) => w % 2 !== 0 };
   const crossed = resolveCrossings(flat);
   const nonzero = (w) => w !== 0;
@@ -1310,6 +1464,8 @@ function unwarpPoint(map, target, guess = target, tolerance = 1e-3) {
 // src/warp/warpPath.ts
 var MIN_SAMPLES = 8;
 var MAX_SAMPLES = 64;
+var FLATNESS = 0.25;
+var MAX_HALVINGS = 6;
 var TANGENT_STEP = 1e-3;
 function warpPath(path, map, opts = {}) {
   const tol = Math.max(opts.tolerance ?? 0.5, 1e-6);
@@ -1328,8 +1484,7 @@ function warpSubpath(sub, closed, map, tol) {
     const b = sub[(i + 1) % n];
     const at = segmentAt(a, b);
     const count = sampleCount(a, b, tol);
-    const pts = [];
-    for (let k = 0; k <= count; k++) pts.push(map(at(k / count)));
+    const pts = sampleWarped((t) => map(at(t)), count, tol);
     const start = pts[0];
     const end = pts[pts.length - 1];
     const tStart = unit(sub2(map(at(TANGENT_STEP)), start));
@@ -1362,6 +1517,25 @@ function sampleCount(a, b, tol) {
   const len = Math.hypot(c1.x - a.x, c1.y - a.y) + Math.hypot(c2.x - c1.x, c2.y - c1.y) + Math.hypot(b.x - c2.x, b.y - c2.y);
   return Math.min(MAX_SAMPLES, Math.max(MIN_SAMPLES, Math.ceil(len / (8 * tol))));
 }
+function sampleWarped(curve, count, tol) {
+  const flat = FLATNESS * tol;
+  const out = [curve(0)];
+  const span = (t0, p0, t1, p1, depth) => {
+    const tm = (t0 + t1) / 2;
+    const pm = curve(tm);
+    if (depth < MAX_HALVINGS && fromChord(pm, p0, p1) > flat) {
+      span(t0, p0, tm, pm, depth + 1);
+      span(tm, pm, t1, p1, depth + 1);
+    } else {
+      out.push(p1);
+    }
+  };
+  for (let k = 0; k < count; k++) span(k / count, out[out.length - 1], (k + 1) / count, curve((k + 1) / count), 0);
+  return out;
+}
+function fromChord(p, a, b) {
+  return nearestOnLine(p.x, p.y, a.x, a.y, b.x, b.y).dist;
+}
 function dedupe(pts) {
   return pts.filter((p, i) => i === 0 || p.x !== pts[i - 1].x || p.y !== pts[i - 1].y);
 }