flo-mat 3.0.0 → 3.0.2

package/src/cp-node/{clone.ts → fs/clone.ts}

@@ -1,5 +1,4 @@
-import { CpNode } from "./cp-node.js";
-import { createCpNode } from "./create-cp-node.js";
+import { CpNode } from "../cp-node.js";
 
 
 /** @internal */
@@ -13,6 +12,10 @@ type Edge =
 const EDGES: Edge[] = ['prev', 'next', 'prevOnCircle', 'nextOnCircle'];
 
 
+type CpNodeWithoutEdges = 
+    Omit<CpNode, 'prev' | 'next' | 'prevOnCircle' | 'nextOnCircle'>;
+
+
 /**
  * Returns a deep clone of this [[CpNode]]. Can be used to copy the MAT 
  * since cloning a single [[CpNode]] necessarily implies cloning all 
@@ -22,14 +25,9 @@ function clone(cpNode: CpNode): CpNode {
     // Don't change this function to be recursive, the call stack may 
     // overflow if there are too many CpNodes.
 
-    const nodeMap: Map<CpNode, CpNode> = new Map();
+    const nodeMap: Map<CpNode, CpNodeWithoutEdges> = new Map();
 
-    // const newCpNode = new CpNode(cpNode.cp, cpNode.isHoleClosing, cpNode.isIntersection);
-    const newCpNode = createCpNode(
-        cpNode.cp,
-        cpNode.isHoleClosing,
-        cpNode.isIntersection
-    );
+    const newCpNode: CpNodeWithoutEdges = cloneWithoutLinks(cpNode);
 
     nodeMap.set(cpNode, newCpNode);
     const cpStack = [{ cpNode, newCpNode }];
@@ -41,21 +39,33 @@ function clone(cpNode: CpNode): CpNode {
             const node = cpNode[edge];
             let newNode = nodeMap.get(node);
             if (!newNode) {	
-                // newNode = new CpNode(node.cp, node.isHoleClosing, node.isIntersection);
-                newNode = createCpNode(
-                    node.cp,
-                    node.isHoleClosing,
-                    node.isIntersection,
-                );
+                newNode = cloneWithoutLinks(node);
+                
                 nodeMap.set(node, newNode);
                 cpStack.push({cpNode: node, newCpNode: newNode });
             }
-            newCpNode[edge] = newNode;
+            (newCpNode as CpNode)[edge] = newNode as CpNode;
         }
     }
 
-    return newCpNode;
+    return newCpNode as CpNode;
+}
+
+
+function cloneWithoutLinks(cpNode: CpNode) {
+    const newNode = {
+        ...cpNode,
+        ...{
+            prev: undefined,
+            next: undefined,
+            prevOnCircle: undefined,
+            nextOnCircle: undefined
+        }
+    };
+
+    return newNode;
 }
 
 
 export { clone }
+

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

@@ -0,0 +1,10 @@
+import { CpNode } from "../cp-node.js";
+import { getBoundaryBeziersToNext } from "./get-boundary-beziers-to-next.js";
+
+
+function cpNodesToBoundaryBeziers(cpNodes: CpNode[]) {
+    return cpNodes.flatMap(getBoundaryBeziersToNext)
+}
+
+
+export { cpNodesToBoundaryBeziers }

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

@@ -0,0 +1,21 @@
+// import { ContactPoint } from '../../contact-point/contact-point.js';
+// import { CpNode } from '../cp-node.js';
+
+
+// function createCpNode(
+//         cp: ContactPoint,
+//         isHoleClosing  : boolean,
+//         isIntersection : boolean,
+//         prev           : CpNode = undefined!,
+//         next           : CpNode = undefined!,
+//         prevOnCircle   : CpNode = undefined!,
+//         nextOnCircle   : CpNode = undefined!): CpNode {
+
+//     return {
+//         cp, isHoleClosing, isIntersection,
+//         prev, next, prevOnCircle, nextOnCircle
+//     }
+// }
+
+
+// export { createCpNode }

package/src/cp-node/{enhance-cp-node.ts → fs/enhance-cp-node.ts}

@@ -1,8 +1,11 @@
-import {
-    CpNode, getProngCount, getRealProngCount, isFullyTerminating,
-    isSharp, isTerminating
-} from "./cp-node.js";
+import { CpNode } from "../cp-node.js";
 import { getCpNodeOrdering } from './get-cp-node-ordering.js';
+import { CpNodeFs } from '../cp-node-fs.js';
+import { getProngCount } from './get-prong-count.js';
+import { getRealProngCount } from "./get-real-prong-count.js";
+import { isFullyTerminating } from "./is-fully-terminating.js";
+import { isSharp } from "./is-sharp.js";
+import { isTerminating } from "./is-terminating.js";
 
 
 function enhanceCpNode(cpNode: CpNode) {
@@ -12,6 +15,9 @@ function enhanceCpNode(cpNode: CpNode) {
 
     return {
         ...cpNode,
+        pos: cpNode.cp.pointOnShape,
+        p: cpNode.cp.pointOnShape.p,
+        t: cpNode.cp.pointOnShape.t,
         isTerminating: isTerminating(cpNode),
         isFullyTerminating: isFullyTerminating(cpNode),
         isSharp: isSharp(cpNode),

package/src/cp-node/fs/find-first.ts

@@ -0,0 +1,25 @@
+import { CpNode } from "../cp-node.js";
+import { CpNodeFs } from "../cp-node-fs.js";
+
+
+function findFirst(
+        f: (cpNode: CpNode) => CpNode | undefined,
+        cpNode: CpNode): CpNode | undefined { 
+
+    const cpStart = cpNode;
+
+    if (f(cpStart)) { return cpStart; }
+
+	let cpNode_ = cpNode.next;
+	while (cpNode_ !== cpStart) {
+		if (f(cpNode_)) {
+            return cpNode_;
+        }
+		cpNode_ = cpNode_.next;
+	}
+
+	return undefined;
+}
+
+
+export { findFirst }

package/src/cp-node/fs/get-all-between.ts

@@ -0,0 +1,44 @@
+import { CpNode } from "../cp-node.js";
+
+
+/**
+ * Returns all `CpNode`s between the two given ones (exclisive the last one).
+ * 
+ * * If the second `CpNode` is never encountered all on the loop will be
+ * returned.
+ * 
+ * @param cpNodeS 
+ * @param cpNodeE 
+ * @param inclAllIfEqual if `true` and first and last `CpNode`s are equal then
+ * include all `CpNode`s around the loop, otherwise include none.
+ */
+function getAllBetween(
+		cpNodeS: CpNode,
+		cpNodeE: CpNode,
+		inclAllIfEqual = true) {
+
+	if (!inclAllIfEqual && cpNodeS === cpNodeE) {
+		return { cpNodes: [], hasHoleCloser: false }
+	}
+
+	const cpStart = cpNodeS;
+	const cpNodes: CpNode[] = [cpStart];
+
+	let cpNode_ = cpNodeS.next;
+	let hasHoleCloser = cpStart.isHoleClosing;
+
+	while (cpNode_ !== cpNodeE &&
+		   cpNode_ !== cpStart) {
+
+		if (cpNode_.isHoleClosing) {
+			hasHoleCloser = true;
+		}
+		cpNodes.push(cpNode_);
+		cpNode_ = cpNode_.next;
+	}
+
+	return { cpNodes, hasHoleCloser };
+}
+
+
+export { getAllBetween }

package/src/cp-node/fs/get-all-on-circle.ts

@@ -0,0 +1,23 @@
+import { CpNode } from "../cp-node.js";
+
+
+function getAllOnCircle(
+        cpNode: CpNode,
+        exclThis = false) {
+
+    const startCpNode = cpNode;
+    let cpNode_ = startCpNode;
+
+    const cpNodes: CpNode[] = [];
+    do {
+        if (!(exclThis && cpNode_ === startCpNode)) {
+            cpNodes.push(cpNode_);
+        }
+        cpNode_ = cpNode_.nextOnCircle;
+    } while (cpNode_ !== startCpNode)
+
+    return cpNodes;
+}
+
+
+export { getAllOnCircle }

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

@@ -0,0 +1,18 @@
+import { CpNode } from "../cp-node.js";
+
+
+function getAllOnLoop(cpNode: CpNode) {
+	const cpStart = cpNode;
+	const cpNodes: CpNode[] = [cpStart];
+	let cpNode_ = cpNode.next;
+
+	while (cpNode_ !== cpStart) {
+		cpNodes.push(cpNode_);
+		cpNode_ = cpNode_.next;
+	}
+
+	return cpNodes;
+}
+
+
+export { getAllOnLoop }

package/src/cp-node/fs/get-all-vertices.ts

@@ -0,0 +1,17 @@
+import { CpNode } from "../cp-node.js";
+import { traverseVertices } from "./traverse-vertices.js";
+
+
+function getAllVertices(
+        cpNode: CpNode) {
+
+    const vertices: CpNode[] = [];
+    traverseVertices(cpNode, cpNode => {
+        vertices.push(cpNode);
+    });
+
+    return vertices;
+}
+
+
+export { getAllVertices }

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

@@ -0,0 +1,33 @@
+import { tangent } from "flo-bezier3";
+import { cross, toUnitVector } from "flo-vector2d";
+import { CpNode } from "../cp-node.js";
+import { getMatCurveToNext } from "./get-mat-curve-to-next.js";
+
+
+/**
+ * 
+ * @param cpNode1 
+ * @param cpNode2 
+ * @returns 
+ */
+function getInitialDegAngleBetweenMatCurves(
+        cpNode1: CpNode,
+        cpNode2: CpNode) {
+
+    const tan1 = toUnitVector(tangent(
+        getMatCurveToNext(cpNode1), 
+        0
+    ));
+    const tan2 = toUnitVector(tangent(
+        getMatCurveToNext(cpNode2), 
+        0
+    ));
+
+    const cross_ = cross(tan1, tan2);
+    const angle = Math.abs(Math.asin( cross_ ) * (180/Math.PI));
+
+    return angle;
+}
+
+
+export { getInitialDegAngleBetweenMatCurves }

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

@@ -0,0 +1,31 @@
+import { totalAbsoluteCurvature, totalLength } from "flo-bezier3";
+import { memoize } from "flo-memoize";
+import { totalCurvature$ } from "../../bezier/total-curvature.js";
+import { CpNode } from "../cp-node.js";
+import { getMatCurveToNext } from "./get-mat-curve-to-next.js";
+import { getRealProngCount } from "./get-real-prong-count.js";
+
+const { min, abs } = Math;
+
+
+const getAvgSpeed$ = memoize(getAvgSpeed);
+
+
+function getAvgSpeed(cpNode: CpNode): number | undefined {
+    if (getRealProngCount(cpNode) !== 2) {
+        return 0;
+    }
+
+    const { radius: r } = cpNode.cp.circle;
+    const matPs = getMatCurveToNext(cpNode);
+    const T = totalCurvature$(matPs);
+    const l = totalLength(matPs);
+    if (l === 0) {
+        return undefined;
+    }
+    
+    return -r*T/l;
+}
+
+
+export { getAvgSpeed, getAvgSpeed$ }

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

@@ -1,13 +1,8 @@
 import { BezierPiece } from 'flo-bezier3';
-import { CpNode } from './cp-node.js';
-import { Curve  } from '../curve/curve.js';
+import { CpNode } from '../cp-node.js';
+import { Curve  } from '../../curve/curve.js';
 
 
-/**
- * Returns the ordered bezier curves from this CpNode to the next CpNode 
- * on the boundary.
- * @param cpNode
- */
 function getBoundaryBezierPartsToNext(cpNode: CpNode): BezierPiece[] {
     const cpThis = cpNode; 
     const cpNext = cpNode.next;
@@ -66,8 +61,6 @@ function addSkippedBeziers(
 
         bezierParts.push(bezierPart);
     } while (curveThis !== curveEnd);
-
-
 }
 
 

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

@@ -0,0 +1,31 @@
+import { CpNode } from "../cp-node.js";
+import { cpNodesToBoundaryBeziers } from "./cp-nodes-to-boundary-beziers.js";
+import { getAllBetween } from "./get-all-between.js";
+
+
+/**
+ * Returns all `CpNode`s between the two given ones (inclusive).
+ * 
+ * * If the second `CpNode` is never encountered all on the loop will be
+ * returned.
+ * 
+ * @param cpNode1 
+ * @param cpNode2 
+ * @param inclAllIfEqual if `true` and first and last `CpNode`s are equal then
+ * include all `CpNode`s around the loop, otherwise include none.
+ */
+function getBoundaryBeziersBetween(
+        cpNode1: CpNode,
+        cpNode2: CpNode,
+        inclAllIfEqual = true) {
+
+    const allBetween = getAllBetween(cpNode1,cpNode2,inclAllIfEqual);
+
+    return {
+        pss: cpNodesToBoundaryBeziers(allBetween.cpNodes),
+        hasHoleCloser: allBetween.hasHoleCloser
+    }
+}
+
+
+export { getBoundaryBeziersBetween }

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

@@ -1,15 +1,9 @@
-// qqq import { fromTo, fromTTo1, from0ToT } from 'flo-bezier3';
 import { fromTo } from 'flo-bezier3';
-import { CpNode } from './cp-node.js';
-import { Curve  } from '../curve/curve.js';
+import { CpNode } from '../cp-node.js';
+import { Curve  } from '../../curve/curve.js';
 
 
-/**
- * Returns the ordered bezier curves from this CpNode to the next CpNode 
- * on the boundary.
- * @param cpNode
- */
-function getBoundaryBeziersToNext(cpNode: CpNode) {
+function getBoundaryBeziersToNext(cpNode: CpNode): number[][][] {
     const cpThis = cpNode; 
     const cpNext = cpNode.next;
 
@@ -22,7 +16,8 @@ function getBoundaryBeziersToNext(cpNode: CpNode) {
     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 beziers = [];

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

@@ -0,0 +1,16 @@
+import { totalLength } from "flo-bezier3";
+import { sum } from "../../utils/sum.js";
+import { CpNode } from "../cp-node.js";
+import { getBoundaryBeziersBetween } from "./get-boundary-beziers-between.js";
+
+
+function getBoundaryDistanceToNext(
+        cpNode: CpNode) {
+    
+    const { pss } = getBoundaryBeziersBetween(cpNode, cpNode.next);
+
+    return sum(pss.map(ps => totalLength(ps)));
+}
+
+
+export { getBoundaryDistanceToNext }

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

@@ -0,0 +1,18 @@
+import { CpNode } from '../cp-node.js';
+import { getBranch } from './get-branch.js';
+import { getMatCurveToNext } from './get-mat-curve-to-next.js';
+
+
+/**
+ * Returns the branch associated with the give cpNode
+ * 
+ * @param cpNode `CpNode` representing the start vertex.
+ */
+function getBranchBeziers(
+		cpNode: CpNode): number[][][] {
+
+    return getBranch(cpNode).map(b => getMatCurveToNext(b));
+}
+
+
+export { getBranchBeziers }

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

@@ -0,0 +1,43 @@
+import { CpNode } from '../cp-node.js';
+import { getRealProngCount } from './get-real-prong-count.js';
+import { isFullyTerminating } from './is-fully-terminating.js';
+import { isTerminating } from './is-terminating.js';
+import { isTrivial } from './is-trivial.js';
+
+
+/**
+ * Returns the branch associated with the give cpNode.
+ * 
+ * * the final `CpNode` is not returned to improve symmetry
+ * 
+ * @param cpNode `CpNode` representing the start vertex.
+ */
+function getBranch(
+		cpNode: CpNode): CpNode[] {
+
+    if (isTrivial(cpNode)) {
+        return [];
+    }
+
+    // Start from a leaf or 3-prong
+    while (isTerminating(cpNode)) {
+        cpNode = cpNode.nextOnCircle;
+    }
+
+    cpNode = cpNode.next;
+    while (getRealProngCount(cpNode) === 2) {
+        cpNode = cpNode.next;
+    }
+    cpNode = cpNode.prevOnCircle;
+
+    const branch: CpNode[] = [];
+    do {
+        branch.push(cpNode);
+        cpNode = cpNode.next;
+    } while (!isFullyTerminating(cpNode) && getRealProngCount(cpNode) === 2)
+
+    return branch;
+}
+
+
+export { getBranch }

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

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

package/src/cp-node/{get-cp-node-ordering.ts → fs/get-cp-node-ordering.ts}

@@ -1,6 +1,10 @@
-import { CpNode } from './cp-node.js';
+import { CpNode } from '../cp-node.js';
 
 
+/**
+ * For debugging.
+ * @param cpNode 
+ */
 function getCpNodeOrdering(cpNode: CpNode) {
     const cp = cpNode.cp;
     const pos = cp.pointOnShape;

package/src/cp-node/fs/get-distance-between.ts

@@ -0,0 +1,16 @@
+import { CpNode } from "../cp-node.js";
+import { getMatDistanceToNext$ } from "./get-distance-to-next.js";
+
+
+// const dMap = new WeakMap<CpNode>
+
+function getDistanceBetween(
+        a: CpNode,
+        b: CpNode) {
+
+    const d = getMatDistanceToNext$(a);
+
+}
+
+
+export { getDistanceBetween }

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

@@ -0,0 +1,19 @@
+import { totalLength } from "flo-bezier3";
+import { memoize } from "flo-memoize";
+import { CpNode } from "../cp-node.js";
+import { getMatCurveToNext } from "./get-mat-curve-to-next.js";
+
+
+function getMatDistanceToNext(
+        cpNode: CpNode) {
+
+    const ps = getMatCurveToNext(cpNode);
+    const l = totalLength(ps);
+
+    return l;
+}
+
+
+const getMatDistanceToNext$ = memoize(getMatDistanceToNext)
+
+export { getMatDistanceToNext, getMatDistanceToNext$ }

package/src/cp-node/fs/get-edge-direction.ts

@@ -0,0 +1,64 @@
+import { 
+    toUnitVector, fromTo, rotate, translate, rotate90Degrees, reverse, dot
+} from 'flo-vector2d';
+import { tangent } from 'flo-bezier3';
+import { CpNode } from '../cp-node.js';
+import { isPosSharpCorner } from '../../point-on-shape/is-pos-sharp-corner.js';
+import { Curve } from '../../curve/curve.js';
+
+
+function getEdgeDirection(cpNode: CpNode) {
+    const circleCenter = cpNode.cp.circle.center;
+
+    const cp1 = cpNode;
+    const cp2 = cpNode.nextOnCircle;
+
+    const pos1 = cp1.cp.pointOnShape;
+    const pos2 = cp2.cp.pointOnShape;
+
+    const p1 = pos1.p;
+    const p2 = pos2.p;
+
+    let vDir;
+    
+    if (!isPosSharpCorner(pos1)) {
+        if (p1[0] === p2[0] && p1[1] === p2[1]) {
+            vDir = fromTo(p1, circleCenter); // A 1-prong
+        } else {
+            vDir = rotate90Degrees( fromTo(p1, p2) ); // not a 1-prong.
+        }
+    } else {
+        let curve1: Curve;
+        let curve2: Curve;
+
+        if (pos1.t === 0) {
+            curve1 = pos1.curve;
+            curve2 = pos1.curve.prev;
+        } else if (pos1.t === 1) {
+            curve1 = pos1.curve.next; 
+            curve2 = pos1.curve;
+        }
+
+        const tan1 = toUnitVector(tangent(curve1!.ps, 0));
+        const tan2 = reverse( toUnitVector(tangent(curve2!.ps, 1)) );
+        
+        const x = dot(tan1, tan2);
+        // Recall the identities sin(acos(x)) = sqrt(1-x^2), etc. Also 
+        // recall the half angle formulas. Then the rotation matrix, R, can 
+        // be calculated.
+        const cosθ = Math.sqrt((1 + x)/2);
+        const sinθ = Math.sqrt((1 - x)/2);
+        
+        vDir = rotate(sinθ, cosθ, tan2);
+    }
+
+    const v = translate(
+        toUnitVector(vDir),
+        circleCenter 
+    );
+
+    return [circleCenter, v];
+}
+
+
+export { getEdgeDirection }

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

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

package/src/cp-node/fs/get-hole-closers.ts

@@ -0,0 +1,13 @@
+import { CpNode } from "../cp-node.js";
+import { getAllOnLoop } from "./get-all-on-loop.js";
+
+
+function getHoleClosers(
+        cpNode: CpNode) {
+
+    return getAllOnLoop(cpNode)
+    .filter(cpNode => cpNode.isHoleClosing);
+}
+
+
+export { getHoleClosers }