flo-mat 2.0.2 → 2.0.3

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

@@ -1,133 +1,133 @@
-import { getLeaves } from '../get-leaves.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.
- */
-function cull(culls, maxCpNode) {
-    const leaves = getLeaves(maxCpNode);
-    function getNonTrivialEdges(cpStart) {
-        let cp = cpStart;
-        const cps = [];
-        do {
-            if (cp.next !== cp.nextOnCircle) {
-                cps.push(cp);
-            }
-            cp = cp.nextOnCircle;
-        } while (cp !== cpStart.prevOnCircle);
-        return cps;
-    }
-    while (leaves.length) {
-        const leaf = leaves.pop();
-        // Preserve topology.
-        if (leaf.isHoleClosing || leaf.isIntersection) {
-            continue;
-        }
-        if (!culls.has(leaf.cp.circle)) {
-            continue;
-        }
-        let cpNode = leaf.next; // Turn around
-        while (true) {
-            cpNode = cpNode.next;
-            let cut = false;
-            const cp1 = cpNode.prevOnCircle;
-            if (!culls.has(cpNode.cp.circle)) {
-                // Cut off the edge once a non-cull has been reached.
-                cut = true;
-            }
-            else if (CpNode.isOnSameCircle(cpNode, maxCpNode)) {
-                cut = true; // We are at the max disk - cut whole edge
-            }
-            else {
-                const cps = getNonTrivialEdges(cpNode);
-                if (cps.length === 1) {
-                    cpNode = cps[0];
-                }
-                else {
-                    cut = true;
-                }
-            }
-            if (cut) {
-                cp1.next = cpNode;
-                cpNode.prev = cp1;
-                break;
-            }
-        }
-    }
-}
-/*
-function cull(
-    culls: Set<Circle>,
-    maxCpNode: CpNode) {
-
-let leaves = getLeaves(maxCpNode);
-
-function getNonTrivialBranches(cpStart: CpNode) {
-    let cp = cpStart.next;
-    
-    let cps: CpNode[] = [];
-    do {
-        if (cp.next !== cp.nextOnCircle) {
-            cps.push(cp);
-        }
-        cp = cp.nextOnCircle;
-    } while (cp !== cpStart)
-
-    return cps;
-}
-
-while (leaves.length) {
-    let leaf = leaves.pop();
-
-    // Preserve topology.
-    if (leaf.isHoleClosing || leaf.isIntersection) { continue; }
-
-    if (!culls.has(leaf.cp.circle)) {
-        continue;
-    }
-
-    let cpNode = leaf.next; // Turn around
-
-    while (true) {
-        cpNode = cpNode.next;
-        let cut = false;
-        let cp1 = cpNode.prevOnCircle;
-
-        if (!culls.has(cpNode.cp.circle)) {
-            // Cut the branch once a non-cull has been reached.
-            cut = true;
-        } else {
-            //let cp2 = cp1.prevOnCircle;
-            let cp2 = cpNode.nextOnCircle;
-
-            //if (maxCpNode === cpNode || maxCpNode === cp1 || maxCpNode === cp2) {
-            if (CpNode.isOnSameCircle(cpNode, maxCpNode)) {
-                cut = true; // We are at the max disk - cut whole edge
-            } else if (cpNode.next === cp2) {
-                // Continue but starting from cp2
-                cpNode = cp2;
-            } else if (cp2.next === cp1) {
-                // Do nothing - ignore the branch starting from cp2 since it
-                // is terminating.
-            } else if (cp2.next !== cp1) {
-                // At this stage (cpNode.next !== cp2 && cp2.next !== cp1)
-                // so it is a bifurcation point - cut the edge.
-                cut = true;
-            }
-        }
-
-        if (cut) {
-            cp1.next = cpNode;
-            cpNode.prev = cp1;
-            break;
-        }
-    }
-}
-}
-*/
-export { cull };
+import { getLeaves } from '../get-leaves.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.
+ */
+function cull(culls, maxCpNode) {
+    const leaves = getLeaves(maxCpNode);
+    function getNonTrivialEdges(cpStart) {
+        let cp = cpStart;
+        const cps = [];
+        do {
+            if (cp.next !== cp.nextOnCircle) {
+                cps.push(cp);
+            }
+            cp = cp.nextOnCircle;
+        } while (cp !== cpStart.prevOnCircle);
+        return cps;
+    }
+    while (leaves.length) {
+        const leaf = leaves.pop();
+        // Preserve topology.
+        if (leaf.isHoleClosing || leaf.isIntersection) {
+            continue;
+        }
+        if (!culls.has(leaf.cp.circle)) {
+            continue;
+        }
+        let cpNode = leaf.next; // Turn around
+        while (true) {
+            cpNode = cpNode.next;
+            let cut = false;
+            const cp1 = cpNode.prevOnCircle;
+            if (!culls.has(cpNode.cp.circle)) {
+                // Cut off the edge once a non-cull has been reached.
+                cut = true;
+            }
+            else if (CpNode.isOnSameCircle(cpNode, maxCpNode)) {
+                cut = true; // We are at the max disk - cut whole edge
+            }
+            else {
+                const cps = getNonTrivialEdges(cpNode);
+                if (cps.length === 1) {
+                    cpNode = cps[0];
+                }
+                else {
+                    cut = true;
+                }
+            }
+            if (cut) {
+                cp1.next = cpNode;
+                cpNode.prev = cp1;
+                break;
+            }
+        }
+    }
+}
+/*
+function cull(
+    culls: Set<Circle>,
+    maxCpNode: CpNode) {
+
+let leaves = getLeaves(maxCpNode);
+
+function getNonTrivialBranches(cpStart: CpNode) {
+    let cp = cpStart.next;
+    
+    let cps: CpNode[] = [];
+    do {
+        if (cp.next !== cp.nextOnCircle) {
+            cps.push(cp);
+        }
+        cp = cp.nextOnCircle;
+    } while (cp !== cpStart)
+
+    return cps;
+}
+
+while (leaves.length) {
+    let leaf = leaves.pop();
+
+    // Preserve topology.
+    if (leaf.isHoleClosing || leaf.isIntersection) { continue; }
+
+    if (!culls.has(leaf.cp.circle)) {
+        continue;
+    }
+
+    let cpNode = leaf.next; // Turn around
+
+    while (true) {
+        cpNode = cpNode.next;
+        let cut = false;
+        let cp1 = cpNode.prevOnCircle;
+
+        if (!culls.has(cpNode.cp.circle)) {
+            // Cut the branch once a non-cull has been reached.
+            cut = true;
+        } else {
+            //let cp2 = cp1.prevOnCircle;
+            let cp2 = cpNode.nextOnCircle;
+
+            //if (maxCpNode === cpNode || maxCpNode === cp1 || maxCpNode === cp2) {
+            if (CpNode.isOnSameCircle(cpNode, maxCpNode)) {
+                cut = true; // We are at the max disk - cut whole edge
+            } else if (cpNode.next === cp2) {
+                // Continue but starting from cp2
+                cpNode = cp2;
+            } else if (cp2.next === cp1) {
+                // Do nothing - ignore the branch starting from cp2 since it
+                // is terminating.
+            } else if (cp2.next !== cp1) {
+                // At this stage (cpNode.next !== cp2 && cp2.next !== cp1)
+                // so it is a bifurcation point - cut the edge.
+                cut = true;
+            }
+        }
+
+        if (cut) {
+            cp1.next = cpNode;
+            cpNode.prev = cp1;
+            break;
+        }
+    }
+}
+}
+*/
+export { cull };
 //# sourceMappingURL=cull.js.map

package/node/mat/trim-mat.d.ts

@@ -1,8 +1,8 @@
-import { Mat } from '../mat.js';
-/**
- * Trims the given Medial Axis Transform so that only cycles remain. Similar to
- * toScaleAxis(mat, Number.POSITIVE_INFINITY).
- * @param mat The MAT to trim.
- */
-declare function trimMat(mat: Mat): Mat;
-export { trimMat };
+import { Mat } from '../mat.js';
+/**
+ * Trims the given Medial Axis Transform so that only cycles remain. Similar to
+ * toScaleAxis(mat, Number.POSITIVE_INFINITY).
+ * @param mat The MAT to trim.
+ */
+declare function trimMat(mat: Mat): Mat;
+export { trimMat };

package/node/mat/trim-mat.js

@@ -1,17 +1,17 @@
-import { createNewCpTree } from './create-new-cp-tree.js';
-import { cullNonCycles } from './to-scale-axis/cull-non-cycles.js';
-import { clone } from '../cp-node/clone.js';
-/**
- * Trims the given Medial Axis Transform so that only cycles remain. Similar to
- * toScaleAxis(mat, Number.POSITIVE_INFINITY).
- * @param mat The MAT to trim.
- */
-function trimMat(mat) {
-    const cpNode = cullNonCycles(clone(mat.cpNode));
-    if (!cpNode) {
-        return undefined;
-    }
-    return { cpNode, cpTrees: createNewCpTree(cpNode) };
-}
-export { trimMat };
+import { createNewCpTree } from './create-new-cp-tree.js';
+import { cullNonCycles } from './to-scale-axis/cull-non-cycles.js';
+import { clone } from '../cp-node/clone.js';
+/**
+ * Trims the given Medial Axis Transform so that only cycles remain. Similar to
+ * toScaleAxis(mat, Number.POSITIVE_INFINITY).
+ * @param mat The MAT to trim.
+ */
+function trimMat(mat) {
+    const cpNode = cullNonCycles(clone(mat.cpNode));
+    if (!cpNode) {
+        return undefined;
+    }
+    return { cpNode, cpTrees: createNewCpTree(cpNode) };
+}
+export { trimMat };
 //# sourceMappingURL=trim-mat.js.map

package/node/mat.d.ts

@@ -1,22 +1,22 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { CpNode } from './cp-node.js';
-import { Loop } from './loop.js';
-/**
- * Represents a complete Medial Axis Transform (MAT).
- *
- * The MAT is fully described through its [[CpNode]] property. The [[cpTrees]]
- * property is only added to facilitate extension of the MAT, e.g. by adding
- * extra maximal disks and is typically not used. See [[CpNode]] for more
- * details.
- */
-interface Mat {
-    /** A complete representation of the MAT. See [[CpNode]]. */
-    cpNode: CpNode;
-    /**
-     * Primarily for internal use. A tree structure storing the
-     * [[CpNode]]s of the MAT by their compare order, i.e. their cyclic order
-     * around the shape boundary.
-     */
-    cpTrees: Map<Loop, LlRbTree<CpNode>>;
-}
-export { Mat };
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { CpNode } from './cp-node.js';
+import { Loop } from './loop.js';
+/**
+ * Represents a complete Medial Axis Transform (MAT).
+ *
+ * The MAT is fully described through its [[CpNode]] property. The [[cpTrees]]
+ * property is only added to facilitate extension of the MAT, e.g. by adding
+ * extra maximal disks and is typically not used. See [[CpNode]] for more
+ * details.
+ */
+interface Mat {
+    /** A complete representation of the MAT. See [[CpNode]]. */
+    cpNode: CpNode;
+    /**
+     * Primarily for internal use. A tree structure storing the
+     * [[CpNode]]s of the MAT by their compare order, i.e. their cyclic order
+     * around the shape boundary.
+     */
+    cpTrees: Map<Loop, LlRbTree<CpNode>>;
+}
+export { Mat };

package/node/mat.js

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=mat.js.map

package/node/point-on-shape.d.ts

@@ -1,73 +1,73 @@
-import { Curve } from './curve.js';
-import { Circle } from './circle.js';
-interface IPointOnShape {
-    /** The [[ICurve]] on the shape boundary this points belong to. */
-    curve: Curve;
-    /** The bezier parameter value on the curve identifying the point coordinates. */
-    t: number;
-    p: number[];
-}
-/**
- * Represents a point on the shape boundary for which MAT vertex information
- * has not *necessarily* been calculated.
- */
-declare class PointOnShape implements IPointOnShape {
-    readonly curve: Curve;
-    readonly t: number;
-    /**
-     * @param curve	The [[ICurve]] on the shape boundary this points belong to.
-     * @param t The bezier parameter value on the curve to identify the point
-     * coordinates.
-     */
-    constructor(curve: Curve, t: number);
-    private p_;
-    /**
-     * The planar point coordinates of this [[PointOnShape]].
-     */
-    get p(): number[];
-}
-/**
- * @hidden
- */
-declare const isPosSharpCorner: (a: IPointOnShape) => boolean;
-/**
- * @hidden
- */
-declare const isPosDullCorner: (a: IPointOnShape) => boolean;
-/**
- * @hidden
- */
-declare const isPosQuiteSharpCorner: (a: IPointOnShape) => boolean;
-/**
- * @hidden
- */
-declare const isPosQuiteDullCorner: (a: IPointOnShape) => boolean;
-/**
- * Returns a human-readable string of the given [[PointOnShape]].
- * For debugging only.
- * @hidden
- */
-declare function posToHumanString(pos: IPointOnShape): string;
-/**
- * @hidden
- * Calculates the order (to distinguish between points lying on top of each
- * other) of the contact point if it is a dull corner.
- * @param pos
- */
-declare function calcPosOrder(circle: Circle, pos: IPointOnShape): number;
-/**
- * Compares two [[PointOnShape]]s according to their cyclic ordering imposed
- * by their relative positions on the shape boundary.
- * @param a The first [[PointOnShape]].
- * @param b The second [[PointOnShape]].
- * @hidden
- */
-declare function comparePoss(a: IPointOnShape, b: IPointOnShape): number;
-/**
- * Returns the osculating circle at this point of the curve.
- * @param maxOsculatingCircleRadius If not Number.POSITIVE_INFINITY then the
- * circle radius will be limited to this value.
- * @param pos The [[PointOnShape]] identifying the point.
- */
-declare function getOsculatingCircle(maxOsculatingCircleRadius: number, pos: IPointOnShape): Circle;
-export { IPointOnShape, PointOnShape, getOsculatingCircle, comparePoss, calcPosOrder, posToHumanString, isPosSharpCorner, isPosDullCorner, isPosQuiteSharpCorner, isPosQuiteDullCorner };
+import { Curve } from './curve.js';
+import { Circle } from './circle.js';
+interface IPointOnShape {
+    /** The [[ICurve]] on the shape boundary this points belong to. */
+    curve: Curve;
+    /** The bezier parameter value on the curve identifying the point coordinates. */
+    t: number;
+    p: number[];
+}
+/**
+ * Represents a point on the shape boundary for which MAT vertex information
+ * has not *necessarily* been calculated.
+ */
+declare class PointOnShape implements IPointOnShape {
+    readonly curve: Curve;
+    readonly t: number;
+    /**
+     * @param curve	The [[ICurve]] on the shape boundary this points belong to.
+     * @param t The bezier parameter value on the curve to identify the point
+     * coordinates.
+     */
+    constructor(curve: Curve, t: number);
+    private p_;
+    /**
+     * The planar point coordinates of this [[PointOnShape]].
+     */
+    get p(): number[];
+}
+/**
+ * @hidden
+ */
+declare const isPosSharpCorner: (a: IPointOnShape) => boolean;
+/**
+ * @hidden
+ */
+declare const isPosDullCorner: (a: IPointOnShape) => boolean;
+/**
+ * @hidden
+ */
+declare const isPosQuiteSharpCorner: (a: IPointOnShape) => boolean;
+/**
+ * @hidden
+ */
+declare const isPosQuiteDullCorner: (a: IPointOnShape) => boolean;
+/**
+ * Returns a human-readable string of the given [[PointOnShape]].
+ * For debugging only.
+ * @hidden
+ */
+declare function posToHumanString(pos: IPointOnShape): string;
+/**
+ * @hidden
+ * Calculates the order (to distinguish between points lying on top of each
+ * other) of the contact point if it is a dull corner.
+ * @param pos
+ */
+declare function calcPosOrder(circle: Circle, pos: IPointOnShape): number;
+/**
+ * Compares two [[PointOnShape]]s according to their cyclic ordering imposed
+ * by their relative positions on the shape boundary.
+ * @param a The first [[PointOnShape]].
+ * @param b The second [[PointOnShape]].
+ * @hidden
+ */
+declare function comparePoss(a: IPointOnShape, b: IPointOnShape): number;
+/**
+ * Returns the osculating circle at this point of the curve.
+ * @param maxOsculatingCircleRadius If not Number.POSITIVE_INFINITY then the
+ * circle radius will be limited to this value.
+ * @param pos The [[PointOnShape]] identifying the point.
+ */
+declare function getOsculatingCircle(maxOsculatingCircleRadius: number, pos: IPointOnShape): Circle;
+export { IPointOnShape, PointOnShape, getOsculatingCircle, comparePoss, calcPosOrder, posToHumanString, isPosSharpCorner, isPosDullCorner, isPosQuiteSharpCorner, isPosQuiteDullCorner };