flo-mat 3.0.9 → 3.0.11

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

@@ -3,11 +3,11 @@ 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 { findEquidistantPointOnLineDd } from './find-equidistant-point-on-line-dd.js';
-import { getInitialBezierPieces } from './get-initial-bezier-pieces.js';
+import { getInitialCurvePieces } 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 { cullCurvePieces2 } 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';
@@ -41,166 +41,166 @@ const { ceil, log2, max, sqrt, abs, sin, cos } = Math;
  * @param loopIdx The loop array index
  */
 function find2Prong(
-		meta: MatMeta,
-		isHoleClosing: boolean,
-		for1Prong: boolean,
-		angle: number,
-        y: PointOnShape): { circle: Circle,	zs: PointOnShape[] } | undefined {
-
-	const { loops, maxCoordinate, squaredDiagonalLength } = meta;
-
-	const loop = y.curve.loop;
-
-	const MAX_ITERATIONS = 25;
-	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
-	);
-
-	const p = y.p;
-
-	// The boundary piece that should contain the other point of 
-	// the 2-prong circle. (Defined by start and end points).
-	let bezierPieces = getInitialBezierPieces(
-		angle, isHoleClosing, loop, loops, meta, 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(maxCoordinate, bezierPieces, p, xO));
-	if (rO > r_) {
-		x = interpolate(p, xO, r_/rO);
-	}
-
-	/** The antipode of the two-prong (successively refined) */
-	let zs: PointOnShape[] = undefined!;
-	let z: PointOnShape = undefined!;
-
-	let i = 0;
-	while (i < MAX_ITERATIONS) {
-		const xy = squaredDistanceBetweenDd(x, y.p);
-
-		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));
-
-		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 || yz === 0) {
-			// addDebugInfo2(isHoleClosing);
-			return undefined;
-		}
-
-		const xz = squaredDistanceBetweenDd(x, z.p);
-
-		// if on first try
-		if (i === 0) {
-			if (rO < (1 - oneProngTolerance)*sqrt(xz)) {
-				// console.log('1prong');
-				add1Prong(meta, rO, xO, y);
-				return undefined;
-			}
-		}
-		
-		// 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;
-			} 
-		}
-
-		// 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 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 = zs.filter(z => z !== undefined)
-	return { circle, zs: [z] };
+        meta: MatMeta,
+        isHoleClosing: boolean,
+        for1Prong: boolean,
+        angle: number,
+        y: PointOnShape): { circle: Circle,    zs: PointOnShape[] } | undefined {
+
+    const { loops, maxCoordinate, squaredDiagonalLength } = meta;
+
+    const loop = y.curve.loop;
+
+    const MAX_ITERATIONS = 25;
+    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
+    );
+
+    const p = y.p;
+
+    // The boundary piece that should contain the other point of 
+    // the 2-prong circle. (Defined by start and end points).
+    let curvePieces = getInitialCurvePieces(
+        angle, isHoleClosing, loop, loops, meta, y, { center: xO, radius: rO }
+    );
+    // console.log(curvePieces.length);
+
+    /** The center of the two-prong (successively refined) */
+    let x = xO;
+
+    // The lines below is an optimization.
+    const r_ = sqrt(reduceRadius(maxCoordinate, curvePieces, p, xO));
+    if (rO > r_) {
+        x = interpolate(p, xO, r_/rO);
+    }
+
+    /** The antipode of the two-prong (successively refined) */
+    let zs: PointOnShape[] = undefined!;
+    let z: PointOnShape = undefined!;
+
+    let i = 0;
+    while (i < MAX_ITERATIONS) {
+        const xy = squaredDistanceBetweenDd(x, y.p);
+
+        if (i < 2) { curvePieces = cullCurvePieces2(curvePieces, x, xy); }
+        const pow = max(0,ceil(log2(maxCoordinate/xy))) + 1;  // determines accuracy
+        // console.log(pow);
+        const _zs = getCloseBoundaryPointsCertified(
+            pow, curvePieces, x, y.curve, y.t,
+            for1Prong && i == 0 && rO !== 1/minCurvature,
+            angle
+        ).map(info => createPos(info.curve, info.t, false));
+
+        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 || yz === 0) {
+            // addDebugInfo2(isHoleClosing);
+            return undefined;
+        }
+
+        const xz = squaredDistanceBetweenDd(x, z.p);
+
+        // if on first try
+        if (i === 0) {
+            if (rO < (1 - oneProngTolerance)*sqrt(xz)) {
+                // console.log('1prong');
+                add1Prong(meta, rO, xO, y);
+                return undefined;
+            }
+        }
+        
+        // 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;
+            } 
+        }
+
+        // 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 circle = { center: x, radius: distanceBetween(x, z.p) };
+
+    // if (typeof _debug_ !== 'undefined') { addDebugInfo(curvePieces, false, x, y, z, circle!, δ!, xs, isHoleClosing); }
+
+    // return { circle, zs };
+    // zs = zs.filter(z => z !== undefined)
+    return { circle, zs: [z] };
 }
 
 
 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];
+        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];
 }
 
 

package/src/find-2-prong/find-equidistant-point-on-line-dd.ts

@@ -1,6 +1,6 @@
 import {
-	twoDiff, twoSum, twoProduct, doubleDivDouble, ddDivDd,
-	ddAddDd, ddDiffDd, ddMultDd, ddMultBy2, ddMultDouble1
+    twoDiff, twoSum, twoProduct, doubleDivDouble, ddDivDd,
+    ddAddDd, ddDiffDd, ddMultDd, ddMultBy2, ddMultDouble1
 } from "double-double";
 
 
@@ -20,57 +20,57 @@ const tp = twoProduct;
  * @param z
   */
 function findEquidistantPointOnLineDd(
-		x: number[],
-		y: number[],
-		z: number[]) {
-	// Some basic algebra (not shown) finds the required point.
-	
-	// Swap axes if x and y are more aligned to y-axis than to x-axis.
-	const swapAxes = abs(x[1] - y[1]) > abs(x[0] - y[0]);
-	
-	// Cache
-	let x1: number;
-	let x2: number;
-	let y1: number;
-	let y2: number;
-	let z1: number;
-	let z2: number;
-	
-	if (swapAxes) {
-		x1 = x[1];	x2 = x[0];
-		y1 = y[1];	y2 = y[0];
-		z1 = z[1];	z2 = z[0];	
-	} else {
-		x1 = x[0];	x2 = x[1];
-		y1 = y[0];	y2 = y[1];
-		z1 = z[0];	z2 = z[1];
-	}
-	
-	// a <= 1 (due to swapped axes)
-	// const a = (x2 - y2) / (x1 - y1); 
-	// const b = y2 - a*y1;
-	// const c = (y1*y1 + y2*y2 - z1*z1 - z2*z2) + 2*b*(z2 - y2);
-	// const d = y1 - z1 + a*(y2 - z2);
-	// const t1 = c/(2*d);
-	// const t2 = a*t1 + b;
+        x: number[],
+        y: number[],
+        z: number[]) {
+    // Some basic algebra (not shown) finds the required point.
+    
+    // Swap axes if x and y are more aligned to y-axis than to x-axis.
+    const swapAxes = abs(x[1] - y[1]) > abs(x[0] - y[0]);
+    
+    // Cache
+    let x1: number;
+    let x2: number;
+    let y1: number;
+    let y2: number;
+    let z1: number;
+    let z2: number;
+    
+    if (swapAxes) {
+        x1 = x[1];    x2 = x[0];
+        y1 = y[1];    y2 = y[0];
+        z1 = z[1];    z2 = z[0];    
+    } else {
+        x1 = x[0];    x2 = x[1];
+        y1 = y[0];    y2 = y[1];
+        z1 = z[0];    z2 = z[1];
+    }
+    
+    // a <= 1 (due to swapped axes)
+    // const a = (x2 - y2) / (x1 - y1); 
+    // const b = y2 - a*y1;
+    // const c = (y1*y1 + y2*y2 - z1*z1 - z2*z2) + 2*b*(z2 - y2);
+    // const d = y1 - z1 + a*(y2 - z2);
+    // const t1 = c/(2*d);
+    // const t2 = a*t1 + b;
 
-	
-	const a = ddDivDd(td(x2,y2),td(x1,y1)); 
-	const b = ddDiffDd([0,y2], ddMultDouble1(y1,a));
+    
+    const a = ddDivDd(td(x2,y2),td(x1,y1)); 
+    const b = ddDiffDd([0,y2], ddMultDouble1(y1,a));
 
-	const c = ddAddDd(
-		(ddDiffDd(
-			ddAddDd(tp(y1,y1), tp(y2,y2)),
-			ddAddDd(tp(z1,z1), tp(z2,z2))
-		)),
-		ddMultBy2(ddMultDd(b,(td(z2,y2))))
-	);
+    const c = ddAddDd(
+        (ddDiffDd(
+            ddAddDd(tp(y1,y1), tp(y2,y2)),
+            ddAddDd(tp(z1,z1), tp(z2,z2))
+        )),
+        ddMultBy2(ddMultDd(b,(td(z2,y2))))
+    );
 
-	const d = ddAddDd(td(y1,z1), ddMultDd(a,td(y2,z2)));
-	const t1 = ddDivDd(c,ddMultBy2(d));
-	const t2 = ddAddDd(ddMultDd(a,t1), b);
-	
-	return swapAxes ? [t2[1],t1[1]] : [t1[1],t2[1]];
+    const d = ddAddDd(td(y1,z1), ddMultDd(a,td(y2,z2)));
+    const t1 = ddDivDd(c,ddMultBy2(d));
+    const t2 = ddAddDd(ddMultDd(a,t1), b);
+    
+    return swapAxes ? [t2[1],t1[1]] : [t1[1],t2[1]];
 }
 
 

package/src/find-2-prong/find-equidistant-point-on-line.ts

@@ -7,33 +7,33 @@
  * @returns The point on the line from y to x that is equidistant from y and z. 
  */
 function findEquidistantPointOnLine(x: number[], y: number[], z: number[]) {
-	// Some basic algebra (not shown) finds the required point.
-	
-	// Swap axes if x and y are more aligned to y-axis than to x-axis.
-	const swapAxes = Math.abs((x[1] - y[1]) / (x[0] - y[0])) > 1;
-	
-	// Cache
-	let x1, x2, y1, y2, z1, z2;
-	
-	if (swapAxes) {
-		x1 = x[1];	x2 = x[0];
-		y1 = y[1];	y2 = y[0];
-		z1 = z[1];	z2 = z[0];	
-	} else {
-		x1 = x[0];	x2 = x[1];
-		y1 = y[0];	y2 = y[1];
-		z1 = z[0];	z2 = z[1];
-	}
-	
-	// a <= 1 (due to swapped axes)
-	const a = (x2 - y2) / (x1 - y1); 
-	const b = y2 - a*y1;
-	const c = (y1*y1 + y2*y2 - z1*z1 - z2*z2) + 2*b*(z2 - y2);
-	const d = y1 - z1 + a*(y2 - z2);
-	const t1 = c/(2*d);
-	const t2 = a*t1 + b;
-	
-	return swapAxes ? [t2,t1] : [t1,t2];
+    // Some basic algebra (not shown) finds the required point.
+    
+    // Swap axes if x and y are more aligned to y-axis than to x-axis.
+    const swapAxes = Math.abs((x[1] - y[1]) / (x[0] - y[0])) > 1;
+    
+    // Cache
+    let x1, x2, y1, y2, z1, z2;
+    
+    if (swapAxes) {
+        x1 = x[1];    x2 = x[0];
+        y1 = y[1];    y2 = y[0];
+        z1 = z[1];    z2 = z[0];    
+    } else {
+        x1 = x[0];    x2 = x[1];
+        y1 = y[0];    y2 = y[1];
+        z1 = z[0];    z2 = z[1];
+    }
+    
+    // a <= 1 (due to swapped axes)
+    const a = (x2 - y2) / (x1 - y1); 
+    const b = y2 - a*y1;
+    const c = (y1*y1 + y2*y2 - z1*z1 - z2*z2) + 2*b*(z2 - y2);
+    const d = y1 - z1 + a*(y2 - z2);
+    const t1 = c/(2*d);
+    const t2 = a*t1 + b;
+    
+    return swapAxes ? [t2,t1] : [t1,t2];
 }
 
 

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

@@ -13,7 +13,7 @@ import { MatMeta } from '../index.js';
 
 
 /** @internal */
-function getInitialBezierPieces(
+function getInitialCurvePieces(
         angle: number,
         isHoleClosing: boolean,
         loop: Loop,
@@ -54,4 +54,4 @@ function getInitialBezierPieces(
 }
 
 
-export { getInitialBezierPieces }
+export { getInitialCurvePieces }

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

@@ -10,22 +10,22 @@ import { CurvePiece } from '../mat/curve-piece.js';
  */
 function reduceRadius(
         extreme: number,
-        bezierPieces: CurvePiece[], 
+        curvePieces: CurvePiece[], 
         p: number[],
         x: number[]) {
 
     const TOLERANCE = 1 + 2**-10;
 
     let minRadius = Number.POSITIVE_INFINITY;
-    for (let i=0; i<bezierPieces.length; i++) {
-        const bezierPiece = bezierPieces[i];
+    for (let i=0; i<curvePieces.length; i++) {
+        const curvePiece = curvePieces[i];
 
-        const ps = bezierPiece.curve.ps;
+        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, bezierPiece.ts[j/num]);
+            const p_ = evalDeCasteljau(ps, curvePiece.ts[j/num]);
             const cc = getCircleCenterFrom2PointsAndNormal(extreme, p, x, p_);
             if (cc) {
                 let r = squaredDistanceBetween(p, cc);

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

@@ -9,14 +9,14 @@ import { getClosestPoints } from './get-closest-points.js';
  * Find new x and ps that are a better estimate of the 3-prong circle.
  * The potential function, V, is defined as the distance to the actual 3 prong 
  * circle center.
- * @param bezierPiece3s The three boundary pieces, each of which should contain 
+ * @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
  */
 function calcBetterX(
-        bezierPiece3s: CurvePiece[][], 
+        curvePiece3s: CurvePiece[][], 
         x: number[], 
         vectorToZeroV: number[]) {
 
@@ -33,7 +33,7 @@ function calcBetterX(
         newX = translate(shift, x); 
         
         
-        newPoss = getClosestPoints(newX, bezierPiece3s);
+        newPoss = getClosestPoints(newX, curvePiece3s);
 
         // Point of zero V
         const newCircleCenter = circumCenter(newPoss.map(pos => pos!.p)); 

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

@@ -13,13 +13,13 @@ const { max, ceil, log2 } = Math;
  * must be within the shape. 
  * @param δ3s - The three boundary pieces of which we need to find the three 
  * 3-prong points.
- * @param bezierPiece3s 
+ * @param curvePiece3s 
  * @param extreme 
  */
 function calcInitial3ProngCenter(
         maxCoordinate: number,
         δ3s: CpNode[][], 
-        bezierPiece3s: CurvePiece[][]) {
+        curvePiece3s: CurvePiece[][]) {
 
     const circle = δ3s[0][0].cp.circle;
     const twoProngCircleCenter = circle.center;
@@ -27,7 +27,7 @@ function calcInitial3ProngCenter(
     const pow = max(0,ceil(log2(maxCoordinate/circle.radius))) + 1;  // determines accuracy;
     const pos = getCloseBoundaryPointsCertified(
         pow,
-        bezierPiece3s[1],
+        curvePiece3s[1],
         twoProngCircleCenter
     )[0];