flo-mat 2.0.2 → 2.0.3

package/node/point-on-shape.js

@@ -1,168 +1,168 @@
-import { dot, fromTo, toUnitVector, rotateNeg90Degrees } from 'flo-vector2d';
-import { memoize } from 'flo-memoize';
-import { curvature, evalDeCasteljau, tangent } from 'flo-bezier3';
-import { getCornerAtEnd } from './curve.js';
-/**
- * Represents a point on the shape boundary for which MAT vertex information
- * has not *necessarily* been calculated.
- */
-class PointOnShape {
-    /**
-     * @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, t) {
-        this.curve = curve;
-        this.t = t;
-        // Cache
-        this.p_ = undefined;
-    }
-    /**
-     * The planar point coordinates of this [[PointOnShape]].
-     */
-    get p() {
-        return this.p_ === undefined
-            ? this.p_ = evalDeCasteljau(this.curve.ps, this.t)
-            : this.p_;
-    }
-}
-/**
- * @hidden
- */
-function isPosCorner(pos) {
-    return (pos.t === 0 || pos.t === 1);
-}
-/**
- * @hidden
- */
-function getPosCorner(pos) {
-    return getCornerAtEnd(pos.t === 1 ? pos.curve : pos.curve.prev);
-}
-/**
- * @hidden
- */
-const isPosSharpCorner = memoize((pos) => {
-    if (!isPosCorner(pos)) {
-        return false;
-    }
-    return getPosCorner(pos).isSharp;
-});
-/**
- * @hidden
- */
-const isPosDullCorner = memoize((pos) => {
-    if (!isPosCorner(pos)) {
-        return false;
-    }
-    return getPosCorner(pos).isDull;
-});
-/**
- * @hidden
- */
-const isPosQuiteSharpCorner = memoize((pos) => {
-    if (!isPosCorner(pos)) {
-        return false;
-    }
-    return getPosCorner(pos).isQuiteSharp;
-});
-/**
- * @hidden
- */
-const isPosQuiteDullCorner = memoize((pos) => {
-    if (!isPosCorner(pos)) {
-        return false;
-    }
-    return getPosCorner(pos).isQuiteDull;
-});
-/**
- * Returns a human-readable string of the given [[PointOnShape]].
- * For debugging only.
- * @hidden
- */
-function posToHumanString(pos) {
-    return '' + pos.p[0] + ', ' + pos.p[1] +
-        ' | bz: ' + pos.curve.idx +
-        ' | t: ' + pos.t;
-}
-/**
- * @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
- */
-function calcPosOrder(circle, pos) {
-    if (!isPosCorner(pos)) {
-        return 0;
-    }
-    if (!isPosDullCorner(pos)) {
-        return 0;
-    }
-    //if (!isPosDullCorner(pos)) { return 0; }
-    const corner = getPosCorner(pos);
-    const n = rotateNeg90Degrees(corner.tangents[0]);
-    const v = toUnitVector(fromTo(pos.p, circle.center));
-    return -dot(n, v);
-}
-/**
- * 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
- */
-function comparePoss(a, b) {
-    if (a === undefined || b === undefined) {
-        return undefined;
-    }
-    let res;
-    res = a.curve.idx - b.curve.idx;
-    if (res !== 0) {
-        return res;
-    }
-    res = a.t - b.t;
-    return res;
-}
-/**
- * Calculates and returns the osculating circle radius of the bezier at a
- * specific t. If it is found to have negative or nearly zero radius
- * it is clipped to have positive radius so it can point into the shape.
- * @param ps
- * @param t
- * @hidden
- */
-const calcOsculatingCircleRadius = memoize((pos) => {
-    const ps = pos.curve.ps;
-    const t = pos.t;
-    const c = -curvature(ps, t);
-    // c > 0 => bending inwards
-    return 1 / c;
-});
-/**
- * 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.
- */
-function getOsculatingCircle(maxOsculatingCircleRadius, pos) {
-    if (isPosSharpCorner(pos)) {
-        return { center: pos.p, radius: 0 };
-    }
-    let radius = calcOsculatingCircleRadius(pos);
-    if (radius < 0) {
-        radius = Number.POSITIVE_INFINITY;
-    }
-    radius = Math.min(radius, maxOsculatingCircleRadius);
-    const ps = pos.curve.ps;
-    const t = pos.t;
-    const tangent_ = tangent(ps, t);
-    const normal_ = toUnitVector([-tangent_[1], tangent_[0]]);
-    const p = evalDeCasteljau(ps, t);
-    const circleCenter = [
-        p[0] - normal_[0] * radius,
-        p[1] - normal_[1] * radius
-    ];
-    return { center: circleCenter, radius };
-}
-export { PointOnShape, getOsculatingCircle, comparePoss, calcPosOrder, posToHumanString, isPosSharpCorner, isPosDullCorner, isPosQuiteSharpCorner, isPosQuiteDullCorner };
+import { dot, fromTo, toUnitVector, rotateNeg90Degrees } from 'flo-vector2d';
+import { memoize } from 'flo-memoize';
+import { curvature, evalDeCasteljau, tangent } from 'flo-bezier3';
+import { getCornerAtEnd } from './curve.js';
+/**
+ * Represents a point on the shape boundary for which MAT vertex information
+ * has not *necessarily* been calculated.
+ */
+class PointOnShape {
+    /**
+     * @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, t) {
+        this.curve = curve;
+        this.t = t;
+        // Cache
+        this.p_ = undefined;
+    }
+    /**
+     * The planar point coordinates of this [[PointOnShape]].
+     */
+    get p() {
+        return this.p_ === undefined
+            ? this.p_ = evalDeCasteljau(this.curve.ps, this.t)
+            : this.p_;
+    }
+}
+/**
+ * @hidden
+ */
+function isPosCorner(pos) {
+    return (pos.t === 0 || pos.t === 1);
+}
+/**
+ * @hidden
+ */
+function getPosCorner(pos) {
+    return getCornerAtEnd(pos.t === 1 ? pos.curve : pos.curve.prev);
+}
+/**
+ * @hidden
+ */
+const isPosSharpCorner = memoize((pos) => {
+    if (!isPosCorner(pos)) {
+        return false;
+    }
+    return getPosCorner(pos).isSharp;
+});
+/**
+ * @hidden
+ */
+const isPosDullCorner = memoize((pos) => {
+    if (!isPosCorner(pos)) {
+        return false;
+    }
+    return getPosCorner(pos).isDull;
+});
+/**
+ * @hidden
+ */
+const isPosQuiteSharpCorner = memoize((pos) => {
+    if (!isPosCorner(pos)) {
+        return false;
+    }
+    return getPosCorner(pos).isQuiteSharp;
+});
+/**
+ * @hidden
+ */
+const isPosQuiteDullCorner = memoize((pos) => {
+    if (!isPosCorner(pos)) {
+        return false;
+    }
+    return getPosCorner(pos).isQuiteDull;
+});
+/**
+ * Returns a human-readable string of the given [[PointOnShape]].
+ * For debugging only.
+ * @hidden
+ */
+function posToHumanString(pos) {
+    return '' + pos.p[0] + ', ' + pos.p[1] +
+        ' | bz: ' + pos.curve.idx +
+        ' | t: ' + pos.t;
+}
+/**
+ * @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
+ */
+function calcPosOrder(circle, pos) {
+    if (!isPosCorner(pos)) {
+        return 0;
+    }
+    if (!isPosDullCorner(pos)) {
+        return 0;
+    }
+    //if (!isPosDullCorner(pos)) { return 0; }
+    const corner = getPosCorner(pos);
+    const n = rotateNeg90Degrees(corner.tangents[0]);
+    const v = toUnitVector(fromTo(pos.p, circle.center));
+    return -dot(n, v);
+}
+/**
+ * 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
+ */
+function comparePoss(a, b) {
+    if (a === undefined || b === undefined) {
+        return undefined;
+    }
+    let res;
+    res = a.curve.idx - b.curve.idx;
+    if (res !== 0) {
+        return res;
+    }
+    res = a.t - b.t;
+    return res;
+}
+/**
+ * Calculates and returns the osculating circle radius of the bezier at a
+ * specific t. If it is found to have negative or nearly zero radius
+ * it is clipped to have positive radius so it can point into the shape.
+ * @param ps
+ * @param t
+ * @hidden
+ */
+const calcOsculatingCircleRadius = memoize((pos) => {
+    const ps = pos.curve.ps;
+    const t = pos.t;
+    const c = -curvature(ps, t);
+    // c > 0 => bending inwards
+    return 1 / c;
+});
+/**
+ * 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.
+ */
+function getOsculatingCircle(maxOsculatingCircleRadius, pos) {
+    if (isPosSharpCorner(pos)) {
+        return { center: pos.p, radius: 0 };
+    }
+    let radius = calcOsculatingCircleRadius(pos);
+    if (radius < 0) {
+        radius = Number.POSITIVE_INFINITY;
+    }
+    radius = Math.min(radius, maxOsculatingCircleRadius);
+    const ps = pos.curve.ps;
+    const t = pos.t;
+    const tangent_ = tangent(ps, t);
+    const normal_ = toUnitVector([-tangent_[1], tangent_[0]]);
+    const p = evalDeCasteljau(ps, t);
+    const circleCenter = [
+        p[0] - normal_[0] * radius,
+        p[1] - normal_[1] * radius
+    ];
+    return { center: circleCenter, radius };
+}
+export { PointOnShape, getOsculatingCircle, comparePoss, calcPosOrder, posToHumanString, isPosSharpCorner, isPosDullCorner, isPosQuiteSharpCorner, isPosQuiteDullCorner };
 //# sourceMappingURL=point-on-shape.js.map

package/node/simplify-mat.d.ts

@@ -1,16 +1,16 @@
-import { Mat } from './mat.js';
-/**
- * Simplifies the given MAT by replacing the piecewise quad beziers composing
- * the MAT with fewer ones to within a given tolerance.
- * @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.
- * TODO - the next two params are wrong??
- * @param hausdorffTolerance The approximate maximum Hausdorff Distance tolerance -
- * defaults to 0.1
- * @param maxIterations The spacing on the curves used to calculate the Hausdorff
- * Distance - defaults to 1
- */
-declare function simplifyMat(mat: Mat, anlgeTolerance?: number, hausdorffTolerance?: number, maxIterations?: number): Mat;
-export { simplifyMat };
+import { Mat } from './mat.js';
+/**
+ * Simplifies the given MAT by replacing the piecewise quad beziers composing
+ * the MAT with fewer ones to within a given tolerance.
+ * @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.
+ * TODO - the next two params are wrong??
+ * @param hausdorffTolerance The approximate maximum Hausdorff Distance tolerance -
+ * defaults to 0.1
+ * @param maxIterations The spacing on the curves used to calculate the Hausdorff
+ * Distance - defaults to 1
+ */
+declare function simplifyMat(mat: Mat, anlgeTolerance?: number, hausdorffTolerance?: number, maxIterations?: number): Mat;
+export { simplifyMat };

package/node/simplify-mat.js

@@ -1,72 +1,72 @@
-import { hausdorffDistance } from 'flo-bezier3';
-import { CpNode } from './cp-node.js';
-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.
- * @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.
- * TODO - the next two params are wrong??
- * @param hausdorffTolerance The approximate maximum Hausdorff Distance tolerance -
- * defaults to 0.1
- * @param maxIterations The spacing on the curves used to calculate the Hausdorff
- * Distance - defaults to 1
- */
-function simplifyMat(mat, anlgeTolerance = 15, hausdorffTolerance = 2 ** -3, maxIterations = 50) {
-    let cpNode = mat.cpNode;
-    // 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, maxIterations);
-                if (hd > hausdorffTolerance) {
-                    break;
-                }
-                else {
-                    canDeletes.push(branch[j]);
-                }
-            }
-            if (i + 1 === j) {
-                // no simplification occured
-                break;
-            }
-        }
-    }
-    for (const cpNode of canDeletes) {
-        const isTerminating = cpNode.isTerminating();
-        const onCircleCount = cpNode.getCpNodesOnCircle().length;
-        if (isTerminating || onCircleCount !== 2) {
-            continue;
-        }
-        CpNode.remove(cpNode);
-    }
-    //return { cpNode, cpTrees: createNewCpTree(cpNode) }; 
-    return { cpNode, cpTrees: undefined };
-}
-function getTotalHausdorffDistance(i, j, branch, hausdorffSpacing) {
-    const hds = [];
-    const longCurve = getCurveBetween(branch[i], branch[j].next);
-    for (; i < j + 1; i++) {
-        hds.push(hausdorffDistance(getCurveToNext(branch[i]), longCurve, hausdorffSpacing));
-    }
-    return Math.max(...hds);
-}
-export { simplifyMat };
+import { hausdorffDistance } from 'flo-bezier3';
+import { CpNode } from './cp-node.js';
+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.
+ * @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.
+ * TODO - the next two params are wrong??
+ * @param hausdorffTolerance The approximate maximum Hausdorff Distance tolerance -
+ * defaults to 0.1
+ * @param maxIterations The spacing on the curves used to calculate the Hausdorff
+ * Distance - defaults to 1
+ */
+function simplifyMat(mat, anlgeTolerance = 15, hausdorffTolerance = 2 ** -3, maxIterations = 50) {
+    let cpNode = mat.cpNode;
+    // 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, maxIterations);
+                if (hd > hausdorffTolerance) {
+                    break;
+                }
+                else {
+                    canDeletes.push(branch[j]);
+                }
+            }
+            if (i + 1 === j) {
+                // no simplification occured
+                break;
+            }
+        }
+    }
+    for (const cpNode of canDeletes) {
+        const isTerminating = cpNode.isTerminating();
+        const onCircleCount = cpNode.getCpNodesOnCircle().length;
+        if (isTerminating || onCircleCount !== 2) {
+            continue;
+        }
+        CpNode.remove(cpNode);
+    }
+    //return { cpNode, cpTrees: createNewCpTree(cpNode) }; 
+    return { cpNode, cpTrees: undefined };
+}
+function getTotalHausdorffDistance(i, j, branch, hausdorffSpacing) {
+    const hds = [];
+    const longCurve = getCurveBetween(branch[i], branch[j].next);
+    for (; i < j + 1; i++) {
+        hds.push(hausdorffDistance(getCurveToNext(branch[i]), longCurve, hausdorffSpacing));
+    }
+    return Math.max(...hds);
+}
+export { simplifyMat };
 //# sourceMappingURL=simplify-mat.js.map

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

@@ -1,12 +1,12 @@
-import { Loop } from '../loop.js';
-import { IPointOnShape } from '../point-on-shape.js';
-/**
- * @hidden
- */
-declare const getLoopBounds: (a: Loop) => {
-    minX: IPointOnShape;
-    minY: IPointOnShape;
-    maxX: IPointOnShape;
-    maxY: IPointOnShape;
-};
-export { getLoopBounds };
+import { Loop } from '../loop.js';
+import { IPointOnShape } from '../point-on-shape.js';
+/**
+ * @hidden
+ */
+declare const getLoopBounds: (a: Loop) => {
+    minX: IPointOnShape;
+    minY: IPointOnShape;
+    maxX: IPointOnShape;
+    maxY: IPointOnShape;
+};
+export { getLoopBounds };