flo-mat 2.0.2 → 2.0.4

package/node/mat/bezier-piece.d.ts

@@ -1,12 +1,12 @@
-import { Curve } from '../curve.js';
-/**
- * @hidden
- * Represents a part of a bezier within the shape boundary.
- */
-interface BezierPiece {
-    /** A bezier curve within the shape boundary. */
-    curve: Curve;
-    /** The start and end t parameter values of the bezier curve. */
-    ts: number[];
-}
-export { BezierPiece };
+import { Curve } from '../curve.js';
+/**
+ * @hidden
+ * Represents a part of a bezier within the shape boundary.
+ */
+interface BezierPiece {
+    /** A bezier curve within the shape boundary. */
+    curve: Curve;
+    /** The start and end t parameter values of the bezier curve. */
+    ts: number[];
+}
+export { BezierPiece };

package/node/mat/bezier-piece.js

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

package/node/mat/closest-boundary-point/closest-points-on-curve.d.ts

@@ -1,14 +1,14 @@
-import { Curve } from "../../curve.js";
-/**
- * @hidden
- * @param curve The curve
- * @param p The point from which to check
- * @param tRange The allowed t range
- * @param touchedCurve The bezier on which p is located
- * @param t The t value of the bezier that locates p
- */
-declare function closestPointsOnCurve(curve: Curve, p: number[], [tS, tE]: number[], touchedCurve: Curve, t: number): {
-    p: number[];
-    t: number;
-}[];
-export { closestPointsOnCurve };
+import { Curve } from "../../curve.js";
+/**
+ * @hidden
+ * @param curve The curve
+ * @param p The point from which to check
+ * @param tRange The allowed t range
+ * @param touchedCurve The bezier on which p is located
+ * @param t The t value of the bezier that locates p
+ */
+declare function closestPointsOnCurve(curve: Curve, p: number[], [tS, tE]: number[], touchedCurve: Curve, t: number): {
+    p: number[];
+    t: number;
+}[];
+export { closestPointsOnCurve };

package/node/mat/closest-boundary-point/closest-points-on-curve.js

@@ -1,73 +1,73 @@
-// qqq import { deflateQuad, allRootsMultiWithErrBounds, RootInterval } from 'flo-poly';
-// qqq import { getTangentPolyFromPointExact, evalDeCasteljau, evaluate, getFootpointPolyExact } from 'flo-bezier3';
-import { ddDeflate, allRootsCertified } from 'flo-poly';
-import { evaluate, getFootpointPolyDd } from 'flo-bezier3';
-/**
- * @hidden
- * @param curve The curve
- * @param p The point from which to check
- * @param tRange The allowed t range
- * @param touchedCurve The bezier on which p is located
- * @param t The t value of the bezier that locates p
- */
-function closestPointsOnCurve(curve, p, [tS, tE] = [0, 1], touchedCurve, t) {
-    // qqq let poly = getTangentPolyFromPointExact(curve.ps, p);
-    const _poly = getFootpointPolyDd(curve.ps, p);
-    // qqq poly = deflateQuad(poly, t);
-    const poly = curve === touchedCurve
-        ? ddDeflate(_poly, t)
-        : _poly;
-    // let roots: Omit<RootInterval,'multiplicity'>[] = allRootsMultiWithErrBounds(
-    const roots = allRootsCertified(poly, tS, tE);
-    // Also test the endpoints
-    let push0 = true;
-    let push1 = true;
-    if ((t === 1 && curve === touchedCurve.next) ||
-        (t === 0 && curve === touchedCurve)) {
-        push0 = false;
-    }
-    if ((t === 0 && curve === touchedCurve.prev) ||
-        (t === 1 && curve === touchedCurve)) {
-        push1 = false;
-    }
-    if (tS === 0) {
-        if (push0) {
-            roots.push({ tS: 0, tE: 0 });
-        }
-    }
-    else if (tS === 1) {
-        if (push1) {
-            roots.push({ tS: 1, tE: 1 });
-        }
-    }
-    else {
-        roots.push({ tS: tS, tE: tS });
-    }
-    if (tE === 0) {
-        if (push0) {
-            roots.push({ tS: 0, tE: 0 });
-        }
-    }
-    else if (tE === 1) {
-        if (push1) {
-            roots.push({ tS: 1, tE: 1 });
-        }
-    }
-    else {
-        roots.push({ tS: tE, tE: tE });
-    }
-    const ps = roots.map(root => {
-        const tS = root.tS;
-        const tE = root.tE;
-        // TODO - tS, tE should always stay within [0,1] - modify findRootsMulti
-        const t = tS < 0
-            ? 0
-            : tE > 1 ? 1 : (tS + tE) / 2;
-        // TODO - why does evalDeCasteljau not work here?
-        return { p: evaluate(curve.ps, t), t };
-        //return { p: evalDeCasteljau(curve.ps,t), t }
-    });
-    return ps;
-}
-export { closestPointsOnCurve };
+// qqq import { deflateQuad, allRootsMultiWithErrBounds, RootInterval } from 'flo-poly';
+// qqq import { getTangentPolyFromPointExact, evalDeCasteljau, evaluate, getFootpointPolyExact } from 'flo-bezier3';
+import { ddDeflate, allRootsCertified } from 'flo-poly';
+import { evaluate, getFootpointPolyDd } from 'flo-bezier3';
+/**
+ * @hidden
+ * @param curve The curve
+ * @param p The point from which to check
+ * @param tRange The allowed t range
+ * @param touchedCurve The bezier on which p is located
+ * @param t The t value of the bezier that locates p
+ */
+function closestPointsOnCurve(curve, p, [tS, tE] = [0, 1], touchedCurve, t) {
+    // qqq let poly = getTangentPolyFromPointExact(curve.ps, p);
+    const _poly = getFootpointPolyDd(curve.ps, p);
+    // qqq poly = deflateQuad(poly, t);
+    const poly = curve === touchedCurve
+        ? ddDeflate(_poly, t)
+        : _poly;
+    // let roots: Omit<RootInterval,'multiplicity'>[] = allRootsMultiWithErrBounds(
+    const roots = allRootsCertified(poly, tS, tE);
+    // Also test the endpoints
+    let push0 = true;
+    let push1 = true;
+    if ((t === 1 && curve === touchedCurve.next) ||
+        (t === 0 && curve === touchedCurve)) {
+        push0 = false;
+    }
+    if ((t === 0 && curve === touchedCurve.prev) ||
+        (t === 1 && curve === touchedCurve)) {
+        push1 = false;
+    }
+    if (tS === 0) {
+        if (push0) {
+            roots.push({ tS: 0, tE: 0 });
+        }
+    }
+    else if (tS === 1) {
+        if (push1) {
+            roots.push({ tS: 1, tE: 1 });
+        }
+    }
+    else {
+        roots.push({ tS: tS, tE: tS });
+    }
+    if (tE === 0) {
+        if (push0) {
+            roots.push({ tS: 0, tE: 0 });
+        }
+    }
+    else if (tE === 1) {
+        if (push1) {
+            roots.push({ tS: 1, tE: 1 });
+        }
+    }
+    else {
+        roots.push({ tS: tE, tE: tE });
+    }
+    const ps = roots.map(root => {
+        const tS = root.tS;
+        const tE = root.tE;
+        // TODO - tS, tE should always stay within [0,1] - modify findRootsMulti
+        const t = tS < 0
+            ? 0
+            : tE > 1 ? 1 : (tS + tE) / 2;
+        // TODO - why does evalDeCasteljau not work here?
+        return { p: evaluate(curve.ps, t), t };
+        //return { p: evalDeCasteljau(curve.ps,t), t }
+    });
+    return ps;
+}
+export { closestPointsOnCurve };
 //# sourceMappingURL=closest-points-on-curve.js.map

package/node/mat/closest-boundary-point/cull-bezier-pieces.d.ts

@@ -1,9 +1,9 @@
-import { BezierPiece } from '../bezier-piece.js';
-/**
- * @hidden
- * @param bezierPieces
- * @param p
- * @param extreme
- */
-declare function cullBezierPieces(bezierPieces: BezierPiece[], p: number[]): BezierPiece[];
-export { cullBezierPieces };
+import { BezierPiece } from '../bezier-piece.js';
+/**
+ * @hidden
+ * @param bezierPieces
+ * @param p
+ * @param extreme
+ */
+declare function cullBezierPieces(bezierPieces: BezierPiece[], p: number[]): BezierPiece[];
+export { cullBezierPieces };

package/node/mat/closest-boundary-point/cull-bezier-pieces.js

@@ -1,20 +1,20 @@
-import { getBestDistanceSquared } from './get-best-distance-squared.js';
-import { cullByLooseBoundingBox } from './cull-by-loose-bounding-box.js';
-import { cullByTightBoundingBox } from './cull-by-tight-boundary-box.js';
-/**
- * @hidden
- * @param bezierPieces
- * @param p
- * @param extreme
- */
-function cullBezierPieces(bezierPieces, p) {
-    const CULL_THRESHOLD = 0;
-    if (bezierPieces.length > CULL_THRESHOLD) {
-        const bestSquaredDistance = getBestDistanceSquared(bezierPieces, p);
-        bezierPieces = cullByLooseBoundingBox(bezierPieces, p, bestSquaredDistance);
-        bezierPieces = cullByTightBoundingBox(bezierPieces, p, bestSquaredDistance);
-    }
-    return bezierPieces;
-}
-export { cullBezierPieces };
+import { getBestDistanceSquared } from './get-best-distance-squared.js';
+import { cullByLooseBoundingBox } from './cull-by-loose-bounding-box.js';
+import { cullByTightBoundingBox } from './cull-by-tight-boundary-box.js';
+/**
+ * @hidden
+ * @param bezierPieces
+ * @param p
+ * @param extreme
+ */
+function cullBezierPieces(bezierPieces, p) {
+    const CULL_THRESHOLD = 0;
+    if (bezierPieces.length > CULL_THRESHOLD) {
+        const bestSquaredDistance = getBestDistanceSquared(bezierPieces, p);
+        bezierPieces = cullByLooseBoundingBox(bezierPieces, p, bestSquaredDistance);
+        bezierPieces = cullByTightBoundingBox(bezierPieces, p, bestSquaredDistance);
+    }
+    return bezierPieces;
+}
+export { cullBezierPieces };
 //# sourceMappingURL=cull-bezier-pieces.js.map

package/node/mat/closest-boundary-point/cull-by-loose-bounding-box.d.ts

@@ -1,11 +1,11 @@
-import { BezierPiece } from '../bezier-piece.js';
-/**
- * @hidden
- * When checking distances, ignore all those with closest possible distance
- * further than 'bestSquaredDistance', i.e. cull them.
- * @param bezierPieces
- * @param p
- * @param dSquared
- */
-declare function cullByLooseBoundingBox(bezierPieces: BezierPiece[], p: number[], dSquared: number): BezierPiece[];
-export { cullByLooseBoundingBox };
+import { BezierPiece } from '../bezier-piece.js';
+/**
+ * @hidden
+ * When checking distances, ignore all those with closest possible distance
+ * further than 'bestSquaredDistance', i.e. cull them.
+ * @param bezierPieces
+ * @param p
+ * @param dSquared
+ */
+declare function cullByLooseBoundingBox(bezierPieces: BezierPiece[], p: number[], dSquared: number): BezierPiece[];
+export { cullByLooseBoundingBox };

package/node/mat/closest-boundary-point/cull-by-loose-bounding-box.js

@@ -1,25 +1,25 @@
-import { getBoundingBox_ } from '../../get-bounding-box-.js';
-import { getClosestSquareDistanceToRect } from '../geometry/get-closest-square-distance-to-rect.js';
-/**
- * @hidden
- * When checking distances, ignore all those with closest possible distance
- * further than 'bestSquaredDistance', i.e. cull them.
- * @param bezierPieces
- * @param p
- * @param dSquared
- */
-function cullByLooseBoundingBox(bezierPieces, p, dSquared) {
-    const candidateBezierPieces = [];
-    for (let i = 0; i < bezierPieces.length; i++) {
-        const bezierPiece = bezierPieces[i];
-        const ps = bezierPiece.curve.ps;
-        const boundingBox = getBoundingBox_(ps);
-        const d = getClosestSquareDistanceToRect(boundingBox, p);
-        if (d <= dSquared) {
-            candidateBezierPieces.push(bezierPiece);
-        }
-    }
-    return candidateBezierPieces;
-}
-export { cullByLooseBoundingBox };
+import { getBoundingBox_ } from '../../get-bounding-box-.js';
+import { getClosestSquareDistanceToRect } from '../geometry/get-closest-square-distance-to-rect.js';
+/**
+ * @hidden
+ * When checking distances, ignore all those with closest possible distance
+ * further than 'bestSquaredDistance', i.e. cull them.
+ * @param bezierPieces
+ * @param p
+ * @param dSquared
+ */
+function cullByLooseBoundingBox(bezierPieces, p, dSquared) {
+    const candidateBezierPieces = [];
+    for (let i = 0; i < bezierPieces.length; i++) {
+        const bezierPiece = bezierPieces[i];
+        const ps = bezierPiece.curve.ps;
+        const boundingBox = getBoundingBox_(ps);
+        const d = getClosestSquareDistanceToRect(boundingBox, p);
+        if (d <= dSquared) {
+            candidateBezierPieces.push(bezierPiece);
+        }
+    }
+    return candidateBezierPieces;
+}
+export { cullByLooseBoundingBox };
 //# sourceMappingURL=cull-by-loose-bounding-box.js.map

package/node/mat/closest-boundary-point/cull-by-tight-boundary-box.d.ts

@@ -1,11 +1,11 @@
-import { BezierPiece } from "../bezier-piece.js";
-/**
- * @hidden
- * When checking distances, ignore all those with closest possible distance
- * further than 'bestSquaredDistance', i.e. cull them.
- * @param bezierPieces
- * @param p
- * @param bestSquaredDistance
- */
-declare function cullByTightBoundingBox(bezierPieces: BezierPiece[], p: number[], bestSquaredDistance: number): BezierPiece[];
-export { cullByTightBoundingBox };
+import { BezierPiece } from "../bezier-piece.js";
+/**
+ * @hidden
+ * When checking distances, ignore all those with closest possible distance
+ * further than 'bestSquaredDistance', i.e. cull them.
+ * @param bezierPieces
+ * @param p
+ * @param bestSquaredDistance
+ */
+declare function cullByTightBoundingBox(bezierPieces: BezierPiece[], p: number[], bestSquaredDistance: number): BezierPiece[];
+export { cullByTightBoundingBox };

package/node/mat/closest-boundary-point/cull-by-tight-boundary-box.js

@@ -1,27 +1,27 @@
-import { getBoundingBoxTight } from "flo-bezier3";
-import { memoize } from "flo-memoize";
-import { getClosestSquaredDistanceToRotatedRect } from '../geometry/get-closest-squared-distance-to-rotated-rect.js';
-const getBoundingBoxTight_ = memoize(getBoundingBoxTight);
-/**
- * @hidden
- * When checking distances, ignore all those with closest possible distance
- * further than 'bestSquaredDistance', i.e. cull them.
- * @param bezierPieces
- * @param p
- * @param bestSquaredDistance
- */
-function cullByTightBoundingBox(bezierPieces, p, bestSquaredDistance) {
-    const candidateBezierPieces = [];
-    for (let i = 0; i < bezierPieces.length; i++) {
-        const bezierPiece = bezierPieces[i];
-        const ps = bezierPiece.curve.ps;
-        const tightBoundingBox = getBoundingBoxTight_(ps);
-        const d = getClosestSquaredDistanceToRotatedRect(tightBoundingBox, p);
-        if (d <= bestSquaredDistance) {
-            candidateBezierPieces.push(bezierPiece);
-        }
-    }
-    return candidateBezierPieces;
-}
-export { cullByTightBoundingBox };
+import { getBoundingBoxTight } from "flo-bezier3";
+import { memoize } from "flo-memoize";
+import { getClosestSquaredDistanceToRotatedRect } from '../geometry/get-closest-squared-distance-to-rotated-rect.js';
+const getBoundingBoxTight_ = memoize(getBoundingBoxTight);
+/**
+ * @hidden
+ * When checking distances, ignore all those with closest possible distance
+ * further than 'bestSquaredDistance', i.e. cull them.
+ * @param bezierPieces
+ * @param p
+ * @param bestSquaredDistance
+ */
+function cullByTightBoundingBox(bezierPieces, p, bestSquaredDistance) {
+    const candidateBezierPieces = [];
+    for (let i = 0; i < bezierPieces.length; i++) {
+        const bezierPiece = bezierPieces[i];
+        const ps = bezierPiece.curve.ps;
+        const tightBoundingBox = getBoundingBoxTight_(ps);
+        const d = getClosestSquaredDistanceToRotatedRect(tightBoundingBox, p);
+        if (d <= bestSquaredDistance) {
+            candidateBezierPieces.push(bezierPiece);
+        }
+    }
+    return candidateBezierPieces;
+}
+export { cullByTightBoundingBox };
 //# sourceMappingURL=cull-by-tight-boundary-box.js.map

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

@@ -1,8 +1,8 @@
-import { BezierPiece } from "../bezier-piece.js";
-/**
- * @hidden
- * Finds an initial distance such that the closest point can not be further than
- * this distance away.
- */
-declare function getBestDistanceSquared(bezierPieces: BezierPiece[], p: number[]): number;
-export { getBestDistanceSquared };
+import { BezierPiece } from "../bezier-piece.js";
+/**
+ * @hidden
+ * Finds an initial distance such that the closest point can not be further than
+ * this distance away.
+ */
+declare function getBestDistanceSquared(bezierPieces: BezierPiece[], p: number[]): number;
+export { getBestDistanceSquared };

package/node/mat/closest-boundary-point/get-best-distance-squared.js

@@ -1,25 +1,25 @@
-import { evalDeCasteljau } from 'flo-bezier3';
-import { squaredDistanceBetween } from 'flo-vector2d';
-/**
- * @hidden
- * Finds an initial distance such that the closest point can not be further than
- * this distance away.
- */
-function getBestDistanceSquared(bezierPieces, p) {
-    let bestSquaredDistance = Number.POSITIVE_INFINITY;
-    for (let i = 0; i < bezierPieces.length; i++) {
-        const bezierPiece = bezierPieces[i];
-        const ps = bezierPiece.curve.ps;
-        const p1 = evalDeCasteljau(ps, bezierPiece.ts[0]);
-        const p2 = evalDeCasteljau(ps, bezierPiece.ts[1]);
-        const d = Math.min(squaredDistanceBetween(p, p1), squaredDistanceBetween(p, p2));
-        if (d < bestSquaredDistance) {
-            bestSquaredDistance = d;
-        }
-    }
-    // The extra multiplier is to account for floating point precision.
-    // TODO - remove delta (or base it on theory)
-    return bestSquaredDistance * 1.01;
-}
-export { getBestDistanceSquared };
+import { evalDeCasteljau } from 'flo-bezier3';
+import { squaredDistanceBetween } from 'flo-vector2d';
+/**
+ * @hidden
+ * Finds an initial distance such that the closest point can not be further than
+ * this distance away.
+ */
+function getBestDistanceSquared(bezierPieces, p) {
+    let bestSquaredDistance = Number.POSITIVE_INFINITY;
+    for (let i = 0; i < bezierPieces.length; i++) {
+        const bezierPiece = bezierPieces[i];
+        const ps = bezierPiece.curve.ps;
+        const p1 = evalDeCasteljau(ps, bezierPiece.ts[0]);
+        const p2 = evalDeCasteljau(ps, bezierPiece.ts[1]);
+        const d = Math.min(squaredDistanceBetween(p, p1), squaredDistanceBetween(p, p2));
+        if (d < bestSquaredDistance) {
+            bestSquaredDistance = d;
+        }
+    }
+    // The extra multiplier is to account for floating point precision.
+    // TODO - remove delta (or base it on theory)
+    return bestSquaredDistance * 1.01;
+}
+export { getBestDistanceSquared };
 //# sourceMappingURL=get-best-distance-squared.js.map

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

@@ -1,17 +1,17 @@
-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 getCloseBoundaryPoints(bezierPieces: BezierPiece[], point: number[], y: IPointOnShape, distance: number): {
-    pos: IPointOnShape;
-    d: number;
-}[];
-export { getCloseBoundaryPoints };
+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 getCloseBoundaryPoints(bezierPieces: BezierPiece[], point: number[], y: IPointOnShape, distance: number): {
+    pos: IPointOnShape;
+    d: number;
+}[];
+export { getCloseBoundaryPoints };