flo-mat 3.0.0 → 3.0.2

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

@@ -1,6 +1,5 @@
-import { BezierPiece  } from '../mat/bezier-piece.js';
+import { CurvePiece  } from '../mat/curve-piece.js';
 import { getCloseBoundaryPointsCertified } from '../closest-boundary-point/get-close-boundary-points-certified.js';
-import { createPos } from '../point-on-shape/create-pos.js';
 
 
 /**
@@ -11,10 +10,11 @@ import { createPos } from '../point-on-shape/create-pos.js';
  */
 function getClosestPoints(
         x: number[], 
-        bezierPiece3s: BezierPiece[][]) {
+        bezierPiece3s: CurvePiece[][]) {
 
     return bezierPiece3s.map(bezierPieces => {
         return getCloseBoundaryPointsCertified(
+            5,  // TODO - see find-2-prong
             bezierPieces, x
         )[0];
     });

package/src/find-mat/add-2-prongs-by-error.ts

@@ -0,0 +1,122 @@
+import { drawFs } from "flo-draw";
+import { closestPointOnBezier } from "flo-bezier3";
+import { CpNode } from "../cp-node/cp-node.js";
+import { findAndAdd2Prong } from "../find-2-prong/find-and-add-2-prong.js";
+import { MatMeta } from "../mat/mat-meta.js";
+import { getHalfAngle } from "./get-half-angles.js";
+import { getMatCurveToNext } from "../cp-node/fs/get-mat-curve-to-next.js";
+import { getAllOnCircle } from "../cp-node/fs/get-all-on-circle.js";
+import { isTerminating } from "../cp-node/fs/is-terminating.js";
+import { findAndAdd3Prongs } from "../find-3-prong.ts/find-and-add-3-prongs.js";
+import { getBoundaryBezierPartsToNext } from "../cp-node/fs/get-boundary-bezier-parts-to-next.js";
+import { drawBezierPieces } from "../debug/functions/draw/draw-bezier-pieces.js";
+import { getAllOnLoop } from "../cp-node/fs/get-all-on-loop.js";
+import { PointOnShape } from "../point-on-shape/point-on-shape.js";
+import { getBoundaryBeziersToNext } from "../cp-node/fs/get-boundary-beziers-to-next.js";
+import { isPosQuiteDullCorner } from "../point-on-shape/is-pos-quite-dull-corner.js";
+import { MatOptions } from "./mat-options.js";
+
+
+const draw = false;
+const scale = 2/50;
+const classes = [
+    'red thin10 nofill',
+    'green thin10 nofill',
+    'deeppink thin10 nofill'
+];
+
+function add2rongsByError(
+        options: Required<MatOptions>,
+        tolerance: number,
+        meta: MatMeta,
+        cpStart: CpNode): number {
+
+    // const g = document.getElementsByTagName('g')[0];
+
+    let maxError = Number.NEGATIVE_INFINITY;
+
+    const cpNodes = getAllOnLoop(cpStart);
+    for (const cpNode of cpNodes) {
+        const { t: tS } = cpNode.cp.pointOnShape;
+        const { t: tE } = cpNode.next.cp.pointOnShape;
+        if (((tS === 0 || tS === 1 || tE === 0 || tE === 1) &&
+             isPosQuiteDullCorner(cpNode.cp.pointOnShape)) ||
+            cpNode.isHoleClosing) {
+
+            continue;
+        }
+
+        // don't check dull corners or hole closers
+        if (isTerminating(cpNode)) {
+            continue;
+        }
+
+        // drawFs.dot(g, cpNode.cp.circle.center, scale*2, 'darkgreen', 0)
+
+        // let threeProngAdded = false;
+        // if (draw) { drawFs.dot(g, cpNode.cp.circle.center, scale*1, 'darkgreen', 0); }
+
+        const q = getMatCurveToNext(cpNode);
+
+        const d = checkAndMaybeAddAnother(q, meta, tolerance, cpNodes, cpNode);
+        if (d > maxError) {
+            maxError = d;
+        }
+	}
+
+    if (maxError > 0) {
+        // console.log(maxError);
+    }
+    return maxError;
+}
+
+
+function checkAndMaybeAddAnother(
+        q: number[][],
+        meta: MatMeta,
+        tolerance: number,
+        cpNodes: CpNode[],
+        cpNode: CpNode): number {
+
+    // const g = document.getElementsByTagName('g')[0];
+
+    const pos = getHalfAngle(cpNode);
+    if (pos === undefined) { return 0; }
+
+    // if (draw) { drawFs.bezier(g, q, 'thin50 deeppink nofill', 0); }
+
+    const _newCpNode = findAndAdd2Prong(meta, pos);
+    if (_newCpNode === undefined) { return 0; }
+
+    // ...since a 3-prong might be revealed
+    // const { closeByss: closeBys, addedCpNodes: threeProngCpNodes } = 
+    //     findAndAdd3Prongs(meta, _newCpNode);
+    // if (threeProngCpNodes.length > 0) {
+    //     threeProngAdded = true;
+    //     console.log('threeProngAdded')
+    //     continue;
+    // }
+
+    // if (draw) { drawFs.dot(g, _newCpNode.cp.circle.center!, scale*1, 'red', 0); }
+
+    const p = _newCpNode.cp.circle.center;
+    const { d, p: pq } = closestPointOnBezier(q, p);
+    // if (draw) { drawFs.line(g, [p,pq], 'thin2 darkgreen nofill', 0); }
+
+    if (d < tolerance) {
+        return 0;
+    }
+
+    // console.log(d);
+    cpNodes.push(_newCpNode, cpNode);
+
+    // if (draw) { drawFs.line(g, [p,pq], 'thin5 darkgreen nofill', 0); }
+    // if (draw) { drawFs.dot(g, _newCpNode.cp.circle.center!, scale*3, 'red', 0); }
+    // drawFs.line(g, [p,pq], 'thin20 darkgreen nofill', 0);
+    // drawFs.dot(g, _newCpNode.cp.circle.center!, scale*3, 'red', 0);
+
+    return d;
+}
+
+
+export { add2rongsByError }

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

@@ -0,0 +1,38 @@
+import { MatOptionMeta, matOptionRanges, MatOptions } from './mat-options.js';
+
+
+function clipOptions(
+        maxCoordinate: number,
+        maxRadius: 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 };
+    for (const k in matOptionRanges) {
+        // @ts-ignore
+        let o = options_[k];
+        // @ts-ignore
+        const c = matOptionRanges[k] as MatOptionMeta;
+        const { range, scaleByMaxCoordinate, scaleByMaxRadius } = 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));
+        }
+
+        // @ts-ignore
+        options_[k] = o;
+    }
+
+    return options_;
+}
+
+
+export { clipOptions }

package/src/find-mat/cp-node-for-insertion.ts

@@ -0,0 +1,13 @@
+import { LlRbTree } from "flo-ll-rb-tree";
+import { CpNode } from "../cp-node/cp-node.js";
+
+
+interface CpNodeForInsertion {
+    cpTree: LlRbTree<CpNode>;
+    cpNode: CpNode;
+    prev: CpNode;
+    next: CpNode;
+}
+
+
+export { CpNodeForInsertion }

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

@@ -0,0 +1,59 @@
+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 { insertCpNode } from '../cp-node/fs/insert-cp-node.js';
+
+const { cpNodeComparator } = CpNodeFs;
+
+
+/**
+ * @internal
+ * Creates the initial ContactPoint loops from the given sharp corners.
+ * 
+ * * modifies `cpTrees`
+ * 
+ * @param shape
+ * @param sharpCornerss
+ */
+function createInitialCpTree(
+        loops: Loop[], 
+        cpTrees: Map<Loop, LlRbTree<CpNode>>,
+        sharpCornerss: PointOnShape[][]) {
+
+    let cpNode;
+    for (let k=0; k<sharpCornerss.length; k++) {
+        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 };
+
+            const cp1: ContactPoint = { pointOnShape: pos, circle, order: -1, order2: 0 };
+            const cp2: ContactPoint = { pointOnShape: pos, circle, order: +1, order2: 0 };
+
+            cpNode1 = insertCpNode(true, false, false, cpTree, cp1, cpNode2)!;
+            cpNode2 = insertCpNode(true, false, false, cpTree, cp2, 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;
+}
+
+
+export { createInitialCpTree }

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

@@ -5,16 +5,17 @@ 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 { Mat } from '../mat/mat.js';
-import { findAndAddAll3Prongs } from '../find-3-prong.ts/find-and-add-all-3-prongs.js';
-import { createInitialCpGraph } from './create-initial-cp-graph.js';
-import { addDebugInfo1, addDebugInfo2, addDebugInfo3, addDebugInfo4 } from './add-debug-info.js';
+import { findAndAdd3ProngsOnLoop } from '../find-3-prong.ts/find-and-add-3-prongs-on-loop.js';
+import { createInitialCpTree } from './create-initial-cp-tree.js';
+import { getMeta, addDebugInfo2, addDebugInfo3, addDebugInfo4 } from './get-meta.js';
 import { getSharpCornersOnLoop } from './get-sharp-corners.js';
-import { getDullCornersOnLoop } from './get-dull-corners.js';
-import { findAndAdd2ProngsOnAllPaths } from '../find-2-prong/find-and-add-2-prongs-on-all-paths.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';
 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';
 
 
 /**
@@ -25,65 +26,76 @@ import { findAndAddHoleClosing2Prongs } from '../find-2-prong/find-and-add-hole-
  */
 function findMat(
         loops: Loop[], 
-        minBezLength: number,
-        maxCurviness: number,
-        maxLength: number,
-        maxCoordinate: number): Mat {
+        maxCoordinate: number,
+        options: Required<MatOptions>) {
+
+    const { minBezLength, maxCurviness, maxLength, angleIncrement } = options;
 
-    addDebugInfo1(loops);
-        
     const getSharpCornersOnLoop_ = getSharpCornersOnLoop(minBezLength);
     const getDullCornersOnLoop_ = getDullCornersOnLoop(minBezLength);
+    const getFor2ProngsOnLoop_ = getFor2ProngsOnLoop(minBezLength, maxCurviness, maxLength);
+    const getFor1ProngsOnLoop_ = getFor1ProngsOnLoop(minBezLength);
+
     const sharpCornersPerLoop = loops.map(getSharpCornersOnLoop_);
-    const dullCornersPerLoop = loops.map(getDullCornersOnLoop_);
 
     const cpTrees: Map<Loop, LlRbTree<CpNode>> = new Map();
-    createInitialCpGraph(loops, cpTrees, sharpCornersPerLoop);
+    createInitialCpTree(loops, cpTrees, sharpCornersPerLoop);
 
-    findAndAddHoleClosing2Prongs(loops, cpTrees, maxCoordinate);
+    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 meta = getMeta(maxCoordinate, squaredDiagonalLength, loops, cpTrees);
+
+    let cpNode: CpNode | undefined;
+
+    cpNode = findAndAddHoleClosing2Prongs(meta);
 
     if (typeof _debug_ !== 'undefined') {
-        if (_debug_.directives.stopAfterHoleClosers) { return undefined!; }
+        if (_debug_.directives.stopAfterHoleClosers) { return { cpNode: cpNode!, meta }; }
     }
     addDebugInfo2();
 
-    const for1ProngsPerLoop = loops.map(
-        getFor1ProngsOnLoop(minBezLength)
-    );
-    const for2ProngsPerLoop = loops.map(
-        getFor2ProngsOnLoop(minBezLength, maxCurviness, maxLength)
-    );
+    const dullCornersPerLoop = loops.map(getDullCornersOnLoop_);
+    cpNode = findAndAdd2ProngsOnAllLoops(meta, angleIncrement, dullCornersPerLoop, false) || cpNode;
 
-    let cpNode: CpNode | undefined;
-    cpNode = findAndAdd2ProngsOnAllPaths(
-        cpNode, loops, cpTrees, dullCornersPerLoop, maxCoordinate, false
-    );
-    cpNode = findAndAdd2ProngsOnAllPaths(
-        cpNode, loops, cpTrees, for1ProngsPerLoop, maxCoordinate, true
-    );
-    cpNode = findAndAdd2ProngsOnAllPaths(
-        cpNode, loops, cpTrees, for2ProngsPerLoop, maxCoordinate, false
-    );
+    const for1ProngsPerLoop = loops.map(getFor1ProngsOnLoop_);
+    cpNode = findAndAdd2ProngsOnAllLoops(meta, angleIncrement, for1ProngsPerLoop, true) || cpNode;
+
+    const for2ProngsPerLoop = loops.map(getFor2ProngsOnLoop_);
+    cpNode = findAndAdd2ProngsOnAllLoops(meta, angleIncrement, for2ProngsPerLoop, false) || cpNode;
 
     addDebugInfo3();
+
     if (typeof _debug_ !== 'undefined') {
-        if (_debug_.directives.stopAfterTwoProngs) { return undefined!; }
+        if (_debug_.directives.stopAfterTwoProngs) { return { cpNode: cpNode!, meta }; }
     }
 
-    if (cpNode === undefined) { return undefined!; }
+    cpNode = findAndAdd3ProngsOnLoop(meta, cpNode);
 
-    findAndAddAll3Prongs(cpTrees, cpNode, maxCoordinate);
+    if (cpNode === undefined) { return undefined!; }
 
     if (typeof _debug_ !== 'undefined') {
-        if (_debug_.directives.stopAfterThreeProngs) { return undefined!; }
+        if (_debug_.directives.stopAfterThreeProngs) { return { cpNode: cpNode!, meta }; }
     }
 
-    const mat = { cpNode, cpTrees };
+    // if (cpNode !== undefined) { add2rongsByError(options, 0.1, meta, cpNode); }
+
+    // if (cpNode !== undefined) { checkOrdering(cpTrees, cpNode); }
 
-    addDebugInfo4(mat);
+    const mat = { cpNode, meta };
+
+    addDebugInfo4();
 
     return mat;
 }
 
 
 export { findMat }
+
+
+
+/** Curvilinear Shape Features (CSFs) */
+// const csfs = getCsfs(meta, minBezLength, loops);
+// const ligatures = getLigatures(meta, csfs);

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

@@ -1,11 +1,11 @@
-/** @internal */
-declare const _debug_: Debug; 
-
 import { beziersToSvgPathStr, simplifyPaths } from 'flo-boolean';
-import { Debug } from '../debug/debug.js';
+import { getLoopsMetrics } from '../loop/get-max-coordinate.js';
 import { Mat } from '../mat/mat.js';
+import { simplifyMat } from '../mat/simplify-mat.js';
+import { toScaleAxis } from '../sat/to-scale-axis.js';
+import { clipOptions } from './clip-options.js';
 import { findMat  } from './find-mat.js';
-import { getSizeParams } from './get-size-params.js';
+import { defaultMatOptions, MatOptions } from './mat-options.js';
 
 
 /**
@@ -23,7 +23,8 @@ import { getSizeParams } from './get-size-params.js';
  * before an additional MAT point is inserted in between. Defaults to 0.4. 
  * (Curviness is measured as the total angle in radians between the consecutive 
  * vectors formed by the ordered control points of th bezier curve). The value
- * is clipped in the range `[0.05,3]`.
+ * is clipped in the range `[0.01,3]`.
+ * 
  * @param maxLength The maximum length a curve can have before an additional MAT 
  * point is inserted. This value is scaled to a reference 1024 x 1024 
  * grid (e.g. if the shape fits in a 512 x 512 axis-aligned box the value will be 
@@ -32,37 +33,53 @@ import { getSizeParams } from './get-size-params.js';
  * in [1,100].
  */
 function findMats(
-		bezierLoops: number[][][][], 
-		maxCurviness = 0.4,
-        maxLength = 4): Mat[] {
+		bezierLoops: number[][][][],
+		options?: MatOptions): Mat[] {
 
 	// if (typeof _debug_ !== 'undefined') { var timingStart = performance.now(); }
+	const { maxCoordinate, maxRadius } = getLoopsMetrics(bezierLoops);
+
+	const options_: Required<MatOptions> = clipOptions(
+		maxCoordinate,
+		maxRadius, {
+		...defaultMatOptions,
+		...(options || {})
+	});
+
+	const {
+		applySat, simplify,
+		satScale, simplifyTolerance
+	} = options_;
 
-	let maxCoordinate: number;
-	let minBezLength: number;
-	({ maxCurviness, maxLength, maxCoordinate, minBezLength } = 
-		getSizeParams(bezierLoops, maxCurviness, maxLength));
 
 	const loopss = simplifyPaths(bezierLoops);
+	// console.log(loopsToSvgPathStr(bezierLoops));
+	// const loopss = [bezierLoops.map(loop => loopFromBeziers(loop,0))];
 	// console.log(loopsToSvgPathStr(bezierLoops.map(v => v.map(v => v.map(v => v.map(v => v*2**4))))));
+	// 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) {
-		const mat = findMat(
-			loops, 
-			minBezLength, 
-			maxCurviness, 
-			maxLength,
-			maxCoordinate
-		);
-		if (mat) { mats.push(mat); }
-	}
+		let mat = findMat(loops, maxCoordinate, options_);
+		if (mat === undefined) { continue; }
 
+		if (applySat) {
+			mat = toScaleAxis(mat, satScale);
+		}
+
+		if (simplify) {
+			mat = simplifyMat(mat, simplifyTolerance, 50)
+		}
+
+		mats.push(mat);
+	}
+	
 	return mats;
 }
 
 
+
 /**
  * Returns an SVG path string representation of the given bezier loops.
  * @param loops An array of loops having an array of bezier curves each given as 

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

@@ -0,0 +1,34 @@
+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 { getCorner } from '../corner/get-corner.js';
+
+
+/** @internal */
+function getDullCornersOnLoop(
+        minBezLength: number) {
+
+    return (loop: Loop) => {
+        const dullCorners: PointOnShape[] = [];
+
+        for (let i=0; i<loop.curves.length; i++) {
+            const curve = loop.curves[i];
+
+            if (controlPointLinesLength(curve.ps) < minBezLength) {
+                continue;
+            }
+            
+            if (getCorner(curve.ps, curve.next.ps).isQuiteDull) {
+                dullCorners.push(createPos(curve, 1, true));
+                dullCorners.push(createPos(curve.next, 0, true));
+            }
+        }
+
+        return dullCorners;
+    }
+}
+
+
+
+export { getDullCornersOnLoop }

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

@@ -1,4 +1,4 @@
-import { getCurvatureExtremaDd, getCurvatureExtremaE, controlPointLinesLength, getCurvatureExtrema } from 'flo-bezier3';
+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';
@@ -17,6 +17,26 @@ function getFor1ProngsOnLoop(
     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: []
+        };
+
         for (let i=0; i<loop.curves.length; i++) {
             const curve = loop.curves[i];
 
@@ -24,15 +44,14 @@ function getFor1ProngsOnLoop(
                 continue;
             }
             
-            // const { minima, maxima } = getCurvatureExtrema(curve.ps);
             const { minima, maxima } = getCurvatureExtremaDd(curve.ps);
-            // const { minima, maxima } = getCurvatureExtremaE(curve.ps);
-            const maxAbsCurvatures = [...minima, ...maxima].map(t => createPos(curve, t, true));
+            // const maxAbsCurvatures = [...minima, ...maxima].map(t => createPos(curve, t, true));
 
-            for1Prongs.push(...maxAbsCurvatures);
+            poss.minima.push(...minima.map(t => createPos(curve, t, true)));
+            poss.maxima.push(...maxima.map(t => createPos(curve, t, true)));
         }
 
-        return for1Prongs;
+        return poss;
     }
 }
 

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

@@ -1,7 +1,8 @@
-import { splitByCurvatureAndLength, controlPointLinesLength } from 'flo-bezier3';
+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';
 
 
 /**
@@ -19,19 +20,26 @@ function getFor2ProngsOnLoop(
     return function(loop: Loop) {
         const for2Prongs: PointOnShape[] = [];
 
-        for (let i=0; i<loop.curves.length; i++) {
-            const curve = loop.curves[i];
+        const curves = loop.curves;
+        for (let i=0; i<curves.length; i++) {
+            const curve = curves[i];
+            const ps = curve.ps;
 
-            if (controlPointLinesLength(curve.ps) < minBezLength) {
+            if (controlPointLinesLength(ps) < minBezLength) {
                 continue;
             }
             
-            let ts = splitByCurvatureAndLength(curve.ps, maxCurviness, maxLength);
-            // add at least one in the middle
-            if (ts.length === 2) { ts = [0, 0.5, 1]; }
+            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.slice(1,ts.length-1).map(t => createPos(curve, t, true));
+                ts.map(t => createPos(curve, t, true));
 
             for2Prongs.push(...byCurvatureAndLength);
         }