flo-mat 4.1.5 → 5.0.2

package/node/mat/clone-mat.js

@@ -0,0 +1,17 @@
+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) {
+    const cpNode = clone(mat.cpNode);
+    return {
+        cpNode,
+        meta: cloneMeta(cpNode, mat.meta)
+    };
+}
+export { cloneMat };
+//# sourceMappingURL=clone-mat.js.map

package/node/mat/clone-mat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone-mat.js","sourceRoot":"","sources":["../../src/mat/clone-mat.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAG5C;;;;;GAKG;AACH,SAAS,QAAQ,CACT,GAAQ;IAEZ,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAEjC,OAAO;QACH,MAAM;QACN,IAAI,EAAE,SAAS,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,CAAC;KACpC,CAAA;AACL,CAAC;AAGD,OAAO,EAAE,QAAQ,EAAE,CAAA"}

package/node/mat/clone-meta.d.ts

@@ -0,0 +1,12 @@
+import type { MatMeta } from './mat-meta.js';
+import type { CpNode } from '../cp-node/cp-node.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
+ */
+declare function cloneMeta(cpNode: CpNode, meta: MatMeta): MatMeta;
+export { cloneMeta };

package/node/mat/clone-meta.js

@@ -0,0 +1,24 @@
+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, meta) {
+    const { 
+    // pointToCpNode,
+    lastInsertId, cpTrees, ...rest } = meta;
+    const cpTrees_ = createNewCpTrees(cpNode);
+    const lastInsertId_ = { id: lastInsertId.id };
+    return {
+        cpTrees: cpTrees_,
+        lastInsertId: lastInsertId_,
+        // pointToCpNode,
+        ...rest
+    };
+}
+export { cloneMeta };
+//# sourceMappingURL=clone-meta.js.map

package/node/mat/clone-meta.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone-meta.js","sourceRoot":"","sources":["../../src/mat/clone-meta.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAG5D;;;;;;;GAOG;AACH,SAAS,SAAS,CACV,MAAc,EACd,IAAa;IAEjB,MAAM;IACF,iBAAiB;IACjB,YAAY,EACZ,OAAO,EACP,GAAG,IAAI,EACV,GAAG,IAAI,CAAC;IAET,MAAM,QAAQ,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAC1C,MAAM,aAAa,GAAG,EAAE,EAAE,EAAE,YAAY,CAAC,EAAE,EAAE,CAAC;IAE9C,OAAO;QACH,OAAO,EAAE,QAAQ;QACjB,YAAY,EAAE,aAAa;QAC3B,iBAAiB;QACjB,GAAG,IAAI;KACV,CAAA;AACL,CAAC;AAGD,OAAO,EAAE,SAAS,EAAE,CAAA"}

package/node/mat/get-boundary-piece-beziers.d.ts

@@ -3,6 +3,11 @@ import type { CurvePiece } from './curve-piece.js';
 /**
  * Returns the ordered bezier pieces between the two given `CpNode`s.
  *
+ * * 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
  *

package/node/mat/get-boundary-piece-beziers.js

@@ -2,6 +2,11 @@ import { comparePoss } from '../point-on-shape/compare-poss.js';
 /**
  * Returns the ordered bezier pieces between the two given `CpNode`s.
  *
+ * * 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
  *
@@ -11,12 +16,6 @@ function getBoundaryPieceBeziers(cpNodes) {
     let cpThis = cpNodes[0];
     const cpEnd = cpNodes[1];
     const curvePieces = [];
-    // 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();
     // As opposed to going around the circle and taking the last exit
     let goStraight = true;
     do {
@@ -26,27 +25,6 @@ function getBoundaryPieceBeziers(cpNodes) {
         const curveNext = posNext.curve;
         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;
         }
@@ -72,78 +50,14 @@ function getBoundaryPieceBeziers(cpNodes) {
         // 2. `this` comes after `next` by ordering
         // 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;
 }
 /**

package/node/mat/get-boundary-piece-beziers.js.map

@@ -1 +1 @@
-{"version":3,"file":"get-boundary-piece-beziers.js","sourceRoot":"","sources":["../../src/mat/get-boundary-piece-beziers.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"get-boundary-piece-beziers.js","sourceRoot":"","sources":["../../src/mat/get-boundary-piece-beziers.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AAGhE;;;;;;;;;;;;GAYG;AACH,SAAS,uBAAuB,CACxB,OAAwB;IAE5B,IAAI,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IACxB,MAAM,KAAK,GAAI,OAAO,CAAC,CAAC,CAAC,CAAC;IAE1B,MAAM,WAAW,GAAiB,EAAE,CAAC;IAErC,iEAAiE;IACjE,IAAI,UAAU,GAAG,IAAI,CAAC;IACtB,GAAG,CAAC;QACA,MAAM,OAAO,GAAG,MAAM,CAAM,YAAY,CAAC;QACzC,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC;QACzC,MAAM,SAAS,GAAG,OAAO,CAAC,KAAK,CAAC;QAChC,MAAM,SAAS,GAAG,OAAO,CAAC,KAAK,CAAC;QAEhC,IAAI,CAAC,UAAU,EAAE,CAAC;YACd,UAAU,GAAG,IAAI,CAAC;YAClB,MAAM,GAAG,MAAM,CAAC,YAAY,CAAC,CAAE,iBAAiB;YAChD,SAAS;QACb,CAAC;QAED,UAAU,GAAG,KAAK,CAAC;QAEnB,IAAI,SAAS,KAAK,SAAS;YACvB,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;YAEpC,kEAAkE;YAClE,iEAAiE;YACjE,mEAAmE;YACnE,oEAAoE;YACpE,8DAA8D;YAC9D,kEAAkE;YAClE,iEAAiE;YACjE,mCAAmC;YACnC,WAAW,CAAC,IAAI,CAAC;gBACb,KAAK,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC;aAC/C,CAAC,CAAC;YAEH,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC;YACrB,SAAS;QACb,CAAC;QAED,uDAAuD;QACvD,oDAAoD;QACpD,2CAA2C;QAC3C,qBAAqB;QAErB,IAAI,SAAS,CAAC,IAAI,KAAK,SAAS,CAAC,IAAI,EAAE,CAAC;YACpC,WAAW,CAAC,IAAI,CAAC;gBACb,KAAK,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC;aACvC,CAAC,CAAC;YAEH,qDAAqD;YACrD,iBAAiB,CAAC,WAAW,EAAE,SAAS,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;QACpE,CAAC;QAED,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC;IACzB,CAAC,QAAQ,MAAM,KAAK,KAAK,EAAE;IAE3B,OAAO,WAAW,CAAC;AACvB,CAAC;AAGD;;;GAGG;AACH,SAAS,iBAAiB,CAClB,WAAyB,EACzB,UAAiB,EACjB,QAAe,EACf,EAAU;IAEd,gEAAgE;IAChE,IAAI,SAAS,GAAG,UAAU,CAAC;IAC3B,GAAG,CAAC;QACA,SAAS,GAAG,SAAS,CAAC,IAAI,CAAC;QAC3B,MAAM,IAAI,GAAG,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7C,WAAW,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC;IAC1D,CAAC,QAAQ,SAAS,KAAK,QAAQ,EAAE;AACrC,CAAC;AAGD,OAAO,EAAE,uBAAuB,EAAE,CAAA"}

package/node/mat/get-largest-3-prong.d.ts

@@ -1,3 +1,9 @@
 import type { CpNode } from '../cp-node/cp-node.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
+ */
 declare function getLargest3Prong(cpNode: CpNode): CpNode | undefined;
 export { getLargest3Prong };

package/node/mat/get-largest-3-prong.js

@@ -1,16 +1,19 @@
 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) {
     const cpNodes = getAllOnLoop(cpNode)
         .filter(cpNode => getRealProngCount(cpNode) >= 3);
     if (cpNodes.length === 0) {
         return undefined;
     }
-    return cpNodes.reduce(function (maxCpNode, cpNode) {
-        return maxCpNode.pointOnShape.circle.radius >= cpNode.pointOnShape.circle.radius
-            ? maxCpNode
-            : cpNode;
-    }, cpNodes[0]);
+    return getLargestOf(cpNodes);
 }
 export { getLargest3Prong };
 //# sourceMappingURL=get-largest-3-prong.js.map

package/node/mat/get-largest-3-prong.js.map

@@ -1 +1 @@
-{"version":3,"file":"get-largest-3-prong.js","sourceRoot":"","sources":["../../src/mat/get-largest-3-prong.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAChE,OAAO,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AAG1E,SAAS,gBAAgB,CACjB,MAAc;IAElB,MAAM,OAAO,GAAG,YAAY,CAAC,MAAM,CAAC;SAC/B,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,iBAAiB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;IAEtD,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAAC,OAAO,SAAS,CAAC;IAAC,CAAC;IAE/C,OAAO,OAAO,CAAC,MAAM,CAAC,UAAS,SAAiB,EAAE,MAAc;QAC5D,OAAO,SAAS,CAAC,YAAY,CAAC,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,MAAM;YAC5E,CAAC,CAAC,SAAS;YACX,CAAC,CAAC,MAAM,CAAA;IAChB,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;AACnB,CAAC;AAGD,OAAO,EAAE,gBAAgB,EAAE,CAAA"}
+{"version":3,"file":"get-largest-3-prong.js","sourceRoot":"","sources":["../../src/mat/get-largest-3-prong.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAChE,OAAO,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AAC1E,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAGvD;;;;;GAKG;AACH,SAAS,gBAAgB,CACjB,MAAc;IAElB,MAAM,OAAO,GAAG,YAAY,CAAC,MAAM,CAAC;SAC/B,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,iBAAiB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;IAEtD,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAAC,OAAO,SAAS,CAAC;IAAC,CAAC;IAE/C,OAAO,YAAY,CAAC,OAAO,CAAC,CAAC;AACjC,CAAC;AAGD,OAAO,EAAE,gBAAgB,EAAE,CAAA"}

package/node/mat/get-largest-vertex.d.ts

@@ -1,3 +1,17 @@
 import type { CpNode } from '../cp-node/cp-node.js';
+/**
+ * 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
+ */
+declare function getLargestOf(cpNodes: CpNode[]): CpNode;
+/**
+ * Returns the `CpNode` on the MAT with the largest maximal disk radius.
+ *
+ * @param cpNode any `CpNode` on the MAT
+ */
 declare function getLargestVertex(cpNode: CpNode): CpNode;
-export { getLargestVertex };
+export { getLargestVertex, getLargestOf };

package/node/mat/get-largest-vertex.js

@@ -1,11 +1,24 @@
 import { getAllOnLoop } from '../cp-node/fs/get-all-on-loop.js';
+/**
+ * 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) {
+    return cpNodes.reduce((maxCpNode, cpNode) => maxCpNode.pointOnShape.circle.radius >= cpNode.pointOnShape.circle.radius
+        ? maxCpNode
+        : cpNode);
+}
+/**
+ * Returns the `CpNode` on the MAT with the largest maximal disk radius.
+ *
+ * @param cpNode any `CpNode` on the MAT
+ */
 function getLargestVertex(cpNode) {
-    const cpNodes = getAllOnLoop(cpNode);
-    return cpNodes.reduce(function (maxCpNode, cpNode) {
-        return maxCpNode.pointOnShape.circle.radius >= cpNode.pointOnShape.circle.radius
-            ? maxCpNode
-            : cpNode;
-    }, cpNodes[0]);
+    return getLargestOf(getAllOnLoop(cpNode));
 }
-export { getLargestVertex };
+export { getLargestVertex, getLargestOf };
 //# sourceMappingURL=get-largest-vertex.js.map

package/node/mat/get-largest-vertex.js.map

@@ -1 +1 @@
-{"version":3,"file":"get-largest-vertex.js","sourceRoot":"","sources":["../../src/mat/get-largest-vertex.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAGhE,SAAS,gBAAgB,CACjB,MAAc;IAElB,MAAM,OAAO,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC;IAErC,OAAO,OAAO,CAAC,MAAM,CAAC,UAAS,SAAiB,EAAE,MAAc;QAC5D,OAAO,SAAS,CAAC,YAAY,CAAC,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,MAAM;YAC5E,CAAC,CAAC,SAAS;YACX,CAAC,CAAC,MAAM,CAAA;IAChB,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;AACnB,CAAC;AAGD,OAAO,EAAE,gBAAgB,EAAE,CAAA"}
+{"version":3,"file":"get-largest-vertex.js","sourceRoot":"","sources":["../../src/mat/get-largest-vertex.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAGhE;;;;;;;GAOG;AACH,SAAS,YAAY,CAAC,OAAiB;IACnC,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,CACxC,SAAS,CAAC,YAAY,CAAC,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,MAAM;QACrE,CAAC,CAAC,SAAS;QACX,CAAC,CAAC,MAAM,CACf,CAAC;AACN,CAAC;AAGD;;;;GAIG;AACH,SAAS,gBAAgB,CACjB,MAAc;IAElB,OAAO,YAAY,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC;AAC9C,CAAC;AAGD,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,CAAA"}

package/node/mat/hausdorff-distance-one-sided-exceeds.d.ts

@@ -0,0 +1,79 @@
+/**
+ * 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
+ */
+declare function closestPointOnCurves(p: number[], curves: number[][][]): Foot;
+/**
+ * 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
+ */
+declare function distanceToCurves(p: number[], curves: number[][][]): number;
+/**
+ * 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
+ */
+declare function hausdorffDistanceOneSidedExceeds(A: number[][], B: number[][][], tolerance: number, maxIterations?: number): boolean;
+export { hausdorffDistanceOneSidedExceeds, distanceToCurves, closestPointOnCurves };

package/node/mat/hausdorff-distance-one-sided-exceeds.js

@@ -0,0 +1,251 @@
+import { closestPointOnBezier, controlPointLinesLength, evalDeCasteljau, fromTo } from 'flo-bezier3';
+const { max, sqrt } = Math;
+/**
+ * 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, curves) {
+    let best = { 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, curves) {
+    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, t) {
+    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, curves, k, t0) {
+    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 = { 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, q) {
+    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);
+}
+/**
+ * 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, B, tolerance, maxIterations = 1000) {
+    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 = [{ 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 };
+//# sourceMappingURL=hausdorff-distance-one-sided-exceeds.js.map