flo-mat 3.0.0 → 3.0.2

package/src/find-3-prong.ts/calc-better-x.ts

@@ -1,6 +1,6 @@
 import { fromTo, circumCenter, len, scale, translate } from 'flo-vector2d';
 import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { BezierPiece  } from '../mat/bezier-piece.js';
+import { CurvePiece  } from '../mat/curve-piece.js';
 import { getClosestPoints } from './get-closest-points.js';
 
 
@@ -16,7 +16,7 @@ import { getClosestPoints } from './get-closest-points.js';
  * @param extreme
  */
 function calcBetterX(
-        bezierPiece3s: BezierPiece[][], 
+        bezierPiece3s: CurvePiece[][], 
         x: number[], 
         vectorToZeroV: number[]) {
 
@@ -25,7 +25,7 @@ function calcBetterX(
     let nu = 1;
     let better;
     let newX;
-    let newPs: (PointOnShape | undefined)[];
+    let newPoss: PointOnShape[];
     let newV;
     let i = 0; // Safeguard
     do { 
@@ -33,10 +33,10 @@ function calcBetterX(
         newX = translate(shift, x); 
         
         
-        newPs = getClosestPoints(newX, bezierPiece3s);
-                    
+        newPoss = getClosestPoints(newX, bezierPiece3s);
+
         // Point of zero V
-        const newCircleCenter = circumCenter(newPs.map(pos => pos!.p)); 
+        const newCircleCenter = circumCenter(newPoss.map(pos => pos!.p)); 
         const newVectorToZeroV = fromTo(newX, newCircleCenter);
         newV = len(newVectorToZeroV);
         
@@ -47,7 +47,7 @@ function calcBetterX(
         i++;
     } while (!better && i < 3);
 
-    return { newX, newV, newPs } 
+    return { newX, newV, newPoss } 
 }
 
 

package/src/find-3-prong.ts/calc-initial-3-prong-center.ts

@@ -1,10 +1,11 @@
 /** @internal */
 import { circumCenter } from 'flo-vector2d';
 import { CpNode      } from '../cp-node/cp-node.js';
-import { BezierPiece } from '../mat/bezier-piece.js';
+import { CurvePiece } from '../mat/curve-piece.js';
 import { getCloseBoundaryPointsCertified } from '../closest-boundary-point/get-close-boundary-points-certified.js';
 import { createPos } from '../point-on-shape/create-pos.js';
 
+const { max, ceil, log2 } = Math;
 
 /**
  * @internal
@@ -16,12 +17,16 @@ import { createPos } from '../point-on-shape/create-pos.js';
  * @param extreme 
  */
 function calcInitial3ProngCenter(
+        maxCoordinate: number,
         δ3s: CpNode[][], 
-        bezierPiece3s: BezierPiece[][]) {
+        bezierPiece3s: CurvePiece[][]) {
 
-    const twoProngCircleCenter = δ3s[0][0].cp.circle.center;
+    const circle = δ3s[0][0].cp.circle;
+    const twoProngCircleCenter = circle.center;
 
+    const pow = max(0,ceil(log2(maxCoordinate/circle.radius))) + 1;  // determines accuracy;
     const pos = getCloseBoundaryPointsCertified(
+        pow,
         bezierPiece3s[1],
         twoProngCircleCenter
     )[0];

package/src/find-3-prong.ts/find-3-prong-for-delta3s.ts

@@ -1,22 +1,21 @@
-/** @internal */
-declare const _debug_: Debug;
-
 import { 
     fromTo, circumCenter, len, distanceBetween, toUnitVector, rotate90Degrees,
     cross 
 } from 'flo-vector2d';
 import { tangent } from 'flo-bezier3';
-import { Debug } from '../debug/debug.js';
-import { CpNode, isSharp } from '../cp-node/cp-node.js';
-import { BezierPiece } from '../mat/bezier-piece.js';
+import { CpNode } from '../cp-node/cp-node.js';
+import { CpNodeFs } from '../cp-node/cp-node-fs.js';
+import { CurvePiece } from '../mat/curve-piece.js';
 import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { isPosDullCorner } from '../point-on-shape/is-pos-dull-corner.js';
 import { calcInitial3ProngCenter } from './calc-initial-3-prong-center.js';
 import { getClosestPoints } from './get-closest-points.js';
 import { calcBetterX } from './calc-better-x.js';
-import { getCornerAtEnd } from '../curve/curve.js';
 import { getCloseBoundaryPointsCertified } from '../closest-boundary-point/get-close-boundary-points-certified.js';
-import { createPos } from '../point-on-shape/create-pos.js';
+import { getCorner } from '../corner/get-corner.js';
+import { isPosCorner } from '../point-on-shape/is-pos-corner.js';
+import { getPosCorner } from '../point-on-shape/get-pos-corner.js';
+
+const { isSharp } = CpNodeFs;
 
 
 /** @internal */
@@ -29,21 +28,21 @@ const calcVectorToZeroV_StraightToIt = fromTo;
  * @param δs The boundary pieces
  * @param idx δ identifier
  * @param bezierPiecess
- * @param extreme The maximum coordinate value used to calculate floating point
+ * @param maxCoordinate The maximum coordinate value used to calculate floating point
  * tolerances.
  */
 function find3ProngForDelta3s(
         δs: CpNode[][], 
         idx: number, 
         k: number,
-        bezierPiecess: BezierPiece[][],
-        extreme: number) {
+        bezierPiecess: CurvePiece[][],
+        maxCoordinate: number) {
 
-    const TOLERANCE = 2**-32*extreme;
+    const TOLERANCE = 2**-32*maxCoordinate;
     const MAX_ITERATIONS = 10;
 
     const δs_ = [
-        δs[0], 
+        δs[0],
         δs[idx], 
         δs[δs.length-1]
     ];
@@ -73,23 +72,16 @@ function find3ProngForDelta3s(
     if (isSharp(δ3s[0][0])) { return undefined; }
 
 
-    let ps: (PointOnShape | undefined)[];
+    let poss: PointOnShape[] = undefined!;
     let circumCenter_;
     let j = 0; // Safeguard for slow convergence
-    let x = calcInitial3ProngCenter(δ3s, bezierPiece3s);
-
-    if (typeof _debug_ !== 'undefined') { 
-        const threeProngs = _debug_.generated.elems.threeProng;
-        const d = threeProngs[threeProngs.length-1];
-        const trace = d.traces[d.traces.length-1];
-        trace.push(x);
-    }
+    let x = calcInitial3ProngCenter(maxCoordinate, δ3s, bezierPiece3s);
 
     let tolerance = Number.POSITIVE_INFINITY;
     while (tolerance > TOLERANCE && j < MAX_ITERATIONS) { 
         j++;
         
-        ps = getClosestPoints(x, bezierPiece3s);
+        poss = getClosestPoints(x, bezierPiece3s);
         if (!Number.isFinite(x[0]) || !Number.isFinite(x[1])) {
 
             // TODO - the code can be cleaned up and sped up a lot if we don't
@@ -99,7 +91,7 @@ function find3ProngForDelta3s(
             return undefined;
         }
 
-        circumCenter_ = circumCenter(ps.map(x => x!.p));
+        circumCenter_ = circumCenter(poss.map(x => x!.p));
 
         const vectorToZeroV = calcVectorToZeroV_StraightToIt(x, circumCenter_);
 
@@ -113,23 +105,16 @@ function find3ProngForDelta3s(
         }
         const upds = calcBetterX(bezierPiece3s, x, vectorToZeroV);
         x = upds.newX;
-        ps = upds.newPs;
-
-        if (typeof _debug_ !== 'undefined') { 
-            const threeProngs = _debug_.generated.elems.threeProng;
-            const d = threeProngs[threeProngs.length-1];
-            const trace = d.traces[d.traces.length-1];
-            trace.push(x);
-        }
+        poss = upds.newPoss;
 
         const V = len(vectorToZeroV); // The 'potential'
         
         tolerance = Math.abs(V - upds.newV);
     }
 
-    const radius = (distanceBetween(x, ps![0]!.p) + 
-                    distanceBetween(x, ps![1]!.p) + 
-                    distanceBetween(x, ps![2]!.p)) / 3;
+    const radius = (distanceBetween(x, poss[0].p) + 
+                    distanceBetween(x, poss[1].p) + 
+                    distanceBetween(x, poss[2].p)) / 3;
 
     const circle = { center: x, radius };
 
@@ -140,19 +125,19 @@ function find3ProngForDelta3s(
     //-------------------------------------------------------------------------
     let totalAngleError = 0;
     for (let i=0; i<3; i++) {
-        const p = ps![i];
+        const pos = poss![i];
         //----------------------------
         // Tangent of circle at point
         //----------------------------
-        const v = toUnitVector(fromTo(p!.p, x));
+        const v = toUnitVector(fromTo(pos!.p, x));
         const v1 = rotate90Degrees(v);
         
         
         //-----------------------------------
         // Check if point is on dull crorner
         //-----------------------------------
-        if (isPosDullCorner(p!)) {
-            const corner = getCornerAtEnd(p!.curve);
+        if (isPosCorner(pos!) && getPosCorner(pos!).isDull) {
+            const corner = getCorner(pos!.curve.ps, pos!.curve.next.ps);
             const tans = corner.tangents;
             const perps = tans.map( rotate90Degrees );
                 
@@ -168,7 +153,7 @@ function find3ProngForDelta3s(
             //---------------------------
             // Tangent of curve at point
             //---------------------------
-            const v2 = toUnitVector( tangent(p!.curve.ps, p!.t) );
+            const v2 = toUnitVector( tangent(pos!.curve.ps, pos!.t) );
             
             // Cross is more numerically stable than Vector.dot at angles a
             // multiple of Math.PI **and** is close to the actual angle value
@@ -190,6 +175,7 @@ function find3ProngForDelta3s(
     const closestDs = [];
     for (let i=0; i<bezierPiecess.length; i++) {
         const p = getCloseBoundaryPointsCertified(
+            5,  // TODO - see find-2-prong
             bezierPiecess[i], x
         )[0];
 
@@ -203,7 +189,7 @@ function find3ProngForDelta3s(
     const W2 = 1;
     const error = W1*radiusDelta + W2*totalAngleError;
 
-    return { ps: ps!, circle, error, δ3s };
+    return { poss: poss!, circle, error, δ3s };
 }
 
 

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

@@ -1,24 +1,8 @@
-/** @internal */
-declare const _debug_: Debug; 
-
-import { fromTo } from 'flo-bezier3';
-import { Debug } from '../debug/debug.js';
 import { CpNode } from '../cp-node/cp-node.js';
 import { Circle } from '../geometry/circle.js';
 import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { createEmptyThreeProngForDebugging } from '../debug/three-prong-for-debugging.js';
 import { find3ProngForDelta3s } from './find-3-prong-for-delta3s.js';
 import { getBoundaryPieceBeziers } from '../mat/get-boundary-piece-beziers.js';
-import { BezierPiece } from '../mat/bezier-piece.js';
-
-
-interface CandidateThreeProng {
-	circle: {
-		center: number[];
-		radius: number;
-	};
-	ps: PointOnShape[];
-}
 
 
 /**
@@ -28,120 +12,36 @@ interface CandidateThreeProng {
  * @param extreme The maximum coordinate value used to calculate floating point
  * tolerances.
  */ 
-function find3Prong(δs: CpNode[][], extreme: number) {
+function find3Prong(
+		δs: CpNode[][], extreme: number) {
+
 	const bezierPiecess = δs.map(getBoundaryPieceBeziers);
-	addDebugInfo1(bezierPiecess);
-	const candidateThreeProngs: CandidateThreeProng[] = [];
 
 	// The best candidate amongst the different 'permutations' of the given δs.
 	let threeProng: { 
         circle: Circle, 
-        ps: PointOnShape[], 
+        poss: PointOnShape[], 
         δ3s: CpNode[][] 
     };
-	let bestIndx = undefined; 
 	let smallestError = Number.POSITIVE_INFINITY;
 	for (let i=1; i<δs.length-1; i++) {
 		for (let k=0; k<3; k++) {
-			addDebugInfo2();
-
 			const threeProngInfo = 
 				find3ProngForDelta3s(δs, i, k, bezierPiecess, extreme);
 			if (!threeProngInfo) { continue; }
 
-			const { circle, ps: poss, error, δ3s } = threeProngInfo;
-			
-			addDebugInfo3(candidateThreeProngs, circle, poss as PointOnShape[]);
+			const { circle, poss: poss, error, δ3s } = threeProngInfo;
 			
 			if (error < smallestError) {
 				smallestError = error;
 				
-				bestIndx = i-1;
-				threeProng = { circle, ps: poss as PointOnShape[], δ3s };
+				threeProng = { circle, poss: poss as PointOnShape[], δ3s };
 			}
 		}
 	}
-
-	addDebugInfo4(threeProng!, δs, bestIndx, candidateThreeProngs);
 	
-	return threeProng!;
-}
-
-
-function addDebugInfo2() {
-	if (typeof _debug_ !== 'undefined') { 
-		const threeProngs = _debug_.generated.elems.threeProng;
-		const d = threeProngs[threeProngs.length-1];
-		const trace: number[][] = [];
-		d.traces.push(trace);
-	}
-}
-
-function addDebugInfo3(
-		candidateThreeProngs: CandidateThreeProng[],
-		circle: Circle,
-		ps: PointOnShape[]) {
-
-	if (typeof _debug_ !== 'undefined') { 
-		candidateThreeProngs.push({ circle, ps });
-	}
-}
-
-
-function addDebugInfo4(
-		threeProng: {
-			circle: Circle;
-			ps: PointOnShape[];
-			δ3s: CpNode[][]
-		},
-		δs: CpNode[][],
-		bestIndx: number | undefined,
-		candidateThreeProngs: CandidateThreeProng[]) {
-
-	if (typeof _debug_ !== 'undefined') { 
-		const threeProngs = _debug_.generated.elems.threeProng;
-		const d = threeProngs[threeProngs.length-1];
-
-		d.generated = _debug_.generated;
-		if (threeProng !== undefined) {
-			d.circle = threeProng.circle;
-			d.poss = threeProng.ps;
-			d.cp3ss = threeProng.δ3s;
-		}
-		d.cpss = δs;
-		d.bestIndx = bestIndx!;
-		d.candidateThreeProngs = candidateThreeProngs;
-	}
-}
-
-
-function addDebugInfo1(
-		bezierPiecess: BezierPiece[][]) {
-
-	if (typeof _debug_ !== 'undefined') { 
-		const threeProngs = _debug_.generated.elems.threeProng;
-		threeProngs.push(createEmptyThreeProngForDebugging());
 
-		const d = threeProngs[threeProngs.length-1];
-		d.boundaries = [];
-		for (const bezierPieces of bezierPiecess) {
-			const boundary: number[][][] = [];
-			d.boundaries.push(boundary);
-			for (const bezierPiece of bezierPieces) {
-				/* qqq
-				let bezier = fromTo(bezierPiece.curve.ps)(
-					bezierPiece.ts[0], bezierPiece.ts[1]
-				);
-				*/
-				const bezier = fromTo(
-					bezierPiece.curve.ps,
-					bezierPiece.ts[0], bezierPiece.ts[1]
-				);
-				boundary.push(bezier);
-			}
-		}
-		d.traces = [];
-	}
+	return threeProng!;
 }
 
 

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

@@ -0,0 +1,61 @@
+import { CpNode } from '../cp-node/cp-node.js';
+import { calcPosOrder } from '../point-on-shape/calc-pos-order.js';
+import { find3Prong } from './find-3-prong.js';
+import { MatMeta } from '../mat/mat-meta.js';
+import { addToCpTree } from '../mat/add-to-cp-tree.js';
+import { getCloseByCpIfExist } from '../mat/get-closeby-cp-if-exist.js';
+import { getRealProngCount } from '../cp-node/fs/get-real-prong-count.js';
+import { removeVertex } from '../vertex/remove-vertex.js';
+import { getProngCount } from '../cp-node/fs/get-prong-count.js';
+
+
+/**
+ * @internal
+ * Finds and add a 3-prong MAT circle to the given shape.
+ * @param cpTrees
+ * @param visitedCps
+ * @param extreme The maximum coordinate value used to calculate floating point
+ * tolerances.
+ */
+function findAndAdd3Prong(
+		meta: MatMeta,
+		visitedCps: CpNode[]) {
+	
+	const δs: [CpNode, CpNode][] = [];
+	for (const visitedCp of visitedCps) {
+		δs.push([visitedCp, visitedCp.next]);
+	}
+	
+	const threeProngInfo = find3Prong(δs, meta.maxCoordinate);
+
+	const { circle, poss, δ3s } = threeProngInfo;
+	
+	const orders: number[] = [];
+	for (let i=0; i<3; i++) {
+		orders.push(calcPosOrder(circle, poss[i]));
+	}
+
+	const closeBysFor3Prong: CpNode[] = [];
+	for (let i=0; i<poss.length; i++) {
+		const pos = poss[i];
+		const order = orders[i];
+		const closeBy = getCloseByCpIfExist(meta, pos, circle, order, 0, 3);
+		if (closeBy !== undefined) {
+			const prongCount = getProngCount(closeBy);
+			if (prongCount <= 2 && !closeBy.isHoleClosing) {
+				closeBysFor3Prong.push(closeBy);
+			}
+		}
+	}
+
+	const cpNodes = closeBysFor3Prong.length === 0
+		? addToCpTree(
+			true, false, circle, orders, meta.cpTrees, poss, δ3s.map(v => v[0])
+		).cpNodes
+		: [];
+
+	return { closeBysFor3Prong, cpNodes: cpNodes as CpNode[] };
+}
+
+
+export { findAndAdd3Prong }

package/src/find-3-prong.ts/find-and-add-3-prongs-on-loop.ts

@@ -0,0 +1,89 @@
+import { CpNode } from '../cp-node/cp-node.js';
+import { findAndAdd3Prongs } from './find-and-add-3-prongs.js';
+import { MatMeta } from '../mat/mat-meta.js';
+import { getAllOnLoop } from '../cp-node/fs/get-all-on-loop.js';
+import { removeVertex } from '../vertex/remove-vertex.js';
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { Loop } from 'flo-boolean';
+import { drawFs } from 'flo-draw';
+import { getAllOnCircle } from '../cp-node/fs/get-all-on-circle.js';
+
+
+/**
+ * @internal
+ * Finds and adds all 3-prongs on a loop.
+ *
+ * @param meta
+ * @param cpStart The CpNode to start traversing from. 
+  */
+function findAndAdd3ProngsOnLoop(
+        meta: MatMeta,
+        cpStart: CpNode | undefined): CpNode | undefined {
+
+    if (cpStart === undefined) { return undefined!; }
+
+    const cpNodeGoodSet = new Set<CpNode>();
+    let reLoop = true;
+    while (reLoop) {
+        reLoop = false;
+        const cpNodeSet = new Set(getAllOnLoop(cpStart));
+        for (const cpNode of cpNodeSet) {
+
+            const { closeBysFor3Prong, addedCpNodes } = 
+                findAndAdd3Prongs(meta, cpNode);
+
+            if (addedCpNodes.length > 0) { reLoop = true; }
+
+            if (closeBysFor3Prong === undefined) {
+                cpNodeGoodSet.add(cpNode);
+            } else {
+                reLoop = true;
+                replaceCloseBys(meta.cpTrees, closeBysFor3Prong, cpNodeSet, cpNodeGoodSet);
+            }
+
+            addedCpNodes.forEach(cpNodes => cpNodes.forEach(cpNode => cpNodeGoodSet.add(cpNode)));
+        }
+        cpStart = getFirstItemOfSet(cpNodeGoodSet)!;
+    }
+
+    return getFirstItemOfSet(cpNodeGoodSet);
+}
+
+
+// From https://stackoverflow.com/a/73281564/2010061
+function getFirstItemOfSet<T>(set: Set<T>) {
+    for (const item of set) {
+         return item;
+    }
+
+    return undefined;
+}
+
+
+// Unfortunately O(n) until Javascript gives us the simple ability to
+// retrieve the first or last item of a set
+function getLastItemOfSet<T>(set: Set<T>) {
+    let item;
+    for (item of set) {}
+
+    return item;
+}
+
+
+function replaceCloseBys(
+        cpTrees: Map<Loop,LlRbTree<CpNode>>,
+        closeBysFor3Prong: CpNode[],
+        cpNodeSet: Set<CpNode>,
+        cpNodeGoodSet: Set<CpNode>) {
+
+    for (const closeBy of [closeBysFor3Prong[0]]) {
+        getAllOnCircle(closeBy).forEach(v => {
+            cpNodeSet.delete(v);
+            cpNodeGoodSet.delete(v);
+        });
+        removeVertex(closeBy, cpTrees);
+    }
+}
+
+
+export { findAndAdd3ProngsOnLoop }

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

@@ -1,110 +1,60 @@
 /** @internal */
 declare const _debug_: Debug; 
 
-import { LlRbTree } from 'flo-ll-rb-tree';
 import { Debug } from '../debug/debug.js';
 import { CpNode } from '../cp-node/cp-node.js';
-import { traverseCp } from '../cp-node/traverse-cp.js';
-import { Loop } from 'flo-boolean';
-import { Circle } from '../geometry/circle.js';
-import { calcPosOrder } from '../point-on-shape/calc-pos-order.js';
-import { find3Prong } from './find-3-prong.js';
-import { add3Prong  } from './add-3-prong.js';
+import { traverseCp } from '../cp-node/fs/traverse-cp.js';
+import { MatMeta } from '../mat/mat-meta.js';
+import { isPosSharpCorner } from '../point-on-shape/is-pos-sharp-corner.js';
+import { findAndAdd3Prong } from './find-and-add-3-prong.js';
 
 
+let ii = 0;
 /**
- * @internal
- * Starting from some ContactPoint, traverses the shape going around Vertices
+  * Starting from some `CpNode`, traverses the shape going around Vertices
  * and if more than two Vertices have been visited in total then recursively 
  * adds 3-prongs until only one or two Vertices have been visited. 
  * 
  * This process further subdivides the shape.
  * 
- * @param cpGraphs
+ * @param cpTrees
  * @param cpStart The ContactPoint from where to start the process.
  * @param extreme The maximum coordinate value used to calculate floating point
  * tolerances.
+ * 
+ * @internal
  */
-let ii = 0;
 function findAndAdd3Prongs(
-		cpGraphs: Map<Loop,LlRbTree<CpNode>>,
-		cpStart: CpNode,
-		extreme: number): CpNode[] {
+		meta: MatMeta,
+		cpStart: CpNode) {
 
-	let visitedCps: CpNode[];
-	
+	if (isPosSharpCorner(cpStart.cp.pointOnShape)) {
+		return { closeBysFor3Prong: undefined, addedCpNodes: [] };
+	}
+
+	const addedCpNodes: CpNode[][] = [];
+	let closeBysFor3Prong: CpNode[] | undefined = undefined;
 	do {
-		visitedCps = traverseCp(cpStart);
+		if (cpStart === undefined) { continue; }
+		const visitedCps = traverseCp(cpStart);
 	
-		if (visitedCps.length > 2) {
-			const newCpNodes = findAndAdd3Prong(cpGraphs, visitedCps, extreme);
-			if (newCpNodes.length === 1) {
-				// There was another closeby cpNode
-				const closeCpNode = newCpNodes[0];
-			}
-			ii++;
-		}
-
-		if (typeof _debug_ !== 'undefined') {
-            if (ii === _debug_.directives.stopAfterThreeProngsNum) {
-                return undefined!;
-            }
-        }
-	} while (visitedCps.length > 2);
-
-	return visitedCps;
-}
-
+		if (visitedCps.length <= 2) { break; }
 
-/**
- * @internal
- * Finds and add a 3-prong MAT circle to the given shape.
- * @param cpGraphs
- * @param visitedCps
- * @param extreme The maximum coordinate value used to calculate floating point
- * tolerances.
- */
-function findAndAdd3Prong(
-		cpGraphs: Map<Loop,LlRbTree<CpNode>>,
-		visitedCps: CpNode[],
-		extreme: number): CpNode[] {
-	
-	const δs: [CpNode, CpNode][] = [];
-	for (const visitedCp of visitedCps) {
-		δs.push([visitedCp, visitedCp.next]);
-	}
-	
-	const threeProng = find3Prong(δs, extreme);
-	
-	const orders: number[] = [];
-	for (let i=0; i<3; i++) {
-		orders.push(
-			calcPosOrder(threeProng.circle, threeProng.ps[i])
-		);
-	}
-	
-	const newCpNodes = add3Prong(cpGraphs, orders, threeProng);
+		const { closeBysFor3Prong, cpNodes } = findAndAdd3Prong(meta, visitedCps);
 
-	if (typeof _debug_ !== 'undefined') {
-		if (newCpNodes.length === 3) {
-			add3ProngDebugInfo(newCpNodes[0].cp.circle, visitedCps);
+		addedCpNodes.push(cpNodes);
+		if (closeBysFor3Prong.length > 0) {
+			return { closeBysFor3Prong, addedCpNodes };
 		}
-	}
-
-	return newCpNodes;
-}
-
 
-/** @internal */
-function add3ProngDebugInfo(
-		circle: Circle, 
-		visitedCps: CpNode[]) {
+		if (typeof _debug_ !== 'undefined') {
+			if (++ii === _debug_.directives.stopAfterThreeProngsNum) {
+				return undefined!;
+			}
+		}
+	} while (true);
 
-	const threeProngs = _debug_.generated.elems.threeProng;
-	const len = threeProngs.length;
-	const data = threeProngs[len-1];
-	data.visitedCps = visitedCps;
-	data.circle = circle;
+	return { closeBysFor3Prong, addedCpNodes };
 }