flo-mat 2.0.1 → 2.0.2

package/src/mat/simplify-mat-map-only.ts

@@ -25,29 +25,29 @@ function simplifyMatMapOnly(
         hausdorffTolerance = 1e-1,
         hausdorffSpacing = 1e0) {
 
-    let simpleMap: Map<CpNode, { ps: number[][], ts: number[] }> = new Map();
+    const simpleMap: Map<CpNode, { ps: number[][], ts: number[] }> = new Map();
 
     // Start from a leaf
     while (!cpNode.isTerminating()) {
         cpNode = cpNode.next;
     }
 
-    let branches = getBranches(cpNode, anlgeTolerance);
+    const branches = getBranches(cpNode, anlgeTolerance);
 
-    let canDeletes: CpNode[] = [];
+    const canDeletes: CpNode[] = [];
     for (let k=0; k<branches.length; k++) {
-        let branch = branches[k];
+        const branch = branches[k];
 
         // Try to remove some
         let j = 0;
         while (j < branch.length) {
-            let i = j;
+            const i = j;
             while (true) {
                 j++;
 
                 if (j === branch.length) { break; }
 
-                let hd = getTotalHausdorffDistance(i, j, branch, hausdorffSpacing);
+                const hd = getTotalHausdorffDistance(i, j, branch, hausdorffSpacing);
 
                 if (hd > hausdorffTolerance) {
                     break;
@@ -59,17 +59,17 @@ function simplifyMatMapOnly(
             if (i+1 === j) { 
                 // no simplification occured
             } else {
-                let branStart = branch[i];
-                let branEnd = branch[j-1];
+                const branStart = branch[i];
+                const branEnd = branch[j-1];
 
-                let medial = toCubic(getCurveBetween(branStart, branEnd.next));
-                let rev = medial.slice().reverse();
+                const medial = toCubic(getCurveBetween(branStart, branEnd.next));
+                const rev = medial.slice().reverse();
                 let curCpNode = branStart;
                 let prevT = 0;
                 while (curCpNode !== branEnd) {
-                    let t = closestPointOnBezier(medial, curCpNode.next.cp.circle.center).t;
+                    const t = closestPointOnBezier(medial, curCpNode.next.cp.circle.center).t;
                     simpleMap.set(curCpNode, { ps: medial, ts: [prevT, t] });
-                    let oppositeCpNode = curCpNode.nextOnCircle.prev;
+                    const oppositeCpNode = curCpNode.nextOnCircle.prev;
                     simpleMap.set(oppositeCpNode, { ps: rev, ts: [1-t, 1-prevT] });
 
                     prevT = t;
@@ -77,7 +77,7 @@ function simplifyMatMapOnly(
                 }
                 simpleMap.set(curCpNode, { ps: medial, ts: [prevT, 1] });
 
-                let oppositeCpNode = curCpNode.nextOnCircle.prev;
+                const oppositeCpNode = curCpNode.nextOnCircle.prev;
                 simpleMap.set(oppositeCpNode, { ps: rev, ts: [0, 1-prevT] });
             }
         }
@@ -93,8 +93,8 @@ function getTotalHausdorffDistance(
         branch: CpNode[],
         hausdorffSpacing: number) {
 
-    let hds: number[] = [];
-    let longCurve = getCurveBetween(branch[i], branch[j].next);
+    const hds: number[] = [];
+    const longCurve = getCurveBetween(branch[i], branch[j].next);
     for (let m=i; m<j+1; m++) {
         hds.push(hausdorffDistance(
             getCurveToNext(branch[m]), 

package/src/mat/to-scale-axis/add-debug-info.ts

@@ -1,4 +1,4 @@
-declare var _debug_: Debug; 
+declare const _debug_: Debug; 
 
 import { Debug } from '../../debug/debug.js';
 import { Mat } from '../../mat.js';
@@ -8,12 +8,15 @@ import { Mat } from '../../mat.js';
  * @hidden
  * @param sat 
  */
-function addDebugInfo(sat: Mat, timingStart: number) {
+function addDebugInfo(
+		sat: Mat,
+		timingStart: number) {
+
 	if (typeof _debug_ === 'undefined') { return; }
 
 	_debug_.generated.elems.sat.push(sat);
 
-	let timing = _debug_.generated.timing;
+	const timing = _debug_.generated.timing;
 	timing.sats = performance.now() - timingStart;
 }
 

package/src/mat/to-scale-axis/add-to-tree.ts

@@ -25,7 +25,7 @@ function addToTree(
     circle: Circle,
     depth: number) {
 
-    let { groups, newLimits } = calcGroups(
+    const { groups, newLimits } = calcGroups(
         s,
         coordinate, 
         limits, 
@@ -34,15 +34,15 @@ function addToTree(
 
     // Create new edge if it does not exist yet.
     if (groups.length === 1 && depth !== DEPTH_LIMIT) {
-        let group = groups[0]; 
+        const group = groups[0]; 
         
-        if (!tree.trees.get(group)) { 
-            tree.trees.set(group, { trees: new Map(), circles: new Set() } ); 
+        if (!tree.trees!.get(group)) { 
+            tree.trees!.set(group, { trees: new Map(), circles: new Set() } ); 
         }	
-        let t = tree.trees.get(group);
+        const t = tree.trees!.get(group)!;
         
         // Flip coordinates
-        let newCoordinate = coordinate ? 0 : 1; 
+        const newCoordinate = coordinate ? 0 : 1; 
         addToTree(
             s,
             t, 
@@ -55,11 +55,11 @@ function addToTree(
         return;
     }
 
-    if (!tree.trees.get(5)) { 
-        tree.trees.set(5, { trees: new Map(), circles: new Set() } );
+    if (!tree.trees!.get(5)) { 
+        tree.trees!.set(5, { trees: new Map(), circles: new Set() } );
     }
-    let vertices = tree.trees.get(5).circles;
-    vertices.add(circle);
+    const vertices = tree.trees!.get(5)!.circles;
+    vertices!.add(circle);
 }
 
 

package/src/mat/to-scale-axis/calc-groups.ts

@@ -29,47 +29,47 @@ function calcGroups(
         limits: number[][], 
         circle: Circle) {
 
-    let limit = limits[coordinate];
-    let l1 = limit[0];
-    let l2 = limit[1];
+    const limit = limits[coordinate];
+    const l1 = limit[0];
+    const l2 = limit[1];
 
     // Relevant cut-off lines.
-    let q = (l2 - l1) / 4;
-    let w = q+q;
+    const q = (l2 - l1) / 4;
+    const w = q+q;
 
     // Shift origin
-    let r = circle.radius;
-    let x = circle.center[coordinate] - l1;
-    let x0 = x - (r * s);
-    let x1 = x + (r * s); 
+    const r = circle.radius;
+    const x = circle.center[coordinate] - l1;
+    const x0 = x - (r * s);
+    const x1 = x + (r * s); 
 
-    let newLimit: number[] = [,];
-    let groups = []; // Group to which circle belongs;
+    let newLimit: (number | undefined)[] = [,];
+    const groups: number[] = []; // Group to which circle belongs;
 
-    let qStart = Math.floor(x0/q);
-    let qEnd   = Math.floor(x1/q) + 1;
-    let qDiff  = qEnd - qStart; 
+    const qStart = Math.floor(x0/q);
+    const qEnd   = Math.floor(x1/q) + 1;
+    const qDiff  = qEnd - qStart; 
 
-    let group;
+    let group: number;
     if (qDiff === 1) {
         // If contained in sliver.
         group = (2 * Math.floor(qStart/2)) + 1;
         groups.push(group);
         
-        let lowerLimit = l1 + q*(group-1); 
+        const lowerLimit = l1 + q*(group-1); 
         newLimit = [lowerLimit, lowerLimit + w];			
         
     } else if (qDiff === 2) {
         group = qStart + 1;
         groups.push(group);
         
-        let lowerLimit = l1 + q*(group-1); 
+        const lowerLimit = l1 + q*(group-1); 
         newLimit = [lowerLimit, lowerLimit + w];
     }
 
-    let newLimits: number[][] = [,];
+    const newLimits: ((number | undefined)[] | undefined)[] = [,];
     if (groups.length === 1) {
-        let otherCoordinate = coordinate ? 0 : 1; 
+        const otherCoordinate = coordinate ? 0 : 1; 
         
         newLimits[otherCoordinate] = limits[otherCoordinate];
         newLimits[coordinate] = newLimit;

package/src/mat/to-scale-axis/create-spacial-tree.ts

@@ -18,12 +18,12 @@ function createSpacialTree(
         s: number, 
         circles: Circle[]) {
 
-    let coordinate = 0;
-    let limits = [[0, width], [0, height]];
+    const coordinate = 0;
+    const limits = [[0, width], [0, height]];
 
-    let tree: TTree = { trees: new Map(), circles: new Set() };
+    const tree: TTree = { trees: new Map(), circles: new Set() };
 
-    for (let circle of circles) {
+    for (const circle of circles) {
         addToTree(
                 s, 
                 tree, 

package/src/mat/to-scale-axis/cull-non-cycles.ts

@@ -12,11 +12,11 @@ function cullNonCycles(cpStart: CpNode) {
 
     let cpNodeKept = cpStart;
 
-    let leaves = getLeaves(cpStart);
+    const leaves = getLeaves(cpStart);
 
     
     while (leaves.length) {
-        let leaf = leaves.pop();
+        const leaf = leaves.pop();
 
         // Preserve topology - keep cycles.
         if (leaf.isHoleClosing || leaf.isIntersection) { continue; }
@@ -26,11 +26,11 @@ function cullNonCycles(cpStart: CpNode) {
         while (true) {
             cpNode = cpNode.next;
             let cut = false;
-            let cp1 = cpNode.prevOnCircle;
+            const cp1 = cpNode.prevOnCircle;
 
             if (cpNode.getProngCount() > 2) {
-                //let cp2 = cp1.prevOnCircle;
-                let cp2 = cpNode.nextOnCircle;
+                //const cp2 = cp1.prevOnCircle;
+                const cp2 = cpNode.nextOnCircle;
 
                 //if (cpStart === cpNode || cpStart === cp1 || cpStart === cp2) {
                 if (CpNode.isOnSameCircle(cpNode, cpStart)) {

package/src/mat/to-scale-axis/cull.ts

@@ -15,12 +15,12 @@ function cull(
         culls: Set<Circle>, 
         maxCpNode: CpNode) {
 
-    let leaves = getLeaves(maxCpNode);
+    const leaves = getLeaves(maxCpNode);
 
     function getNonTrivialEdges(cpStart: CpNode) {
 		let cp = cpStart;
 		
-        let cps: CpNode[] = [];
+        const cps: CpNode[] = [];
 		do {
             if (cp.next !== cp.nextOnCircle) {
                 cps.push(cp);
@@ -32,7 +32,7 @@ function cull(
     }
 
     while (leaves.length) {
-        let leaf = leaves.pop();
+        const leaf = leaves.pop();
 
         // Preserve topology.
         if (leaf.isHoleClosing || leaf.isIntersection) { continue; }
@@ -46,7 +46,7 @@ function cull(
         while (true) {
             cpNode = cpNode.next;
             let cut = false;
-            let cp1 = cpNode.prevOnCircle;
+            const cp1 = cpNode.prevOnCircle;
 
             if (!culls.has(cpNode.cp.circle)) {
                 // Cut off the edge once a non-cull has been reached.
@@ -54,7 +54,7 @@ function cull(
             } else if (CpNode.isOnSameCircle(cpNode, maxCpNode)) {
                 cut = true; // We are at the max disk - cut whole edge
             } else {
-                let cps = getNonTrivialEdges(cpNode);
+                const cps = getNonTrivialEdges(cpNode);
 
                 if (cps.length === 1) { 
                     cpNode = cps[0];

package/src/mat/to-scale-axis/get-engulfed-vertices.ts

@@ -22,24 +22,24 @@ function getEngulfedVertices(
         tree: TTree, 
         circle: Circle) {
 
-    let c1 = scaleCircle(circle, s);
+    const c1 = scaleCircle(circle, s);
 
-    let cullNodes: Set<Circle> = new Set();
+    const cullNodes: Set<Circle> = new Set();
 
-    let limits = [[0, width], [0, height]];
+    const limits = [[0, width], [0, height]];
     f(tree, 0, limits, 0);
 
     return cullNodes;
 
 
     function cullBranch5(tree: TTree) {
-        let t = tree.trees.get(5);
+        const t = tree.trees!.get(5);
         if (!t) { return; }
 
-        let circles = t.circles;
+        const circles = t.circles!;
         
         circles.forEach(function(circle, key) {
-            let c2 = scaleCircle(circle, s);
+            const c2 = scaleCircle(circle, s);
             if (engulfsCircle(c1, c2)) {
                 cullNodes.add(circle);
                 circles.delete(key);
@@ -51,7 +51,7 @@ function getEngulfedVertices(
     function f(
             tree: TTree, 
             coordinate: number, 
-            limits: number[][], 
+            limits: number[][] | null, 
             depth: number) {
         
         if (limits === null) {
@@ -60,7 +60,7 @@ function getEngulfedVertices(
             cullBranch5(tree);
             
             for (let i=0; i<=4; i++) {
-                let t = tree.trees.get(i);
+                const t = tree.trees!.get(i);
                 if (t) {
                     f(t, 0, null, depth+1);
                 }
@@ -69,7 +69,7 @@ function getEngulfedVertices(
             return;
         }
         
-        let { groups, newLimits } = calcGroups(
+        const { groups, newLimits } = calcGroups(
                 s, 
                 coordinate, 
                 limits, 
@@ -79,13 +79,13 @@ function getEngulfedVertices(
         if (groups.length === 1) {
             cullBranch5(tree);
             
-            let group = groups[0];
-            let newCoordinate = coordinate ? 0 : 1;
+            const group = groups[0];
+            const newCoordinate = coordinate ? 0 : 1;
             
             if (group === 1 || group === 3) {
                 // One of the higher priority left/top or 
                 // right/bottom half groups.
-                let t = tree.trees.get(group);
+                const t = tree.trees!.get(group);
                 
                 if (t) {
                     f(
@@ -98,12 +98,12 @@ function getEngulfedVertices(
             } else {
                 // One of the lower priority even groups (0,2 or 4).
                 
-                let branches = [];
-                branches.push(tree.trees.get(group));
-                if (group > 0) { branches.push(tree.trees.get(group-1)); }
-                if (group < 4) { branches.push(tree.trees.get(group+1)); }
+                const branches: TTree[] = [];
+                branches.push(tree.trees!.get(group)!);
+                if (group > 0) { branches.push(tree.trees!.get(group-1)!); }
+                if (group < 4) { branches.push(tree.trees!.get(group+1)!); }
                 
-                for (let branch of branches) {
+                for (const branch of branches) {
                     if (branch) {
                         f(
                                 branch, 
@@ -123,7 +123,7 @@ function getEngulfedVertices(
         // Circle spans multiple groups at this level of the tree. Check all 
         // circles in all branches.
         for (let i=0; i<=4; i++) {
-            let t = tree.trees.get(i);
+            const t = tree.trees!.get(i);
             if (!t) { continue; }
             
             f(t, 0, null, depth+1);

package/src/mat/trim-mat.ts

@@ -10,7 +10,7 @@ import { clone } from '../cp-node/clone.js';
  * @param mat The MAT to trim.
  */
 function trimMat(mat: Mat): Mat {
-	let cpNode = cullNonCycles(clone(mat.cpNode));
+	const cpNode = cullNonCycles(clone(mat.cpNode));
 
     if (!cpNode) { return undefined; }
 

package/src/point-on-shape.ts

@@ -65,7 +65,7 @@ function getPosCorner(pos: IPointOnShape) {
 /**
  * @hidden
  */
-let isPosSharpCorner = memoize((pos: IPointOnShape) => {
+const isPosSharpCorner = memoize((pos: IPointOnShape) => {
     if (!isPosCorner(pos)) { return false; }
 
     return getPosCorner(pos).isSharp;
@@ -75,7 +75,7 @@ let isPosSharpCorner = memoize((pos: IPointOnShape) => {
 /**
  * @hidden
  */
-let isPosDullCorner = memoize((pos: IPointOnShape) => {
+const isPosDullCorner = memoize((pos: IPointOnShape) => {
     if (!isPosCorner(pos)) { return false; }
 
     return getPosCorner(pos).isDull;
@@ -85,7 +85,7 @@ let isPosDullCorner = memoize((pos: IPointOnShape) => {
 /**
  * @hidden
  */
-let isPosQuiteSharpCorner = memoize((pos: IPointOnShape) => {
+const isPosQuiteSharpCorner = memoize((pos: IPointOnShape) => {
     if (!isPosCorner(pos)) { return false; }
 
     return getPosCorner(pos).isQuiteSharp;
@@ -95,7 +95,7 @@ let isPosQuiteSharpCorner = memoize((pos: IPointOnShape) => {
 /**
  * @hidden
  */
-let isPosQuiteDullCorner = memoize((pos: IPointOnShape) => {
+const isPosQuiteDullCorner = memoize((pos: IPointOnShape) => {
     if (!isPosCorner(pos)) { return false; }
 
     return getPosCorner(pos).isQuiteDull;
@@ -128,10 +128,10 @@ function calcPosOrder(
     if (!isPosDullCorner(pos)) { return 0; }
     //if (!isPosDullCorner(pos)) { return 0; }
 
-    let corner = getPosCorner(pos);
+    const corner = getPosCorner(pos);
 
-    let n = rotateNeg90Degrees(corner.tangents[0]);
-    let v = toUnitVector( fromTo(pos.p, circle.center) );
+    const n = rotateNeg90Degrees(corner.tangents[0]);
+    const v = toUnitVector( fromTo(pos.p, circle.center) );
 
     return -dot(n, v);
 }
@@ -168,11 +168,11 @@ function comparePoss(a: IPointOnShape, b: IPointOnShape) {
  * @param t
  * @hidden
  */
-let calcOsculatingCircleRadius = memoize((pos: IPointOnShape) => {
-    let ps = pos.curve.ps;
-    let t  = pos.t;
+const calcOsculatingCircleRadius = memoize((pos: IPointOnShape) => {
+    const ps = pos.curve.ps;
+    const t  = pos.t;
 
-    let c = -curvature(ps, t); 
+    const c = -curvature(ps, t); 
 
     // c > 0 => bending inwards
 
@@ -202,13 +202,13 @@ function getOsculatingCircle(
         maxOsculatingCircleRadius
     );
 
-    let ps = pos.curve.ps;
-    let t  = pos.t;
+    const ps = pos.curve.ps;
+    const t  = pos.t;
     
     const tangent_ = tangent(ps,t);
-    let normal_ = toUnitVector([-tangent_[1],tangent_[0]]);
-    let p = evalDeCasteljau(ps,t);
-    let circleCenter = [
+    const normal_ = toUnitVector([-tangent_[1],tangent_[0]]);
+    const p = evalDeCasteljau(ps,t);
+    const circleCenter = [
         p[0] - normal_[0]*radius,
         p[1] - normal_[1]*radius
     ];

package/src/simplify-mat.ts

@@ -30,22 +30,22 @@ function simplifyMat(
     // Start from a leaf
     while (!cpNode.isTerminating()) { cpNode = cpNode.next; }
 
-    let branches = getBranches(cpNode, anlgeTolerance);
+    const branches = getBranches(cpNode, anlgeTolerance);
 
-    let canDeletes: CpNode[] = [];
+    const canDeletes: CpNode[] = [];
     for (let k=0; k<branches.length; k++) {
-        let branch = branches[k];
+        const branch = branches[k];
 
         // Try to remove some
         let j = 0;
         while (j < branch.length) {
-            let i = j;
+            const i = j;
             while (true) {
                 j++;
 
                 if (j === branch.length) { break; }
 
-                let hd = getTotalHausdorffDistance(i, j, branch, maxIterations);
+                const hd = getTotalHausdorffDistance(i, j, branch, maxIterations);
 
                 if (hd > hausdorffTolerance) {
                     break;
@@ -61,9 +61,9 @@ function simplifyMat(
         }
     }
 
-    for (let cpNode of canDeletes) {
-        let isTerminating = cpNode.isTerminating();
-        let onCircleCount = cpNode.getCpNodesOnCircle().length;
+    for (const cpNode of canDeletes) {
+        const isTerminating = cpNode.isTerminating();
+        const onCircleCount = cpNode.getCpNodesOnCircle().length;
         if (isTerminating || onCircleCount !== 2) { 
             continue; 
         }
@@ -82,8 +82,8 @@ function getTotalHausdorffDistance(
         branch: CpNode[],
         hausdorffSpacing: number) {
 
-    let hds: number[] = [];
-    let longCurve = getCurveBetween(branch[i], branch[j].next);
+    const hds: number[] = [];
+    const longCurve = getCurveBetween(branch[i], branch[j].next);
     for (; i<j+1; i++) {
         hds.push(hausdorffDistance(
             getCurveToNext(branch[i]),

package/src/svg/get-curvature-at-interface.ts

@@ -11,24 +11,22 @@ import { Curve } from '../curve.js';
  * @param curve
  */
 function getCurvatureAtInterface(curve: Curve) {	
-	const ts = [1,0];
-	
-	let pss = [
+	const pss = [
 		curve.ps,
 		curve.next.ps
 	];
 	
-	let tans = [ 
+	const tans = [ 
 		toUnitVector(tangent(pss[0], 1)), 
 		toUnitVector(tangent(pss[0], 0))
 	];
 	
 	// The integral of a kind of Dirac Delta function.
-	let cosθ = dot  (tans[0], tans[1]);
-	let sinθ = cross(tans[0], tans[1]);
-	let θ = acos(cosθ);
+	const cosθ = dot  (tans[0], tans[1]);
+	const sinθ = cross(tans[0], tans[1]);
+	const θ = acos(cosθ);
 	
-	let result = sinθ >= 0 ? θ : -θ;
+	const result = sinθ >= 0 ? θ : -θ;
 	
 	return result;
 }

package/src/svg/get-extreme.ts

@@ -9,7 +9,7 @@ import { getShapeBounds } from './get-shape-bounds.js';
  * @param loops 
  */
 function getExtreme(loops: Loop[]) {
-	let bounds = getShapeBounds(loops);
+	const bounds = getShapeBounds(loops);
 	
 	return Math.max(  
 			Math.abs(bounds.minX.p[0]),

package/src/svg/get-loop-bounds.ts

@@ -12,13 +12,13 @@ const INF = Number.POSITIVE_INFINITY;
 /** 
  * @hidden 
  */
-let getLoopBounds = memoize(function(loop: Loop): {
+const getLoopBounds = memoize(function(loop: Loop): {
 		minX: IPointOnShape;
 		minY: IPointOnShape;
 		maxX: IPointOnShape;
 		maxY: IPointOnShape } {	
 
-	let extremes: { 
+	const extremes: { 
 		bezier: Curve, 
 		t: number, 
 		val: number 
@@ -34,15 +34,15 @@ let getLoopBounds = memoize(function(loop: Loop): {
 	];
 	
 	loop.curves.forEach(function(curve: Curve): void {			
-		let ps = curve.ps; 
-		// let bounds = getBounds_(ps);
-		let bounds = getBounds(ps);
+		const ps = curve.ps; 
+		// const bounds = getBounds_(ps);
+		const bounds = getBounds(ps);
 		
 		
 		{	
 			{
-				let v = bounds.box[0][0];
-				let x = extremes[0][0].val;
+				const v = bounds.box[0][0];
+				const x = extremes[0][0].val;
 				if (v < x || (v === x && bounds.ts[0][0] > extremes[0][0].t)) { 
 					extremes[0][0] = { 
 						bezier : curve, 
@@ -53,8 +53,8 @@ let getLoopBounds = memoize(function(loop: Loop): {
 			}
 
 			{
-				let v = bounds.box[0][1];
-				let x = extremes[0][1].val;
+				const v = bounds.box[0][1];
+				const x = extremes[0][1].val;
 				if (v < x || (v === x && bounds.ts[0][1] > extremes[0][1].t)) { 
 					extremes[0][1] = { 
 						bezier : curve, 
@@ -67,8 +67,8 @@ let getLoopBounds = memoize(function(loop: Loop): {
 
 		{	
 			{
-				let v = bounds.box[1][0];
-				let x = extremes[1][0].val;
+				const v = bounds.box[1][0];
+				const x = extremes[1][0].val;
 				if (v > x || (v === x && bounds.ts[1][0] > extremes[1][0].t)) { 
 					extremes[1][0] = { 
 						bezier : curve, 
@@ -79,8 +79,8 @@ let getLoopBounds = memoize(function(loop: Loop): {
 			}
 
 			{
-				let v = bounds.box[1][1];
-				let x = extremes[1][1].val;
+				const v = bounds.box[1][1];
+				const x = extremes[1][1].val;
 				if (v > x || (v === x && bounds.ts[1][1] > extremes[1][1].t)) { 
 					extremes[1][1] = { 
 						bezier : curve,