flo-mat 4.1.4 → 5.0.1

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

@@ -7,7 +7,7 @@ import type { MatMeta } from '../mat/mat-meta.js';
 import { find2Prong } from './find-2-prong.js';
 import { add2Prong } from './add-2-prong.js';
 import { rotateNeg90Degrees } from 'flo-vector2d';
-import { getCorner } from '../corner/get-corner.js';
+import { getCorner$ } from '../corner/get-corner.js';
 
 
 const { PI, atan2 } = Math;
@@ -67,7 +67,7 @@ function getValidAngles(
     const angles = [0];
     if (ppos.t === 1) {
         const { curve } = ppos;
-        const corner = getCorner(curve.ps, curve.next.ps);
+        const corner = getCorner$(curve.ps, curve.next.ps);
         if (corner.isQuiteDull) {
             const tangentI = rotateNeg90Degrees(corner.tangents[0]);
             const tangentO = rotateNeg90Degrees(corner.tangents[1]);

package/src/find-2-prong/get-medial/get-antipodal-points.ts

@@ -9,7 +9,6 @@ import { getClosestPoint } from './get-closest-points.js';
  * bezier pieces, including the beziers actually checked after culling.
  * 
  * @param maxCoordPowerOf2
- * @param nnorm
  * @param yPos
  * @param for1Prong defaults to `false`;
  * @param angle angle from normal
@@ -19,7 +18,6 @@ import { getClosestPoint } from './get-closest-points.js';
  */
 function getAntipodalPoints(
         maxCoordPowerOf2: number,
-        nnorm: number[],
         nnormDd: number[][],
         yPos: PrePointOnShape,
         for1Prong: boolean,
@@ -31,7 +29,7 @@ function getAntipodalPoints(
         const curvePiece = curvePieces[i];
 
         const pInfos = getClosestPoint(
-            maxCoordPowerOf2, nnorm, nnormDd, yPos, for1Prong, angle,
+            maxCoordPowerOf2, nnormDd, yPos, for1Prong, angle,
             curvePiece
         );
 

package/src/find-2-prong/get-medial/get-closest-points.ts

@@ -4,21 +4,20 @@ import type { PrePointOnShape } from "../../point-on-shape/point-on-shape.js";
 import type { AntipodalPoint } from './antipodal-point.js';
 import { ddMultDouble1 } from 'double-double';
 import { lengthSquared } from "flo-vector2d";
-import { roots, Horner, ddHorner } from 'flo-poly';
-import { evalDeCasteljau, getMedialPointCoeffs, getMedialPointCoeffsBez0 } from 'flo-bezier3';
+import { roots, ddHorner } from 'flo-poly';
+import { evalDeCasteljau } from 'flo-bezier3';
 import { ddGetMedialPointCoeffs } from '../../get-medial-points/double-double/dd-get-medial-point-coeffs.js';
 import { ddGetMedialPointCoeffsBez2_SameCurve } from '../../get-medial-points/double-double/dd-get-medial-point-coeffs-bez2-same-curve.js';
 import { ddGetMedialPointCoeffsBez3_SameCurve } from '../../get-medial-points/double-double/dd-get-medial-point-coeffs-bez3-same-curve.js';
 import { ddGetMedialPointCoeffsBez0 } from '../../get-medial-points/double-double/dd-get-medial-point-coeffs-bez0.js';
 
-const { sqrt, abs, max } = Math;
+const { sqrt, abs } = Math;
 
 const qmd = ddMultDouble1;
 
 
 /**
  * @param maxCoordPowerOf2
- * @param nnorm
  * @param yPos The point on the shape
  * @param for1Prong defaults to `false`;
  * @param angle defaults to `0`;
@@ -28,7 +27,6 @@ const qmd = ddMultDouble1;
  */
 function getClosestPoint(
         maxCoordPowerOf2: number,
-        nnorm: number[], 
         nnormDd: number[][],
         yPos: PrePointOnShape,
         for1Prong: boolean,
@@ -90,8 +88,7 @@ function getClosestPoint(
             const _AS = abs(AS);
             // const _CS = abs(CS);
 
-            // if (max(_AS, _CS) < 2**-40) { continue; }
-            if (max(_AS) < 2**-40) { continue; }
+            if (_AS < 2**-40) { continue; }
 
             // const w = _AS > _CS
             //     ? -BS / AS
@@ -144,7 +141,7 @@ function getClosestPoint(
     //------------------------------------------
     const pLast = ps[ps.length - 1];
 
-    let dontPush1 = (
+    const dontPush1 = (
         (t === 0 && curve === touchedCurve!.prev) ||
         (t === 1 && curve === touchedCurve)
     );
@@ -177,7 +174,7 @@ function getClosestPoint(
             // which cannot be culled if this curve`s `t === 0` is included
         } else if (tE === 1) {
             if (!dontPush1 && !endPushed) {
-                PS.push({ P: pLast, t: 1 }); dontPush1 = true;
+                PS.push({ P: pLast, t: 1 });
             }
         } else {
             if (!endPushed) {
@@ -228,45 +225,3 @@ function getClosestPoint(
 
 
 export { getClosestPoint }
-
-
-
-/**
- * Recovers a numerically stable ray parameter `t` from linear equations
- * `A*t + B = 0` and (optionally) `C*t + D = 0` evaluated at a fixed `s`.
- *
- * If `C,D` are unavailable, this falls back to `-B/A`.
- */
-// function chooseStableT(
-//         A: number,
-//         B: number,
-//         C: number,
-//         D: number) {
-
-//     const epsScale = max(1, abs(A), abs(B), abs(C), abs(D));
-//     const eps = Number.EPSILON * epsScale;
-
-//     const denomAB = abs(A);
-//     const hasAB = denomAB > eps;
-//     const denomCD = abs(C);
-//     const hasCD = denomCD > eps;
-
-//     if (!hasAB && !hasCD) {
-//         return undefined;
-//     }
-//     if (hasAB && !hasCD) {
-//         return -B / A;
-//     }
-//     if (!hasAB && hasCD) {
-//         return -D / C;
-//     }
-
-//     const tAB = -B / A;
-//     const tCD = -D / C;
-
-//     // Score each candidate by how well it satisfies the *other* equation.
-//     const scoreAB = abs(C*tAB + D) / (abs(C) + abs(D) + eps);
-//     const scoreCD = abs(A*tCD + B) / (abs(A) + abs(B) + eps);
-
-//     return scoreAB <= scoreCD ? tAB : tCD;
-// }

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

@@ -2,7 +2,7 @@ import type { CurvePiece } from '../mat/curve-piece.js';
 import { getMedialPointCoeffsBez0 } from "flo-bezier3";
 import { lengthSquared, squaredDistanceBetween } from "flo-vector2d";
 
-const { abs } = Math;
+const { abs, sqrt } = Math;
 
 
 const TOLERANCE = 1 + 2**-20;
@@ -16,14 +16,16 @@ const TOLERANCE = 1 + 2**-20;
  * @internal
  */
 function reduceRadius(
-        maxCoordPowerOf2: number,
         rO: number,
-        curvePieces: CurvePiece[], 
+        curvePieces: CurvePiece[],
         y: number[],
         nnorm: number[]): number {
 
     let minRadiusSqrd = rO**2;
-    let x = [y[0] + nnorm[0], y[1] + nnorm[1]];
+    // the center of the initial circle (radius `rO`) - `nnorm` is not
+    // necessarily of unit length so scale it
+    const s = rO / sqrt(lengthSquared(nnorm));
+    let x = [y[0] + s*nnorm[0], y[1] + s*nnorm[1]];
 
     for (let i=0; i<curvePieces.length; i++) {
         const curvePiece = curvePieces[i];

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

@@ -31,7 +31,7 @@ function calcBetterX(
 
     let nu = 1;
     let better;
-    let newX;
+    let newX: number[];
     let newPoss: PrePointOnShape[];
     let newV;
     let i = 0;  // Safeguard
@@ -40,7 +40,7 @@ function calcBetterX(
         newX = translate(shift, x); 
 
         newPoss = curvePiece3s.map(curvePieces => 
-            getCloseBoundaryPointsCertified(curvePieces, x)[0]
+            getCloseBoundaryPointsCertified(curvePieces, newX)[0]
         );
 
         // Point of zero V

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

@@ -1,214 +1,197 @@
-import type { CpNode } from '../cp-node/cp-node.js';
-import type { CurvePiece } from '../mat/curve-piece.js';
-import type { ThreeProngInfo } from './three-prong-info.js';
-import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
-import { circumCenter as getCircumCenter, fromTo, len, distanceBetween, toUnitVector, rotate90Degrees, cross } from 'flo-vector2d';
-import { tangent } from 'flo-bezier3';
-import { calcInitial3ProngCenter } from './calc-initial-3-prong-center.js';
-import { getClosestPoints } from './get-closest-points.js';
-import { calcBetterX } from './calc-better-x.js';
-import { getCloseBoundaryPointsCertified } from '../closest-boundary-point/get-close-boundary-points-certified.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';
-import { isSharp } from '../cp-node/fs/is-sharp.js';
-
-const { min, abs, asin } = Math;
-
-
-/**
- * Finds a 3-prong using only the 3 given δs.
- * 
- * @param δs the boundary pieces
- * @param idx δ identifier
- * @param k δs identifier
- * @param curvePiecess
- * @param maxCoordPowerOf2
- * 
- * @internal
- */
-function find3ProngForDelta3s(
-        δs: [CpNode, CpNode][], 
-        idx: number, 
-        k: number,
-        curvePiecess: CurvePiece[][],
-        maxCoordPowerOf2: number): { error: number, threeProngInfo: ThreeProngInfo } | undefined {
-
-    const TOLERANCE = 2**(maxCoordPowerOf2 - 32);
-    const MAX_ITERATIONS = 10;
-
-    const δs_: [[CpNode,CpNode], [CpNode,CpNode], [CpNode,CpNode]] = [
-        δs[0],
-        δs[idx], 
-        δs[δs.length-1]
-    ];
-
-    const curvePieces_: [CurvePiece[], CurvePiece[], CurvePiece[]] = [
-        curvePiecess[0], 
-        curvePiecess[idx], 
-        curvePiecess[δs.length - 1]
-    ];
-
-    const δ3ss: [
-        [[CpNode, CpNode], [CpNode, CpNode], [CpNode, CpNode]],
-        [[CpNode, CpNode], [CpNode, CpNode], [CpNode, CpNode]],
-        [[CpNode, CpNode], [CpNode, CpNode], [CpNode, CpNode]]
-    ] = [
-        [δs_[0], δs_[1], δs_[2]],
-        [δs_[1], δs_[2], δs_[0]],
-        [δs_[2], δs_[0], δs_[1]],
-    ];
-
-    const curvePiecess_: [
-        [CurvePiece[], CurvePiece[], CurvePiece[]],
-        [CurvePiece[], CurvePiece[], CurvePiece[]],
-        [CurvePiece[], CurvePiece[], CurvePiece[]]
-    ] = [
-        [curvePieces_[0], curvePieces_[1], curvePieces_[2]],
-        [curvePieces_[1], curvePieces_[2], curvePieces_[0]],
-        [curvePieces_[2], curvePieces_[0], curvePieces_[1]],
-    ]
-
-
-    const δ3s = δ3ss[k];
-    const curvePiece3s = curvePiecess_[k];
-
-    if (isSharp(δ3s[0][0])) { return undefined; }
-
-    //----------------------------
-    // const l1 = curvePiece3s[0].length;
-    // const l2 = curvePiece3s[1].length;
-    // const l3 = curvePiece3s[2].length;
-    // if (l1 === 1 && l2 == 1 && l3 === 1) {
-    //     // console.log('aaa');
-    //     const A = curvePiece3s[0][0].curve.ps;
-    //     const B = curvePiece3s[1][0].curve.ps;
-    //     const C = curvePiece3s[2][0].curve.ps;
-
-    //     console.log(A.length, B.length, C.length);
-    // } else {
-    //     // console.log('bbb');
-    // }
-    //----------------------------
-
-
-    let poss: PrePointOnShape[] = undefined!;
-    let j = 0;  // Safeguard for slow convergence
-    let x = calcInitial3ProngCenter(δ3s, curvePiece3s);
-
-    let tolerance = Infinity;
-    while (tolerance > TOLERANCE && j < MAX_ITERATIONS) { 
-        j++;
-        
-        poss = getClosestPoints(x, curvePiece3s);
-        if (!Number.isFinite(x[0]) || !Number.isFinite(x[1])) {
-
-            // FUTURE - the code can be cleaned up and sped up a lot if we don't
-            // use this function as is but instead use δs[0] and δs[2] as is
-            // and make δs[1] include all the rest of the beziers around the 
-            // loop. This check, for instance, would be eliminated completely.
-            return undefined;
-        }
-
-        const circumCenter = getCircumCenter(poss.map(x => x.p));
-        const vectorToZeroV = fromTo(x, circumCenter);
-
-        if (!Number.isFinite(vectorToZeroV[0]) || !Number.isFinite(vectorToZeroV[1])) {
-
-            // FUTURE - the code can be cleaned up and sped up a lot if we don't
-            // use this function as is but instead use δs[0] and δs[2] as is
-            // and make δs[1] include all the rest of the beziers around the 
-            // loop. This check, for instance, would be eliminated completely.
-            return undefined;
-        }
-        const upds = calcBetterX(curvePiece3s, x, vectorToZeroV);
-        x = upds.newX;
-        poss = upds.newPoss;
-
-        const V = len(vectorToZeroV); // The 'potential'
-        
-        tolerance = abs(V - upds.newV);
-    }
-
-    const radius = (distanceBetween(x, poss[0].p) + 
-                    distanceBetween(x, poss[1].p) + 
-                    distanceBetween(x, poss[2].p)) / 3;
-
-    const circle = { center: x, radius };
-
-    //-------------------------------------------------------------------------
-    // Calculate the unit tangent vector at 3-prong circle points - they should 
-    // be very close to tangent to the boundary piece tangents at those points 
-    // (up to sign). Dull corners is a common special case.
-    //-------------------------------------------------------------------------
-    let totalAngleError = 0;
-    for (let i=0; i<3; i++) {
-        const pos = poss[i];
-        //----------------------------
-        // Tangent of circle at point
-        //----------------------------
-        const v = toUnitVector(fromTo(pos.p, x));
-        const v1 = rotate90Degrees(v);
-        
-        
-        //-----------------------------------
-        // Check if point is on dull crorner
-        //-----------------------------------
-        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 );
-                
-            const angleError1 = asin( cross( perps[0], v ) );
-            const angleError2 = asin( cross( v, perps[1] ) );
-            
-            let angleError = 0;
-            if (angleError1 > 0) { angleError += angleError1; }
-            if (angleError2 > 0) { angleError += angleError2; }
-            
-            totalAngleError += angleError;
-        } else {
-            //---------------------------
-            // Tangent of curve at point
-            //---------------------------
-            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
-            // and can thus just be added to cone method of looking at 
-            // tolerance.
-            
-            // Should be close to zero and is close to the actual angle.
-            const cross_ = abs( asin( cross(v1, v2) ) );
-            
-            totalAngleError += cross_;
-        }
-    }
-
-    //-------------------------------------------------------------------------
-    // Calculate radiusDelta, the difference between the radius and the closest
-    // point to the 3-prong. It should be around 0. If not, this is not a good 
-    // candidate for the 3-prong.
-    //-------------------------------------------------------------------------
-    const closestDs = [];
-    for (let i=0; i<curvePiecess.length; i++) {
-        const pos = getCloseBoundaryPointsCertified(
-            curvePiecess[i],
-            x
-        )[0];
-
-        closestDs.push( distanceBetween(pos.p, x) );
-    }
-    const closestD = min(...closestDs);
-    const radiusDelta = abs(radius - closestD);
-
-    // Weights below still need to be optimized.
-    const W1 = 1;
-    const W2 = 1;
-    const error = W1*radiusDelta + W2*totalAngleError;
-
-    return { threeProngInfo: { poss, circle, δ3s }, error };
-}
-
-
-export { find3ProngForDelta3s }
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { CurvePiece } from '../mat/curve-piece.js';
+import type { ThreeProngInfo } from './three-prong-info.js';
+import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
+import { circumCenter as getCircumCenter, fromTo, len, distanceBetween, toUnitVector, rotate90Degrees, cross } from 'flo-vector2d';
+import { tangent } from 'flo-bezier3';
+import { calcInitial3ProngCenter } from './calc-initial-3-prong-center.js';
+import { getClosestPoints } from './get-closest-points.js';
+import { calcBetterX } from './calc-better-x.js';
+import { getCloseBoundaryPointsCertified } from '../closest-boundary-point/get-close-boundary-points-certified.js';
+import { cullCurvePieces } from '../closest-boundary-point/cull-curve-pieces.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';
+import { isSharp } from '../cp-node/fs/is-sharp.js';
+
+const { abs, asin } = Math;
+
+
+/**
+ * Finds a 3-prong using only the 3 given δs.
+ * 
+ * @param δs the boundary pieces
+ * @param idx δ identifier
+ * @param k δs identifier
+ * @param curvePiecess the curve pieces of each boundary piece
+ * @param allCurvePieces all of the above flattened into one array
+ * @param maxCoordPowerOf2
+ * 
+ * @internal
+ */
+
+function find3ProngForDelta3s(
+        δs: [CpNode, CpNode][], 
+        idx: number, 
+        k: number,
+        curvePiecess: CurvePiece[][],
+        allCurvePieces: CurvePiece[],
+        maxCoordPowerOf2: number): { error: number, threeProngInfo: ThreeProngInfo } | undefined {
+
+    const TOLERANCE = 2**(maxCoordPowerOf2 - 32);
+    const MAX_ITERATIONS = 10;
+
+    // The three boundary pieces (and their curve pieces) with the first, 
+    // the `idx`th and the last taken, rotated so that the one with index `k`
+    // comes first (the first one is treated specially below).
+    const δs_ = [δs[0], δs[idx], δs[δs.length-1]];
+    const curvePieces_ = [curvePiecess[0], curvePiecess[idx], curvePiecess[δs.length-1]];
+    const r = (i: number) => (k + i) % 3;
+    const δ3s: [[CpNode,CpNode], [CpNode,CpNode], [CpNode,CpNode]] = 
+        [δs_[r(0)], δs_[r(1)], δs_[r(2)]];
+    const curvePiece3s: [CurvePiece[], CurvePiece[], CurvePiece[]] = 
+        [curvePieces_[r(0)], curvePieces_[r(1)], curvePieces_[r(2)]];
+
+    if (isSharp(δ3s[0][0])) { return undefined; }
+
+    //----------------------------
+    // const l1 = curvePiece3s[0].length;
+    // const l2 = curvePiece3s[1].length;
+    // const l3 = curvePiece3s[2].length;
+    // if (l1 === 1 && l2 == 1 && l3 === 1) {
+    //     // console.log('aaa');
+    //     const A = curvePiece3s[0][0].curve.ps;
+    //     const B = curvePiece3s[1][0].curve.ps;
+    //     const C = curvePiece3s[2][0].curve.ps;
+
+    //     console.log(A.length, B.length, C.length);
+    // } else {
+    //     // console.log('bbb');
+    // }
+    //----------------------------
+
+
+    let poss: PrePointOnShape[] = undefined!;
+    let j = 0;  // Safeguard for slow convergence
+    let x = calcInitial3ProngCenter(δ3s, curvePiece3s);
+
+    if (!Number.isFinite(x[0]) || !Number.isFinite(x[1])) {
+
+        // FUTURE - the code can be cleaned up and sped up a lot if we don't
+        // use this function as is but instead use δs[0] and δs[2] as is
+        // and make δs[1] include all the rest of the beziers around the 
+        // loop. This check, for instance, would be eliminated completely.
+        return undefined;
+    }
+
+    // the closest points on the three boundary pieces to the current center
+    poss = getClosestPoints(x, curvePiece3s);
+
+    let tolerance = Infinity;
+    while (tolerance > TOLERANCE && j < MAX_ITERATIONS) { 
+        j++;
+
+
+        const circumCenter = getCircumCenter(poss.map(x => x.p));
+        const vectorToZeroV = fromTo(x, circumCenter);
+
+        if (!Number.isFinite(vectorToZeroV[0]) || !Number.isFinite(vectorToZeroV[1])) {
+
+            // FUTURE - the code can be cleaned up and sped up a lot if we don't
+            // use this function as is but instead use δs[0] and δs[2] as is
+            // and make δs[1] include all the rest of the beziers around the 
+            // loop. This check, for instance, would be eliminated completely.
+            return undefined;
+        }
+        const upds = calcBetterX(curvePiece3s, x, vectorToZeroV);
+        x = upds.newX;
+        // `calcBetterX` already found the closest points at the new center -
+        // use them for the next iteration instead of searching again
+        poss = upds.newPoss;
+
+        const V = len(vectorToZeroV); // The 'potential'
+        
+        tolerance = abs(V - upds.newV);
+    }
+
+    const radius = (distanceBetween(x, poss[0].p) + 
+                    distanceBetween(x, poss[1].p) + 
+                    distanceBetween(x, poss[2].p)) / 3;
+
+    const circle = { center: x, radius };
+
+    //-------------------------------------------------------------------------
+    // Calculate the unit tangent vector at 3-prong circle points - they should 
+    // be very close to tangent to the boundary piece tangents at those points 
+    // (up to sign). Dull corners is a common special case.
+    //-------------------------------------------------------------------------
+    let totalAngleError = 0;
+    for (let i=0; i<3; i++) {
+        const pos = poss[i];
+        //----------------------------
+        // Tangent of circle at point
+        //----------------------------
+        const v = toUnitVector(fromTo(pos.p, x));
+        const v1 = rotate90Degrees(v);
+        
+        
+        //-----------------------------------
+        // Check if point is on dull crorner
+        //-----------------------------------
+        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 );
+                
+            const angleError1 = asin( cross( perps[0], v ) );
+            const angleError2 = asin( cross( v, perps[1] ) );
+            
+            let angleError = 0;
+            if (angleError1 > 0) { angleError += angleError1; }
+            if (angleError2 > 0) { angleError += angleError2; }
+            
+            totalAngleError += angleError;
+        } else {
+            //---------------------------
+            // Tangent of curve at point
+            //---------------------------
+            const v2 = toUnitVector( tangent(pos.curve.ps, pos.t) );
+            
+            // Cross is more numerically stable than Vector.dot at angles a
+            // multiple of π **and** is close to the actual angle value
+            // and can thus just be added to cone method of looking at 
+            // tolerance.
+            
+            // Should be close to zero and is close to the actual angle.
+            const cross_ = abs( asin( cross(v1, v2) ) );
+            
+            totalAngleError += cross_;
+        }
+    }
+
+    //-------------------------------------------------------------------------
+    // Calculate radiusDelta, the difference between the radius and the closest
+    // point to the 3-prong. It should be around 0. If not, this is not a good 
+    // candidate for the 3-prong.
+    //-------------------------------------------------------------------------
+    // Only boundary pieces that come within the radius of the center can be
+    // closer than the three touching pieces, so cull against the radius first
+    // (cheap, memoized bounding box tests) and run the (expensive) certified
+    // closest point search once on the survivors only. The touching pieces 
+    // always survive (their distance is about the radius) so the result is
+    // the true closest distance over all the boundary pieces.
+    const nearCurvePieces = cullCurvePieces(allCurvePieces, x, (1 + 2**-20)*radius*radius);
+    const closestPos = getCloseBoundaryPointsCertified(nearCurvePieces, x)[0];
+    const closestD = closestPos === undefined ? radius : distanceBetween(closestPos.p, x);
+    const radiusDelta = abs(radius - closestD);
+
+    // Weights below still need to be optimized.
+    const W1 = 1;
+    const W2 = 1;
+    const error = W1*radiusDelta + W2*totalAngleError;
+
+    return { threeProngInfo: { poss, circle, δ3s }, error };
+}
+
+
+export { find3ProngForDelta3s }