flo-mat 2.0.2 → 2.0.3

package/node/mat/is-another-cp-closeby.js

@@ -1,56 +1,56 @@
-import { distanceBetween, toUnitVector, fromTo, dot } from 'flo-vector2d';
-import { getNeighbouringPoints } from './get-neighboring-cps.js';
-/** @hidden */
-//const ANGLE_THRESHOLD = Math.cos(3 * (Math.PI / 180)); // 3 degrees
-const ANGLE_THRESHOLD = 0.9986295347545738; // === Math.cos(3  degrees)
-//const ANGLE_THRESHOLD = 0.9848077530122080; // === Math.cos(10 degrees)
-//const ANGLE_THRESHOLD = 0.9998476951563913; // === Math.cos(1 degrees)
-//const ANGLE_THRESHOLD = 0.9999984769132877; // === Math.cos(0.1 degrees)   
-//const ANGLE_THRESHOLD = 0.9999999847691291  // === Math.cos(0.01 degrees)   
-/**
- * @hidden
- * Returns true if another CpNode is close to the given implied (via pos, order
- * and order2) CpNode.
- * @param cpTrees
- * @param pos
- * @param circle
- * @param order
- * @param order2
- * @param extreme The maximum coordinate value used to calculate floating point
- * tolerances.
- * @param color Used for debugging only
- */
-function isAnotherCpCloseby(cpTrees, pos, circle, order, order2, extreme, color) {
-    //console.log(extreme)
-    //const DISTANCE_THRESHOLD = extreme * 1e-1; 
-    //const DISTANCE_THRESHOLD = extreme * 1e-1;
-    const DISTANCE_THRESHOLD = extreme * 1e-4;
-    //const DISTANCE_THRESHOLD = extreme * 1e-4; - was this
-    //const DISTANCE_THRESHOLD = extreme * 1e-6;
-    //const DISTANCE_THRESHOLD = extreme * 1e-12;
-    // It seems this can be zero else the ordering should be correct
-    //const DISTANCE_THRESHOLD = 0;
-    const cpTree = cpTrees.get(pos.curve.loop);
-    const cpNodes = getNeighbouringPoints(cpTree, pos, order, order2);
-    if (!cpNodes[0]) {
-        return false;
-    }
-    for (const cpNode of cpNodes) {
-        const pos2 = cpNode.cp.pointOnShape;
-        const p1 = pos.p;
-        const p2 = pos2.p;
-        if (distanceBetween(p1, p2) > DISTANCE_THRESHOLD) {
-            continue;
-        }
-        const v1 = toUnitVector(fromTo(cpNode.cp.pointOnShape.p, cpNode.cp.circle.center));
-        const v2 = toUnitVector(fromTo(p1, circle.center));
-        const cosTheta = dot(v1, v2);
-        if (cosTheta > ANGLE_THRESHOLD) {
-            //console.log(`%c${cosTheta} - ${distanceBetween(p1,p2)}`, `color: ${color}`);
-            return true;
-        }
-    }
-    return false;
-}
-export { isAnotherCpCloseby };
+import { distanceBetween, toUnitVector, fromTo, dot } from 'flo-vector2d';
+import { getNeighbouringPoints } from './get-neighboring-cps.js';
+/** @hidden */
+//const ANGLE_THRESHOLD = Math.cos(3 * (Math.PI / 180)); // 3 degrees
+const ANGLE_THRESHOLD = 0.9986295347545738; // === Math.cos(3  degrees)
+//const ANGLE_THRESHOLD = 0.9848077530122080; // === Math.cos(10 degrees)
+//const ANGLE_THRESHOLD = 0.9998476951563913; // === Math.cos(1 degrees)
+//const ANGLE_THRESHOLD = 0.9999984769132877; // === Math.cos(0.1 degrees)   
+//const ANGLE_THRESHOLD = 0.9999999847691291  // === Math.cos(0.01 degrees)   
+/**
+ * @hidden
+ * Returns true if another CpNode is close to the given implied (via pos, order
+ * and order2) CpNode.
+ * @param cpTrees
+ * @param pos
+ * @param circle
+ * @param order
+ * @param order2
+ * @param extreme The maximum coordinate value used to calculate floating point
+ * tolerances.
+ * @param color Used for debugging only
+ */
+function isAnotherCpCloseby(cpTrees, pos, circle, order, order2, extreme, color) {
+    //console.log(extreme)
+    //const DISTANCE_THRESHOLD = extreme * 1e-1; 
+    //const DISTANCE_THRESHOLD = extreme * 1e-1;
+    const DISTANCE_THRESHOLD = extreme * 1e-4;
+    //const DISTANCE_THRESHOLD = extreme * 1e-4; - was this
+    //const DISTANCE_THRESHOLD = extreme * 1e-6;
+    //const DISTANCE_THRESHOLD = extreme * 1e-12;
+    // It seems this can be zero else the ordering should be correct
+    //const DISTANCE_THRESHOLD = 0;
+    const cpTree = cpTrees.get(pos.curve.loop);
+    const cpNodes = getNeighbouringPoints(cpTree, pos, order, order2);
+    if (!cpNodes[0]) {
+        return false;
+    }
+    for (const cpNode of cpNodes) {
+        const pos2 = cpNode.cp.pointOnShape;
+        const p1 = pos.p;
+        const p2 = pos2.p;
+        if (distanceBetween(p1, p2) > DISTANCE_THRESHOLD) {
+            continue;
+        }
+        const v1 = toUnitVector(fromTo(cpNode.cp.pointOnShape.p, cpNode.cp.circle.center));
+        const v2 = toUnitVector(fromTo(p1, circle.center));
+        const cosTheta = dot(v1, v2);
+        if (cosTheta > ANGLE_THRESHOLD) {
+            //console.log(`%c${cosTheta} - ${distanceBetween(p1,p2)}`, `color: ${color}`);
+            return true;
+        }
+    }
+    return false;
+}
+export { isAnotherCpCloseby };
 //# sourceMappingURL=is-another-cp-closeby.js.map

package/node/mat/simplify-mat-map-only.d.ts

@@ -1,23 +1,23 @@
-import { CpNode } from '../cp-node.js';
-/**
- * Simplifies the given MAT by replacing the piecewise quad beziers composing
- * the MAT with fewer ones to within a given tolerance. Returns the map of
- * to be deleted nodes only - does not actually delete them. Use simplifyMat
- * instead if you want to delete the nodes.
- * @param cpNode A representation of the MAT
- * @param anlgeTolerance Tolerance given as the degrees difference of the unit
- * direction vectors at the interface between curves. A tolerance of zero means
- * perfect smoothness is required - defaults to 15.
- * @param hausdorffTolerance The approximate maximum Hausdorff Distance tolerance -
- * defaults to 0.1
- * @param hausdorffSpacing The spacing on the curves used to calculate the Hausdorff
- * Distance - defaults to 1
- */
-declare function simplifyMatMapOnly(cpNode: CpNode, anlgeTolerance?: number, hausdorffTolerance?: number, hausdorffSpacing?: number): {
-    simpleMap: Map<CpNode, {
-        ps: number[][];
-        ts: number[];
-    }>;
-    cpNode: CpNode;
-};
-export { simplifyMatMapOnly };
+import { CpNode } from '../cp-node.js';
+/**
+ * Simplifies the given MAT by replacing the piecewise quad beziers composing
+ * the MAT with fewer ones to within a given tolerance. Returns the map of
+ * to be deleted nodes only - does not actually delete them. Use simplifyMat
+ * instead if you want to delete the nodes.
+ * @param cpNode A representation of the MAT
+ * @param anlgeTolerance Tolerance given as the degrees difference of the unit
+ * direction vectors at the interface between curves. A tolerance of zero means
+ * perfect smoothness is required - defaults to 15.
+ * @param hausdorffTolerance The approximate maximum Hausdorff Distance tolerance -
+ * defaults to 0.1
+ * @param hausdorffSpacing The spacing on the curves used to calculate the Hausdorff
+ * Distance - defaults to 1
+ */
+declare function simplifyMatMapOnly(cpNode: CpNode, anlgeTolerance?: number, hausdorffTolerance?: number, hausdorffSpacing?: number): {
+    simpleMap: Map<CpNode, {
+        ps: number[][];
+        ts: number[];
+    }>;
+    cpNode: CpNode;
+};
+export { simplifyMatMapOnly };

package/node/mat/simplify-mat-map-only.js

@@ -1,81 +1,81 @@
-import { closestPointOnBezier, hausdorffDistance, toCubic } from 'flo-bezier3';
-import { getBranches } from '../get-branches.js';
-import { getCurveToNext } from '../get-curve-to-next.js';
-import { getCurveBetween } from '../get-curve/get-curve-between.js';
-/**
- * Simplifies the given MAT by replacing the piecewise quad beziers composing
- * the MAT with fewer ones to within a given tolerance. Returns the map of
- * to be deleted nodes only - does not actually delete them. Use simplifyMat
- * instead if you want to delete the nodes.
- * @param cpNode A representation of the MAT
- * @param anlgeTolerance Tolerance given as the degrees difference of the unit
- * direction vectors at the interface between curves. A tolerance of zero means
- * perfect smoothness is required - defaults to 15.
- * @param hausdorffTolerance The approximate maximum Hausdorff Distance tolerance -
- * defaults to 0.1
- * @param hausdorffSpacing The spacing on the curves used to calculate the Hausdorff
- * Distance - defaults to 1
- */
-function simplifyMatMapOnly(cpNode, anlgeTolerance = 15, hausdorffTolerance = 1e-1, hausdorffSpacing = 1e0) {
-    const simpleMap = new Map();
-    // Start from a leaf
-    while (!cpNode.isTerminating()) {
-        cpNode = cpNode.next;
-    }
-    const branches = getBranches(cpNode, anlgeTolerance);
-    const canDeletes = [];
-    for (let k = 0; k < branches.length; k++) {
-        const branch = branches[k];
-        // Try to remove some
-        let j = 0;
-        while (j < branch.length) {
-            const i = j;
-            while (true) {
-                j++;
-                if (j === branch.length) {
-                    break;
-                }
-                const hd = getTotalHausdorffDistance(i, j, branch, hausdorffSpacing);
-                if (hd > hausdorffTolerance) {
-                    break;
-                }
-                else {
-                    canDeletes.push(branch[j]);
-                }
-            }
-            if (i + 1 === j) {
-                // no simplification occured
-            }
-            else {
-                const branStart = branch[i];
-                const branEnd = branch[j - 1];
-                const medial = toCubic(getCurveBetween(branStart, branEnd.next));
-                const rev = medial.slice().reverse();
-                let curCpNode = branStart;
-                let prevT = 0;
-                while (curCpNode !== branEnd) {
-                    const t = closestPointOnBezier(medial, curCpNode.next.cp.circle.center).t;
-                    simpleMap.set(curCpNode, { ps: medial, ts: [prevT, t] });
-                    const oppositeCpNode = curCpNode.nextOnCircle.prev;
-                    simpleMap.set(oppositeCpNode, { ps: rev, ts: [1 - t, 1 - prevT] });
-                    prevT = t;
-                    curCpNode = curCpNode.next;
-                }
-                simpleMap.set(curCpNode, { ps: medial, ts: [prevT, 1] });
-                const oppositeCpNode = curCpNode.nextOnCircle.prev;
-                simpleMap.set(oppositeCpNode, { ps: rev, ts: [0, 1 - prevT] });
-            }
-        }
-    }
-    return { simpleMap, cpNode };
-}
-function getTotalHausdorffDistance(i, j, branch, hausdorffSpacing) {
-    const hds = [];
-    const longCurve = getCurveBetween(branch[i], branch[j].next);
-    for (let m = i; m < j + 1; m++) {
-        hds.push(hausdorffDistance(getCurveToNext(branch[m]), longCurve, hausdorffSpacing));
-    }
-    return Math.max(...hds);
-}
-export { simplifyMatMapOnly };
+import { closestPointOnBezier, hausdorffDistance, toCubic } from 'flo-bezier3';
+import { getBranches } from '../get-branches.js';
+import { getCurveToNext } from '../get-curve-to-next.js';
+import { getCurveBetween } from '../get-curve/get-curve-between.js';
+/**
+ * Simplifies the given MAT by replacing the piecewise quad beziers composing
+ * the MAT with fewer ones to within a given tolerance. Returns the map of
+ * to be deleted nodes only - does not actually delete them. Use simplifyMat
+ * instead if you want to delete the nodes.
+ * @param cpNode A representation of the MAT
+ * @param anlgeTolerance Tolerance given as the degrees difference of the unit
+ * direction vectors at the interface between curves. A tolerance of zero means
+ * perfect smoothness is required - defaults to 15.
+ * @param hausdorffTolerance The approximate maximum Hausdorff Distance tolerance -
+ * defaults to 0.1
+ * @param hausdorffSpacing The spacing on the curves used to calculate the Hausdorff
+ * Distance - defaults to 1
+ */
+function simplifyMatMapOnly(cpNode, anlgeTolerance = 15, hausdorffTolerance = 1e-1, hausdorffSpacing = 1e0) {
+    const simpleMap = new Map();
+    // Start from a leaf
+    while (!cpNode.isTerminating()) {
+        cpNode = cpNode.next;
+    }
+    const branches = getBranches(cpNode, anlgeTolerance);
+    const canDeletes = [];
+    for (let k = 0; k < branches.length; k++) {
+        const branch = branches[k];
+        // Try to remove some
+        let j = 0;
+        while (j < branch.length) {
+            const i = j;
+            while (true) {
+                j++;
+                if (j === branch.length) {
+                    break;
+                }
+                const hd = getTotalHausdorffDistance(i, j, branch, hausdorffSpacing);
+                if (hd > hausdorffTolerance) {
+                    break;
+                }
+                else {
+                    canDeletes.push(branch[j]);
+                }
+            }
+            if (i + 1 === j) {
+                // no simplification occured
+            }
+            else {
+                const branStart = branch[i];
+                const branEnd = branch[j - 1];
+                const medial = toCubic(getCurveBetween(branStart, branEnd.next));
+                const rev = medial.slice().reverse();
+                let curCpNode = branStart;
+                let prevT = 0;
+                while (curCpNode !== branEnd) {
+                    const t = closestPointOnBezier(medial, curCpNode.next.cp.circle.center).t;
+                    simpleMap.set(curCpNode, { ps: medial, ts: [prevT, t] });
+                    const oppositeCpNode = curCpNode.nextOnCircle.prev;
+                    simpleMap.set(oppositeCpNode, { ps: rev, ts: [1 - t, 1 - prevT] });
+                    prevT = t;
+                    curCpNode = curCpNode.next;
+                }
+                simpleMap.set(curCpNode, { ps: medial, ts: [prevT, 1] });
+                const oppositeCpNode = curCpNode.nextOnCircle.prev;
+                simpleMap.set(oppositeCpNode, { ps: rev, ts: [0, 1 - prevT] });
+            }
+        }
+    }
+    return { simpleMap, cpNode };
+}
+function getTotalHausdorffDistance(i, j, branch, hausdorffSpacing) {
+    const hds = [];
+    const longCurve = getCurveBetween(branch[i], branch[j].next);
+    for (let m = i; m < j + 1; m++) {
+        hds.push(hausdorffDistance(getCurveToNext(branch[m]), longCurve, hausdorffSpacing));
+    }
+    return Math.max(...hds);
+}
+export { simplifyMatMapOnly };
 //# sourceMappingURL=simplify-mat-map-only.js.map

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

@@ -1,7 +1,7 @@
-import { Mat } from '../../mat.js';
-/**
- * @hidden
- * @param sat
- */
-declare function addDebugInfo(sat: Mat, timingStart: number): void;
-export { addDebugInfo };
+import { Mat } from '../../mat.js';
+/**
+ * @hidden
+ * @param sat
+ */
+declare function addDebugInfo(sat: Mat, timingStart: number): void;
+export { addDebugInfo };

package/node/mat/to-scale-axis/add-debug-info.js

@@ -1,14 +1,14 @@
-/**
- * @hidden
- * @param sat
- */
-function addDebugInfo(sat, timingStart) {
-    if (typeof _debug_ === 'undefined') {
-        return;
-    }
-    _debug_.generated.elems.sat.push(sat);
-    const timing = _debug_.generated.timing;
-    timing.sats = performance.now() - timingStart;
-}
-export { addDebugInfo };
+/**
+ * @hidden
+ * @param sat
+ */
+function addDebugInfo(sat, timingStart) {
+    if (typeof _debug_ === 'undefined') {
+        return;
+    }
+    _debug_.generated.elems.sat.push(sat);
+    const timing = _debug_.generated.timing;
+    timing.sats = performance.now() - timingStart;
+}
+export { addDebugInfo };
 //# sourceMappingURL=add-debug-info.js.map

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

@@ -1,9 +1,9 @@
-import { CpNode } from '../../cp-node.js';
-/**
- * @hidden
- * Cull all edges not part of a cycle in the MAT planar graph.
- * @param cpStart The start CpNode which must reprsesent the maximal 3-prong
- * vertex.
- */
-declare function cullNonCycles(cpStart: CpNode): CpNode;
-export { cullNonCycles };
+import { CpNode } from '../../cp-node.js';
+/**
+ * @hidden
+ * Cull all edges not part of a cycle in the MAT planar graph.
+ * @param cpStart The start CpNode which must reprsesent the maximal 3-prong
+ * vertex.
+ */
+declare function cullNonCycles(cpStart: CpNode): CpNode;
+export { cullNonCycles };

package/node/mat/to-scale-axis/cull-non-cycles.js

@@ -1,52 +1,52 @@
-import { getLeaves } from '../get-leaves.js';
-import { CpNode } from '../../cp-node.js';
-/**
- * @hidden
- * Cull all edges not part of a cycle in the MAT planar graph.
- * @param cpStart The start CpNode which must reprsesent the maximal 3-prong
- * vertex.
- */
-function cullNonCycles(cpStart) {
-    let cpNodeKept = cpStart;
-    const leaves = getLeaves(cpStart);
-    while (leaves.length) {
-        const leaf = leaves.pop();
-        // Preserve topology - keep cycles.
-        if (leaf.isHoleClosing || leaf.isIntersection) {
-            continue;
-        }
-        let cpNode = leaf.next; // Turn around
-        while (true) {
-            cpNode = cpNode.next;
-            let cut = false;
-            const cp1 = cpNode.prevOnCircle;
-            if (cpNode.getProngCount() > 2) {
-                //const cp2 = cp1.prevOnCircle;
-                const cp2 = cpNode.nextOnCircle;
-                //if (cpStart === cpNode || cpStart === cp1 || cpStart === cp2) {
-                if (CpNode.isOnSameCircle(cpNode, cpStart)) {
-                    cut = true; // We are at the max disk - cut whole edge
-                }
-                else if (cpNode.next === cp2) {
-                    cpNode = cp2;
-                }
-                else if (cp2.next !== cp1) {
-                    cut = true; // Cut whole edge
-                }
-            }
-            else if (cpNode.isTerminating() && !cpNode.isIntersection) {
-                cpNodeKept = cpNode;
-                return undefined;
-            }
-            if (cut) {
-                cp1.next = cpNode;
-                cpNode.prev = cp1;
-                cpNodeKept = cpNode;
-                break;
-            }
-        }
-    }
-    return cpNodeKept;
-}
-export { cullNonCycles };
+import { getLeaves } from '../get-leaves.js';
+import { CpNode } from '../../cp-node.js';
+/**
+ * @hidden
+ * Cull all edges not part of a cycle in the MAT planar graph.
+ * @param cpStart The start CpNode which must reprsesent the maximal 3-prong
+ * vertex.
+ */
+function cullNonCycles(cpStart) {
+    let cpNodeKept = cpStart;
+    const leaves = getLeaves(cpStart);
+    while (leaves.length) {
+        const leaf = leaves.pop();
+        // Preserve topology - keep cycles.
+        if (leaf.isHoleClosing || leaf.isIntersection) {
+            continue;
+        }
+        let cpNode = leaf.next; // Turn around
+        while (true) {
+            cpNode = cpNode.next;
+            let cut = false;
+            const cp1 = cpNode.prevOnCircle;
+            if (cpNode.getProngCount() > 2) {
+                //const cp2 = cp1.prevOnCircle;
+                const cp2 = cpNode.nextOnCircle;
+                //if (cpStart === cpNode || cpStart === cp1 || cpStart === cp2) {
+                if (CpNode.isOnSameCircle(cpNode, cpStart)) {
+                    cut = true; // We are at the max disk - cut whole edge
+                }
+                else if (cpNode.next === cp2) {
+                    cpNode = cp2;
+                }
+                else if (cp2.next !== cp1) {
+                    cut = true; // Cut whole edge
+                }
+            }
+            else if (cpNode.isTerminating() && !cpNode.isIntersection) {
+                cpNodeKept = cpNode;
+                return undefined;
+            }
+            if (cut) {
+                cp1.next = cpNode;
+                cpNode.prev = cp1;
+                cpNodeKept = cpNode;
+                break;
+            }
+        }
+    }
+    return cpNodeKept;
+}
+export { cullNonCycles };
 //# sourceMappingURL=cull-non-cycles.js.map

package/node/mat/to-scale-axis/cull.d.ts

@@ -1,12 +1,12 @@
-import { Circle } from '../../circle.js';
-import { CpNode } from '../../cp-node.js';
-/**
- * @hidden
- * Returns the set of Vertices passing the following test: walk the MAT tree and
- * keep all Vertices not in the current cull set and any Vertices that have a
- * non-culled node further down the line toward the tree leaves.
- * @param culls The CpNodes (referred to by circles) that should be culled.
- * @param maxCpNode The start CpNode which must reprsesent the maximal vertex.
- */
-declare function cull(culls: Set<Circle>, maxCpNode: CpNode): void;
-export { cull };
+import { Circle } from '../../circle.js';
+import { CpNode } from '../../cp-node.js';
+/**
+ * @hidden
+ * Returns the set of Vertices passing the following test: walk the MAT tree and
+ * keep all Vertices not in the current cull set and any Vertices that have a
+ * non-culled node further down the line toward the tree leaves.
+ * @param culls The CpNodes (referred to by circles) that should be culled.
+ * @param maxCpNode The start CpNode which must reprsesent the maximal vertex.
+ */
+declare function cull(culls: Set<Circle>, maxCpNode: CpNode): void;
+export { cull };