flo-mat 3.0.9 → 3.0.11

package/src/index.ts

@@ -1,8 +1,8 @@
 
-export { loopFromBeziers, beziersToSvgPathStr, getPathsFromStr } from 'flo-boolean';	
+export { loopFromBeziers, beziersToSvgPathStr, getPathsFromStr } from 'flo-boolean';
 
 export type { MatMeta } from './mat/mat-meta.js';
-export type { Loop } from 'flo-boolean';	
+export type { Loop } from 'flo-boolean';    
 export type { Mat } from './mat/mat.js';
 export type { Curve } from './curve/curve.js';
 export type { CpNode  } from './cp-node/cp-node.js';
@@ -39,7 +39,6 @@ export { sweepLine } from './sweep-line/sweep-line.js';
 export { getClosestSquareDistanceToRect } from './geometry/get-closest-square-distance-to-rect.js';
 export { connectHoleClosers } from './mat/connect-hole-closers.js';
 export { findAndAdd2Prong } from './find-2-prong/find-and-add-2-prong.js';
-export { getBoundaryBeziersToNext } from './cp-node/fs/get-boundary-beziers-to-next.js';
 export { getImpliedBoundaryBezierBetween } from './cp-node/fs/get-implied-boundary-bezier-between.js';
 export { getSatCulls } from './sat/get-sat-culls.js';
 export { getGraph } from './floyd-warshall/get-graph.js';
@@ -50,4 +49,42 @@ export { getFor2ProngsOnLoop } from './find-mat/get-for-2-prongs-on-loop.js';
 export { getPotentialClosestPointsOnCurveCertified } from './closest-boundary-point/get-potential-closest-points-on-curve-certified.js';
 export { getCloseBoundaryPointsCertified } from './closest-boundary-point/get-close-boundary-points-certified.js';
 export { getPartialMeta, getPointToCpNode } from './find-mat/get-meta.js';
-export { findAndAddHoleClosing2Prongs } from './find-2-prong/find-and-add-hole-closing-2-prongs.js';
+export { findAndAddHoleClosing2Prongs } from './find-2-prong/find-and-add-hole-closing-2-prongs.js';
+
+
+// CpNodeFs functions
+export { getChildren } from './cp-node/fs/get-children.js';
+export { getVertexForwardChildren } from './cp-node/fs/get-vertex-forward-children.js';
+export { getAllOnLoop } from './cp-node/fs/get-all-on-loop.js';
+export { getAllOnCircle } from './cp-node/fs/get-all-on-circle.js';
+export { isOnSameCircle } from './cp-node/fs/is-on-same-circle.js';
+export { isTerminating } from './cp-node/fs/is-terminating.js';
+export { isFullyTerminating } from './cp-node/fs/is-fully-terminating.js';
+export { getFirstExit } from './cp-node/fs/get-first-exit.js';
+export { isSharp } from './cp-node/fs/is-sharp.js';
+export { isOneProng } from './cp-node/fs/is-one-prong.js';
+export { getProngCount } from './cp-node/fs/get-prong-count.js';
+export { getRealProngCount } from './cp-node/fs/get-real-prong-count.js';
+export { cpNodeComparator } from './cp-node/fs/cp-node-comparator.js';
+export { enhanceCpNode } from './cp-node/fs/enhance-cp-node.js';
+export { traverseCp } from './cp-node/fs/traverse-cp.js';
+export { traverseEdges } from './cp-node/fs/traverse-edges.js';
+export { traverseVertices } from './cp-node/fs/traverse-vertices.js';
+export { clone } from './cp-node/fs/clone.js';
+export { getBoundaryBezierPartsToNext } from './cp-node/fs/get-boundary-bezier-parts-to-next.js';
+export { getBoundaryBeziersToNext } from './cp-node/fs/get-boundary-beziers-to-next.js';
+export { removeVertex } from './vertex/remove-vertex.js';
+export { getMatCurveToNext } from './cp-node/fs/get-mat-curve-to-next.js';
+export { isTwoProng } from './cp-node/fs/is-two-prong.js';
+export { getBranch } from './cp-node/fs/get-branch.js';
+export { getBranchBeziers } from './cp-node/fs/get-branch-beziers.js';
+export { getSalience } from './cp-node/fs/get-salience.js';
+export { getMatCurveBetween } from './cp-node/fs/get-mat-curve-between.js';
+export { getEdgeDirection } from './cp-node/fs/get-edge-direction.js';
+export { getBoundaryBeziersBetween } from './cp-node/fs/get-boundary-beziers-between.js';
+export { getMatCurvesBetween } from './cp-node/fs/get-mat-curves-between.js';
+export { getHoleClosers } from './cp-node/fs/get-hole-closers.js';
+export { getSpeed } from './cp-node/fs/get-speed.js';
+export { getSmoothedSpeed$ } from './cp-node/fs/get-smoothed-speed.js';
+export { getInitialDegAngleBetweenMatCurves } from './cp-node/fs/get-angle-between-mat-curves.js';
+export { getAllVertices } from './cp-node/fs/get-all-vertices.js';

package/src/mat/cmp-cp-on-delta.ts

@@ -45,7 +45,7 @@ function cmpCpOnδ(
     } 
 
     if (cmpPrev === 0 || cmpNext === 0) {
-        console.log('2-PRONG orders are equal.');	
+        console.log('2-PRONG orders are equal.');    
         return 0;
     }
 

package/src/mat/create-new-cp-tree.ts

@@ -11,21 +11,21 @@ const { cpNodeComparator, getAllOnLoop } = CpNodeFs;
  * @param cpNode 
  */
 function createNewCpTree(cpNode: CpNode) {
-	const newCpTrees: Map<Loop,LlRbTree<CpNode>> = new Map();
+    const newCpTrees: Map<Loop,LlRbTree<CpNode>> = new Map();
 
-	getAllOnLoop(cpNode).forEach(createNewCpTree_);
+    getAllOnLoop(cpNode).forEach(createNewCpTree_);
 
-	function createNewCpTree_(cpNode: CpNode) {
-		const loop = cpNode.cp.pointOnShape.curve.loop;
-		let cpTree = newCpTrees.get(loop);
-		if (!cpTree) { 
-			cpTree = new LlRbTree(cpNodeComparator, false); 
-			newCpTrees.set(loop, cpTree);
-		}
-		cpTree.insert(cpNode);
-	}
+    function createNewCpTree_(cpNode: CpNode) {
+        const loop = cpNode.cp.pointOnShape.curve.loop;
+        let cpTree = newCpTrees.get(loop);
+        if (!cpTree) { 
+            cpTree = new LlRbTree(cpNodeComparator, false); 
+            newCpTrees.set(loop, cpTree);
+        }
+        cpTree.insert(cpNode);
+    }
 
-	return newCpTrees;
+    return newCpTrees;
 }
 
 

package/src/mat/get-boundary-piece-beziers.ts

@@ -17,7 +17,7 @@ function getBoundaryPieceBeziers(cpNodes: CpNode[]): CurvePiece[] {
     let cpThis = cpNodes[0]; 
     const cpEnd  = cpNodes[1];
     
-    const bezierPieces: CurvePiece[] = [];
+    const curvePieces: CurvePiece[] = [];
 
     // As opposed to going around the circle and taking the last exit
     let goStraight = true; 
@@ -41,17 +41,17 @@ function getBoundaryPieceBeziers(cpNodes: CpNode[]): CurvePiece[] {
         } else if (posNext.curve === posThis.curve &&
                    compareCps(cpThis.next.cp, cpThis.cp) > 0) {
                 
-            bezierPieces.push(
+            curvePieces.push(
                 { curve: posThis.curve, ts: [posThis.t, posNext.t] }
             );
         } else {
-            bezierPieces.push(
+            curvePieces.push(
                 { curve: posThis.curve, ts: [posThis.t, 1] }
             );
             
             if (posThis.curve.loop === posNext.curve.loop) {
                 addSkippedBeziers(
-                        bezierPieces, 
+                        curvePieces, 
                         posThis.curve, 
                         posNext.curve,
                         posNext.t
@@ -63,7 +63,7 @@ function getBoundaryPieceBeziers(cpNodes: CpNode[]): CurvePiece[] {
     } while (cpThis !== cpEnd);
 
 
-    return bezierPieces;
+    return curvePieces;
 }
 
 
@@ -72,7 +72,7 @@ function getBoundaryPieceBeziers(cpNodes: CpNode[]): CurvePiece[] {
  * Adds pieces of skipped beziers
  */
 function addSkippedBeziers(
-        bezierPieces: CurvePiece[], 
+        curvePieces: CurvePiece[], 
         curveStart: Curve, 
         curveEnd: Curve, 
         t1: number) {
@@ -81,7 +81,7 @@ function addSkippedBeziers(
     do {
         curveThis = curveThis.next;
         const tEnd = curveThis === curveEnd ? t1 : 1;
-        bezierPieces.push({ curve: curveThis, ts: [0, tEnd] });
+        curvePieces.push({ curve: curveThis, ts: [0, tEnd] });
     } while (curveThis !== curveEnd);
 }
 

package/src/mat/get-edges-as-array.ts

@@ -3,15 +3,15 @@
 
 
 // /** @internal */
-// function getEdgesAsArray(cpNode: CpNode) {	
-// 	const cpNodes: CpNode[] = [];
-	
-// 	traverseEdges(
-// 		cpNode, 
-// 		function(cpNode) { cpNodes.push(cpNode) }
-// 	);
-	
-// 	return cpNodes;
+// function getEdgesAsArray(cpNode: CpNode) {    
+//     const cpNodes: CpNode[] = [];
+    
+//     traverseEdges(
+//         cpNode, 
+//         function(cpNode) { cpNodes.push(cpNode) }
+//     );
+    
+//     return cpNodes;
 // }
 
 

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

@@ -5,16 +5,16 @@ 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);
+    const cpNodes = getAllOnLoop(cpNode)
+        .filter(cpNode => getRealProngCount(cpNode) >= 3);
 
-	if (cpNodes.length === 0) { return undefined; }
+    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]);
+    return cpNodes.reduce(function(maxCpNode: CpNode, cpNode: CpNode) {
+        return maxCpNode.cp.circle.radius >= cpNode.cp.circle.radius
+            ? maxCpNode
+            : cpNode
+    }, cpNodes[0]);
 }
 
 

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

@@ -3,11 +3,11 @@ import { CpNode } from '../cp-node/cp-node.js';
 
 /** @internal */
 function getLargestThreeProng(cpNodes: CpNode[]) {
-	return cpNodes.reduce(function(maxCpNode: CpNode, cpNode: CpNode) {
-		return cpNode === undefined || maxCpNode.cp.circle.radius >= cpNode.cp.circle.radius
-			? maxCpNode
-			: cpNode;
-	}, undefined!);
+    return cpNodes.reduce(function(maxCpNode: CpNode, cpNode: CpNode) {
+        return cpNode === undefined || maxCpNode.cp.circle.radius >= cpNode.cp.circle.radius
+            ? maxCpNode
+            : cpNode;
+    }, undefined!);
 }
 
 

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

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

package/src/mat/get-two-prong-type.ts

@@ -1,13 +1,13 @@
-import { TwoProngForDebugging } from '../debug/two-prong-for-debugging.js';
-import { ElemType_TwoProng } from './elem-type-two-prong.js';
+// import { TwoProngForDebugging } from '../debug/two-prong-for-debugging.js';
+// import { ElemType_TwoProng } from './elem-type-two-prong.js';
 
 
-/** @internal */
-function getTwoProngType(e: TwoProngForDebugging): ElemType_TwoProng {
-	if (e.holeClosing) { return 'twoProng_holeClosing' }
-	
-	return 'twoProng_regular';
-}
+// /** @internal */
+// function getTwoProngType(e: TwoProngForDebugging): ElemType_TwoProng {
+//     if (e.holeClosing) { return 'twoProng_holeClosing' }
+    
+//     return 'twoProng_regular';
+// }
 
 
-export { getTwoProngType }
+// export { getTwoProngType }

package/src/mat/trim-mat.ts

@@ -10,7 +10,7 @@ import { clone } from '../cp-node/fs/clone.js';
  * @param mat The MAT to trim.
  */
 function trimMat(mat: Mat): Mat {
-	const cpNode = cullNonCycles(clone(mat.cpNode));
+    const cpNode = cullNonCycles(clone(mat.cpNode));
 
     if (!cpNode) { return undefined!; }
 

package/src/memoize-primitive.ts

@@ -10,21 +10,21 @@
  * 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; 
-		}
+    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;
-	}
+        //console.log('cache miss');
+        result = f(a);
+        results.set(a, result);
+        
+        return result;
+    }
 }
 
 

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

@@ -8,12 +8,12 @@ import { Debug } from '../debug/debug.js';
  * @param sat 
  */
 function addDebugInfo(
-		timingStart: number) {
+        timingStart: number) {
 
-	if (typeof _debug_ === 'undefined') { return; }
+    if (typeof _debug_ === 'undefined') { return; }
 
-	const timing = _debug_.generated.timing;
-	timing.sats = performance.now() - timingStart;
+    const timing = _debug_.generated.timing;
+    timing.sats = performance.now() - timingStart;
 }
 
 

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

@@ -75,7 +75,7 @@ function cullBySalience(
         cpNode: cpNodeT,
         meta: {
             ...mat.meta,
-			cpTrees: createNewCpTree(cpNodeT)
+            cpTrees: createNewCpTree(cpNodeT)
         }
     };
 

package/src/sat/cull.ts

@@ -1,16 +1,17 @@
-import { Circle } from '../geometry/circle.js';
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { DualSet } from '../utils/dual-set.js';
 import { getLeaves } from './get-leaves.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';
+import { DualSetFs } from '../utils/dual-set.js';
 
 const { isOnSameCircle } = CpNodeFs;
 
 
 /**
+ * Returns the set of non-trivial forward edges starting from the given `CpNode`.
  * 
- * @param cpStart 
+ * @param cpStart the start `CpNode`
  */
 function getNonTrivialForwardEdges(cpStart: CpNode) {
     let cpNode = cpStart;
@@ -32,12 +33,14 @@ function getNonTrivialForwardEdges(cpStart: CpNode) {
 
 
 /**
- * @internal
  * Returns the set of Vertices passing the following test: walk the MAT tree and 
  * keep all Vertices not in the current cull set and any Vertices that have a 
  * non-culled node further down the line toward the tree leaves.
- * @param culls The CpNodes (referred to by circles) that should be culled.
- * @param maxCpNode The start CpNode which must reprsesent the maximal vertex.
+ * 
+ * @param culls the `CpNode`s (referred to by circles) that should be culled
+ * @param maxCpNode the start `CpNode` which must represent the maximal vertex
+ * 
+ * @internal
  */
 function cull(
         culls: DualSet<number, number>,

package/src/sat/get-leaves.ts

@@ -1,7 +1,6 @@
 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;
 

package/src/sat/to-scale-axis.ts

@@ -12,43 +12,44 @@ import { getSatCulls } from './get-sat-culls.js';
 
 
 /**
- * Apply and returns an enhanced version of the Scale Axis Transform (SAT) to 
- * the given MAT. The returned SAT is guaranteed to be a subset of the MAT and 
+ * Apply and returns an enhanced version of the Scale Axis Transform (SAT) to
+ * the given MAT. The returned SAT is guaranteed to be a subset of the MAT and
  * preserves topology at any scale.
  * 
  * Typically the MAT contains too many branches caused by minute details on the
  * boundary of the shape. The SAT is a simplification of the MAT that preserves
  * less detail the higher the applied scale factor. The severity at which noise
  * are removed depends on the local scale of the shape.
- * @param mat The Medial Axis Transform (`Mat`) on which to apply the SAT. 
- * @param s The scale factor >= 1 (e.g. 1.3)
+ * 
+ * @param mat the Medial Axis Transform (MAT) on which to apply the SAT
+ * @param s the scale factor >= 1 (e.g. 1.3)
  */
 function toScaleAxis(
-		mat: Mat, 
-		s: number): Mat {
+        mat: Mat,
+        s: number): Mat {
 
-	let timingStart = 0;
-	if (typeof _debug_ !== 'undefined') {
-		timingStart = performance.now();
-	}
+    let timingStart = 0;
+    if (typeof _debug_ !== 'undefined') {
+        timingStart = performance.now();
+    }
 
-	const cpNode = getLargestVertex(clone(mat.cpNode));
-	const culls = getSatCulls(cpNode, s);
+    const cpNode = getLargestVertex(clone(mat.cpNode));
+    const culls = getSatCulls(cpNode, s);
 
-	cull(culls, cpNode);
+    cull(culls, cpNode);
 
-	const sat: Mat = {
+    const sat: Mat = {
         cpNode: cpNode,
         meta: {
             ...mat.meta,
-			cpTrees: createNewCpTree(cpNode)
+            cpTrees: createNewCpTree(cpNode)
         }
     };
 
 
-	addDebugInfo(timingStart);
+    addDebugInfo(timingStart);
 
-	return sat;
+    return sat;
 }
 
 

package/src/svg/get-extreme.ts

@@ -9,14 +9,14 @@ import { getShapeBounds } from './get-shape-bounds.js';
  * @param loops 
  */
 function getExtreme(loops: Loop[]) {
-	const bounds = getShapeBounds(loops);
-	
-	return Math.max(  
-			Math.abs(bounds.minX.p[0]),
-			Math.abs(bounds.minY.p[1]),
-			Math.abs(bounds.maxX.p[0]),
-			Math.abs(bounds.maxY.p[1])
-	);
+    const bounds = getShapeBounds(loops);
+    
+    return Math.max(  
+            Math.abs(bounds.minX.p[0]),
+            Math.abs(bounds.minY.p[1]),
+            Math.abs(bounds.maxX.p[0]),
+            Math.abs(bounds.maxY.p[1])
+    );
 }