flo-mat 4.1.4 → 5.0.1

package/node/utils/get-beziers-from-tangents.js

@@ -0,0 +1,92 @@
+import { fromTo, dot, cross, lineLineIntersection } from 'flo-vector2d';
+const { abs, sqrt } = Math;
+/**
+ * The maximum sine of the angle between the chord and either tangent for
+ * which a 'twisted' (inflected) curve is approximated by a straight line -
+ * the line then deviates from the true curve by only about a millionth of the
+ * chord length.
+ *
+ * * a relative (angle) tolerance and thus independent of the scale of the
+ *   shape and of the magnitude of the given tangents
+ *
+ * @internal
+ */
+const SIN_TOLERANCE_USE_LINE = 2 ** -16;
+/**
+ * Returns an array of 1 or 2 bezier curves (each a line or a quadratic) that
+ * together form a smooth curve from the start point of `l0` to the start point
+ * of `l1` such that the curve is tangent to `l0` at its start and tangent to
+ * `l1` at its end.
+ *
+ * * `l0` and `l1` are given as `[p, p + dir]` where `p` is the curve endpoint
+ * and `dir` is the tangent direction (of any magnitude; its orientation does
+ * not matter)
+ * * if the tangent lines are not 'twisted' (they meet strictly between the
+ * endpoints along the chord) a single quadratic is returned
+ * * if the tangent lines are 'twisted' (the curve must have an inflection)
+ * 2 quadratics joined smoothly at the inflection are returned as an
+ * approximation - or, if both tangents deviate from the chord by less than
+ * `SIN_TOLERANCE_USE_LINE`, a single line
+ * * if the endpoints coincide (or a tangent is degenerate) a (degenerate) line
+ * is returned
+ *
+ * FUTURE: a strongly twisted MAT edge indicates that an additional 2-prong
+ * should be added so that the edge is approximated by two less twisted ones.
+ *
+ * @param l0 the tangent line at the start of the curve
+ * @param l1 the tangent line at the end of the curve
+ *
+ * @internal
+ */
+function getBeziersFromTangents(l0, l1) {
+    const p0 = l0[0];
+    const p1 = l1[0];
+    const c = fromTo(p0, p1);
+    if (c[0] === 0 && c[1] === 0) {
+        return [[p0, p1]]; // coinciding endpoints - a degenerate line
+    }
+    const w0 = fromTo(l0[0], l0[1]);
+    const w1 = fromTo(l1[0], l1[1]);
+    const lc = sqrt(dot(c, c));
+    const lw0 = sqrt(dot(w0, w0));
+    const lw1 = sqrt(dot(w1, w1));
+    if (lw0 === 0 || lw1 === 0) {
+        return [[p0, p1]]; // a degenerate tangent - fall back to a line
+    }
+    const mid = lineLineIntersection(l0, l1);
+    let twisted;
+    if (!mid) {
+        twisted = true;
+    }
+    else {
+        const a = fromTo(p0, mid);
+        const b = fromTo(p1, mid);
+        // (`<= 0` / `>= 0`: an intersection *at* an endpoint, which happens for
+        // collinear tangents, would give a degenerate quadratic with a zero
+        // end tangent - treat it as twisted so a line results instead)
+        twisted = dot(a, c) <= 0 || dot(b, c) >= 0;
+    }
+    if (!twisted) {
+        return [[p0, mid, p1]];
+    }
+    // the sines of the angles between the chord and the tangents
+    const sin0 = abs(cross(c, w0)) / (lc * lw0);
+    const sin1 = abs(cross(c, w1)) / (lc * lw1);
+    if (sin0 <= SIN_TOLERANCE_USE_LINE && sin1 <= SIN_TOLERANCE_USE_LINE) {
+        return [[p0, p1]]; // within tolerance - a straight line
+    }
+    // Approximate with 2 quadratic beziers joined smoothly at the inflection.
+    // The control points lie on the tangent lines a quarter of the chord
+    // length away from the endpoints, on the side facing the other endpoint
+    // (for small angles this is the midpoint degree reduction of the cubic
+    // having control points at 1/3 and 2/3 along the chord; unlike placing
+    // them at 1/4 and 3/4 *along* the chord it stays bounded for any angle).
+    const q0 = (dot(w0, c) < 0 ? -1 : 1) * lc / (4 * lw0);
+    const q1 = (dot(w1, c) < 0 ? 1 : -1) * lc / (4 * lw1);
+    const c0 = [p0[0] + q0 * w0[0], p0[1] + q0 * w0[1]];
+    const c1 = [p1[0] + q1 * w1[0], p1[1] + q1 * w1[1]];
+    const j = [(c0[0] + c1[0]) / 2, (c0[1] + c1[1]) / 2];
+    return [[p0, c0, j], [j, c1, p1]];
+}
+export { getBeziersFromTangents };
+//# sourceMappingURL=get-beziers-from-tangents.js.map

package/node/utils/get-beziers-from-tangents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-beziers-from-tangents.js","sourceRoot":"","sources":["../../src/utils/get-beziers-from-tangents.ts"],"names":[],"mappings":"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"}

package/node/vertex/remove-vertex.d.ts

@@ -1,10 +1,12 @@
 import type { CpNode } from "../cp-node/cp-node.js";
 import type { MatMeta } from '../mat/mat-meta.js';
 /**
- * Removes a cpNode from the MAT.
+ * Removes the (2-prong) vertex represented by the given `CpNode` from the MAT,
+ * i.e. both `CpNode`s on its circle are unlinked from the boundary and removed
+ * from `meta.cpTrees`.
  *
- * @param cpTree The tree graph holding the `CpNodes` of the MAT.
- * @param cpNode The `CpNode` to remove.
+ * @param cpNode a `CpNode` on the vertex to remove
+ * @param meta the `MatMeta` whose `cpTrees` hold the `CpNode`s of the MAT
  */
 declare function removeVertex(cpNode: CpNode, meta: MatMeta): void;
 export { removeVertex };

package/node/vertex/remove-vertex.js

@@ -2,10 +2,12 @@ import { getAllOnCircle } from '../cp-node/fs/get-all-on-circle.js';
 import { getProngCount } from '../cp-node/fs/get-prong-count.js';
 import { removeCpNode } from '../cp-node/fs/remove-cp-node.js';
 /**
- * Removes a cpNode from the MAT.
+ * Removes the (2-prong) vertex represented by the given `CpNode` from the MAT,
+ * i.e. both `CpNode`s on its circle are unlinked from the boundary and removed
+ * from `meta.cpTrees`.
  *
- * @param cpTree The tree graph holding the `CpNodes` of the MAT.
- * @param cpNode The `CpNode` to remove.
+ * @param cpNode a `CpNode` on the vertex to remove
+ * @param meta the `MatMeta` whose `cpTrees` hold the `CpNode`s of the MAT
  */
 function removeVertex(cpNode, meta) {
     const prongCount = getProngCount(cpNode);

package/node/vertex/remove-vertex.js.map

@@ -1 +1 @@
-{"version":3,"file":"remove-vertex.js","sourceRoot":"","sources":["../../src/vertex/remove-vertex.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAG/D;;;;;GAKG;AACH,SAAS,YAAY,CACb,MAAc,EACd,IAAa;IAEjB,MAAM,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC;IACzC,IAAI,UAAU,KAAK,CAAC,EAAE,CAAC;QACnB,MAAM,IAAI,KAAK,CAAC,+BAA+B,UAAU,QAAQ,CAAC,CAAA;IACtE,CAAC;IAED,cAAc,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC;AACzE,CAAC;AAGD,OAAO,EAAE,YAAY,EAAE,CAAA"}
+{"version":3,"file":"remove-vertex.js","sourceRoot":"","sources":["../../src/vertex/remove-vertex.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAG/D;;;;;;;GAOG;AACH,SAAS,YAAY,CACb,MAAc,EACd,IAAa;IAEjB,MAAM,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC;IACzC,IAAI,UAAU,KAAK,CAAC,EAAE,CAAC;QACnB,MAAM,IAAI,KAAK,CAAC,+BAA+B,UAAU,QAAQ,CAAC,CAAA;IACtE,CAAC;IAED,cAAc,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC;AACzE,CAAC;AAGD,OAAO,EAAE,YAAY,EAAE,CAAA"}

package/package.json

@@ -2,7 +2,7 @@
     "name": "flo-mat",
     "sideEffects": false,
     "description": "Medial / Scale Axis Transform (MAT/SAT) Library.",
-    "version": "4.1.4",
+    "version": "5.0.1",
     "author": {
         "name": "Floris Steenkamp"
     },
@@ -32,32 +32,32 @@
     ],
     "dependencies": {
         "big-float-ts": "^4.0.4",
-        "double-double": "^3.0.4",
-        "flo-bezier3": "^8.1.1",
-        "flo-boolean": "^6.0.2",
+        "double-double": "^4.0.0",
+        "flo-bezier3": "^9.0.0",
+        "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.0",
         "flo-vector2d": "^4.0.6"
     },
     "devDependencies": {
-        "squares-rng": "^2.0.4",
-        "@jest/globals": "^30.5.1",
-        "@swc/core": "^1.16.2",
+        "@jest/globals": "^30.5.2",
+        "@swc/core": "^1.16.18",
         "@swc/jest": "^0.2.39",
         "@types/jest": "^30.0.0",
-        "jest": "^30.5.1",
-        "jest-ts-webcompat-resolver": "^1.0.1",
-        "ts-node": "^10.9.2",
-        "@types/node": "^26.6.0",
+        "@types/node": "^26.6.5",
         "c8": "^12.0.0",
         "cheerio": "^1.2.0",
         "circular-dependency-plugin": "^5.2.2",
+        "jest": "^30.5.2",
+        "jest-ts-webcompat-resolver": "^1.0.1",
         "rimraf": "^6.1.3",
-        "ts-loader": "^9.6.2",
-        "typescript": "^6.0.3",
-        "webpack": "^5.111.0",
+        "squares-rng": "^2.0.4",
+        "swc-loader": "^0.2.7",
+        "ts-node": "^10.9.2",
+        "typescript": "^7.0.2",
+        "webpack": "^5.111.1",
         "webpack-cli": "^7.2.3"
     },
     "scripts": {
@@ -70,6 +70,6 @@
     "allowScripts": {
         "unrs-resolver@1.12.2": true,
         "@parcel/watcher@2.6.0": true,
-        "@swc/core@1.16.2": 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/add-n-prong.ts/join-spokes.ts

@@ -2,6 +2,8 @@ import type { CpNode } from "../cp-node/cp-node.js";
 import type { Circle } from "../geometry/circle.js";
 import type { Mutable } from "../utils/mutable.js";
 
+const { atan2 } = Math;
+
 
 function joinSpokes(
         circle: Circle,
@@ -30,8 +32,8 @@ function byAngle(circle: Circle) {
         a = [a[0] - c[0], a[1] - c[1]];
         b = [b[0] - c[0], b[1] - c[1]];
 
-        const a_ = Math.atan2(a[1], a[0]);
-        const b_ = Math.atan2(b[1], b[0]);
+        const a_ = atan2(a[1], a[0]);
+        const b_ = atan2(b[1], b[0]);
 
         return b_ - a_;
     }

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;
 }