flo-mat 3.0.0 → 3.0.2

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

@@ -1,16 +1,7 @@
-/** @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';
@@ -19,9 +10,11 @@ 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';
+import { MatMeta } from '../mat/mat-meta.js';
+import { calcSeperationTolerance } from './calc-seperation-tolerance.js';
 
 
-const { sqrt, abs, sin, cos } = Math;
+const { ceil, log2, max, sqrt, abs, sin, cos } = Math;
 
 
 /**
@@ -40,105 +33,112 @@ const { sqrt, abs, sin, cos } = Math;
  *    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 maxCoordinate 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
+ * @param loopIdx The loop array index
  */
-
 function find2Prong(
-		angle: number,
-		loops: Loop[],
-		extreme: number,
-		squaredDiagonalLength: number,
-		cpTrees: Map<Loop,LlRbTree<CpNode>>,
-        y: PointOnShape,
+		meta: MatMeta,
 		isHoleClosing: boolean,
-		k: number,
-		for1Prong: boolean): { circle: Circle,	zs: PointOnShape[] } | undefined {
+		for1Prong: boolean,
+		angle: number,
+        y: PointOnShape): { circle: Circle,	zs: PointOnShape[] } | undefined {
+
+	const { loops, maxCoordinate, squaredDiagonalLength, cpTrees } = meta;
+
+	const loop = y.curve.loop;
 
 	const MAX_ITERATIONS = 25;
-	const squaredSeperationTolerance = ((2**-21)*extreme)**2;
-	const errorTolerance = (2**-46)*extreme;
+	const minSquaredSeperationTolerance = ((2**-21)*maxCoordinate)**2;
+	const errorTolerance = (2**-46)*maxCoordinate;
+	// const errorTolerance = (2**-28)*maxCoordinate;
 	const maxOsculatingCircleRadius = sqrt(squaredDiagonalLength);
 	const minCurvature = 1/maxOsculatingCircleRadius;
+	const oneProngTolerance = (2**-16)*maxCoordinate;
+
+	const [xO,rO] = getO(
+		angle, isHoleClosing, maxOsculatingCircleRadius, minCurvature, y
+	);
 
-	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 }
+	let bezierPieces = getInitialBezierPieces(
+		angle, isHoleClosing, loop, loops, cpTrees, y, { center: xO, radius: rO }
 	);
+	// console.log(bezierPieces.length);
 
 	/** 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));
+	const r_ = sqrt(reduceRadius(maxCoordinate, 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,
+		if (i < 2) { bezierPieces = cullBezierPieces2(bezierPieces, x, xy); }
+		const pow = max(0,ceil(log2(maxCoordinate/xy))) + 1;  // determines accuracy
+		// console.log(pow);
+		const _zs = getCloseBoundaryPointsCertified(
+			pow, bezierPieces, x, y.curve, y.t,
 			for1Prong && i == 0 && rO !== 1/minCurvature,
 			angle
 		).map(info => createPos(info.curve, info.t, false));
 
-		z = zs[0];
+		let maxD = Number.NEGATIVE_INFINITY;
+		let maxPos: PointOnShape = undefined!;
+		zs = [];
+		for (const z of _zs) {
+			if (z === undefined) { continue; }
+			const _yz = squaredDistanceBetweenDd(y.p, z.p);
+			if (_yz > maxD) {
+				maxD = _yz;
+				maxPos = z;
+			}
+			if (_yz !== 0) {
+				zs.push(z);
+			}
+		}
+		// z = zs[0];
+		const yz = maxD;
+		z = maxPos;
 
-		if (z === undefined) {
-			addDebugInfo2(isHoleClosing);
+		if (z === undefined || yz === 0) {
+			// 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);
+			if (rO < (1 - oneProngTolerance)*sqrt(xz)) {
+				// console.log('1prong');
+				add1Prong(meta, rO, xO, y);
 				return undefined;
 			}
-			// return undefined;
 		}
 		
-		if (typeof _debug_ !== 'undefined') { xs.push({ x, y, z: createPos(z.curve, z.t, false), t: y.t }); }
+		// if (typeof _debug_ !== 'undefined') { xs.push({ x, y, z: createPos(z.curve, z.t, false), t: y.t }); }
 
 	
 		if (!isHoleClosing) {
+			const squaredSeperationTolerance = max(calcSeperationTolerance(
+				rO, sqrt(xz), 2**2*errorTolerance
+			), minSquaredSeperationTolerance);
 			if (yz <= squaredSeperationTolerance) {
 				// if (typeof _debug_ !== 'undefined') { console.log(`failed: seperation too small - ${sqrt(yz)}`); }
 				return undefined;
@@ -161,31 +161,47 @@ function find2Prong(
 		
 		if (i === MAX_ITERATIONS) {
 			// Convergence was too slow.
-			if (typeof _debug_ !== 'undefined') { console.log('failed (slow): max iterations reached'); }
+			// 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 };
+	// if (typeof _debug_ !== 'undefined') { addDebugInfo(bezierPieces, false, x, y, z, circle!, δ!, xs, isHoleClosing); }
+
+	// return { circle, zs };
+	// zs = zs.filter(z => z !== undefined)
+	return { circle, zs: [z] };
 }
 
 
-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);
+function getO(
+		angle: number,
+		isHoleClosing: boolean,
+		maxOsculatingCircleRadius: number,
+		minCurvature: number,
+		y: PointOnShape) {
+
+	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_);
+		}
 	}
+
+	return [xO,rO] as [number[],number];
 }
 
+
 export { find2Prong }

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

@@ -0,0 +1,30 @@
+import { CpNode } from "../cp-node/cp-node.js";
+import { MatMeta } from "../mat/mat-meta.js";
+import { PointOnShape } from "../point-on-shape/point-on-shape.js";
+import { add2Prong } from "./add-2-prong.js";
+import { find2Prong } from "./find-2-prong.js";
+
+
+/**
+ * Just to simplify `find2Prong` a bit.
+ * 
+ * * Cannot be used with holeClosers or angles other than 0
+ * * Can be used after the mat has been found
+ */
+function findAndAdd2Prong(
+        meta: MatMeta,
+        y: PointOnShape): CpNode | undefined {
+
+    const twoProngInfo = find2Prong(meta, false, false, 0, y);
+    if (twoProngInfo === undefined) {
+        return undefined;
+    }
+
+    const { circle, zs } = twoProngInfo;
+    const cpNode = add2Prong(meta, circle, [y, ...zs], false);
+
+    return cpNode;
+}
+
+
+export { findAndAdd2Prong }

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

@@ -0,0 +1,37 @@
+import { LlRbTree } from 'flo-ll-rb-tree';
+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 { MatMeta } from '../mat/mat-meta.js';
+
+
+/** 
+ * @internal
+ * Add 2 prongs. See comments on the add2Prong function.
+ *
+ * @param meta
+ * @param angleIncrement
+ * @param for2Prongss
+ * @param for1Prongs
+ */ 
+function findAndAdd2ProngsOnAllLoops(
+        meta: MatMeta,
+        angleIncrement: number,
+        for2Prongss: PointOnShape[][],
+        for1Prongs: boolean) {
+
+    let cpNode: CpNode | undefined;
+    for (let k=0; k<for2Prongss.length; k++) {
+        const for2Prongs = for2Prongss[k];
+        const _cpNode = findAndAdd2Prongs(
+            meta, angleIncrement, for2Prongs, for1Prongs
+        );
+        cpNode = cpNode === undefined ? _cpNode : cpNode;
+    }
+
+    return cpNode;
+}
+
+
+export { findAndAdd2ProngsOnAllLoops }

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

@@ -1,52 +1,38 @@
 /** @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 { rotateNeg90Degrees } from 'flo-vector2d';
+import { MatMeta } from '../mat/mat-meta.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
+// 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 meta 
+ * @param angleIncrement 
  * @param for2Prongs 
- * @param extreme The maximum coordinate value used to calculate floating point
- * tolerances.
+ * @param for1Prong
  */
 function findAndAdd2Prongs(
-        loops: Loop[],
-        cpGraphs: Map<Loop,LlRbTree<CpNode>>,
-        k: number, 
+        meta: MatMeta,
+        angleIncrement: number,
         for2Prongs: PointOnShape[],
-        extreme: number,
-        for1Prongs: boolean) {
+        for1Prong: 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;
-
+    const angleIncrement_ = angleIncrement*PI/180;
     for (let i=0; i<for2Prongs.length; i++) {
-        // const angles = [0];
-        let angles = [0];
+        const angles = [0];
         const pos = for2Prongs[i];
         if (pos.t === 1) {
             const { curve } = pos;
@@ -54,24 +40,25 @@ function findAndAdd2Prongs(
             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 tangentI = corner.tangents[0];
+                // const tangentO = 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)) {
+                let angle = angleIncrement_;
+                while (angle <= a3 - (angleIncrement_/2)) {
                     angles.push(angle);
-                    angle += ANGLE;
+                    angle += angleIncrement_;
                 }
             }
         }
         for (let angle of angles) {
             const twoProngInfo = find2Prong(
-                angle, loops, extreme, squaredDiagonalLength, cpGraphs, pos, false, k, for1Prongs
+                meta, false, for1Prong, angle, pos
             );
-
             if (twoProngInfo) {
                 const { circle, zs } = twoProngInfo;
-                const cpNode = add2Prong(cpGraphs, circle, pos, zs, false, extreme);
+                const cpNode = add2Prong(meta, circle, [pos, ...zs], false);
                 cpNode_ = cpNode_ || cpNode;
             }
 

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

@@ -1,10 +1,8 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-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';
+import { MatMeta } from '../mat/mat-meta.js';
 
 
 /**
@@ -13,28 +11,25 @@ import { add2Prong } from './add-2-prong.js';
  * @param loops The loops (that as a precondition must be ordered from 
  * highest (i.e. smallest y-value) topmost point loops to lowest)
  * @param cpTrees
- * @param extreme The maximum coordinate value used to calculate floating point
+ * @param maxCoordinate The maximum coordinate value used to calculate floating point
  * tolerances.
  */
 function findAndAddHoleClosing2Prongs(
-        loops: Loop[],
-        cpTrees: Map<Loop,LlRbTree<CpNode>>,
-        extreme: number) {
+        meta: MatMeta) {
 
-    const bounds = getShapeBounds(loops);
-    const squaredDiagonalLength = 
-        (bounds.maxX.p[0] - bounds.minX.p[0])**2 +
-        (bounds.maxY.p[1] - bounds.minY.p[1])**2;
+    const { loops } = meta;
 
     // Find the topmost points on each loop.
     const minYs = loops.map(getMinYPos);
 
+    let cpNode: CpNode | undefined;
+
     // We start at 1 since 0 is the outer (root) loop
     for (let k=1; k<minYs.length; k++) {
         const posSource = minYs[k];
         
         const holeClosingTwoProng = find2Prong(
-            0, loops, extreme, squaredDiagonalLength, cpTrees, posSource, true, k, false
+            meta, true, false, 0, posSource
         );
 
         if (!holeClosingTwoProng) { 
@@ -45,8 +40,12 @@ function findAndAddHoleClosing2Prongs(
         // - currently we only handle case of single antipode (the general case)
         const { circle, zs: posAntipodes } = holeClosingTwoProng;
 
-        add2Prong(cpTrees, circle, posSource, [posAntipodes[0]], true, extreme);
-    }	
+        const _cpNode = add2Prong(meta, circle, [posSource, posAntipodes[0]], true);
+
+        cpNode = cpNode === undefined ? _cpNode : cpNode;
+    }
+
+    return cpNode;
 }
 
 

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

@@ -1,60 +1,52 @@
 import { LlRbTree } from 'flo-ll-rb-tree';
 import { Loop } from 'flo-boolean';
-import { getNeighbouringPoints } from '../mat/get-neighboring-cps.js';
+import { getCpNodeToLeftOrSame } from '../mat/get-cp-node-to-left-or-same.js';
 import { getBoundaryPieceBeziers } from '../mat/get-boundary-piece-beziers.js';
-import { BezierPiece  } from '../mat/bezier-piece.js';
+import { CurvePiece  } from '../mat/curve-piece.js';
 import { CpNode } from '../cp-node/cp-node.js';
 import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { isPosDullCorner } from '../point-on-shape/is-pos-dull-corner.js';
 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';
 
 
 /** @internal */
 function getInitialBezierPieces(
         angle: number,
         isHoleClosing: boolean,
-        k: number,
+        loop: Loop,
         loops: Loop[],
         cpTrees: Map<Loop,LlRbTree<CpNode>>,
         y: PointOnShape,
-        circle: Circle) {
+        circle: Circle): CurvePiece[] {
 
     if (isHoleClosing) {
-        const bezierPieces: BezierPiece[] = [];
-        for (let k2=0; k2<k; k2++) {
-            const pieces: BezierPiece[] = loops[k2].curves
-                .map(curve => ({ curve, ts: [0,1] }))
-            bezierPieces.push(...pieces);
-        }
-
-        return { bezierPieces, δ: undefined };
+        return loops
+        .filter(_loop => _loop !== loop)
+        .flatMap(loop => loop.curves
+            .map(curve => ({ curve, ts: [0,1] })));
     }
 
-    let bezierPieces: BezierPiece[];
-    const order = isPosDullCorner(y)
-            ? y.t === 1 && angle === 0
-                ? -1 
-                : y.t === 0
-                ? +1
-                : calcPosOrder(circle, y)
-            : 0;
-
-    const loop = loops[k];
-    const cpNode = getNeighbouringPoints(cpTrees.get(loop)!, y, order, 0)[0];
-    const δ = [cpNode, cpNode];
+    const order = isPosCorner(y) && getPosCorner(y).isDull
+        ? y.t === 1 && angle === 0
+            ? -1 
+            : y.t === 0
+            ? +1
+            : calcPosOrder(circle, y)
+        : 0;
+
+    const cpNode = getCpNodeToLeftOrSame(cpTrees.get(loop)!, y, order, 0);
     if (!cpNode || 
         // The special case if there is only a single sharp corner or 
-        // terminating 2-prong currently in the MAT. Don't remove!
+        // two-way terminating 2-prong currently in the MAT. Don't remove!
         (cpNode === cpNode.next.next) 
     ) {
-        bezierPieces = loop.curves
-            .map(curve => ({ curve, ts: [0,1] }))
-    } else {
-        bezierPieces = getBoundaryPieceBeziers(δ);	
+        return loop.curves
+        .map(curve => ({ curve, ts: [0,1] }));
     }
 
-    return { bezierPieces, δ };
+    return getBoundaryPieceBeziers([cpNode, cpNode]);
 }
 
 

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

@@ -1,6 +1,6 @@
 import { evalDeCasteljau } from "flo-bezier3";
 import { dot, lineLineIntersection, squaredDistanceBetween } from "flo-vector2d";
-import { BezierPiece } from '../mat/bezier-piece.js';
+import { CurvePiece } from '../mat/curve-piece.js';
 
 
 /**
@@ -10,40 +10,29 @@ import { BezierPiece } from '../mat/bezier-piece.js';
  */
 function reduceRadius(
         extreme: number,
-        bezierPieces: BezierPiece[], 
+        bezierPieces: CurvePiece[], 
         p: number[],
         x: number[]) {
 
     const TOLERANCE = 1 + 2**-10;
 
-    let prevP: number[] | undefined = undefined;
     let minRadius = Number.POSITIVE_INFINITY;
     for (let i=0; i<bezierPieces.length; i++) {
         const bezierPiece = bezierPieces[i];
 
         const ps = bezierPiece.curve.ps;
 
-        let r1 = Number.POSITIVE_INFINITY;
-        const p1 = evalDeCasteljau(ps, bezierPiece.ts[0]);
-
-        // Prevent evaluating the same points twice
-        if (!prevP || prevP[0] !== p1[0] || prevP[1] !== p1[1]) {
-            const cc1 = getCircleCenterFrom2PointsAndNormal(extreme, p, x, p1);
-            if (cc1) { r1 = squaredDistanceBetween(p, cc1);	}
-        }
-        
-        let r2 = Number.POSITIVE_INFINITY;
-        const p2 = evalDeCasteljau(ps, bezierPiece.ts[1]);
-
-        const cc2 = getCircleCenterFrom2PointsAndNormal(extreme, p, x, p2);
-        if (cc2) { r2 = squaredDistanceBetween(p, cc2);	}
-        
-        prevP = p2;
-        
-        const d = Math.min(r1, r2); 
-        
-        if (d < minRadius) {
-            minRadius = d;  
+        // let min = Number.POSITIVE_INFINITY;
+        const num = 2;
+        for (let j=0; j<(num + 1); j++) {
+            const p_ = evalDeCasteljau(ps, bezierPiece.ts[j/num]);
+            const cc = getCircleCenterFrom2PointsAndNormal(extreme, p, x, p_);
+            if (cc) {
+                let r = squaredDistanceBetween(p, cc);
+                if (r < minRadius) {
+                    minRadius = r;
+                }
+            }
         }
     }
 

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

@@ -0,0 +1,47 @@
+
+// interface ArraySet<T> {
+//     idxMap: Map<T,number>;
+//     arr: T[];
+// }
+
+
+// function add<T>(
+//         arraySet: ArraySet<T>,
+//         t: T) {
+
+//     const { arr, idxMap } = arraySet;
+//     arr.push(t);
+//     idxMap.set(t, arr.length-1);
+// }
+
+
+// function addAll<T>(
+//         arraySet: ArraySet<T>,
+//         ts: T[]) {
+
+//     for (const t of ts) {
+//         add(arraySet, t);
+//     }
+// }
+
+
+// function remove<T>(
+//         arraySet: ArraySet<T>,
+//         t: T) {
+
+//     const { arr, idxMap } = arraySet;
+//     const idx = idxMap.get(t);
+//     if (idx === undefined) {
+//         return false;
+//     }
+
+
+// }
+
+
+// const ArraySetFs = {
+//     add, addAll, remove
+// }
+
+
+// export { ArraySetFs }