flo-mat 3.0.15 → 4.0.1

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

@@ -1,86 +1,63 @@
-import { evalDeCasteljau } from "flo-bezier3";
-import { dot, lineLineIntersection, squaredDistanceBetween } from "flo-vector2d";
-import { CurvePiece } from '../mat/curve-piece.js';
+import type { CurvePiece } from '../mat/curve-piece.js';
+import { getMedialPointCoeffsBez0 } from "flo-bezier3";
+import { lengthSquared, squaredDistanceBetween } from "flo-vector2d";
+
+const { abs } = Math;
+
+
+const TOLERANCE = 1 + 2**-20;
 
 
 /**
- * @internal
- * 
  * Reduces the circle radius initially as an optimization step.
+ * 
+ * @internal
  */
 function reduceRadius(
-        extreme: number,
+        maxCoordPowerOf2: number,
         curvePieces: CurvePiece[], 
-        p: number[],
-        x: number[]) {
+        y: number[],
+        nnorm: number[]): number {
 
-    const TOLERANCE = 1 + 2**-10;
+    let minRadius = Infinity;
+    let x = [y[0] + nnorm[0], y[1] + nnorm[1]];
 
-    let minRadius = Number.POSITIVE_INFINITY;
     for (let i=0; i<curvePieces.length; i++) {
         const curvePiece = curvePieces[i];
 
-        const ps = curvePiece.curve.ps;
-
-        // let min = Number.POSITIVE_INFINITY;
-        const num = 2;
-        for (let j=0; j<(num + 1); j++) {
-            const p_ = evalDeCasteljau(ps, curvePiece.ts[j/num]);
-            const cc = getCircleCenterFrom2PointsAndNormal(extreme, p, x, p_);
-            if (cc) {
-                let r = squaredDistanceBetween(p, cc);
-                if (r < minRadius) {
-                    minRadius = r;
-                }
-            }
-        }
-    }
-
-    // The extra bit is to account for floating point precision.
-    return TOLERANCE*minRadius;
-}
+        const { ps } = curvePiece.curve;
 
+        const pS = ps[0];
+        const pE = ps[ps.length - 1];
 
-/**
- * @internal
- * @param p A point on the circle with normal pointing to x towards the center
- * of the circle.
- * @param x
- * @param p1 Another point on the circle.
- */
-function getCircleCenterFrom2PointsAndNormal(
-        extreme: number, 
-        p: number[], 
-        x: number[],
-        p1: number[]) {
+        for (const P of [pS,pE]) {
+            if (squaredDistanceBetween(x,P) > minRadius) {
+                continue;  // short-circuit
+            }
 
-    const TOLERANCE = (2**-14*extreme)**2;
+            const { a0, b0 } = getMedialPointCoeffsBez0(y, nnorm, P);
 
-    // Ignore if p and p1 are too close together
-    if (squaredDistanceBetween(p,p1) < TOLERANCE) {
-        return undefined;
-    }
+            if (abs(a0) <= 2**-40 || abs(b0) <= 2**-40) {
+                continue;
+            }
 
-    /** The perpindicular bisector between the two given points on the circle */
-    const pb = [
-        (p[0] + p1[0]) / 2,
-        (p[1] + p1[1]) / 2,
-    ];
-    const tan = [p1[0] - p[0], p1[1] - p[1]];
-    const norm  = [-tan[1], tan[0]]; // Rotate by 90 degrees
-    const pb2 = [pb[0] + norm[0], pb[1] + norm[1]];
+            const w = -b0 / a0;
 
-    const res = lineLineIntersection([p,x], [pb, pb2]);
+            // too close to point of origin *or* negative;
+            if (w < 2**-40) { continue; }
 
-    if (!res) { return undefined; }
+            const N = [w*nnorm[0], w*nnorm[1]];
+            const r = lengthSquared(N);
 
-    const resO = [res[0] - p[0], res[1] - p[1]];
-    const xO = [x[0] - p[0], x[1] - p[1]];
-    if (dot(resO, xO) < 0) {
-        return undefined;
+            if (r < minRadius) {
+                minRadius = r;
+                x = [y[0] + N[0], y[1] + N[1]];
+            }
+        }
     }
 
-    return res;
+    // The extra bit is to account for floating point precision.
+    return TOLERANCE*minRadius;
 }
 
 

package/src/find-2-prong/x-for-debugging.ts

@@ -1,13 +1,13 @@
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+// import { PointOnShape } from '../point-on-shape/point-on-shape.js';
 
 
-/** @internal */
-type TXForDebugging = { 
-    x: number[]; 
-    y: PointOnShape; 
-    z: PointOnShape; 
-    t: number; 
-}
+// /** @internal */
+// type TXForDebugging = { 
+//     x: number[]; 
+//     y: PointOnShape; 
+//     z: PointOnShape; 
+//     t: number; 
+// }
 
 
-export { TXForDebugging }
+// export { TXForDebugging }

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

@@ -1,39 +1,46 @@
+import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
+import type { CurvePiece } from '../mat/curve-piece.js';
 import { fromTo, circumCenter, len, scale, translate } from 'flo-vector2d';
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { CurvePiece  } from '../mat/curve-piece.js';
 import { getClosestPoints } from './get-closest-points.js';
 
 
 /**
- * @internal
- * Find new x and ps that are a better estimate of the 3-prong circle.
+ * Find new `x` and `ps` that are better estimates of the 3-prong circle.
+ * 
  * The potential function, V, is defined as the distance to the actual 3 prong 
  * circle center.
+ * 
+ * @param maxCoordPowerOf2
  * @param curvePiece3s The three boundary pieces, each of which should contain 
  * a point of the 3-prong to be found.
  * @param x The currently best guess at the center of the 3-prong circle.
  * @param vectorToZeroV
- * @param extreme
+ * 
+ * @internal
  */
 function calcBetterX(
+        maxCoordPowerOf2: number,
         curvePiece3s: CurvePiece[][], 
         x: number[], 
-        vectorToZeroV: number[]) {
+        vectorToZeroV: number[]): {
+            newX: number[];
+            newV: number;
+            newPoss: PrePointOnShape[];
+        } {
 
     const V = len(vectorToZeroV);
 
     let nu = 1;
     let better;
     let newX;
-    let newPoss: PointOnShape[];
+    let newPoss: PrePointOnShape[];
     let newV;
-    let i = 0; // Safeguard
+    let i = 0;  // Safeguard
     do { 
         const shift = scale(vectorToZeroV, nu);
         newX = translate(shift, x); 
-        
-        
-        newPoss = getClosestPoints(newX, curvePiece3s);
+
+        newPoss = getClosestPoints(maxCoordPowerOf2, newX, curvePiece3s);
 
         // Point of zero V
         const newCircleCenter = circumCenter(newPoss.map(pos => pos!.p)); 

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

@@ -1,40 +1,38 @@
-/** @internal */
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { CurvePiece } from '../mat/curve-piece.js';
 import { circumCenter } from 'flo-vector2d';
-import { CpNode      } from '../cp-node/cp-node.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
  * Finds an initial 3-prong circle center point from which to iterate. The point 
  * must be within the shape. 
- * @param δ3s - The three boundary pieces of which we need to find the three 
+ * 
+ * @param maxCoordPowerOf2
+ * @param δ3s the three boundary pieces of which we need to find the three 
  * 3-prong points.
  * @param curvePiece3s 
- * @param extreme 
+ * 
+ * @internal
  */
 function calcInitial3ProngCenter(
-        maxCoordinate: number,
+        maxCoordPowerOf2: number,
         δ3s: CpNode[][], 
         curvePiece3s: CurvePiece[][]) {
 
-    const circle = δ3s[0][0].cp.circle;
+    const circle = δ3s[0][0].pointOnShape.circle;
     const twoProngCircleCenter = circle.center;
 
-    const pow = max(0,ceil(log2(maxCoordinate/circle.radius))) + 1;  // determines accuracy;
     const pos = getCloseBoundaryPointsCertified(
-        pow,
+        maxCoordPowerOf2,
         curvePiece3s[1],
         twoProngCircleCenter
     )[0];
 
     const meanPoints = [
-        δ3s[0][0].cp.pointOnShape.p, 
+        δ3s[0][0].pointOnShape.p, 
         pos.p,
-        δ3s[2][1].cp.pointOnShape.p,
+        δ3s[2][1].pointOnShape.p,
     ];
 
     return circumCenter(meanPoints);

package/src/{find-3-prong.ts → find-3-prong}/find-3-prong-for-delta3s.ts

@@ -1,44 +1,40 @@
-import { 
-    fromTo, circumCenter, len, distanceBetween, toUnitVector, rotate90Degrees,
-    cross 
-} from 'flo-vector2d';
+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 { fromTo, circumCenter as getCircumCenter, len, distanceBetween, toUnitVector, rotate90Degrees, cross } from 'flo-vector2d';
 import { tangent } from 'flo-bezier3';
-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 { 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 { getPosCorner$ } from '../point-on-shape/get-pos-corner.js';
+import { isSharp } from '../cp-node/fs/is-sharp.js';
 
-const { isSharp } = CpNodeFs;
-
-
-/** @internal */
-const calcVectorToZeroV_StraightToIt = fromTo;
+const { min, abs, asin } = Math;
 
 
 /**
- * @internal
  * Finds a 3-prong using only the 3 given δs.
- * @param δs The boundary pieces
+ * 
+ * @param δs the boundary pieces
  * @param idx δ identifier
+ * @param k δs identifier
  * @param curvePiecess
- * @param maxCoordinate The maximum coordinate value used to calculate floating point
- * tolerances.
+ * @param maxCoordPowerOf2
+ * 
+ * @internal
  */
 function find3ProngForDelta3s(
         δs: CpNode[][], 
         idx: number, 
         k: number,
         curvePiecess: CurvePiece[][],
-        maxCoordinate: number) {
+        maxCoordPowerOf2: number): { error: number, threeProngInfo: ThreeProngInfo } | undefined {
 
-    const TOLERANCE = 2**-32*maxCoordinate;
+    const TOLERANCE = 2**(maxCoordPowerOf2 - 32);
     const MAX_ITERATIONS = 10;
 
     const δs_ = [
@@ -72,44 +68,42 @@ function find3ProngForDelta3s(
     if (isSharp(δ3s[0][0])) { return undefined; }
 
 
-    let poss: PointOnShape[] = undefined!;
-    let circumCenter_;
-    let j = 0; // Safeguard for slow convergence
-    let x = calcInitial3ProngCenter(maxCoordinate, δ3s, curvePiece3s);
+    let poss: PrePointOnShape[] = undefined!;
+    let j = 0;  // Safeguard for slow convergence
+    let x = calcInitial3ProngCenter(maxCoordPowerOf2, δ3s, curvePiece3s);
 
-    let tolerance = Number.POSITIVE_INFINITY;
+    let tolerance = Infinity;
     while (tolerance > TOLERANCE && j < MAX_ITERATIONS) { 
         j++;
         
-        poss = getClosestPoints(x, curvePiece3s);
+        poss = getClosestPoints(maxCoordPowerOf2, x, curvePiece3s);
         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
+            // 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;
         }
 
-        circumCenter_ = circumCenter(poss.map(x => x!.p));
-
-        const vectorToZeroV = calcVectorToZeroV_StraightToIt(x, circumCenter_);
+        const circumCenter = getCircumCenter(poss.map(x => x.p));
+        const vectorToZeroV = fromTo(x, circumCenter);
 
         if (!Number.isFinite(vectorToZeroV[0]) || !Number.isFinite(vectorToZeroV[1])) {
 
-            // TODO - the code can be cleaned up and sped up a lot if we don't
+            // 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);
+        const upds = calcBetterX(maxCoordPowerOf2, curvePiece3s, x, vectorToZeroV);
         x = upds.newX;
         poss = upds.newPoss;
 
         const V = len(vectorToZeroV); // The 'potential'
         
-        tolerance = Math.abs(V - upds.newV);
+        tolerance = abs(V - upds.newV);
     }
 
     const radius = (distanceBetween(x, poss[0].p) + 
@@ -121,28 +115,28 @@ function find3ProngForDelta3s(
     //-------------------------------------------------------------------------
     // 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). Sharp corners are a common special case.
+    // (up to sign). Dull corners is a common special case.
     //-------------------------------------------------------------------------
     let totalAngleError = 0;
     for (let i=0; i<3; i++) {
-        const pos = poss![i];
+        const pos = poss[i];
         //----------------------------
         // Tangent of circle at point
         //----------------------------
-        const v = toUnitVector(fromTo(pos!.p, x));
+        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);
+        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 = Math.asin( cross( perps[0], v ) );
-            const angleError2 = Math.asin( cross( v, perps[1] ) );
+            const angleError1 = asin( cross( perps[0], v ) );
+            const angleError2 = asin( cross( v, perps[1] ) );
             
             let angleError = 0;
             if (angleError1 > 0) { angleError += angleError1; }
@@ -153,18 +147,18 @@ function find3ProngForDelta3s(
             //---------------------------
             // Tangent of curve at point
             //---------------------------
-            const v2 = toUnitVector( tangent(pos!.curve.ps, pos!.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
+            // 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_ = Math.abs( Math.asin( cross(v1, v2) ) );
+            const cross_ = abs( asin( cross(v1, v2) ) );
             
             totalAngleError += cross_;
-        }        
+        }
     }
 
     //-------------------------------------------------------------------------
@@ -174,22 +168,23 @@ function find3ProngForDelta3s(
     //-------------------------------------------------------------------------
     const closestDs = [];
     for (let i=0; i<curvePiecess.length; i++) {
-        const p = getCloseBoundaryPointsCertified(
-            5,  // TODO - see find-2-prong
-            curvePiecess[i], x
+        const pos = getCloseBoundaryPointsCertified(
+            maxCoordPowerOf2,
+            curvePiecess[i],
+            x
         )[0];
 
-        closestDs.push( distanceBetween(p.p, x) );
+        closestDs.push( distanceBetween(pos.p, x) );
     }
-    const closestD = Math.min(...closestDs);
-    const radiusDelta = Math.abs(radius - closestD);
+    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 { poss: poss!, circle, error, δ3s };
+    return { threeProngInfo: { poss, circle, δ3s }, error };
 }
 
 

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

@@ -0,0 +1,52 @@
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { ThreeProngInfo } from './three-prong-info.js';
+import { find3ProngForDelta3s } from './find-3-prong-for-delta3s.js';
+import { getBoundaryPieceBeziers } from '../mat/get-boundary-piece-beziers.js';
+import { timeFunctionCalls } from '../utils/time-function-call.js';
+
+
+/**
+ * Find and return a 3-prong from the given boundary piece.
+ * 
+ * @param δs A boundary piece
+ * @param maxCoordPowerOf2 The maximum coordinate power of 2 value used to
+ * calculate floating point tolerances.
+ * 
+ * @internal
+ */ 
+function find3Prong(
+        δs: CpNode[][],
+        maxCoordPowerOf2: number): ThreeProngInfo {
+
+    // FUTURE if `δs.length > (some threshold (say 4 or 5))` then add two-prongs
+    // to reduced the number of permutations required
+    // if (δs.length > 3) { console.log(δs.length); }
+
+    const curvePiecess = δs.map(getBoundaryPieceBeziers);
+
+    // The best candidate amongst the different 'permutations' of the given δs.
+    let threeProng: ThreeProngInfo;
+
+    let smallestError = Infinity;
+    for (let i=1; i<δs.length - 1; i++) {
+        for (let k=0; k<3; k++) {
+            const r = find3ProngForDelta3s(
+                δs, i, k, curvePiecess, maxCoordPowerOf2
+            );
+
+            if (r === undefined) { continue; }
+
+            const { error, threeProngInfo } = r;
+
+            if (error < smallestError) {
+                smallestError = error;
+                threeProng = threeProngInfo;
+            }
+        }
+    }
+
+    return threeProng!;
+}
+
+
+export { find3Prong }

package/src/{find-3-prong.ts → find-3-prong}/find-and-add-3-prong.ts

@@ -26,13 +26,13 @@ function findAndAdd3Prong(
         δs.push([visitedCp, visitedCp.next]);
     }
     
-    const threeProngInfo = find3Prong(δs, meta.maxCoordinate);
+    const threeProngInfo = find3Prong(δs, meta.maxCoordPowerOf2);
 
     const { circle, poss, δ3s } = threeProngInfo;
     
     const orders: number[] = [];
     for (let i=0; i<3; i++) {
-        orders.push(calcPosOrder(circle, poss[i]));
+        orders.push(calcPosOrder(circle.center, poss[i]));
     }
 
     const closeBysFor3Prong: CpNode[] = [];

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

@@ -28,7 +28,7 @@ function findAndAdd3Prongs(
         meta: MatMeta,
         cpStart: CpNode) {
 
-    if (isPosSharpCorner(cpStart.cp.pointOnShape)) {
+    if (isPosSharpCorner(cpStart.pointOnShape)) {
         return { closeBysFor3Prong: undefined, addedCpNodes: [] };
     }
 

package/src/{find-3-prong.ts → find-3-prong}/get-closest-points.ts

@@ -1,21 +1,24 @@
-import { CurvePiece  } from '../mat/curve-piece.js';
+import type { CurvePiece  } from '../mat/curve-piece.js';
 import { getCloseBoundaryPointsCertified } from '../closest-boundary-point/get-close-boundary-points-certified.js';
 
 
 /**
- * @internal
+ * @param maxCoordPowerOf2
  * @param x 
  * @param curvePiece3s 
- * @param extreme 
+ * 
+ * @internal
  */
 function getClosestPoints(
+        maxCoordPowerOf2: number,
         x: number[], 
         curvePiece3s: CurvePiece[][]) {
 
     return curvePiece3s.map(curvePieces => {
         return getCloseBoundaryPointsCertified(
-            5,  // TODO - see find-2-prong
-            curvePieces, x
+            maxCoordPowerOf2,
+            curvePieces,
+            x
         )[0];
     });
 }

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

@@ -0,0 +1,13 @@
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { Circle } from '../geometry/circle.js';
+import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
+
+
+interface ThreeProngInfo {
+    readonly circle: Circle;
+    readonly poss: PrePointOnShape[];
+    readonly δ3s: CpNode[][];
+}
+
+
+export type { ThreeProngInfo }

package/src/find-mat/clip-options.ts

@@ -1,34 +1,29 @@
-import { MatOptionMeta, matOptionRanges, MatOptions } from './mat-options.js';
+import type { Mutable } from '../utils/mutable.js';
+import { matOptionRanges, type MatOptions } from './mat-options.js';
 
 
 function clipOptions(
-        maxCoordinate: number,
-        maxRadius: number,
+        maxCoordPowerOf2: number,
         options: Required<MatOptions>): Required<MatOptions> {
 
-    const expMaxCoord = Math.ceil(Math.log2(maxCoordinate));
-    const expMaxRadius = Math.ceil(Math.log2(maxRadius));
     const scaleSigBits = 10;  // 1024 x 1024
 
-    const options_ = { ...options };
+    const options_: Mutable<Required<MatOptions>> = { ...options };
+
     for (const k in matOptionRanges) {
-        // @ts-ignore
-        let o = options_[k];
-        // @ts-ignore
-        const c = matOptionRanges[k] as MatOptionMeta;
-        const { range, scaleByMaxCoordinate, scaleByMaxRadius } = c;
+        const key = k as keyof typeof matOptionRanges;
+        let o = options_[key];
+        const c = matOptionRanges[key];
+        const { range, scaleByMaxCoordinate } = c;
         if (o < range[0]) { o = range[0]; }
         if (o > range[1]) { o = range[1]; }
 
         // Adjust length tolerance according to a reference max coordinate
         if (!!scaleByMaxCoordinate) {
-            o = o * (2**expMaxCoord * 2**(-scaleSigBits));
-        } else if (!!scaleByMaxRadius) {
-            o = o * (2**expMaxRadius * 2**(-scaleSigBits));
+            o *= 2**(maxCoordPowerOf2 - scaleSigBits);
         }
 
-        // @ts-ignore
-        options_[k] = o;
+        options_[key] = o;
     }
 
     return options_;