flo-mat 4.1.5 → 5.0.2

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

@@ -1,6 +1,6 @@
 import type { CpNode } from '../cp-node/cp-node.js';
 import type { Circle } from '../geometry/circle.js';
-import type { PointOnShape, PrePointOnShape } from '../point-on-shape/point-on-shape.js';
+import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
 import type { MatMeta } from '../mat/mat-meta.js';
 import type { Mutable } from '../utils/mutable.js';
 import { calcPosOrder } from '../point-on-shape/calc-pos-order.js';
@@ -35,13 +35,6 @@ function add2Prong(
     const orderSource = calcPosOrder(circle.center, pposSource);
     const orderAntipode = calcPosOrder(circle.center, pposAntipode);
 
-    const posAntipode: PointOnShape = {
-        ...pposAntipode, circle, order: orderAntipode, order2: 0
-    };
-    const posSource: PointOnShape = {
-        ...pposSource, circle, order: orderSource, order2: 0
-    }
-
     // Make sure there isn't already a ContactPoint close by - it can cause
     // floating point stability issues.
     if (!!getCloseByCpIfExist(meta, pposSource, circle, orderSource, 0, 2)) {
@@ -55,7 +48,7 @@ function add2Prong(
         isHoleClosing, isHoleClosing, circle,
         [orderSource, orderAntipode],
         meta,
-        [posSource, posAntipode]
+        [pposSource, pposAntipode]
     );
 
     if (anyFailed) {

package/src/find-2-prong/calc-seperation-tolerance.ts

@@ -1,127 +1,46 @@
-import { ddAddDd, twoProduct, ddDiffDd, ddDivDd, twoDiff, ddMultDouble1 } from 'double-double';
-
-const tp = twoProduct;
-const qaq = ddAddDd;
-const qdq = ddDiffDd;
-const qmd = ddMultDouble1;
-
-const { acos } = Math;
-
-
 /**
- * Calculates and returns an appropriate seperation tolerance between `CpNode`s.
- * 
- * @param R radius of the circle implied by the curvature at the boundary
+ * Returns the *squared* separation tolerance between the two contact points
+ * `y` (the source point) and `z` (the antipode) of a candidate 2-prong: if
+ * `|yz|²` is below it the antipode is indistinguishable (to within the error
+ * tolerance `δ`) from the circle merely grazing the boundary at `y` - the
+ * near-1-prong case - and the 2-prong should be rejected.
+ *
+ * Derivation: the MAT circle (radius `r`) is tangent to the boundary at `y`
+ * and so is the osculating circle there (radius `R`), both centers lying on
+ * the inward normal at `y`. Approximating the boundary near `y` by the
+ * osculating circle, the MAT circle enlarged by `δ` crosses it at the angle
+ * `θ` (at the MAT center, measured from `y`) given by the law of cosines:
+ *
+ *     cos θ = (r(R-r) - rδ - δ²/2) / ((R-r)(r+δ))
+ *
+ * Points of the MAT circle within that angle of `y` are within `δ` of the
+ * boundary. The chord `|yz|` subtending `θ` is `2r·sin(θ/2)`, and since
+ * `2sin²(θ/2) = 1 - cos θ = (Rδ + δ²/2) / ((R-r)(r+δ))` the squared chord is
+ *
+ *     |yz|² = r²(2Rδ + δ²) / ((R-r)(r+δ))
+ *
+ * which is what is returned - in closed form, without the cancellation that
+ * recovering a tiny `θ` from `cos θ` suffers from.
+ *
+ * @param R radius of the osculating circle of the boundary at `y`
  * @param r radius of the MAT circle
- * @param θ angle between point...
+ * @param δ the error tolerance on distances
+ *
+ * @internal
  */
-function calcSeperationTolerance(
+function calcSquaredSeperationTolerance(
         R: number,
         r: number,
-        δ: number) {
+        δ: number): number {
 
-    const a = r + δ;
-    if (a >= R) {
+    if (r + δ >= R) {
+        // The enlarged MAT circle is at least as large as the osculating
+        // circle: every point on it is within tolerance of the boundary.
         return Infinity;
     }
 
-    const R_r_ = twoDiff(R,r);
-    const A_  = qmd(r,R_r_);  
-    const N_ = qdq(qdq(A_, tp(r,δ)), tp(δ,δ/2));
-    const D_ = qaq(A_,qmd(δ,R_r_));
-
-    const R_r = R - r;
-    const A = r*R_r; 
-    const N = A - r*δ - (δ*δ)/2;
-    const D = A + R_r*δ;    
-    const cosC = N/D;    
-    const Q = ddDivDd(N_,D_)[1];
-    // const Q = N_[1]/D_[1];
-    const C = acos(cosC);
-    const CC = acos(Q)
-
-    const θ = CC;
-
-    // return r*θ;
-    return r*θ;
+    return r*r*(2*R*δ + δ*δ) / ((R - r)*(r + δ));
 }
 
 
-export { calcSeperationTolerance }
-
-
-// Quokka tests
-
-// /**
-//  * Calculates and returns an appropriate seperation tolerance between `CpNode`s.
-//  * 
-//  * @param R radius of the circle implied by the curvature at the boundary
-//  * @param r radius of the MAT circle
-//  * @param θ angle between point...
-//  */
-// function calcSeperationTolerance2(
-//         R: number,
-//         r: number,
-//         δ: number) {
-
-//     const a = r + δ;
-//     if (a >= R) {
-//         return Infinity;
-//     }
-
-//     const b = R - r;
-//     const c = R;    
-    
-//     const N = c*c - a*a - b*b;
-//     const N_ = qdq(qdq(tp(c,c), tp(a,a)), tp(b,b));
-//     const D = 2*a*b;          
-//     const D_ = tp(-2*a,b);
-//     const Q = ddDivDd(N_,D_)[1];
-//     const cosC = -N/D;
-//     const C = acos(cosC);
-//     const CC = acos(Q);
-
-//     const θ = π - CC;
-
-//     return θ;
-//     // return r*θ;  // approximate arc with line
-// }
-
-
-// function degToRad(degrees: number) {
-//     return degrees/360*2*PI;
-// }
-// function radToDeg(rad: number) {
-//     return rad*360/2/PI;
-// }
-
-
-// const R = 699;
-// const r = 698;
-// const δ = 1000*2**-46;
-// calcSeperationTolerance(R,r,δ); 
-// calcSeperationTolerance2(R,r,δ);
-// calcSeperationTolerance3(R,r,δ);
-
-// // * see https://en.wikipedia.org/wiki/Law_of_cosines, Version suited to small angles
-// function calcSeperationTolerance3(
-//         R: number,
-//         r: number,
-//         δ: number) {
-
-//     const a = r + δ;
-//     const c = R - r;
-//     const b = R;    
-    
-//     // c² = (a - b)² + 4ab*sin²(θ/2) OR
-//     // (c² - (a - b)²)/4ab = sin²(θ/2)
-//     const cc = c*c; 
-//     const abc = a*a + b*b - 2*a*b;
-//     const A = cc - abc;
-//     const B = sqrt(A/(4*a*b));
-
-//     const θ = 2*asin(B);
-
-//     return θ;
-//     // return r*θ;  // approximate arc with line
-// }
+export { calcSquaredSeperationTolerance }

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

@@ -6,10 +6,10 @@ import { getInitialCurvePieces } from './get-initial-bezier-pieces.js';
 import { getAntipodalPoints } from './get-medial/get-antipodal-points.js';
 import { reduceRadius } from './reduce-radius.js';
 import { squaredDistanceBetweenDd } from './squared-distance-between-dd.js';
-import { cullCurvePieces } from './cull-bezier-pieces.js';
+import { cullCurvePieces } from '../closest-boundary-point/cull-curve-pieces.js';
 import { add1Prong } from './add-1-prong.js';
 import { toP } from '../point-on-shape/to-p.js';
-import { calcSeperationTolerance } from './calc-seperation-tolerance.js';
+import { calcSquaredSeperationTolerance } from './calc-seperation-tolerance.js';
 import { getInitialX } from './get-initial-x.js';
 import { ddNormal } from 'flo-bezier3';
 import { rotate } from 'flo-vector2d';
@@ -85,26 +85,24 @@ function find2Prong(
         );
 
         // The lines below is an optimization.
-        const xy2 = reduceRadius(maxCoordPowerOf2, rO, curvePieces, y, nnorm);
+        const xy2 = reduceRadius(rO, curvePieces, y, nnorm);
         const xy = sqrt(xy2);
 
         const l = sqrt(nnorm[0]**2 + nnorm[1]**2);
         xO = [y[0] + nnorm[0]/l*xy, y[1] + nnorm[1]/l*xy];
 
-        cullCurvePieces(curvePieces, xO, xy2);
+        // (the extra multiplier accounts for floating point error)
+        const culledCurvePieces = cullCurvePieces(curvePieces, xO, (1 + 2**-20)*xy2);
 
         const antipodalPoints = getAntipodalPoints(
-            maxCoordPowerOf2, nnorm, nnormDd, yPos,
+            maxCoordPowerOf2, nnormDd, yPos,
             for1Prong, angle,
-            curvePieces
+            culledCurvePieces
         );
 
         // FUTURE - if antipodalPoints.length > 1 let's just add an n-prong;
         if (antipodalPoints.length !== 1) {
             if (antipodalPoints.length === 0) {
-                if (isHoleClosing) {
-                    console.log(yPos)
-                }
                 return undefined;
             }
             if (!isHoleClosing && !areAllAntipodesSame(antipodalPoints, maxCoordPowerOf2)) {
@@ -144,7 +142,7 @@ function find2Prong(
             // The lines below eliminate cases where the found 2-prong is too
             // close to a one-prong
             const squaredSeperationTolerance = max(
-                calcSeperationTolerance(rO, sqrt(xz), (2**2)*errorTolerance),
+                calcSquaredSeperationTolerance(rO, sqrt(xz), (2**2)*errorTolerance),
                 minSquaredSeperationTolerance
             );
             if (yz <= squaredSeperationTolerance) {
@@ -171,7 +169,7 @@ function areAllAntipodesSame(
         // }
 
         const { x: x_ } = point[i];
-        if (abs(x[0] - x_[0]) > tol || abs(x[0] - x_[0]) > tol) {
+        if (abs(x[0] - x_[0]) > tol || abs(x[1] - x_[1]) > tol) {
             return false;
         }
     }

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