flo-mat 3.0.15 → 4.0.2

package/src/{find-3-prong.ts → find-3-prong}/find-and-add-3-prongs.ts

@@ -26,14 +26,16 @@ let ii = 0;
  */
 function findAndAdd3Prongs(
         meta: MatMeta,
-        cpStart: CpNode) {
+        cpStart: CpNode): {
+            closeBysFor3Prong: CpNode[] | undefined;
+            addedCpNodes: CpNode[][];
+        } {
 
-    if (isPosSharpCorner(cpStart.cp.pointOnShape)) {
+    if (isPosSharpCorner(cpStart.pointOnShape)) {
         return { closeBysFor3Prong: undefined, addedCpNodes: [] };
     }
 
     const addedCpNodes: CpNode[][] = [];
-    let closeBysFor3Prong: CpNode[] | undefined = undefined;
     do {
         if (cpStart === undefined) { continue; }
         const visitedCps = traverseCp(cpStart);
@@ -54,7 +56,7 @@ function findAndAdd3Prongs(
         }
     } while (true);
 
-    return { closeBysFor3Prong, addedCpNodes };
+    return { closeBysFor3Prong: undefined, addedCpNodes };
 }
 
 

package/src/{find-3-prong.ts → find-3-prong}/get-closest-points.ts

@@ -1,12 +1,13 @@
-import { CurvePiece  } from '../mat/curve-piece.js';
+import type { CurvePiece  } from '../mat/curve-piece.js';
 import { getCloseBoundaryPointsCertified } from '../closest-boundary-point/get-close-boundary-points-certified.js';
 
 
 /**
- * @internal
+ * @param maxCoordPowerOf2
  * @param x 
  * @param curvePiece3s 
- * @param extreme 
+ * 
+ * @internal
  */
 function getClosestPoints(
         x: number[], 
@@ -14,8 +15,8 @@ function getClosestPoints(
 
     return curvePiece3s.map(curvePieces => {
         return getCloseBoundaryPointsCertified(
-            5,  // TODO - see find-2-prong
-            curvePieces, x
+            curvePieces,
+            x
         )[0];
     });
 }

package/src/find-3-prong/three-prong-info.ts

@@ -0,0 +1,13 @@
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { Circle } from '../geometry/circle.js';
+import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
+
+
+interface ThreeProngInfo {
+    readonly circle: Circle;
+    readonly poss: PrePointOnShape[];
+    readonly δ3s: CpNode[][];
+}
+
+
+export type { ThreeProngInfo }

package/src/find-3-prong/timed-cc.ts

@@ -0,0 +1,9 @@
+import { circumCenter } from 'flo-vector2d';
+import { timeFunctionCalls } from '../utils/time-function-call.js';
+
+
+// const timeCircumCenter = timeFunctionCalls(circumCenter);
+const timeCircumCenter = circumCenter;
+
+
+export { timeCircumCenter as circumCenter }

package/src/find-mat/clip-options.ts

@@ -1,34 +1,29 @@
-import { MatOptionMeta, matOptionRanges, MatOptions } from './mat-options.js';
+import type { Mutable } from '../utils/mutable.js';
+import { matOptionRanges, type MatOptions } from './mat-options.js';
 
 
 function clipOptions(
-        maxCoordinate: number,
-        maxRadius: number,
+        maxCoordPowerOf2: number,
         options: Required<MatOptions>): Required<MatOptions> {
 
-    const expMaxCoord = Math.ceil(Math.log2(maxCoordinate));
-    const expMaxRadius = Math.ceil(Math.log2(maxRadius));
     const scaleSigBits = 10;  // 1024 x 1024
 
-    const options_ = { ...options };
+    const options_: Mutable<Required<MatOptions>> = { ...options };
+
     for (const k in matOptionRanges) {
-        // @ts-ignore
-        let o = options_[k];
-        // @ts-ignore
-        const c = matOptionRanges[k] as MatOptionMeta;
-        const { range, scaleByMaxCoordinate, scaleByMaxRadius } = c;
+        const key = k as keyof typeof matOptionRanges;
+        let o = options_[key];
+        const c = matOptionRanges[key];
+        const { range, scaleByMaxCoordinate } = c;
         if (o < range[0]) { o = range[0]; }
         if (o > range[1]) { o = range[1]; }
 
         // Adjust length tolerance according to a reference max coordinate
         if (!!scaleByMaxCoordinate) {
-            o = o * (2**expMaxCoord * 2**(-scaleSigBits));
-        } else if (!!scaleByMaxRadius) {
-            o = o * (2**expMaxRadius * 2**(-scaleSigBits));
+            o *= 2**(maxCoordPowerOf2 - scaleSigBits);
         }
 
-        // @ts-ignore
-        options_[k] = o;
+        options_[key] = o;
     }
 
     return options_;

package/src/find-mat/create-initial-cp-tree.ts

@@ -1,62 +1,57 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { Loop } from 'flo-boolean';
-import { CpNode } from '../cp-node/cp-node.js';
-import { CpNodeFs } from '../cp-node/cp-node-fs.js';
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { ContactPoint } from '../contact-point/contact-point.js';
+import type { Loop } from 'flo-boolean';
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { PointOnShape, PrePointOnShape } from '../point-on-shape/point-on-shape.js';
+import type { Mutable } from '../utils/mutable.js';
+import { RbTree } from 'flo-ll-rb-tree';
 import { insertCpNode } from '../cp-node/fs/insert-cp-node.js';
-import { MatMeta } from '../index.js';
-
-const { cpNodeComparator } = CpNodeFs;
+import { cpNodeComparator } from '../cp-node/fs/cp-node-comparator.js';
 
 
 /**
- * @internal
  * Creates the initial ContactPoint loops from the given sharp corners.
  * 
- * * modifies `cpTrees` and `lastInsertId` of `meta`
+ * * ❗Modifies❗`cpTrees` and `lastInsertId`
  * 
  * @param loops
  * @param cpTrees
  * @param sharpCornerss
  * @param lastInsertId
+ * 
+ * @internal
  */
 function createInitialCpTree(
         loops: Loop[], 
-        cpTrees: Map<Loop, LlRbTree<CpNode>>,
-        sharpCornerss: PointOnShape[][],
+        sharpCornerss: PrePointOnShape[][],
         lastInsertId: { id: number }) {
 
-    let cpNode: CpNode | undefined;
+    const cpTrees: Map<Loop, RbTree<CpNode>> = new Map();
+
     for (let k=0; k<sharpCornerss.length; k++) {
+        const cpTree = new RbTree(cpNodeComparator);
+        cpTrees.set(loops[k], cpTree);
+
         const sharpCorners = sharpCornerss[k];
 
-        const cpTree = new LlRbTree(cpNodeComparator, false);
-        
-        let cpNode1: CpNode | undefined = undefined;
-        let cpNode2: CpNode | undefined = undefined;
-        for (const pos of sharpCorners) {
-            const circle = { center: pos.p, radius: 0 };
+        let cpNode1: Mutable<CpNode> | undefined = undefined;
+        let cpNode2: Mutable<CpNode> | undefined = undefined;
+        for (const ppos of sharpCorners) {
+            const circle = { center: ppos.p, radius: 0 };
+            const { curve } = ppos;
 
-            const cp1: ContactPoint = { pointOnShape: pos, circle, order: -1, order2: 0 };
-            const cp2: ContactPoint = { pointOnShape: pos, circle, order: +1, order2: 0 };
+            const pos1: PointOnShape = { ...ppos, curve,             t: 1, circle, order: -1, order2: 0 };
+            const pos2: PointOnShape = { ...ppos, curve: curve.next, t: 0, circle, order: +1, order2: 0 };
 
-            cpNode1 = insertCpNode(true, false, false, cpTree, cp1, cpNode2, lastInsertId)!;
-            cpNode2 = insertCpNode(true, false, false, cpTree, cp2, cpNode1, lastInsertId)!;
+            cpNode1 = insertCpNode(true, false, false, cpTree, pos1, cpNode2, lastInsertId)!;
+            cpNode2 = insertCpNode(true, false, false, cpTree, pos2, cpNode1, lastInsertId)!;
             
-            cpNode1.prevOnCircle = cpNode2; 
-            cpNode2.prevOnCircle = cpNode1; 
-            cpNode1.nextOnCircle = cpNode2; 
-            cpNode2.nextOnCircle = cpNode1; 
+            cpNode1.prevOnCircle = cpNode2;
+            cpNode2.prevOnCircle = cpNode1;
+            cpNode1.nextOnCircle = cpNode2;
+            cpNode2.nextOnCircle = cpNode1;
         }
-
-        if (!cpNode) { cpNode = cpNode1; }
-
-        const loop = loops[k];
-        cpTrees.set(loop, cpTree);
     }
 
-    return cpNode;
+    return cpTrees;
 }
 
 

package/src/find-mat/find-mat.ts

@@ -1,13 +1,14 @@
 /** @internal */
 declare const _debug_: Debug; 
 
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { Debug } from '../debug/debug.js';
-import { CpNode } from '../cp-node/cp-node.js';
-import { Loop } from 'flo-boolean';
-import { findAndAdd3ProngsOnLoop } from '../find-3-prong.ts/find-and-add-3-prongs-on-loop.js';
+import type { Debug } from '../debug/debug.js';
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { Loop } from 'flo-boolean';
+import type { MatOptions } from './mat-options.js';
+import type { MatMeta } from '../mat/mat-meta.js';
+import { findAndAdd3ProngsOnLoop } from '../find-3-prong/find-and-add-3-prongs-on-loop.js';
 import { createInitialCpTree } from './create-initial-cp-tree.js';
-import { getPointToCpNode, getPartialMeta, addDebugInfo2, addDebugInfo3, addDebugInfo4 } from './get-meta.js';
+import { /*getPointToCpNode,*/ getPartialMeta, addDebugInfo2, addDebugInfo3, addDebugInfo4, getPointToCpNode } from './get-meta.js';
 import { getSharpCornersOnLoop } from './get-sharp-corners.js';
 import { getDullCornersOnLoop } from './get-dull-corners-on-loop.js';
 import { findAndAdd2ProngsOnAllLoops } from '../find-2-prong/find-and-add-2-prongs-on-all-loops.js';
@@ -15,8 +16,6 @@ import { getFor2ProngsOnLoop } from './get-for-2-prongs-on-loop.js';
 import { getFor1ProngsOnLoop } from './get-for-1-prongs-on-loop.js';
 import { findAndAddHoleClosing2Prongs } from '../find-2-prong/find-and-add-hole-closing-2-prongs.js';
 import { getShapeBounds } from '../svg/get-shape-bounds.js';
-import { MatOptions } from './mat-options.js';
-import { MatMeta } from '../mat/mat-meta.js';
 
 
 /**
@@ -27,8 +26,11 @@ import { MatMeta } from '../mat/mat-meta.js';
  */
 function findMat(
         loops: Loop[], 
-        maxCoordinate: number,
-        options: Required<MatOptions>) {
+        maxCoordPowerOf2: number,
+        options: Required<MatOptions>): {
+            cpNode: CpNode;
+            meta: MatMeta;
+        } {
 
     const { minBezLength, maxCurviness, maxLength, angleIncrement } = options;
 
@@ -37,29 +39,21 @@ function findMat(
     const getFor2ProngsOnLoop_ = getFor2ProngsOnLoop(minBezLength, maxCurviness, maxLength);
     const getFor1ProngsOnLoop_ = getFor1ProngsOnLoop(minBezLength);
 
-    const sharpCornersPerLoop = loops.map(getSharpCornersOnLoop_);
-
     const bounds = getShapeBounds(loops);
     const squaredDiagonalLength = 
         (bounds.maxX.p[0] - bounds.minX.p[0])**2 +
         (bounds.maxY.p[1] - bounds.minY.p[1])**2;
 
-    const cpTrees: Map<Loop, LlRbTree<CpNode>> = new Map();
+    const sharpCornersPerLoop = loops.map(getSharpCornersOnLoop_);
     const lastInsertId = { id: 0 };
-    createInitialCpTree(loops, cpTrees, sharpCornersPerLoop, lastInsertId);
+    const cpTrees = createInitialCpTree(loops, sharpCornersPerLoop, lastInsertId);
 
     const _meta = getPartialMeta(loops);
     const pointToCpNode = getPointToCpNode(loops, cpTrees);
     const meta: MatMeta = {
-        maxCoordinate, squaredDiagonalLength, loops, cpTrees, pointToCpNode,
+        maxCoordPowerOf2, squaredDiagonalLength, loops, cpTrees,// pointToCpNode,
         lastInsertId, ..._meta
     };
-    // const cpTrees: Map<Loop, LlRbTree<CpNode>> = new Map();
-    // const lastInsertId = { id: 0 };
-    // createInitialCpTree(loops, cpTrees, sharpCornersPerLoop, lastInsertId);
-
-    // const meta = getMeta(maxCoordinate, squaredDiagonalLength, loops, cpTrees, lastInsertId);
-
 
     let cpNode: CpNode | undefined;
 
@@ -93,8 +87,6 @@ function findMat(
         if (_debug_.directives.stopAfterThreeProngs) { return { cpNode: cpNode!, meta }; }
     }
 
-    // if (cpNode !== undefined) { add2rongsByError(options, 0.1, meta, cpNode); }
-
     // if (cpNode !== undefined) { checkOrdering(cpTrees, cpNode); }
 
     const mat = { cpNode, meta };

package/src/find-mat/find-mats.ts

@@ -6,6 +6,10 @@ import { toScaleAxis } from '../sat/to-scale-axis.js';
 import { clipOptions } from './clip-options.js';
 import { findMat  } from './find-mat.js';
 import { defaultMatOptions, MatOptions } from './mat-options.js';
+import { circumCenter } from '../find-3-prong/timed-cc.js';
+
+
+const { ceil, log2 } = Math;
 
 
 /**
@@ -37,11 +41,11 @@ function findMats(
         options?: MatOptions): Mat[] {
 
     // if (typeof _debug_ !== 'undefined') { var timingStart = performance.now(); }
-    const { maxCoordinate, maxRadius } = getLoopsMetrics(bezierLoops);
+    const { maxCoordinate } = getLoopsMetrics(bezierLoops);
+    const maxCoordPowerOf2 = ceil(log2(maxCoordinate));
 
     const options_: Required<MatOptions> = clipOptions(
-        maxCoordinate,
-        maxRadius, {
+        maxCoordPowerOf2, {
         ...defaultMatOptions,
         ...(options || {})
     });
@@ -55,19 +59,10 @@ function findMats(
     const loopss = simplifyPaths(bezierLoops, undefined, { forceOrientationNegative: true });
 
     // console.log(loopsToSvgPathStr(bezierLoops));
-    // console.log(loopsToSvgPathStr(loopss[0].map(loop => loop.beziers.map(ps => ps.map(p => p.map(c => Math.round(c*1)/1))))));
-    // console.log(loopsToSvgPathStr(loopss[1].map(loop => loop.beziers.map(ps => ps.map(p => p.map(c => Math.round(c*1)/1))))));
-    // console.log(loopsToSvgPathStr(loopss[0].map(loop => loop.beziers.map(ps => ps.map(p => p.map(c => Math.round(c*1000)/1000))))));
-    // console.log(loopsToSvgPathStr(loopss[1].map(loop => loop.beziers.map(ps => ps.map(p => p.map(c => Math.round(c*1000)/1000))))));
-    // console.log(loopss.map(loops => loops.map(loop => loop.beziers)));
-    // console.log(loopss.map(loops => loopsToSvgPathStr(loops.map(loop => loop.beziers))));
-    // const loopss = [bezierLoops.map(loop => loopFromBeziers(loop,0))];
-    // console.log(loopsToSvgPathStr(bezierLoops.map(v => v.map(v => v.map(v => [-v[0],v[1]])))));
-    // console.log(loopsToSvgPathStr(loopss[0].map(loop => loop.beziers)));
 
     const mats: Mat[] = [];
     for (const loops of loopss) {
-        let mat = findMat(loops, maxCoordinate, options_);
+        let mat = findMat(loops, maxCoordPowerOf2, options_);
         if (mat === undefined) { continue; }
 
         if (applySat) {
@@ -81,6 +76,9 @@ function findMats(
         mats.push(mat);
     }
     
+    // console.log(structuredClone(circumCenter.getStats()));
+    // circumCenter.resetStats();
+
     return mats;
 }
 

package/src/find-mat/fix-ordering.ts

@@ -1,69 +1,69 @@
-import { CpNode, cpNodeComparator, getAllOnLoop } from "../cp-node/cp-node.js";
-import { enhanceCpNode } from "../cp-node/enhance-cp-node.js";
+// import { CpNode, cpNodeComparator, getAllOnLoop } from "../cp-node/cp-node.js";
+// import { enhanceCpNode } from "../cp-node/enhance-cp-node.js";
 
 
-/**
- * @internal
- * 
- * Use only for debugging. Check all nodes around the loop.
- */
-function fixOrdering(
-        cpNode: CpNode) {
+// /**
+//  * @internal
+//  * 
+//  * Use only for debugging. Check all nodes around the loop.
+//  */
+// function fixOrdering(
+//         cpNode: CpNode) {
 
-    const cpStart = cpNode;
+//     const cpStart = cpNode;
 
-    /* holeCloser order causes an issue here
-    {
-        const cpNodes = getAllOnLoop(cpStart);
+//     /* holeCloser order causes an issue here
+//     {
+//         const cpNodes = getAllOnLoop(cpStart);
 
-        cpNodes.sort(cpNodeComparator);
-        // console.log(cpNodes.map(cpn => enhanceCpNode(cpn).ordering))
+//         cpNodes.sort(cpNodeComparator);
+//         // console.log(cpNodes.map(cpn => enhanceCpNode(cpn).ordering))
 
-        const len = cpNodes.length;
-        for (let i=0; i<len; i++) {
-            const cpNode = cpNodes[i];
-            const prev = cpNodes[(i + len - 1)%len];
-            const next = cpNodes[(i + len + 1)%len];
-            if (cpNode.prev !== prev) {
-                // console.log(enhanceCpNode(cpNode));
-            }
-            if (cpNode.next !== next) {
-                // console.log(enhanceCpNode(cpNode));
-            }
-            // cpNode.prev = prev;
-            // cpNode.next = next;
-        }
-    }
-    */
+//         const len = cpNodes.length;
+//         for (let i=0; i<len; i++) {
+//             const cpNode = cpNodes[i];
+//             const prev = cpNodes[(i + len - 1)%len];
+//             const next = cpNodes[(i + len + 1)%len];
+//             if (cpNode.prev !== prev) {
+//                 // console.log(enhanceCpNode(cpNode));
+//             }
+//             if (cpNode.next !== next) {
+//                 // console.log(enhanceCpNode(cpNode));
+//             }
+//             // cpNode.prev = prev;
+//             // cpNode.next = next;
+//         }
+//     }
+//     */
 
-    /*
-    {
-        let cpNode2 = cpStart.next;
-        while (cpNode2 !== cpStart) {
-            const cpNode1 = cpNode2;
-            cpNode2 = cpNode2.next;
+//     /*
+//     {
+//         let cpNode2 = cpStart.next;
+//         while (cpNode2 !== cpStart) {
+//             const cpNode1 = cpNode2;
+//             cpNode2 = cpNode2.next;
 
-            const c = cpNodeComparator(cpNode1, cpNode2)!;
-            const looplen = cpNode1.cp.pointOnShape.curve.loop.beziers.length;
-            if (c > 0 && !cpNode1.isHoleClosing && !cpNode2.isHoleClosing) {
-                const o1 = cpNode1.cp.pointOnShape.curve.idx;
-                const o2 = cpNode2.cp.pointOnShape.curve.idx;
-                if (if) {
-                   1;
-                } else {
-                    console.log('ORDER IS WRONG!', looplen, o1, o2)
-                    console.log(c);
-                    console.log(enhanceCpNode(cpNode1));
-                    console.log(enhanceCpNode(cpNode2));
-                    console.log('');
-                }
-            }
-        }
-    }
-    */
+//             const c = cpNodeComparator(cpNode1, cpNode2)!;
+//             const looplen = cpNode1.cp.pointOnShape.curve.loop.beziers.length;
+//             if (c > 0 && !cpNode1.isHoleClosing && !cpNode2.isHoleClosing) {
+//                 const o1 = cpNode1.cp.pointOnShape.curve.idx;
+//                 const o2 = cpNode2.cp.pointOnShape.curve.idx;
+//                 if (if) {
+//                    1;
+//                 } else {
+//                     console.log('ORDER IS WRONG!', looplen, o1, o2)
+//                     console.log(c);
+//                     console.log(enhanceCpNode(cpNode1));
+//                     console.log(enhanceCpNode(cpNode2));
+//                     console.log('');
+//                 }
+//             }
+//         }
+//     }
+//     */
 
-    // return cpNodes;
-}
+//     // return cpNodes;
+// }
 
 
-export { fixOrdering }
+// export { fixOrdering }

package/src/find-mat/get-dull-corners-on-loop.ts

@@ -1,7 +1,6 @@
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { Loop } from 'flo-boolean';
-import { createPos } from '../point-on-shape/create-pos.js';
-import { bezierBezierIntersectionFast, controlPointLinesLength } from 'flo-bezier3';
+import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
+import type { Loop } from 'flo-boolean';
+import { controlPointLinesLength } from 'flo-bezier3';
 import { getCorner } from '../corner/get-corner.js';
 
 
@@ -9,8 +8,8 @@ import { getCorner } from '../corner/get-corner.js';
 function getDullCornersOnLoop(
         minBezLength: number) {
 
-    return (loop: Loop) => {
-        const dullCorners: PointOnShape[] = [];
+    return (loop: Loop): PrePointOnShape[] => {
+        const dullCorners: PrePointOnShape[] = [];
 
         for (let i=0; i<loop.curves.length; i++) {
             const curve = loop.curves[i];
@@ -18,10 +17,14 @@ function getDullCornersOnLoop(
             if (controlPointLinesLength(curve.ps) < minBezLength) {
                 continue;
             }
+
+            const { next, ps } = curve;
             
-            if (getCorner(curve.ps, curve.next.ps).isQuiteDull) {
-                dullCorners.push(createPos(curve, 1, true));
-                dullCorners.push(createPos(curve.next, 0, true));
+            if (getCorner(ps, next.ps).isQuiteDull) {
+                const p = ps[ps.length - 1];
+
+                dullCorners.push({ curve, t: 1, isSource: true, p });
+                dullCorners.push({ curve: next, t: 0, isSource: true, p });
             }
         }
 
@@ -30,5 +33,4 @@ function getDullCornersOnLoop(
 }
 
 
-
 export { getDullCornersOnLoop }

package/src/find-mat/get-for-1-prongs-on-loop.ts

@@ -1,41 +1,21 @@
+import type { Loop } from 'flo-boolean';
+import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
 import { getCurvatureExtremaDd, controlPointLinesLength } from 'flo-bezier3';
-import { Loop } from 'flo-boolean';
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { createPos } from '../point-on-shape/create-pos.js';
+import { toP } from '../point-on-shape/to-p.js';
 
 
 /**
- * @internal
- * Get useful points on the shape - these incude points of maximum curvature and 
- * points at the bezier-bezier interfaces.  
+ * Get points of maximum curvature.
+ * 
  * @param loop
- * @param additionalPointCount 
+ * 
+ * @internal
  */
 function getFor1ProngsOnLoop(
         minBezLength: number) {
 
     return function(loop: Loop) {
-        const for1Prongs: PointOnShape[] = [];
-
-        const poss = getCurvatureExtremaPoss(minBezLength)(loop);
-        for1Prongs.push(...poss.minima, ...poss.maxima);
-
-        return for1Prongs;
-    }
-}
-
-
-function getCurvatureExtremaPoss(
-        minBezLength: number) {
-
-    return function(loop: Loop) {
-        const poss: {
-            minima: PointOnShape[],
-            maxima: PointOnShape[]
-        } = {
-            minima: [],
-            maxima: []
-        };
+        const poss: PrePointOnShape[] = [];
 
         for (let i=0; i<loop.curves.length; i++) {
             const curve = loop.curves[i];
@@ -43,12 +23,10 @@ function getCurvatureExtremaPoss(
             if (controlPointLinesLength(curve.ps) < minBezLength) {
                 continue;
             }
-            
-            const { minima, maxima } = getCurvatureExtremaDd(curve.ps);
-            // const maxAbsCurvatures = [...minima, ...maxima].map(t => createPos(curve, t, true));
 
-            poss.minima.push(...minima.map(t => createPos(curve, t, true)));
-            poss.maxima.push(...maxima.map(t => createPos(curve, t, true)));
+            poss.push(...getCurvatureExtremaDd(curve.ps).maxima.map(t => ({
+                curve, t, isSource: true, p: toP(curve.ps, t)
+            })));
         }
 
         return poss;

package/src/find-mat/get-for-2-prongs-on-loop.ts

@@ -1,16 +1,16 @@
-import { splitByCurvatureAndLength, controlPointLinesLength, fitQuadsToCubic, getInflections } from 'flo-bezier3';
-import { Loop } from 'flo-boolean';
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { createPos } from '../point-on-shape/create-pos.js';
-import { fitQuadsToCubicTsOnly } from '../bezier/fit-quads-to-cubic.js';
+import type { Loop } from 'flo-boolean';
+import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
+import { splitByCurvatureAndLength, controlPointLinesLength, getInflections } from 'flo-bezier3';
+import { toP } from '../point-on-shape/to-p.js';
 
 
 /**
- * @internal
  * Get useful points on the shape - these incude points of maximum curvature and 
  * points at the bezier-bezier interfaces.  
  * @param loop
  * @param additionalPointCount 
+ * 
+ * @internal
  */
 function getFor2ProngsOnLoop(
         minBezLength: number,
@@ -18,7 +18,7 @@ function getFor2ProngsOnLoop(
         maxLength: number) {
 
     return function(loop: Loop) {
-        const for2Prongs: PointOnShape[] = [];
+        const for2Prongs: PrePointOnShape[] = [];
 
         const curves = loop.curves;
         for (let i=0; i<curves.length; i++) {
@@ -30,16 +30,13 @@ function getFor2ProngsOnLoop(
             }
             
             let ts = splitByCurvatureAndLength(ps, maxCurviness, maxLength);
-            // let ts = [0,0.25,0.5,0.75,1];
-            // let ts = [0,0.5 + 2**-20,1];
-            // let ts = ps.length <= 3 ? [0,1] : fitQuadsToCubicTsOnly(ps, 1);
 
             ts = ts.length === 2 ? [0.5] : ts;
             ts.push(...getInflections(ps));
             ts = ts.filter(t => t !== 0 && t !== 1);
 
-            const byCurvatureAndLength = 
-                ts.map(t => createPos(curve, t, true));
+            const byCurvatureAndLength: PrePointOnShape[] = 
+                ts.map(t => ({ curve, t, isSource: true, p: toP(curve.ps, t) }));
 
             for2Prongs.push(...byCurvatureAndLength);
         }