flo-mat 3.0.14 → 4.0.1

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

@@ -1,58 +1,46 @@
-import { CurvePiece  } from '../mat/curve-piece.js';
+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.js';
-import { Curve } from '../curve/curve.js';
-import { FootAndEndpointInfo } from './foot-and-endpoint-info.js';
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { createPos } from '../point-on-shape/create-pos.js';
+import { cullCurvePieces1 } from './cull-bezier-pieces-1.js';
+import { toP } from '../point-on-shape/to-p.js';
 
 
 /**
- * @internal
  * Returns the closest boundary point to the given point, limited to the given 
  * bezier pieces, including the beziers actually checked after culling.
  * 
- * @param pow
+ * @param maxCoordPowerOf2
  * @param curvePieces
  * @param x
- * @param touchedCurve
- * @param t
- * @param for1Prong defaults to `false`;
- * @param angle defaults to `0`
+ * 
+ * @internal
  */
 function getCloseBoundaryPointsCertified(
-        pow: number,
+        maxCoordPowerOf2: number,
         curvePieces: CurvePiece[], 
-        x: number[], 
-        touchedCurve: Curve | undefined = undefined,
-        t: number | undefined = undefined,
-        for1Prong = false,
-        angle = 0): PointOnShape[] {
+        x: number[]): PrePointOnShape[] {
     
     curvePieces = cullCurvePieces1(curvePieces, x);
  
-    const pInfoss: FootAndEndpointInfo[] = [];
+    const pInfos: FootAndEndpointInfo[] = [];
     for (let i=0; i<curvePieces.length; i++) {
         const curvePiece = curvePieces[i];
 
-        const pInfos = getPotentialClosestPointsOnCurveCertified(
-            pow,
+        const _pInfos = getPotentialClosestPointsOnCurveCertified(
+            maxCoordPowerOf2,
             curvePiece.curve, 
             x, 
-            curvePiece.ts, 
-            touchedCurve, 
-            t,
-            for1Prong,
-            angle
+            curvePiece.ts as [number,number]
         );
 
-        pInfoss.push(...pInfos);
+        pInfos.push(..._pInfos);
     }
 
     /** the minimum max interval value */
-    let minMax = Number.POSITIVE_INFINITY;
-    for (let i=0; i<pInfoss.length; i++) {
-        const diMax = pInfoss[i].dSquaredI[1];
+    let minMax = Infinity;
+    for (let i=0; i<pInfos.length; i++) {
+        const diMax = pInfos[i].dSquaredI[1];
         if (diMax < minMax) {
             minMax = diMax;
         }
@@ -60,14 +48,22 @@ function getCloseBoundaryPointsCertified(
 
     const closestPointInfos: FootAndEndpointInfo[] = [];
 
-    for (let i=0; i<pInfoss.length; i++) {
-        const info = pInfoss[i];
+    for (let i=0; i<pInfos.length; i++) {
+        const info = pInfos[i];
         if (info.dSquaredI[0] <= minMax) {
             closestPointInfos.push(info);
         }
     }
 
-    return closestPointInfos.map(info => createPos(info.curve, info.t, false));
+    return closestPointInfos.map(info => {
+        const { curve, t } = info;
+        const { ps } = curve;
+        const p = toP(ps, t);
+        
+        return {
+            p, t, curve, isSource: false
+        };
+    });
 }
 
 

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

@@ -1,15 +1,9 @@
-import { allRootsCertified } from 'flo-poly';
+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 { Curve } from "../curve/curve.js";
-import { ddDeflateWithRunningError } from './dd-deflate-with-running-error.js';
-import { eDeflate } from 'flo-poly';
-import { γγ } from '../error-analysis/gamma.js';
 import { rootIntervalToDistanceSquaredInterval } from './root-interval-to-distance-squared-interval.js';
 import { getPFromBox } from './get-p-from-box.js';
-import { FootAndEndpointInfo } from './foot-and-endpoint-info.js';
-
-
-const γγ3 = γγ(3);
 
 const { sqrt } = Math;
 
@@ -17,106 +11,39 @@ const { sqrt } = Math;
 /**
  * @internal
  * 
- * @param pow
- * @param curve The curve
- * @param x The point from which to check
+ * @param maxCoordPowerOf2
+ * @param curve the curve
+ * @param x the point from which to check
  * @param tRange The allowed t range
- * @param touchedCurve The bezier on which p is located
- * @param t The t value of the bezier that locates p
- * @param for1Prong defaults to `false;
- * @param angle defaults to `0`;
  */
 function getPotentialClosestPointsOnCurveCertified(
-        pow: number,
+        maxCoordPowerOf2: number,
         curve: Curve, 
         x: number[], 
-        tRange: number[] = [0,1], 
-        touchedCurve: Curve | undefined = undefined,
-        t: number | undefined = undefined,
-        for1Prong = false,
-        angle = 0): FootAndEndpointInfo[] {
+        tRange: [number, number]): FootAndEndpointInfo[] {
 
     const [tS,tE] = tRange;
     const ps = curve.ps;
 
-    const shouldDeflate = angle === 0 && curve === touchedCurve;
-
-    let { polyDd: polyDdO, polyE: polyEO, getPolyExact: getPolyExactO } =
+    let { polyDd: pDd, polyE: pDd_, getPolyExact } =
         getFootPointsOnBezierPolysCertified(ps, x);
 
-    const def = shouldDeflate
-            ? ddDeflateWithRunningError(polyDdO, polyEO.map(e => e/γγ3), t!)
-            : undefined;
-    
-    const def2 = for1Prong && shouldDeflate
-            ? ddDeflateWithRunningError(def!.coeffs, def!.errBound.map(e => e/γγ3), t!)
-            : undefined;
-
-    const def3 = for1Prong && shouldDeflate
-            ? ddDeflateWithRunningError(def2!.coeffs, def2!.errBound.map(e => e/γγ3), t!)
-            : undefined;
-    
-    const { polyDd, polyE, getPolyExact } = 
-              def3 !== undefined
-            ? {
-                polyDd: def3.coeffs,
-                polyE: def3.errBound,
-                getPolyExact:  () => eDeflate(eDeflate(eDeflate(getPolyExactO(), t!), t!), t!)
-            }
-            : def !== undefined
-            ? {
-                polyDd: def.coeffs,
-                polyE: def.errBound,
-                getPolyExact: () => eDeflate(getPolyExactO(), t!)
-            }
-            : {
-                polyDd: polyDdO,
-                polyE: polyEO,
-                getPolyExact: getPolyExactO
-            };
-    
-    const ris = allRootsCertified(polyDd, tS, tE, polyE, getPolyExact);
-
-    const dontPush0 = (
-        (t === 1 && curve === touchedCurve!.next) ||
-        (t === 0 && curve === touchedCurve)
-    );
-    const dontPush1 = (
-        (t === 0 && curve === touchedCurve!.prev) ||
-        (t === 1 && curve === touchedCurve)
-    );
+    const ris = roots(pDd, tS, tE, pDd_, getPolyExact) || [];
 
-    if (tS === 0) {
-        if (!dontPush0) { ris.push({ tS: 0, tE: 0, multiplicity: 1 }); }
-    } else if (tS === 1) {
-        if (!dontPush1) { ris.push({ tS: 1, tE: 1, multiplicity: 1 }); }
-    } else {
-        ris.push({ tS: tS, tE: tS, multiplicity: 1 });
-    }
-
-    if (tE === 0) {
-        if (!dontPush0) { ris.push({ tS: 0, tE: 0, multiplicity: 1 }); }
-    } else if (tE === 1) {
-        if (!dontPush1) { ris.push({ tS: 1, tE: 1, multiplicity: 1 }); }
-    } else {
-        ris.push({ tS: tE, tE: tE, multiplicity: 1 });
-    }
+    ris.push(createRootExact(tS));
+    ris.push(createRootExact(tE));
 
     const infos = ris
     .map(ri => {
         const { tS: ts, tE: te } = ri;
 
-        if (te < tS || ts > tE) {
-            return undefined;
-        }
-
         const _t = (ts + te)/2;
         const t = _t < 0 ? 0 : _t > 1 ? 1 : _t;
 
         const box = getIntervalBox(ps, [ts, te]);
         const p_ = getPFromBox(box);
         
-        const dSquaredI = rootIntervalToDistanceSquaredInterval(pow, box, x);
+        const dSquaredI = rootIntervalToDistanceSquaredInterval(maxCoordPowerOf2, box, x);
 
         const t_ = t === 0 ? 1 : t;
         const curve_ = t === 0 ? curve.prev : curve;
@@ -127,13 +54,11 @@ function getPotentialClosestPointsOnCurveCertified(
             t: t_,
             d: (sqrt(dSquaredI[0]) + sqrt(dSquaredI[1]))/2,
             dSquaredI,
-            box,
+            box
         }
     });
 
-    const infos_ = infos.filter(info => info !== undefined) as FootAndEndpointInfo[];
-
-    return infos_;
+    return infos;
 }
 
 

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

@@ -25,7 +25,7 @@ const eps = Number.EPSILON;
  * @internal
  */
 function rootIntervalToDistanceSquaredInterval(
-        pow: number,
+        maxCoordPowerOf2: number,
         box: number[][], 
         p: number[]) {
 
@@ -39,8 +39,8 @@ function rootIntervalToDistanceSquaredInterval(
     const x = p[0];  // <0>
     const y = p[1];  // <0>
 
-    let minDSquared = Number.POSITIVE_INFINITY;
-    let maxDSquared = Number.NEGATIVE_INFINITY;
+    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]]) {
@@ -62,8 +62,8 @@ function rootIntervalToDistanceSquaredInterval(
         const dc1Dd = qaq(qmq(ax,ax),qmq(by,by));  // ax**2 + bx**2
         const dc1 = dc1Dd[1];
 
-        const dc1Min = dc1*(1 - 2**pow*eps);  // distance minus max error
-        const dc1Max = dc1*(1 + 2**pow*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
         
         if (dc1Min <= minDSquared) {
             minDSquared = dc1Min;

package/src/corner/compare-curvatures-at-interface.ts

@@ -13,7 +13,7 @@ const { sign } = Math;
  * Precondition: The point psI evaluated at zero must === the point psO 
  * evaluated at zero.
  * 
- * // TODO - is this correct?
+ * // FUTURE - is this correct?
  * Exact: Returns the exact result if the bithlength of all 
  * coordinates <= 53 - 5 === 48 and are bit-aligned.
  * 

package/src/corner/corner.ts

@@ -1,39 +1,40 @@
 
 /**
- * @internal
  * Represents a corner on the shape boundary, i.e. a point where two bezier
  * curves meet. Typically used internally only.
+ * 
+ * @internal
  */
 interface Corner {
     /** 
      * The unit tangents at the points t === 1 of the first curve and at 
      * t === 0 of the second respectively.
      */
-    tangents: number[][];
+    readonly tangents: number[][];
     /** The cross of the unit tangents. */
     // crossTangents: number;
     /** 
      * True if the corner is sharp, i.e. > 0 radians as one goes in a positive 
      * direction around the shape boundary.
      */
-    isSharp: boolean;
+    readonly isSharp: boolean;
     /** 
      * True if the corner is dull, i.e. < 0 radians as one goes in a positive 
      * direction around the shape boundary.
      */
-    isDull: boolean;
+    readonly isDull: boolean;
     /** 
      * True if the corner is quite sharp, i.e. > δ radians as one goes in a 
      * positive direction around the shape boundary where δ is some 
      * pre-determined parameter.
      */
-    isQuiteSharp: boolean;
+    readonly isQuiteSharp: boolean;
     /** 
      * True if the corner is quite dull, i.e. < δ radians as one goes in a 
      * positive direction around the shape boundary where δ is some 
      * pre-determined parameter.
      */
-    isQuiteDull: boolean;
+    readonly isQuiteDull: boolean;
 }
 
 

package/src/corner/get-corner.ts

@@ -1,5 +1,5 @@
-import { cross, dot, toUnitVector } from "flo-vector2d";
-import { Corner } from "./corner.js";
+import type { Corner } from "./corner.js";
+import { cross, toUnitVector } from "flo-vector2d";
 import { getInterfaceCcw } from './get-interface-ccw.js';
 
 
@@ -26,11 +26,6 @@ const DEGREE_LIMIT = DEGREES[4];
  * @internal
  * Returns a new corner with properties.
  * 
- * PRECONDITION: The beziers has control points with max bit-length of 26 and
- * aligned to a 'grid' to have the same exponent. This is so the vectors between
- * control points can be calculated exactly without resorting to adaptive 
- * infinite precision floating point operations.
- * 
  * @param psI The incoming bezier that ends in the corner
  * @param psO The outgoing bezier that starts at the corner
  */
@@ -38,8 +33,8 @@ function getCorner(
         psI: number[][],
         psO: number[][]): Corner {
 
-    // getInterfaceCcw must return a number !== 0 if psI and psO are not the
-    // same as seen as a curve extension with t ∈ [-∞,+∞]
+    // `getInterfaceCcw` must return a number !== 0 if `psI` and `psO` are not
+    // the same up to a curve extension with `t ∈ [-∞,+∞]`
     const { ccw, tangentI, tangentO, dotTangents } = getInterfaceCcw(psI, psO);
     const isSharp = ccw < 0;
     const isDull  = ccw > 0;
@@ -56,7 +51,6 @@ function getCorner(
 
     let isQuiteSharp: boolean; 
     let isQuiteDull: boolean; 
-    // const dotTangents = dot(tangentAtIncoming, tangentAtOutgoing);
     if (dotTangents > 0) {
         // Curves go in same direction
         isQuiteSharp = crossTangents < -DEGREE_LIMIT;
@@ -68,7 +62,6 @@ function getCorner(
 
     return {
         tangents: unitTangents, 
-        // crossTangents, 
         isSharp,
         isDull, 
         isQuiteSharp,

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

@@ -15,8 +15,8 @@ import { compareCurvaturesAtInterface } from "./compare-curvatures-at-interface.
  * Preconditions (for robustness):
  * * The bezier does not have infinite curvature at either endpoint
  * 
- * @param psI The incoming bezier that ends at the interface
- * @param psO The outgoing bezier that starts at the interface
+ * @param psI the incoming bezier that ends at the interface
+ * @param psO the outgoing bezier that starts at the interface
  */
 function getInterfaceCcw(
         psI: number[][],
@@ -72,9 +72,9 @@ function getInterfaceCcw(
 
     // Look at curvature
 
-    // TODO2
+    // FUTURE
     // The line below is probably not working correctly for infinite
-    // curvature but it should be rare to get here - investiagte.
+    // curvature but it should be rare to get here - investigate.
     // Probably need to resort to length of tangents and then if this is
     // also the same simply look at the last point's ccw wrt the 1st or
     // the second?
@@ -82,7 +82,6 @@ function getInterfaceCcw(
         ccw: compareCurvaturesAtInterface(psI.slice().reverse(), psO),
         tangentI,
         tangentO,
-        // crossTangents,
         dotTangents
     }
 }
@@ -95,6 +94,7 @@ function pointsEqual(
     return p1[0] === p2[0] && p1[1] === p2[1];
 }
 
+
 /**
  * The input is two exact double-double coefficient vectors
  * 

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

@@ -1,7 +1,4 @@
-import { CpNode } from "./cp-node.js";
 import { getHoleClosers } from "./fs/get-hole-closers.js";
-import { getSpeed } from "./fs/get-speed.js";
-import { getSmoothedSpeed$ } from "./fs/get-smoothed-speed.js";
 import { enhanceCpNode } from "./fs/enhance-cp-node.js";
 import { traverseCp } from './fs/traverse-cp.js';
 import { traverseEdges } from './fs/traverse-edges.js';
@@ -221,8 +218,6 @@ const CpNodeFs = {
     getBoundaryBeziersBetween,
     getMatCurvesBetween,
     getHoleClosers,
-    getSpeed,
-    getSmoothedSpeed$,
     getInitialDegAngleBetweenMatCurves,
     getAllVertices
 }

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

@@ -1,4 +1,5 @@
-import { ContactPoint } from '../contact-point/contact-point.js';
+// import { ContactPoint } from '../contact-point/contact-point.js';
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
 
 
 /**
@@ -50,35 +51,41 @@ import { ContactPoint } from '../contact-point/contact-point.js';
  * in opposite directions.
  */
 interface CpNode {
+    /** For debugging / easy identification only */
+    readonly id: number;
+
     /** The shape boundary contact point, i.e. a `CpNode` without its edges. */
-    cp: ContactPoint;
+    // cp: ContactPoint;
+    readonly pointOnShape: PointOnShape;
     /** If true, this `CpNode` belongs to a hole-closing maximal disk. */
-    isHoleClosing: boolean;
+    readonly isHoleClosing: boolean;
     /** true if this `CpNode` is at a shape boundary intersection point, false otherwise */
-    isIntersection: boolean;
+    readonly isIntersection: boolean;
+
+    //------------------------
+    // EDGES TO OTHER CpNodes
+    //------------------------
+
     /** The previous (going clockwise around the boundary) contact point `CpNode`. */
-    prev: CpNode;
+    readonly prev: CpNode;
     /** The next (going anti-clockwise around the boundary) contact point `CpNode`. */
-    next: CpNode;
+    readonly next: CpNode;
     /**
      * The previous `CpNode` (going clockwise around the inscribed circle
      * defined by the maximal disk).
      */
-    prevOnCircle: CpNode;
+    readonly prevOnCircle: CpNode;
     /**
      * The next `CpNode` (going anti-clockwise around 
      * the inscribed circle defined by the maximal disk).
      */
-    nextOnCircle: CpNode;
+    readonly nextOnCircle: CpNode;
     /**
      * For hole closers only - the twin `CpNode` at the same point, e.g.
      * use `cpNode.holeCloserTwin.next` to skip the hole closer and get to the
      * next `CpNode` on the same loop.
      */
-    holeCloserTwin?: CpNode | undefined;
-
-    /** For debugging / easy identification only */
-    id: number;
+    readonly holeCloserTwin?: CpNode | undefined;
 }
 
 

package/src/cp-node/fs/add-distance-from.ts

@@ -1,50 +1,49 @@
-import { getTAtLength, length } from "flo-bezier3";
-import { createPos } from "../../point-on-shape/create-pos.js";
-import { CpNode } from "../cp-node.js";
+//------------------------------
+// KEEP FOR POSSIBLE FUTURE USE
+//------------------------------
 
+// import { getTAtLength, length } from "flo-bezier3";
+// import { CpNode } from "../cp-node.js";
 
-function addDistanceFrom(
-        d: number,
-        cpNode: CpNode) {
 
-    const posS = cpNode.cp.pointOnShape;
-    const curveS = posS.curve;
+// function addDistanceFrom(
+//         d: number,
+//         cpNode: CpNode) {
 
-    let tS = posS.t;
-    let cumL = 0;
-    let dist = 0;
-    let curve = curveS;
-    let ps;
-    let dLeft = d;
-    while (true) {
-        ps = curve.ps;
-        dist = length([tS,1], ps);
-        cumL += dist;
+//     const posS = cpNode.cp.pointOnShape;
+//     const curveS = posS.curve;
 
-        if (cumL < d) {
-            tS = 0;
-            dLeft -= dist;
-            curve = curve.next;
-        } else {
-            break;
-        }
-    }
+//     let tS = posS.t;
+//     let cumL = 0;
+//     let dist = 0;
+//     let curve = curveS;
+//     let ps;
+//     let dLeft = d;
+//     while (true) {
+//         ps = curve.ps;
+//         dist = length([tS,1], ps);
+//         cumL += dist;
 
-    // const overshoot = cumL - d;
-    const lL = length([0,tS], curve.ps);
-    const l = lL + dLeft;
+//         if (cumL < d) {
+//             tS = 0;
+//             dLeft -= dist;
+//             curve = curve.next;
+//         } else {
+//             break;
+//         }
+//     }
 
-    const t = getTAtLength(curve.ps, l);
+//     // const overshoot = cumL - d;
+//     const lL = length([0,tS], curve.ps);
+//     const l = lL + dLeft;
 
-    const posE = createPos(curve, t);
+//     const t = getTAtLength(curve.ps, l);
 
-    return posE;
-}
+//     const posE: PrePointOnShape = { curve, t ;
 
+//     return posE;
+// }
 
 
-export { addDistanceFrom }
-
-
-// TESTING
 
+// export { addDistanceFrom }

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

@@ -1,3 +1,4 @@
+import { Mutable } from "../../utils/mutable.js";
 import type { CpNode } from "../cp-node.js";
 
 
@@ -26,7 +27,7 @@ function clone(
         cpNode: CpNode): CpNode {
 
     // Don't change this function to be recursive, the call stack may 
-    // overflow if there are too many CpNodes.
+    // overflow if there are too many `CpNode`s.
 
     const nodeMap: Map<CpNode, CpNodeWithoutEdges> = new Map();
 
@@ -49,7 +50,7 @@ function clone(
                 nodeMap.set(node, node_);
                 cpStack.push({ cpNode: node, newCpNode: node_ });
             }
-            (newCpNode as CpNode)[edge] = node_ as CpNode;
+            (newCpNode as Mutable<CpNode>)[edge] = node_ as CpNode;
         }
     }
 
@@ -58,7 +59,7 @@ function clone(
 
 
 function cloneWithoutEdges(cpNode: CpNode) {
-    const newNode = {
+    const cpNode_ = {
         ...cpNode,
         ...{
             prev: undefined,
@@ -69,7 +70,7 @@ function cloneWithoutEdges(cpNode: CpNode) {
         }
     };
 
-    return newNode;
+    return cpNode_;
 }
 
 

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

@@ -1,5 +1,5 @@
 import type { CpNode } from "../cp-node.js";
-import { compareCps } from "../../contact-point/contact-point.js";
+import { comparePoss } from "../../point-on-shape/compare-poss.js";
 
 
 /**
@@ -12,7 +12,7 @@ function cpNodeComparator(
         a: CpNode,
         b: CpNode) {
 
-    return compareCps(a.cp, b.cp);
+    return comparePoss(a.pointOnShape, b.pointOnShape);
 }
 
 

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

@@ -12,15 +12,15 @@ import { isTerminating } from "./is-terminating.js";
  * @param cpNode 
  */
 function enhanceCpNode(cpNode: CpNode) {
-    const cp = cpNode.cp;
-    const pos = cp.pointOnShape;
+    // const cp = cpNode.cp;
+    const pos = cpNode.pointOnShape;
     const curve = pos.curve;
 
     return {
         ...cpNode,
-        pos: cpNode.cp.pointOnShape,
-        p: cpNode.cp.pointOnShape.p,
-        t: cpNode.cp.pointOnShape.t,
+        pos,//: cpNode.cp.pointOnShape,
+        p: pos.p,
+        t: pos.t,
         isTerminating: isTerminating(cpNode),
         isFullyTerminating: isFullyTerminating(cpNode),
         isSharp: isSharp(cpNode),