flo-mat 3.0.9 → 3.0.10

package/package.json

@@ -2,7 +2,7 @@
     "name": "flo-mat",
     "sideEffects": false,
     "description": "Medial / Scale Axis Transform (MAT/SAT) Library.",
-    "version": "3.0.9",
+    "version": "3.0.10",
     "author": {
         "name": "Floris Steenkamp"
     },
@@ -33,7 +33,7 @@
     "dependencies": {
         "big-float-ts": "^4.0.2",
         "double-double": "^3.0.4",
-        "flo-bezier3": "^6.0.7",
+        "flo-bezier3": "^6.0.8",
         "flo-boolean": "^5.0.3",
         "flo-draw": "^2.0.5",
         "flo-gauss-quadrature": "^2.1.4",
@@ -47,19 +47,19 @@
         "@swc/core": "^1.15.33",
         "@swc/jest": "^0.2.39",
         "@types/jest": "^30.0.0",
-        "@types/node": "^25.9.0",
+        "@types/node": "^25.9.1",
         "jest": "^30.4.2",
         "jest-ts-webcompat-resolver": "^1.0.1",
         "c8": "^11.0.0",
         "chai": "^6.2.2",
         "circular-dependency-plugin": "^5.2.2",
-        "mocha": "^11.7.5",
+        "mocha": "^11.7.6",
         "rimraf": "^6.1.3",
         "source-map-support": "^0.5.21",
         "ts-loader": "^9.5.7",
         "ts-node": "^10.9.2",
         "typescript": "^6.0.3",
-        "webpack": "^5.106.2",
+        "webpack": "^5.107.1",
         "webpack-cli": "^7.0.2"
     },
     "scripts": {

package/src/closest-boundary-point/cull-bezier-pieces.ts

@@ -5,31 +5,32 @@ import { cullByTightBoundingBox } from './cull-by-tight-boundary-box.js';
 
 
 /**
- * @internal
- * @param bezierPieces 
+ * @param curvePieces 
  * @param p 
  * @param extreme
+ * 
+ * @internal
  */
-function cullBezierPieces1(
-        bezierPieces: CurvePiece[],
+function cullCurvePieces1(
+        curvePieces: CurvePiece[],
         p: number[]) {
 
     const bestSquaredDistance = getBestDistanceSquared(
-        bezierPieces, p
+        curvePieces, p
     );
-    bezierPieces = cullByLooseBoundingBox(
-        bezierPieces, p,
+    curvePieces = cullByLooseBoundingBox(
+        curvePieces, p,
         bestSquaredDistance
     );
     
-    bezierPieces = cullByTightBoundingBox(
-        bezierPieces, p,
+    curvePieces = cullByTightBoundingBox(
+        curvePieces, p,
         bestSquaredDistance
     );
 
 
-    return bezierPieces;
+    return curvePieces;
 }
 
 
-export { cullBezierPieces1 }
+export { cullCurvePieces1 }

package/src/closest-boundary-point/cull-by-loose-bounding-box.ts

@@ -8,20 +8,20 @@ import { getBoundingBox$ } from '../geometry/get-bounding-box-.js';
  * @internal
  * When checking distances, ignore all those with closest possible distance 
  * further than 'bestSquaredDistance', i.e. cull them.
- * @param bezierPieces 
+ * @param curvePieces 
  * @param p 
  * @param dSquared 
  */
 function cullByLooseBoundingBox(
-        bezierPieces: CurvePiece[],
+        curvePieces: CurvePiece[],
         p: number[],
         dSquared: number) {
 
-    const candidateBezierPieces = [];
+    const candidateCurvePieces = [];
 
-    for (let i=0; i<bezierPieces.length; i++) {
-        const bezierPiece = bezierPieces[i];
-        const ps = bezierPiece.curve.ps;
+    for (let i=0; i<curvePieces.length; i++) {
+        const curvePiece = curvePieces[i];
+        const ps = curvePiece.curve.ps;
         
         const boundingBox = getBoundingBox$(ps);
         
@@ -30,11 +30,11 @@ function cullByLooseBoundingBox(
             p
         );
         if (d <= dSquared) {
-            candidateBezierPieces.push(bezierPiece);
+            candidateCurvePieces.push(curvePiece);
         } 
     }
 
-    return candidateBezierPieces;
+    return candidateCurvePieces;
 }
 
 

package/src/closest-boundary-point/cull-by-tight-boundary-box.ts

@@ -11,20 +11,20 @@ const getBoundingBoxTight_ = memoize(getBoundingBoxTight);
  * @internal
  * When checking distances, ignore all those with closest possible distance 
  * further than 'bestSquaredDistance', i.e. cull them.
- * @param bezierPieces 
+ * @param curvePieces 
  * @param p 
  * @param bestSquaredDistance 
  */
 function cullByTightBoundingBox(
-        bezierPieces: CurvePiece[], 
+        curvePieces: CurvePiece[], 
         p: number[],
         bestSquaredDistance: number) {
 
-    const candidateBezierPieces = [];
+    const candidateCurvePieces = [];
 
-    for (let i=0; i<bezierPieces.length; i++) {
-        const bezierPiece = bezierPieces[i];
-        const ps = bezierPiece.curve.ps;
+    for (let i=0; i<curvePieces.length; i++) {
+        const curvePiece = curvePieces[i];
+        const ps = curvePiece.curve.ps;
         
         const tightBoundingBox = getBoundingBoxTight_(ps);
         const d = getClosestSquaredDistanceToRotatedRect(
@@ -32,11 +32,11 @@ function cullByTightBoundingBox(
                 p
         );
         if (d <= bestSquaredDistance) {
-            candidateBezierPieces.push(bezierPiece);
+            candidateCurvePieces.push(curvePiece);
         } 
     } 
 
-    return candidateBezierPieces;
+    return candidateCurvePieces;
 }
 
 

package/src/closest-boundary-point/get-best-distance-squared.ts

@@ -9,17 +9,17 @@ import { CurvePiece } from "../mat/curve-piece.js";
  * this distance away.
  */ 
 function getBestDistanceSquared(
-        bezierPieces: CurvePiece[], 
+        curvePieces: CurvePiece[], 
         p: number[]) {
 
     let bestSquaredDistance = Number.POSITIVE_INFINITY;
-    for (let i=0; i<bezierPieces.length; i++) {
-        const bezierPiece = bezierPieces[i];
+    for (let i=0; i<curvePieces.length; i++) {
+        const curvePiece = curvePieces[i];
 
-        const ps = bezierPiece.curve.ps;
+        const ps = curvePiece.curve.ps;
         
-        const p1 = evalDeCasteljau(ps, bezierPiece.ts[0]);
-        const p2 = evalDeCasteljau(ps, bezierPiece.ts[1]);
+        const p1 = evalDeCasteljau(ps, curvePiece.ts[0]);
+        const p2 = evalDeCasteljau(ps, curvePiece.ts[1]);
         
         const d = Math.min(
             squaredDistanceBetween(p, p1),

package/src/closest-boundary-point/get-close-boundary-points-certified.ts

@@ -1,6 +1,6 @@
 import { CurvePiece  } from '../mat/curve-piece.js';
 import { getPotentialClosestPointsOnCurveCertified } from './get-potential-closest-points-on-curve-certified.js';
-import { cullBezierPieces1 } from './cull-bezier-pieces.js';
+import { cullCurvePieces1 } from './cull-bezier-pieces.js';
 import { Curve } from '../curve/curve.js';
 import { FootAndEndpointInfo } from './foot-and-endpoint-info.js';
 import { PointOnShape } from '../point-on-shape/point-on-shape.js';
@@ -13,7 +13,7 @@ import { createPos } from '../point-on-shape/create-pos.js';
  * bezier pieces, including the beziers actually checked after culling.
  * 
  * @param pow
- * @param bezierPieces
+ * @param curvePieces
  * @param x
  * @param touchedCurve
  * @param t
@@ -22,24 +22,24 @@ import { createPos } from '../point-on-shape/create-pos.js';
  */
 function getCloseBoundaryPointsCertified(
 		pow: number,
-        bezierPieces: CurvePiece[], 
+        curvePieces: CurvePiece[], 
         x: number[], 
 		touchedCurve: Curve | undefined = undefined,
 		t: number | undefined = undefined,
 		for1Prong = false,
 		angle = 0): PointOnShape[] {
 	
-	bezierPieces = cullBezierPieces1(bezierPieces, x);
+	curvePieces = cullCurvePieces1(curvePieces, x);
  
 	const pInfoss: FootAndEndpointInfo[] = [];
-	for (let i=0; i<bezierPieces.length; i++) {
-		const bezierPiece = bezierPieces[i];
+	for (let i=0; i<curvePieces.length; i++) {
+		const curvePiece = curvePieces[i];
 
 		const pInfos = getPotentialClosestPointsOnCurveCertified(
 			pow,
-			bezierPiece.curve, 
+			curvePiece.curve, 
 			x, 
-			bezierPiece.ts, 
+			curvePiece.ts, 
 			touchedCurve, 
 			t,
 			for1Prong,

package/src/cp-node/fs/get-boundary-bezier-parts-to-next.ts

@@ -13,7 +13,7 @@ import type { Curve  } from '../../curve/curve.js';
  * @param cpNode 
  */
 function getBoundaryBezierPartsToNext(
-        cpNode: CpNode): BezierPiece[] | undefined {
+        cpNode: CpNode): BezierPiece[] {
 
     const cpThis = cpNode; 
     const cpNext = cpNode.next;
@@ -27,27 +27,22 @@ function getBoundaryBezierPartsToNext(
     if (curveThis.loop !== curveNext.loop) {
         // It is a hole-closer going over to the other loop - a kind of terminal
         // CpNode.
-        return undefined;
+        // return undefined;
+        return [];
     }
     
     const bezierPieces: BezierPiece[] = [];
 
     if (curveNext === curveThis) {
         bezierPieces.push(
-            {
-                ps: posThis.curve.ps,
-                ts: [posThis.t, posNext.t]
-            }
+            { ps: posThis.curve.ps, ts: [posThis.t, posNext.t] }
         );
     } else {
         bezierPieces.push(
-            {
-                ps: posThis.curve.ps,
-                ts: [posThis.t, 1]
-            }
+            { ps: posThis.curve.ps, ts: [posThis.t, 1] }
         );
         
-        addSkippedBeziers(
+        addSkippedBezierPiecess(
             bezierPieces,
             posThis.curve,
             posNext.curve,
@@ -60,10 +55,10 @@ function getBoundaryBezierPartsToNext(
 
 
 /**
- * @internal
  * Adds pieces of skipped beziers.
+ * @internal
  */
-function addSkippedBeziers(
+function addSkippedBezierPiecess(
         bezierPieces: BezierPiece[],
         curveStart: Curve,
         curveEnd: Curve,
@@ -72,11 +67,10 @@ function addSkippedBeziers(
     let curveThis = curveStart;
     do {
         curveThis = curveThis.next;
-        const bezierPart = curveThis === curveEnd 
-            ? { ps: curveThis.ps, ts: [0, t1] }
-            : { ps: curveThis.ps, ts: [0, 1] }
-
-        bezierPieces.push(bezierPart);
+        const tEnd = curveThis === curveEnd ? t1 : 1;
+        bezierPieces.push({
+            ps: curveThis.ps, ts: [0, tEnd]
+        });
     } while (curveThis !== curveEnd);
 }
 

package/src/cp-node/fs/get-boundary-beziers-between.ts

@@ -1,7 +1,6 @@
-import type { BezierPiece } from "flo-bezier3";
 import type { CpNode } from "../cp-node.js";
-import { cpNodesToBoundaryBeziers } from "./cp-nodes-to-boundary-beziers.js";
 import { getAllBetween } from "./get-all-between.js";
+import { getBoundaryBeziersToNext } from "./get-boundary-beziers-to-next.js";
 
 
 /**
@@ -23,12 +22,12 @@ function getBoundaryBeziersBetween(
             hasHoleCloser: boolean
         } {
 
-    const allBetween = getAllBetween(cpNode1,cpNode2,inclAllIfEqual);
+    const { cpNodes, hasHoleCloser } =
+        getAllBetween(cpNode1,cpNode2,inclAllIfEqual);
 
-    return {
-        pss: cpNodesToBoundaryBeziers(allBetween.cpNodes),
-        hasHoleCloser: allBetween.hasHoleCloser
-    }
+    const pss = cpNodes.flatMap(getBoundaryBeziersToNext);
+
+    return { pss, hasHoleCloser }
 }
 
 

package/src/cp-node/fs/get-boundary-beziers-to-next.ts

@@ -1,70 +1,96 @@
+import type { CpNode } from '../cp-node.js';
 import { fromTo } from 'flo-bezier3';
-import { CpNode } from '../cp-node.js';
-import { Curve  } from '../../curve/curve.js';
+import { getBoundaryBezierPartsToNext } from './get-boundary-bezier-parts-to-next.js';
 
 
+/**
+//  * Returns the boundary beziers between this `CpNode` and the next
+//  * one.
+//  * 
+//  * * returns `[]` if the next `CpNode` is on a different loop,
+//  * as this is a hole-closer and there are no boundary beziers between them.
+//  * 
+//  * @param cpNode 
+//  */
 function getBoundaryBeziersToNext(
         cpNode: CpNode): number[][][] {
 
-    const cpThis = cpNode; 
-    const cpNext = cpNode.next;
+    return getBoundaryBezierPartsToNext(cpNode).map(
+        bp => fromTo(bp.ps, bp.ts[0], bp.ts[1])
+    );
+}
+
+
+// /**
+//  * Returns the boundary beziers between this `CpNode` and the next
+//  * one.
+//  * 
+//  * * returns `[]` if the next `CpNode` is on a different loop,
+//  * as this is a hole-closer and there are no boundary beziers between them.
+//  * 
+//  * @param cpNode 
+//  */
+// function getBoundaryBeziersToNext(
+//         cpNode: CpNode): number[][][] {
+
+//     const cpThis = cpNode; 
+//     const cpNext = cpNode.next;
 
-    const posThis = cpThis.cp.pointOnShape;
-    const posNext = cpNext.cp.pointOnShape;
+//     const posThis = cpThis.cp.pointOnShape;
+//     const posNext = cpNext.cp.pointOnShape;
 
-    const curveThis = posThis.curve;
-    const curveNext = posNext.curve;
+//     const curveThis = posThis.curve;
+//     const curveNext = posNext.curve;
 
-    if (curveThis.loop !== curveNext.loop) {
-        // It is a hole-closer going over to the other loop - a kind of terminal
-        // CpNode.
-        // return undefined!;
-        return [];
-    }
+//     if (curveThis.loop !== curveNext.loop) {
+//         // It is a hole-closer going over to the other loop - a kind of terminal
+//         // CpNode.
+//         // return undefined!;
+//         return [];
+//     }
 
-    const beziers = [];
+//     const beziers: number[][][] = [];
 
-    if (curveNext === curveThis) {
-        beziers.push(
-            fromTo(posThis.curve.ps, posThis.t, posNext.t)
-        );
-    } else {
-        beziers.push(
-            fromTo(posThis.curve.ps, posThis.t, 1)
-        );
+//     if (curveNext === curveThis) {
+//         beziers.push(
+//             fromTo(posThis.curve.ps, posThis.t, posNext.t)
+//         );
+//     } else {
+//         beziers.push(
+//             fromTo(posThis.curve.ps, posThis.t, 1)
+//         );
         
-        addSkippedBeziers(
-                beziers, 
-                posThis.curve, 
-                posNext.curve,
-                posNext.t
-        );
-    }
-
-    return beziers;
-}
+//         addSkippedBeziers(
+//             beziers,
+//             posThis.curve,
+//             posNext.curve,
+//             posNext.t
+//         );
+//     }
 
+//     return beziers;
+// }
 
-/**
- * Adds pieces of skipped beziers.
- * @internal
- */
-function addSkippedBeziers(
-        beziers    : number[][][], 
-        curveStart : Curve, 
-        curveEnd   : Curve, 
-        t1         : number) {
-
-    let curveThis = curveStart;
-    do {
-        curveThis = curveThis.next;
-        const tEnd = curveThis === curveEnd ? t1 : 1;
-        beziers.push( 
-            // qqq from0ToT(curveThis.ps, tEnd) 
-            fromTo(curveThis.ps, 0, tEnd)
-        );
-    } while (curveThis !== curveEnd);
-}
+
+// /**
+//  * Adds pieces of skipped beziers.
+//  * @internal
+//  */
+// function addSkippedBeziers(
+//         beziers: number[][][],
+//         curveStart: Curve,
+//         curveEnd: Curve,
+//         t1: number) {
+
+//     let curveThis = curveStart;
+//     do {
+//         curveThis = curveThis.next;
+//         const tEnd = curveThis === curveEnd ? t1 : 1;
+//         beziers.push( 
+//             fromTo(curveThis.ps, 0, tEnd)
+//         );
+//     } while (curveThis !== curveEnd);
+// }
 
 
 export { getBoundaryBeziersToNext }

package/src/cp-node/fs/get-salience.ts

@@ -17,9 +17,9 @@ function getSalience(cpNode: CpNode) {
 
     const d = distanceBetween(bp1, bp2);
 
-    const { pss: bps, hasHoleCloser } = getBoundaryBeziersBetween(cpNode1, cpNode2);
+    const { pss, hasHoleCloser } = getBoundaryBeziersBetween(cpNode1, cpNode2);
 
-    const s = sum(bps.map(ps => totalLength(ps)));
+    const s = sum(pss.map(ps => totalLength(ps)));
 
     return hasHoleCloser ? Number.POSITIVE_INFINITY : s/d;
 }

package/src/cp-node/fs/get-speed.ts

@@ -1,14 +1,9 @@
-import { curvature, totalAbsoluteCurvature, totalLength } from "flo-bezier3";
+import { totalAbsoluteCurvature, totalLength } from "flo-bezier3";
 import { memoize } from "flo-memoize";
-import { sum } from "../../utils/sum.js";
 import { CpNode } from "../cp-node.js";
-import { getBoundaryBeziersToNext } from "./get-boundary-beziers-to-next.js";
 import { getMatCurveToNext } from "./get-mat-curve-to-next.js";
 import { getRealProngCount } from "./get-real-prong-count.js";
 
-const { min, abs } = Math;
-
-
 const getSpeed$ = memoize(getSpeed);
 
 

package/src/curve/curve.ts

@@ -9,28 +9,28 @@ interface Curve {
 	 * The closed loop of bezier curves representing the shape 
 	 * boundary this curve belongs to.
 	 */
-	loop : Loop;
+	loop: Loop;
 	/**
 	 * The bezier control points.
 	 */
-	ps   : number[][];
+	ps: number[][];
 	/**
 	 * The previous curve (when going in a negative direction around
 	 * the shape boundary, i.e. clockwise for the outer shape and anti-clockwise
 	 * for the holes (if any))
 	 */
-	prev : Curve; 
+	prev: Curve; 
 	/**
 	 * The next curve (when going in a positive direction around
 	 * the shape boundary, i.e. anti-clockwise for the outer shape and clockwise
 	 * for the holes (if any))
 	 */
-	next : Curve;
+	next: Curve;
 	/**
 	 * The curve's ordered index in the loop. This imposes a cycling
 	 * ordering of the curves in the loop
 	 */
-	idx  : number;
+	idx: number;
 }
 
 

package/src/debug/functions/draw-elem/two-prong.ts

@@ -1,50 +1,50 @@
-import { drawFs } from 'flo-draw';
-import { TwoProngForDebugging   } from '../../two-prong-for-debugging.js';
-import { getTwoProngType } from '../../../mat/get-two-prong-type.js';
+// import { drawFs } from 'flo-draw';
+// import { TwoProngForDebugging   } from '../../two-prong-for-debugging.js';
+// import { getTwoProngType } from '../../../mat/get-two-prong-type.js';
 
 
-/** @internal */
-function twoProng(
-		g: SVGGElement,
-		twoProng: TwoProngForDebugging,
-        classes?: string,
-        delay = 0,
-        scaleFactor = 1) {
+// /** @internal */
+// function twoProng(
+// 		g: SVGGElement,
+// 		twoProng: TwoProngForDebugging,
+//         classes?: string,
+//         delay = 0,
+//         scaleFactor = 1) {
 
-	let $failedDot : SVGElement[] = [];
-	let $center    : SVGElement[] = [];
-	let $circle    : SVGElement[] = [];
-	let $cp1       : SVGElement[] = [];
-	let $cp2       : SVGElement[] = [];
+// 	let $failedDot : SVGElement[] = [];
+// 	let $center    : SVGElement[] = [];
+// 	let $circle    : SVGElement[] = [];
+// 	let $cp1       : SVGElement[] = [];
+// 	let $cp2       : SVGElement[] = [];
 	
-	let color;
-	let thin;
+// 	let color;
+// 	let thin;
 
-	switch (getTwoProngType(twoProng)) {
-		case 'twoProng_regular': {
-			color = 'red ';
-			thin = '2';
-			break;
-		}
-		case 'twoProng_holeClosing': {
-			color = 'cyan ';
-			thin = '10';
-			break;
-		}		
-	}
+// 	switch (getTwoProngType(twoProng)) {
+// 		case 'twoProng_regular': {
+// 			color = 'red ';
+// 			thin = '2';
+// 			break;
+// 		}
+// 		case 'twoProng_holeClosing': {
+// 			color = 'cyan ';
+// 			thin = '10';
+// 			break;
+// 		}		
+// 	}
 		
 	
-	if (twoProng.failed) {
-		$failedDot = drawFs.dot(g, twoProng.pos.p, 1*scaleFactor, 'black', delay);
-	} else if (!twoProng.failed) {
-		$center = drawFs.dot   (g, twoProng.circle.center, 0.01*scaleFactor, 'yellow', delay);
-		$circle = drawFs.circle(g, twoProng.circle, color + 'thin' + thin + ' nofill', delay); 
-		$cp1    = drawFs.dot   (g, twoProng.pos.p, 0.0175*scaleFactor, color, delay);
-		$cp2    = drawFs.dot   (g, twoProng.z, 0.035*scaleFactor, color, delay);	
-	}
+// 	if (twoProng.failed) {
+// 		$failedDot = drawFs.dot(g, twoProng.pos.p, 1*scaleFactor, 'black', delay);
+// 	} else if (!twoProng.failed) {
+// 		$center = drawFs.dot   (g, twoProng.circle.center, 0.01*scaleFactor, 'yellow', delay);
+// 		$circle = drawFs.circle(g, twoProng.circle, color + 'thin' + thin + ' nofill', delay); 
+// 		$cp1    = drawFs.dot   (g, twoProng.pos.p, 0.0175*scaleFactor, color, delay);
+// 		$cp2    = drawFs.dot   (g, twoProng.z, 0.035*scaleFactor, color, delay);	
+// 	}
 	
-	return [...$failedDot, ...$center, ...$circle, ...$cp1, ...$cp2];	
-}
+// 	return [...$failedDot, ...$center, ...$circle, ...$cp1, ...$cp2];	
+// }
 
 
-export { twoProng }
+// export { twoProng }