flo-mat 3.0.1 → 3.0.2

package/src/mat/get-largest-3-prong.ts

@@ -0,0 +1,21 @@
+import { CpNode } from '../cp-node/cp-node.js';
+import { getAllOnLoop } from '../cp-node/fs/get-all-on-loop.js';
+import { getRealProngCount } from '../cp-node/fs/get-real-prong-count.js';
+
+
+/** @internal */
+function getLargest3Prong(cpNode: CpNode) {
+	const cpNodes = getAllOnLoop(cpNode)
+		.filter(cpNode => getRealProngCount(cpNode) >= 3);
+
+	if (cpNodes.length === 0) { return undefined; }
+
+	return cpNodes.reduce(function(maxCpNode: CpNode, cpNode: CpNode) {
+		return maxCpNode.cp.circle.radius >= cpNode.cp.circle.radius
+			? maxCpNode
+			: cpNode
+	}, cpNodes[0]);
+}
+
+
+export { getLargest3Prong }

package/src/mat/get-largest-vertex.ts

@@ -1,8 +1,11 @@
 import { CpNode } from '../cp-node/cp-node.js';
+import { getAllOnLoop } from '../cp-node/fs/get-all-on-loop.js';
 
 
 /** @internal */
-function getLargestVertex(cpNodes: CpNode[]) {
+function getLargestVertex(cpNode: CpNode) {
+	const cpNodes = getAllOnLoop(cpNode);
+
 	return cpNodes.reduce(function(maxCpNode: CpNode, cpNode: CpNode) {
 		return maxCpNode.cp.circle.radius >= cpNode.cp.circle.radius
 			? maxCpNode

package/src/mat/mat-meta.ts

@@ -0,0 +1,31 @@
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { Loop } from 'flo-boolean';
+import { CpNode } from '../cp-node/cp-node.js';
+import { Curve } from '../curve/curve.js';
+import { TriMap } from '../utils/tri-map.js';
+
+
+interface MatMeta {
+    readonly maxCoordinate: number;
+    readonly squaredDiagonalLength: number;
+    readonly looseBoundingBoxes: number[][][];
+    readonly tightBoundingBoxes: number[][][];
+    readonly boundingHulls: number[][][];
+
+    readonly sharpCorners: Curve[];
+    readonly dullCorners: Curve[];
+
+    readonly loops: Loop[];
+    
+    /** 
+     * Primarily for internal use. A tree structure storing the
+     * [[CpNode]]s of the MAT by their compare order, i.e. their cyclic order
+     * around the shape boundary.
+     */
+    readonly cpTrees: Map<Loop, LlRbTree<CpNode>>;
+    /** A map from a bezier and t value to a `PointOnShape` */
+    readonly pointToCpNode: TriMap<Loop,number,number,CpNode>;
+}
+
+
+export { MatMeta }

package/src/mat/mat.ts

@@ -1,6 +1,5 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
 import { CpNode } from '../cp-node/cp-node.js';
-import { Loop } from 'flo-boolean';
+import { MatMeta } from './mat-meta.js';
 
 
 /**
@@ -14,12 +13,13 @@ import { Loop } from 'flo-boolean';
 interface Mat {
     /** A complete representation of the MAT. See [[CpNode]]. */
     cpNode: CpNode;
-    /** 
-     * Primarily for internal use. A tree structure storing the
-     * [[CpNode]]s of the MAT by their compare order, i.e. their cyclic order
-     * around the shape boundary. 
+    /**
+     * Stores additional info about the shape that could be useful for various
+     * purposes in post-processing.
+     * 
+     * Most meta items have a CpNode property to link back to the MAT.
      */
-    cpTrees: Map<Loop, LlRbTree<CpNode>>;
+    meta: MatMeta;
 }
 
 

package/src/mat/simplify-mat.ts

@@ -1,11 +1,20 @@
-import { hausdorffDistance } from 'flo-bezier3';
-import { CpNode, getCpNodesOnCircle, isTerminating, removeCpNode } from '../cp-node/cp-node.js';
+import { hausdorffDistanceOneSided } from 'flo-bezier3';
+import { CpNode } from '../cp-node/cp-node.js';
+import { removeVertex } from '../vertex/remove-vertex.js';
 import { getBranches } from './get-branches.js';
-import { getCurveToNext } from '../cp-node/get-curve-to-next.js';
-import { getCurveBetween } from '../get-curve/get-curve-between.js';
+import { getMatCurveToNext } from '../cp-node/fs/get-mat-curve-to-next.js';
+import { getMatCurveBetween } from '../cp-node/fs/get-mat-curve-between.js';
 import { Mat } from './mat.js';
+import { createNewCpTree } from './create-new-cp-tree.js';
+import { clone } from '../cp-node/fs/clone.js';
+import { findFirst } from '../cp-node/fs/find-first.js';
+import { isTerminating } from '../cp-node/fs/is-terminating.js';
+import { isVertex } from '../cp-node/fs/is-vertex.js';
+import { getProngCount } from '../cp-node/fs/get-prong-count.js';
 
 
+
+// TODO2 could be made faster by binary "search" on hausdorff curves
 /**
  * Simplifies the given MAT by replacing the piecewise quad beziers composing 
  * the MAT with fewer ones to within a given tolerance.
@@ -13,24 +22,23 @@ import { Mat } from './mat.js';
  * @param anlgeTolerance Tolerance given as the degrees difference of the unit 
  * direction vectors at the interface between curves. A tolerance of zero means
  * perfect smoothness is required - defaults to 15.
-  * @param hausdorffTolerance The approximate maximum Hausdorff Distance tolerance -
+ * @param hausdorffTolerance The approximate maximum Hausdorff Distance tolerance -
  * defaults to `2**-3`
  * @param maxIterations The max iterations, defaults to `50`
  */
 function simplifyMat(
         mat: Mat,
-        anlgeTolerance = 15,
         hausdorffTolerance = 2**-3,
         maxIterations = 50): Mat {
 
-    let cpNode = mat.cpNode;
-    
+    let cpNode = clone(mat.cpNode);
+
     // Start from a leaf
     while (!isTerminating(cpNode)) { cpNode = cpNode.next; }
 
-    const branches = getBranches(cpNode, anlgeTolerance);
+    const branches = getBranches(cpNode);
 
-    const canDeletes: CpNode[] = [];
+    const canDeletes: Set<CpNode> = new Set();
     for (let k=0; k<branches.length; k++) {
         const branch = branches[k];
 
@@ -48,29 +56,37 @@ function simplifyMat(
                 if (hd > hausdorffTolerance) {
                     break;
                 } else {
-                    canDeletes.push(branch[j]);
+                    canDeletes.add(branch[j]);
                 }
             }
 
             if (i+1 === j) { 
                 // no simplification occured
-                break;
+                continue;
             }
         }
     }
 
+    cpNode = findFirst(cpNode_ => isTerminating(cpNode_) ? cpNode_ : undefined, cpNode)!;
+
     for (const cpNode of canDeletes) {
-        const isTerminating_ = isTerminating(cpNode);
-        const onCircleCount = getCpNodesOnCircle(cpNode).length;
-        if (isTerminating_ || onCircleCount !== 2) { 
-            continue; 
+        if (!isVertex(cpNode =>
+                (getProngCount(cpNode) !== 2) &&
+                !cpNode.isHoleClosing
+            )(cpNode)) {
+
+            removeVertex(cpNode, mat.meta.cpTrees);
         }
+    }
+
 
-        removeCpNode(cpNode);
+    return {
+        cpNode,
+        meta: {
+            ...mat.meta,
+            cpTrees: createNewCpTree(cpNode)
+        }
     }
-    
-    //return { cpNode, cpTrees: createNewCpTree(cpNode) }; 
-    return { cpNode, cpTrees: undefined! }; 
 }
 
 
@@ -81,10 +97,10 @@ function getTotalHausdorffDistance(
         hausdorffSpacing: number) {
 
     const hds: number[] = [];
-    const longCurve = getCurveBetween(branch[i], branch[j].next);
+    const longCurve = getMatCurveBetween(branch[i], branch[j].next);
     for (; i<j+1; i++) {
-        hds.push(hausdorffDistance(
-            getCurveToNext(branch[i]),
+        hds.push(hausdorffDistanceOneSided(
+            getMatCurveToNext(branch[i]),
             longCurve,
             hausdorffSpacing
         ));

package/src/mat/trim-mat.ts

@@ -1,7 +1,7 @@
 import { Mat } from './mat.js';
 import { createNewCpTree } from './create-new-cp-tree.js';
 import { cullNonCycles } from '../sat/cull-non-cycles.js';
-import { clone } from '../cp-node/clone.js';
+import { clone } from '../cp-node/fs/clone.js';
 
 
 /**
@@ -14,7 +14,13 @@ function trimMat(mat: Mat): Mat {
 
     if (!cpNode) { return undefined!; }
 
-    return { cpNode, cpTrees: createNewCpTree(cpNode) };
+    return {
+        cpNode,
+        meta: {
+            ...mat.meta,
+            cpTrees: createNewCpTree(cpNode)
+        }
+    }
 }
 
 

package/src/memoize-primitive.ts

@@ -0,0 +1,31 @@
+
+
+/**
+ * Memoize (by reference on the input parameter) the given arity 1 function.
+ * 
+ * * also works with primitive keys
+ * * keys will *never* be garbage collected (even if they're not
+ * primitive); this may or may not be ok, depending on the use case
+ * * will also work with `object`s but since this will hold a reference and
+ * prevent garbage collection, rather use `memoize` instead
+ */
+function memoizePrimitive<T, U>(f: (a: T) => U): (a: T) => U {
+	const results = new Map<T,U>();
+	
+	return function(a: T): U {
+		let result = results.get(a);
+		if (result !== undefined) {
+			//console.log('cache hit');
+			return result; 
+		}
+
+		//console.log('cache miss');
+		result = f(a);
+		results.set(a, result);
+		
+		return result;
+	}
+}
+
+
+export { memoizePrimitive }

package/src/point-on-shape/calc-pos-order.ts

@@ -2,7 +2,6 @@ import { dot, fromTo, rotateNeg90Degrees, toUnitVector } from "flo-vector2d";
 import { Circle } from "../geometry/circle.js";
 import { PointOnShape } from "./point-on-shape.js";
 import { isPosCorner } from './is-pos-corner.js';
-import { isPosDullCorner } from "./is-pos-dull-corner.js";
 import { getPosCorner } from './get-pos-corner.js';
 
 
@@ -21,7 +20,7 @@ function calcPosOrder(
         pos: PointOnShape): number {
 
     if (!isPosCorner(pos)) { return 0; }
-    if (!isPosDullCorner(pos)) { return 0; }
+    if (!getPosCorner(pos).isDull) { return 0; }
 
     const corner = getPosCorner(pos);
 

package/src/point-on-shape/create-pos.ts

@@ -6,14 +6,13 @@ import { PointOnShape } from "./point-on-shape.js"
 function createPos(
         curve: Curve,
         t: number,
-        source: boolean): PointOnShape {
+        isSource?: boolean): PointOnShape {
 
     return {
         curve,
         t,
         p: evalDeCasteljauDd(curve.ps, [0,t]).map(c => c[1]),
-        // angle
-        source
+        isSource: isSource === undefined ? false : isSource
     }
 }
 

package/src/point-on-shape/get-osculating-circle.ts

@@ -6,13 +6,16 @@ import { PointOnShape } from './point-on-shape.js';
 
 /**
  * Returns the osculating circle at this point of the curve.
- * @param maxOsculatingCircleRadius If not Number.POSITIVE_INFINITY then the
+ * 
+ * @param minCurvature If not Number.POSITIVE_INFINITY then the
  * circle radius will be limited to this value.
  * @param pos The [[PointOnShape]] identifying the point.
+ * @param useMaxRadius
  */
 function getOsculatingCircle(
         minCurvature: number, 
         pos: PointOnShape,
+        // pos: { p: number[], t: number },
         useMaxRadius = false): Circle {
 
     const ps = pos.curve.ps;

package/src/point-on-shape/get-pos-corner.ts

@@ -1,16 +1,20 @@
-import { getCornerAtEnd } from "../curve/curve.js";
+import { memoize } from "flo-memoize";
 import { Corner } from "../corner/corner.js";
+import { getCorner } from "../corner/get-corner.js";
 import { PointOnShape } from "./point-on-shape.js";
 
 
 /**
  * @internal
  */
-function getPosCorner(pos: PointOnShape): Corner {
-    return getCornerAtEnd(
-        pos.t === 1 ? pos.curve : pos.curve.prev
-    );
-}
+// const getPosCorner$ = memoize(
+    function getPosCorner(pos: PointOnShape): Corner {
+        return getCorner(
+            pos.t === 1 ? pos.curve.ps : pos.curve.prev.ps,
+            pos.t === 1 ? pos.curve.next.ps : pos.curve.ps,
+        );
+    }
+// );
 
 
 export { getPosCorner }

package/src/point-on-shape/is-pos-dull-corner.ts

@@ -6,11 +6,13 @@ import { PointOnShape } from "./point-on-shape.js";
 /**
  * @internal
  */
-const isPosDullCorner = memoize((pos: PointOnShape) => {
-    if (!isPosCorner(pos)) { return false; }
+// const isPosDullCorner = memoize(
+    function isPosDullCorner(pos: PointOnShape) {
+        if (!isPosCorner(pos)) { return false; }
 
-    return getPosCorner(pos).isDull;
-});
+        return getPosCorner(pos).isDull;
+    }
+// );
 
 
 export { isPosDullCorner }

package/src/point-on-shape/point-on-shape.ts

@@ -8,7 +8,7 @@ interface PointOnShape {
     t: number;
     p: number[];
     /** just for debugging */
-    source: boolean;  
+    isSource?: boolean;
 }
 
 

package/src/sat/add-debug-info.ts

@@ -1,7 +1,6 @@
 declare const _debug_: Debug; 
 
 import { Debug } from '../debug/debug.js';
-import { Mat } from '../mat/mat.js';
 
 
 /**
@@ -9,13 +8,10 @@ import { Mat } from '../mat/mat.js';
  * @param sat 
  */
 function addDebugInfo(
-		sat: Mat,
 		timingStart: number) {
 
 	if (typeof _debug_ === 'undefined') { return; }
 
-	_debug_.generated.elems.sat.push(sat);
-
 	const timing = _debug_.generated.timing;
 	timing.sats = performance.now() - timingStart;
 }

package/src/sat/cull-by-salience.ts

@@ -0,0 +1,115 @@
+import { CpNode } from "../cp-node/cp-node.js";
+import { clone } from "../cp-node/fs/clone.js";
+import { getAllOnCircle } from "../cp-node/fs/get-all-on-circle.js";
+import { getAllOnLoop } from "../cp-node/fs/get-all-on-loop.js";
+import { getNonTerminatingOnCircle } from "../cp-node/fs/get-non-terminating-on-circle.js";
+import { getProngCount } from "../cp-node/fs/get-prong-count.js";
+import { getSalience } from "../cp-node/fs/get-salience.js";
+import { traverseAllForward } from "../cp-node/fs/traverse-all-forward.js";
+import { createNewCpTree } from "../mat/create-new-cp-tree.js";
+import { getLargest3Prong } from "../mat/get-largest-3-prong.js";
+import { Mat } from "../mat/mat.js";
+
+
+function cullBySalience(
+        minSalience: number,
+        mat: Mat) {
+
+    // get largest 3-prong
+    const cpNode = getLargest3Prong(clone(mat.cpNode));
+    if (cpNode === undefined) {
+        return mat;
+    }
+
+    // get all 3-prongs (even if having terminal prongs)
+    const cpNodesOnThreeProngs = new Set(
+        getAllOnLoop(cpNode)
+        .filter(cpNode => getProngCount(cpNode) > 2)
+    );
+
+
+    // add culls according to salience
+    const culls: Set<CpNode> = new Set();
+    for (const cpNode of cpNodesOnThreeProngs) {
+        const cpNodesOC = getNonTerminatingOnCircle(cpNode);
+        for (const cpNodeOC of cpNodesOC) {
+            const salience = getSalience(cpNodeOC)
+            if (salience < minSalience) {
+                culls.add(cpNodeOC);
+            }
+        }
+    }
+
+
+    // Get all 3-prongs that have been culled, including those on culled
+    // branches.
+    const culled3ProngCpNodes: Set<CpNode> = new Set();
+    for (const cull of culls) {
+        // cull branch and return all 3-prong cp-nodes on the culled branch
+        const culled3ProngsToAdd = cullBranch(cull);
+        for (const cpNode of culled3ProngsToAdd) {
+            culled3ProngCpNodes.add(cpNode);
+        }
+    }
+
+    // Find 3-prong not culled and assign to `cpNodeT`
+    let cpNodeT: CpNode | undefined = undefined;
+    for (const cpNode of cpNodesOnThreeProngs) {
+        if (!culled3ProngCpNodes.has(cpNode)) {
+            cpNodeT = cpNode;
+            break;
+        }
+    }
+
+    // Special case: only one completely terminating 3-prong survives
+    if (cpNodeT === undefined) {
+        // Return the largest 3-prong with all branches snipped
+        cpNodeT = cpNode;
+        for (const b of getAllOnCircle(cpNode)) {
+            b.next = b.nextOnCircle;
+            b.prev = b.prevOnCircle;
+        }
+    }
+
+    const sat: Mat = {
+        cpNode: cpNodeT,
+        meta: {
+            ...mat.meta,
+			cpTrees: createNewCpTree(cpNodeT)
+        }
+    };
+
+    return sat;
+}
+
+
+/**
+ * Cull branch and return all 3-prong cp-nodes on the culled branch
+ */ 
+function cullBranch(
+        cpNode: CpNode): Set<CpNode> {
+
+    const cull = cpNode;
+    const culledCpNodes = new Set<CpNode>();
+
+    culledCpNodes.add(cull);
+    traverseAllForward(cull, cpNode_ => {
+        if (getProngCount(cpNode_) >= 3 &&
+            cpNode_ !== cull) {
+
+            for (const cpN of getAllOnCircle(cpNode_)) {
+                culledCpNodes.add(cpN);
+            }
+        }
+    });
+
+    const cpNodeNOC = cull.nextOnCircle;
+
+    cull.next = cpNodeNOC;
+    cpNodeNOC.prev = cull;
+
+    return culledCpNodes;
+}
+
+
+export { cullBySalience }

package/src/sat/cull-non-cycles.ts

@@ -1,5 +1,8 @@
 import { getLeaves } from './get-leaves.js';
-import { CpNode, getProngCount, isOnSameCircle, isTerminating } from '../cp-node/cp-node.js';
+import { CpNode } from '../cp-node/cp-node.js';
+import { CpNodeFs } from '../cp-node/cp-node-fs.js';
+
+const { getProngCount, isOnSameCircle, isTerminating } = CpNodeFs;
 
 
 /**
@@ -32,7 +35,6 @@ function cullNonCycles(cpStart: CpNode) {
                 //const cp2 = cp1.prevOnCircle;
                 const cp2 = cpNode.nextOnCircle;
 
-                //if (cpStart === cpNode || cpStart === cp1 || cpStart === cp2) {
                 if (isOnSameCircle(cpNode, cpStart)) {
                     cut = true; // We are at the max disk - cut whole edge
                 } else if (cpNode.next === cp2) {

package/src/sat/cull.ts

@@ -1,6 +1,34 @@
 import { Circle } from '../geometry/circle.js';
 import { getLeaves } from './get-leaves.js';
-import { CpNode, isOnSameCircle } from '../cp-node/cp-node.js';
+import { CpNode } from '../cp-node/cp-node.js';
+import { CpNodeFs } from '../cp-node/cp-node-fs.js';
+import { isTerminating } from '../cp-node/fs/is-terminating.js';
+import { DualSet, DualSetFs } from '../utils/dual-set.js';
+
+const { isOnSameCircle } = CpNodeFs;
+
+
+/**
+ * 
+ * @param cpStart 
+ */
+function getNonTrivialForwardEdges(cpStart: CpNode) {
+    let cpNode = cpStart;
+    let cpEnd = cpStart.prevOnCircle;
+    while (isTerminating(cpEnd)) {
+        cpEnd = cpEnd.prevOnCircle;
+    }
+    
+    const cps: CpNode[] = [];
+    do {
+        if (!isTerminating(cpNode)) {
+            cps.push(cpNode);
+        }
+        cpNode = cpNode.nextOnCircle;
+    } while (cpNode !== cpEnd)
+
+    return cps;
+}
 
 
 /**
@@ -12,63 +40,55 @@ import { CpNode, isOnSameCircle } from '../cp-node/cp-node.js';
  * @param maxCpNode The start CpNode which must reprsesent the maximal vertex.
  */
 function cull(
-        culls: Set<Circle>, 
+        culls: DualSet<number, number>,
         maxCpNode: CpNode) {
 
     const leaves = getLeaves(maxCpNode);
 
-    function getNonTrivialEdges(cpStart: CpNode) {
-		let cp = cpStart;
-		
-        const cps: CpNode[] = [];
-		do {
-            if (cp.next !== cp.nextOnCircle) {
-                cps.push(cp);
-            }
-			cp = cp.nextOnCircle;
-		} while (cp !== cpStart.prevOnCircle)
-
-		return cps;
-    }
-
     while (leaves.length) {
         const leaf = leaves.pop()!;
 
-        // Preserve topology.
-        if (leaf.isHoleClosing || leaf.isIntersection) { continue; }
+        const { center: c } = leaf.cp.circle;
+        if (!DualSetFs.has(culls, c[0], c[1]) ||
+            // Preserve topology.
+            leaf.isIntersection) {
 
-        if (!culls.has(leaf.cp.circle)) {
             continue;
         }
 
-        let cpNode = leaf.next; // Turn around
-
-        while (true) {
+        let cpNode = leaf.prevOnCircle; // Turn around
+        let cut = false;
+        while (!cut) {
             cpNode = cpNode.next;
-            let cut = false;
-            const cp1 = cpNode.prevOnCircle;
 
-            if (!culls.has(cpNode.cp.circle)) {
+            const { center: c } = cpNode.cp.circle;
+            if (!DualSetFs.has(culls, c[0], c[1])) {
                 // Cut off the edge once a non-cull has been reached.
+                while (isTerminating(cpNode.prevOnCircle)) {
+                    cpNode = cpNode.prevOnCircle;
+                }
                 cut = true;
             } else if (isOnSameCircle(cpNode, maxCpNode)) {
                 cut = true; // We are at the max disk - cut whole edge
             } else {
-                const cps = getNonTrivialEdges(cpNode);
+                const cps = getNonTrivialForwardEdges(cpNode);
 
                 if (cps.length === 1) { 
-                    cpNode = cps[0];
+                    continue;
                 } else {
                     cut = true;
                 }
-            } 
-
-            if (cut) {
-                cp1.next = cpNode;
-                cpNode.prev = cp1;
-                break;
             }
         }
+
+        if (cut) {
+            const cp1 = cpNode.prevOnCircle;
+            cp1.next = cpNode;
+            cpNode.prev = cp1;
+
+            cp1.nextOnCircle = cpNode;
+            cpNode.prevOnCircle = cp1;
+        }
     }
 }
 

package/src/sat/get-leaves.ts

@@ -1,4 +1,9 @@
-import { CpNode, getAllOnLoop, isTerminating } from '../cp-node/cp-node.js';
+import { CpNode } from '../cp-node/cp-node.js';
+import { CpNodeFs } from '../cp-node/cp-node-fs.js';
+import { isFullyTerminating } from '../cp-node/fs/is-fully-terminating.js';
+import { getRealProngCount } from '../cp-node/fs/get-real-prong-count.js';
+
+const { getAllOnLoop } = CpNodeFs;
 
 
 /** @internal */
@@ -7,7 +12,7 @@ function getLeaves(cpNode: CpNode) {
 
     const cps = getAllOnLoop(cpNode);
     for (const cp of cps) {
-        if (isTerminating(cp)) { 
+        if (isFullyTerminating(cp) && !cp.isHoleClosing) { 
             leaves.push(cp);
         }
     }