flo-mat 2.0.2 → 2.0.3

package/node/mat/closest-boundary-point/get-close-boundary-points.js

@@ -1,81 +1,81 @@
-import { distanceBetween } from 'flo-vector2d';
-import { PointOnShape } from '../../point-on-shape.js';
-import { cullBezierPieces } from './cull-bezier-pieces.js';
-import { closestPointsOnCurve } from './closest-points-on-curve.js';
-/**
- * @hidden
- * Returns the closest boundary point to the given point, limited to the given
- * bezier pieces, including the beziers actually checked after culling.
- * @param bezierPieces
- * @param point
- * @param touchedCurve
- * @param t
- * @param extreme
- */
-function getCloseBoundaryPoints(bezierPieces, point, y, distance) {
-    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!
-    const DISTANCE_TOLERANCE = 1e-9;
-    const posInfos = [];
-    for (let i = 0; i < bezierPieces.length; i++) {
-        const bezierPiece = bezierPieces[i];
-        // TOOD - important - should be able to return multiple points
-        const ps = closestPointsOnCurve(bezierPiece.curve, point, bezierPiece.ts, touchedCurve, t);
-        //if (ps === undefined) { continue; }
-        for (let j = 0; j < ps.length; j++) {
-            const p = ps[j];
-            const d = distanceBetween(p.p, point);
-            let curve = bezierPiece.curve;
-            let t_ = p.t;
-            if (Math.abs(d - distance) < DISTANCE_TOLERANCE) {
-                if (t_ === 0) {
-                    t_ = 1;
-                    curve = bezierPiece.curve.prev;
-                }
-                posInfos.push({ pos: new PointOnShape(curve, t_), d });
-            }
-        }
-    }
-    if (posInfos.length > 1) {
-        // Remove ones that are too close together.
-        // 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!
-        const indexesToCheck = [];
-        for (let i = 0; i < posInfos.length; 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);
-            //}
-        }
-        const indexesToRemove = [];
-        for (let i = 0; i < indexesToCheck.length; i++) {
-            for (let j = i + 1; j < indexesToCheck.length; j++) {
-                if (i === j) {
-                    continue;
-                }
-                const p1 = posInfos[indexesToCheck[i]].pos.p;
-                const p2 = posInfos[indexesToCheck[j]].pos.p;
-                // Below checks for source point too - similar to 
-                // isAnotherCpCloseBy
-                const p3 = p_;
-                if ((Math.abs(p1[0] - p2[0]) < 1e-6 &&
-                    Math.abs(p1[1] - p2[1]) < 1e-6) ||
-                    (Math.abs(p1[0] - p3[0]) < 1e-6 &&
-                        Math.abs(p1[1] - p3[1]) < 1e-6)) {
-                    indexesToRemove.push(indexesToCheck[i]);
-                }
-            }
-        }
-        for (let i = indexesToRemove.length - 1; i >= 0; i--) {
-            posInfos.splice(indexesToRemove[i], 1);
-        }
-    }
-    return posInfos;
-}
-export { getCloseBoundaryPoints };
+import { distanceBetween } from 'flo-vector2d';
+import { PointOnShape } from '../../point-on-shape.js';
+import { cullBezierPieces } from './cull-bezier-pieces.js';
+import { closestPointsOnCurve } from './closest-points-on-curve.js';
+/**
+ * @hidden
+ * Returns the closest boundary point to the given point, limited to the given
+ * bezier pieces, including the beziers actually checked after culling.
+ * @param bezierPieces
+ * @param point
+ * @param touchedCurve
+ * @param t
+ * @param extreme
+ */
+function getCloseBoundaryPoints(bezierPieces, point, y, distance) {
+    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!
+    const DISTANCE_TOLERANCE = 1e-9;
+    const posInfos = [];
+    for (let i = 0; i < bezierPieces.length; i++) {
+        const bezierPiece = bezierPieces[i];
+        // TOOD - important - should be able to return multiple points
+        const ps = closestPointsOnCurve(bezierPiece.curve, point, bezierPiece.ts, touchedCurve, t);
+        //if (ps === undefined) { continue; }
+        for (let j = 0; j < ps.length; j++) {
+            const p = ps[j];
+            const d = distanceBetween(p.p, point);
+            let curve = bezierPiece.curve;
+            let t_ = p.t;
+            if (Math.abs(d - distance) < DISTANCE_TOLERANCE) {
+                if (t_ === 0) {
+                    t_ = 1;
+                    curve = bezierPiece.curve.prev;
+                }
+                posInfos.push({ pos: new PointOnShape(curve, t_), d });
+            }
+        }
+    }
+    if (posInfos.length > 1) {
+        // Remove ones that are too close together.
+        // 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!
+        const indexesToCheck = [];
+        for (let i = 0; i < posInfos.length; 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);
+            //}
+        }
+        const indexesToRemove = [];
+        for (let i = 0; i < indexesToCheck.length; i++) {
+            for (let j = i + 1; j < indexesToCheck.length; j++) {
+                if (i === j) {
+                    continue;
+                }
+                const p1 = posInfos[indexesToCheck[i]].pos.p;
+                const p2 = posInfos[indexesToCheck[j]].pos.p;
+                // Below checks for source point too - similar to 
+                // isAnotherCpCloseBy
+                const p3 = p_;
+                if ((Math.abs(p1[0] - p2[0]) < 1e-6 &&
+                    Math.abs(p1[1] - p2[1]) < 1e-6) ||
+                    (Math.abs(p1[0] - p3[0]) < 1e-6 &&
+                        Math.abs(p1[1] - p3[1]) < 1e-6)) {
+                    indexesToRemove.push(indexesToCheck[i]);
+                }
+            }
+        }
+        for (let i = indexesToRemove.length - 1; i >= 0; i--) {
+            posInfos.splice(indexesToRemove[i], 1);
+        }
+    }
+    return posInfos;
+}
+export { getCloseBoundaryPoints };
 //# sourceMappingURL=get-close-boundary-points.js.map

package/node/mat/closest-boundary-point/get-closest-boundary-point.d.ts

@@ -1,18 +1,18 @@
-import { Curve } from '../../curve.js';
-import { IPointOnShape } from '../../point-on-shape.js';
-import { BezierPiece } from '../bezier-piece.js';
-/**
- * @hidden
- * Returns the closest boundary point to the given point, limited to the given
- * bezier pieces, including the beziers actually checked after culling.
- * @param bezierPieces
- * @param point
- * @param touchedCurve
- * @param t
- * @param extreme
- */
-declare function getClosestBoundaryPoint(bezierPieces: BezierPiece[], point: number[], touchedCurve: Curve, t: number): {
-    pos: IPointOnShape;
-    d: number;
-};
-export { getClosestBoundaryPoint };
+import { Curve } from '../../curve.js';
+import { IPointOnShape } from '../../point-on-shape.js';
+import { BezierPiece } from '../bezier-piece.js';
+/**
+ * @hidden
+ * Returns the closest boundary point to the given point, limited to the given
+ * bezier pieces, including the beziers actually checked after culling.
+ * @param bezierPieces
+ * @param point
+ * @param touchedCurve
+ * @param t
+ * @param extreme
+ */
+declare function getClosestBoundaryPoint(bezierPieces: BezierPiece[], point: number[], touchedCurve: Curve, t: number): {
+    pos: IPointOnShape;
+    d: number;
+};
+export { getClosestBoundaryPoint };

package/node/mat/closest-boundary-point/get-closest-boundary-point.js

@@ -1,41 +1,41 @@
-import { distanceBetween, getObjClosestTo } from 'flo-vector2d';
-import { PointOnShape } from '../../point-on-shape.js';
-import { cullBezierPieces } from './cull-bezier-pieces.js';
-import { closestPointsOnCurve } from './closest-points-on-curve.js';
-/**
- * @hidden
- * Returns the closest boundary point to the given point, limited to the given
- * bezier pieces, including the beziers actually checked after culling.
- * @param bezierPieces
- * @param point
- * @param touchedCurve
- * @param t
- * @param extreme
- */
-function getClosestBoundaryPoint(bezierPieces, point, touchedCurve, t) {
-    bezierPieces = cullBezierPieces(bezierPieces, point);
-    let bestDistance = Number.POSITIVE_INFINITY;
-    let posInfo;
-    for (let i = 0; i < bezierPieces.length; i++) {
-        const bezierPiece = bezierPieces[i];
-        const ps = closestPointsOnCurve(bezierPiece.curve, point, bezierPiece.ts, touchedCurve, t);
-        const p = getObjClosestTo(point, ps, p => p.p);
-        if (p === undefined) {
-            continue;
-        }
-        const d = distanceBetween(p.p, point);
-        let curve = bezierPiece.curve;
-        let t_ = p.t;
-        if (d < bestDistance) {
-            if (t_ === 0) {
-                t_ = 1;
-                curve = bezierPiece.curve.prev;
-            }
-            posInfo = { pos: new PointOnShape(curve, t_), d };
-            bestDistance = d;
-        }
-    }
-    return posInfo;
-}
-export { getClosestBoundaryPoint };
+import { distanceBetween, getObjClosestTo } from 'flo-vector2d';
+import { PointOnShape } from '../../point-on-shape.js';
+import { cullBezierPieces } from './cull-bezier-pieces.js';
+import { closestPointsOnCurve } from './closest-points-on-curve.js';
+/**
+ * @hidden
+ * Returns the closest boundary point to the given point, limited to the given
+ * bezier pieces, including the beziers actually checked after culling.
+ * @param bezierPieces
+ * @param point
+ * @param touchedCurve
+ * @param t
+ * @param extreme
+ */
+function getClosestBoundaryPoint(bezierPieces, point, touchedCurve, t) {
+    bezierPieces = cullBezierPieces(bezierPieces, point);
+    let bestDistance = Number.POSITIVE_INFINITY;
+    let posInfo;
+    for (let i = 0; i < bezierPieces.length; i++) {
+        const bezierPiece = bezierPieces[i];
+        const ps = closestPointsOnCurve(bezierPiece.curve, point, bezierPiece.ts, touchedCurve, t);
+        const p = getObjClosestTo(point, ps, p => p.p);
+        if (p === undefined) {
+            continue;
+        }
+        const d = distanceBetween(p.p, point);
+        let curve = bezierPiece.curve;
+        let t_ = p.t;
+        if (d < bestDistance) {
+            if (t_ === 0) {
+                t_ = 1;
+                curve = bezierPiece.curve.prev;
+            }
+            posInfo = { pos: new PointOnShape(curve, t_), d };
+            bestDistance = d;
+        }
+    }
+    return posInfo;
+}
+export { getClosestBoundaryPoint };
 //# sourceMappingURL=get-closest-boundary-point.js.map

package/node/mat/corner.d.ts

@@ -1,37 +1,37 @@
-/**
- * @hidden
- * Represents a corner on the shape boundary, i.e. a point where two bezier
- * curves meet. Typically used internally only.
- */
-interface Corner {
-    /**
-     * The unit tangents at the points t === 1 of the first curve and at
-     * t === 0 of the second respectively.
-     */
-    tangents: number[][];
-    /** The cross of the unit tangents. */
-    crossTangents: number;
-    /**
-     * True if the corner is sharp, i.e. > 0 radians as one goes in a positive
-     * direction around the shape boundary.
-     */
-    isSharp: boolean;
-    /**
-     * True if the corner is dull, i.e. < 0 radians as one goes in a positive
-     * direction around the shape boundary.
-     */
-    isDull: boolean;
-    /**
-     * True if the corner is quite sharp, i.e. > δ radians as one goes in a
-     * positive direction around the shape boundary where δ is some
-     * pre-determined parameter.
-     */
-    isQuiteSharp: boolean;
-    /**
-     * True if the corner is quite dull, i.e. < δ radians as one goes in a
-     * positive direction around the shape boundary where δ is some
-     * pre-determined parameter.
-     */
-    isQuiteDull: boolean;
-}
-export { Corner };
+/**
+ * @hidden
+ * Represents a corner on the shape boundary, i.e. a point where two bezier
+ * curves meet. Typically used internally only.
+ */
+interface Corner {
+    /**
+     * The unit tangents at the points t === 1 of the first curve and at
+     * t === 0 of the second respectively.
+     */
+    tangents: number[][];
+    /** The cross of the unit tangents. */
+    crossTangents: number;
+    /**
+     * True if the corner is sharp, i.e. > 0 radians as one goes in a positive
+     * direction around the shape boundary.
+     */
+    isSharp: boolean;
+    /**
+     * True if the corner is dull, i.e. < 0 radians as one goes in a positive
+     * direction around the shape boundary.
+     */
+    isDull: boolean;
+    /**
+     * True if the corner is quite sharp, i.e. > δ radians as one goes in a
+     * positive direction around the shape boundary where δ is some
+     * pre-determined parameter.
+     */
+    isQuiteSharp: boolean;
+    /**
+     * True if the corner is quite dull, i.e. < δ radians as one goes in a
+     * positive direction around the shape boundary where δ is some
+     * pre-determined parameter.
+     */
+    isQuiteDull: boolean;
+}
+export { Corner };

package/node/mat/corner.js

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

package/node/mat/create-new-cp-tree.d.ts

@@ -1,9 +1,9 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { CpNode } from '../cp-node.js';
-import { Loop } from '../loop.js';
-/**
- * @hidden
- * @param cpNode
- */
-declare function createNewCpTree(cpNode: CpNode): Map<Loop, LlRbTree<CpNode>>;
-export { createNewCpTree };
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { CpNode } from '../cp-node.js';
+import { Loop } from '../loop.js';
+/**
+ * @hidden
+ * @param cpNode
+ */
+declare function createNewCpTree(cpNode: CpNode): Map<Loop, LlRbTree<CpNode>>;
+export { createNewCpTree };

package/node/mat/create-new-cp-tree.js

@@ -1,24 +1,24 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { CpNode } from '../cp-node.js';
-/**
- * @hidden
- * @param cpNode
- */
-function createNewCpTree(cpNode) {
-    const newCpTrees = new Map();
-    const cps = cpNode.getAllOnLoop();
-    cps.forEach(f);
-    function f(cpNode) {
-        const loop = cpNode.cp.pointOnShape.curve.loop;
-        let cpTree = newCpTrees.get(loop);
-        if (!cpTree) {
-            // qqq cpTree = new LlRbTree(CpNode.comparator, [], true); 
-            cpTree = new LlRbTree(CpNode.comparator, false);
-            newCpTrees.set(loop, cpTree);
-        }
-        cpTree.insert(cpNode);
-    }
-    return newCpTrees;
-}
-export { createNewCpTree };
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { CpNode } from '../cp-node.js';
+/**
+ * @hidden
+ * @param cpNode
+ */
+function createNewCpTree(cpNode) {
+    const newCpTrees = new Map();
+    const cps = cpNode.getAllOnLoop();
+    cps.forEach(f);
+    function f(cpNode) {
+        const loop = cpNode.cp.pointOnShape.curve.loop;
+        let cpTree = newCpTrees.get(loop);
+        if (!cpTree) {
+            // qqq cpTree = new LlRbTree(CpNode.comparator, [], true); 
+            cpTree = new LlRbTree(CpNode.comparator, false);
+            newCpTrees.set(loop, cpTree);
+        }
+        cpTree.insert(cpNode);
+    }
+    return newCpTrees;
+}
+export { createNewCpTree };
 //# sourceMappingURL=create-new-cp-tree.js.map

package/node/mat/elem-type-two-prong.d.ts

@@ -1,3 +1,3 @@
-/** @hidden */
-type ElemType_TwoProng = 'twoProng_regular' | 'twoProng_holeClosing';
-export { ElemType_TwoProng };
+/** @hidden */
+type ElemType_TwoProng = 'twoProng_regular' | 'twoProng_holeClosing';
+export { ElemType_TwoProng };

package/node/mat/elem-type-two-prong.js

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=elem-type-two-prong.js.map

package/node/mat/find-mat/add-1-prong.d.ts

@@ -1,12 +1,12 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { Loop } from '../../loop.js';
-import { IPointOnShape } from '../../point-on-shape.js';
-import { CpNode } from '../../cp-node.js';
-/**
- * @hidden
- * Add a 1-prong to the MAT.
- * @param cpGraphs
- * @param pos
- */
-declare function add1Prong(maxOsculatingCircleRadius: number, cpGraphs: Map<Loop, LlRbTree<CpNode>>, pos: IPointOnShape): void;
-export { add1Prong };
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { Loop } from '../../loop.js';
+import { IPointOnShape } from '../../point-on-shape.js';
+import { CpNode } from '../../cp-node.js';
+/**
+ * @hidden
+ * Add a 1-prong to the MAT.
+ * @param cpGraphs
+ * @param pos
+ */
+declare function add1Prong(maxOsculatingCircleRadius: number, cpGraphs: Map<Loop, LlRbTree<CpNode>>, pos: IPointOnShape): void;
+export { add1Prong };

package/node/mat/find-mat/add-1-prong.js

@@ -1,43 +1,43 @@
-import { getOsculatingCircle, calcPosOrder, isPosDullCorner } from '../../point-on-shape.js';
-import { addToCpGraph } from '../add-to-cp-graph.js';
-import { isAnotherCpCloseby } from '../is-another-cp-closeby.js';
-/**
- * @hidden
- * Add a 1-prong to the MAT.
- * @param cpGraphs
- * @param pos
- */
-function add1Prong(maxOsculatingCircleRadius, cpGraphs, pos) {
-    //if (PointOnShape.isDullCorner(pos)) {
-    if (isPosDullCorner(pos)) {
-        // This is a 1-prong at a dull corner.
-        // TODO IMPORTANT 
-        // Remove this line, uncomment piece below it and implement the 
-        // following strategy to find the 3-prongs: if deltas are conjoined due 
-        // to dull corner, split the conjoinment by inserting successively 
-        // closer (binary division) 2-prongs. If a 2-prong actually fails, 
-        // simply remove the 1-prong at the dull corner. In this way **all** 
-        // terminal points are found, e.g. zoom in on top left leg of ant.
-        // Afterthought: there is a better way - split points by two prongs.
-        //toRemove.push(posNode); // this!
-        if (typeof _debug_ !== 'undefined') {
-            _debug_.generated.elems.oneProngAtDullCorner.push(pos);
-        }
-        return;
-    }
-    //let circle = PointOnShape.getOsculatingCircle(maxOsculatingCircleRadius, pos);
-    const circle = getOsculatingCircle(maxOsculatingCircleRadius, 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')) {
-        return;
-    }
-    addToCpGraph(circle, [-0.5, +0.5], cpGraphs, [pos, pos]);
-    if (typeof _debug_ !== 'undefined') {
-        _debug_.generated.elems.oneProng.push(pos);
-    }
-}
-export { add1Prong };
+import { getOsculatingCircle, calcPosOrder, isPosDullCorner } from '../../point-on-shape.js';
+import { addToCpGraph } from '../add-to-cp-graph.js';
+import { isAnotherCpCloseby } from '../is-another-cp-closeby.js';
+/**
+ * @hidden
+ * Add a 1-prong to the MAT.
+ * @param cpGraphs
+ * @param pos
+ */
+function add1Prong(maxOsculatingCircleRadius, cpGraphs, pos) {
+    //if (PointOnShape.isDullCorner(pos)) {
+    if (isPosDullCorner(pos)) {
+        // This is a 1-prong at a dull corner.
+        // TODO IMPORTANT 
+        // Remove this line, uncomment piece below it and implement the 
+        // following strategy to find the 3-prongs: if deltas are conjoined due 
+        // to dull corner, split the conjoinment by inserting successively 
+        // closer (binary division) 2-prongs. If a 2-prong actually fails, 
+        // simply remove the 1-prong at the dull corner. In this way **all** 
+        // terminal points are found, e.g. zoom in on top left leg of ant.
+        // Afterthought: there is a better way - split points by two prongs.
+        //toRemove.push(posNode); // this!
+        if (typeof _debug_ !== 'undefined') {
+            _debug_.generated.elems.oneProngAtDullCorner.push(pos);
+        }
+        return;
+    }
+    //let circle = PointOnShape.getOsculatingCircle(maxOsculatingCircleRadius, pos);
+    const circle = getOsculatingCircle(maxOsculatingCircleRadius, 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')) {
+        return;
+    }
+    addToCpGraph(circle, [-0.5, +0.5], cpGraphs, [pos, pos]);
+    if (typeof _debug_ !== 'undefined') {
+        _debug_.generated.elems.oneProng.push(pos);
+    }
+}
+export { add1Prong };
 //# sourceMappingURL=add-1-prong.js.map

package/node/mat/find-mat/add-2-prong.d.ts

@@ -1,21 +1,21 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { Loop } from '../../loop.js';
-import { CpNode } from '../../cp-node.js';
-import { Circle } from '../../circle.js';
-import { IPointOnShape } from '../../point-on-shape.js';
-/**
- * @hidden
- * Adds a 2-prong contact circle to the shape.
- * @param cpGraphs
- * @param circle Circle containing the 2 contact points
- * @param posSource The source point on shape
- * @param posAntipode The found antipodal point on shape
- * @param holeClosing True if this is a hole-closing 2-prong, false otherwise
- * @param extreme The maximum coordinate value used to calculate floating point
- * tolerances.
- */
-declare function add2Prong(cpGraphs: Map<Loop, LlRbTree<CpNode>>, circle: Circle, posSource: IPointOnShape, posAntipodes: {
-    pos: IPointOnShape;
-    d: number;
-}[], holeClosing: boolean, extreme: number): CpNode;
-export { add2Prong };
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { Loop } from '../../loop.js';
+import { CpNode } from '../../cp-node.js';
+import { Circle } from '../../circle.js';
+import { IPointOnShape } from '../../point-on-shape.js';
+/**
+ * @hidden
+ * Adds a 2-prong contact circle to the shape.
+ * @param cpGraphs
+ * @param circle Circle containing the 2 contact points
+ * @param posSource The source point on shape
+ * @param posAntipode The found antipodal point on shape
+ * @param holeClosing True if this is a hole-closing 2-prong, false otherwise
+ * @param extreme The maximum coordinate value used to calculate floating point
+ * tolerances.
+ */
+declare function add2Prong(cpGraphs: Map<Loop, LlRbTree<CpNode>>, circle: Circle, posSource: IPointOnShape, posAntipodes: {
+    pos: IPointOnShape;
+    d: number;
+}[], holeClosing: boolean, extreme: number): CpNode;
+export { add2Prong };