flo-mat 2.0.2 → 2.0.3

package/node/svg/get-loop-bounds.js

@@ -1,81 +1,81 @@
-import { getBounds } from 'flo-bezier3';
-import { memoize } from 'flo-memoize';
-import { PointOnShape } from '../point-on-shape.js';
-/** @hidden */
-const INF = Number.POSITIVE_INFINITY;
-/**
- * @hidden
- */
-const getLoopBounds = memoize(function (loop) {
-    const extremes = [
-        [
-            { bezier: undefined, t: undefined, val: INF },
-            { bezier: undefined, t: undefined, val: INF }
-        ],
-        [
-            { bezier: undefined, t: undefined, val: -INF },
-            { bezier: undefined, t: undefined, val: -INF }
-        ]
-    ];
-    loop.curves.forEach(function (curve) {
-        const ps = curve.ps;
-        // const bounds = getBounds_(ps);
-        const bounds = getBounds(ps);
-        {
-            {
-                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,
-                        t: bounds.ts[0][0],
-                        val: v
-                    };
-                }
-            }
-            {
-                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,
-                        t: bounds.ts[0][1],
-                        val: v
-                    };
-                }
-            }
-        }
-        {
-            {
-                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,
-                        t: bounds.ts[1][0],
-                        val: v
-                    };
-                }
-            }
-            {
-                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,
-                        t: bounds.ts[1][1],
-                        val: v
-                    };
-                }
-            }
-        }
-    });
-    return {
-        minX: new PointOnShape(extremes[0][0].bezier, extremes[0][0].t),
-        minY: new PointOnShape(extremes[0][1].bezier, extremes[0][1].t),
-        maxX: new PointOnShape(extremes[1][0].bezier, extremes[1][0].t),
-        maxY: new PointOnShape(extremes[1][1].bezier, extremes[1][1].t)
-    };
-});
-export { getLoopBounds };
+import { getBounds } from 'flo-bezier3';
+import { memoize } from 'flo-memoize';
+import { PointOnShape } from '../point-on-shape.js';
+/** @hidden */
+const INF = Number.POSITIVE_INFINITY;
+/**
+ * @hidden
+ */
+const getLoopBounds = memoize(function (loop) {
+    const extremes = [
+        [
+            { bezier: undefined, t: undefined, val: INF },
+            { bezier: undefined, t: undefined, val: INF }
+        ],
+        [
+            { bezier: undefined, t: undefined, val: -INF },
+            { bezier: undefined, t: undefined, val: -INF }
+        ]
+    ];
+    loop.curves.forEach(function (curve) {
+        const ps = curve.ps;
+        // const bounds = getBounds_(ps);
+        const bounds = getBounds(ps);
+        {
+            {
+                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,
+                        t: bounds.ts[0][0],
+                        val: v
+                    };
+                }
+            }
+            {
+                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,
+                        t: bounds.ts[0][1],
+                        val: v
+                    };
+                }
+            }
+        }
+        {
+            {
+                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,
+                        t: bounds.ts[1][0],
+                        val: v
+                    };
+                }
+            }
+            {
+                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,
+                        t: bounds.ts[1][1],
+                        val: v
+                    };
+                }
+            }
+        }
+    });
+    return {
+        minX: new PointOnShape(extremes[0][0].bezier, extremes[0][0].t),
+        minY: new PointOnShape(extremes[0][1].bezier, extremes[0][1].t),
+        maxX: new PointOnShape(extremes[1][0].bezier, extremes[1][0].t),
+        maxY: new PointOnShape(extremes[1][1].bezier, extremes[1][1].t)
+    };
+});
+export { getLoopBounds };
 //# sourceMappingURL=get-loop-bounds.js.map

package/node/svg/get-min-y-pos.d.ts

@@ -1,8 +1,8 @@
-/** @hidden */
-import { Loop } from '../loop.js';
-/**
- * @hidden
- * Get topmost PointOnShape of the given loop.
- */
-declare function getMinYPos(loop: Loop): import("../point-on-shape.js").IPointOnShape;
-export { getMinYPos };
+/** @hidden */
+import { Loop } from '../loop.js';
+/**
+ * @hidden
+ * Get topmost PointOnShape of the given loop.
+ */
+declare function getMinYPos(loop: Loop): import("../point-on-shape.js").IPointOnShape;
+export { getMinYPos };

package/node/svg/get-min-y-pos.js

@@ -1,10 +1,10 @@
-import { getLoopBounds } from './get-loop-bounds.js';
-/**
- * @hidden
- * Get topmost PointOnShape of the given loop.
- */
-function getMinYPos(loop) {
-    return getLoopBounds(loop).minY;
-}
-export { getMinYPos };
+import { getLoopBounds } from './get-loop-bounds.js';
+/**
+ * @hidden
+ * Get topmost PointOnShape of the given loop.
+ */
+function getMinYPos(loop) {
+    return getLoopBounds(loop).minY;
+}
+export { getMinYPos };
 //# sourceMappingURL=get-min-y-pos.js.map

package/node/svg/get-shape-bounds.d.ts

@@ -1,9 +1,9 @@
-import { Loop } from '../loop.js';
-/** @internal */
-declare const getShapeBounds: (a: Loop[]) => {
-    minX: import("../point-on-shape.js").IPointOnShape;
-    minY: import("../point-on-shape.js").IPointOnShape;
-    maxX: import("../point-on-shape.js").IPointOnShape;
-    maxY: import("../point-on-shape.js").IPointOnShape;
-};
-export { getShapeBounds };
+import { Loop } from '../loop.js';
+/** @internal */
+declare const getShapeBounds: (a: Loop[]) => {
+    minX: import("../point-on-shape.js").IPointOnShape;
+    minY: import("../point-on-shape.js").IPointOnShape;
+    maxX: import("../point-on-shape.js").IPointOnShape;
+    maxY: import("../point-on-shape.js").IPointOnShape;
+};
+export { getShapeBounds };

package/node/svg/get-shape-bounds.js

@@ -1,36 +1,36 @@
-import { memoize } from 'flo-memoize';
-import { getLoopBounds } from './get-loop-bounds.js';
-// TODO - move to another library
-/** @internal */
-const getShapeBounds = memoize(function (loops) {
-    let minX_ = Number.POSITIVE_INFINITY;
-    let maxX_ = Number.NEGATIVE_INFINITY;
-    let minY_ = Number.POSITIVE_INFINITY;
-    let maxY_ = Number.NEGATIVE_INFINITY;
-    let minX;
-    let maxX;
-    let minY;
-    let maxY;
-    for (const loop of loops) {
-        const bounds = getLoopBounds(loop);
-        if (bounds.minX.p[0] < minX_) {
-            minX = bounds.minX;
-            minX_ = bounds.minX.p[0];
-        }
-        if (bounds.maxX.p[0] > maxX_) {
-            maxX = bounds.maxX;
-            maxX_ = bounds.maxX.p[0];
-        }
-        if (bounds.minY.p[1] < minY_) {
-            minY = bounds.minY;
-            minY_ = bounds.minY.p[1];
-        }
-        if (bounds.maxY.p[1] > maxY_) {
-            maxY = bounds.maxY;
-            maxY_ = bounds.maxY.p[1];
-        }
-    }
-    return { minX, minY, maxX, maxY };
-});
-export { getShapeBounds };
+import { memoize } from 'flo-memoize';
+import { getLoopBounds } from './get-loop-bounds.js';
+// TODO - move to another library
+/** @internal */
+const getShapeBounds = memoize(function (loops) {
+    let minX_ = Number.POSITIVE_INFINITY;
+    let maxX_ = Number.NEGATIVE_INFINITY;
+    let minY_ = Number.POSITIVE_INFINITY;
+    let maxY_ = Number.NEGATIVE_INFINITY;
+    let minX;
+    let maxX;
+    let minY;
+    let maxY;
+    for (const loop of loops) {
+        const bounds = getLoopBounds(loop);
+        if (bounds.minX.p[0] < minX_) {
+            minX = bounds.minX;
+            minX_ = bounds.minX.p[0];
+        }
+        if (bounds.maxX.p[0] > maxX_) {
+            maxX = bounds.maxX;
+            maxX_ = bounds.maxX.p[0];
+        }
+        if (bounds.minY.p[1] < minY_) {
+            minY = bounds.minY;
+            minY_ = bounds.minY.p[1];
+        }
+        if (bounds.maxY.p[1] > maxY_) {
+            maxY = bounds.maxY;
+            maxY_ = bounds.maxY.p[1];
+        }
+    }
+    return { minX, minY, maxX, maxY };
+});
+export { getShapeBounds };
 //# sourceMappingURL=get-shape-bounds.js.map

package/node/sweep-line/sweep-line.d.ts

@@ -1,18 +1,18 @@
-/**
- * @hidden
- * Generalized sweepline algorithm.
- *
- * Typically used to turn O(n^2) algorithms into roughly O(n logn) algorithms.
- *
- * @param items An array of items that are to be compared. Items should
- * typically be geometric objects in 2d space with well-defined left and right
- * endpoints.
- * @param getLeftmostPoint A function that returns the leftmost point of the
- * geometric object of interest.
- * @param getRightmostPoint A function that returns the rightmost point of the
- * geometric object of interest.
- * @param predicate A predicate that takes two geometric objects and returns
- * true if they are of interest or false otherwise.
- */
-declare function sweepLine<T>(items: T[], getLeftmost: (item: T) => number, getRightmost: (item: T) => number, predicate: (item1: T, item2: T) => boolean): [T, T][];
-export { sweepLine };
+/**
+ * @hidden
+ * Generalized sweepline algorithm.
+ *
+ * Typically used to turn O(n^2) algorithms into roughly O(n logn) algorithms.
+ *
+ * @param items An array of items that are to be compared. Items should
+ * typically be geometric objects in 2d space with well-defined left and right
+ * endpoints.
+ * @param getLeftmostPoint A function that returns the leftmost point of the
+ * geometric object of interest.
+ * @param getRightmostPoint A function that returns the rightmost point of the
+ * geometric object of interest.
+ * @param predicate A predicate that takes two geometric objects and returns
+ * true if they are of interest or false otherwise.
+ */
+declare function sweepLine<T>(items: T[], getLeftmost: (item: T) => number, getRightmost: (item: T) => number, predicate: (item1: T, item2: T) => boolean): [T, T][];
+export { sweepLine };

package/node/sweep-line/sweep-line.js

@@ -1,73 +1,73 @@
-/** @hidden */
-const EVENT_LEFT = 0;
-/** @hidden */
-const EVENT_RIGHT = 1;
-/**
- * @hidden
- * Generalized sweepline algorithm.
- *
- * Typically used to turn O(n^2) algorithms into roughly O(n logn) algorithms.
- *
- * @param items An array of items that are to be compared. Items should
- * typically be geometric objects in 2d space with well-defined left and right
- * endpoints.
- * @param getLeftmostPoint A function that returns the leftmost point of the
- * geometric object of interest.
- * @param getRightmostPoint A function that returns the rightmost point of the
- * geometric object of interest.
- * @param predicate A predicate that takes two geometric objects and returns
- * true if they are of interest or false otherwise.
- */
-function sweepLine(items, getLeftmost, getRightmost, predicate) {
-    // Initialize event queue to contain all endpoints.
-    const events = [];
-    for (const item of items) {
-        events.push({
-            type: EVENT_LEFT,
-            item,
-            x: getLeftmost(item)
-        });
-        events.push({
-            type: EVENT_RIGHT,
-            item,
-            x: getRightmost(item)
-        });
-    }
-    events.sort(compare);
-    const activeItems = new Set();
-    /** A list of pairs of items that passed the predicate */
-    const pairedItems = [];
-    for (const event of events) {
-        const { item } = event;
-        if (event.type === EVENT_LEFT) {
-            for (const activeItem of activeItems.values()) {
-                if (predicate(item, activeItem)) {
-                    pairedItems.push([item, activeItem]);
-                }
-            }
-            activeItems.add(item);
-        }
-        else if (event.type === EVENT_RIGHT) {
-            activeItems.delete(event.item);
-        }
-    }
-    return pairedItems;
-}
-/**
- * @hidden
- * Compare two Events by their x-axis and then by their type. Since it is
- * open boxes that are compared we must let the right endpoint type come
- * before the left.
- * @param a An event
- * @param b Another event
- */
-function compare(a, b) {
-    const res = a.x - b.x;
-    if (res !== 0) {
-        return res;
-    }
-    // Alwys put left events before right ones.
-    return a.type === EVENT_LEFT ? -1 : +1;
-}
-export { sweepLine };
+/** @hidden */
+const EVENT_LEFT = 0;
+/** @hidden */
+const EVENT_RIGHT = 1;
+/**
+ * @hidden
+ * Generalized sweepline algorithm.
+ *
+ * Typically used to turn O(n^2) algorithms into roughly O(n logn) algorithms.
+ *
+ * @param items An array of items that are to be compared. Items should
+ * typically be geometric objects in 2d space with well-defined left and right
+ * endpoints.
+ * @param getLeftmostPoint A function that returns the leftmost point of the
+ * geometric object of interest.
+ * @param getRightmostPoint A function that returns the rightmost point of the
+ * geometric object of interest.
+ * @param predicate A predicate that takes two geometric objects and returns
+ * true if they are of interest or false otherwise.
+ */
+function sweepLine(items, getLeftmost, getRightmost, predicate) {
+    // Initialize event queue to contain all endpoints.
+    const events = [];
+    for (const item of items) {
+        events.push({
+            type: EVENT_LEFT,
+            item,
+            x: getLeftmost(item)
+        });
+        events.push({
+            type: EVENT_RIGHT,
+            item,
+            x: getRightmost(item)
+        });
+    }
+    events.sort(compare);
+    const activeItems = new Set();
+    /** A list of pairs of items that passed the predicate */
+    const pairedItems = [];
+    for (const event of events) {
+        const { item } = event;
+        if (event.type === EVENT_LEFT) {
+            for (const activeItem of activeItems.values()) {
+                if (predicate(item, activeItem)) {
+                    pairedItems.push([item, activeItem]);
+                }
+            }
+            activeItems.add(item);
+        }
+        else if (event.type === EVENT_RIGHT) {
+            activeItems.delete(event.item);
+        }
+    }
+    return pairedItems;
+}
+/**
+ * @hidden
+ * Compare two Events by their x-axis and then by their type. Since it is
+ * open boxes that are compared we must let the right endpoint type come
+ * before the left.
+ * @param a An event
+ * @param b Another event
+ */
+function compare(a, b) {
+    const res = a.x - b.x;
+    if (res !== 0) {
+        return res;
+    }
+    // Alwys put left events before right ones.
+    return a.type === EVENT_LEFT ? -1 : +1;
+}
+export { sweepLine };
 //# sourceMappingURL=sweep-line.js.map

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

@@ -1,16 +1,16 @@
-import { Mat } from './mat.js';
-/** @hidden */
-/**
- * Apply and returns an enhanced version of the Scale Axis Transform (SAT) to
- * the given MAT. The returned SAT is guaranteed to be a subset of the MAT and
- * preserves topology at any scale.
- *
- * Typically the MAT contains too many branches caused by minute details on the
- * boundary of the shape. The SAT is a simplification of the MAT that preserves
- * less detail the higher the applied scale factor. The severity at which noise
- * are removed depends on the local scale of the shape.
- * @param mat The Medial Axis Transform ([[Mat]]) on which to apply the SAT.
- * @param s The scale factor >= 1 (e.g. 1.3)
- */
-declare function toScaleAxis(mat: Mat, s: number, f?: (s: number) => (r: number) => number): Mat;
-export { toScaleAxis };
+import { Mat } from './mat.js';
+/** @hidden */
+/**
+ * Apply and returns an enhanced version of the Scale Axis Transform (SAT) to
+ * the given MAT. The returned SAT is guaranteed to be a subset of the MAT and
+ * preserves topology at any scale.
+ *
+ * Typically the MAT contains too many branches caused by minute details on the
+ * boundary of the shape. The SAT is a simplification of the MAT that preserves
+ * less detail the higher the applied scale factor. The severity at which noise
+ * are removed depends on the local scale of the shape.
+ * @param mat The Medial Axis Transform ([[Mat]]) on which to apply the SAT.
+ * @param s The scale factor >= 1 (e.g. 1.3)
+ */
+declare function toScaleAxis(mat: Mat, s: number, f?: (s: number) => (r: number) => number): Mat;
+export { toScaleAxis };

package/node/to-scale-axis.js

@@ -1,75 +1,75 @@
-import { length } from 'flo-bezier3';
-import { traverseEdges } from './traverse-edges.js';
-import { traverseVertices } from './traverse-vertices.js';
-import { getLargestVertex } from './mat/get-largest-vertex.js';
-import { getLeaves } from './mat/get-leaves.js';
-import { cull } from './mat/to-scale-axis/cull.js';
-import { addDebugInfo } from './mat/to-scale-axis/add-debug-info.js';
-import { clone } from './cp-node/clone.js';
-import { getCurveToNext } from './get-curve-to-next.js';
-function linearScale(s) {
-    return function (r) {
-        return s * r;
-    };
-}
-/** @hidden */
-//let len = length([0,1]);
-/**
- * Apply and returns an enhanced version of the Scale Axis Transform (SAT) to
- * the given MAT. The returned SAT is guaranteed to be a subset of the MAT and
- * preserves topology at any scale.
- *
- * Typically the MAT contains too many branches caused by minute details on the
- * boundary of the shape. The SAT is a simplification of the MAT that preserves
- * less detail the higher the applied scale factor. The severity at which noise
- * are removed depends on the local scale of the shape.
- * @param mat The Medial Axis Transform ([[Mat]]) on which to apply the SAT.
- * @param s The scale factor >= 1 (e.g. 1.3)
- */
-function toScaleAxis(mat, s, f = linearScale) {
-    let timingStart = 0;
-    if (typeof _debug_ !== 'undefined') {
-        timingStart = performance.now();
-        const leaves = getLeaves(mat.cpNode);
-        _debug_.generated.elems.leaves.push(leaves);
-    }
-    /** The largest vertex (as measured by its inscribed disk) */
-    const cpNodes = [];
-    traverseVertices(clone(mat.cpNode), cpNode => { cpNodes.push(cpNode); });
-    const cpNode = getLargestVertex(cpNodes);
-    const f_ = f(s);
-    if (typeof _debug_ !== 'undefined') {
-        _debug_.generated.elems.maxVertex.push(cpNode);
-    }
-    /**
-     * All vertices that are set to be culled initially. This may change later
-     * in order to preserve topology.
-     */
-    const culls = new Set();
-    const rMap = new Map();
-    traverseEdges(cpNode, function (cpNode) {
-        /** The occulating radius stored with this vertex. */
-        const R = rMap.get(cpNode) || f_(cpNode.cp.circle.radius);
-        const cpNode_ = cpNode.next;
-        const l = length([0, 1], getCurveToNext(cpNode));
-        const r = cpNode_.cp.circle.radius;
-        const r_ = f_(r);
-        if (R - l > r_) {
-            for (const cpNode of cpNode_.getCpNodesOnCircle()) {
-                rMap.set(cpNode, R - l); // Update osculating radii
-            }
-            culls.add(cpNode_.cp.circle);
-        }
-    });
-    cull(culls, cpNode);
-    if (typeof _debug_ !== 'undefined') {
-        _debug_.generated.elems.culls.push(Array.from(culls));
-    }
-    // TODO - put line below back - goes into infinite loop
-    //const sat: Mat = { cpNode, cpTrees: createNewCpTree(cpNode) };
-    const sat = { cpNode, cpTrees: undefined };
-    addDebugInfo(sat, timingStart);
-    return sat;
-}
-export { toScaleAxis };
+import { length } from 'flo-bezier3';
+import { traverseEdges } from './traverse-edges.js';
+import { traverseVertices } from './traverse-vertices.js';
+import { getLargestVertex } from './mat/get-largest-vertex.js';
+import { getLeaves } from './mat/get-leaves.js';
+import { cull } from './mat/to-scale-axis/cull.js';
+import { addDebugInfo } from './mat/to-scale-axis/add-debug-info.js';
+import { clone } from './cp-node/clone.js';
+import { getCurveToNext } from './get-curve-to-next.js';
+function linearScale(s) {
+    return function (r) {
+        return s * r;
+    };
+}
+/** @hidden */
+//let len = length([0,1]);
+/**
+ * Apply and returns an enhanced version of the Scale Axis Transform (SAT) to
+ * the given MAT. The returned SAT is guaranteed to be a subset of the MAT and
+ * preserves topology at any scale.
+ *
+ * Typically the MAT contains too many branches caused by minute details on the
+ * boundary of the shape. The SAT is a simplification of the MAT that preserves
+ * less detail the higher the applied scale factor. The severity at which noise
+ * are removed depends on the local scale of the shape.
+ * @param mat The Medial Axis Transform ([[Mat]]) on which to apply the SAT.
+ * @param s The scale factor >= 1 (e.g. 1.3)
+ */
+function toScaleAxis(mat, s, f = linearScale) {
+    let timingStart = 0;
+    if (typeof _debug_ !== 'undefined') {
+        timingStart = performance.now();
+        const leaves = getLeaves(mat.cpNode);
+        _debug_.generated.elems.leaves.push(leaves);
+    }
+    /** The largest vertex (as measured by its inscribed disk) */
+    const cpNodes = [];
+    traverseVertices(clone(mat.cpNode), cpNode => { cpNodes.push(cpNode); });
+    const cpNode = getLargestVertex(cpNodes);
+    const f_ = f(s);
+    if (typeof _debug_ !== 'undefined') {
+        _debug_.generated.elems.maxVertex.push(cpNode);
+    }
+    /**
+     * All vertices that are set to be culled initially. This may change later
+     * in order to preserve topology.
+     */
+    const culls = new Set();
+    const rMap = new Map();
+    traverseEdges(cpNode, function (cpNode) {
+        /** The occulating radius stored with this vertex. */
+        const R = rMap.get(cpNode) || f_(cpNode.cp.circle.radius);
+        const cpNode_ = cpNode.next;
+        const l = length([0, 1], getCurveToNext(cpNode));
+        const r = cpNode_.cp.circle.radius;
+        const r_ = f_(r);
+        if (R - l > r_) {
+            for (const cpNode of cpNode_.getCpNodesOnCircle()) {
+                rMap.set(cpNode, R - l); // Update osculating radii
+            }
+            culls.add(cpNode_.cp.circle);
+        }
+    });
+    cull(culls, cpNode);
+    if (typeof _debug_ !== 'undefined') {
+        _debug_.generated.elems.culls.push(Array.from(culls));
+    }
+    // TODO - put line below back - goes into infinite loop
+    //const sat: Mat = { cpNode, cpTrees: createNewCpTree(cpNode) };
+    const sat = { cpNode, cpTrees: undefined };
+    addDebugInfo(sat, timingStart);
+    return sat;
+}
+export { toScaleAxis };
 //# sourceMappingURL=to-scale-axis.js.map