flo-mat 3.0.9 → 3.0.11

package/src/find-3-prong.ts/find-3-prong-for-delta3s.ts

@@ -27,7 +27,7 @@ const calcVectorToZeroV_StraightToIt = fromTo;
  * Finds a 3-prong using only the 3 given δs.
  * @param δs The boundary pieces
  * @param idx δ identifier
- * @param bezierPiecess
+ * @param curvePiecess
  * @param maxCoordinate The maximum coordinate value used to calculate floating point
  * tolerances.
  */
@@ -35,7 +35,7 @@ function find3ProngForDelta3s(
         δs: CpNode[][], 
         idx: number, 
         k: number,
-        bezierPiecess: CurvePiece[][],
+        curvePiecess: CurvePiece[][],
         maxCoordinate: number) {
 
     const TOLERANCE = 2**-32*maxCoordinate;
@@ -47,10 +47,10 @@ function find3ProngForDelta3s(
         δs[δs.length-1]
     ];
 
-    const bezierPieces_ = [
-        bezierPiecess[0], 
-        bezierPiecess[idx], 
-        bezierPiecess[δs.length-1]
+    const curvePieces_ = [
+        curvePiecess[0], 
+        curvePiecess[idx], 
+        curvePiecess[δs.length-1]
     ];
 
     const δ3ss = [
@@ -59,15 +59,15 @@ function find3ProngForDelta3s(
         [δs_[2], δs_[0], δs_[1]],
     ];
 
-    const bezierPiecess_ = [
-        [bezierPieces_[0], bezierPieces_[1], bezierPieces_[2]],
-        [bezierPieces_[1], bezierPieces_[2], bezierPieces_[0]],
-        [bezierPieces_[2], bezierPieces_[0], bezierPieces_[1]],
+    const curvePiecess_ = [
+        [curvePieces_[0], curvePieces_[1], curvePieces_[2]],
+        [curvePieces_[1], curvePieces_[2], curvePieces_[0]],
+        [curvePieces_[2], curvePieces_[0], curvePieces_[1]],
     ]
 
 
     const δ3s = δ3ss[k];
-    const bezierPiece3s = bezierPiecess_[k];
+    const curvePiece3s = curvePiecess_[k];
 
     if (isSharp(δ3s[0][0])) { return undefined; }
 
@@ -75,13 +75,13 @@ function find3ProngForDelta3s(
     let poss: PointOnShape[] = undefined!;
     let circumCenter_;
     let j = 0; // Safeguard for slow convergence
-    let x = calcInitial3ProngCenter(maxCoordinate, δ3s, bezierPiece3s);
+    let x = calcInitial3ProngCenter(maxCoordinate, δ3s, curvePiece3s);
 
     let tolerance = Number.POSITIVE_INFINITY;
     while (tolerance > TOLERANCE && j < MAX_ITERATIONS) { 
         j++;
         
-        poss = getClosestPoints(x, bezierPiece3s);
+        poss = getClosestPoints(x, curvePiece3s);
         if (!Number.isFinite(x[0]) || !Number.isFinite(x[1])) {
 
             // TODO - the code can be cleaned up and sped up a lot if we don't
@@ -103,7 +103,7 @@ function find3ProngForDelta3s(
             // loop. This check, for instance, would be eliminated completely.
             return undefined;
         }
-        const upds = calcBetterX(bezierPiece3s, x, vectorToZeroV);
+        const upds = calcBetterX(curvePiece3s, x, vectorToZeroV);
         x = upds.newX;
         poss = upds.newPoss;
 
@@ -164,7 +164,7 @@ function find3ProngForDelta3s(
             const cross_ = Math.abs( Math.asin( cross(v1, v2) ) );
             
             totalAngleError += cross_;
-        }		
+        }        
     }
 
     //-------------------------------------------------------------------------
@@ -173,10 +173,10 @@ function find3ProngForDelta3s(
     // candidate for the 3-prong.
     //-------------------------------------------------------------------------
     const closestDs = [];
-    for (let i=0; i<bezierPiecess.length; i++) {
+    for (let i=0; i<curvePiecess.length; i++) {
         const p = getCloseBoundaryPointsCertified(
             5,  // TODO - see find-2-prong
-            bezierPiecess[i], x
+            curvePiecess[i], x
         )[0];
 
         closestDs.push( distanceBetween(p.p, x) );

package/src/find-3-prong.ts/find-3-prong.ts

@@ -13,35 +13,35 @@ import { getBoundaryPieceBeziers } from '../mat/get-boundary-piece-beziers.js';
  * tolerances.
  */ 
 function find3Prong(
-		δs: CpNode[][], extreme: number) {
+        δs: CpNode[][], extreme: number) {
 
-	const bezierPiecess = δs.map(getBoundaryPieceBeziers);
+    const curvePiecess = δs.map(getBoundaryPieceBeziers);
 
-	// The best candidate amongst the different 'permutations' of the given δs.
-	let threeProng: { 
+    // The best candidate amongst the different 'permutations' of the given δs.
+    let threeProng: { 
         circle: Circle, 
         poss: PointOnShape[], 
         δ3s: CpNode[][] 
     };
-	let smallestError = Number.POSITIVE_INFINITY;
-	for (let i=1; i<δs.length-1; i++) {
-		for (let k=0; k<3; k++) {
-			const threeProngInfo = 
-				find3ProngForDelta3s(δs, i, k, bezierPiecess, extreme);
-			if (!threeProngInfo) { continue; }
-
-			const { circle, poss: poss, error, δ3s } = threeProngInfo;
-			
-			if (error < smallestError) {
-				smallestError = error;
-				
-				threeProng = { circle, poss: poss as PointOnShape[], δ3s };
-			}
-		}
-	}
-	
-
-	return threeProng!;
+    let smallestError = Number.POSITIVE_INFINITY;
+    for (let i=1; i<δs.length-1; i++) {
+        for (let k=0; k<3; k++) {
+            const threeProngInfo = 
+                find3ProngForDelta3s(δs, i, k, curvePiecess, extreme);
+            if (!threeProngInfo) { continue; }
+
+            const { circle, poss: poss, error, δ3s } = threeProngInfo;
+            
+            if (error < smallestError) {
+                smallestError = error;
+                
+                threeProng = { circle, poss: poss as PointOnShape[], δ3s };
+            }
+        }
+    }
+    
+
+    return threeProng!;
 }
 
 

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

@@ -18,43 +18,43 @@ import { getProngCount } from '../cp-node/fs/get-prong-count.js';
  * tolerances.
  */
 function findAndAdd3Prong(
-		meta: MatMeta,
-		visitedCps: CpNode[]) {
-	
-	const δs: [CpNode, CpNode][] = [];
-	for (const visitedCp of visitedCps) {
-		δs.push([visitedCp, visitedCp.next]);
-	}
-	
-	const threeProngInfo = find3Prong(δs, meta.maxCoordinate);
-
-	const { circle, poss, δ3s } = threeProngInfo;
-	
-	const orders: number[] = [];
-	for (let i=0; i<3; i++) {
-		orders.push(calcPosOrder(circle, poss[i]));
-	}
-
-	const closeBysFor3Prong: CpNode[] = [];
-	for (let i=0; i<poss.length; i++) {
-		const pos = poss[i];
-		const order = orders[i];
-		const closeBy = getCloseByCpIfExist(meta, pos, circle, order, 0, 3);
-		if (closeBy !== undefined) {
-			const prongCount = getProngCount(closeBy);
-			if (prongCount <= 2 && !closeBy.isHoleClosing) {
-				closeBysFor3Prong.push(closeBy);
-			}
-		}
-	}
-
-	const cpNodes = closeBysFor3Prong.length === 0
-		? addToCpTree(
-			true, false, circle, orders, meta, poss, δ3s.map(v => v[0])
-		).cpNodes
-		: [];
-
-	return { closeBysFor3Prong, cpNodes: cpNodes as CpNode[] };
+        meta: MatMeta,
+        visitedCps: CpNode[]) {
+    
+    const δs: [CpNode, CpNode][] = [];
+    for (const visitedCp of visitedCps) {
+        δs.push([visitedCp, visitedCp.next]);
+    }
+    
+    const threeProngInfo = find3Prong(δs, meta.maxCoordinate);
+
+    const { circle, poss, δ3s } = threeProngInfo;
+    
+    const orders: number[] = [];
+    for (let i=0; i<3; i++) {
+        orders.push(calcPosOrder(circle, poss[i]));
+    }
+
+    const closeBysFor3Prong: CpNode[] = [];
+    for (let i=0; i<poss.length; i++) {
+        const pos = poss[i];
+        const order = orders[i];
+        const closeBy = getCloseByCpIfExist(meta, pos, circle, order, 0, 3);
+        if (closeBy !== undefined) {
+            const prongCount = getProngCount(closeBy);
+            if (prongCount <= 2 && !closeBy.isHoleClosing) {
+                closeBysFor3Prong.push(closeBy);
+            }
+        }
+    }
+
+    const cpNodes = closeBysFor3Prong.length === 0
+        ? addToCpTree(
+            true, false, circle, orders, meta, poss, δ3s.map(v => v[0])
+        ).cpNodes
+        : [];
+
+    return { closeBysFor3Prong, cpNodes: cpNodes as CpNode[] };
 }
 
 

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-3-prong.ts/get-closest-points.ts

@@ -5,17 +5,17 @@ import { getCloseBoundaryPointsCertified } from '../closest-boundary-point/get-c
 /**
  * @internal
  * @param x 
- * @param bezierPiece3s 
+ * @param curvePiece3s 
  * @param extreme 
  */
 function getClosestPoints(
         x: number[], 
-        bezierPiece3s: CurvePiece[][]) {
+        curvePiece3s: CurvePiece[][]) {
 
-    return bezierPiece3s.map(bezierPieces => {
+    return curvePiece3s.map(curvePieces => {
         return getCloseBoundaryPointsCertified(
             5,  // TODO - see find-2-prong
-            bezierPieces, x
+            curvePieces, x
         )[0];
     });
 }

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

@@ -1,18 +1,18 @@
-import { drawFs } from "flo-draw";
+// import { drawFs } from "flo-draw";
 import { closestPointOnBezier } from "flo-bezier3";
 import { CpNode } from "../cp-node/cp-node.js";
 import { findAndAdd2Prong } from "../find-2-prong/find-and-add-2-prong.js";
 import { MatMeta } from "../mat/mat-meta.js";
 import { getHalfAngle } from "./get-half-angles.js";
 import { getMatCurveToNext } from "../cp-node/fs/get-mat-curve-to-next.js";
-import { getAllOnCircle } from "../cp-node/fs/get-all-on-circle.js";
+// import { getAllOnCircle } from "../cp-node/fs/get-all-on-circle.js";
 import { isTerminating } from "../cp-node/fs/is-terminating.js";
-import { findAndAdd3Prongs } from "../find-3-prong.ts/find-and-add-3-prongs.js";
-import { getBoundaryBezierPartsToNext } from "../cp-node/fs/get-boundary-bezier-parts-to-next.js";
-import { drawBezierPieces } from "../debug/functions/draw/draw-bezier-pieces.js";
+// import { findAndAdd3Prongs } from "../find-3-prong.ts/find-and-add-3-prongs.js";
+// import { getBoundaryBezierPartsToNext } from "../cp-node/fs/get-boundary-bezier-parts-to-next.js";
+// import { drawBezierPieces } from "../debug/functions/draw/draw-bezier-pieces.js";
 import { getAllOnLoop } from "../cp-node/fs/get-all-on-loop.js";
-import { PointOnShape } from "../point-on-shape/point-on-shape.js";
-import { getBoundaryBeziersToNext } from "../cp-node/fs/get-boundary-beziers-to-next.js";
+// import { PointOnShape } from "../point-on-shape/point-on-shape.js";
+// import { getBoundaryBeziersToNext } from "../cp-node/fs/get-boundary-beziers-to-next.js";
 import { isPosQuiteDullCorner } from "../point-on-shape/is-pos-quite-dull-corner.js";
 import { MatOptions } from "./mat-options.js";
 
@@ -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/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) {