flo-mat 2.0.4 → 3.0.0

package/src/{mat/find-mat → find-2-prong}/add-2-prong.ts

@@ -3,19 +3,22 @@ declare const _debug_: Debug;
 
 import { LlRbTree } from 'flo-ll-rb-tree';
 import { exponent } from 'big-float-ts';
-import { Debug } from '../../debug/debug.js';
-import { Loop         } from '../../loop.js';
-import { CpNode       } from '../../cp-node.js';
-import { Circle       } from '../../circle.js';
-import { ContactPoint } from '../../contact-point.js';
-import { PointOnShape, calcPosOrder, IPointOnShape } from '../../point-on-shape.js';
-import { isAnotherCpCloseby } from '../is-another-cp-closeby.js';
-import { getNeighbouringPoints } from '../get-neighboring-cps.js';
-import { TwoProngForDebugging } from '../../debug/two-prong-for-debugging.js';
+import { Debug } from '../debug/debug.js';
+import { Loop } from 'flo-boolean';
+import { CpNode, insertCpNode } from '../cp-node/cp-node.js';
+import { Circle } from '../geometry/circle.js';
+import { ContactPoint } from '../contact-point/contact-point.js';
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import { calcPosOrder } from '../point-on-shape/calc-pos-order.js';
+import { createPos } from '../point-on-shape/create-pos.js';
+import { isAnotherCpCloseby } from '../mat/is-another-cp-closeby.js';
+import { getNeighbouringPoints } from '../mat/get-neighboring-cps.js';
+import { TwoProngForDebugging } from '../debug/two-prong-for-debugging.js';
+import { Curve } from '../curve/curve.js';
 
 
 /**
- * @hidden
+ * @internal
  * Adds a 2-prong contact circle to the shape.
  * @param cpGraphs
  * @param circle Circle containing the 2 contact points
@@ -28,45 +31,37 @@ import { TwoProngForDebugging } from '../../debug/two-prong-for-debugging.js';
 function add2Prong(
 		cpGraphs      : Map<Loop,LlRbTree<CpNode>>,
         circle        : Circle, 
-        posSource     : IPointOnShape, 
-		posAntipodes  : { pos: IPointOnShape, d: number }[],
+        posSource     : PointOnShape, 
+		posAntipodes  : PointOnShape[],
 		holeClosing   : boolean,
-		extreme       : number): CpNode {
-
-	//let orderSource   = PointOnShape.calcOrder(circle, posSource);
-	const orderSource   = calcPosOrder(circle, posSource);
-	const orderAntipodes = posAntipodes.map(
-		posAntipode => {
-			//console.log(circle.center)
-			//return PointOnShape.calcOrder(circle, posAntipode.pos);
-			return calcPosOrder(circle, posAntipode.pos);
-		}
-	);
+		extreme       : number): CpNode | undefined {
 
 	let t_s = posSource.t;
-	let curve;
 	if (t_s === 0) {
 		t_s = 1;
-		curve = posSource.curve.prev;
-		posSource = new PointOnShape(curve, t_s);
+		posSource = createPos(posSource.curve.prev, t_s, true);
 	}
 
+	const orderSource = calcPosOrder(circle, posSource);
+	const orderAntipodes = posAntipodes.map(
+		posAntipode => calcPosOrder(circle, posAntipode)
+	);
+
 
 	// Make sure there isn't already a ContactPoint close by - it can cause
 	// floating point stability issues.
-	// TODO - possibly combine n-prongs in this case
 
 	let isCloseByAntipodes = false;
 	for (let i=0; i<posAntipodes.length; i++) {
 		const posAntipode = posAntipodes[i];
 		const orderAntipode = orderAntipodes[i];
 
-		if (isAnotherCpCloseby(cpGraphs, posAntipode.pos, circle, orderAntipode, 0, extreme, 'red')) {
+		if (!!isAnotherCpCloseby(cpGraphs, posAntipode, circle, orderAntipode, 0, extreme)) {
 			isCloseByAntipodes = true;
 			break;
 		}
 	}
-	if (isAnotherCpCloseby(cpGraphs, posSource, circle, orderSource, 0, extreme, 'red') ||
+	if (!!isAnotherCpCloseby(cpGraphs, posSource, circle, orderSource, 0, extreme) ||
 		isCloseByAntipodes) {
 
 		if (typeof _debug_ !== 'undefined') {
@@ -89,18 +84,20 @@ function add2Prong(
 		const posAntipode = posAntipodes[i];
 		const orderAntipode = orderAntipodes[i];
 
-		const cpAntipode: ContactPoint = { pointOnShape: posAntipode.pos, circle, order: orderAntipode, order2: 0 };
+		const cpAntipode: ContactPoint = {
+			pointOnShape: posAntipode, circle, order: orderAntipode, order2: 0
+		};
 		cpAntipodes.push(cpAntipode);
-		const loopAntipode = posAntipode.pos.curve.loop;
+		const loopAntipode = posAntipode.curve.loop;
 		loopAntipodes.push(loopAntipode);
-		const cpTreeAntipode = cpGraphs.get(loopAntipode);
+		const cpTreeAntipode = cpGraphs.get(loopAntipode)!;
 		cpTreeAntipodes.push(cpTreeAntipode);
 		const deltaAntipode = getNeighbouringPoints(
-			cpTreeAntipode, posAntipode.pos, orderAntipode, 0
+			cpTreeAntipode, posAntipode, orderAntipode, 0
 		);	
 		deltaAntipodes.push(deltaAntipode);
 
-		newCpAntipodes.push(CpNode.insert(
+		newCpAntipodes.push(insertCpNode(
 			holeClosing,
 			false,
 			cpTreeAntipode,
@@ -113,11 +110,11 @@ function add2Prong(
 	// Source
 	const cpSource: ContactPoint = { pointOnShape: posSource, circle, order: orderSource, order2: 0 };
 	const loopSource = posSource.curve.loop;
-	const cpTreeSource = cpGraphs.get(loopSource);
+	const cpTreeSource = cpGraphs.get(loopSource)!;
 	const deltaSource = getNeighbouringPoints(
 		cpTreeSource, posSource, orderSource, 0
 	);
-	const newCpSource = CpNode.insert(
+	const newCpSource = insertCpNode(
 		holeClosing,
 		false,
 		cpTreeSource,
@@ -141,8 +138,8 @@ function add2Prong(
 		cpNodes.sort(byAngle(circle));
 
 		for (let i=0; i<cpNodes.length; i++) {
-			const iNext = (i+1 === cpNodes.length) ? 0 : i+1;
-			const iPrev = (i === 0) ? cpNodes.length-1 : i-1;
+			const iNext = (i + 1 === cpNodes.length) ? 0 : i + 1;
+			const iPrev = (i === 0) ? cpNodes.length-1 : i - 1;
 
 			const cpNodeCurr = cpNodes[i];
 			const cpNodeNext = cpNodes[iNext];
@@ -155,13 +152,13 @@ function add2Prong(
 	
 
 	if (holeClosing) { 
-		// TODO - important - take care of case where there are more than 1 antipode
+		// TODO - take care of case where there are more than 1 antipode
 		// Duplicate ContactPoints
-		const cpB2: ContactPoint = { pointOnShape: posAntipodes[0].pos, circle, order: cpAntipodes[0].order, order2: +1 };
-		const newCpB2Node = CpNode.insert(true, false, cpTreeAntipodes[0], cpB2, newCpAntipodes[0]);
+		const cpB2: ContactPoint = { pointOnShape: posAntipodes[0], circle, order: cpAntipodes[0].order, order2: +1 };
+		const newCpB2Node = insertCpNode(true, false, cpTreeAntipodes[0], cpB2, newCpAntipodes[0]);
 		
 		const cpB1: ContactPoint = { pointOnShape: posSource, circle, order: cpSource.order, order2: -1 };
-		const newCpB1Node = CpNode.insert(true, false, cpTreeSource, cpB1, newCpSource.prev);
+		const newCpB1Node = insertCpNode(true, false, cpTreeSource, cpB1, newCpSource.prev);
 		
 		// Connect graph
 		newCpB1Node.prevOnCircle = newCpB2Node;
@@ -195,65 +192,22 @@ function add2Prong(
 }
 
 
-/** @hidden */
-function scale(n: number, exp: number) {
-    return n * (2**-(exp+1));
-}
-
-
-/** @hidden */
-function getSize(x: number, y: number) {
-	// Get size of a
-	if (x > 0) {
-		if (x > 0.5) {
-			return y; // ~ -0.7 -> 0.7, i.e. -(sqrt(2)/2) -> +(sqrt(2)/2) 
-		} else {
-			if (y < 0) {
-				return x - 2; // ~ -2.0 -> -1.3
-			} else {
-				return -x + 2; // ~ 1.3 -> 2.0
-			}
-		}
-	} else {
-		if (x < -0.5) {
-			return -y + 4; // ~ 3.3 -> 4.7
-		} else {
-			if (y < 0) {
-				return x + 6; // ~ 5.3 -> 6.0
-			} else {
-				return -x + 2; // ~ 2 -> 2.7
-			}
-		}
-	}
-}
-
-
-/** @hidden */
+/** @internal */
 function byAngle(circle: Circle) {
 	const c = circle.center;
-	const r = circle.radius;
-
-	const exp = exponent(r);
 
 	return function(_a: CpNode, _b: CpNode) {
 		let a = _a.cp.pointOnShape.p;
 		let b = _b.cp.pointOnShape.p;
 
 		// Move onto origin
-		a = [a[0]-c[0], a[1]-c[1]];
-		b = [b[0]-c[0], b[1]-c[1]];
-
-		// Scale
-		const ax = scale(a[0], exp);
-		const ay = scale(a[1], exp);
-		const bx = scale(b[0], exp);
-		const by = scale(b[1], exp);
+		a = [a[0] - c[0], a[1] - c[1]];
+		b = [b[0] - c[0], b[1] - c[1]];
 
-		// Get 'size'
-		const sa = getSize(ax, ay);
-		const sb = getSize(bx, by);
+		const a_ = Math.atan2(a[1], a[0]);
+		const b_ = Math.atan2(b[1], b[0]);
 
-		return sb - sa;
+		return b_ - a_;
 	}
 }
 

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

@@ -0,0 +1,49 @@
+/** @internal */
+declare const _debug_: Debug; 
+
+import { Debug } from '../debug/debug.js';
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import { Circle } from '../geometry/circle.js';
+import { CpNode } from '../cp-node/cp-node.js';
+import { BezierPiece } from '../mat/bezier-piece.js';
+import { TwoProngForDebugging } from '../debug/two-prong-for-debugging.js';
+import { getTwoProngType } from '../mat/get-two-prong-type.js';
+import { ElemType_TwoProng } from '../mat/elem-type-two-prong.js';
+import { TXForDebugging } from './x-for-debugging.js';
+
+
+/** @internal */
+function addDebugInfo(
+        bezierPieces: BezierPiece[],
+        failed: boolean, 
+        x: number[],
+        y: PointOnShape,
+        z: PointOnShape,
+        circle: Circle,
+        δ: CpNode[], 
+        xs: TXForDebugging[], 
+        holeClosing: boolean) {
+
+    xs.push({ x, y, z, t: y.t });
+
+    const twoProng: TwoProngForDebugging = {
+            generated: _debug_.generated,
+            bezierPieces,
+            pos: y,
+            δ,
+            z: z ? z.p : undefined!,
+            circle,
+            xs,
+            failed,
+            holeClosing,
+            notAdded: false,
+            deleted: false,
+            cpNode: undefined!
+    };
+
+    const twoProngType = getTwoProngType(twoProng) as ElemType_TwoProng;
+    _debug_.generated.elems[twoProngType].push(twoProng);
+}
+
+
+export { addDebugInfo }

package/src/{mat/find-mat/find-2-prong → find-2-prong}/cull-bezier-pieces.ts

@@ -1,26 +1,24 @@
-import { getClosestSquareDistanceToRect } from '../../geometry/get-closest-square-distance-to-rect.js';
-import { BezierPiece } from '../../bezier-piece.js';
-import { getBoundingBox_ } from '../../../get-bounding-box-.js';
+import { getClosestSquareDistanceToRect } from '../geometry/get-closest-square-distance-to-rect.js';
+import { BezierPiece } from '../mat/bezier-piece.js';
+import { getBoundingBox_ } from '../geometry/get-bounding-box-.js';
 
 
 /**
- * @hidden
+ * @internal
  * Cull all bezierPieces not within given radius of a given point.
  * @param extreme
  * @param bezierPieces
  * @param p
  * @param rSquared
  */
-function cullBezierPieces(
+function cullBezierPieces2(
         bezierPieces: BezierPiece[], 
         p: number[], 
         rSquared: number) {
 
-    const CULL_THRESHOLD = 5;
-    // TODO - base delta on theory
-    const TOLERANCE = 1+1e-3;
+    const TOLERANCE = 1 + 2**-10;
 
-    if (bezierPieces.length <= CULL_THRESHOLD) {
+    if (bezierPieces.length <= 1) {
         return bezierPieces;
     }
 
@@ -31,7 +29,7 @@ function cullBezierPieces(
         
         const rect = getBoundingBox_(ps);
         const bd = getClosestSquareDistanceToRect(rect, p);
-        if (bd <= rSquared * TOLERANCE) {
+        if (bd <= TOLERANCE*rSquared) {
             newPieces.push(bezierPiece);
         } 
     }
@@ -40,4 +38,4 @@ function cullBezierPieces(
 }
 
 
-export { cullBezierPieces }
+export { cullBezierPieces2 }

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

@@ -0,0 +1,191 @@
+/** @internal */
+declare const _debug_: Debug;
+
+import { Debug } from '../debug/debug.js';
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { distanceBetween, fromTo, interpolate, rotate, translate } from 'flo-vector2d';
+import { CpNode } from '../cp-node/cp-node.js';
+import { Loop } from 'flo-boolean';
+import { Circle } from '../geometry/circle.js';
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import { getOsculatingCircle } from '../point-on-shape/get-osculating-circle.js';
+import { addDebugInfo } from './add-debug-info.js';
+import { TXForDebugging } from './x-for-debugging.js';
+import { findEquidistantPointOnLineDd } from './find-equidistant-point-on-line-dd.js';
+import { getInitialBezierPieces } from './get-initial-bezier-pieces.js';
+import { getCloseBoundaryPointsCertified } from '../closest-boundary-point/get-close-boundary-points-certified.js';
+import { reduceRadius } from './reduce-radius.js';
+import { squaredDistanceBetweenDd } from './squared-distance-between-dd.js';
+import { cullBezierPieces2 } from './cull-bezier-pieces.js';
+import { add1Prong } from './add-1-prong.js';
+import { createPos } from '../point-on-shape/create-pos.js';
+
+
+const { sqrt, abs, sin, cos } = Math;
+
+
+/**
+ * @internal
+ * Adds a 2-prong to the MAT. The first point on the shape boundary is given and 
+ * the second one is found by the algorithm.
+ * 
+ * A 2-prong is defined as a MAT circle that touches the shape at exactly 2 
+ * points.
+ * 
+ * Before any 2-prongs are added the entire shape is our δΩ.
+ * 
+ * As per the paper by Choi, Choi, Moon and Wee: 
+ *   "The starting point of this algorithm is a choice of a circle Br(x)
+ *    centered at an interior point x which contains two boundary portions c and
+ *    d of dΩ as in Fig. 19."
+ * In fact, we (and they) start by fixing one point on the boundary beforehand. 
+ * @param loops A shape represented by path loops
+ * @param extreme The extreme coordinate value of the shape
+ * @param squaredDiagonalLength The squared diagonal length of the shape 
+ * bounding box.
+ * @param y The source point of the 2-prong to be found
+ * @param isHoleClosing True if this is a hole-closing two-prong, false otherwise
+ * @param k The loop array index
+ */
+
+function find2Prong(
+		angle: number,
+		loops: Loop[],
+		extreme: number,
+		squaredDiagonalLength: number,
+		cpTrees: Map<Loop,LlRbTree<CpNode>>,
+        y: PointOnShape,
+		isHoleClosing: boolean,
+		k: number,
+		for1Prong: boolean): { circle: Circle,	zs: PointOnShape[] } | undefined {
+
+	const MAX_ITERATIONS = 25;
+	const squaredSeperationTolerance = ((2**-21)*extreme)**2;
+	const errorTolerance = (2**-46)*extreme;
+	const maxOsculatingCircleRadius = sqrt(squaredDiagonalLength);
+	const minCurvature = 1/maxOsculatingCircleRadius;
+
+	let xO: number[];  // the original x to mitigate drift
+	const p = y.p;
+	let rO: number;
+	if (isHoleClosing) {
+		xO = [p[0], p[1] - maxOsculatingCircleRadius];
+		rO = maxOsculatingCircleRadius;
+	} else {
+		if (angle === 0) {
+			({ center: xO, radius: rO } = getOsculatingCircle(minCurvature, y));
+		} else {
+			({ center: xO, radius: rO } = getOsculatingCircle(minCurvature, y, true));
+			const v = fromTo(y.p, xO);
+			const v_ = rotate(sin(angle), cos(angle))(v);
+			xO = translate(y.p)(v_);
+		}
+	}
+
+	// The boundary piece that should contain the other point of 
+	// the 2-prong circle. (Defined by start and end points).
+	const { bezierPieces, δ } = getInitialBezierPieces(
+		angle, isHoleClosing, k, loops, cpTrees, y, { center: xO, radius: rO }
+	);
+
+	/** The center of the two-prong (successively refined) */
+	let x = xO;
+
+	// The lines below is an optimization.
+	const r_ = sqrt(reduceRadius(extreme, bezierPieces, p, xO));
+	if (rO > r_) {
+		x = interpolate(p, xO, r_/rO);
+	}
+
+	/** Trace the convergence (for debugging). */
+	const xs: TXForDebugging[] = []; 
+	/** The antipode of the two-prong (successively refined) */
+	let zs: PointOnShape[] = undefined!;
+	let z: PointOnShape = undefined!;
+	let bezierPieces_ = bezierPieces;
+
+	let i = 0;
+	while (i < MAX_ITERATIONS) {
+		const xy = squaredDistanceBetweenDd(x, y.p);
+
+		if (i < 5) { bezierPieces_ = cullBezierPieces2(bezierPieces_, x, xy); }
+
+		zs = getCloseBoundaryPointsCertified(
+			bezierPieces_, x, y.curve, y.t,
+			for1Prong && i == 0 && rO !== 1/minCurvature,
+			angle
+		).map(info => createPos(info.curve, info.t, false));
+
+		z = zs[0];
+
+		if (z === undefined) {
+			addDebugInfo2(isHoleClosing);
+			return undefined;
+		}
+
+		const xz = squaredDistanceBetweenDd(x, z.p);
+		const yz = squaredDistanceBetweenDd(y.p, z.p);
+
+		// if on first try
+		if (i === 0) {
+			if (rO < (1 - 2**-6)*sqrt(xz)) {
+				add1Prong(rO, xO, cpTrees, y);
+				return undefined;
+			}
+			// return undefined;
+		}
+		
+		if (typeof _debug_ !== 'undefined') { xs.push({ x, y, z: createPos(z.curve, z.t, false), t: y.t }); }
+
+	
+		if (!isHoleClosing) {
+			if (yz <= squaredSeperationTolerance) {
+				// if (typeof _debug_ !== 'undefined') { console.log(`failed: seperation too small - ${sqrt(yz)}`); }
+				return undefined;
+			} 
+		}
+
+		// Find the point on the line connecting y with x that is  
+		// equidistant from y and z. This will be our next x.
+		const nextX = findEquidistantPointOnLineDd(x, y.p, z.p);
+		const error = abs(sqrt(xy) - sqrt(xz));
+		// if (xy < xz) { return undefined; }
+		
+		x = nextX;
+
+		if (error < errorTolerance) {
+			break;
+		} 
+
+		i++;
+		
+		if (i === MAX_ITERATIONS) {
+			// Convergence was too slow.
+			if (typeof _debug_ !== 'undefined') { console.log('failed (slow): max iterations reached'); }
+			return undefined;
+		}
+	}
+
+	// const zs_ = zs;
+	// console.log(zs.length)
+	// const zPos = createPos(z.curve, z.t, false);
+
+	const circle = { center: x, radius: distanceBetween(x, z.p) };
+
+	if (typeof _debug_ !== 'undefined') { addDebugInfo(bezierPieces, false, x, y, z, circle!, δ!, xs, isHoleClosing); }
+	
+	// return { circle, zs: zs_ };
+	return { circle, zs: zs };
+}
+
+
+function addDebugInfo2(isHoleClosing: boolean) {
+	if (typeof _debug_ !== 'undefined') {
+		const elems = _debug_.generated.elems;
+		const elem = isHoleClosing  ? elems.twoProng_holeClosing : elems.twoProng_regular
+		const elemStr = isHoleClosing ? 'hole-closing: ' + elem.length : 'regular: ' + elem.length;
+		console.log('failed: no closest point - ' + elemStr);
+	}
+}
+
+export { find2Prong }

package/src/{mat/find-mat → find-2-prong}/find-and-add-2-prongs-on-all-paths.ts

@@ -1,12 +1,13 @@
 import { LlRbTree } from 'flo-ll-rb-tree';
-import { Loop } from '../../loop.js';
-import { CpNode } from '../../cp-node.js';
-import { IPointOnShape } from '../../point-on-shape.js';
+import { Loop } from 'flo-boolean';
+import { CpNode } from '../cp-node/cp-node.js';
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
 import { findAndAdd2Prongs } from './find-and-add-2-prongs.js';
+import { fixOrdering } from '../find-mat/fix-ordering.js';
 
 
 /** 
- * @hidden
+ * @internal
  * Add 2 prongs. See comments on the add2Prong function.
  * @param loops
  * @param cpGraphs
@@ -15,19 +16,21 @@ import { findAndAdd2Prongs } from './find-and-add-2-prongs.js';
  * tolerances.
  */ 
 function findAndAdd2ProngsOnAllPaths(
+        cpNode: CpNode | undefined,
         loops: Loop[],
         cpGraphs: Map<Loop,LlRbTree<CpNode>>,
-        for2Prongss: IPointOnShape[][],
-        extreme: number) {
-
-    let cpNode;
+        for2Prongss: PointOnShape[][],
+        extreme: number,
+        for1Prongs: boolean) {
 
     for (let k=0; k<for2Prongss.length; k++) {
         const for2Prongs = for2Prongss[k];
-        const _cpNode = findAndAdd2Prongs(loops, cpGraphs, k, for2Prongs, extreme);
+        const _cpNode = findAndAdd2Prongs(loops, cpGraphs, k, for2Prongs, extreme, for1Prongs);
         cpNode = cpNode || _cpNode;
     }
 
+    fixOrdering(cpNode!);
+
     return cpNode;
 }
 

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

@@ -0,0 +1,88 @@
+/** @internal */
+declare const _debug_: Debug;
+
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { Debug } from '../debug/debug.js';
+import { Loop } from 'flo-boolean';
+import { CpNode } from '../cp-node/cp-node.js';
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import { getShapeBounds } from '../svg/get-shape-bounds.js';
+import { find2Prong } from './find-2-prong.js';
+import { add2Prong } from './add-2-prong.js';
+import { isPosDullCorner } from '../point-on-shape/is-pos-dull-corner.js';
+import { getCornerAtEnd } from '../curve/curve.js';
+import { getCorner } from '../corner/get-corner.js';
+import { rotate90Degrees, rotateNeg90Degrees } from 'flo-vector2d';
+
+
+const { PI, atan2 } = Math;
+const ANGLE = 15*PI/180;  // 15 degrees - don't make smaller than 2 degrees
+
+
+/**
+ * @internal
+ * Find and add two-prongs.
+ * @param loops 
+ * @param cpGraphs 
+ * @param k 
+ * @param for2Prongs 
+ * @param extreme The maximum coordinate value used to calculate floating point
+ * tolerances.
+ */
+function findAndAdd2Prongs(
+        loops: Loop[],
+        cpGraphs: Map<Loop,LlRbTree<CpNode>>,
+        k: number, 
+        for2Prongs: PointOnShape[],
+        extreme: number,
+        for1Prongs: boolean) {
+
+    let cpNode_;
+
+    const bounds = getShapeBounds(loops);
+    const squaredDiagonalLength = 
+        (bounds.maxX.p[0] - bounds.minX.p[0])**2 +
+        (bounds.maxY.p[1] - bounds.minY.p[1])**2;
+
+    for (let i=0; i<for2Prongs.length; i++) {
+        // const angles = [0];
+        let angles = [0];
+        const pos = for2Prongs[i];
+        if (pos.t === 1) {
+            const { curve } = pos;
+            const corner = getCorner(curve.ps, curve.next.ps);
+            if (corner.isQuiteDull) {
+                const tangentI = rotateNeg90Degrees(corner.tangents[0]);
+                const tangentO = rotateNeg90Degrees(corner.tangents[1]);
+                const a1 = ((atan2(tangentI[1], tangentI[0]) + 2*PI)%(2*PI));
+                const a2 = ((atan2(tangentO[1], tangentO[0]) + 2*PI)%(2*PI));
+                const a3 = ((a2 - a1) + 2*PI)%(2*PI);
+                let angle = ANGLE;
+                while (angle <= a3 - (ANGLE/2)) {
+                    angles.push(angle);
+                    angle += ANGLE;
+                }
+            }
+        }
+        for (let angle of angles) {
+            const twoProngInfo = find2Prong(
+                angle, loops, extreme, squaredDiagonalLength, cpGraphs, pos, false, k, for1Prongs
+            );
+
+            if (twoProngInfo) {
+                const { circle, zs } = twoProngInfo;
+                const cpNode = add2Prong(cpGraphs, circle, pos, zs, false, extreme);
+                cpNode_ = cpNode_ || cpNode;
+            }
+
+            if (typeof _debug_ !== 'undefined') {
+                if (i + 1 === _debug_.directives.stopAfterTwoProngsNum) { return undefined; }
+            }
+        }
+    }
+
+    return cpNode_;
+}
+
+
+export { findAndAdd2Prongs }

package/src/{mat/find-mat → find-2-prong}/find-and-add-hole-closing-2-prongs.ts

@@ -1,14 +1,14 @@
 import { LlRbTree } from 'flo-ll-rb-tree';
-import { Loop } from '../../loop.js';
-import { CpNode } from '../../cp-node.js';
-import { getShapeBounds } from '../../svg/get-shape-bounds.js';
-import { getMinYPos } from '../../svg/get-min-y-pos.js';
-import { find2Prong } from './find-2-prong/find-2-prong.js';
+import { Loop } from 'flo-boolean';
+import { CpNode } from '../cp-node/cp-node.js';
+import { getShapeBounds } from '../svg/get-shape-bounds.js';
+import { getMinYPos } from '../svg/get-min-y-pos.js';
+import { find2Prong } from './find-2-prong.js';
 import { add2Prong } from './add-2-prong.js';
 
 
 /**
- * @hidden
+ * @internal
  * Find and add two-prongs that remove any holes in the shape.
  * @param loops The loops (that as a precondition must be ordered from 
  * highest (i.e. smallest y-value) topmost point loops to lowest)
@@ -34,7 +34,7 @@ function findAndAddHoleClosing2Prongs(
         const posSource = minYs[k];
         
         const holeClosingTwoProng = find2Prong(
-            loops, extreme, squaredDiagonalLength, cpTrees, posSource, true, k
+            0, loops, extreme, squaredDiagonalLength, cpTrees, posSource, true, k, false
         );
 
         if (!holeClosingTwoProng) {