flo-mat 4.0.2 → 4.1.0

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;

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

@@ -2,7 +2,6 @@ import type { CpNode } from '../cp-node/cp-node.js';
 import type { ThreeProngInfo } from './three-prong-info.js';
 import { find3ProngForDelta3s } from './find-3-prong-for-delta3s.js';
 import { getBoundaryPieceBeziers } from '../mat/get-boundary-piece-beziers.js';
-import { timeFunctionCalls } from '../utils/time-function-call.js';
 
 
 /**

package/src/find-3-prong/find-and-add-3-prong.ts

@@ -25,21 +25,7 @@ function findAndAdd3Prong(
         δs.push([visitedCp, visitedCp.next]);
     }
 
-    // TODO - remove - debugging
-    //-------------------------
-    // ii++;
-    // if (ii === 13) {
-    //     //@ts-ignore
-    //     if (_debug_.temp === undefined) { _debug_.temp = []; }
-    //     //@ts-ignore
-    //     _debug_.temp.push(δs);
-    // }
-    // //@ts-ignore
-    // if (_debug_.temp2 === undefined) { _debug_.temp2 = []; }
-    // //@ts-ignore
-    // _debug_.temp2.push(δs.length);
-    //-------------------------
-    
+
     const threeProngInfo = find3Prong(δs, meta.maxCoordPowerOf2);
 
     const { circle, poss, δ3s } = threeProngInfo;

package/src/find-mat/find-mat.ts

@@ -8,7 +8,7 @@ import type { MatOptions } from './mat-options.js';
 import type { MatMeta } from '../mat/mat-meta.js';
 import { findAndAdd3ProngsOnLoop } from '../find-3-prong/find-and-add-3-prongs-on-loop.js';
 import { createInitialCpTree } from './create-initial-cp-tree.js';
-import { /*getPointToCpNode,*/ getPartialMeta, addDebugInfo2, addDebugInfo3, addDebugInfo4, getPointToCpNode } from './get-meta.js';
+import { getPartialMeta, addDebugInfo1, addDebugInfo2, addDebugInfo3, addDebugInfo4 } from './get-meta.js';
 import { getSharpCornersOnLoop } from './get-sharp-corners.js';
 import { getDullCornersOnLoop } from './get-dull-corners-on-loop.js';
 import { findAndAdd2ProngsOnAllLoops } from '../find-2-prong/find-and-add-2-prongs-on-all-loops.js';
@@ -32,6 +32,8 @@ function findMat(
             meta: MatMeta;
         } {
 
+    addDebugInfo1();
+
     const { minBezLength, maxCurviness, maxLength, angleIncrement } = options;
 
     const getSharpCornersOnLoop_ = getSharpCornersOnLoop(minBezLength);
@@ -49,7 +51,6 @@ function findMat(
     const cpTrees = createInitialCpTree(loops, sharpCornersPerLoop, lastInsertId);
 
     const _meta = getPartialMeta(loops);
-    const pointToCpNode = getPointToCpNode(loops, cpTrees);
     const meta: MatMeta = {
         maxCoordPowerOf2, squaredDiagonalLength, loops, cpTrees,// pointToCpNode,
         lastInsertId, ..._meta

package/src/find-mat/find-mats.ts

@@ -6,7 +6,6 @@ import { toScaleAxis } from '../sat/to-scale-axis.js';
 import { clipOptions } from './clip-options.js';
 import { findMat  } from './find-mat.js';
 import { defaultMatOptions, MatOptions } from './mat-options.js';
-import { circumCenter } from '../find-3-prong/timed-cc.js';
 
 
 const { ceil, log2 } = Math;

package/src/find-mat/get-dull-corners-on-loop.ts

@@ -19,12 +19,13 @@ function getDullCornersOnLoop(
             }
 
             const { next, ps } = curve;
-            
+
             if (getCorner(ps, next.ps).isQuiteDull) {
                 const p = ps[ps.length - 1];
+                const pDd = [[0,p[0]], [0,p[1]]];
 
-                dullCorners.push({ curve, t: 1, isSource: true, p });
-                dullCorners.push({ curve: next, t: 0, isSource: true, p });
+                dullCorners.push({ curve, t: 1, isSource: true, p, pDd });
+                dullCorners.push({ curve: next, t: 0, isSource: true, p, pDd });
             }
         }
 

package/src/find-mat/get-for-1-prongs-on-loop.ts

@@ -24,9 +24,14 @@ function getFor1ProngsOnLoop(
                 continue;
             }
 
-            poss.push(...getCurvatureExtremaDd(curve.ps).maxima.map(t => ({
-                curve, t, isSource: true, p: toP(curve.ps, t)
-            })));
+            const { ps } = curve;
+
+            poss.push(...getCurvatureExtremaDd(ps).maxima.map(t => {
+                const pDd = toP(ps, t);
+                const p = pDd.map(c => c[0] + c[1]);
+
+                return { curve, t, isSource: true, p, pDd }
+            }));
         }
 
         return poss;

package/src/find-mat/get-for-2-prongs-on-loop.ts

@@ -36,7 +36,12 @@ function getFor2ProngsOnLoop(
             ts = ts.filter(t => t !== 0 && t !== 1);
 
             const byCurvatureAndLength: PrePointOnShape[] = 
-                ts.map(t => ({ curve, t, isSource: true, p: toP(curve.ps, t) }));
+                ts.map(t => {
+                    const pDd = toP(curve.ps, t);
+                    const p = pDd.map(c => c[0] + c[1]);
+
+                    return { curve, t, isSource: true, p, pDd };
+                });
 
             for2Prongs.push(...byCurvatureAndLength);
         }

package/src/find-mat/get-meta.ts

@@ -1,13 +1,9 @@
 import type { Debug }   from '../debug/debug.js';
 import type { Loop } from 'flo-boolean';
 import type { Curve } from 'flo-boolean';
-import type { CpNode } from '../cp-node/cp-node.js';
-import type { TriMap } from '../utils/tri-map.js';
 import type { MatMeta } from '../mat/mat-meta.js';
-// import { TriMapFs } from '../utils/tri-map.js';
 import { getBoundingHull, getBoundingBoxTight } from 'flo-bezier3';
 import { getBoundingBox$ } from '../geometry/get-bounding-box-.js';
-import { RbTree } from 'flo-ll-rb-tree';
 import { getCorner } from '../corner/get-corner.js';
 
 
@@ -18,30 +14,6 @@ declare const _debug_: Debug;
 let timingStart: number;
 
 
-/** @internal */
-function getPointToCpNode(
-        loops: Loop[],
-        cpTrees: Map<Loop, RbTree<CpNode>>): TriMap<Loop,number,number,CpNode> {
-
-    timingStart = performance.now();
-
-    // const pointToCpNode: TriMap<Loop,number,number,CpNode> = new Map();
-
-    // for (const loop of loops) {
-    //     // Populate `posMap`
-    //     const cpTree = cpTrees.get(loop)!;
-    //     const cpNodes = cpTree.toArrayInOrder();
-    //     for (const cpNode of cpNodes) {
-    //         const { p, t } = cpNode.pointOnShape;
-    //         TriMapFs.set(pointToCpNode,loop,p[0],p[1],cpNode);
-    //     }
-    // }
-
-    // return pointToCpNode;
-    return undefined!
-}
-
-
 /** @internal */
 function getPartialMeta(
         loops: Loop[]): Omit<
@@ -92,42 +64,46 @@ function getPartialMeta(
 }
 
 
+function addDebugInfo1() {
+    if (typeof _debug_ === 'undefined') { return; }
+
+    timingStart = performance.now();
+}
+
+
+
 /** @internal */
 function addDebugInfo2() {
     if (typeof _debug_ === 'undefined') { return; }
 
-    const timing = _debug_.generated.timing;
     const now = performance.now();
-    timing.holeClosers += now - timingStart;
+    _debug_.timing.holeClosers += now - timingStart;
     timingStart = now;
 }
 
 
+/** @internal */
 function addDebugInfo3() {
     if (typeof _debug_ === 'undefined') { return; }
 
-    const generated = _debug_.generated;
-    const timing = generated.timing;
     const now = performance.now();
 
-    timing.oneAnd2Prongs += now - timingStart;
+    _debug_.timing.oneAnd2Prongs += now - timingStart;
     timingStart = now;
 }
 
 
+/** @internal */
 function addDebugInfo4() {
     if (typeof _debug_ === 'undefined') { return; }
 
-    const generated = _debug_.generated;
-    const timing = generated.timing;
-
-    timing.threeProngs += performance.now() - timingStart;
+    _debug_.timing.threeProngs += performance.now() - timingStart;
 }
 
 
 export {
-    getPointToCpNode,
     getPartialMeta,
+    addDebugInfo1,
     addDebugInfo2,
     addDebugInfo3,
     addDebugInfo4

package/src/find-mat/get-sharp-corners.ts

@@ -20,7 +20,11 @@ function getSharpCornersOnLoop(
             }
             
             if (getCorner(curve.ps, curve.next.ps).isQuiteSharp) {
-                sharpCorners.push({ curve, t: 1, isSource: true, p: toP(curve.ps, 1) });
+                const { ps } = curve;
+
+                const p = ps[ps.length - 1];
+                const pDd = [[0,p[0]],[0,p[1]]];
+                sharpCorners.push({ curve, t: 1, isSource: true, p, pDd });
             }
         }