flo-mat 4.0.3 → 4.1.0

package/src/debug/debug.ts

@@ -1,27 +1,19 @@
-import type { DrawElemFunctions } from './functions/draw-elem/draw-elem.js';
-import type { DebugElems } from './debug-elem-types.js';
-import { drawElemFs } from './functions/draw-elem/draw-elem.js';
-
 
 /** @internal */
 interface Debug {
     /** Generated by debug object for later inspection */
-    elems: GeneratedElems;
+    elems: {};
     timing: Timing;
 
     /**
      * These functions are meant to be used in the console, e.g. in the 
      * console try typing d.fs.twoProng.traceConvergence(0);
      */
-    fs: DebugFunctions;
+    fs: {};
     directives: Directives;
 }
 
 
-/** @internal */
-type GeneratedElems = { [T in keyof DebugElems]: DebugElems[T][] };
-
-
 /** @internal */
 interface Timing {
     holeClosers: number;
@@ -32,12 +24,6 @@ interface Timing {
 }
 
 
-/** @internal */
-interface DebugFunctions {
-    drawElem: DrawElemFunctions,
-}
-
-
 /** @internal */
 interface Directives {
     stopAfterHoleClosers: boolean,
@@ -60,30 +46,7 @@ function enableDebugForMat(debugOn: boolean) {
     debug = { 
         ...debug, 
         elems: { 
-            ...debug?.elems,
-            // @ts-ignore
-
-            oneProng             : [],
-            // oneProngAtDullCorner : [],
-            twoProng             : [],
-            // twoProng_regular     : [],
-            // twoProng_failed      : [],
-            // twoProng_notAdded    : [],
-            // twoProng_deleted     : [],
-            // twoProng_holeClosing : [],
-            looseBoundingBox     : [],
-            tightBoundingBox     : [],
-            // sharpCorner          : [],
-            // dullCorner           : [],
-            vertex               : [],
-            threeProng           : [],
-            boundingHull         : [],
-            mat                  : [],
-            // sat                  : [],
-            cpNode               : [],
-            maxVertex            : [],
-            leaves               : [],
-            // culls                : [],
+            ...debug?.elems
         },
         timing: {
             ...debug?.timing,
@@ -91,14 +54,10 @@ function enableDebugForMat(debugOn: boolean) {
             oneAnd2Prongs: 0,
             threeProngs: 0,
             sats: 0,
-            simplifyMat: 0,
+            simplifyMat: 0
         },
         fs: {
-            ...debug?.fs,
-            drawElem: {
-                ...debug?.fs?.drawElem,
-                ...drawElemFs
-            }
+            ...debug?.fs
         },
         directives: {
             //...debug?.directives,
@@ -116,7 +75,6 @@ function enableDebugForMat(debugOn: boolean) {
 }
 
 
-export { 
-    Debug, GeneratedElems, Timing,
-    DebugFunctions, Directives, enableDebugForMat
-}
+export type { Debug, Timing, Directives }
+export { enableDebugForMat }
+

package/src/find-2-prong/find-2-prong.ts

@@ -15,7 +15,7 @@ import { ddNormal } from 'flo-bezier3';
 import { rotate } from 'flo-vector2d';
 
 
-const { sin, cos, max, sqrt } = Math;
+const { abs, sin, cos, max, sqrt } = Math;
 
 
 /**
@@ -60,6 +60,7 @@ function find2Prong(
             angle: number,
             yPos: PrePointOnShape): { circle: Circle, z: PrePointOnShape } | undefined {
 
+
         const { curve: { loop, ps }, t, p: y } = yPos;
         const normDd = ddNormal(ps, t);
         const _nnorm = [-normDd[0][1], -normDd[1][1]];  // Left-handed system (sorry)
@@ -67,6 +68,10 @@ function find2Prong(
             ? [0, -maxOsculatingCircleRadius]
             : (angle !== 0 ? rotate(sin(angle), cos(angle))(_nnorm) : _nnorm);
 
+        const nnormDd = isHoleClosing || angle !== 0
+            ? [[0, nnorm[0]], [0, nnorm[1]]]
+            : [[-normDd[0][0], -normDd[0][1]], [-normDd[1][0], -normDd[1][1]]];
+
         // Get initial kissing circle guess
         let [xO,rO] = getInitialX(
             angle, isHoleClosing, maxOsculatingCircleRadius, yPos, nnorm
@@ -80,7 +85,7 @@ function find2Prong(
         );
 
         // The lines below is an optimization.
-        const xy2 = reduceRadius(maxCoordPowerOf2, curvePieces, y, nnorm);
+        const xy2 = reduceRadius(maxCoordPowerOf2, rO, curvePieces, y, nnorm);
         const xy = sqrt(xy2);
 
         const l = sqrt(nnorm[0]**2 + nnorm[1]**2);
@@ -89,17 +94,24 @@ function find2Prong(
         cullCurvePieces(curvePieces, xO, xy2);
 
         const antipodalPoints = getAntipodalPoints(
-            maxCoordPowerOf2, nnorm, yPos,
+            maxCoordPowerOf2, nnorm, nnormDd, yPos,
             for1Prong, angle,
             curvePieces
         );
 
+        // FUTURE - if antipodalPoints.length > 1 let's just add an n-prong;
         if (antipodalPoints.length !== 1) {
-            if (antipodalPoints.length === 0) { return undefined; }
-            if (!areAllAntipodesSame(antipodalPoints)) {
+            if (antipodalPoints.length === 0) {
+                if (isHoleClosing) {
+                    console.log(yPos)
+                }
+                return undefined;
+            }
+            if (!isHoleClosing && !areAllAntipodesSame(antipodalPoints, maxCoordPowerOf2)) {
                 // At this point there is multiple antipodal points (zs) for the given
                 // source point so do not add the 2-prong, it will be caught when 
                 // adding 3+-prongs.
+
                 return undefined;
             }
         }
@@ -111,9 +123,12 @@ function find2Prong(
             return undefined;
         }
 
+        const pDd = toP(curve.ps, s);
+        const p = pDd.map(c => c[0] + c[1]);
+
         const z: PrePointOnShape = {
             curve, t: s, isSource: false,
-            p: toP(curve.ps, s)
+            p, pDd
         };
 
         const circle = { center: x, radius: d };
@@ -122,7 +137,9 @@ function find2Prong(
         const xz = squaredDistanceBetweenDd(x, z.p);
 
         if (!isHoleClosing) {
-            if (yz === 0) { return undefined; }
+            if (yz === 0) {
+                return undefined;
+            }
 
             // The lines below eliminate cases where the found 2-prong is too
             // close to a one-prong
@@ -142,13 +159,19 @@ function find2Prong(
 
 /** @internal */
 function areAllAntipodesSame(
-        app: AntipodalPoint[]): boolean {
-
-    const { curve, s: t } = app[0];
-    for (let i=1; i<app.length; i++) {
-        const { curve: curve_, s: t_ } = app[i];
-
-        if (curve !== curve_ || t !== t_) {
+        point: AntipodalPoint[],
+        maxCoordPowerOf2: number): boolean {
+
+    const { curve, s: t, x } = point[0];
+    const tol = 2**(maxCoordPowerOf2 - 40);
+    for (let i=1; i<point.length; i++) {
+        // const { curve: curve_, s: t_ } = point[i];
+        // if (curve !== curve_ || t !== t_) {
+        //     return false;
+        // }
+
+        const { x: x_ } = point[i];
+        if (abs(x[0] - x_[0]) > tol || abs(x[0] - x_[0]) > tol) {
             return false;
         }
     }

package/src/find-2-prong/get-medial/get-antipodal-points.ts

@@ -19,7 +19,8 @@ import { getClosestPoint } from './get-closest-points.js';
  */
 function getAntipodalPoints(
         maxCoordPowerOf2: number,
-        nnorm: number[], 
+        nnorm: number[],
+        nnormDd: number[][],
         yPos: PrePointOnShape,
         for1Prong: boolean,
         angle: number,
@@ -30,7 +31,7 @@ function getAntipodalPoints(
         const curvePiece = curvePieces[i];
 
         const pInfos = getClosestPoint(
-            maxCoordPowerOf2, nnorm, yPos, for1Prong, angle,
+            maxCoordPowerOf2, nnorm, nnormDd, yPos, for1Prong, angle,
             curvePiece
         );
 

package/src/find-2-prong/get-medial/get-closest-points-d.ts

@@ -0,0 +1,213 @@
+import type { RootInterval } from 'flo-poly';
+import type { CurvePiece } from "../../mat/curve-piece.js";
+import type { PrePointOnShape } from "../../point-on-shape/point-on-shape.js";
+import type { AntipodalPoint } from './antipodal-point.js';
+import { lengthSquared } from "flo-vector2d";
+import { roots, Horner } from 'flo-poly';
+import { evalDeCasteljau, getMedialPointCoeffs, getMedialPointCoeffsBez0, getMedialPointCoeffsBez2_SameCurve, getMedialPointCoeffsBez3_SameCurve } from 'flo-bezier3';
+
+const { sqrt, abs, max } = Math;
+
+
+/**
+ * @param maxCoordPowerOf2
+ * @param nnorm
+ * @param yPos The point on the shape
+ * @param for1Prong defaults to `false`;
+ * @param angle defaults to `0`;
+ * @param curvePiece The curve piece
+ * 
+ * @internal
+ */
+function getClosestPoint(
+        maxCoordPowerOf2: number,
+        nnorm: number[], 
+        nnormDd: number[][],
+        yPos: PrePointOnShape,
+        for1Prong: boolean,
+        angle: number,
+        curvePiece: CurvePiece): AntipodalPoint[] {
+
+    const { curve, ts: [tS,tE] } = curvePiece;
+    const { ps } = curve;
+    const { curve: touchedCurve, t, p: y, pDd: yDd } = yPos;
+
+    const isTouched = curve === touchedCurve;
+    const shouldDeflate = angle === 0 && isTouched;
+
+    const infos: AntipodalPoint[] = [];
+    let startPushed = false;
+    let endPushed = false;
+
+    let ss: RootInterval[];
+    if (tS !== tE &&
+        !(shouldDeflate && ps.length === 2) &&
+        !(isTouched && ps.length === 3 && for1Prong)) {
+
+        const { A, B, H } = shouldDeflate
+            ? ps.length === 3
+                ? getMedialPointCoeffsBez2_SameCurve(t, nnorm, ps)
+                : getMedialPointCoeffsBez3_SameCurve(t, nnorm, ps)
+            : getMedialPointCoeffs(y, nnorm, ps);
+        
+        ss = roots(H, tS, tE) || [];
+        //-----------------------
+
+        for (let i=0; i<ss.length; i++) {
+            const ri = ss[i];
+            const { tS: sS, tE: sE, t: _s } = ri;
+            if (ri.multiplicity > 1) {
+                continue;
+            }
+
+            if (sE < tS || sS > tE) { continue; }  // outside curve piece
+            if (sS < 0) { continue; }  // outside curve piece
+
+            // clip to [0,1]
+            const s = sE > 1 ? 1 : _s;
+
+            //-----------------------
+            const AS = Horner(A, s);
+            const BS = Horner(B, s);
+            // const CS = Horner(C, s);
+            // const DS = Horner(D, s);
+
+            const _AS = abs(AS);
+            // const _CS = abs(CS);
+
+            // if (max(_AS, _CS) < 2**-40) { continue; }
+            if (max(_AS) < 2**-40) { continue; }
+
+            // const w = _AS > _CS
+            //     ? -BS / AS
+            //     : -DS / CS;  // alternative
+            const w = -BS / AS;
+
+            if (w <= 0) {
+                // If `w` is negative the circle radius is negative -> discard
+                continue;
+            }
+
+            const V = [w*nnorm[0], w*nnorm[1]];
+            const d = sqrt(lengthSquared(V));
+
+            if (d <= 2**(maxCoordPowerOf2 - 40)) {
+                // If `w` <= 2**-40 -> discard
+                continue;
+            }
+
+            const x = [y[0] + V[0], y[1] + V[1]];
+            //-----------------------
+
+            if (ri.tS <= tS && ri.tE >= tS) {
+                startPushed = true;
+            }
+            if (ri.tS <= tE && ri.tE >= tE) {
+                endPushed = true;
+            }
+
+
+            // If the point is the first control point of the curve then we
+            // ensure the point becomes the last control point of the prior
+            // curve to induce some symmetery and simplify the algorithm.
+            const s_ = s === 0 ? 1 : s;
+            const curve_ = s === 0 ? curve.prev : curve;
+
+            const info: AntipodalPoint = {
+                curve: curve_,
+                s: s_,
+                d, x
+            };
+
+            infos.push(info);
+        }
+    }
+    
+
+
+    //------------------------------------------
+    const pLast = ps[ps.length - 1];
+
+    let dontPush1 = (
+        (t === 0 && curve === touchedCurve!.prev) ||
+        (t === 1 && curve === touchedCurve)
+    );
+
+    
+    //--------------------------------------
+    // Also check curve start control point
+    //--------------------------------------
+    const PS: { P: number[], t: number }[] = [];
+    if (tS === 0) {
+        // We never check points at `t === 0` since they are covered by the previous curve's endpoint
+        // which cannot be culled if this curve`s `t === 0` is included
+    } else if (tS === 1) {
+        if (!dontPush1 && !startPushed) {
+            PS.push({ P: pLast, t: 1 });
+        }
+    } else {
+        if (!startPushed) {
+            const pp = evalDeCasteljau(ps, tS);
+            PS.push({ P: pp, t: tS });
+        }
+    }
+
+    //--------------------------------------
+    // Also check curve end control point
+    //--------------------------------------
+    if (tS !== tE) {
+        if (tE === 0) {
+            // We never check points at `t === 0` since they are covered by the previous curve's endpoint
+            // which cannot be culled if this curve`s `t === 0` is included
+        } else if (tE === 1) {
+            if (!dontPush1 && !endPushed) {
+                PS.push({ P: pLast, t: 1 }); dontPush1 = true;
+            }
+        } else {
+            if (!endPushed) {
+                const pp = evalDeCasteljau(ps, tE);
+                PS.push({ P: pp, t: tE });
+            }
+        }
+    }
+    //------------------------------------------
+
+
+    for (let i=0; i<PS.length; i++) {
+        //-----------------------
+        const { P, t: s } = PS[i];
+        const { a0, b0 } = getMedialPointCoeffsBez0(y,nnorm,P);
+
+        if (abs(a0) <= 2**-40 || abs(b0) <= 2**-40) {
+            continue;
+        }
+
+        const w = -b0 / a0;
+
+        // too close to point of origin *or* negative;
+        if (w < 2**-40) {
+            continue;
+        }
+
+        const V = [w*nnorm[0], w*nnorm[1]];
+        const d = sqrt(lengthSquared(V));
+
+        const x = [y[0] + V[0], y[1] + V[1]];
+
+        const s_ = s === 0 ? 1 : s;
+        const curve_ = s === 0 ? curve.prev : curve;
+
+        const info: AntipodalPoint = {
+            curve: curve_,
+            s: s_,
+            d, x
+        };
+
+        infos.push(info);
+    }
+
+    return infos;
+}
+
+
+export { getClosestPoint }

package/src/find-2-prong/get-medial/get-closest-points.ts

@@ -2,12 +2,19 @@ import type { RootInterval } from 'flo-poly';
 import type { CurvePiece } from "../../mat/curve-piece.js";
 import type { PrePointOnShape } from "../../point-on-shape/point-on-shape.js";
 import type { AntipodalPoint } from './antipodal-point.js';
+import { ddMultDouble1 } from 'double-double';
 import { lengthSquared } from "flo-vector2d";
-import { roots, deflate, Horner } from 'flo-poly';
-import { evalDeCasteljau, getMedialPointCoeffs, getMedialPointCoeffsBez0, getMedialPointCoeffsBez2_SameCurve, getMedialPointCoeffsBez3_SameCurve } from 'flo-bezier3';
+import { roots, Horner, ddHorner } from 'flo-poly';
+import { evalDeCasteljau, getMedialPointCoeffs, getMedialPointCoeffsBez0 } from 'flo-bezier3';
+import { ddGetMedialPointCoeffs } from '../../get-medial-points/double-double/dd-get-medial-point-coeffs.js';
+import { ddGetMedialPointCoeffsBez2_SameCurve } from '../../get-medial-points/double-double/dd-get-medial-point-coeffs-bez2-same-curve.js';
+import { ddGetMedialPointCoeffsBez3_SameCurve } from '../../get-medial-points/double-double/dd-get-medial-point-coeffs-bez3-same-curve.js';
+import { ddGetMedialPointCoeffsBez0 } from '../../get-medial-points/double-double/dd-get-medial-point-coeffs-bez0.js';
 
 const { sqrt, abs, max } = Math;
 
+const qmd = ddMultDouble1;
+
 
 /**
  * @param maxCoordPowerOf2
@@ -22,6 +29,7 @@ const { sqrt, abs, max } = Math;
 function getClosestPoint(
         maxCoordPowerOf2: number,
         nnorm: number[], 
+        nnormDd: number[][],
         yPos: PrePointOnShape,
         for1Prong: boolean,
         angle: number,
@@ -29,7 +37,7 @@ function getClosestPoint(
 
     const { curve, ts: [tS,tE] } = curvePiece;
     const { ps } = curve;
-    const { curve: touchedCurve, t, p: y } = yPos;
+    const { curve: touchedCurve, t, p: y, pDd: yDd } = yPos;
 
     const isTouched = curve === touchedCurve;
     const shouldDeflate = angle === 0 && isTouched;
@@ -42,11 +50,14 @@ function getClosestPoint(
     if (tS !== tE &&
         !(shouldDeflate && ps.length === 2) &&
         !(isTouched && ps.length === 3 && for1Prong)) {
+
         const { A, B, H } = shouldDeflate
             ? ps.length === 3
-                ? getMedialPointCoeffsBez2_SameCurve(t,nnorm,ps)
-                : getMedialPointCoeffsBez3_SameCurve(t,nnorm,ps)
-            : getMedialPointCoeffs(y, nnorm, ps);
+                ? ddGetMedialPointCoeffsBez2_SameCurve(t, nnormDd, ps)
+                : ddGetMedialPointCoeffsBez3_SameCurve(t, nnormDd, ps)
+            : ddGetMedialPointCoeffs(yDd, nnormDd, ps);
+
+        // const Hd = H.map(h => h[0] + h[1]);
         
         ss = roots(H, tS, tE) || [];
         //-----------------------
@@ -65,8 +76,14 @@ function getClosestPoint(
             const s = sE > 1 ? 1 : _s;
 
             //-----------------------
-            const AS = Horner(A, s);
-            const BS = Horner(B, s);
+            // const AS = Horner(A, s);
+            // const BS = Horner(B, s);
+
+            const ASDd = ddHorner(A, s);
+            const BSDd = ddHorner(B, s);
+            const AS = ASDd[0] + ASDd[1];
+            const BS = BSDd[0] + BSDd[1];
+
             // const CS = Horner(C, s);
             // const DS = Horner(D, s);
 
@@ -86,7 +103,8 @@ function getClosestPoint(
                 continue;
             }
 
-            const V = [w*nnorm[0], w*nnorm[1]];
+            const VDd = [qmd(w, nnormDd[0]), qmd(w, nnormDd[1])];
+            const V = [VDd[0][1], VDd[1][1]];
             const d = sqrt(lengthSquared(V));
 
             if (d <= 2**(maxCoordPowerOf2 - 40)) {
@@ -174,20 +192,21 @@ function getClosestPoint(
     for (let i=0; i<PS.length; i++) {
         //-----------------------
         const { P, t: s } = PS[i];
-        const { a0, b0 } = getMedialPointCoeffsBez0(y,nnorm,P);
+        const { a0, b0 } = ddGetMedialPointCoeffsBez0(yDd, nnormDd, P);
 
-        if (abs(a0) <= 2**-40 || abs(b0) <= 2**-40) {
+        if (abs(a0[1]) <= 2**-40 || abs(b0[1]) <= 2**-40) {
             continue;
         }
 
-        const w = -b0 / a0;
+        const w = -b0[1] / a0[1];
 
         // too close to point of origin *or* negative;
         if (w < 2**-40) {
             continue;
         }
 
-        const V = [w*nnorm[0], w*nnorm[1]];
+        const VDd = [qmd(w, nnormDd[0]), qmd(w, nnormDd[1])];
+        const V = [VDd[0][1], VDd[1][1]];
         const d = sqrt(lengthSquared(V));
 
         const x = [y[0] + V[0], y[1] + V[1]];
@@ -209,3 +228,45 @@ function getClosestPoint(
 
 
 export { getClosestPoint }
+
+
+
+/**
+ * Recovers a numerically stable ray parameter `t` from linear equations
+ * `A*t + B = 0` and (optionally) `C*t + D = 0` evaluated at a fixed `s`.
+ *
+ * If `C,D` are unavailable, this falls back to `-B/A`.
+ */
+// function chooseStableT(
+//         A: number,
+//         B: number,
+//         C: number,
+//         D: number) {
+
+//     const epsScale = max(1, abs(A), abs(B), abs(C), abs(D));
+//     const eps = Number.EPSILON * epsScale;
+
+//     const denomAB = abs(A);
+//     const hasAB = denomAB > eps;
+//     const denomCD = abs(C);
+//     const hasCD = denomCD > eps;
+
+//     if (!hasAB && !hasCD) {
+//         return undefined;
+//     }
+//     if (hasAB && !hasCD) {
+//         return -B / A;
+//     }
+//     if (!hasAB && hasCD) {
+//         return -D / C;
+//     }
+
+//     const tAB = -B / A;
+//     const tCD = -D / C;
+
+//     // Score each candidate by how well it satisfies the *other* equation.
+//     const scoreAB = abs(C*tAB + D) / (abs(C) + abs(D) + eps);
+//     const scoreCD = abs(A*tCD + B) / (abs(A) + abs(B) + eps);
+
+//     return scoreAB <= scoreCD ? tAB : tCD;
+// }

package/src/find-2-prong/reduce-radius.ts

@@ -11,15 +11,18 @@ const TOLERANCE = 1 + 2**-20;
 /**
  * Reduces the circle radius initially as an optimization step.
  * 
+ * @param rO maximum possible initial radius
+ * 
  * @internal
  */
 function reduceRadius(
         maxCoordPowerOf2: number,
+        rO: number,
         curvePieces: CurvePiece[], 
         y: number[],
         nnorm: number[]): number {
 
-    let minRadius = Infinity;
+    let minRadiusSqrd = rO**2;
     let x = [y[0] + nnorm[0], y[1] + nnorm[1]];
 
     for (let i=0; i<curvePieces.length; i++) {
@@ -31,7 +34,7 @@ function reduceRadius(
         const pE = ps[ps.length - 1];
 
         for (const P of [pS,pE]) {
-            if (squaredDistanceBetween(x,P) > minRadius) {
+            if (squaredDistanceBetween(x,P) > minRadiusSqrd) {
                 continue;  // short-circuit
             }
 
@@ -49,15 +52,15 @@ function reduceRadius(
             const N = [w*nnorm[0], w*nnorm[1]];
             const r = lengthSquared(N);
 
-            if (r < minRadius) {
-                minRadius = r;
+            if (r < minRadiusSqrd) {
+                minRadiusSqrd = r;
                 x = [y[0] + N[0], y[1] + N[1]];
             }
         }
     }
 
     // The extra bit is to account for floating point precision.
-    return TOLERANCE*minRadius;
+    return TOLERANCE*minRadiusSqrd;
 }
 
 

package/src/find-3-prong/calc-better-x.ts

@@ -1,8 +1,6 @@
 import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
 import type { CurvePiece } from '../mat/curve-piece.js';
-// import { fromTo, circumCenter, len, scale, translate } from 'flo-vector2d';
-import { fromTo, len, scale, translate } from 'flo-vector2d';
-import { circumCenter } from './timed-cc.js';  // TODO - testing - restore
+import { circumCenter, fromTo, len, scale, translate } from 'flo-vector2d';
 import { getCloseBoundaryPointsCertified } from '../closest-boundary-point/get-close-boundary-points-certified.js';
 
 

package/src/find-3-prong/calc-initial-3-prong-center.ts

@@ -1,7 +1,6 @@
 import type { CpNode } from '../cp-node/cp-node.js';
 import type { CurvePiece } from '../mat/curve-piece.js';
-// import { circumCenter } from 'flo-vector2d';
-import { circumCenter } from './timed-cc.js';  // TODO - testing - restore
+import { circumCenter } from 'flo-vector2d';
 import { getCloseBoundaryPointsCertified } from '../closest-boundary-point/get-close-boundary-points-certified.js';
 
 

package/src/find-3-prong/find-3-prong-for-delta3s.ts

@@ -2,9 +2,7 @@ import type { CpNode } from '../cp-node/cp-node.js';
 import type { CurvePiece } from '../mat/curve-piece.js';
 import type { ThreeProngInfo } from './three-prong-info.js';
 import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
-// import { fromTo, circumCenter as getCircumCenter, len, distanceBetween, toUnitVector, rotate90Degrees, cross } from 'flo-vector2d';
-import { fromTo, len, distanceBetween, toUnitVector, rotate90Degrees, cross } from 'flo-vector2d';
-import { circumCenter as getCircumCenter } from './timed-cc.js';  // TODO - testing - restore
+import { circumCenter as getCircumCenter, fromTo, len, distanceBetween, toUnitVector, rotate90Degrees, cross } from 'flo-vector2d';
 import { tangent } from 'flo-bezier3';
 import { calcInitial3ProngCenter } from './calc-initial-3-prong-center.js';
 import { getClosestPoints } from './get-closest-points.js';
@@ -69,7 +67,6 @@ function find3ProngForDelta3s(
 
     if (isSharp(δ3s[0][0])) { return undefined; }
 
-    // TODO
     //----------------------------
     // const l1 = curvePiece3s[0].length;
     // const l2 = curvePiece3s[1].length;