flo-mat 4.0.2 → 4.1.0

package/src/cp-node/fs/get-mat-curve-between.ts

@@ -1,6 +1,6 @@
 import type { CpNode } from '../cp-node.js';
 import { 
-    fromTo, dot, cross, rotate90Degrees, interpolate, translate,
+    fromTo as fromToVec, dot, cross, rotate90Degrees, interpolate, translate,
     lineLineIntersection
 } from 'flo-vector2d';
 import { getEdgeDirection } from './get-edge-direction.js';
@@ -32,14 +32,14 @@ function getMatCurveBetween(
 
     const mid = lineLineIntersection(fromL, toL);
 
-    const c = fromTo(fromCc,toCc);
+    const c = fromToVec(fromCc,toCc);
 
     let twisted: boolean;
     if (!mid) {
         twisted = true;
     } else {
-        const a = fromTo(fromCc, mid);
-        const b = fromTo(toCc,   mid);
+        const a = fromToVec(fromCc, mid);
+        const b = fromToVec(toCc,   mid);
         
         twisted = dot(a,c) < 0 || dot(b,c) > 0;
     }
@@ -49,8 +49,8 @@ function getMatCurveBetween(
     } 
         
     const r = rotate90Degrees(c);
-    const w1 = fromTo(fromL[0], fromL[1]); // This is a unit vector
-    const w2 = fromTo(toL[0],  toL[1]);  // This is a unit vector
+    const w1 = fromToVec(fromL[0], fromL[1]); // This is a unit vector
+    const w2 = fromToVec(toL[0],  toL[1]);  // This is a unit vector
 
     const d1 = abs(cross(c, w1)) / (3*3); 
     const d2 = abs(cross(c, w2)) / (3*3); 

package/src/cp-node/fs/is-fully-terminating.ts

@@ -1,6 +1,7 @@
 import type { CpNode } from "../cp-node.js";
 import { getAllOnCircle } from "./get-all-on-circle.js";
 import { isTerminating } from "./is-terminating.js";
+import { isTrivial } from "./is-trivial.js";
 
 
 /**
@@ -8,6 +9,21 @@ import { isTerminating } from "./is-terminating.js";
  * (except this.prevOnCircle) is terminating.
  */
 function isFullyTerminating(cpNode: CpNode) {
+    // const otherOnCircle = getAllOnCircle(cpNode.prevOnCircle, true);
+
+    // return otherOnCircle.every(isTerminating);
+    if (!isTerminating(cpNode)) {
+        return false;
+    }
+
+    if (isTrivial(cpNode)) {
+        return true;
+    }
+
+    while (cpNode.prev === cpNode.prevOnCircle) {
+        cpNode = cpNode.prev;
+    }
+
     const otherOnCircle = getAllOnCircle(cpNode.prevOnCircle, true);
 
     return otherOnCircle.every(isTerminating);

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/debug/debug.ts

@@ -1,54 +1,31 @@
-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 { drawElemFs } from './functions/draw-elem/draw-elem.js';
-
 
 /** @internal */
 interface Debug {
     /** Generated by debug object for later inspection */
-    generated: Generated;
+    elems: {};
+    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;
-}
-
-
-/** @internal */
-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;
+    fs: {};
+    directives: Directives;
 }
 
 
 /** @internal */
-interface IDebugFunctions extends IGeneralDebugFunctions {
-    drawElem   : DrawElemFunctions,
+interface Timing {
+    holeClosers: number;
+    oneAnd2Prongs: number;
+    threeProngs: number;
+    sats: number;
+    simplifyMat: number;
 }
 
 
 /** @internal */
-interface IDirectives {
+interface Directives {
     stopAfterHoleClosers: boolean,
     stopAfterHoleClosersNum: number,
     stopAfterTwoProngs: boolean,
@@ -68,59 +45,23 @@ function enableDebugForMat(debugOn: boolean) {
 
     debug = { 
         ...debug, 
-        generated: { 
-            //...debug?.generated,
-            ...(!debug ? {} : !debug.generated ? {} : debug.generated),
-            // @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,
-            }
+        elems: { 
+            ...debug?.elems
+        },
+        timing: {
+            ...debug?.timing,
+            holeClosers: 0,
+            oneAnd2Prongs: 0,
+            threeProngs: 0,
+            sats: 0,
+            simplifyMat: 0
         },
         fs: {
-            //...debug?.fs,
-            ...(!debug ? {} : !debug.fs ? {} : debug.fs),
-            // @ts-ignore
-            drawElem: {
-                //...debug?.fs?.drawElem,
-                ...(!debug ? {} : !debug.fs ? {} : !debug.fs.drawElem ? {} : debug.fs.drawElem),
-                ...drawElemFs
-            },
-            ...generalDebugFunctions
+            ...debug?.fs
         },
         directives: {
             //...debug?.directives,
-            ...(!debug ? {} : !debug.directives ? {} : debug.directives),
+            ...debug?.directives,
             stopAfterHoleClosers: false,
             stopAfterHoleClosersNum: undefined!,
             stopAfterTwoProngs: false,
@@ -134,7 +75,6 @@ function enableDebugForMat(debugOn: boolean) {
 }
 
 
-export { 
-    Debug, GeneratedElems, ITiming, Generated,
-    IDebugFunctions, IDirectives, enableDebugForMat
-}
+export type { Debug, Timing, Directives }
+export { enableDebugForMat }
+

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

@@ -15,7 +15,7 @@ import { ddNormal } from 'flo-bezier3';
 import { rotate } from 'flo-vector2d';
 
 
-const { sin, cos, max, sqrt } = Math;
+const { abs, sin, cos, max, sqrt } = Math;
 
 
 /**
@@ -60,6 +60,7 @@ function find2Prong(
             angle: number,
             yPos: PrePointOnShape): { circle: Circle, z: PrePointOnShape } | undefined {
 
+
         const { curve: { loop, ps }, t, p: y } = yPos;
         const normDd = ddNormal(ps, t);
         const _nnorm = [-normDd[0][1], -normDd[1][1]];  // Left-handed system (sorry)
@@ -67,6 +68,10 @@ function find2Prong(
             ? [0, -maxOsculatingCircleRadius]
             : (angle !== 0 ? rotate(sin(angle), cos(angle))(_nnorm) : _nnorm);
 
+        const nnormDd = isHoleClosing || angle !== 0
+            ? [[0, nnorm[0]], [0, nnorm[1]]]
+            : [[-normDd[0][0], -normDd[0][1]], [-normDd[1][0], -normDd[1][1]]];
+
         // Get initial kissing circle guess
         let [xO,rO] = getInitialX(
             angle, isHoleClosing, maxOsculatingCircleRadius, yPos, nnorm
@@ -80,7 +85,7 @@ function find2Prong(
         );
 
         // The lines below is an optimization.
-        const xy2 = reduceRadius(maxCoordPowerOf2, curvePieces, y, nnorm);
+        const xy2 = reduceRadius(maxCoordPowerOf2, rO, curvePieces, y, nnorm);
         const xy = sqrt(xy2);
 
         const l = sqrt(nnorm[0]**2 + nnorm[1]**2);
@@ -89,17 +94,24 @@ function find2Prong(
         cullCurvePieces(curvePieces, xO, xy2);
 
         const antipodalPoints = getAntipodalPoints(
-            maxCoordPowerOf2, nnorm, yPos,
+            maxCoordPowerOf2, nnorm, nnormDd, yPos,
             for1Prong, angle,
             curvePieces
         );
 
+        // FUTURE - if antipodalPoints.length > 1 let's just add an n-prong;
         if (antipodalPoints.length !== 1) {
-            if (antipodalPoints.length === 0) { return undefined; }
-            if (!areAllAntipodesSame(antipodalPoints)) {
+            if (antipodalPoints.length === 0) {
+                if (isHoleClosing) {
+                    console.log(yPos)
+                }
+                return undefined;
+            }
+            if (!isHoleClosing && !areAllAntipodesSame(antipodalPoints, maxCoordPowerOf2)) {
                 // At this point there is multiple antipodal points (zs) for the given
                 // source point so do not add the 2-prong, it will be caught when 
                 // adding 3+-prongs.
+
                 return undefined;
             }
         }
@@ -111,9 +123,12 @@ function find2Prong(
             return undefined;
         }
 
+        const pDd = toP(curve.ps, s);
+        const p = pDd.map(c => c[0] + c[1]);
+
         const z: PrePointOnShape = {
             curve, t: s, isSource: false,
-            p: toP(curve.ps, s)
+            p, pDd
         };
 
         const circle = { center: x, radius: d };
@@ -122,7 +137,9 @@ function find2Prong(
         const xz = squaredDistanceBetweenDd(x, z.p);
 
         if (!isHoleClosing) {
-            if (yz === 0) { return undefined; }
+            if (yz === 0) {
+                return undefined;
+            }
 
             // The lines below eliminate cases where the found 2-prong is too
             // close to a one-prong
@@ -142,13 +159,19 @@ function find2Prong(
 
 /** @internal */
 function areAllAntipodesSame(
-        app: AntipodalPoint[]): boolean {
-
-    const { curve, s: t } = app[0];
-    for (let i=1; i<app.length; i++) {
-        const { curve: curve_, s: t_ } = app[i];
-
-        if (curve !== curve_ || t !== t_) {
+        point: AntipodalPoint[],
+        maxCoordPowerOf2: number): boolean {
+
+    const { curve, s: t, x } = point[0];
+    const tol = 2**(maxCoordPowerOf2 - 40);
+    for (let i=1; i<point.length; i++) {
+        // const { curve: curve_, s: t_ } = point[i];
+        // if (curve !== curve_ || t !== t_) {
+        //     return false;
+        // }
+
+        const { x: x_ } = point[i];
+        if (abs(x[0] - x_[0]) > tol || abs(x[0] - x_[0]) > tol) {
             return false;
         }
     }

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

@@ -19,7 +19,8 @@ import { getClosestPoint } from './get-closest-points.js';
  */
 function getAntipodalPoints(
         maxCoordPowerOf2: number,
-        nnorm: number[], 
+        nnorm: number[],
+        nnormDd: number[][],
         yPos: PrePointOnShape,
         for1Prong: boolean,
         angle: number,
@@ -30,7 +31,7 @@ function getAntipodalPoints(
         const curvePiece = curvePieces[i];
 
         const pInfos = getClosestPoint(
-            maxCoordPowerOf2, nnorm, yPos, for1Prong, angle,
+            maxCoordPowerOf2, nnorm, nnormDd, yPos, for1Prong, angle,
             curvePiece
         );
 

package/src/find-2-prong/get-medial/get-closest-points-d.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, Horner } from 'flo-poly';
+import { evalDeCasteljau, getMedialPointCoeffs, getMedialPointCoeffsBez0, getMedialPointCoeffsBez2_SameCurve, getMedialPointCoeffsBez3_SameCurve } 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[], 
+        nnormDd: 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, pDd: yDd } = yPos;
+
+    const isTouched = curve === touchedCurve;
+    const shouldDeflate = angle === 0 && isTouched;
+
+    const infos: AntipodalPoint[] = [];
+    let startPushed = false;
+    let endPushed = false;
+
+    let ss: RootInterval[];
+    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);
+        
+        ss = roots(H, 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
+            if (sS < 0) { continue; }  // outside curve piece
+
+            // clip to [0,1]
+            const s = sE > 1 ? 1 : _s;
+
+            //-----------------------
+            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; }
+            if (max(_AS) < 2**-40) { continue; }
+
+            // const w = _AS > _CS
+            //     ? -BS / AS
+            //     : -DS / CS;  // alternative
+            const w = -BS / AS;
+
+            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 }