flo-mat 3.0.9 → 3.0.11

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-branch-beziers.ts

@@ -9,7 +9,7 @@ import { getMatCurveToNext } from './get-mat-curve-to-next.js';
  * @param cpNode `CpNode` representing the start vertex.
  */
 function getBranchBeziers(
-		cpNode: CpNode): number[][][] {
+        cpNode: CpNode): number[][][] {
 
     return getBranch(cpNode).map(b => getMatCurveToNext(b));
 }

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

@@ -13,7 +13,7 @@ import { isTrivial } from './is-trivial.js';
  * @param cpNode `CpNode` representing the start vertex.
  */
 function getBranch(
-		cpNode: CpNode): CpNode[] {
+        cpNode: CpNode): CpNode[] {
 
     if (isTrivial(cpNode)) {
         return [];

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

@@ -2,16 +2,16 @@ import { CpNode } from "../cp-node.js";
 
 
 function getChildren(cpNode: CpNode) {
-	const children: CpNode[] = [];
+    const children: CpNode[] = [];
 
-	const cp = cpNode.next;
-	let cpNode_ = cp;
-	do {
-		children.push(cpNode_); 
-		cpNode_ = cpNode_.nextOnCircle;
-	} while (cpNode_.nextOnCircle !== cp);
+    const cp = cpNode.next;
+    let cpNode_ = cp;
+    do {
+        children.push(cpNode_); 
+        cpNode_ = cpNode_.nextOnCircle;
+    } while (cpNode_.nextOnCircle !== cp);
 
-	return children;
+    return children;
 }
 
 

package/src/cp-node/fs/get-first-exit.ts

@@ -2,20 +2,20 @@ import { CpNode } from "../cp-node.js";
 
 
 function getFirstExit(cpNode: CpNode) {
-	// const startNode = this as CpNode;
-	const startNode = cpNode;
-	let cpNode_ = startNode;
+    // const startNode = this as CpNode;
+    const startNode = cpNode;
+    let cpNode_ = startNode;
 
-	while (cpNode_.next === cpNode_.prevOnCircle) {
-		cpNode_ = cpNode_.next;
+    while (cpNode_.next === cpNode_.prevOnCircle) {
+        cpNode_ = cpNode_.next;
 
-		if (cpNode_ === startNode) {
-			// The very special case the MAT is a single point.
-			return undefined; 
-		}
-	}
+        if (cpNode_ === startNode) {
+            // The very special case the MAT is a single point.
+            return undefined; 
+        }
+    }
 
-	return cpNode_;
+    return cpNode_;
 }
 
 

package/src/cp-node/fs/get-mat-curve-to-next.ts

@@ -4,7 +4,7 @@ import { getMatCurveBetween } from './get-mat-curve-between.js';
 
 
 function getMatCurveToNext(cpNode: CpNode) {
-	return getMatCurveBetween(cpNode, cpNode.next);
+    return getMatCurveBetween(cpNode, cpNode.next);
 }
 
 

package/src/cp-node/fs/get-mat-curves-between.ts

@@ -9,7 +9,7 @@ function getMatCurvesBetween(
     let cpNode = cpNodeS;
     const pss: number[][][] = [];
     while (cpNode !== cpNodeE) {
-	    const ps = getMatCurveBetween(cpNode, cpNode.next);
+        const ps = getMatCurveBetween(cpNode, cpNode.next);
         pss.push(ps);
 
         cpNode = cpNode.next;

package/src/cp-node/fs/get-prong-count.ts

@@ -2,16 +2,16 @@ import { CpNode } from "../cp-node.js";
 
 
 function getProngCount(cpNode: CpNode) {
-	const startCpNode = cpNode;
-	let cpNode_ = startCpNode;
+    const startCpNode = cpNode;
+    let cpNode_ = startCpNode;
 
-	let i = 0;
-	do {
-		i++;
-		cpNode_ = cpNode_.nextOnCircle;
-	} while (cpNode_ !== startCpNode)
+    let i = 0;
+    do {
+        i++;
+        cpNode_ = cpNode_.nextOnCircle;
+    } while (cpNode_ !== startCpNode)
 
-	return i;
+    return i;
 }
 
 

package/src/cp-node/fs/get-real-prong-count.ts

@@ -4,10 +4,10 @@ import { isTerminating } from "./is-terminating.js";
 
 
 function getRealProngCount(cpNode: CpNode) {
-	const nonTerminatingCpNodes = getAllOnCircle(cpNode)
-	.filter(cpNode => !isTerminating(cpNode));
+    const nonTerminatingCpNodes = getAllOnCircle(cpNode)
+    .filter(cpNode => !isTerminating(cpNode));
 
-	return nonTerminatingCpNodes.length;
+    return nonTerminatingCpNodes.length;
 }
 
 

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/cp-node/fs/get-vertex-forward-children.ts

@@ -3,19 +3,19 @@ import { isTerminating } from "./is-terminating.js";
 
 
 function getVertexForwardChildren(cpNode: CpNode) {
-	const children: CpNode[] = [];
+    const children: CpNode[] = [];
 
-	const cpStart = cpNode;
+    const cpStart = cpNode;
 
-	let cpNode_ = cpStart;
-	while (cpNode_ !== cpStart.prevOnCircle) {
-		if (!isTerminating(cpNode_)) {
-			children.push(cpNode_.next);
-		}
-		cpNode_ = cpNode_.nextOnCircle;
-	}
+    let cpNode_ = cpStart;
+    while (cpNode_ !== cpStart.prevOnCircle) {
+        if (!isTerminating(cpNode_)) {
+            children.push(cpNode_.next);
+        }
+        cpNode_ = cpNode_.nextOnCircle;
+    }
 
-	return children;
+    return children;
 }
 
 

package/src/cp-node/fs/is-fully-terminating.ts

@@ -1,4 +1,4 @@
-import { CpNode } from "../cp-node.js";
+import type { CpNode } from "../cp-node.js";
 import { getAllOnCircle } from "./get-all-on-circle.js";
 import { isTerminating } from "./is-terminating.js";
 
@@ -11,9 +11,9 @@ import { isTerminating } from "./is-terminating.js";
  * @param cpNode 
  */
 function isFullyTerminating(cpNode: CpNode) {
-	const otherOnCircle = getAllOnCircle(cpNode.prevOnCircle, true);
+    const otherOnCircle = getAllOnCircle(cpNode.prevOnCircle, true);
 
-	return otherOnCircle.every(isTerminating);
+    return otherOnCircle.every(isTerminating);
 }
 
 

package/src/cp-node/fs/is-one-prong.ts

@@ -3,18 +3,18 @@ import { CpNode } from "../cp-node.js";
 
 // TODO2 - remove - or replace with `getRealProngCount === 1`
 function isOneProng(cpNode: CpNode) {
-	const cp1 = cpNode;
+    const cp1 = cpNode;
 
-	if (cp1.cp.circle.radius === 0) {
-		return true;
-	}
+    if (cp1.cp.circle.radius === 0) {
+        return true;
+    }
 
-	const cp2 = cp1.nextOnCircle;
+    const cp2 = cp1.nextOnCircle;
 
-	const p1 = cp1.cp.pointOnShape.p;
-	const p2 = cp2.cp.pointOnShape.p;
+    const p1 = cp1.cp.pointOnShape.p;
+    const p2 = cp2.cp.pointOnShape.p;
 
-	return (p1[0] === p2[0] && p1[1] === p2[1]);
+    return (p1[0] === p2[0] && p1[1] === p2[1]);
 }
 
 

package/src/cp-node/fs/is-sharp.ts

@@ -2,7 +2,7 @@ import { CpNode } from "../cp-node.js";
 
 
 function isSharp(cpNode: CpNode) {
-	return cpNode.cp.circle.radius === 0;
+    return cpNode.cp.circle.radius === 0;
 }
 
 

package/src/cp-node/fs/is-terminating.ts

@@ -2,7 +2,7 @@ import type { CpNode } from "../cp-node.js";
 
 
 function isTerminating(cpNode: CpNode) {
-	return cpNode === cpNode.next.prevOnCircle;
+    return cpNode === cpNode.next.prevOnCircle;
 }
 
 

package/src/cp-node/fs/iterate-all-on-loop.ts

@@ -2,13 +2,13 @@ import { CpNode } from "../cp-node.js";
 
 
 function* iterateAllOnLoop(cpNode: CpNode) {
-	yield cpNode;
+    yield cpNode;
 
-	let cpNode_ = cpNode.next;
-	while (cpNode_ !== cpNode) {
-		yield cpNode_;
-		cpNode_ = cpNode_.next;
-	}
+    let cpNode_ = cpNode.next;
+    while (cpNode_ !== cpNode) {
+        yield cpNode_;
+        cpNode_ = cpNode_.next;
+    }
 }
 
 

package/src/cp-node/fs/traverse-all-forward.ts

@@ -4,20 +4,20 @@ import { getChildren } from './get-children.js';
 
 
 function traverseAllForward(
-		cpNode: CpNode,
-		traverseEdgesCallback: (cpNode: CpNode) => void) {
+        cpNode: CpNode,
+        traverseEdgesCallback: (cpNode: CpNode) => void) {
 
-	// Since the tree is unrooted we must iterate in all directions from the
-	// given vertex.
-	const cps = [cpNode];
+    // Since the tree is unrooted we must iterate in all directions from the
+    // given vertex.
+    const cps = [cpNode];
 
-	while (cps.length) {
-		const cp = cps.pop()!;
-		traverseEdgesCallback(cp);
+    while (cps.length) {
+        const cp = cps.pop()!;
+        traverseEdgesCallback(cp);
 
-		if (isTerminating(cp)) { continue; }
-		cps.push(...getChildren(cp));
-	}
+        if (isTerminating(cp)) { continue; }
+        cps.push(...getChildren(cp));
+    }
 }
 
 

package/src/cp-node/fs/traverse-cp.ts

@@ -2,25 +2,27 @@ import { CpNode } from "../cp-node.js";
 import { isTerminating } from "./is-terminating.js";
 
 
-function traverseCp(cpStart: CpNode) {
-	let cpNode = cpStart;
+function traverseCp(
+        cpStart: CpNode) {
 
-	if (isTerminating(cpNode)) {
-		return [cpNode];  // one-sharp corner
-	}
+    let cpNode = cpStart;
 
-	const visitedCps: CpNode[] = [];
-	do {
-		visitedCps.push(cpNode);
-	
-		const next = cpNode.next.prevOnCircle;
-		cpNode = cpNode === next
-				? cpNode = cpNode.next.next // Terminal vertex
-				: cpNode = next         // Take last exit
-	
-	} while (cpNode !== cpStart); 
-	
-	return visitedCps;
+    if (isTerminating(cpNode)) {
+        return [cpNode];  // one-sharp corner
+    }
+
+    const visitedCps: CpNode[] = [];
+    do {
+        visitedCps.push(cpNode);
+    
+        const next = cpNode.next.prevOnCircle;
+        cpNode = cpNode === next
+                ? cpNode = cpNode.next.next // Terminal vertex
+                : cpNode = next         // Take last exit
+    
+    } while (cpNode !== cpStart); 
+    
+    return visitedCps;
 }
 
 

package/src/cp-node/fs/traverse-edges.ts

@@ -4,18 +4,18 @@ import { getAllOnLoop } from './get-all-on-loop.js';
 
 
 function traverseEdges(
-		cpNode: CpNode,
-		traverseEdgesCallback: (cpNode: CpNode) => void) {
+        cpNode: CpNode,
+        traverseEdgesCallback: (cpNode: CpNode) => void) {
 
-	const cpNodes = getAllOnLoop(cpNode);
-	const seen = new Set<CpNode>();
+    const cpNodes = getAllOnLoop(cpNode);
+    const seen = new Set<CpNode>();
 
-	for (cpNode of cpNodes) {
-		if (!isTerminating(cpNode) && !seen.has(cpNode.next.prevOnCircle)) {
-			traverseEdgesCallback(cpNode);
-		}
-		seen.add(cpNode);
-	}
+    for (cpNode of cpNodes) {
+        if (!isTerminating(cpNode) && !seen.has(cpNode.next.prevOnCircle)) {
+            traverseEdgesCallback(cpNode);
+        }
+        seen.add(cpNode);
+    }
 }
 
 

package/src/cp-node/fs/traverse-vertices.ts

@@ -6,26 +6,26 @@ import { getVertexForwardChildren } from './get-vertex-forward-children.js';
 
 
 function traverseVertices(
-		cpStart: CpNode, 
-		traverseVerticesCallback: (cpNode: CpNode) => void) {
+        cpStart: CpNode, 
+        traverseVerticesCallback: (cpNode: CpNode) => void) {
 
-	traverseVerticesCallback(cpStart);
+    traverseVerticesCallback(cpStart);
 
-	// Since the tree is unrooted we must iterate in all directions from the
-	// given cpNode.
-	const cpNodes = 
-		getAllOnCircle(cpStart)
-		.filter(cpNode => !isTerminating(cpNode))
-		.map(cpNode => cpNode.next);
+    // Since the tree is unrooted we must iterate in all directions from the
+    // given cpNode.
+    const cpNodes = 
+        getAllOnCircle(cpStart)
+        .filter(cpNode => !isTerminating(cpNode))
+        .map(cpNode => cpNode.next);
 
-	for (const cpNode of cpNodes) {
-		const cps = [cpNode];
-		while (cps.length) {
-			const cp = cps.pop()!;
-			traverseVerticesCallback(cp);
-			cps.push(...getVertexForwardChildren(cp));
-		}
-	}
+    for (const cpNode of cpNodes) {
+        const cps = [cpNode];
+        while (cps.length) {
+            const cp = cps.pop()!;
+            traverseVerticesCallback(cp);
+            cps.push(...getVertexForwardChildren(cp));
+        }
+    }
 }