flo-mat 2.0.4 → 3.0.0

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

@@ -0,0 +1,77 @@
+import {
+	twoDiff, twoSum, twoProduct, doubleDivDouble, ddDivDd,
+	ddAddDd, ddDiffDd, ddMultDd, ddMultBy2, ddMultDouble1
+} from "double-double";
+
+
+const { abs } = Math;
+
+const td = twoDiff;
+const tp = twoProduct;
+
+
+
+/**
+ * Returns the point on the line from y to x that is equidistant from y and z.
+ * 
+ * @internal
+ * @param x
+ * @param y
+ * @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;
+
+	
+	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 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]];
+}
+
+
+export { findEquidistantPointOnLineDd }

package/src/{mat/find-mat/find-2-prong → find-2-prong}/find-equidistant-point-on-line.ts

@@ -1,6 +1,6 @@
 
 /**
- * @hidden
+ * @internal
  * @param x
  * @param y
  * @param z

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

@@ -0,0 +1,61 @@
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { Loop } from 'flo-boolean';
+import { getNeighbouringPoints } from '../mat/get-neighboring-cps.js';
+import { getBoundaryPieceBeziers } from '../mat/get-boundary-piece-beziers.js';
+import { BezierPiece  } from '../mat/bezier-piece.js';
+import { CpNode } from '../cp-node/cp-node.js';
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import { isPosDullCorner } from '../point-on-shape/is-pos-dull-corner.js';
+import { calcPosOrder } from '../point-on-shape/calc-pos-order.js';
+import { Circle } from '../geometry/circle.js';
+
+
+/** @internal */
+function getInitialBezierPieces(
+        angle: number,
+        isHoleClosing: boolean,
+        k: number,
+        loops: Loop[],
+        cpTrees: Map<Loop,LlRbTree<CpNode>>,
+        y: PointOnShape,
+        circle: Circle) {
+
+    if (isHoleClosing) {
+        const bezierPieces: BezierPiece[] = [];
+        for (let k2=0; k2<k; k2++) {
+            const pieces: BezierPiece[] = loops[k2].curves
+                .map(curve => ({ curve, ts: [0,1] }))
+            bezierPieces.push(...pieces);
+        }
+
+        return { bezierPieces, δ: undefined };
+    }
+
+    let bezierPieces: BezierPiece[];
+    const order = isPosDullCorner(y)
+            ? y.t === 1 && angle === 0
+                ? -1 
+                : y.t === 0
+                ? +1
+                : calcPosOrder(circle, y)
+            : 0;
+
+    const loop = loops[k];
+    const cpNode = getNeighbouringPoints(cpTrees.get(loop)!, y, order, 0)[0];
+    const δ = [cpNode, cpNode];
+    if (!cpNode || 
+        // The special case if there is only a single sharp corner or 
+        // terminating 2-prong currently in the MAT. Don't remove!
+        (cpNode === cpNode.next.next) 
+    ) {
+        bezierPieces = loop.curves
+            .map(curve => ({ curve, ts: [0,1] }))
+    } else {
+        bezierPieces = getBoundaryPieceBeziers(δ);	
+    }
+
+    return { bezierPieces, δ };
+}
+
+
+export { getInitialBezierPieces }

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

@@ -0,0 +1,146 @@
+import { primitivePart } from "flo-poly";
+
+/**
+ * From https://www.geeksforgeeks.org/generate-pythagorean-triplets/
+ * 
+ * Function to generate pythagorean triplets smaller than limit
+ */
+function pythagoreanTriplets(
+        limit: number): number[][] {
+
+    // Triplet: a^2 + b^2 = c^2
+    let a = 0;
+    let b = 0;
+    let c = 0;
+
+    // Loop from 2 to max_limit
+    let m = 2;
+
+    const triples: number[][] = [];
+    // Limiting c would limit all a, b and c
+    while (c < limit) {
+        for(let n=1; n<m; ++n) {
+            a = m*m - n*n;
+            b = 2*m*n;
+            c = m*m + n*n;
+
+            if (c > limit) { break; }
+
+            triples.push([a,b,c]);
+        }
+        m++;
+    }
+
+    return triples;
+}
+
+
+function get1DegreeSpacingTriples() {
+    let limit = 10000;
+    const triplesRaw = pythagoreanTriplets(limit);
+    const triplesRed = triplesRaw.map(triple => {
+        let [x,y] = triple;
+        [x,y] = primitivePart([x,y]);
+        if (x > y) { [x,y] = [y,x]; }
+
+        return [x,y];
+    });
+
+    triplesRed.sort((a,b) => {
+        let res = a[0] - b[0];
+
+        if (res !== 0) { return res; }
+
+        return a[1] - b[1];
+    });
+
+    const triples: number[][] = [];
+    for (let i=0; i<triplesRed.length; i++) {
+        const tripleRedPrev = triplesRed[i-1];
+        const tripleRed = triplesRed[i];
+        if (tripleRedPrev === undefined ||
+            tripleRed[0] !== tripleRedPrev[0] ||
+            tripleRed[1] !== tripleRedPrev[1]) {
+
+            triples.push(tripleRed);
+        }
+    }
+
+
+    function toDeg(angle: number) {
+        return angle*180/Math.PI;
+    }
+
+    const triplesWithAngles = triples.map(triple => {
+        const [x,y] = triple;
+
+        return [x,y,toDeg(Math.atan2(y,x))];
+    }).sort((a,b) => a[2] - b[2]);//?
+
+    triplesWithAngles.length;//?
+    triplesWithAngles[0];//?
+    triplesWithAngles[triplesWithAngles.length-1];//?
+
+    const trips: number[][] = [];
+    const GAP = 1;
+    let prev = 45;
+    for (let t of triplesWithAngles) {
+        if (t[2] - prev > GAP) {
+            trips.push(t);
+            prev = t[2];
+        }
+    }
+
+    return trips;
+}
+
+
+// get1DegreeSpacingTriples();
+
+const triples = [
+    [ 2184, 2263, 46.017740165645755 ],
+    [ 2928, 3145, 47.046418040919235 ],
+    [ 2760, 3071, 48.0530131573584 ],
+    [ 1675, 1932, 49.075456953155594 ],
+    [ 3003, 3596, 50.13492687612096 ],
+    [ 3885, 4828, 51.177026282632845 ],
+    [ 1825, 2352, 52.19084831477669 ],
+    [ 3220, 4371, 53.621908600697374 ],
+    [ 3036, 4277, 54.63121594688451 ],
+    [ 935, 1368, 55.64819276850652 ],
+    [ 2813, 4284, 56.70992357064812 ],
+    [ 836, 1323, 57.71132243943304 ],
+    [ 175, 288, 58.715507085582544 ],
+    [ 1955, 3348, 59.718032329846196 ],
+    [ 276, 493, 60.75825202273669 ],
+    [ 8, 15, 61.92751306414704 ],
+    [ 1404, 2747, 62.92828726173151 ],
+    [ 39, 80, 64.01076641616699 ],
+    [ 2825, 6072, 65.04978057558209 ],
+    [ 1144, 2583, 66.11164562310735 ],
+    [ 5, 12, 67.38013505195958 ],
+    [ 168, 425, 68.4314042648748 ],
+    [ 1995, 5332, 69.48636031660722 ],
+    [ 1408, 3975, 70.49515011669244 ],
+    [ 301, 900, 71.5077745088735 ],
+    [ 1887, 6016, 72.5852594569592 ],
+    [ 7, 24, 73.73979529168804 ],
+    [ 2159, 7920, 74.75161499109633 ],
+    [ 1815, 7208, 75.86654056719784 ],
+    [ 1469, 6300, 76.87460298212505 ],
+    [ 924, 4307, 77.89161621177033 ],
+    [ 1008, 5135, 78.8940579339264 ],
+    [ 204, 1147, 79.91509786165818 ],
+    [ 315, 1972, 80.92445498418671 ],
+    [ 355, 2508, 81.94347266702972 ],
+    [ 520, 4209, 82.95709324615554 ],
+    [ 19, 180, 83.97442499163333 ],
+    [ 23, 264, 85.0208941560017 ],
+    [ 29, 420, 86.05013197823607 ],
+    [ 39, 760, 87.06239857122834 ],
+    [ 120, 3599, 88.09031749225564 ],
+    [ 127, 8064, 89.09772290642545 ]
+];
+
+
+export { triples }

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

@@ -0,0 +1,98 @@
+import { evalDeCasteljau } from "flo-bezier3";
+import { dot, lineLineIntersection, squaredDistanceBetween } from "flo-vector2d";
+import { BezierPiece } from '../mat/bezier-piece.js';
+
+
+/**
+ * @internal
+ * 
+ * Reduces the circle radius initially as an optimization step.
+ */
+function reduceRadius(
+        extreme: number,
+        bezierPieces: BezierPiece[], 
+        p: number[],
+        x: number[]) {
+
+    const TOLERANCE = 1 + 2**-10;
+
+    let prevP: number[] | undefined = undefined;
+    let minRadius = Number.POSITIVE_INFINITY;
+    for (let i=0; i<bezierPieces.length; i++) {
+        const bezierPiece = bezierPieces[i];
+
+        const ps = bezierPiece.curve.ps;
+
+        let r1 = Number.POSITIVE_INFINITY;
+        const p1 = evalDeCasteljau(ps, bezierPiece.ts[0]);
+
+        // Prevent evaluating the same points twice
+        if (!prevP || prevP[0] !== p1[0] || prevP[1] !== p1[1]) {
+            const cc1 = getCircleCenterFrom2PointsAndNormal(extreme, p, x, p1);
+            if (cc1) { r1 = squaredDistanceBetween(p, cc1);	}
+        }
+        
+        let r2 = Number.POSITIVE_INFINITY;
+        const p2 = evalDeCasteljau(ps, bezierPiece.ts[1]);
+
+        const cc2 = getCircleCenterFrom2PointsAndNormal(extreme, p, x, p2);
+        if (cc2) { r2 = squaredDistanceBetween(p, cc2);	}
+        
+        prevP = p2;
+        
+        const d = Math.min(r1, r2); 
+        
+        if (d < minRadius) {
+            minRadius = d;  
+        }
+    }
+
+    // The extra bit is to account for floating point precision.
+    return TOLERANCE*minRadius;
+}
+
+
+/**
+ * @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[]) {
+
+    const TOLERANCE = (2**-14*extreme)**2;
+
+    // Ignore if p and p1 are too close together
+    if (squaredDistanceBetween(p,p1) < TOLERANCE) {
+        return undefined;
+    }
+
+    /** 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 res = lineLineIntersection([p,x], [pb, pb2]);
+
+    if (!res) { return undefined; }
+
+    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;
+    }
+
+    return res;
+}
+
+
+export { reduceRadius }

package/src/find-2-prong/squared-distance-between-dd.ts

@@ -0,0 +1,25 @@
+import { ddMultDd, ddAddDd, twoDiff } from 'double-double';
+
+
+function squaredDistanceBetweenDd(
+        x: number[], y: number[]) {
+
+    const [x0,y0] = x;
+    const [x1,y1] = y;
+
+    // xd = x0 - x1;
+    // yd = y0 - y1;
+    // xx = xd**2;
+    // yy = yd**2;
+    // return xx + yy
+
+    const xd = twoDiff(x0,x1);
+    const yd = twoDiff(y0,y1);
+    const xx = ddMultDd(xd,xd);
+    const yy = ddMultDd(yd,yd);
+
+    return ddAddDd(xx,yy)[1];
+}
+
+
+export { squaredDistanceBetweenDd }

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

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

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

@@ -0,0 +1,110 @@
+declare const _debug_: Debug;
+
+import { Debug } from '../debug/debug.js';
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { CpNode } from '../cp-node/cp-node.js';
+import { Loop } from 'flo-boolean';
+import { Circle } from '../geometry/circle.js';
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import { addToCpGraph } from '../mat/add-to-cp-graph.js';
+import { isAnotherCpCloseby } from '../mat/is-another-cp-closeby.js';
+
+
+/**
+ * @internal
+ * 
+ * Adds a 3-prong MAT circle according to the 3 given (previously calculated) 
+ * points on the shape. 
+ * 
+ * Returns 3 CpNodes if successful, else return one CpNode that is an offending
+ * too close existing CpNode.
+ * 
+ * @param cpTrees 
+ * @param orders 
+ * @param threeProng 
+ */
+function add3Prong(
+		cpTrees: Map<Loop,LlRbTree<CpNode>>,
+		orders: number[],
+		threeProng: { 
+    		circle: Circle, 
+			ps: PointOnShape[],
+			δ3s: CpNode[][]
+		}): CpNode[] {
+	
+	const { circle, ps: poss, δ3s } = threeProng;
+
+	// Keep for possible future debugging.	
+
+	/*
+	let ii = -1;
+	if (typeof _debug_ !== 'undefined') {
+		for (let i=0; i<3; i++) {
+			const cpBef = threeProng.δ3s[i][0].cp;
+			const cpAft = threeProng.δ3s[i][1].cp;
+
+			//let cmpBef = PointOnShape.compareInclOrder(cpBef.pointOnShape, poss[i], cpBef.order, orders[i]);
+			//let cmpAft = PointOnShape.compareInclOrder(cpAft.pointOnShape, poss[i], cpAft.order, orders[i]); 
+			const cmpBef = compareCps(cpBef, { pointOnShape: poss[i], order: orders[i], order2: 0, circle: undefined });
+			const cmpAft = compareCps(cpAft, { pointOnShape: poss[i], order: orders[i], order2: 0, circle: undefined });
+
+			// const cmpBef = comparePoss(cpBef.pointOnShape, poss[i]);
+			// const cmpAft = comparePoss(cpAft.pointOnShape, poss[i]); 
+
+			// len is used by debug functions to reference a particular 
+			// three-prong.
+			const len = _debug_.generated.elems.threeProng.length-1; 
+			if (cmpBef > 0) {
+				console.log('----------------------------------------');
+				console.log(`3-prong order is wrong (bef) : i: ${i} - cmp: ${cmpBef} - n: ${len}`);
+				console.log(threeProng);
+				console.log(cpBef);
+				console.log(cpAft);
+				console.log(poss[i]);
+				ii = i;
+			}
+			if (cmpAft < 0) {
+				console.log('----------------------------------------');
+				console.log(`3-prong order is wrong (aft) : i: ${i} - cmp: ${cmpAft} - n: ${len}`);
+				console.log(threeProng);
+				console.log(cpBef);
+				console.log(cpAft);
+				console.log(poss[i]);
+			}
+		}
+	}
+	*/
+
+	// TODO - replace 1000 below with correct value
+	const c1 = isAnotherCpCloseby(cpTrees, poss[0], circle, orders[0], 0, 1000);
+	const c2 = isAnotherCpCloseby(cpTrees, poss[1], circle, orders[1], 0, 1000);
+	const c3 = isAnotherCpCloseby(cpTrees, poss[2], circle, orders[2], 0, 1000);
+
+	// for (let pos of poss) {
+	// 	if (pos.t === 0.9978869234519733) {
+	// 		console.log(pos)
+	// 	}
+	// }
+	
+
+	// if (!!c1) {
+	// 	console.log(getRealProngCount(c1));
+	// }
+	// if (!!c2) {
+	// 	console.log(getRealProngCount(c2));
+	// }
+	// if (!!c3) {
+	// 	console.log(getRealProngCount(c3));
+	// }
+
+	// if (!!c1) { return [c1]; }
+	// if (!!c2) { return [c2]; }
+	// if (!!c3) { return [c3]; }
+
+	const cps = addToCpGraph(circle, orders, cpTrees, poss, δ3s); 
+	
+	return cps;
+}
+
+
+export { add3Prong }

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

@@ -1,11 +1,11 @@
 import { fromTo, circumCenter, len, scale, translate } from 'flo-vector2d';
-import { IPointOnShape } from '../../../point-on-shape.js';
-import { BezierPiece  } from '../../bezier-piece.js';
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import { BezierPiece  } from '../mat/bezier-piece.js';
 import { getClosestPoints } from './get-closest-points.js';
 
 
 /**
- * @hidden
+ * @internal
  * 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.
@@ -25,7 +25,7 @@ function calcBetterX(
     let nu = 1;
     let better;
     let newX;
-    let newPs: IPointOnShape[];
+    let newPs: (PointOnShape | undefined)[];
     let newV;
     let i = 0; // Safeguard
     do { 
@@ -36,7 +36,7 @@ function calcBetterX(
         newPs = getClosestPoints(newX, bezierPiece3s);
                     
         // Point of zero V
-        const newCircleCenter = circumCenter(newPs.map(pos => pos.p)); 
+        const newCircleCenter = circumCenter(newPs.map(pos => pos!.p)); 
         const newVectorToZeroV = fromTo(newX, newCircleCenter);
         newV = len(newVectorToZeroV);
         

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

@@ -1,12 +1,13 @@
-/** @hidden */
+/** @internal */
 import { circumCenter } from 'flo-vector2d';
-import { CpNode      } from '../../../cp-node.js';
-import { BezierPiece } from '../../bezier-piece.js';
-import { getClosestBoundaryPoint } from '../../closest-boundary-point/get-closest-boundary-point.js';
+import { CpNode      } from '../cp-node/cp-node.js';
+import { BezierPiece } from '../mat/bezier-piece.js';
+import { getCloseBoundaryPointsCertified } from '../closest-boundary-point/get-close-boundary-points-certified.js';
+import { createPos } from '../point-on-shape/create-pos.js';
 
 
 /**
- * @hidden
+ * @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 
@@ -20,16 +21,14 @@ function calcInitial3ProngCenter(
 
     const twoProngCircleCenter = δ3s[0][0].cp.circle.center;
 
-    const posInfo = getClosestBoundaryPoint(
-            bezierPiece3s[1],
-            twoProngCircleCenter, 
-            undefined, // curve
-            undefined  // t
-    );
+    const pos = getCloseBoundaryPointsCertified(
+        bezierPiece3s[1],
+        twoProngCircleCenter
+    )[0];
 
     const meanPoints = [
         δ3s[0][0].cp.pointOnShape.p, 
-        posInfo.pos.p,
+        pos.p,
         δ3s[2][1].cp.pointOnShape.p,
     ];