flo-mat 3.0.6 → 3.0.7

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);
 

package/src/find-2-prong/get-initial-bezier-pieces.ts

@@ -9,6 +9,7 @@ import { calcPosOrder } from '../point-on-shape/calc-pos-order.js';
 import { Circle } from '../geometry/circle.js';
 import { isPosCorner } from '../point-on-shape/is-pos-corner.js';
 import { getPosCorner } from '../point-on-shape/get-pos-corner.js';
+import { MatMeta } from '../index.js';
 
 
 /** @internal */
@@ -17,10 +18,13 @@ function getInitialBezierPieces(
         isHoleClosing: boolean,
         loop: Loop,
         loops: Loop[],
-        cpTrees: Map<Loop,LlRbTree<CpNode>>,
+        // cpTrees: Map<Loop,LlRbTree<CpNode>>,
+        meta: MatMeta,
         y: PointOnShape,
         circle: Circle): CurvePiece[] {
 
+    const { cpTrees } = meta;
+
     if (isHoleClosing) {
         return loops
         .filter(_loop => _loop !== loop)

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

@@ -8,6 +8,7 @@ import { Circle } from '../geometry/circle.js';
 import { PointOnShape } from '../point-on-shape/point-on-shape.js';
 import { addToCpGraph } from '../mat/add-to-cp-graph.js';
 import { isAnotherCpCloseby } from '../mat/is-another-cp-closeby.js';
+import { MatMeta } from '../mat/mat-meta.js';
 
 
 /**
@@ -24,86 +25,88 @@ import { isAnotherCpCloseby } from '../mat/is-another-cp-closeby.js';
  * @param threeProng 
  */
 function add3Prong(
-		cpTrees: Map<Loop,LlRbTree<CpNode>>,
-		orders: number[],
-		threeProng: { 
-    		circle: Circle, 
-			ps: PointOnShape[],
-			δ3s: CpNode[][]
-		}): CpNode[] {
-	
-	const { circle, ps: poss, δ3s } = threeProng;
+        // cpTrees: Map<Loop,LlRbTree<CpNode>>,
+        meta: MatMeta,
+        orders: number[],
+        threeProng: { 
+            circle: Circle, 
+            ps: PointOnShape[],
+            δ3s: CpNode[][]
+        }): CpNode[] {
+    
+    const { cpTrees } = meta;
+    const { circle, ps: poss, δ3s } = threeProng;
 
-	// Keep for possible future debugging.	
+    // Keep for possible future debugging.    
 
-	/*
-	let ii = -1;
-	if (typeof _debug_ !== 'undefined') {
-		for (let i=0; i<3; i++) {
-			const cpBef = threeProng.δ3s[i][0].cp;
-			const cpAft = threeProng.δ3s[i][1].cp;
+    /*
+    let ii = -1;
+    if (typeof _debug_ !== 'undefined') {
+        for (let i=0; i<3; i++) {
+            const cpBef = threeProng.δ3s[i][0].cp;
+            const cpAft = threeProng.δ3s[i][1].cp;
 
-			//let cmpBef = PointOnShape.compareInclOrder(cpBef.pointOnShape, poss[i], cpBef.order, orders[i]);
-			//let cmpAft = PointOnShape.compareInclOrder(cpAft.pointOnShape, poss[i], cpAft.order, orders[i]); 
-			const cmpBef = compareCps(cpBef, { pointOnShape: poss[i], order: orders[i], order2: 0, circle: undefined });
-			const cmpAft = compareCps(cpAft, { pointOnShape: poss[i], order: orders[i], order2: 0, circle: undefined });
+            //let cmpBef = PointOnShape.compareInclOrder(cpBef.pointOnShape, poss[i], cpBef.order, orders[i]);
+            //let cmpAft = PointOnShape.compareInclOrder(cpAft.pointOnShape, poss[i], cpAft.order, orders[i]); 
+            const cmpBef = compareCps(cpBef, { pointOnShape: poss[i], order: orders[i], order2: 0, circle: undefined });
+            const cmpAft = compareCps(cpAft, { pointOnShape: poss[i], order: orders[i], order2: 0, circle: undefined });
 
-			// const cmpBef = comparePoss(cpBef.pointOnShape, poss[i]);
-			// const cmpAft = comparePoss(cpAft.pointOnShape, poss[i]); 
+            // const cmpBef = comparePoss(cpBef.pointOnShape, poss[i]);
+            // const cmpAft = comparePoss(cpAft.pointOnShape, poss[i]); 
 
-			// len is used by debug functions to reference a particular 
-			// three-prong.
-			const len = _debug_.generated.elems.threeProng.length-1; 
-			if (cmpBef > 0) {
-				console.log('----------------------------------------');
-				console.log(`3-prong order is wrong (bef) : i: ${i} - cmp: ${cmpBef} - n: ${len}`);
-				console.log(threeProng);
-				console.log(cpBef);
-				console.log(cpAft);
-				console.log(poss[i]);
-				ii = i;
-			}
-			if (cmpAft < 0) {
-				console.log('----------------------------------------');
-				console.log(`3-prong order is wrong (aft) : i: ${i} - cmp: ${cmpAft} - n: ${len}`);
-				console.log(threeProng);
-				console.log(cpBef);
-				console.log(cpAft);
-				console.log(poss[i]);
-			}
-		}
-	}
-	*/
+            // len is used by debug functions to reference a particular 
+            // three-prong.
+            const len = _debug_.generated.elems.threeProng.length-1; 
+            if (cmpBef > 0) {
+                console.log('----------------------------------------');
+                console.log(`3-prong order is wrong (bef) : i: ${i} - cmp: ${cmpBef} - n: ${len}`);
+                console.log(threeProng);
+                console.log(cpBef);
+                console.log(cpAft);
+                console.log(poss[i]);
+                ii = i;
+            }
+            if (cmpAft < 0) {
+                console.log('----------------------------------------');
+                console.log(`3-prong order is wrong (aft) : i: ${i} - cmp: ${cmpAft} - n: ${len}`);
+                console.log(threeProng);
+                console.log(cpBef);
+                console.log(cpAft);
+                console.log(poss[i]);
+            }
+        }
+    }
+    */
 
-	// TODO - replace 1000 below with correct value
-	const c1 = isAnotherCpCloseby(cpTrees, poss[0], circle, orders[0], 0, 1000);
-	const c2 = isAnotherCpCloseby(cpTrees, poss[1], circle, orders[1], 0, 1000);
-	const c3 = isAnotherCpCloseby(cpTrees, poss[2], circle, orders[2], 0, 1000);
+    // TODO - replace 1000 below with correct value
+    const c1 = isAnotherCpCloseby(cpTrees, poss[0], circle, orders[0], 0, 1000);
+    const c2 = isAnotherCpCloseby(cpTrees, poss[1], circle, orders[1], 0, 1000);
+    const c3 = isAnotherCpCloseby(cpTrees, poss[2], circle, orders[2], 0, 1000);
 
-	// for (let pos of poss) {
-	// 	if (pos.t === 0.9978869234519733) {
-	// 		console.log(pos)
-	// 	}
-	// }
-	
+    // for (let pos of poss) {
+    //     if (pos.t === 0.9978869234519733) {
+    //         console.log(pos)
+    //     }
+    // }
+    
 
-	// if (!!c1) {
-	// 	console.log(getRealProngCount(c1));
-	// }
-	// if (!!c2) {
-	// 	console.log(getRealProngCount(c2));
-	// }
-	// if (!!c3) {
-	// 	console.log(getRealProngCount(c3));
-	// }
+    // if (!!c1) {
+    //     console.log(getRealProngCount(c1));
+    // }
+    // if (!!c2) {
+    //     console.log(getRealProngCount(c2));
+    // }
+    // if (!!c3) {
+    //     console.log(getRealProngCount(c3));
+    // }
 
-	// if (!!c1) { return [c1]; }
-	// if (!!c2) { return [c2]; }
-	// if (!!c3) { return [c3]; }
+    // if (!!c1) { return [c1]; }
+    // if (!!c2) { return [c2]; }
+    // if (!!c3) { return [c3]; }
 
-	const cps = addToCpGraph(circle, orders, cpTrees, poss, δ3s); 
-	
-	return cps;
+    const cps = addToCpGraph(circle, orders, cpTrees, poss, δ3s); 
+    
+    return cps;
 }