flo-mat 2.0.1 → 2.0.2

package/src/get-branches.ts

@@ -26,15 +26,15 @@ function getBranches(
 		cpNode = cpNode.next;
 	}
 
-	let branches: CpNode[][] = [];
+	const branches: CpNode[][] = [];
 
 	// Since the tree is unrooted we must iterate in all directions from the
 	// given vertex.
-	let cps = [cpNode.prevOnCircle];
+	const cps = [cpNode.prevOnCircle];
 
 	let branchCpNodes: CpNode[] = [];
 	while (cps.length) {
-		let cp = cps.pop();
+		const cp = cps.pop();
 		branchCpNodes.push(cp);
 
 		let children = cp.getChildren();
@@ -68,17 +68,17 @@ function getBranches(
 			continue;
 		}
 
-		let backPointingTan = toUnitVector(tangent(
+		const backPointingTan = toUnitVector(tangent(
 			getCurveToNext(cp.next.prevOnCircle), 
 			0
 		));
-		let forwardPointingTan = toUnitVector(tangent(
+		const forwardPointingTan = toUnitVector(tangent(
 			getCurveToNext(children[0]), 
 			0
 		));
 
-		let cross_ = cross(backPointingTan, forwardPointingTan);
-		let angle = Math.abs(Math.asin( cross_ ) * (180/Math.PI));
+		const cross_ = cross(backPointingTan, forwardPointingTan);
+		const angle = Math.abs(Math.asin( cross_ ) * (180/Math.PI));
 
 		if (angle > tolerance) {
 			branches.push(branchCpNodes);

package/src/get-curve/get-curve-between.ts

@@ -22,22 +22,22 @@ function getCurveBetween(
         cpNodeFrom: CpNode, 
         cpNodeTo: CpNode) {
 
-    let fromCc = cpNodeFrom.cp.circle.center;
-    let fromL = getEdgeDirection(cpNodeFrom);
+    const fromCc = cpNodeFrom.cp.circle.center;
+    const fromL = getEdgeDirection(cpNodeFrom);
 
-    let toCc = cpNodeTo.cp.circle.center;
-    let toL = getEdgeDirection(cpNodeTo.prevOnCircle);
+    const toCc = cpNodeTo.cp.circle.center;
+    const toL = getEdgeDirection(cpNodeTo.prevOnCircle);
 
-    let mid = lineLineIntersection(fromL, toL);
+    const mid = lineLineIntersection(fromL, toL);
 
-    let c = fromTo(fromCc,toCc);
+    const c = fromTo(fromCc,toCc);
 
     let twisted: boolean;
     if (!mid) {
         twisted = true;
     } else {
-        let a = fromTo(fromCc, mid);
-        let b = fromTo(toCc,   mid);
+        const a = fromTo(fromCc, mid);
+        const b = fromTo(toCc,   mid);
         
         twisted = dot(a,c) < 0 || dot(b,c) > 0;			
     }
@@ -46,12 +46,12 @@ function getCurveBetween(
         return [fromCc, mid, toCc];
     } 
         
-    let r = rotate90Degrees(c);
-    let w1 = fromTo(fromL[0], fromL[1]); // This is a unit vector
-    let w2 = fromTo(toL[0],  toL[1]);  // This is a unit vector
+    const r = rotate90Degrees(c);
+    const w1 = fromTo(fromL[0], fromL[1]); // This is a unit vector
+    const w2 = fromTo(toL[0],  toL[1]);  // This is a unit vector
 
-    let d1 = Math.abs(cross(c, w1)) / (3*3); 
-    let d2 = Math.abs(cross(c, w2)) / (3*3); 
+    const d1 = Math.abs(cross(c, w1)) / (3*3); 
+    const d2 = Math.abs(cross(c, w2)) / (3*3); 
 
     if (d1 > TOLERANCE_ADD_2PRONG || d2 > TOLERANCE_ADD_2PRONG) {
         // TODO - not within tolerance - must add additional 2-prong
@@ -60,14 +60,14 @@ function getCurveBetween(
 
     if (d1 > TOLERANCE_USE_LINE || d2 > TOLERANCE_USE_LINE) {
         // approximate with cubic bezier
-        let m1 = interpolate(fromCc,toCc,1/3);
-        let m2 = interpolate(fromCc,toCc,2/3);
-        let v1 = translate(r, m1);
-        let v2 = translate(r, m2);
-        let l1 = [m1,v1];
-        let l2 = [m2,v2];
-        let mid1 = lineLineIntersection(fromL, l1);
-        let mid2 = lineLineIntersection(toL,   l2);
+        const m1 = interpolate(fromCc,toCc,1/3);
+        const m2 = interpolate(fromCc,toCc,2/3);
+        const v1 = translate(r, m1);
+        const v2 = translate(r, m2);
+        const l1 = [m1,v1];
+        const l2 = [m2,v2];
+        const mid1 = lineLineIntersection(fromL, l1);
+        const mid2 = lineLineIntersection(toL,   l2);
 
         return [fromCc, mid1, mid2, toCc];
     } 

package/src/get-curve/get-edge-direction.ts

@@ -13,17 +13,16 @@ import { isPosSharpCorner } from '../point-on-shape.js';
  * @param cpNode 
  */
 function getEdgeDirection(cpNode: CpNode) {
+    const circleCenter = cpNode.cp.circle.center;
 
-    let circleCenter = cpNode.cp.circle.center;
+    const cp1 = cpNode;
+    const cp2 = cpNode.nextOnCircle;
 
-    let cp1 = cpNode;
-    let cp2 = cpNode.nextOnCircle;
+    const pos1 = cp1.cp.pointOnShape;
+    const pos2 = cp2.cp.pointOnShape;
 
-    let pos1 = cp1.cp.pointOnShape;
-    let pos2 = cp2.cp.pointOnShape;
-
-    let p1 = pos1.p;
-    let p2 = pos2.p;
+    const p1 = pos1.p;
+    const p2 = pos2.p;
 
     let vDir;
     
@@ -46,20 +45,20 @@ function getEdgeDirection(cpNode: CpNode) {
             curve2 = pos1.curve;
         }
 
-        let tan1 = toUnitVector(tangent(curve1.ps, 0));
-        let tan2 = reverse( toUnitVector(tangent(curve2.ps, 1)) );
+        const tan1 = toUnitVector(tangent(curve1.ps, 0));
+        const tan2 = reverse( toUnitVector(tangent(curve2.ps, 1)) );
         
-        let x = dot(tan1, tan2);
+        const x = dot(tan1, tan2);
         // Recall the identities sin(acos(x)) = sqrt(1-x^2), etc. Also 
         // recall the half angle formulas. Then the rotation matrix, R, can 
         // be calculated.
-        let cosθ = Math.sqrt((1+x)/2);
-        let sinθ = Math.sqrt((1-x)/2);
+        const cosθ = Math.sqrt((1+x)/2);
+        const sinθ = Math.sqrt((1-x)/2);
         
         vDir = rotate(sinθ, cosθ, tan2);
     }
 
-    let v = translate(
+    const v = translate(
         toUnitVector(vDir),
         circleCenter 
     );

package/src/get-interface-ccw.ts

@@ -27,14 +27,14 @@ import { compareCurvaturesAtInterface } from "./compare-curvatures-at-interface.
  */
 // TODO - improve and make at least 46-bitlength precondition
 function getInterfaceCcw(psI: number[][], psO: number[][]) {
-    let lenI = psI.length;
+    const lenI = psI.length;
 
     // second last control point of incoming curve
-    let p0 = psI[lenI-2];  
+    const p0 = psI[lenI-2];  
     // last control point of incoming curve / first control point of outgoing
-    let p1 = psO[0];
+    const p1 = psO[0];
     // second control point of outgoing curve
-    let p2 = psO[1];
+    const p2 = psO[1];
 
     /*
     if (typeof _bez_debug_ !== 'undefined') {
@@ -63,18 +63,18 @@ function getInterfaceCcw(psI: number[][], psO: number[][]) {
     */
 
     // Max one bit can be added in the calculations below due to bit-alignment
-    let xE = p1[0] - p0[0];  // tangent x-coordinate
-	let yE = p1[1] - p0[1];  // tangent y-coordinate
-	let xS = p2[0] - p1[0];  // tangent x-coordinate
-    let yS = p2[1] - p1[1];  // tangent y-coordinate
+    const xE = p1[0] - p0[0];  // tangent x-coordinate
+	const yE = p1[1] - p0[1];  // tangent y-coordinate
+	const xS = p2[0] - p1[0];  // tangent x-coordinate
+    const yS = p2[1] - p1[1];  // tangent y-coordinate
     
 	// If the tangent is to be found at t === 0 or t === 1 then using a basic 
     // property of bezier curves we can find the tangents easily as below
     
     // (non-normalized) tangent of incoming curve at t === 1
-    let tangentAtEnd = [xE,yE];
+    const tangentAtEnd = [xE,yE];
     // (non-normalized) tangent of outgoing curve at t === 0
-	let tangentAtStart = [xS,yS];
+	const tangentAtStart = [xS,yS];
 
     // The cross calculated below will have a max bitlength of 
     // (2*(maxBitLength+1))+1 === e.g. (2*(25+1)) + 1 === 53
@@ -82,7 +82,7 @@ function getInterfaceCcw(psI: number[][], psO: number[][]) {
     //let crossTangents = cross(tangentAtEnd, tangentAtStart);
     
     // The cross below is exact by adaptive infinite precision
-    let crossTangents = orient2d(p0, p1, p2);
+    const crossTangents = orient2d(p0, p1, p2);
 
 	if (crossTangents !== 0) {
 		return crossTangents;
@@ -91,7 +91,7 @@ function getInterfaceCcw(psI: number[][], psO: number[][]) {
     // The dot calculated below will have a max bitlength of 
     // (2*(maxBitLength+1))+1 === e.g. (2*(25+1)) + 1 === 53
     // If the preconditions are met it is exact
-    let dotTangents = dot(tangentAtEnd, tangentAtStart);
+    const dotTangents = dot(tangentAtEnd, tangentAtStart);
     if (dotTangents > 0) {
         // Curves go in same direction at interface - neither clock or 
         // anti-clockwise.

package/src/loop/get-max-coordinate.ts

@@ -17,10 +17,10 @@ function getLoopsMetrics(loops: number[][][][]): {
     let minY = Number.POSITIVE_INFINITY;
     let maxY = Number.NEGATIVE_INFINITY;
 
-    for (let loop of loops) { for (let ps of loop) { for (let p of ps) {
-        let x = p[0];
-        let y = p[1];
-        let c = max(abs(x), abs(y));
+    for (const loop of loops) { for (const ps of loop) { for (const p of ps) {
+        const x = p[0];
+        const y = p[1];
+        const c = max(abs(x), abs(y));
         if (c > maxCoordinate) { maxCoordinate = c; }
         if (x < minX) { minX = x; }
         if (x > maxX) { maxX = x; }
@@ -28,9 +28,9 @@ function getLoopsMetrics(loops: number[][][][]): {
         if (y > maxY) { maxY = y; }
     } } }
 
-    let width  = maxX - minX;
-    let height = maxY - minY;
-    let maxRadius = max(width, height);
+    const width  = maxX - minX;
+    const height = maxY - minY;
+    const maxRadius = max(width, height);
 
     return { maxCoordinate, maxRadius };
 }

package/src/loop.ts

@@ -17,9 +17,9 @@ interface Loop {
  * @param beziers A pre-ordered array of bezier curves to add initially.
  */
 function loopFromBeziers(beziers: number[][][] = []) {
-    let curves: Curve[] = [];
+    const curves: Curve[] = [];
 
-    let loop: Loop = {
+    const loop: Loop = {
         beziers,
         curves
     };
@@ -30,7 +30,7 @@ function loopFromBeziers(beziers: number[][][] = []) {
     
     for (let i=0; i<beziers.length; i++) {
 
-        let curve: Curve = {
+        const curve: Curve = {
             loop,
             ps: beziers[i],
             prev,
@@ -45,7 +45,7 @@ function loopFromBeziers(beziers: number[][][] = []) {
     }
 
     // close loop
-    let lastCurve = curves[curves.length-1];
+    const lastCurve = curves[curves.length-1];
     curves[0].prev = lastCurve;
     lastCurve.next = curves[0];
 

package/src/mat/add-to-cp-graph.ts

@@ -23,16 +23,16 @@ function addToCpGraph(
         poss    : IPointOnShape[],
         neighbors? : CpNode[][]) {
 
-    let newCps = poss.map((pos, i) => {
-        let cpTree = cpTrees.get(pos.curve.loop);
+    const newCps = poss.map((pos, i) => {
+        const cpTree = cpTrees.get(pos.curve.loop);
 
-        let newCp_: ContactPoint = { pointOnShape: pos, circle, order: orders[i], order2: 0 };
+        const newCp_: ContactPoint = { pointOnShape: pos, circle, order: orders[i], order2: 0 };
 
-        let neighboringCp = neighbors 
+        const neighboringCp = neighbors 
             ? neighbors[i]
             : getNeighbouringPoints(cpTree, pos, orders[i], 0);
 
-        let newCp = CpNode.insert(
+        const newCp = CpNode.insert(
                 false,
                 false,
                 cpTree,
@@ -43,10 +43,10 @@ function addToCpGraph(
         return newCp;
     });
 
-    let len = poss.length;
+    const len = poss.length;
     for (let i=0; i<len; i++) {
-        let indxPrev = i === 0     ? len-1 : i-1;
-        let indxNext = i === len-1 ? 0     : i+1;
+        const indxPrev = i === 0     ? len-1 : i-1;
+        const indxNext = i === len-1 ? 0     : i+1;
 
         newCps[i].prevOnCircle = newCps[indxPrev];
         newCps[i].nextOnCircle = newCps[indxNext];

package/src/mat/closest-boundary-point/closest-points-on-curve.ts

@@ -33,8 +33,7 @@ function closestPointsOnCurve(
         : _poly;
 
     // let roots: Omit<RootInterval,'multiplicity'>[] = allRootsMultiWithErrBounds(
-    let roots: Omit<RootInterval,'multiplicity'>[];
-    roots = allRootsCertified(poly, tS, tE);
+    const roots: Omit<RootInterval,'multiplicity'>[] = allRootsCertified(poly, tS, tE);
 
     // Also test the endpoints
     let push0 = true;
@@ -64,12 +63,12 @@ function closestPointsOnCurve(
         roots.push({ tS: tE, tE: tE });
     }
 
-    let ps = roots.map(
+    const ps = roots.map(
         root => { 
-            let tS = root.tS;
-            let tE = root.tE;
+            const tS = root.tS;
+            const tE = root.tE;
             // TODO - tS, tE should always stay within [0,1] - modify findRootsMulti
-            let t = tS < 0 
+            const t = tS < 0 
                 ? 0
                 : tE > 1 ? 1 : (tS + tE)/2;
             // TODO - why does evalDeCasteljau not work here?

package/src/mat/closest-boundary-point/cull-bezier-pieces.ts

@@ -17,7 +17,7 @@ function cullBezierPieces(
     const CULL_THRESHOLD = 0;
 
     if (bezierPieces.length > CULL_THRESHOLD) {
-        let bestSquaredDistance = getBestDistanceSquared(
+        const bestSquaredDistance = getBestDistanceSquared(
             bezierPieces, p
         );
         bezierPieces = cullByLooseBoundingBox(

package/src/mat/closest-boundary-point/cull-by-loose-bounding-box.ts

@@ -16,15 +16,15 @@ function cullByLooseBoundingBox(
         p: number[],
         dSquared: number) {
 
-    let candidateBezierPieces = [];
+    const candidateBezierPieces = [];
 
     for (let i=0; i<bezierPieces.length; i++) {
-        let bezierPiece = bezierPieces[i];
-        let ps = bezierPiece.curve.ps;
+        const bezierPiece = bezierPieces[i];
+        const ps = bezierPiece.curve.ps;
         
-        let boundingBox = getBoundingBox_(ps);
+        const boundingBox = getBoundingBox_(ps);
         
-        let d = getClosestSquareDistanceToRect(
+        const d = getClosestSquareDistanceToRect(
             boundingBox,
             p
         );

package/src/mat/closest-boundary-point/cull-by-tight-boundary-box.ts

@@ -20,14 +20,14 @@ function cullByTightBoundingBox(
         p: number[],
         bestSquaredDistance: number) {
 
-    let candidateBezierPieces = []; 
+    const candidateBezierPieces = [];
 
     for (let i=0; i<bezierPieces.length; i++) {
-        let bezierPiece = bezierPieces[i];
-        let ps = bezierPiece.curve.ps;
+        const bezierPiece = bezierPieces[i];
+        const ps = bezierPiece.curve.ps;
         
-        let tightBoundingBox = getBoundingBoxTight_(ps);
-        let d = getClosestSquaredDistanceToRotatedRect(
+        const tightBoundingBox = getBoundingBoxTight_(ps);
+        const d = getClosestSquaredDistanceToRotatedRect(
                 tightBoundingBox,
                 p
         );

package/src/mat/closest-boundary-point/get-best-distance-squared.ts

@@ -14,14 +14,14 @@ function getBestDistanceSquared(
 
     let bestSquaredDistance = Number.POSITIVE_INFINITY;
     for (let i=0; i<bezierPieces.length; i++) {
-        let bezierPiece = bezierPieces[i];
+        const bezierPiece = bezierPieces[i];
 
-        let ps = bezierPiece.curve.ps;
+        const ps = bezierPiece.curve.ps;
         
-        let p1 = evalDeCasteljau(ps, bezierPiece.ts[0]);
-        let p2 = evalDeCasteljau(ps, bezierPiece.ts[1]);
+        const p1 = evalDeCasteljau(ps, bezierPiece.ts[0]);
+        const p2 = evalDeCasteljau(ps, bezierPiece.ts[1]);
         
-        let d = Math.min(
+        const d = Math.min(
             squaredDistanceBetween(p, p1),
             squaredDistanceBetween(p, p2)
         ); 

package/src/mat/closest-boundary-point/get-close-boundary-points.ts

@@ -21,20 +21,20 @@ function getCloseBoundaryPoints(
 		y: IPointOnShape,
 		distance: number) {
 	
-	let touchedCurve = y.curve;
-	let t = y.t;
-	let p_ = y.p;
+	const touchedCurve = y.curve;
+	const t = y.t;
+	const p_ = y.p;
 
 	bezierPieces = cullBezierPieces(bezierPieces, point);
  
 	// TODO - integrate with is-another-cp-closeby - we MUST check angle too!
-	let DISTANCE_TOLERANCE = 1e-9;
-	let posInfos: { pos: IPointOnShape; d: number }[] = [];
+	const DISTANCE_TOLERANCE = 1e-9;
+	const posInfos: { pos: IPointOnShape; d: number }[] = [];
 	for (let i=0; i<bezierPieces.length; i++) {
-		let bezierPiece = bezierPieces[i];
+		const bezierPiece = bezierPieces[i];
 
 		// TOOD - important - should be able to return multiple points
-		let ps = closestPointsOnCurve(
+		const ps = closestPointsOnCurve(
 				bezierPiece.curve, 
 				point, 
 				bezierPiece.ts, 
@@ -45,8 +45,8 @@ function getCloseBoundaryPoints(
 		//if (ps === undefined) { continue; }
 
 		for (let j=0; j<ps.length; j++) {
-			let p = ps[j];
-			let d = distanceBetween(p.p, point);
+			const p = ps[j];
+			const d = distanceBetween(p.p, point);
 
 			let curve = bezierPiece.curve;
 			let t_= p.t;
@@ -67,23 +67,23 @@ function getCloseBoundaryPoints(
 		// TODO - in future remove all these checks and join n-prongs when they
 		// are being added - much simpler and more symmetric. Remeber order when
 		// comparing closeness!
-		let indexesToCheck: number[] = [];
+		const indexesToCheck: number[] = [];
 		for (let i=0; i<posInfos.length; i++) {
-			let pi = posInfos[i];
+			const pi = posInfos[i];
 			// Only check if they are close to the edges. Why??
 			//if (pi.pos.t < 1e-2 || 1-pi.pos.t < 1e-2) {
 				indexesToCheck.push(i);
 			//}
 		}
-		let indexesToRemove: number[] = [];
+		const indexesToRemove: number[] = [];
 		for (let i=0; i<indexesToCheck.length; i++) {
 			for (let j=i+1; j<indexesToCheck.length; j++) {
 				if (i === j) { continue; }
-				let p1 = posInfos[indexesToCheck[i]].pos.p;
-				let p2 = posInfos[indexesToCheck[j]].pos.p;
+				const p1 = posInfos[indexesToCheck[i]].pos.p;
+				const p2 = posInfos[indexesToCheck[j]].pos.p;
 				// Below checks for source point too - similar to 
 				// isAnotherCpCloseBy
-				let p3 = p_;
+				const p3 = p_;
 				if ((Math.abs(p1[0] - p2[0]) < 1e-6 && 
 					 Math.abs(p1[1] - p2[1]) < 1e-6) ||
 					

package/src/mat/closest-boundary-point/get-closest-boundary-point.ts

@@ -27,9 +27,9 @@ function getClosestBoundaryPoint(
 	let bestDistance = Number.POSITIVE_INFINITY;
 	let posInfo: { pos: IPointOnShape; d: number };
 	for (let i=0; i<bezierPieces.length; i++) {
-		let bezierPiece = bezierPieces[i];
+		const bezierPiece = bezierPieces[i];
 
-		let ps = closestPointsOnCurve(
+		const ps = closestPointsOnCurve(
 				bezierPiece.curve, 
 				point, 
 				bezierPiece.ts, 
@@ -37,11 +37,11 @@ function getClosestBoundaryPoint(
 				t
 		);
 
-		let p = getObjClosestTo(point, ps, p => p.p)
+		const p = getObjClosestTo(point, ps, p => p.p)
 
 		if (p === undefined) { continue; }
 
-		let d = distanceBetween(p.p, point);
+		const d = distanceBetween(p.p, point);
 
 		let curve = bezierPiece.curve;
 		let t_= p.t;

package/src/mat/cmp-cp-on-delta.ts

@@ -20,12 +20,12 @@ function cmpCpOnδ(
         return 1;
     }
 
-    let cpBef = δ[0].cp;
-    let cpAft = δ[1].cp;
+    const cpBef = δ[0].cp;
+    const cpAft = δ[1].cp;
 
-    let cmp     = compareCps(cpBef, cpAft); 
-    let cmpPrev = compareCps(cpBef, cp);
-    let cmpNext = compareCps(cp,    cpAft);
+    const cmp     = compareCps(cpBef, cpAft); 
+    const cmpPrev = compareCps(cpBef, cp);
+    const cmpNext = compareCps(cp,    cpAft);
     
     if (cmp < 0) {
         if (cmpPrev > 0 || cmpNext > 0) {

package/src/mat/create-new-cp-tree.ts

@@ -8,14 +8,14 @@ import { Loop } from '../loop.js';
  * @param cpNode 
  */
 function createNewCpTree(cpNode: CpNode) {
-	let newCpTrees: Map<Loop,LlRbTree<CpNode>> = new Map();
+	const newCpTrees: Map<Loop,LlRbTree<CpNode>> = new Map();
 
-	let cps = cpNode.getAllOnLoop();
+	const cps = cpNode.getAllOnLoop();
 
 	cps.forEach(f);
 
 	function f(cpNode: CpNode) {
-		let loop = cpNode.cp.pointOnShape.curve.loop;
+		const loop = cpNode.cp.pointOnShape.curve.loop;
 		let cpTree = newCpTrees.get(loop);
 		if (!cpTree) { 
 			// qqq cpTree = new LlRbTree(CpNode.comparator, [], true); 

package/src/mat/find-mat/add-1-prong.ts

@@ -1,5 +1,5 @@
-/** @hidden */
-declare var _debug_: Debug; 
+/** @internal */
+declare const _debug_: Debug; 
 
 import { LlRbTree } from 'flo-ll-rb-tree';
 import { Debug }   from '../../debug/debug.js';
@@ -44,10 +44,10 @@ function add1Prong(
 	}
 	
 	//let circle = PointOnShape.getOsculatingCircle(maxOsculatingCircleRadius, pos);
-	let circle = getOsculatingCircle(maxOsculatingCircleRadius, pos);
+	const circle = getOsculatingCircle(maxOsculatingCircleRadius, pos);
 	
-	//let order = PointOnShape.calcOrder(circle, pos);
-	let order = calcPosOrder(circle, pos);
+	//const order = PointOnShape.calcOrder(circle, pos);
+	const order = calcPosOrder(circle, pos);
 	// Make sure there isn't already a ContactPoint close by - it can cause
 	// floating point stability issues.
 	if (isAnotherCpCloseby(cpGraphs, pos, circle, order, 0, 1000, 'magenta')) {