flo-mat 4.1.5 → 5.0.2

package/src/index.ts

@@ -8,7 +8,7 @@ export type { PointOnShape } from './point-on-shape/point-on-shape.js';
 export type { Circle } from './geometry/circle.js';
 export type { CurvePiece } from './mat/curve-piece.js';
 export type { Timing } from './debug/debug.js';
-export type { Debug } from './debug/debug.js';
+export type { Debug, Elems } from './debug/debug.js';
 export type { MatOptions } from './find-mat/mat-options.js';
 
 export { floydWarshall } from './floyd-warshall/floyd-warshall.js';
@@ -35,7 +35,8 @@ export { getSharpCornersOnLoop } from './find-mat/get-sharp-corners.js';
 export { getFor2ProngsOnLoop } from './find-mat/get-for-2-prongs-on-loop.js';
 export { getPotentialClosestPointsOnCurveCertified } from './closest-boundary-point/get-potential-closest-points-on-curve-certified.js';
 export { getCloseBoundaryPointsCertified } from './closest-boundary-point/get-close-boundary-points-certified.js';
-export { getPartialMeta } from './find-mat/get-meta.js';
+export { cloneMat } from './mat/clone-mat.js';
+export { cloneMeta } from './mat/clone-meta.js';
 export { findAndAddHoleClosing2Prongs } from './find-2-prong/find-and-add-hole-closing-2-prongs.js';
 export { reconstructFromMats } from './reconstruct-from-mat/reconstruct-from-mat.js';
 export { getOsculatingCircle } from './point-on-shape/get-osculating-circle.js';

package/src/mat/clone-mat.ts

@@ -3,14 +3,20 @@ import { clone } from "../cp-node/fs/clone.js";
 import { cloneMeta } from "./clone-meta.js";
 
 
+/**
+ * Returns a deep clone of the given `Mat` (its `CpNode`s are cloned and its
+ * `meta` rebuilt for the clones; the boundary loops are shared).
+ *
+ * @param mat the `Mat` to clone
+ */
 function cloneMat(
         mat: Mat): Mat {
 
-    const { cpNode, meta } = mat;
+    const cpNode = clone(mat.cpNode);
 
     return {
-        cpNode: clone(cpNode),
-        meta: cloneMeta(cpNode, meta)
+        cpNode,
+        meta: cloneMeta(cpNode, mat.meta)
     }
 }
 

package/src/mat/clone-meta.ts

@@ -3,6 +3,14 @@ import type { CpNode } from '../cp-node/cp-node.js';
 import { createNewCpTrees } from './create-new-cp-trees.js';
 
 
+/**
+ * Returns a clone of the given `MatMeta` for the given (already cloned)
+ * `CpNode`, i.e. with `cpTrees` rebuilt from the clone and a fresh
+ * `lastInsertId`.
+ *
+ * @param cpNode the (cloned) `CpNode` the meta is for
+ * @param meta the `MatMeta` to clone
+ */
 function cloneMeta(
         cpNode: CpNode,
         meta: MatMeta): MatMeta {

package/src/mat/get-boundary-piece-beziers.ts

@@ -6,29 +6,27 @@ import { comparePoss } from '../point-on-shape/compare-poss.js';
 
 /**
  * Returns the ordered bezier pieces between the two given `CpNode`s.
- * 
- * @param cpNodes - An ordered pair that represents the start and end points of 
+ *
+ * * NOTE: an earlier version 'stitched' pieces together at hole closers and
+ * loop endpoints to avoid duplicate antipodal points later; this was removed
+ * (duplicates are now checked for in `find2Prong`) - see the git history
+ * before 2026-10 for that code.
+ *
+ * @param cpNodes - An ordered pair that represents the start and end points of
  * the boundary piece
- * 
+ *
  * @internal
  */
 function getBoundaryPieceBeziers(
         cpNodes: [CpNode,CpNode]): CurvePiece[] {
 
-    let cpThis = cpNodes[0]; 
+    let cpThis = cpNodes[0];
     const cpEnd  = cpNodes[1];
-    
-    const curvePieces: CurvePiece[] = [];
 
-    // NOTE❗ Currently removed stichables; we're just checking for duplicates
-    // later in `find2Prong`; KEEP for possible future use.
-    // We have to stich curves together if they're at a hole closer or at the
-    // endpoints of a loop to avoid duplicates later within the code; the map
-    // is from curves
-    // const stichables: Map<Curve, number[]> = new Map();
+    const curvePieces: CurvePiece[] = [];
 
     // As opposed to going around the circle and taking the last exit
-    let goStraight = true; 
+    let goStraight = true;
     do {
         const posThis = cpThis     .pointOnShape;
         const posNext = cpThis.next.pointOnShape;
@@ -37,31 +35,6 @@ function getBoundaryPieceBeziers(
 
         if (!goStraight) {
             goStraight = true;
-            // NOTE❗ Currently removed stichables; we're just checking for duplicates
-            // later in `find2Prong`; KEEP for possible future use.
-            // const { loop: loopThis } = curveThis;
-            // const cpPrevOnCircle = cpThis.prevOnCircle;
-            // const curvePrevOnCircle = cpPrevOnCircle.pointOnShape.curve;
-            // const { loop: loopNext } = cpPrevOnCircle.pointOnShape.curve;
-            
-
-            // if (loopThis !== loopNext) {
-            //     let idxsThis = stichables.get(curveThis);
-            //     if (idxsThis === undefined) {
-            //         idxsThis = [];
-            //         stichables.set(curveThis, idxsThis);
-            //     }
-            //     idxsThis.push(curvePieces.length - 1);  // last `CurvePiece` idx
-
-            //     let idxsNext = stichables.get(curvePrevOnCircle);
-            //     if (idxsNext === undefined) {
-            //         idxsNext = [];
-            //         stichables.set(curvePrevOnCircle, idxsNext);
-            //     }
-            //     idxsNext.push(curvePieces.length);  // upcoming `CurvePiece` idx
-            // }
-
-            // cpThis = cpPrevOnCircle;  // take last exit
             cpThis = cpThis.prevOnCircle;  // take last exit
             continue;
         }
@@ -93,91 +66,17 @@ function getBoundaryPieceBeziers(
         // so split at t = 1.
 
         if (curveThis.loop === curveNext.loop) {
-            const initialCurvePiece = {
+            curvePieces.push({
                 curve: curveThis, ts: [posThis.t, 1]
-            };
-            curvePieces.push(initialCurvePiece);
+            });
 
             // Fill in any curves skipped between the two points.
             addSkippedBeziers(curvePieces, curveThis, curveNext, posNext.t);
-
-            // NOTE❗ Currently removed stichables; we're just checking for duplicates
-            // later in `find2Prong`; KEEP for possible future use.
-            // const finalCurvePiece = curvePieces[curvePieces.length - 1];
-            // if (initialCurvePiece.curve === finalCurvePiece!.curve) {
-            //     const { ts: tsS } = initialCurvePiece;
-            //     const { ts: tsE } = finalCurvePiece!;
-
-            //     // If it is a closed loop we must join the endpoints to prevent duplicate
-            //     // antipodal points later
-            //     if (tsS[0] === tsE[1]) {
-            //         initialCurvePiece.ts[0] = tsE[0];
-
-            //         if (curvePieces.length > 1) {
-            //             curvePieces.pop();
-            //         }
-            //         // console.log('was inner closed loop')
-            //     }
-            // }
         }
 
         cpThis = cpThis.next;
     } while (cpThis !== cpEnd);
 
-    // NOTE❗ Currently removed stichables; we're just checking for duplicates
-    // later in `find2Prong`; KEEP for possible future use.
-    // if (stichables.size > 0) {
-    //     for (const [loop,idxs] of stichables.entries()) {
-    //         if (idxs.length === 2) {
-    //             const curvePieceS = curvePieces[idxs[0]]!;
-    //             const curvePieceE = curvePieces[idxs[1]]!;
-
-    //             if (curvePieceS === undefined || curvePieceE === undefined) {
-    //                 console.log(curvePieceS);
-    //                 console.log(curvePieceE);
-    //                 continue;
-    //             }
-
-    //             const { curve: curveS, ts: tsS } = curvePieceS;
-    //             const { curve: curveE, ts: tsE } = curvePieceE;
-    //             if (curveS !== curveE) {
-    //                 continue;
-    //             }
-
-    //             // If it is a closed loop we must join the endpoints to prevent duplicate
-    //             // antipodal points later
-    //             if (tsS[0] === tsE[1]) {
-    //                 curvePieceS.ts[0] = tsE[0];
-    //                 // console.log('was closed loop 1')
-    //             } else if (tsE[0] === tsS[1]) {
-    //                 curvePieceS.ts[1] = tsE[1];
-    //                 // console.log('was closed loop 2')
-    //             }
-    //             if (idxs[0] !== idxs[1]) {
-    //                 curvePieces[idxs[1]] = undefined;
-    //             }
-    //         }
-    //     }
-    // }
-
-    // NOTE❗ The below endcurve check is not enough for specific cases involving
-    // multiple hole closers; KEEP for now but must use stichables instead
-    // if (curvePieces[0]!.curve === curvePieces[curvePieces.length - 1]!.curve) {
-    //     const { ts: tsS } = curvePieces[0]!;
-    //     const { ts: tsE } = curvePieces[curvePieces.length - 1]!;
-
-    //     // If it is a closed loop we must join the endpoints to prevent duplicate
-    //     // antipodal points later
-    //     if (tsS[0] === tsE[1]) {
-    //         curvePieces[0]!.ts[0] = tsE[0];
-
-    //         if (curvePieces.length > 1) {
-    //             curvePieces.pop();
-    //         }
-    //         // console.log('was closed loop')
-    //     }
-    // }
-
     return curvePieces;
 }
 
@@ -187,9 +86,9 @@ function getBoundaryPieceBeziers(
  * Adds pieces of skipped beziers
  */
 function addSkippedBeziers(
-        curvePieces: (CurvePiece | undefined)[], 
-        curveStart: Curve, 
-        curveEnd: Curve, 
+        curvePieces: CurvePiece[],
+        curveStart: Curve,
+        curveEnd: Curve,
         t1: number) {
 
     // Walk forward through the loop until the end curve is reached.

package/src/mat/get-largest-3-prong.ts

@@ -1,21 +1,24 @@
 import type { CpNode } from '../cp-node/cp-node.js';
 import { getAllOnLoop } from '../cp-node/fs/get-all-on-loop.js';
 import { getRealProngCount } from '../cp-node/fs/get-real-prong-count.js';
+import { getLargestOf } from './get-largest-vertex.js';
 
 
+/**
+ * Returns the `CpNode` on a 3-prong (or higher) MAT vertex with the largest
+ * maximal disk radius, or `undefined` if there is none.
+ *
+ * @param cpNode any `CpNode` on the MAT
+ */
 function getLargest3Prong(
-        cpNode: CpNode) {
+        cpNode: CpNode): CpNode | undefined {
 
     const cpNodes = getAllOnLoop(cpNode)
         .filter(cpNode => getRealProngCount(cpNode) >= 3);
 
     if (cpNodes.length === 0) { return undefined; }
 
-    return cpNodes.reduce(function(maxCpNode: CpNode, cpNode: CpNode) {
-        return maxCpNode.pointOnShape.circle.radius >= cpNode.pointOnShape.circle.radius
-            ? maxCpNode
-            : cpNode
-    }, cpNodes[0]);
+    return getLargestOf(cpNodes);
 }
 
 

package/src/mat/get-largest-vertex.ts

@@ -2,17 +2,33 @@ import type { CpNode } from '../cp-node/cp-node.js';
 import { getAllOnLoop } from '../cp-node/fs/get-all-on-loop.js';
 
 
-function getLargestVertex(
-        cpNode: CpNode) {
-
-    const cpNodes = getAllOnLoop(cpNode);
-
-    return cpNodes.reduce(function(maxCpNode: CpNode, cpNode: CpNode) {
-        return maxCpNode.pointOnShape.circle.radius >= cpNode.pointOnShape.circle.radius
+/**
+ * Returns the `CpNode` (of the given ones) with the largest maximal disk
+ * radius (the first one in case of a tie).
+ *
+ * @param cpNodes a non-empty array of `CpNode`s
+ *
+ * @internal
+ */
+function getLargestOf(cpNodes: CpNode[]): CpNode {
+    return cpNodes.reduce((maxCpNode, cpNode) =>
+        maxCpNode.pointOnShape.circle.radius >= cpNode.pointOnShape.circle.radius
             ? maxCpNode
             : cpNode
-    }, cpNodes[0]);
+    );
+}
+
+
+/**
+ * Returns the `CpNode` on the MAT with the largest maximal disk radius.
+ *
+ * @param cpNode any `CpNode` on the MAT
+ */
+function getLargestVertex(
+        cpNode: CpNode): CpNode {
+
+    return getLargestOf(getAllOnLoop(cpNode));
 }
 
 
-export { getLargestVertex }
+export { getLargestVertex, getLargestOf }

package/src/mat/hausdorff-distance-one-sided-exceeds.ts

@@ -0,0 +1,314 @@
+import { closestPointOnBezier, controlPointLinesLength, evalDeCasteljau, fromTo } from 'flo-bezier3';
+
+const { max, sqrt } = Math;
+
+
+/**
+ * A point `q` on a piecewise bezier curve at parameter `t` of piece `k`
+ * together with its distance `d` to some other point.
+ *
+ * @internal
+ */
+interface Foot {
+    d: number;
+    q: number[];
+    k: number;
+    t: number;
+}
+
+
+/**
+ * Returns the closest point on the piecewise bezier curve given by `curves`
+ * to the point `p` (as a `Foot`), i.e. the piece-wise minimum of the
+ * (certified) `closestPointOnBezier` of `flo-bezier3`.
+ *
+ * @param p the point
+ * @param curves the pieces of the piecewise bezier curve
+ *
+ * @internal
+ */
+function closestPointOnCurves(
+        p: number[],
+        curves: number[][][]): Foot {
+
+    let best: Foot = { d: Infinity, q: p, k: 0, t: 0 };
+    for (let k=0; k<curves.length; k++) {
+        const c = closestPointOnBezier(curves[k], p);
+        if (c.d < best.d) {
+            best = { d: c.d, q: c.p, k, t: c.t };
+        }
+    }
+
+    return best;
+}
+
+
+/**
+ * Returns the distance from the point `p` to the piecewise bezier curve given
+ * by `curves` (i.e. the minimum over the pieces of the distance to the piece).
+ *
+ * @param p the point
+ * @param curves the pieces of the piecewise bezier curve
+ *
+ * @internal
+ */
+function distanceToCurves(
+        p: number[],
+        curves: number[][][]): number {
+
+    return closestPointOnCurves(p, curves).d;
+}
+
+
+/**
+ * Evaluates the bezier curve `ps` (of order 1, 2 or 3) and its first two
+ * derivatives at `t`, returned as `[B, B', B'']`.
+ *
+ * @internal
+ */
+function evalWithDerivatives(
+        ps: number[][],
+        t: number): [number[], number[], number[]] {
+
+    const [p0, p1] = ps;
+
+    if (ps.length === 2) {
+        return [
+            [p0[0] + t*(p1[0] - p0[0]), p0[1] + t*(p1[1] - p0[1])],
+            [p1[0] - p0[0], p1[1] - p0[1]],
+            [0, 0]
+        ];
+    }
+
+    const s = 1 - t;
+
+    if (ps.length === 3) {
+        const p2 = ps[2];
+        return [
+            [s*s*p0[0] + 2*s*t*p1[0] + t*t*p2[0],
+             s*s*p0[1] + 2*s*t*p1[1] + t*t*p2[1]],
+            [2*(s*(p1[0] - p0[0]) + t*(p2[0] - p1[0])),
+             2*(s*(p1[1] - p0[1]) + t*(p2[1] - p1[1]))],
+            [2*(p2[0] - 2*p1[0] + p0[0]),
+             2*(p2[1] - 2*p1[1] + p0[1])]
+        ];
+    }
+
+    const p2 = ps[2];
+    const p3 = ps[3];
+    return [
+        [s*s*s*p0[0] + 3*s*s*t*p1[0] + 3*s*t*t*p2[0] + t*t*t*p3[0],
+         s*s*s*p0[1] + 3*s*s*t*p1[1] + 3*s*t*t*p2[1] + t*t*t*p3[1]],
+        [3*(s*s*(p1[0] - p0[0]) + 2*s*t*(p2[0] - p1[0]) + t*t*(p3[0] - p2[0])),
+         3*(s*s*(p1[1] - p0[1]) + 2*s*t*(p2[1] - p1[1]) + t*t*(p3[1] - p2[1]))],
+        [6*(s*(p2[0] - 2*p1[0] + p0[0]) + t*(p3[0] - 2*p2[0] + p1[0])),
+         6*(s*(p2[1] - 2*p1[1] + p0[1]) + t*(p3[1] - 2*p2[1] + p1[1]))]
+    ];
+}
+
+
+/**
+ * Returns a point on piece `k` of `curves` close to `p` found by a few Newton
+ * iterations on the squared distance starting from parameter `t0`, as a
+ * `Foot`.
+ *
+ * * the returned distance is thus an *upper bound* on the distance from `p`
+ * to the piecewise curve (any point on the curve gives one) - it is not
+ * certified to be the minimum
+ *
+ * @internal
+ */
+function newtonFoot(
+        p: number[],
+        curves: number[][][],
+        k: number,
+        t0: number): Foot {
+
+    const ps = curves[k];
+    if (ps.length === 1) {
+        const q = ps[0];
+        return { d: sqrt((q[0] - p[0])**2 + (q[1] - p[1])**2), q, k, t: 0 };
+    }
+
+    let t = t0;
+    let [q, dq, ddq] = evalWithDerivatives(ps, t);
+    let rx = q[0] - p[0];
+    let ry = q[1] - p[1];
+    let best: Foot = { d: sqrt(rx*rx + ry*ry), q, k, t };
+
+    for (let i=0; i<4; i++) {
+        // minimize g(t) = |B(t) - p|²/2: g' = r·B', g'' = B'·B' + r·B''
+        const g1 = rx*dq[0] + ry*dq[1];
+        const g2 = dq[0]*dq[0] + dq[1]*dq[1] + rx*ddq[0] + ry*ddq[1];
+        if (g2 <= 0) { break; }
+
+        let t_ = t - g1/g2;
+        if (t_ < 0) { t_ = 0; } else if (t_ > 1) { t_ = 1; }
+        if (t_ === t) { break; }
+        t = t_;
+
+        [q, dq, ddq] = evalWithDerivatives(ps, t);
+        rx = q[0] - p[0];
+        ry = q[1] - p[1];
+        const d = sqrt(rx*rx + ry*ry);
+        if (d < best.d) { best = { d, q, k, t }; }
+    }
+
+    return best;
+}
+
+
+/**
+ * Returns the maximum distance from the point `q` to the control points of
+ * `ps` - an upper bound on the distance from `q` to any point on the bezier
+ * curve `ps` (which lies within the convex hull of its control points).
+ *
+ * @internal
+ */
+function maxDistanceToControlPoints(
+        ps: number[][],
+        q: number[]): number {
+
+    let m = 0;
+    for (let i=0; i<ps.length; i++) {
+        const c = ps[i];
+        const dd = (c[0] - q[0])**2 + (c[1] - q[1])**2;
+        if (dd > m) { m = dd; }
+    }
+
+    return sqrt(m);
+}
+
+
+/**
+ * An interval `[tS,tE]` of the parameter of the 'from' curve together with
+ * the feet (on the 'to' curve) of its endpoints.
+ *
+ * @internal
+ */
+interface Interval {
+    tS: number;
+    tE: number;
+    fS: Foot;
+    fE: Foot;
+}
+
+
+/**
+ * Returns `true` if the one-sided Hausdorff distance from the bezier curve `A`
+ * to the piecewise bezier curve `B` exceeds `tolerance` and `false` otherwise.
+ *
+ * * this is a *decision procedure* and is thus much cheaper than computing the
+ * distance (e.g. via `hausdorffDistanceOneSided` from `flo-bezier3`) and then
+ * comparing it: it stops as soon as either a point on `A` further than
+ * `tolerance` from `B` is found (a certified *lower* bound exceeding the
+ * tolerance) or every piece of `A` is certified to be within `tolerance`
+ * (a certified *upper* bound)
+ * * `A` is bisected into parameter intervals; the upper bound on an interval
+ * `[tS,tE]` is the smaller of
+ *     * `(hS + hE + L)/2` where `hS`, `hE` are (upper bounds on) the
+ *       distances from its endpoints to `B` and `L` is the control polygon
+ *       length of `A` restricted to the interval (an upper bound on its arc
+ *       length): any point on the interval is within `L` of both endpoints so
+ *       its distance to `B` is at most `min(hS + l, hE + (L - l))` with `l`
+ *       the arc length from the start, maximized at `(hS + hE + L)/2`
+ *     * the maximum distance from the foot (on `B`) of either endpoint to the
+ *       control points of `A` restricted to the interval (the sub-curve lies
+ *       within the convex hull of its control points, within which the
+ *       distance to a fixed point is maximized at a vertex)
+ * * the distances from sample points on `A` to `B` are found cheaply by
+ * Newton iteration from the feet of the neighboring samples - these are upper
+ * bounds (any point on `B` gives one) which suffice for certifying the
+ * acceptance of an interval; only when such a bound exceeds the tolerance is
+ * the certified (and expensive) closest point computed to decide whether the
+ * tolerance is really exceeded
+ * * `B` need not be smooth, nor need its pieces be connected
+ * * the result is approximate only to the extent that the floating point
+ * evaluations are, i.e. a decision is only taken once it is certain up to
+ * roundoff
+ *
+ * @param A the 'from' bezier curve given by its control points
+ * @param B the 'to' piecewise bezier curve given as an array of bezier curves
+ * @param tolerance the distance to compare against
+ * @param maxIterations the maximum number of interval bisections (each
+ * costing one cheap closest point calculation) before giving up, in which
+ * case `true` is returned (the conservative answer for simplification
+ * purposes); defaults to `1000` (curves only just within tolerance may
+ * need many bisections, especially where they run nearly parallel to `B`)
+ *
+ * @internal
+ */
+function hausdorffDistanceOneSidedExceeds(
+        A: number[][],
+        B: number[][][],
+        tolerance: number,
+        maxIterations = 1000): boolean {
+
+    const fS = closestPointOnCurves(A[0], B);
+    if (fS.d > tolerance) { return true; }
+    const fE = closestPointOnCurves(A[A.length - 1], B);
+    if (fE.d > tolerance) { return true; }
+
+    if (A.length <= 2) {
+        // A point or a line: if `B` is a single line (a convex set) the
+        // distance is convex along `A` and thus maximal at an endpoint.
+        if (A.length === 1 || (B.length === 1 && B[0].length <= 2)) {
+            return false;
+        }
+    }
+
+    // Depth first; the stack never holds more than about `2*log2(iterations)`
+    // intervals.
+    const stack: Interval[] = [{ tS: 0, tE: 1, fS, fE }];
+    let iterations = 0;
+    while (stack.length > 0) {
+        const { tS, tE, fS, fE } = stack.pop()!;
+
+        const ps = tS === 0 && tE === 1 ? A : fromTo(A, tS, tE);
+
+        // the entire interval is certified within tolerance if either upper
+        // bound says so
+        if ((fS.d + fE.d + controlPointLinesLength(ps))/2 <= tolerance) {
+            continue;
+        }
+        if (maxDistanceToControlPoints(ps, fS.q) <= tolerance ||
+            maxDistanceToControlPoints(ps, fE.q) <= tolerance) {
+            continue;
+        }
+
+        if (iterations++ >= maxIterations) {
+            return true;  // undecided - be conservative
+        }
+
+        const tM = (tS + tE)/2;
+        const pM = evalDeCasteljau(A, tM);
+
+        // a cheap upper bound on the distance from `pM` to `B` - by Newton
+        // iteration from the feet of the endpoints
+        let fM = newtonFoot(pM, B, fS.k, fS.k === fE.k ? (fS.t + fE.t)/2 : fS.t);
+        if (fS.k !== fE.k) {
+            const fM_ = newtonFoot(pM, B, fE.k, fE.t);
+            if (fM_.d < fM.d) { fM = fM_; }
+        }
+
+        if (fM.d > tolerance) {
+            // possibly exceeds - now get the certified closest point
+            fM = closestPointOnCurves(pM, B);
+            if (fM.d > tolerance) { return true; }
+        }
+
+        // push the half with the larger lower bound last so it is tried first
+        if (max(fS.d, fM.d) >= max(fM.d, fE.d)) {
+            stack.push({ tS: tM, tE, fS: fM, fE });
+            stack.push({ tS, tE: tM, fS, fE: fM });
+        } else {
+            stack.push({ tS, tE: tM, fS, fE: fM });
+            stack.push({ tS: tM, tE, fS: fM, fE });
+        }
+    }
+
+    return false;
+}
+
+
+export { hausdorffDistanceOneSidedExceeds, distanceToCurves, closestPointOnCurves }

package/src/mat/mat-meta.ts

@@ -1,7 +1,5 @@
 import type { Loop } from 'flo-boolean';
 import type { CpNode } from '../cp-node/cp-node.js';
-import type { Curve } from 'flo-boolean';
-import type { TriMap } from '../utils/tri-map.js';
 import { RbTree } from 'flo-ll-rb-tree';
 
 
@@ -9,13 +7,6 @@ interface MatMeta {
     /** The minimum power of 2 such that `2**maxCoordPowerOf2 >= "the max coordinate"` */
     readonly maxCoordPowerOf2: number;
     readonly squaredDiagonalLength: number;
-    readonly looseBoundingBoxes: number[][][];
-    readonly tightBoundingBoxes: number[][][];
-    readonly boundingHulls: number[][][];
-
-    readonly sharpCorners: Curve[];
-    readonly dullCorners: Curve[];
-
     readonly loops: Loop[];
     
     /**