flo-mat 3.0.15 → 4.0.1

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

@@ -1,30 +1,30 @@
-import { CpNode } from "../cp-node/cp-node.js";
-import { MatMeta } from "../mat/mat-meta.js";
-import { PointOnShape } from "../point-on-shape/point-on-shape.js";
-import { add2Prong } from "./add-2-prong.js";
-import { find2Prong } from "./find-2-prong.js";
+// import type { CpNode } from "../cp-node/cp-node.js";
+// import type { MatMeta } from "../mat/mat-meta.js";
+// import type { PrePointOnShape } from "../point-on-shape/point-on-shape.js";
+// import { add2Prong } from "./add-2-prong.js";
+// import { find2Prong } from "./find-2-prong.js";
 
 
-/**
- * Just to simplify `find2Prong` a bit.
- * 
- * * Cannot be used with holeClosers or angles other than 0
- * * Can be used after the mat has been found
- */
-function findAndAdd2Prong(
-        meta: MatMeta,
-        y: PointOnShape): CpNode | undefined {
+// /**
+//  * Just to simplify `find2Prong` a bit.
+//  * 
+//  * * Cannot be used with holeClosers or angles other than 0
+//  * * Can be used after the mat has been found
+//  */
+// function findAndAdd2Prong(
+//         meta: MatMeta,
+//         y: PrePointOnShape): CpNode | undefined {
 
-    const twoProngInfo = find2Prong(meta, false, false, 0, y);
-    if (twoProngInfo === undefined) {
-        return undefined;
-    }
+//     const twoProngInfo = find2Prong(meta, false, false, 0, y);
+//     if (twoProngInfo === undefined) {
+//         return undefined;
+//     }
 
-    const { circle, zs } = twoProngInfo;
-    const cpNode = add2Prong(meta, circle, [y, ...zs], false);
+//     const { circle, z } = twoProngInfo;
+//     const cpNode = add2Prong(meta, circle, y, z, false);
 
-    return cpNode;
-}
+//     return cpNode;
+// }
 
 
-export { findAndAdd2Prong }
+// export { findAndAdd2Prong }

package/src/find-2-prong/find-and-add-2-prongs-on-all-loops.ts

@@ -1,9 +1,7 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { Loop } from 'flo-boolean';
-import { CpNode } from '../cp-node/cp-node.js';
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
+import type { MatMeta } from '../mat/mat-meta.js';
 import { findAndAdd2Prongs } from './find-and-add-2-prongs.js';
-import { MatMeta } from '../mat/mat-meta.js';
 
 
 /** 
@@ -18,7 +16,7 @@ import { MatMeta } from '../mat/mat-meta.js';
 function findAndAdd2ProngsOnAllLoops(
         meta: MatMeta,
         angleIncrement: number,
-        for2Prongss: PointOnShape[][],
+        for2Prongss: PrePointOnShape[][],
         for1Prongs: boolean) {
 
     let cpNode: CpNode | undefined;

package/src/find-2-prong/find-and-add-2-prongs.ts

@@ -1,12 +1,12 @@
 /** @internal */
 declare const _debug_: Debug;
 
-import { Debug } from '../debug/debug.js';
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import type { Debug } from '../debug/debug.js';
+import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
+import type { MatMeta } from '../mat/mat-meta.js';
 import { find2Prong } from './find-2-prong.js';
 import { add2Prong } from './add-2-prong.js';
 import { rotateNeg90Degrees } from 'flo-vector2d';
-import { MatMeta } from '../mat/mat-meta.js';
 import { getCorner } from '../corner/get-corner.js';
 
 
@@ -15,50 +15,38 @@ const { PI, atan2 } = Math;
 
 
 /**
- * @internal
  * Find and add two-prongs.
  * @param meta 
  * @param angleIncrement 
  * @param for2Prongs 
  * @param for1Prong
+ * 
+ * @internal
  */
 function findAndAdd2Prongs(
         meta: MatMeta,
         angleIncrement: number,
-        for2Prongs: PointOnShape[],
+        for2Prongs: PrePointOnShape[],
         for1Prong: boolean) {
 
     let cpNode_;
 
+    const find2Prong_ = find2Prong(meta);
+
     const angleIncrement_ = angleIncrement*PI/180;
     for (let i=0; i<for2Prongs.length; i++) {
-        const angles = [0];
         const pos = for2Prongs[i];
-        if (pos.t === 1) {
-            const { curve } = pos;
-            const corner = getCorner(curve.ps, curve.next.ps);
-            if (corner.isQuiteDull) {
-                const tangentI = rotateNeg90Degrees(corner.tangents[0]);
-                const tangentO = rotateNeg90Degrees(corner.tangents[1]);
-                // const tangentI = corner.tangents[0];
-                // const tangentO = corner.tangents[1];
-                const a1 = (atan2(tangentI[1], tangentI[0]) + 2*PI)%(2*PI);
-                const a2 = (atan2(tangentO[1], tangentO[0]) + 2*PI)%(2*PI);
-                const a3 = ((a2 - a1) + 2*PI)%(2*PI);
-                let angle = angleIncrement_;
-                while (angle <= a3 - (angleIncrement_/2)) {
-                    angles.push(angle);
-                    angle += angleIncrement_;
-                }
-            }
-        }
-        for (let angle of angles) {
-            const twoProngInfo = find2Prong(
-                meta, false, for1Prong, angle, pos
+
+        const angles = getValidAngles(angleIncrement_, pos);
+
+        for (const angle of angles) {
+            const twoProngInfo = find2Prong_(
+                false, for1Prong, angle, pos
             );
+
             if (twoProngInfo) {
-                const { circle, zs } = twoProngInfo;
-                const cpNode = add2Prong(meta, circle, [pos, ...zs], false);
+                const { circle, z } = twoProngInfo;
+                const cpNode = add2Prong(meta, circle, pos, z, false);
                 cpNode_ = cpNode_ || cpNode;
             }
 
@@ -72,4 +60,31 @@ function findAndAdd2Prongs(
 }
 
 
+function getValidAngles(
+        angleIncrement_: number,
+        ppos: PrePointOnShape) {
+
+    const angles = [0];
+    if (ppos.t === 1) {
+        const { curve } = ppos;
+        const corner = getCorner(curve.ps, curve.next.ps);
+        if (corner.isQuiteDull) {
+            const tangentI = rotateNeg90Degrees(corner.tangents[0]);
+            const tangentO = rotateNeg90Degrees(corner.tangents[1]);
+
+            const a1 = (atan2(tangentI[1], tangentI[0]) + 2*PI)%(2*PI);
+            const a2 = (atan2(tangentO[1], tangentO[0]) + 2*PI)%(2*PI);
+            const a3 = ((a2 - a1) + 2*PI)%(2*PI);
+            let angle = angleIncrement_;
+            while (angle <= a3 - (angleIncrement_/2)) {
+                angles.push(angle);
+                angle += angleIncrement_;
+            }
+        }
+    }
+
+    return angles;
+}
+
+
 export { findAndAdd2Prongs }

package/src/find-2-prong/find-and-add-hole-closing-2-prongs.ts

@@ -1,18 +1,16 @@
-import { CpNode } from '../cp-node/cp-node.js';
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { MatMeta } from '../mat/mat-meta.js';
 import { getMinYPos } from '../svg/get-min-y-pos.js';
 import { find2Prong } from './find-2-prong.js';
 import { add2Prong } from './add-2-prong.js';
-import { MatMeta } from '../mat/mat-meta.js';
 
 
 /**
+ * Find and add two-prongs that close any holes in the shape.
+ * 
+ * @param meta
+ * 
  * @internal
- * Find and add two-prongs that remove any holes in the shape.
- * @param loops The loops (that as a precondition must be ordered from 
- * highest (i.e. smallest y-value) topmost point loops to lowest)
- * @param cpTrees
- * @param maxCoordinate The maximum coordinate value used to calculate floating point
- * tolerances.
  */
 function findAndAddHoleClosing2Prongs(
         meta: MatMeta) {
@@ -24,23 +22,25 @@ function findAndAddHoleClosing2Prongs(
 
     let cpNode: CpNode | undefined;
 
+    const find2Prong_ = find2Prong(meta);
+
     // We start at 1 since 0 is the outer (root) loop
     for (let k=1; k<minYs.length; k++) {
-        const posSource = minYs[k];
+        const pposSource = minYs[k];
         
-        const holeClosingTwoProng = find2Prong(
-            meta, true, false, 0, posSource
+        const posAntipode = find2Prong_(
+            true, false, 0, pposSource
         );
 
-        if (!holeClosingTwoProng) { 
+        if (!posAntipode) { 
             throw new Error(`Unable to find hole-closing 2-prong`);
         } 
 
-        // TODO important - handle case of n-prong, i.e. more than one antipode
+        // FUTURE - handle case of n-prong, i.e. more than one antipode
         // - currently we only handle case of single antipode (the general case)
-        const { circle, zs: posAntipodes } = holeClosingTwoProng;
+        const { circle, z } = posAntipode;
 
-        const _cpNode = add2Prong(meta, circle, [posSource, posAntipodes[0]], true);
+        const _cpNode = add2Prong(meta, circle, pposSource, z, true);
 
         cpNode = cpNode === undefined ? _cpNode : cpNode;
     }

package/src/find-2-prong/get-initial-bezier-pieces.ts

@@ -1,15 +1,12 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { Loop } from 'flo-boolean';
+import type { Loop } from 'flo-boolean';
+import type { CurvePiece  } from '../mat/curve-piece.js';
+import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
+import type { MatMeta } from '../mat/mat-meta.js';
 import { getCpNodeToLeftOrSame } from '../mat/get-cp-node-to-left-or-same.js';
 import { getBoundaryPieceBeziers } from '../mat/get-boundary-piece-beziers.js';
-import { CurvePiece  } from '../mat/curve-piece.js';
-import { CpNode } from '../cp-node/cp-node.js';
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
 import { calcPosOrder } from '../point-on-shape/calc-pos-order.js';
-import { Circle } from '../geometry/circle.js';
 import { isPosCorner } from '../point-on-shape/is-pos-corner.js';
-import { getPosCorner } from '../point-on-shape/get-pos-corner.js';
-import { MatMeta } from '../index.js';
+import { getPosCorner$ } from '../point-on-shape/get-pos-corner.js';
 
 
 /** @internal */
@@ -18,10 +15,9 @@ function getInitialCurvePieces(
         isHoleClosing: boolean,
         loop: Loop,
         loops: Loop[],
-        // cpTrees: Map<Loop,LlRbTree<CpNode>>,
         meta: MatMeta,
-        y: PointOnShape,
-        circle: Circle): CurvePiece[] {
+        yPos: PrePointOnShape,
+        xO: number[]): CurvePiece[] {
 
     const { cpTrees } = meta;
 
@@ -29,25 +25,26 @@ function getInitialCurvePieces(
         return loops
         .filter(_loop => _loop !== loop)
         .flatMap(loop => loop.curves
-            .map(curve => ({ curve, ts: [0,1] })));
+            .map(curve => ({ curve, ts: [0,1] }))
+        );
     }
 
-    const order = isPosCorner(y) && getPosCorner(y).isDull
-        ? y.t === 1 && angle === 0
-            ? -1 
-            : y.t === 0
-            ? +1
-            : calcPosOrder(circle, y)
-        : 0;
+    const order =
+        isPosCorner(yPos) && getPosCorner$(yPos).isDull
+            ? yPos.t === 1 && angle === 0
+                ? -1 
+                : yPos.t === 0
+                ? +1
+                : calcPosOrder(xO, yPos)
+            : 0;
 
-    const cpNode = getCpNodeToLeftOrSame(cpTrees.get(loop)!, y, order, 0);
+    const cpNode = getCpNodeToLeftOrSame(cpTrees.get(loop)!, yPos, order, 0);
     if (!cpNode || 
         // The special case if there is only a single sharp corner or 
         // two-way terminating 2-prong currently in the MAT. Don't remove!
-        (cpNode === cpNode.next.next) 
-    ) {
-        return loop.curves
-        .map(curve => ({ curve, ts: [0,1] }));
+        (cpNode === cpNode.next.next)) {
+
+        return loop.curves.map(curve => ({ curve, ts: [0,1] }));
     }
 
     return getBoundaryPieceBeziers([cpNode, cpNode]);

package/src/find-2-prong/get-initial-x.ts

@@ -0,0 +1,52 @@
+import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
+import { getOsculatingCircle } from '../point-on-shape/get-osculating-circle.js';
+
+const { sqrt } = Math;
+
+
+/**
+ * 
+ * @param angle
+ * @param isHoleClosing `true` if this is a hole-closing two-prong, `false` otherwise
+ * @param maxOscRadius the maximum that the osculating circle radius can be
+ * @param yPos the source point of the 2-prong to be found
+ * 
+ * @internal
+*/
+function getInitialX(
+        angle: number,
+        isHoleClosing: boolean,
+        maxOscRadius: number,
+        yPos: PrePointOnShape,
+        nnorm: number[]): [number[],number] {
+
+    let xO: number[];
+    let rO: number;
+
+    const { p: y } = yPos;
+
+    if (isHoleClosing) {
+        return [
+            [y[0], y[1] - maxOscRadius],  // xO
+            maxOscRadius                  // rO
+        ];
+    }
+
+    if (angle === 0) {
+        return getOsculatingCircle(maxOscRadius, yPos, nnorm);
+    }
+     
+    const { p } = yPos;
+    const [tx, ty] = nnorm;
+    const l = sqrt(tx*tx + ty*ty);
+    const scale = maxOscRadius/l;
+
+    const v = [tx*scale, ty*scale];
+    xO = [p[0] + v[0], p[1] + v[1]];
+    rO = maxOscRadius;
+
+    return [xO,rO];
+}
+
+
+export { getInitialX }

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

@@ -0,0 +1,12 @@
+import type { Curve } from "flo-boolean";
+
+
+interface AntipodalPoint {
+    readonly curve: Curve;
+    readonly s: number;
+    readonly d: number;
+    readonly x: number[];
+}
+
+
+export type { AntipodalPoint }

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

@@ -0,0 +1,63 @@
+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 { getClosestPoint } from './get-closest-points.js';
+
+
+/**
+ * Returns the closest boundary point to the given point, limited to the given 
+ * bezier pieces, including the beziers actually checked after culling.
+ * 
+ * @param maxCoordPowerOf2
+ * @param nnorm
+ * @param yPos
+ * @param for1Prong defaults to `false`;
+ * @param angle angle from normal
+ * @param curvePieces
+ * 
+ * @internal
+ */
+function getAntipodalPoints(
+        maxCoordPowerOf2: number,
+        nnorm: number[], 
+        yPos: PrePointOnShape,
+        for1Prong: boolean,
+        angle: number,
+        curvePieces: CurvePiece[]): AntipodalPoint[] {
+
+    const pInfoss: AntipodalPoint[] = [];
+    for (let i=0; i<curvePieces.length; i++) {
+        const curvePiece = curvePieces[i];
+
+        const pInfos = getClosestPoint(
+            maxCoordPowerOf2, nnorm, yPos, for1Prong, angle,
+            curvePiece
+        );
+
+        pInfoss.push(...pInfos);
+    }
+
+
+    /** the minimum max value */
+    let minMax = Infinity;
+    for (let i=0; i<pInfoss.length; i++) {
+        const diMax = pInfoss[i].d*(1 + 2**-46);
+        if (diMax < minMax) {
+            minMax = diMax;
+        }
+    }
+
+    const antipodalPoints: AntipodalPoint[] = [];
+    for (let i=0; i<pInfoss.length; i++) {
+        const info = pInfoss[i];
+        const d = info.d*(1 - 2**-46);
+        if (d <= minMax) {
+            antipodalPoints.push(info);
+        }
+    }
+
+    return antipodalPoints;
+}
+
+
+export { getAntipodalPoints }

package/src/find-2-prong/get-medial/get-closest-points.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, deflate, Horner } from 'flo-poly';
+import { evalDeCasteljau, getMedialPointCoeffs, getMedialPointCoeffsBez0 } 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[], 
+        yPos: PrePointOnShape,
+        for1Prong: boolean,
+        angle: number,
+        curvePiece: CurvePiece): AntipodalPoint[] {
+
+    const { curve, ts: [tS,tE] } = curvePiece;
+    const { ps } = curve;
+    const { curve: touchedCurve, t, p: y } = yPos;
+
+    const shouldDeflate = angle === 0 && curve === touchedCurve;
+
+    const infos: AntipodalPoint[] = [];
+    // let onePushed = false;
+    let startPushed = false;
+    let endPushed = false;
+
+    let ss: RootInterval[];
+    if (tS !== tE) {
+        const { A, B, C, D, H } = getMedialPointCoeffs(y, nnorm, ps);
+
+        const def = shouldDeflate ? deflate(H, t!) : undefined;
+        
+        const def2 = for1Prong && shouldDeflate
+            ? deflate(def!, t!)
+            : undefined;
+
+        const def3 = for1Prong && shouldDeflate
+            ? deflate(def2!, t!)
+            : undefined;
+        
+        const pDd = def3 ?? def ?? H;
+        
+        ss = roots(pDd, 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
+
+            const s = _s < 0 ? 0 : _s > 1 ? 1 : _s;  // clip to [0,1]
+
+            //-----------------------
+            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; }
+
+            const w = _AS > _CS
+                ? -BS / AS
+                : -DS / CS;  // alternative
+
+            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 }