flo-mat 3.0.10 → 3.0.12

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

@@ -25,36 +25,36 @@ let ii = 0;
  * @internal
  */
 function findAndAdd3Prongs(
-		meta: MatMeta,
-		cpStart: CpNode) {
-
-	if (isPosSharpCorner(cpStart.cp.pointOnShape)) {
-		return { closeBysFor3Prong: undefined, addedCpNodes: [] };
-	}
-
-	const addedCpNodes: CpNode[][] = [];
-	let closeBysFor3Prong: CpNode[] | undefined = undefined;
-	do {
-		if (cpStart === undefined) { continue; }
-		const visitedCps = traverseCp(cpStart);
-	
-		if (visitedCps.length <= 2) { break; }
-
-		const { closeBysFor3Prong, cpNodes } = findAndAdd3Prong(meta, visitedCps);
-
-		addedCpNodes.push(cpNodes);
-		if (closeBysFor3Prong.length > 0) {
-			return { closeBysFor3Prong, addedCpNodes };
-		}
-
-		if (typeof _debug_ !== 'undefined') {
-			if (++ii === _debug_.directives.stopAfterThreeProngsNum) {
-				return undefined!;
-			}
-		}
-	} while (true);
-
-	return { closeBysFor3Prong, addedCpNodes };
+        meta: MatMeta,
+        cpStart: CpNode) {
+
+    if (isPosSharpCorner(cpStart.cp.pointOnShape)) {
+        return { closeBysFor3Prong: undefined, addedCpNodes: [] };
+    }
+
+    const addedCpNodes: CpNode[][] = [];
+    let closeBysFor3Prong: CpNode[] | undefined = undefined;
+    do {
+        if (cpStart === undefined) { continue; }
+        const visitedCps = traverseCp(cpStart);
+    
+        if (visitedCps.length <= 2) { break; }
+
+        const { closeBysFor3Prong, cpNodes } = findAndAdd3Prong(meta, visitedCps);
+
+        addedCpNodes.push(cpNodes);
+        if (closeBysFor3Prong.length > 0) {
+            return { closeBysFor3Prong, addedCpNodes };
+        }
+
+        if (typeof _debug_ !== 'undefined') {
+            if (++ii === _debug_.directives.stopAfterThreeProngsNum) {
+                return undefined!;
+            }
+        }
+    } while (true);
+
+    return { closeBysFor3Prong, addedCpNodes };
 }
 
 

package/src/find-mat/add-2-prongs-by-error.ts

@@ -62,7 +62,7 @@ function add2rongsByError(
         if (d > maxError) {
             maxError = d;
         }
-	}
+    }
 
     if (maxError > 0) {
         // console.log(maxError);

package/src/find-mat/find-mats.ts

@@ -33,49 +33,49 @@ import { defaultMatOptions, MatOptions } from './mat-options.js';
  * in [1,100].
  */
 function findMats(
-		bezierLoops: number[][][][],
-		options?: MatOptions): Mat[] {
-
-	// if (typeof _debug_ !== 'undefined') { var timingStart = performance.now(); }
-	const { maxCoordinate, maxRadius } = getLoopsMetrics(bezierLoops);
-
-	const options_: Required<MatOptions> = clipOptions(
-		maxCoordinate,
-		maxRadius, {
-		...defaultMatOptions,
-		...(options || {})
-	});
-
-	const {
-		applySat, simplify,
-		satScale, simplifyTolerance
-	} = options_;
-
-
-	const loopss = simplifyPaths(bezierLoops);
-	// console.log(loopsToSvgPathStr(bezierLoops));
-	// const loopss = [bezierLoops.map(loop => loopFromBeziers(loop,0))];
-	// console.log(loopsToSvgPathStr(bezierLoops.map(v => v.map(v => v.map(v => v.map(v => v*2**4))))));
-	// console.log(loopsToSvgPathStr(bezierLoops.map(v => v.map(v => v.map(v => [-v[0],v[1]])))));
-	// console.log(loopsToSvgPathStr(loopss[0].map(loop => loop.beziers)));
-
-	const mats: Mat[] = [];
-	for (const loops of loopss) {
-		let mat = findMat(loops, maxCoordinate, options_);
-		if (mat === undefined) { continue; }
-
-		if (applySat) {
-			mat = toScaleAxis(mat, satScale);
-		}
-
-		if (simplify) {
-			mat = simplifyMat(mat, simplifyTolerance, 50)
-		}
-
-		mats.push(mat);
-	}
-	
-	return mats;
+        bezierLoops: number[][][][],
+        options?: MatOptions): Mat[] {
+
+    // if (typeof _debug_ !== 'undefined') { var timingStart = performance.now(); }
+    const { maxCoordinate, maxRadius } = getLoopsMetrics(bezierLoops);
+
+    const options_: Required<MatOptions> = clipOptions(
+        maxCoordinate,
+        maxRadius, {
+        ...defaultMatOptions,
+        ...(options || {})
+    });
+
+    const {
+        applySat, simplify,
+        satScale, simplifyTolerance
+    } = options_;
+
+
+    const loopss = simplifyPaths(bezierLoops);
+    // console.log(loopsToSvgPathStr(bezierLoops));
+    // const loopss = [bezierLoops.map(loop => loopFromBeziers(loop,0))];
+    // console.log(loopsToSvgPathStr(bezierLoops.map(v => v.map(v => v.map(v => v.map(v => v*2**4))))));
+    // console.log(loopsToSvgPathStr(bezierLoops.map(v => v.map(v => v.map(v => [-v[0],v[1]])))));
+    // console.log(loopsToSvgPathStr(loopss[0].map(loop => loop.beziers)));
+
+    const mats: Mat[] = [];
+    for (const loops of loopss) {
+        let mat = findMat(loops, maxCoordinate, options_);
+        if (mat === undefined) { continue; }
+
+        if (applySat) {
+            mat = toScaleAxis(mat, satScale);
+        }
+
+        if (simplify) {
+            mat = simplifyMat(mat, simplifyTolerance, 50)
+        }
+
+        mats.push(mat);
+    }
+    
+    return mats;
 }
 
 
@@ -86,14 +86,14 @@ function findMats(
  * an array of control points.
  */
 function loopsToSvgPathStr(
-		loops: number[][][][]) {
+        loops: number[][][][]) {
 
-	let str = '';
-	for (const loop of loops) {
-		str = str + beziersToSvgPathStr(loop) + '\n';
-	}
+    let str = '';
+    for (const loop of loops) {
+        str = str + beziersToSvgPathStr(loop) + '\n';
+    }
 
-	return str;
+    return str;
 }
 
 

package/src/find-mat/fix-ordering.ts

@@ -59,10 +59,10 @@ function fixOrdering(
                 }
             }
         }
-	}
+    }
     */
 
-	// return cpNodes;
+    // return cpNodes;
 }
 
 

package/src/find-mat/get-total-by.ts

@@ -9,18 +9,18 @@ import type { Curve } from '../curve/curve.js';
  * @param totalByF
  */
 function getTotalBy(totalByF: (curve: Curve) => number) {
-	
-	return function(loop: Loop) {
-		let node = loop.curves[0];
-		let total = 0;
-		do {
-			total += totalByF(node);
-			
-			node = node.next;
-		} while (node !== loop.curves[0]);
-		
-		return total;		
-	}
+    
+    return function(loop: Loop) {
+        let node = loop.curves[0];
+        let total = 0;
+        do {
+            total += totalByF(node);
+            
+            node = node.next;
+        } while (node !== loop.curves[0]);
+        
+        return total;        
+    }
 }
 
 

package/src/find-mat/mat-options.ts

@@ -127,7 +127,7 @@ const matOptionRanges: Partial<{ [K in keyof MatOptions]: MatOptionMeta }> = {
         range: [1, Number.POSITIVE_INFINITY],
     },
     simplifyTolerance: {
-        range: [2**-10,1024],
+        range: [2**-20,2**20],
         scaleByMaxCoordinate: true
     },
     minBezLength: {

package/src/geometry/get-closest-square-distance-to-rect.ts

@@ -7,45 +7,45 @@ const squaredDistanceBetween = squaredDistanceBetween_;
  * @internal
  */
 function getClosestSquareDistanceToRect(
-		box: number[][], p: number[]): number {
+        box: number[][], p: number[]): number {
 
-	const p0 = box[0];
-	const p1 = box[1];
-	const x0 = p0[0];
-	const y0 = p0[1];
-	const x1 = p1[0];
-	const y1 = p1[1];	
-	const xp = p[0];
-	const yp = p[1];
+    const p0 = box[0];
+    const p1 = box[1];
+    const x0 = p0[0];
+    const y0 = p0[1];
+    const x1 = p1[0];
+    const y1 = p1[1];    
+    const xp = p[0];
+    const yp = p[1];
 
-	//let [[x0,y0],[x1,y1]] = box;
-	//let [xp,yp] = p;
-	
-	if (xp < x0) {
-		if (yp < y0) {
-			return squaredDistanceBetween(box[0], p);
-		} else if (yp > y1) {
-			return squaredDistanceBetween([x0,y1], p);
-		} else {
-			return (x0 - xp)**2;
-		}
-	} else if (xp > x1) {
-		if (yp < y0) {
-			return squaredDistanceBetween([x1,y0], p);
-		} else if (yp > y1) {
-			return squaredDistanceBetween(box[1], p);
-		} else {
-			return (xp - x1)**2;
-		}
-	} else {
-		if (yp < y0) {
-			return (y0 - yp)**2;
-		} else if (yp > y1) {
-			return (yp - y1)**2;
-		} 
-			
-		return 0;
-	}
+    //let [[x0,y0],[x1,y1]] = box;
+    //let [xp,yp] = p;
+    
+    if (xp < x0) {
+        if (yp < y0) {
+            return squaredDistanceBetween(box[0], p);
+        } else if (yp > y1) {
+            return squaredDistanceBetween([x0,y1], p);
+        } else {
+            return (x0 - xp)**2;
+        }
+    } else if (xp > x1) {
+        if (yp < y0) {
+            return squaredDistanceBetween([x1,y0], p);
+        } else if (yp > y1) {
+            return squaredDistanceBetween(box[1], p);
+        } else {
+            return (xp - x1)**2;
+        }
+    } else {
+        if (yp < y0) {
+            return (y0 - yp)**2;
+        } else if (yp > y1) {
+            return (yp - y1)**2;
+        } 
+            
+        return 0;
+    }
 }
 
 

package/src/geometry/get-closest-squared-distance-to-rotated-rect.ts

@@ -1,5 +1,5 @@
 import { 
-	squaredDistanceBetweenPointAndLineSegment, squaredDistanceBetween 
+    squaredDistanceBetweenPointAndLineSegment, squaredDistanceBetween 
 } from 'flo-vector2d';
 
 
@@ -7,22 +7,22 @@ import {
  * @internal
  */
 function getClosestSquaredDistanceToRotatedRect(ps: number[][], p: number[]) {
-	const ds = [0,1,2,3].map(i => squaredDistanceBetweenPointAndLineSegment(
-			p, 
-			[ps[i], ps[(i + 1) % 4]]
-		)				
-	);
-	
-	const width  = squaredDistanceBetween(ps[0], ps[1]);
-	const height = squaredDistanceBetween(ps[0], ps[3]);
+    const ds = [0,1,2,3].map(i => squaredDistanceBetweenPointAndLineSegment(
+            p, 
+            [ps[i], ps[(i + 1) % 4]]
+        )                
+    );
+    
+    const width  = squaredDistanceBetween(ps[0], ps[1]);
+    const height = squaredDistanceBetween(ps[0], ps[3]);
 
-	if (ds[0] <= height && ds[2] <= height && 
-		ds[1] <= width  && ds[3] <= width) {
+    if (ds[0] <= height && ds[2] <= height && 
+        ds[1] <= width  && ds[3] <= width) {
 
-		return 0; // Inside rotated rect
-	}
+        return 0; // Inside rotated rect
+    }
 
-	return Math.min(...ds);
+    return Math.min(...ds);
 }
 
 

package/src/get-curve/get-curve-between.ts

@@ -39,7 +39,7 @@ function getCurveBetween(
         const a = fromTo(fromCc, mid);
         const b = fromTo(toCc,   mid);
         
-        twisted = dot(a,c) < 0 || dot(b,c) > 0;			
+        twisted = dot(a,c) < 0 || dot(b,c) > 0;            
     }
     
     if (!twisted) {

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';
@@ -51,3 +50,41 @@ export { getPotentialClosestPointsOnCurveCertified } from './closest-boundary-po
 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';
+
+
+// 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-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

@@ -4,9 +4,9 @@
 
 // /** @internal */
 // function getTwoProngType(e: TwoProngForDebugging): ElemType_TwoProng {
-// 	if (e.holeClosing) { return 'twoProng_holeClosing' }
-	
-// 	return 'twoProng_regular';
+//     if (e.holeClosing) { return 'twoProng_holeClosing' }
+    
+//     return 'twoProng_regular';
 // }
 
 

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;
+    }
 }