flo-mat 3.0.6 → 3.0.9

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

@@ -1,9 +1,20 @@
-import { BezierPiece } from 'flo-bezier3';
-import { CpNode } from '../cp-node.js';
-import { Curve  } from '../../curve/curve.js';
+import type { BezierPiece } from 'flo-bezier3';
+import type { CpNode } from '../cp-node.js';
+import type { Curve  } from '../../curve/curve.js';
 
 
-function getBoundaryBezierPartsToNext(cpNode: CpNode): BezierPiece[] {
+/**
+ * Returns the boundary beziers pieces between this `CpNode` and the next
+ * one.
+ * 
+ * * returns `undefined` 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 getBoundaryBezierPartsToNext(
+        cpNode: CpNode): BezierPiece[] | undefined {
+
     const cpThis = cpNode; 
     const cpNext = cpNode.next;
 
@@ -16,29 +27,35 @@ function getBoundaryBezierPartsToNext(cpNode: CpNode): BezierPiece[] {
     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;
     }
     
-    const bezierParts: BezierPiece[] = [];
+    const bezierPieces: BezierPiece[] = [];
 
     if (curveNext === curveThis) {
-        bezierParts.push(
-            { ps: posThis.curve.ps, ts: [posThis.t, posNext.t] }
+        bezierPieces.push(
+            {
+                ps: posThis.curve.ps,
+                ts: [posThis.t, posNext.t]
+            }
         );
     } else {
-        bezierParts.push(
-            { ps: posThis.curve.ps, ts: [posThis.t, 1] }
+        bezierPieces.push(
+            {
+                ps: posThis.curve.ps,
+                ts: [posThis.t, 1]
+            }
         );
         
         addSkippedBeziers(
-                bezierParts,
-                posThis.curve, 
-                posNext.curve,
-                posNext.t
+            bezierPieces,
+            posThis.curve,
+            posNext.curve,
+            posNext.t
         );
-    }				
-        
-    return bezierParts;
+    }
+
+    return bezierPieces;
 }
 
 
@@ -47,10 +64,10 @@ function getBoundaryBezierPartsToNext(cpNode: CpNode): BezierPiece[] {
  * Adds pieces of skipped beziers.
  */
 function addSkippedBeziers(
-        bezierParts: { ps: number[][]; ts: number[] }[], 
-        curveStart : Curve, 
-        curveEnd   : Curve, 
-        t1         : number) {
+        bezierPieces: BezierPiece[],
+        curveStart: Curve,
+        curveEnd: Curve,
+        t1: number) {
 
     let curveThis = curveStart;
     do {
@@ -59,7 +76,7 @@ function addSkippedBeziers(
             ? { ps: curveThis.ps, ts: [0, t1] }
             : { ps: curveThis.ps, ts: [0, 1] }
 
-        bezierParts.push(bezierPart);
+        bezierPieces.push(bezierPart);
     } while (curveThis !== curveEnd);
 }
 

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

@@ -1,4 +1,5 @@
-import { CpNode } from "../cp-node.js";
+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";
 
@@ -17,7 +18,10 @@ import { getAllBetween } from "./get-all-between.js";
 function getBoundaryBeziersBetween(
         cpNode1: CpNode,
         cpNode2: CpNode,
-        inclAllIfEqual = true) {
+        inclAllIfEqual = true): {
+            pss: number[][][],
+            hasHoleCloser: boolean
+        } {
 
     const allBetween = getAllBetween(cpNode1,cpNode2,inclAllIfEqual);
 

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

@@ -3,7 +3,9 @@ import { CpNode } from '../cp-node.js';
 import { Curve  } from '../../curve/curve.js';
 
 
-function getBoundaryBeziersToNext(cpNode: CpNode): number[][][] {
+function getBoundaryBeziersToNext(
+        cpNode: CpNode): number[][][] {
+
     const cpThis = cpNode; 
     const cpNext = cpNode.next;
 
@@ -19,7 +21,7 @@ function getBoundaryBeziersToNext(cpNode: CpNode): number[][][] {
         // return undefined!;
         return [];
     }
-    
+
     const beziers = [];
 
     if (curveNext === curveThis) {
@@ -37,8 +39,8 @@ function getBoundaryBeziersToNext(cpNode: CpNode): number[][][] {
                 posNext.curve,
                 posNext.t
         );
-    }				
-        
+    }
+
     return beziers;
 }
 

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

@@ -10,7 +10,8 @@ function insertCpNode(
         isIntersection: boolean,
         cpTree: LlRbTree<CpNode>,
         cp: ContactPoint, 
-        _prev: CpNode | undefined) {
+        _prev: CpNode | undefined,
+        lastInsertId: { id: number }): CpNode | undefined {
 
     if (_prev !== undefined &&
         !isOrderCorrect(cpTree, cp, _prev.next)) {
@@ -21,7 +22,17 @@ function insertCpNode(
         }
     }
 
-    const cpNode = { cp, isHoleClosing, isIntersection } as CpNode;
+    const cpNode: CpNode = {
+        cp,
+        isHoleClosing,
+        isIntersection,
+        id: lastInsertId.id,
+        next: undefined!,
+        prev: undefined!,
+        nextOnCircle: undefined!,
+        prevOnCircle: undefined!
+    };
+    lastInsertId.id++;
 
     const prev = _prev === undefined ? cpNode : _prev;
     const next = _prev === undefined ? cpNode : prev.next;

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

@@ -3,6 +3,13 @@ import { getAllOnCircle } from "./get-all-on-circle.js";
 import { isTerminating } from "./is-terminating.js";
 
 
+/**
+ * Returns `true` if this `CpNode` is fully terminating, meaning that all
+ * `CpNode`s (except `CpNode.prevOnCircle`) on the same circle are terminating,
+ * `false` otherwise.
+ * 
+ * @param cpNode 
+ */
 function isFullyTerminating(cpNode: CpNode) {
 	const otherOnCircle = getAllOnCircle(cpNode.prevOnCircle, true);
 

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

@@ -1,4 +1,4 @@
-import { CpNode } from "../cp-node.js";
+import type { CpNode } from "../cp-node.js";
 
 
 function isTerminating(cpNode: CpNode) {

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

@@ -1,11 +1,15 @@
-import { Loop } from 'flo-boolean';
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { CpNode } from "../cp-node.js";
+// import { Loop } from 'flo-boolean';
+// import { LlRbTree } from 'flo-ll-rb-tree';
+import type { CpNode } from "../cp-node.js";
+import type { MatMeta } from '../../mat/mat-meta.js';
 
 
 function removeCpNode(
         cpNode: CpNode,
-        cpTrees: Map<Loop, LlRbTree<CpNode>>): void {
+        meta: MatMeta): void {
+        // cpTrees: Map<Loop, LlRbTree<CpNode>>): void {
+
+    const { cpTrees } = meta;
 
     const prev = cpNode.prev;
     const next = cpNode.next;

package/src/curve/curve.ts

@@ -5,25 +5,31 @@ import { Loop } from 'flo-boolean';
  * Represents a bezier curve on the shape boundary / loop.
  */
 interface Curve {
-
-	/** 
-	 * Primarily for internal use.
-	 * @param loop The closed loop of bezier curves representing the shape 
+	/**
+	 * The closed loop of bezier curves representing the shape 
 	 * boundary this curve belongs to.
-	 * @param ps The bezier control points.
-	 * @param prev 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)).
-	 * @param next 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)).
-	 * @param idx The curve's ordered index in the loop. This imposes a cycling
-	 * ordering of the curves in the loop.
 	 */
 	loop : Loop;
+	/**
+	 * The bezier control points.
+	 */
 	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; 
+	/**
+	 * 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;
+	/**
+	 * The curve's ordered index in the loop. This imposes a cycling
+	 * ordering of the curves in the loop
+	 */
 	idx  : number;
 }
 

package/src/debug/functions/check-ordering.ts

@@ -1,5 +1,6 @@
-import { Loop } from "flo-boolean";
-import { LlRbTree } from "flo-ll-rb-tree";
+import type { Loop } from "flo-boolean";
+import type { LlRbTree } from "flo-ll-rb-tree";
+import type { MatMeta } from "../../mat/mat-meta.js";
 import { compareCps } from "../../contact-point/contact-point.js";
 import { CpNode } from "../../cp-node/cp-node.js";
 import { getAllOnLoop } from "../../cp-node/fs/get-all-on-loop.js";
@@ -8,9 +9,12 @@ import { isOrderCorrect } from "../../cp-node/fs/is-order-correct.js";
 
 
 function checkOrdering(
-        cpTrees: Map<Loop,LlRbTree<CpNode>>,
+        // cpTrees: Map<Loop,LlRbTree<CpNode>>,
+        meta: MatMeta,
         cpStart: CpNode) {
 
+    const { cpTrees } = meta;
+
     const cpNodes = getAllOnLoop(cpStart);
 
     const wrongsPerLoop: Map<Loop,[Order,Order][]> = new Map();

package/src/find-2-prong/add-1-prong.ts

@@ -50,7 +50,7 @@ function add1Prong(
 		return;
 	}
 
-    const { anyFailed, cpNodes } = addToCpTree(false, false, circle, [-0.5, +0.5], meta.cpTrees, [pos, pos]); 
+    const { anyFailed, cpNodes } = addToCpTree(false, false, circle, [-0.5, +0.5], meta, [pos, pos]); 
 	
 	// if (typeof _debug_ !== 'undefined') { 
     //     _debug_.generated.elems.oneProng.push(cpNodes);

package/src/find-2-prong/add-2-prong.ts

@@ -25,85 +25,90 @@ import { removeCpNode } from '../cp-node/fs/remove-cp-node.js';
  * tolerances.
  */
 function add2Prong(
-		meta: MatMeta,
+        meta: MatMeta,
         circle: Circle,
-		poss: PointOnShape[],
-		isHoleClosing: boolean): CpNode | undefined {
-
-	const { cpTrees } = meta;
-
-	poss[0] = poss[0].t === 0
-		? createPos(poss[0].curve.prev, 1, true)
-		: poss[0];
-
-	const orders = poss.map(pos => calcPosOrder(circle, pos));
-
-	// Make sure there isn't already a ContactPoint close by - it can cause
-	// floating point stability issues.
-	for (let i=0; i<poss.length; i++) {
-		if (!!getCloseByCpIfExist(meta, poss[i], circle, orders[i], 0, 2)) {
-			return undefined;
-		}
-	}
-
-	const { anyFailed, cpNodes } = addToCpTree(isHoleClosing, isHoleClosing, circle, orders, cpTrees, poss);
-
-	if (anyFailed) {
-		cpNodes.forEach(cpNode => {
-			if (cpNode !== undefined) {
-				removeCpNode(cpNode, cpTrees);
-			}
-		});
-		return undefined;
-	}
-
-	// Get points ordered according to their angle with the x-axis
-	// joinSpokes(circle, cpNodes);
-
-	if (isHoleClosing) { 
-		closeHole(cpTrees, cpNodes as CpNode[]);
-	}
-
-	return cpNodes[0];  // return the source `CpNode`
+        poss: PointOnShape[],
+        isHoleClosing: boolean): CpNode | undefined {
+
+    poss[0] = poss[0].t === 0
+        ? createPos(poss[0].curve.prev, 1, true)
+        : poss[0];
+
+    const orders = poss.map(pos => calcPosOrder(circle, pos));
+
+    // Make sure there isn't already a ContactPoint close by - it can cause
+    // floating point stability issues.
+    for (let i=0; i<poss.length; i++) {
+        if (!!getCloseByCpIfExist(meta, poss[i], circle, orders[i], 0, 2)) {
+            return undefined;
+        }
+    }
+
+    const { anyFailed, cpNodes } = addToCpTree(
+        isHoleClosing, isHoleClosing, circle, orders, meta, poss
+    );
+
+    if (anyFailed) {
+        cpNodes.forEach(cpNode => {
+            if (cpNode !== undefined) {
+                removeCpNode(cpNode, meta);
+            }
+        });
+        return undefined;
+    }
+
+    // Get points ordered according to their angle with the x-axis
+    // joinSpokes(circle, cpNodes);
+
+    if (isHoleClosing) { 
+        closeHole(meta, cpNodes as CpNode[]);
+    }
+
+    return cpNodes[0];  // return the source `CpNode`
 }
 
 
 function closeHole(
-		cpTrees: Map<Loop, LlRbTree<CpNode>>,
-		cpNodes: CpNode[]) {
-
-	const [cpNodeA, cpNodeB] = cpNodes;
-	// Duplicate ContactPoints
-	// const antipodeCpNode = cpNodeB[0];
-	const cpAntipode = cpNodeB.cp;
-
-	const cpNodeB2 = insertCpNode(
-		true,
-		true, false,
-		cpTrees.get(cpAntipode.pointOnShape.curve.loop)!,
-		{ ...cpAntipode, order2: +1 },
-		cpNodeB
-	)!;
-
-	const cpNodeB1 = insertCpNode(
-		true,
-		true, false,
-		cpTrees.get(cpNodeA.cp.pointOnShape.curve.loop)!,
-		{ ...cpNodeA.cp, order2: -1 },
-		cpNodeA.prev
-	)!;
-
-	// Connect graph
-	cpNodeB1.prevOnCircle = cpNodeB2;
-	cpNodeB1.nextOnCircle = cpNodeB2;
-	cpNodeB2.prevOnCircle = cpNodeB1;
-	cpNodeB2.nextOnCircle = cpNodeB1;
-
-	cpNodeB.next = cpNodeA;
-	cpNodeA.prev = cpNodeB;
-
-	cpNodeB1.next = cpNodeB2;
-	cpNodeB2.prev = cpNodeB1;
+        meta: MatMeta,
+        // cpTrees: Map<Loop, LlRbTree<CpNode>>,
+        cpNodes: CpNode[]) {
+
+    const { cpTrees } = meta;
+
+    const [cpNodeA, cpNodeB] = cpNodes;
+    // Duplicate ContactPoints
+    // const antipodeCpNode = cpNodeB[0];
+    const cpAntipode = cpNodeB.cp;
+
+    const cpNodeB2 = insertCpNode(
+        true,
+        true, false,
+        cpTrees.get(cpAntipode.pointOnShape.curve.loop)!,
+        { ...cpAntipode, order2: +1 },
+        cpNodeB,
+        meta.lastInsertId
+    )!;
+
+    const cpNodeB1 = insertCpNode(
+        true,
+        true, false,
+        cpTrees.get(cpNodeA.cp.pointOnShape.curve.loop)!,
+        { ...cpNodeA.cp, order2: -1 },
+        cpNodeA.prev,
+        meta.lastInsertId
+    )!;
+
+    // Connect graph
+    cpNodeB1.prevOnCircle = cpNodeB2;
+    cpNodeB1.nextOnCircle = cpNodeB2;
+    cpNodeB2.prevOnCircle = cpNodeB1;
+    cpNodeB2.nextOnCircle = cpNodeB1;
+
+    cpNodeB.next = cpNodeA;
+    cpNodeA.prev = cpNodeB;
+
+    cpNodeB1.next = cpNodeB2;
+    cpNodeB2.prev = cpNodeB1;
 }
 
 

package/src/find-2-prong/calc-seperation-tolerance.ts

@@ -18,52 +18,6 @@ const { asin, acos, cos, sqrt, PI: π } = Math;
  * @param r radius of the MAT circle
  * @param θ angle between point...
  */
-function calcSeperationTolerance2(
-        R: number,
-        r: number,
-        δ: number) {
-
-    const a = r + δ;
-    if (a >= R) {
-        return Number.POSITIVE_INFINITY;
-    }
-
-    const b = R - r;  //?
-    const c = R;      //?
-    
-    const N = c*c - a*a - b*b;  //?
-    const N_ = qdq(qdq(tp(c,c), tp(a,a)), tp(b,b));
-    const D = 2*a*b;            //?
-    const D_ = tp(-2*a,b);
-    const Q = ddDivDd(N_,D_)[1];  //?
-    const cosC = -N/D;  //?
-    const C = acos(cosC);
-    const CC = acos(Q);
-
-    const θ = π - CC;  //?
-
-    return θ;
-    // return r*θ;  // approximate arc with line
-}
-
-
-export { calcSeperationTolerance }
-
-function degToRad(degrees: number) {
-    return degrees/360*2*Math.PI;
-}
-function radToDeg(rad: number) {
-    return rad*360/2/Math.PI;
-}
-
-
-const R = 699;
-const r = 698;
-const δ = 1000*2**-46; //?
-calcSeperationTolerance(R,r,δ);   //?
-calcSeperationTolerance2(R,r,δ);  //?
-calcSeperationTolerance3(R,r,δ);  //?
-
 function calcSeperationTolerance(
         R: number,
         r: number,
@@ -75,47 +29,103 @@ function calcSeperationTolerance(
     }
 
 
-    const R_r_ = twoDiff(R,r);  //?
-    const A_  = qmd(r,R_r_);    //?
-    const N_ = qdq(qdq(A_, tp(r,δ)), tp(δ,δ/2));  //?
-    const D_ = qaq(A_,qmd(δ,R_r_));  //?
+    const R_r_ = twoDiff(R,r);
+    const A_  = qmd(r,R_r_);  
+    const N_ = qdq(qdq(A_, tp(r,δ)), tp(δ,δ/2));
+    const D_ = qaq(A_,qmd(δ,R_r_));
 
-    const R_r = R - r; //?
-    const A = r*R_r;   //?
-    const N = A - r*δ - (δ*δ)/2;  //?
-    const D = A + R_r*δ;      //?
-    const cosC = N/D;      //?
-    const Q = ddDivDd(N_,D_)[1];//?
-    // const Q = N_[1]/D_[1];//?
+    const R_r = R - r;
+    const A = r*R_r; 
+    const N = A - r*δ - (δ*δ)/2;
+    const D = A + R_r*δ;    
+    const cosC = N/D;    
+    const Q = ddDivDd(N_,D_)[1];
+    // const Q = N_[1]/D_[1];
     const C = acos(cosC);
     const CC = acos(Q)
 
-    const θ = CC;  //?
+    const θ = CC;
 
     // return r*θ;
     return r*θ;
 }
 
 
-// * see https://en.wikipedia.org/wiki/Law_of_cosines, Version suited to small angles
-function calcSeperationTolerance3(
-        R: number,
-        r: number,
-        δ: number) {
+export { calcSeperationTolerance }
+
 
-    const a = r + δ;  //?
-    const c = R - r;  //?
-    const b = R;      //?
+// Quokka tests
+
+// /**
+//  * Calculates and returns an appropriate seperation tolerance between `CpNode`s.
+//  * 
+//  * @param R radius of the circle implied by the curvature at the boundary
+//  * @param r radius of the MAT circle
+//  * @param θ angle between point...
+//  */
+// function calcSeperationTolerance2(
+//         R: number,
+//         r: number,
+//         δ: number) {
+
+//     const a = r + δ;
+//     if (a >= R) {
+//         return Number.POSITIVE_INFINITY;
+//     }
+
+//     const b = R - r;
+//     const c = R;    
+    
+//     const N = c*c - a*a - b*b;
+//     const N_ = qdq(qdq(tp(c,c), tp(a,a)), tp(b,b));
+//     const D = 2*a*b;          
+//     const D_ = tp(-2*a,b);
+//     const Q = ddDivDd(N_,D_)[1];
+//     const cosC = -N/D;
+//     const C = acos(cosC);
+//     const CC = acos(Q);
+
+//     const θ = π - CC;
+
+//     return θ;
+//     // return r*θ;  // approximate arc with line
+// }
+
+
+// function degToRad(degrees: number) {
+//     return degrees/360*2*Math.PI;
+// }
+// function radToDeg(rad: number) {
+//     return rad*360/2/Math.PI;
+// }
+
+
+// const R = 699;
+// const r = 698;
+// const δ = 1000*2**-46;
+// calcSeperationTolerance(R,r,δ); 
+// calcSeperationTolerance2(R,r,δ);
+// calcSeperationTolerance3(R,r,δ);
+
+// // * see https://en.wikipedia.org/wiki/Law_of_cosines, Version suited to small angles
+// function calcSeperationTolerance3(
+//         R: number,
+//         r: number,
+//         δ: number) {
+
+//     const a = r + δ;
+//     const c = R - r;
+//     const b = R;    
     
-    // c² = (a - b)² + 4ab*sin²(θ/2) OR
-    // (c² - (a - b)²)/4ab = sin²(θ/2)
-    const cc = c*c;  //? 
-    const abc = a*a + b*b - 2*a*b;  //?
-    const A = cc - abc;  //?
-    const B = sqrt(A/(4*a*b));  //?
-
-    const θ = 2*asin(B);  //?
-
-    return θ;
-    // return r*θ;  // approximate arc with line
-}
+//     // c² = (a - b)² + 4ab*sin²(θ/2) OR
+//     // (c² - (a - b)²)/4ab = sin²(θ/2)
+//     const cc = c*c; 
+//     const abc = a*a + b*b - 2*a*b;
+//     const A = cc - abc;
+//     const B = sqrt(A/(4*a*b));
+
+//     const θ = 2*asin(B);
+
+//     return θ;
+//     // return r*θ;  // approximate arc with line
+// }

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

@@ -47,7 +47,7 @@ function find2Prong(
 		angle: number,
         y: PointOnShape): { circle: Circle,	zs: PointOnShape[] } | undefined {
 
-	const { loops, maxCoordinate, squaredDiagonalLength, cpTrees } = meta;
+	const { loops, maxCoordinate, squaredDiagonalLength } = meta;
 
 	const loop = y.curve.loop;
 
@@ -68,7 +68,7 @@ function find2Prong(
 	// The boundary piece that should contain the other point of 
 	// the 2-prong circle. (Defined by start and end points).
 	let bezierPieces = getInitialBezierPieces(
-		angle, isHoleClosing, loop, loops, cpTrees, y, { center: xO, radius: rO }
+		angle, isHoleClosing, loop, loops, meta, y, { center: xO, radius: rO }
 	);
 	// console.log(bezierPieces.length);