flo-mat 4.0.1 → 4.0.3

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

@@ -17,7 +17,6 @@ import { toP } from '../point-on-shape/to-p.js';
  * @internal
  */
 function getCloseBoundaryPointsCertified(
-        maxCoordPowerOf2: number,
         curvePieces: CurvePiece[], 
         x: number[]): PrePointOnShape[] {
     
@@ -28,7 +27,6 @@ function getCloseBoundaryPointsCertified(
         const curvePiece = curvePieces[i];
 
         const _pInfos = getPotentialClosestPointsOnCurveCertified(
-            maxCoordPowerOf2,
             curvePiece.curve, 
             x, 
             curvePiece.ts as [number,number]

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

@@ -1,62 +1,76 @@
 import type { Curve } from "flo-boolean";
 import type { FootAndEndpointInfo } from './foot-and-endpoint-info.js';
-import { createRootExact, roots } from 'flo-poly';
-import { getFootPointsOnBezierPolysCertified, getIntervalBox } from 'flo-bezier3';
+import { roots } from 'flo-poly';
+import { evalDeCasteljauDd, getFootPointsOnBezierPolysCertified, getIntervalBox } from 'flo-bezier3';
 import { rootIntervalToDistanceSquaredInterval } from './root-interval-to-distance-squared-interval.js';
-import { getPFromBox } from './get-p-from-box.js';
-
-const { sqrt } = Math;
+import { squaredDistanceBetweenDd } from "../find-2-prong/squared-distance-between-dd.js";
+import { eps } from '../error-analysis/gamma.js';
 
 
 /**
  * @internal
  * 
- * @param maxCoordPowerOf2
  * @param curve the curve
  * @param x the point from which to check
  * @param tRange The allowed t range
  */
 function getPotentialClosestPointsOnCurveCertified(
-        maxCoordPowerOf2: number,
         curve: Curve, 
         x: number[], 
         tRange: [number, number]): FootAndEndpointInfo[] {
 
     const [tS,tE] = tRange;
-    const ps = curve.ps;
+    const { ps } = curve;
+
+    const infos: FootAndEndpointInfo[] = [];
+
+    if (tS !== tE) {
+        const { polyDd: pDd, polyE: pDd_, getPolyExact } =
+            getFootPointsOnBezierPolysCertified(ps, x);
+
+        const ris = roots(pDd, tS, tE, pDd_, getPolyExact) || [];
+
+        infos.push(...ris.map(ri => {
+            const { tS: ts, tE: te, t: _t } = ri;
+
+            const t = _t < 0 ? 0 : _t > 1 ? 1 : _t;
+
+            const box = getIntervalBox(ps, [ts, te]);
 
-    let { polyDd: pDd, polyE: pDd_, getPolyExact } =
-        getFootPointsOnBezierPolysCertified(ps, x);
+            const dSquaredI = rootIntervalToDistanceSquaredInterval(box, x);
 
-    const ris = roots(pDd, tS, tE, pDd_, getPolyExact) || [];
+            const t_ = t === 0 ? 1 : t;
+            const curve_ = t === 0 ? curve.prev : curve;
 
-    ris.push(createRootExact(tS));
-    ris.push(createRootExact(tE));
+            return {
+                curve: curve_,
+                t: t_,
+                dSquaredI
+            }
+        }));
+    }
 
-    const infos = ris
-    .map(ri => {
-        const { tS: ts, tE: te } = ri;
+    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 _t = (ts + te)/2;
-        const t = _t < 0 ? 0 : _t > 1 ? 1 : _t;
+        const d = squaredDistanceBetweenDd(p, x);
 
-        const box = getIntervalBox(ps, [ts, te]);
-        const p_ = getPFromBox(box);
-        
-        const dSquaredI = rootIntervalToDistanceSquaredInterval(maxCoordPowerOf2, box, x);
+        const dSquaredI = [d*(1 - eps), d*(1 + eps)];
 
         const t_ = t === 0 ? 1 : t;
         const curve_ = t === 0 ? curve.prev : curve;
 
         return {
             curve: curve_,
-            p: p_,
             t: t_,
-            d: (sqrt(dSquaredI[0]) + sqrt(dSquaredI[1]))/2,
-            dSquaredI,
-            box
+            dSquaredI
         }
-    });
+    }));
 
     return infos;
 }

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

@@ -1,12 +1,6 @@
-import { twoDiff, eEstimate, eMult, eAdd } from 'big-float-ts';
-import { ddMultDd, ddAddDd } from 'double-double';
+import { twoDiff, ddMultDd, ddAddDd } from 'double-double';
 
-
-// We *have* to do the below to improve performance with bundlers❗ The assignee is a getter❗ The assigned is a pure function❗
-const estimate = eEstimate;
 const td = twoDiff;
-// const emult = eMult;
-// const eadd = eAdd;
 const qmq = ddMultDd;
 const qaq = ddAddDd;
 
@@ -25,7 +19,6 @@ const eps = Number.EPSILON;
  * @internal
  */
 function rootIntervalToDistanceSquaredInterval(
-        maxCoordPowerOf2: number,
         box: number[][], 
         p: number[]) {
 
@@ -62,8 +55,10 @@ function rootIntervalToDistanceSquaredInterval(
         const dc1Dd = qaq(qmq(ax,ax),qmq(by,by));  // ax**2 + bx**2
         const dc1 = dc1Dd[1];
 
-        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 - 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;

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

@@ -1,7 +1,7 @@
 import type { CpNode } from "../cp-node.js";
 import type { PointOnShape } from "../../point-on-shape/point-on-shape.js";
 import type { Mutable } from "../../utils/mutable.js";
-import { LlRbTree } from "flo-ll-rb-tree";
+import { RbTree } from "flo-ll-rb-tree";
 import { isOrderCorrect } from "./is-order-correct.js";
 
 
@@ -9,7 +9,7 @@ function insertCpNode(
         insertIfOrderWrong: boolean,
         isHoleClosing: boolean,
         isIntersection: boolean,
-        cpTree: LlRbTree<CpNode>,
+        cpTree: RbTree<CpNode>,
         pos: PointOnShape,
         _prev: CpNode | undefined,
         lastInsertId: { id: number }): CpNode | undefined {

package/src/cp-node/fs/is-on-same-loop.ts

@@ -0,0 +1,15 @@
+import type { CpNode } from "flo-mat";
+
+
+function isOnSameLoop(
+        cpNode1: CpNode,
+        cpNode2: CpNode): boolean {
+
+    return (
+        cpNode1.pointOnShape.curve.loop === 
+        cpNode2.pointOnShape.curve.loop
+    );
+}
+
+
+export { isOnSameLoop }

package/src/cp-node/fs/is-order-correct.ts

@@ -1,11 +1,11 @@
 import type { CpNode } from "../cp-node.js";
-import { LlRbTree } from "flo-ll-rb-tree";
+import { RbTree } from "flo-ll-rb-tree";
 import { PointOnShape } from "../../point-on-shape/point-on-shape.js";
 import { comparePoss } from "../../point-on-shape/compare-poss.js";
 
 
 function isOrderCorrect(
-        cpTree: LlRbTree<CpNode>,
+        cpTree: RbTree<CpNode>,
         pos: PointOnShape,
         next: CpNode): boolean {
 

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

@@ -27,7 +27,7 @@ function traverseCp(
         const next = cpNode.next.prevOnCircle;
         cpNode = cpNode === next
                 ? cpNode = cpNode.next.next // Terminal vertex
-                : cpNode = next         // Take last exit
+                : cpNode = next             // Take last exit
     
     } while (cpNode !== cpStart); 
     

package/src/cp-node/fs/traverse-vertices.ts

@@ -1,5 +1,4 @@
-import { CpNode } from '../cp-node.js';
-import { CpNodeFs } from '../cp-node-fs.js';
+import type { CpNode } from '../cp-node.js';
 import { getAllOnCircle } from './get-all-on-circle.js';
 import { isTerminating } from './is-terminating.js';
 import { getVertexForwardChildren } from './get-vertex-forward-children.js';

package/src/debug/debug.ts

@@ -1,20 +1,20 @@
-import { generalDebugFunctions } from './functions/general.js';
-import { IGeneralDebugFunctions } from './functions/general.js'; 
-import { DrawElemFunctions } from './functions/draw-elem/draw-elem.js';
-import { DebugElems } from './debug-elem-types.js';
+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 */
-    generated: Generated;
+    elems: GeneratedElems;
+    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: IDebugFunctions;
-    directives: IDirectives;
+    fs: DebugFunctions;
+    directives: Directives;
 }
 
 
@@ -23,32 +23,23 @@ type GeneratedElems = { [T in keyof DebugElems]: DebugElems[T][] };
 
 
 /** @internal */
-interface ITiming {
-    //normalize     : number;
-    //simplifyPaths : number;
-    holeClosers   : number;
-    oneAnd2Prongs : number;
-    threeProngs   : number;
-    sats          : number;
-    simplifyMat   : number;
-}
-
-
-/** @internal */
-interface Generated {
-    elems: GeneratedElems;
-    timing: ITiming;
+interface Timing {
+    holeClosers: number;
+    oneAnd2Prongs: number;
+    threeProngs: number;
+    sats: number;
+    simplifyMat: number;
 }
 
 
 /** @internal */
-interface IDebugFunctions extends IGeneralDebugFunctions {
-    drawElem   : DrawElemFunctions,
+interface DebugFunctions {
+    drawElem: DrawElemFunctions,
 }
 
 
 /** @internal */
-interface IDirectives {
+interface Directives {
     stopAfterHoleClosers: boolean,
     stopAfterHoleClosersNum: number,
     stopAfterTwoProngs: boolean,
@@ -68,59 +59,50 @@ function enableDebugForMat(debugOn: boolean) {
 
     debug = { 
         ...debug, 
-        generated: { 
-            //...debug?.generated,
-            ...(!debug ? {} : !debug.generated ? {} : debug.generated),
+        elems: { 
+            ...debug?.elems,
             // @ts-ignore
-            elems: { 
-                //...debug?.generated?.elems,
-                ...(!debug ? {} : !debug.generated ? {} : !debug.generated.elems ? {} : debug.generated.elems),
-                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                : [],
-            },
-            timing: {
-                //...debug?.generated?.timing,
-                ...(!debug ? {} : !debug.generated ? {} : !debug.generated.timing ? {} : debug.generated.timing),
-                holeClosers   : 0,
-                oneAnd2Prongs : 0,
-                threeProngs   : 0,
-                sats          : 0,
-                simplifyMat   : 0,
-            }
+
+            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                : [],
+        },
+        timing: {
+            ...debug?.timing,
+            holeClosers: 0,
+            oneAnd2Prongs: 0,
+            threeProngs: 0,
+            sats: 0,
+            simplifyMat: 0,
         },
         fs: {
-            //...debug?.fs,
-            ...(!debug ? {} : !debug.fs ? {} : debug.fs),
-            // @ts-ignore
+            ...debug?.fs,
             drawElem: {
-                //...debug?.fs?.drawElem,
-                ...(!debug ? {} : !debug.fs ? {} : !debug.fs.drawElem ? {} : debug.fs.drawElem),
+                ...debug?.fs?.drawElem,
                 ...drawElemFs
-            },
-            ...generalDebugFunctions
+            }
         },
         directives: {
             //...debug?.directives,
-            ...(!debug ? {} : !debug.directives ? {} : debug.directives),
+            ...debug?.directives,
             stopAfterHoleClosers: false,
             stopAfterHoleClosersNum: undefined!,
             stopAfterTwoProngs: false,
@@ -135,6 +117,6 @@ function enableDebugForMat(debugOn: boolean) {
 
 
 export { 
-    Debug, GeneratedElems, ITiming, Generated,
-    IDebugFunctions, IDirectives, enableDebugForMat
+    Debug, GeneratedElems, Timing,
+    DebugFunctions, Directives, enableDebugForMat
 }

package/src/debug/functions/check-ordering.ts

@@ -1,5 +1,4 @@
 import type { Loop } from "flo-boolean";
-import type { LlRbTree } from "flo-ll-rb-tree";
 import type { MatMeta } from "../../mat/mat-meta.js";
 import { CpNode } from "../../cp-node/cp-node.js";
 import { getAllOnLoop } from "../../cp-node/fs/get-all-on-loop.js";

package/src/debug/functions/draw-elem/draw-branch.ts

@@ -1,6 +1,4 @@
-import { drawFs } from 'flo-draw';
-import { CpNode } from '../../../cp-node/cp-node.js';
-import { CpNodeFs } from '../../../cp-node/cp-node-fs.js';
+import type { CpNode } from '../../../cp-node/cp-node.js';
 import { getMatCurveToNext } from '../../../cp-node/fs/get-mat-curve-to-next.js';
 import { isTerminating } from '../../../cp-node/fs/is-terminating.js';
 import { drawBeziersAsSinglePath } from '../draw/draw-beziers-as-single-path.js';

package/src/debug/functions/draw-elem/draw-cp-node.ts

@@ -1,8 +1,7 @@
-
+import type { CpNode } from '../../../cp-node/cp-node.js';
 import { drawFs } from 'flo-draw';
 import { scaleCircle } from '../../../geometry/circle.js';
-import { CpNode } from '../../../cp-node/cp-node.js';
-import { CpNodeFs } from '../../../cp-node/cp-node-fs.js';
+import { getAllOnCircle } from '../../../cp-node/fs/get-all-on-circle.js';
 
 
 /** @internal */
@@ -19,7 +18,7 @@ function drawCpNode(
     );
     const { center: c, radius: r } = circle;
     
-    const poss = CpNodeFs.getAllOnCircle(cpNode)
+    const poss = getAllOnCircle(cpNode)
         .map(cpNode => cpNode.pointOnShape)
 
     const { dot, circle: drawCircle, crossHair } = drawFs;

package/src/debug/functions/draw-elem/draw-leaves.ts

@@ -1,7 +1,7 @@
+import type { CpNode } from '../../../cp-node/cp-node.js';
 import { drawFs } from 'flo-draw';
-import { CpNodeFs } from '../../../cp-node/cp-node-fs.js';
-import { CpNode } from '../../../cp-node/cp-node.js';
 import { drawCirclePercent } from './draw-circle-percent.js';
+import { getAllOnCircle } from '../../../cp-node/fs/get-all-on-circle.js';
 
 
 /** @internal */
@@ -22,7 +22,7 @@ function drawLeaves(
 
         const $center = [drawCirclePercent(g, c, 0.5, 'pinker thin5 nofill')];
 
-        const poss = CpNodeFs.getAllOnCircle(cpNode)
+        const poss = getAllOnCircle(cpNode)
             .map(cpNode => cpNode.pointOnShape);
 
         const $ls: SVGElement[] = [];

package/src/debug/functions/draw-elem/draw-mat.ts

@@ -1,11 +1,8 @@
+import type { Mat } from '../../../mat/mat.js';
 import { drawFs } from 'flo-draw';
-import { Mat } from '../../../mat/mat.js';
 import { traverseEdges } from '../../../cp-node/fs/traverse-edges.js';
 import { getMatCurveToNext } from '../../../cp-node/fs/get-mat-curve-to-next.js';
-import { CpNodeFs } from '../../../cp-node/cp-node-fs.js';
-
-
-const { isTerminating } = CpNodeFs;
+import { isTerminating } from '../../../cp-node/fs/is-terminating.js';
 
 
 const altClasses = [

package/src/debug/functions/draw-elem/draw-min-y.ts

@@ -1,6 +1,6 @@
-import { toCubic, evalDeCasteljau } from 'flo-bezier3';
+import type { PointOnShape } from '../../../point-on-shape/point-on-shape.js';
+import { evalDeCasteljau } from 'flo-bezier3';
 import { drawFs } from 'flo-draw';
-import { PointOnShape } from '../../../point-on-shape/point-on-shape.js';
 
 
 /** @internal */

package/src/debug/functions/draw-elem/draw-three-prong.ts

@@ -1,7 +1,7 @@
+import type { CpNode } from '../../../cp-node/cp-node.js';
 import { drawFs } from 'flo-draw';
 import { scaleCircle } from '../../../geometry/circle.js';
-import { CpNode } from '../../../cp-node/cp-node.js';
-import { CpNodeFs } from '../../../cp-node/cp-node-fs.js';
+import { getAllOnCircle } from '../../../cp-node/fs/get-all-on-circle.js';
 
 
 /** @internal */
@@ -20,7 +20,7 @@ function drawThreeProng(
     const { center: c, radius: r } = circle;
     
     // const poss = threeProng.poss;
-    const poss = CpNodeFs.getAllOnCircle(threeProng)
+    const poss = getAllOnCircle(threeProng)
         .map(cpNode => cpNode.pointOnShape)
 
     const { dot, circle: drawCircle, crossHair } = drawFs;

package/src/debug/functions/draw-elem/draw-vertex.ts

@@ -1,8 +1,5 @@
+import type { CpNode } from '../../../cp-node/cp-node.js';
 import { drawFs } from 'flo-draw';
-import { CpNode } from '../../../cp-node/cp-node.js';
-import { CpNodeFs } from '../../../cp-node/cp-node-fs.js';
-
-const { getAllOnCircle } = CpNodeFs;
 
 
 /** @internal */

package/src/error-analysis/gamma.ts

@@ -1,4 +1,11 @@
-const u = Number.EPSILON / 2;
+
+/** `2 * 2^-53` -> 2x the standard round-of unit `=== Number.EPSILON` */
+const eps = Number.EPSILON;
+
+/** `2^-53` -> the standard round-of unit `=== eps/2` */
+const u = eps / 2; 
+
+/** `2^-106` -> the standard round-of unit for double-double precision `=== (eps/2)**2` */
 const uu = u*u;
 
 
@@ -38,4 +45,4 @@ function γγ(n: number): number {
 }
 
 
-export { γ, γγ }
+export { γ, γγ, u, uu, eps }

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

@@ -50,11 +50,7 @@ function add1Prong(
         return;
     }
 
-    const { anyFailed, cpNodes } = addToCpTree(false, false, circle, [-0.5, +0.5], meta, [pos, pos]); 
-    
-    // if (typeof _debug_ !== 'undefined') { 
-    //     _debug_.generated.elems.oneProng.push(cpNodes);
-    // }
+    addToCpTree(false, false, circle, [-0.5, +0.5], meta, [pos, pos]); 
 }
 
 

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

@@ -83,11 +83,6 @@ function find2Prong(
         const xy2 = reduceRadius(maxCoordPowerOf2, curvePieces, y, nnorm);
         const xy = sqrt(xy2);
 
-        if (for1Prong && rO < (1 - oneProngTolerance)*xy) {
-            add1Prong(meta, rO, xO, yPos);
-            return undefined;
-        }
-
         const l = sqrt(nnorm[0]**2 + nnorm[1]**2);
         xO = [y[0] + nnorm[0]/l*xy, y[1] + nnorm[1]/l*xy];
 
@@ -110,6 +105,12 @@ function find2Prong(
         }
 
         const { x, d, curve, s } = antipodalPoints[0];
+
+        if (for1Prong && rO < (1 - oneProngTolerance)*d) {
+            add1Prong(meta, rO, xO, yPos);
+            return undefined;
+        }
+
         const z: PrePointOnShape = {
             curve, t: s, isSource: false,
             p: toP(curve.ps, s)
@@ -126,7 +127,7 @@ function find2Prong(
             // The lines below eliminate cases where the found 2-prong is too
             // close to a one-prong
             const squaredSeperationTolerance = max(
-                calcSeperationTolerance(rO, sqrt(xz), 2**2*errorTolerance),
+                calcSeperationTolerance(rO, sqrt(xz), (2**2)*errorTolerance),
                 minSquaredSeperationTolerance
             );
             if (yz <= squaredSeperationTolerance) {