flo-mat 3.0.10 → 3.0.11

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

@@ -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 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] };
+        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-3-prong.ts/find-3-prong-for-delta3s.ts

@@ -164,7 +164,7 @@ function find3ProngForDelta3s(
             const cross_ = Math.abs( Math.asin( cross(v1, v2) ) );
             
             totalAngleError += cross_;
-        }		
+        }        
     }
 
     //-------------------------------------------------------------------------

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

@@ -13,35 +13,35 @@ import { getBoundaryPieceBeziers } from '../mat/get-boundary-piece-beziers.js';
  * tolerances.
  */ 
 function find3Prong(
-		δs: CpNode[][], extreme: number) {
+        δs: CpNode[][], extreme: number) {
 
-	const curvePiecess = δs.map(getBoundaryPieceBeziers);
+    const curvePiecess = δs.map(getBoundaryPieceBeziers);
 
-	// The best candidate amongst the different 'permutations' of the given δs.
-	let threeProng: { 
+    // The best candidate amongst the different 'permutations' of the given δs.
+    let threeProng: { 
         circle: Circle, 
         poss: PointOnShape[], 
         δ3s: CpNode[][] 
     };
-	let smallestError = Number.POSITIVE_INFINITY;
-	for (let i=1; i<δs.length-1; i++) {
-		for (let k=0; k<3; k++) {
-			const threeProngInfo = 
-				find3ProngForDelta3s(δs, i, k, curvePiecess, extreme);
-			if (!threeProngInfo) { continue; }
-
-			const { circle, poss: poss, error, δ3s } = threeProngInfo;
-			
-			if (error < smallestError) {
-				smallestError = error;
-				
-				threeProng = { circle, poss: poss as PointOnShape[], δ3s };
-			}
-		}
-	}
-	
-
-	return threeProng!;
+    let smallestError = Number.POSITIVE_INFINITY;
+    for (let i=1; i<δs.length-1; i++) {
+        for (let k=0; k<3; k++) {
+            const threeProngInfo = 
+                find3ProngForDelta3s(δs, i, k, curvePiecess, extreme);
+            if (!threeProngInfo) { continue; }
+
+            const { circle, poss: poss, error, δ3s } = threeProngInfo;
+            
+            if (error < smallestError) {
+                smallestError = error;
+                
+                threeProng = { circle, poss: poss as PointOnShape[], δ3s };
+            }
+        }
+    }
+    
+
+    return threeProng!;
 }
 
 

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

@@ -18,43 +18,43 @@ import { getProngCount } from '../cp-node/fs/get-prong-count.js';
  * tolerances.
  */
 function findAndAdd3Prong(
-		meta: MatMeta,
-		visitedCps: CpNode[]) {
-	
-	const δs: [CpNode, CpNode][] = [];
-	for (const visitedCp of visitedCps) {
-		δs.push([visitedCp, visitedCp.next]);
-	}
-	
-	const threeProngInfo = find3Prong(δs, meta.maxCoordinate);
-
-	const { circle, poss, δ3s } = threeProngInfo;
-	
-	const orders: number[] = [];
-	for (let i=0; i<3; i++) {
-		orders.push(calcPosOrder(circle, poss[i]));
-	}
-
-	const closeBysFor3Prong: CpNode[] = [];
-	for (let i=0; i<poss.length; i++) {
-		const pos = poss[i];
-		const order = orders[i];
-		const closeBy = getCloseByCpIfExist(meta, pos, circle, order, 0, 3);
-		if (closeBy !== undefined) {
-			const prongCount = getProngCount(closeBy);
-			if (prongCount <= 2 && !closeBy.isHoleClosing) {
-				closeBysFor3Prong.push(closeBy);
-			}
-		}
-	}
-
-	const cpNodes = closeBysFor3Prong.length === 0
-		? addToCpTree(
-			true, false, circle, orders, meta, poss, δ3s.map(v => v[0])
-		).cpNodes
-		: [];
-
-	return { closeBysFor3Prong, cpNodes: cpNodes as CpNode[] };
+        meta: MatMeta,
+        visitedCps: CpNode[]) {
+    
+    const δs: [CpNode, CpNode][] = [];
+    for (const visitedCp of visitedCps) {
+        δs.push([visitedCp, visitedCp.next]);
+    }
+    
+    const threeProngInfo = find3Prong(δs, meta.maxCoordinate);
+
+    const { circle, poss, δ3s } = threeProngInfo;
+    
+    const orders: number[] = [];
+    for (let i=0; i<3; i++) {
+        orders.push(calcPosOrder(circle, poss[i]));
+    }
+
+    const closeBysFor3Prong: CpNode[] = [];
+    for (let i=0; i<poss.length; i++) {
+        const pos = poss[i];
+        const order = orders[i];
+        const closeBy = getCloseByCpIfExist(meta, pos, circle, order, 0, 3);
+        if (closeBy !== undefined) {
+            const prongCount = getProngCount(closeBy);
+            if (prongCount <= 2 && !closeBy.isHoleClosing) {
+                closeBysFor3Prong.push(closeBy);
+            }
+        }
+    }
+
+    const cpNodes = closeBysFor3Prong.length === 0
+        ? addToCpTree(
+            true, false, circle, orders, meta, poss, δ3s.map(v => v[0])
+        ).cpNodes
+        : [];
+
+    return { closeBysFor3Prong, cpNodes: cpNodes as CpNode[] };
 }