flo-mat 3.0.15 → 4.0.1

package/src/closest-boundary-point/cull-by-loose-bounding-box.ts

@@ -1,40 +1,41 @@
-import { allRoots, deflate } from 'flo-poly';
-import { CurvePiece } from '../mat/curve-piece.js';
+import type { CurvePiece } from '../mat/curve-piece.js';
 import { getClosestSquareDistanceToRect } from '../geometry/get-closest-square-distance-to-rect.js';
 import { getBoundingBox$ } from '../geometry/get-bounding-box-.js';
 
 
 /**
- * @internal
  * When checking distances, ignore all those with closest possible distance 
  * further than 'bestSquaredDistance', i.e. cull them.
+ * 
  * @param curvePieces 
- * @param p 
- * @param dSquared 
+ * @param xO 
+ * @param xy2 
+ * 
+ * @internal
  */
 function cullByLooseBoundingBox(
         curvePieces: CurvePiece[],
-        p: number[],
-        dSquared: number) {
+        xO: number[],
+        xy2: number) {
 
-    const candidateCurvePieces = [];
+    const curvePieces_ = [];
 
     for (let i=0; i<curvePieces.length; i++) {
         const curvePiece = curvePieces[i];
-        const ps = curvePiece.curve.ps;
+        const { ps } = curvePiece.curve;
         
         const boundingBox = getBoundingBox$(ps);
         
         const d = getClosestSquareDistanceToRect(
             boundingBox,
-            p
+            xO
         );
-        if (d <= dSquared) {
-            candidateCurvePieces.push(curvePiece);
-        } 
+        if (d <= xy2) {
+            curvePieces_.push(curvePiece);
+        }
     }
 
-    return candidateCurvePieces;
+    return curvePieces_;
 }
 
 

package/src/closest-boundary-point/cull-by-tight-boundary-box.ts

@@ -4,7 +4,7 @@ import { CurvePiece } from "../mat/curve-piece.js";
 import { getClosestSquaredDistanceToRotatedRect } from '../geometry/get-closest-squared-distance-to-rotated-rect.js';
 
 
-const getBoundingBoxTight_ = memoize(getBoundingBoxTight);
+const getBoundingBoxTight$ = memoize(getBoundingBoxTight);
 
 
 /**
@@ -26,7 +26,7 @@ function cullByTightBoundingBox(
         const curvePiece = curvePieces[i];
         const ps = curvePiece.curve.ps;
         
-        const tightBoundingBox = getBoundingBoxTight_(ps);
+        const tightBoundingBox = getBoundingBoxTight$(ps);
         const d = getClosestSquaredDistanceToRotatedRect(
                 tightBoundingBox,
                 p

package/src/closest-boundary-point/foot-and-endpoint-info.ts

@@ -1,15 +1,13 @@
-// import { RootInterval } from "flo-poly";
-import { Curve } from "flo-boolean";
+import type { Curve } from "flo-boolean";
 
 
-type FootAndEndpointInfo = {
-    curve: Curve;
-    p: number[];
-    t: number;
-    d: number;
-    box: number[][];
-    // ri: RootInterval;
-    dSquaredI: number[];
+interface FootAndEndpointInfo {
+    readonly curve: Curve;
+    readonly p: number[];
+    readonly t: number;
+    readonly d: number;
+    readonly box: number[][];
+    readonly dSquaredI: number[];
 }
 
 

package/src/closest-boundary-point/get-best-distance-squared.ts

@@ -1,38 +1,41 @@
+import type { CurvePiece } from "../mat/curve-piece.js";
 import { evalDeCasteljau } from 'flo-bezier3';
 import { squaredDistanceBetween } from 'flo-vector2d';
-import { CurvePiece } from "../mat/curve-piece.js";
+
+const { min } = Math;
+
+
+const TOLERANCE = 1 + 2**-20;
 
 
 /**
- * @internal
  * Finds an initial distance such that the closest point can not be further than 
  * this distance away.
+ * 
+ * @internal
  */ 
 function getBestDistanceSquared(
         curvePieces: CurvePiece[], 
-        p: number[]) {
+        xO: number[]) {
 
-    let bestSquaredDistance = Number.POSITIVE_INFINITY;
+    let bestSquaredDistance = Infinity;
     for (let i=0; i<curvePieces.length; i++) {
         const curvePiece = curvePieces[i];
 
-        const ps = curvePiece.curve.ps;
+        const { curve: { ps }, ts } = curvePiece;
         
-        const p1 = evalDeCasteljau(ps, curvePiece.ts[0]);
-        const p2 = evalDeCasteljau(ps, curvePiece.ts[1]);
+        const p1 = evalDeCasteljau(ps, ts[0]);
+        const p2 = evalDeCasteljau(ps, ts[1]);
         
-        const d = Math.min(
-            squaredDistanceBetween(p, p1),
-            squaredDistanceBetween(p, p2)
+        bestSquaredDistance = min(
+            bestSquaredDistance,
+            squaredDistanceBetween(xO, p1),
+            squaredDistanceBetween(xO, p2)
         ); 
-        
-        if (d < bestSquaredDistance) {
-            bestSquaredDistance = d;  
-        }
     }
 
     // The extra multiplier is to account for floating point precision.
-    return (1 + 2**-10)*bestSquaredDistance;
+    return TOLERANCE*bestSquaredDistance;
 }
 
 

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

@@ -1,58 +1,46 @@
-import type { Curve } from 'flo-boolean';
 import type { CurvePiece  } from '../mat/curve-piece.js';
 import type { FootAndEndpointInfo } from './foot-and-endpoint-info.js';
-import type { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { createPos } from '../point-on-shape/create-pos.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 { 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,122 +1,49 @@
 import type { Curve } from "flo-boolean";
 import type { FootAndEndpointInfo } from './foot-and-endpoint-info.js';
-import { allRootsCertified } from 'flo-poly';
-import { eDeflate } from 'flo-poly';
+import { createRootExact, roots } from 'flo-poly';
 import { getFootPointsOnBezierPolysCertified, getIntervalBox } from 'flo-bezier3';
-import { ddDeflateWithRunningError } from './dd-deflate-with-running-error.js';
-import { γγ } from '../error-analysis/gamma.js';
 import { rootIntervalToDistanceSquaredInterval } from './root-interval-to-distance-squared-interval.js';
 import { getPFromBox } from './get-p-from-box.js';
 
-
-const γγ3 = γγ(3);
-
 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({ t: 0, tS: 0, tE: 0, multiplicity: 1 }); }
-    } else if (tS === 1) {
-        if (!dontPush1) { ris.push({ t: 1, tS: 1, tE: 1, multiplicity: 1 }); }
-    } else {
-        ris.push({ t: tS, tS: tS, tE: tS, multiplicity: 1 });
-    }
-
-    if (tE === 0) {
-        if (!dontPush0) { ris.push({ t: 0, tS: 0, tE: 0, multiplicity: 1 }); }
-    } else if (tE === 1) {
-        if (!dontPush1) { ris.push({ t: 1, tS: 1, tE: 1, multiplicity: 1 }); }
-    } else {
-        ris.push({ t: tE, 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';
 
 
 /**
@@ -51,39 +52,40 @@ import { ContactPoint } from '../contact-point/contact-point.js';
  */
 interface CpNode {
     /** For debugging / easy identification only */
-    id: number;
+    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;
+    readonly holeCloserTwin?: CpNode | undefined;
 }
 
 

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

@@ -3,7 +3,6 @@
 //------------------------------
 
 // import { getTAtLength, length } from "flo-bezier3";
-// import { createPos } from "../../point-on-shape/create-pos.js";
 // import { CpNode } from "../cp-node.js";
 
 
@@ -40,7 +39,7 @@
 
 //     const t = getTAtLength(curve.ps, l);
 
-//     const posE = createPos(curve, t);
+//     const posE: PrePointOnShape = { curve, t ;
 
 //     return posE;
 // }