flo-mat 4.1.5 → 5.0.2

package/package.json

@@ -2,7 +2,7 @@
     "name": "flo-mat",
     "sideEffects": false,
     "description": "Medial / Scale Axis Transform (MAT/SAT) Library.",
-    "version": "4.1.5",
+    "version": "5.0.2",
     "author": {
         "name": "Floris Steenkamp"
     },
@@ -31,22 +31,22 @@
         "skeleton"
     ],
     "dependencies": {
-        "big-float-ts": "^4.0.4",
-        "double-double": "^3.0.4",
-        "flo-bezier3": "^8.1.1",
-        "flo-boolean": "^6.0.2",
+        "big-float-ts": "^4.0.5",
+        "double-double": "^4.0.0",
+        "flo-bezier3": "^9.0.1",
+        "flo-boolean": "^6.0.3",
         "flo-gauss-quadrature": "^2.1.4",
         "flo-ll-rb-tree": "^1.0.4",
         "flo-memoize": "^2.0.1",
-        "flo-poly": "^8.1.4",
+        "flo-poly": "^9.0.2",
         "flo-vector2d": "^4.0.6"
     },
     "devDependencies": {
         "@jest/globals": "^30.5.2",
-        "@swc/core": "^1.16.13",
+        "@swc/core": "^1.16.18",
         "@swc/jest": "^0.2.39",
         "@types/jest": "^30.0.0",
-        "@types/node": "^26.6.4",
+        "@types/node": "^26.6.5",
         "c8": "^12.0.0",
         "cheerio": "^1.2.0",
         "circular-dependency-plugin": "^5.2.2",
@@ -70,6 +70,6 @@
     "allowScripts": {
         "unrs-resolver@1.12.2": true,
         "@parcel/watcher@2.6.0": true,
-        "@swc/core@1.16.13": true
+        "@swc/core@1.16.18": true
     }
 }

package/qv-infinite-loop.md

@@ -0,0 +1,120 @@
+# Q_V infinite loop - investigation handoff
+
+Status: root cause found, **nothing fixed yet**. All diagnostic instrumentation
+has been removed from `src/`.
+
+## Symptom
+
+`findMats` never returns for the `Q_V` glyph of `__tests__/specific-cases/test-svgs/achispado.svg`
+**once the 1-prong pass is enabled**, i.e. once line 39 of
+`src/find-mat/get-for-1-prongs-on-loop.ts` reads
+
+```ts
+.filter(pos => pos.t > 2**-20 && pos.t < 1 - 2**-20);
+```
+
+(The historical form `pos.t < 2**-20` is impossible, so the 1-prong pass added
+nothing and the problem was invisible. Line 39 is correct as written above; the
+bug is elsewhere.)
+
+Reproduce (the loop is synchronous, so only a process-level time limit stops it;
+use Git Bash for `timeout`):
+
+```
+timeout 120 npx jest __tests__/specific-cases      # with "Q_V" in the glyph list
+```
+
+## Where it loops
+
+`findAndAdd3Prongs` (`src/find-3-prong/find-and-add-3-prongs.ts`, the
+`do ... while (true)`), started from CpNode #90. Each iteration:
+
+1. `traverseCp(#90)` visits the same 7-vertex face.
+2. `find3Prong` finds the same 3-prong: radius 23.18, contacts at the dull
+   corner at the end of curve 10, the dull corner at the end of curve 14, and
+   curve 14 at t = 0.726.
+3. `findAndAdd3Prong`'s close-by check (`getCloseByCpIfExist`) *does* find the
+   copy inserted in the previous iteration, but `if (prongCount <= 2 && ...)`
+   ignores anything that is already a 3-prong, so a duplicate is inserted.
+4. The face does not shrink (the new nodes interleave with existing ones at the
+   two corners) - repeat forever.
+
+## Why the face is wrong
+
+`traverseCp` from #90 returns to its own vertex through the *other* node #91 and
+continues, so vertex {#90, #91} appears twice on one face. That 2-prong is
+geometrically invalid: center [567.20, 736.36], radius 14.99; its contacts
+(curve 13 at t = 0.9999926 and the far dull corner of curve 14, t = 1)
+interleave along the boundary with those of the existing 3-prong A
+(curve 13 at 0.58, curve 14 at 0.7265), and A's contact point on curve 14
+([559.44, 748.45]) is 14.37 from the disk's center - inside the disk. The disk
+cuts through curve 14.
+
+## Root cause: a degenerate bezier end in the font data
+
+Curve 13 (raw path bezier 21) is a tiny cubic whose last two control points are
+identical in the SVG itself:
+
+```
+[[551.49,738.38],[552.36,738.88],[552.7243186433545,740.2428659207691],[552.7243186433545,740.2428659207691]]
+```
+
+Its speed is therefore 0 at t = 1 (|tangent| ~ 2e-10). Three things break:
+
+1. **Spurious curvature maximum.** `getCurvatureExtremaDd` reports a maximum at
+   t = 0.9999925600310483 - the curvature blowing up toward the zero-speed end
+   (2.6e3 there, -4e19 at t = 1), not a feature of the shape. It passes the
+   line-39 filter: 7e-6 in parameter from the end, ~1e-10 in distance. The
+   candidate *is* the c13/c14 junction.
+2. **Garbage normal.** `ddNormal` at that t is a vector of length 6e-5 whose
+   direction is ~11 degrees off the true inward direction at the junction. The
+   2-prong ray search runs along it (curve 14 *was* fully in the searched
+   pieces), finds no interior tangency on that ray, and accepts the far corner
+   of curve 14 at distance 14.99. `getOsculatingCircle` clamps rO to the maximum
+   (1346.7) because the curvature sign is wrong there.
+3. **Corner not detected.** The c13/c14 junction is a real corner of ~8 degrees,
+   but `getInterfaceCcw(c13.ps, c14.ps)` takes curve 13's end tangent from the
+   3e-11-long derivative; the unit tangent comes out as (0.447, 0.894) - a 1:2
+   rounding residue - giving a 3.5 degree turn, under the 4 degree `DEGREE_LIMIT`.
+   Result: `isDull = true`, `isQuiteDull = false`, so the corner gets no corner
+   handling and no corner contact points at all.
+
+So the spurious contact sits exactly at a corner position but is ordered as an
+interior point of curve 13 (order 0), outside all corner-ordering logic, while
+the corner itself is never registered - hence the "ordering" smell.
+
+## Suggested fixes (not implemented)
+
+Most fundamental first:
+
+- Handle near-zero end derivatives: in `getInterfaceCcw` take the end tangent
+  from the last *distinct* control point when control points coincide; reject
+  curvature-extrema 1-prong candidates where the speed is below a scaled
+  threshold (or where the osculating radius comes back clamped to the maximum).
+- Make `findAndAdd3Prong` treat an existing 3-prong at the same contact points
+  as a duplicate (drop or rethink the `prongCount <= 2` filter) so a repeat is
+  detected instead of re-inserted.
+- Put an iteration cap on the `do ... while (true)` in `findAndAdd3Prongs` that
+  throws with context, so this class of bug fails loudly.
+- Consider making `traverseCp` terminate on reaching the start *vertex* (any
+  node on the start circle), not the start *node*, which would have exposed the
+  inconsistency immediately.
+
+## Useful diagnostics (how it was found, for re-use)
+
+- `node --prof node_modules/jest/bin/jest.js --runInBand <spec>` under
+  `timeout`, then `node --prof-process isolate-*.log`: the V8 log is appended
+  while running, so it survives the kill and shows the hot functions.
+- A per-call iteration counter in `findAndAdd3Prongs` that logs `traverseCp`'s
+  visited nodes (id, curve idx, t, order, radius, ring members, prev/next) once
+  a call exceeds ~3 iterations, plus logging of `getCloseByCpIfExist` results
+  and `insertCpNode` pred/succ in `addToCpTree`, found the duplicate cycle.
+- Logging `nnorm`, `rO`, the searched curve pieces and the antipodes in
+  `find2Prong` for the source at curve 13, t > 0.9999 exposed the bad ray.
+
+## Working-tree state to be aware of
+
+- Line 39 of `get-for-1-prongs-on-loop.ts` is currently back in the impossible
+  `pos.t < 2**-20` form (1-prong pass disabled again).
+- `__tests__/specific-cases/specific-cases.spec.ts` currently lists only `"Q_V"`;
+  the full glyph list from HEAD must be restored before committing.

package/src/closest-boundary-point/cull-curve-pieces.ts

@@ -0,0 +1,49 @@
+import type { CurvePiece } from '../mat/curve-piece.js';
+import { getBoundingBox$, getBoundingBoxTight$ } from '../geometry/get-bounding-box-.js';
+import { getClosestSquareDistanceToRect } from '../geometry/get-closest-square-distance-to-rect.js';
+import { getClosestSquaredDistanceToRotatedRect } from '../geometry/get-closest-squared-distance-to-rotated-rect.js';
+
+
+/**
+ * Returns the given curve pieces with those culled whose closest possible
+ * point to `p` is further than `sqrt(maxSquaredDistance)` away.
+ *
+ * * a piece is kept only if both its (cheap, axis-aligned) loose bounding box
+ *   and then its (rotated) tight bounding box come within the distance
+ * * the bounding boxes are those of the entire curves (not just the pieces)
+ *   and are memoized per curve
+ * * the given array is not modified (callers may reuse it for other points)
+ * * any tolerance for floating point error is the responsibility of the
+ *   caller (i.e. `maxSquaredDistance` should already include it)
+ *
+ * @param curvePieces the curve pieces to cull
+ * @param p the point
+ * @param maxSquaredDistance the squared distance beyond which to cull
+ *
+ * @internal
+ */
+function cullCurvePieces(
+        curvePieces: CurvePiece[],
+        p: number[],
+        maxSquaredDistance: number): CurvePiece[] {
+
+    const culled: CurvePiece[] = [];
+
+    for (let i=0; i<curvePieces.length; i++) {
+        const curvePiece = curvePieces[i];
+        const { ps } = curvePiece.curve;
+
+        const d = getClosestSquareDistanceToRect(getBoundingBox$(ps), p);
+        if (d > maxSquaredDistance) { continue; }
+
+        const d2 = getClosestSquaredDistanceToRotatedRect(getBoundingBoxTight$(ps), p);
+        if (d2 > maxSquaredDistance) { continue; }
+
+        culled.push(curvePiece);
+    }
+
+    return culled;
+}
+
+
+export { cullCurvePieces }

package/src/closest-boundary-point/get-close-boundary-points-certified.ts

@@ -2,7 +2,8 @@ import type { CurvePiece  } from '../mat/curve-piece.js';
 import type { FootAndEndpointInfo } from './foot-and-endpoint-info.js';
 import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
 import { getPotentialClosestPointsOnCurveCertified } from './get-potential-closest-points-on-curve-certified.js';
-import { cullCurvePieces1 } from './cull-bezier-pieces-1.js';
+import { cullCurvePieces } from './cull-curve-pieces.js';
+import { getBestDistanceSquared } from './get-best-distance-squared.js';
 import { toP } from '../point-on-shape/to-p.js';
 
 
@@ -20,7 +21,9 @@ function getCloseBoundaryPointsCertified(
         curvePieces: CurvePiece[], 
         x: number[]): PrePointOnShape[] {
     
-    curvePieces = cullCurvePieces1(curvePieces, x);
+    // cull the pieces that cannot contain the closest point (the best
+    // squared distance already includes a floating point tolerance)
+    curvePieces = cullCurvePieces(curvePieces, x, getBestDistanceSquared(curvePieces, x));
  
     const pInfos: FootAndEndpointInfo[] = [];
     for (let i=0; i<curvePieces.length; i++) {

package/src/closest-boundary-point/get-endpoint-info.ts

@@ -0,0 +1,96 @@
+import type { Curve } from "flo-boolean";
+import type { FootAndEndpointInfo } from './foot-and-endpoint-info.js';
+import { evalDeCasteljauWithErrDd } from 'flo-bezier3';
+import { ddDiffDouble } from 'double-double';
+import { eps } from '../error-analysis/gamma.js';
+
+const { abs, max } = Math;
+
+/**
+ * Relative widening of the interval bounds - see the error analysis in
+ * `getEndpointInfoCertified`: the exact first order requirement is `6u = 3eps`
+ * (`u = eps/2` the unit roundoff); `4eps = 2**-50` (exactly representable)
+ * leaves room for the `O(u²)` terms.
+ */
+const WIDEN = 4*eps;
+/**
+ * Absolute slack (relative to `ax² + ay²`) for the lower bound - see the error
+ * analysis: the exact first order requirement is `2u² = eps²/2`.
+ */
+const SLACK = eps*eps;
+
+
+/**
+ * Returns the `FootAndEndpointInfo` of the endpoint at parameter `t` of the
+ * given curve, i.e. the certified interval `dSquaredI` guaranteed to contain
+ * the squared distance from `x` to the point on the curve at `t` (`t` taken as
+ * exact).
+ *
+ * * the point is kept in double-double precision (including its evaluation
+ *   error bound) until the differences with `x` have been taken, so the only
+ *   rounding left is that of forming the interval in double precision, which
+ *   is accounted for exactly below
+ *
+ * Error analysis (`u = eps/2` the unit roundoff, `fl(a∘b) = (a∘b)(1+δ)`,
+ * `|δ| <= u`): let `a` be the exact magnitude of the double-double difference
+ * `dx` and `Δx` the true (exact) difference. Then
+ * * `|Δx| ∈ [a(1-ρ) - ex, a(1+ρ) + ex]` with `ρ = 2u²` (the relative error
+ *   bound of the double-double minus double subtraction) and `ex` the
+ *   evaluation error bound on the coordinate
+ * * `ax = |hi(dx)|` satisfies `|ax - a| <= u·ax` (the low part of a
+ *   normalized double-double is at most half an ulp of the high part)
+ * * the upper bound `(ax+ex)² + (ay+ey)²` is then computed with 3 roundings
+ *   (addition, square, sum) and widened with 1 more; it must dominate
+ *   `(a(1+ρ)+ex)² + ...` which requires `(1-u)⁴(1+WIDEN) >= (1+u+ρ)²`, i.e.
+ *   `WIDEN >= 6u + O(u²)`
+ * * the lower bound `(ax-ex)₊² + (ay-ey)₊²` likewise requires
+ *   `(1+u)⁴(1-WIDEN) <= (1-u-ρ)²`, i.e. `WIDEN >= 6u + O(u²)`, *except* that
+ *   when the true term is `0` (`a <= ex`) rounding may still leave
+ *   `ax - ex <= ax·u` positive, giving a spurious `(ax-ex)² <= 2u²·ax²`; this
+ *   is covered by subtracting `SLACK·(ax² + ay²)` with `SLACK >= 2u²`
+ *
+ * @param curve the curve
+ * @param x the point from which to check
+ * @param t the parameter value of the endpoint
+ *
+ * @internal
+ */
+function getEndpointInfoCertified(
+        curve: Curve,
+        x: number[],
+        t: number): FootAndEndpointInfo {
+
+    const { ps } = curve;
+
+    // the point in double-double precision with coordinate-wise absolute
+    // error bounds `pE`
+    const { p: pDd, pE } = evalDeCasteljauWithErrDd(ps, [0,t]);
+
+    // the coordinate differences in double-double precision
+    const dx = ddDiffDouble(pDd[0], x[0]);
+    const dy = ddDiffDouble(pDd[1], x[1]);
+
+    const ax = abs(dx[1]);
+    const ay = abs(dy[1]);
+    const [ex, ey] = pE;
+
+    const lo = max(ax - ex, 0)**2 + max(ay - ey, 0)**2;
+    const hi = (ax + ex)**2 + (ay + ey)**2;
+
+    const dSquaredI = [
+        max(lo*(1 - WIDEN) - SLACK*(ax*ax + ay*ay), 0),
+        hi*(1 + WIDEN)
+    ];
+
+    const t_ = t === 0 ? 1 : t;
+    const curve_ = t === 0 ? curve.prev : curve;
+
+    return {
+        curve: curve_,
+        t: t_,
+        dSquaredI
+    }
+}
+
+
+export { getEndpointInfoCertified }

package/src/closest-boundary-point/get-potential-closest-points-on-curve-certified.ts

@@ -1,10 +1,9 @@
 import type { Curve } from "flo-boolean";
 import type { FootAndEndpointInfo } from './foot-and-endpoint-info.js';
 import { roots } from 'flo-poly';
-import { evalDeCasteljauDd, getFootPointsOnBezierPolysCertified, getIntervalBox } from 'flo-bezier3';
+import { getFootPointsOnBezierPolysCertified, getIntervalBox } from 'flo-bezier3';
 import { rootIntervalToDistanceSquaredInterval } from './root-interval-to-distance-squared-interval.js';
-import { squaredDistanceBetweenDd } from "../find-2-prong/squared-distance-between-dd.js";
-import { eps } from '../error-analysis/gamma.js';
+import { getEndpointInfoCertified } from './get-endpoint-info.js';
 
 
 /**
@@ -50,27 +49,10 @@ function getPotentialClosestPointsOnCurveCertified(
         }));
     }
 
-    const ts = tRange.slice();
-    if (tS === tE) {
-        ts.push(tS);
-    }
-    
-    infos.push(...ts.map(t => {
-        const p = evalDeCasteljauDd(ps, [0,t]).map(v => v[0] + v[1]);
-
-        const d = squaredDistanceBetweenDd(p, x);
-
-        const dSquaredI = [d*(1 - eps), d*(1 + eps)];
-
-        const t_ = t === 0 ? 1 : t;
-        const curve_ = t === 0 ? curve.prev : curve;
+    // the endpoints of the range (just the one if the range is a single point)
+    const ts = tS === tE ? [tS] : [tS, tE];
 
-        return {
-            curve: curve_,
-            t: t_,
-            dSquaredI
-        }
-    }));
+    infos.push(...ts.map(t => getEndpointInfoCertified(curve, x, t)));
 
     return infos;
 }

package/src/closest-boundary-point/root-interval-to-distance-squared-interval.ts

@@ -1,75 +1,57 @@
-import { twoDiff, ddMultDd, ddAddDd } from 'double-double';
+import { eps } from '../error-analysis/gamma.js';
 
-const td = twoDiff;
-const qmq = ddMultDd;
-const qaq = ddAddDd;
+const { max } = Math;
 
-const eps = Number.EPSILON;
+/**
+ * Relative widening of the interval bounds - see the error analysis in
+ * `rootIntervalToDistanceSquaredInterval`: the exact first order requirement
+ * is `4u = 2eps` (`u = eps/2` the unit roundoff); `4eps = 2**-50` (exactly
+ * representable) leaves room for the `O(u²)` terms.
+ */
+const WIDEN = 4*eps;
 
 
 /**
- * Returns the distance interval squared given the root interval (currently
- * ignoring multiplicity). 
- * 
- * * the result is returned as `[minPossibleSquared, maxPossibleSquared]` distance.
- * 
- * @param box
- * @param p
- * 
+ * Returns an interval `[min, max]` guaranteed to contain the squared distance
+ * from the point `p` to *any* point of a curve piece, given an axis-aligned
+ * box that is guaranteed to engulf that piece (see `getIntervalBox`).
+ *
+ * * the minimum squared distance to the box is attained on its boundary (or
+ *   is `0` if `p` is inside): per axis the distance is the gap between `p` and
+ *   the box's range on that axis (`0` if `p` is within the range)
+ * * the maximum squared distance to the box is attained at a corner: per axis
+ *   it is the larger of the distances to the two range ends
+ *
+ * Error analysis (`u = eps/2` the unit roundoff, `fl(a∘b) = (a∘b)(1+δ)`,
+ * `|δ| <= u`): all inputs are doubles and each bound is computed with 3
+ * roundings per term path (subtraction, square, sum - `max` is exact) and
+ * widened with 1 more, so the computed bound is within a factor `(1±u)⁴` of
+ * the exact one before widening and `WIDEN >= 4u + O(u²)` makes the interval
+ * rigorous. (A gap of `0` is exact: `fl(a-b)` has the sign of `a-b`.)
+ *
+ * @param box the engulfing box given as `[[minX, minY], [maxX, maxY]]`
+ * @param p the point
+ *
  * @internal
  */
 function rootIntervalToDistanceSquaredInterval(
-        box: number[][], 
-        p: number[]) {
-
-    const bl = box[0];
-    const tr = box[1];
-    const minX = bl[0];
-    const minY = bl[1];
-    const maxX = tr[0];
-    const maxY = tr[1];
-
-    const x = p[0];  // <0>
-    const y = p[1];  // <0>
-
-    let minDSquared = +Infinity;
-    let maxDSquared = -Infinity;
-
-    // for each corner of the interval box
-    for (const [a,b] of [[minX,minY],[minX,maxY],[maxX,minY],[maxX,maxY]]) {
-        /*
-        // distance to 1st corner of interval box - `distance² = x² + y²`
-        const dc1 = (a - x)**2 + (b - y)**2;
-        // max absolute roundoff error of `dc1`
-        // <4>dc1 <-- <4>(<3>(<1>(a - x)**2) + <3>(<1>((b - y)**2))
-        const dc1E = 4*γ1*((a + x)**2 + (b + y)**2);
-        const dc1Min = dc1 - dc1E;  // distance minus max error
-        const dc1Max = dc1 + dc1E;  // distance plus max error
-        */
+        box: number[][],
+        p: number[]): number[] {
 
-        /** distance to 1st corner of interval box - `distance² = x² + y²` */
-        const ax = td(a,x);  // a - x
-        const by = td(b,y);  // b - y
-        // const dc1Exact = eadd(emult(ax,ax),emult(by,by));  // ax**2 + bx**2
-        // const dc1 = estimate(dc1Exact);
-        const dc1Dd = qaq(qmq(ax,ax),qmq(by,by));  // ax**2 + bx**2
-        const dc1 = dc1Dd[1];
+    const [[minX, minY], [maxX, maxY]] = box;
+    const [x, y] = p;
 
-        // const dc1Min = dc1*(1 - 2**maxCoordPowerOf2*eps);  // distance minus max error
-        // const dc1Max = dc1*(1 + 2**maxCoordPowerOf2*eps);  // distance plus max error
-        const dc1Min = dc1*(1 - eps);  // distance minus max error
-        const dc1Max = dc1*(1 + eps);  // distance plus max error
-        
-        if (dc1Min <= minDSquared) {
-            minDSquared = dc1Min;
-        }
+    // per axis gap between `p` and the box (`0` if `p` is within range)
+    const dxMin = max(minX - x, 0, x - maxX);
+    const dyMin = max(minY - y, 0, y - maxY);
+    // per axis distance from `p` to the furthest end of the box's range
+    const dxMax = max(x - minX, maxX - x);
+    const dyMax = max(y - minY, maxY - y);
 
-        if (dc1Max >= maxDSquared) {
-            maxDSquared = dc1Max;
-        }
-    }
+    const minDSquared = dxMin*dxMin + dyMin*dyMin;
+    const maxDSquared = dxMax*dxMax + dyMax*dyMax;
 
-    return [minDSquared,maxDSquared];
+    return [minDSquared*(1 - WIDEN), maxDSquared*(1 + WIDEN)];
 }
 
 

package/src/corner/get-corner.ts

@@ -1,4 +1,5 @@
 import type { Corner } from "./corner.js";
+import { memoize } from 'flo-memoize';
 import { cross, toUnitVector } from "flo-vector2d";
 import { getInterfaceCcw } from './get-interface-ccw.js';
 
@@ -70,4 +71,12 @@ function getCorner(
 }
 
 
-export { getCorner }
+/**
+ * Memoized version of `getCorner` (keyed on the two control point arrays).
+ * 
+ * @internal
+ */
+const getCorner$ = memoize(getCorner);
+
+
+export { getCorner, getCorner$ }

package/src/corner/get-interface-ccw.ts

@@ -1,4 +1,4 @@
-import { eAdd, eCompress, eEstimate, eMult, eNegativeOf, eProduct, orient2d, twoDiff } from 'big-float-ts';
+import { eAdd, eEstimate, eMult, eNegativeOf, twoDiff } from 'big-float-ts';
 import { compareCurvaturesAtInterface } from "./compare-curvatures-at-interface.js";
 
 
@@ -137,4 +137,4 @@ function crossPrecise(
 }
 
 
-export { getInterfaceCcw }
+export { getInterfaceCcw }

package/src/cp-node/cp-node.ts

@@ -26,9 +26,10 @@ import { PointOnShape } from '../point-on-shape/point-on-shape.js';
  * following other branches on the MAT.
  * 
  * Call `getMatCurveBetween(cpNodeFrom, cpNodeTo)` or `getMatCurveToNext(cpNode)` 
- * (replacing the older CpNode.`matCurveToNextVertex`) to get a bezier curve 
- * from the maximal disk of this `CpNode` to the next `CpNode`'s 
- * maximal disk and thus directly representing a piece of the medial axis.
+ * (replacing the older CpNode.`matCurveToNextVertex`) to get the bezier curves 
+ * (1 or 2 lines or quadratics joined smoothly) from the maximal disk of this 
+ * `CpNode` to the next `CpNode`'s maximal disk and thus directly representing 
+ * a piece of the medial axis.
  * 
  * The function, `getChildren`, returns the children of this `CpNode` when
  * seen as a MAT edge. Only children in a 'forward' direction are returned. These

package/src/cp-node/fs/get-all-on-loop-by-loop.ts

@@ -16,10 +16,6 @@ function getAllOnLoop_ByLoop(
 
     const cpStarts: CpNode[] = [cpNode];
     const cpStartSet = new Set(cpStarts);
-    if (cpNode.isHoleClosing) {
-        cpStartSet.add(cpNode.prevOnCircle.holeCloserTwin!);
-    }
-    cpStartSet.add(cpNode);
 
     while (cpStarts.length > 0) {
         const cpNodes: CpNode[] = [];

package/src/cp-node/fs/get-angle-between-mat-curves.ts

@@ -3,7 +3,7 @@ import { tangent } from "flo-bezier3";
 import { cross, toUnitVector } from "flo-vector2d";
 import { getMatCurveToNext } from "./get-mat-curve-to-next.js";
 
-const { abs, asin, PI: π } = Math;
+const { abs, asin, min, max, PI: π } = Math;
 
 
 /**
@@ -17,15 +17,17 @@ function getInitialDegAngleBetweenMatCurves(
         cpNode2: CpNode) {
 
     const tan1 = toUnitVector(tangent(
-        getMatCurveToNext(cpNode1), 
+        getMatCurveToNext(cpNode1)[0], 
         0
     ));
     const tan2 = toUnitVector(tangent(
-        getMatCurveToNext(cpNode2), 
+        getMatCurveToNext(cpNode2)[0], 
         0
     ));
 
-    const cross_ = cross(tan1, tan2);
+    // clamp: rounding can push the cross product of two unit vectors just
+    // outside [-1,1], which would make `asin` return `NaN`
+    const cross_ = max(-1, min(1, cross(tan1, tan2)));
     const angle = abs(asin( cross_ ) * (180/π));
 
     return angle;

package/src/cp-node/fs/get-boundary-beziers-between.ts

@@ -4,15 +4,17 @@ import { getBoundaryBeziersToNext } from "./get-boundary-beziers-to-next.js";
 
 
 /**
- * Returns all `CpNode`s between the two given ones (inclusive).
- * 
- * * If the second `CpNode` is never encountered all on the loop will be
+ * Returns the bezier curves of the shape boundary from the contact point of
+ * the first given `CpNode` to that of the second (following `next`), together
+ * with whether a hole closer was passed on the way.
+ *
+ * * If the second `CpNode` is never encountered the entire boundary is
  * returned.
- * 
- * @param cpNode1 
- * @param cpNode2 
- * @param inclAllIfEqual if `true` and first and last `CpNode`s are equal then
- * include all `CpNode`s around the loop, otherwise include none.
+ *
+ * @param cpNode1
+ * @param cpNode2
+ * @param inclAllIfEqual if `true` and the two `CpNode`s are equal then return
+ * the entire boundary, otherwise return nothing.
  */
 function getBoundaryBeziersBetween(
         cpNode1: CpNode,

package/src/cp-node/fs/get-branch-beziers.ts

@@ -4,14 +4,15 @@ import { getMatCurveToNext } from './get-mat-curve-to-next.js';
 
 
 /**
- * Returns the branch associated with the give cpNode
+ * Returns the (flattened) array of bezier curves (lines or quadratics) 
+ * representing the branch associated with the given cpNode
  * 
  * @param cpNode `CpNode` representing the start vertex.
  */
 function getBranchBeziers(
         cpNode: CpNode): number[][][] {
 
-    return getBranch(cpNode).map(b => getMatCurveToNext(b));
+    return getBranch(cpNode).flatMap(getMatCurveToNext);
 }
 
 

package/src/cp-node/fs/get-branch.ts

@@ -1,6 +1,5 @@
 import { CpNode } from '../cp-node.js';
 import { getRealProngCount } from './get-real-prong-count.js';
-import { isFullyTerminating } from './is-fully-terminating.js';
 import { isTerminating } from './is-terminating.js';
 import { isTrivial } from './is-trivial.js';
 
@@ -34,7 +33,7 @@ function getBranch(
     do {
         branch.push(cpNode);
         cpNode = cpNode.next;
-    } while (!isFullyTerminating(cpNode) && getRealProngCount(cpNode) === 2)
+    } while (getRealProngCount(cpNode) === 2)
 
     return branch;
 }

package/src/cp-node/fs/get-distance-to-next.ts

@@ -7,8 +7,10 @@ import { getMatCurveToNext } from "./get-mat-curve-to-next.js";
 function getMatDistanceToNext(
         cpNode: CpNode) {
 
-    const ps = getMatCurveToNext(cpNode);
-    const l = totalLength(ps);
+    let l = 0;
+    for (const ps of getMatCurveToNext(cpNode)) {
+        l += totalLength(ps);
+    }
 
     return l;
 }