flo-mat 1.2.0 → 2.0.0

package/src/debug/functions/two-prong.ts

@@ -1,20 +1,12 @@
-
 declare let _debug_: Debug; 
 
 import { drawFs } from 'flo-draw';
-import { Debug, Generated } from '../debug';
-
-import { CpNode } from '../../cp-node';
-import { Circle } from '../../circle';
-
-import { 
-	getObjClosestTo, 
-	distanceBetween, 
-	squaredDistanceBetween 
-} from 'flo-vector2d';
-
-import { TwoProngForDebugging } from '../two-prong-for-debugging';
-import { ElemType_TwoProng } from '../../mat/elem-type-two-prong';
+import { getObjClosestTo, distanceBetween, squaredDistanceBetween } from 'flo-vector2d';
+import { Debug, Generated } from '../debug.js';
+import { CpNode } from '../../cp-node.js';
+import { Circle } from '../../circle.js';
+import { TwoProngForDebugging } from '../two-prong-for-debugging.js';
+import { ElemType_TwoProng } from '../../mat/elem-type-two-prong.js';
 
 
 /** @hidden */

package/src/debug/three-prong-for-debugging.ts

@@ -1,8 +1,7 @@
-
-import { CpNode       } from '../cp-node';
-import { posToHumanString, IPointOnShape } from '../point-on-shape';
-import { Circle       } from '../circle';
-import { Generated } from './debug';
+import { CpNode } from '../cp-node.js';
+import { posToHumanString, IPointOnShape } from '../point-on-shape.js';
+import { Circle } from '../circle.js';
+import { Generated } from './debug.js';
 
 
 /**

package/src/debug/two-prong-for-debugging.ts

@@ -1,9 +1,8 @@
-
-import { CpNode       } from '../cp-node';
-import { IPointOnShape } from '../point-on-shape';
-import { Circle       } from '../circle';
-import { BezierPiece  } from '../mat/bezier-piece';
-import { Generated    } from './debug';
+import { CpNode } from '../cp-node.js';
+import { IPointOnShape } from '../point-on-shape.js';
+import { Circle } from '../circle.js';
+import { BezierPiece } from '../mat/bezier-piece.js';
+import { Generated } from './debug.js';
 
 
 /** @hidden */

package/src/find-mats.ts

@@ -1,69 +1,66 @@
-
 /** @hidden */
 declare var _debug_: Debug; 
 
-import { Debug } from './debug/debug';
-import LlRbTree from 'flo-ll-rb-tree';
+import { LlRbTree } from 'flo-ll-rb-tree';
 import { simplifyPaths } from 'flo-boolean';
-import { CpNode } from './cp-node';
-import { Loop } from './loop';
-import { Mat } from './mat';
-import { findAndAddAll3Prongs } from './mat/find-mat/find-and-add-3-prongs';
-import { createInitialCpGraph } from './mat/find-mat/create-initial-cp-graph';;
-import { addDebugInfo1, addDebugInfo2, addDebugInfo3, addDebugInfo4 } from './mat/find-mat/add-debug-info';
-import { getPotential2Prongs } from './mat/find-mat/get-potential-2-prongs';
-import { getSharpCorners } from './mat/find-mat/get-sharp-corners';
-import { findAndAdd2ProngsOnAllPaths } from './mat/find-mat/find-and-add-2-prongs-on-all-paths';
-import { getInterestingPointsOnLoop } from './mat/find-mat/create-get-interesting-points-on-loop';
-import { findAndAddHoleClosing2Prongs } from './mat/find-mat/find-and-add-hole-closing-2-prongs';
-import { getLoopsMetrics } from './loop/get-max-coordinate';
+import { Debug } from './debug/debug.js';
+import { CpNode } from './cp-node.js';
+import { Loop } from './loop.js';
+import { Mat } from './mat.js';
+import { findAndAddAll3Prongs } from './mat/find-mat/find-and-add-3-prongs.js';
+import { createInitialCpGraph } from './mat/find-mat/create-initial-cp-graph.js';;
+import { addDebugInfo1, addDebugInfo2, addDebugInfo3, addDebugInfo4 } from './mat/find-mat/add-debug-info.js';
+import { getPotential2Prongs } from './mat/find-mat/get-potential-2-prongs.js';
+import { getSharpCorners } from './mat/find-mat/get-sharp-corners.js';
+import { findAndAdd2ProngsOnAllPaths } from './mat/find-mat/find-and-add-2-prongs-on-all-paths.js';
+import { getInterestingPointsOnLoop } from './mat/find-mat/create-get-interesting-points-on-loop.js';
+import { findAndAddHoleClosing2Prongs } from './mat/find-mat/find-and-add-hole-closing-2-prongs.js';
+import { getLoopsMetrics } from './loop/get-max-coordinate.js';
 
 
 /**
  * Finds and returns the Medial Axis Transforms (MATs) from the given array of 
  * bezier loops representing shape boundaries.
+ * 
  * @param bezierLoops An array of (possibly intersecting) loops with each loop 
  * representing one or more piecewise smooth closed curves (i.e. shapes). Each 
  * loop consists of an array of beziers represented by an array of control 
  * points with 2,3 or 4 elements corresponding to linear, quadratic and cubic 
  * beziers respectively. Each point is a two-element array (ordered pair), the
  * first of which is the x-coordinate and the second the y-coordinate.
- * @param maxFlatness The maximum value the flatness of a curve can have before
- * an additional MAT point is added in between. Defaults to 1.01. (Flatness is
- * measured as the total distance between control points of a curve divided by
- * the length of the curve.) The is clipped in [1.001,2]..
+ * 
+ * @param maxCurviness The maximum value the 'curviness' of a curve can have 
+ * 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]`.
  * @param maxLength The maximum length a curve can have before an additional MAT 
- * point is added in between. 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 will be 
- * halved, e.g. from 10 to 5). Together with maxFlatness it represents a 
+ * 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 
+ * halved, e.g. from 10 to 5). Together with maxCurviness it represents a 
  * tolerance for the accuracy of the MAT. Defaults to 4. The value is clipped 
  * in [1,100].
  */
 function findMats(
 		bezierLoops: number[][][][], 
-		maxFlatness = 1.01,
+		maxCurviness = 0.4,
         maxLength = 4): Mat[] {
 
 	if (typeof _debug_ !== 'undefined') { var timingStart = performance.now(); }
 
 	let maxCoordinate: number;
 	let minBezLength: number;
-	({ maxFlatness, maxLength, maxCoordinate, minBezLength } = 
-		getSizeParams(bezierLoops, maxFlatness, maxLength));
+	({ maxCurviness, maxLength, maxCoordinate, minBezLength } = 
+		getSizeParams(bezierLoops, maxCurviness, maxLength));
 
 	let loopss = simplifyPaths(bezierLoops, maxCoordinate);
 
-	if (typeof _debug_ !== 'undefined') {
-		let timing = _debug_.generated.timing;
-		timing.simplifyPaths = performance.now() - timingStart;
-	}
-
 	let mats: Mat[] = [];
 	for (let loops of loopss) {
 		let mat = findMat(
 			loops, 
 			minBezLength, 
-			maxFlatness, 
+			maxCurviness, 
 			maxLength,
 			maxCoordinate
 		);
@@ -76,7 +73,7 @@ function findMats(
 
 function getSizeParams(
 		bezierLoops: number[][][][],
-		maxFlatness: number,
+		maxCurviness: number,
         maxLength: number) {
 
 	// Gather some shape metrics
@@ -90,8 +87,8 @@ function getSizeParams(
 	let minBezLength = 2**expMax * 2**(-minBezLengthSigBits);
 
 	// Limit the tolerance to a reasonable level
-	if (maxFlatness < 1.001) { maxFlatness = 1.001; }
-	if (maxFlatness > 2    ) { maxFlatness = 2;     }
+	if (maxCurviness < 0.05) { maxCurviness = 0.05; }
+	if (maxCurviness > 3   ) { maxCurviness = 3;    }
 	// Limit the tolerance to a reasonable level
 	if (maxLength < 0.1) { maxLength = 0.1; }
 	if (maxLength > 100) { maxLength = 100; }
@@ -100,7 +97,7 @@ function getSizeParams(
 	let maxLengthSigBits = 10;  // 1024 x 1024
 	maxLength = maxLength * (2**expMaxRadius * 2**(-maxLengthSigBits));
 
-	return { maxFlatness, maxLength, maxCoordinate, minBezLength };
+	return { maxCurviness, maxLength, maxCoordinate, minBezLength };
 }
 
 
@@ -109,13 +106,11 @@ function getSizeParams(
  * Find the MAT of the given loops.
  * @param loops The loops (that as a precondition must be ordered from highest 
  * (i.e. smallest y-value) topmost point loops to lowest)
- * @param xMap Intersection point map.
- * @param additionalPointCount 
  */
 function findMat(
 		loops: Loop[], 
 		minBezLength: number,
-		maxFlatness: number,
+		maxCurviness: number,
 		maxLength: number,
 		maxCoordinate: number): Mat {
 
@@ -124,7 +119,7 @@ function findMat(
 	// Gets interesting points on the shape, i.e. those that makes sense to use 
 	// for the 2-prong procedure.
 	let pointsPerLoop = loops.map(
-		getInterestingPointsOnLoop(minBezLength, maxFlatness, maxLength)
+		getInterestingPointsOnLoop(minBezLength, maxCurviness, maxLength)
 	);
 
 	let for2ProngsPerLoop = getPotential2Prongs(pointsPerLoop);

package/src/get-boundary-bezier-parts-to-next.ts

@@ -1,7 +1,6 @@
-
-import { BezierPart } from 'flo-bezier3';
-import { CpNode } from './cp-node';
-import { Curve  } from './curve';
+import { BezierPiece } from 'flo-bezier3';
+import { CpNode } from './cp-node.js';
+import { Curve  } from './curve.js';
 
 
 /**
@@ -9,7 +8,7 @@ import { Curve  } from './curve';
  * on the boundary.
  * @param cpNode
  */
-function getBoundaryBezierPartsToNext(cpNode: CpNode): BezierPart[] {
+function getBoundaryBezierPartsToNext(cpNode: CpNode): BezierPiece[] {
     let cpThis = cpNode; 
     let cpNext = cpNode.next;
 
@@ -25,7 +24,7 @@ function getBoundaryBezierPartsToNext(cpNode: CpNode): BezierPart[] {
         return undefined;
     }
     
-    let bezierParts: BezierPart[] = [];
+    let bezierParts: BezierPiece[] = [];
 
     if (curveNext === curveThis) {
         bezierParts.push(

package/src/get-boundary-beziers-to-next.ts

@@ -1,7 +1,7 @@
-
-import { CpNode } from './cp-node';
-import { Curve  } from './curve';
-import { fromTo, fromTTo1, from0ToT } from 'flo-bezier3';
+// qqq import { fromTo, fromTTo1, from0ToT } from 'flo-bezier3';
+import { fromTo } from 'flo-bezier3';
+import { CpNode } from './cp-node.js';
+import { Curve  } from './curve.js';
 
 
 /**
@@ -29,11 +29,11 @@ function getBoundaryBeziersToNext(cpNode: CpNode) {
 
     if (curveNext === curveThis) {
         beziers.push(
-            fromTo(posThis.curve.ps)(posThis.t, posNext.t)
+            fromTo(posThis.curve.ps, posThis.t, posNext.t)
         );
     } else {
         beziers.push(
-            fromTTo1(posThis.curve.ps, posThis.t)
+            fromTo(posThis.curve.ps, posThis.t, 1)
         );
         
         addSkippedBeziers(
@@ -63,7 +63,8 @@ function addSkippedBeziers(
         curveThis = curveThis.next;
         let tEnd = curveThis === curveEnd ? t1 : 1;
         beziers.push( 
-            from0ToT(curveThis.ps, tEnd) 
+            // qqq from0ToT(curveThis.ps, tEnd) 
+            fromTo(curveThis.ps, 0, tEnd)
         );
     } while (curveThis !== curveEnd);
 }

package/src/get-bounding-box-.ts

@@ -0,0 +1,7 @@
+import { getBoundingBox } from "flo-bezier3";
+import { memoize } from "flo-memoize";
+
+const getBoundingBox_ = memoize(getBoundingBox);
+
+
+export { getBoundingBox_ }

package/src/get-branches.ts

@@ -1,8 +1,7 @@
-
-import { CpNode } from './cp-node';
 import { tangent } from 'flo-bezier3';
 import { cross, toUnitVector } from 'flo-vector2d';
-import { getCurveToNext } from './get-curve-to-next';
+import { CpNode } from './cp-node.js';
+import { getCurveToNext } from './get-curve-to-next.js';
 
 
 /** @hidden */

package/src/get-curve/get-curve-between.ts

@@ -1,10 +1,9 @@
-
 import { 
     fromTo, dot, cross, rotate90Degrees, interpolate, translate,
     lineLineIntersection
 } from 'flo-vector2d';
-import { CpNode } from '../cp-node';
-import { getEdgeDirection } from './get-edge-direction';
+import { CpNode } from '../cp-node.js';
+import { getEdgeDirection } from './get-edge-direction.js';
 
 
 /** @hidden */

package/src/get-curve/get-edge-direction.ts

@@ -1,12 +1,9 @@
-
 import { 
     toUnitVector, fromTo, rotate, translate, rotate90Degrees, reverse, dot
 } from 'flo-vector2d';
-
 import { tangent } from 'flo-bezier3';
-
-import { CpNode } from '../cp-node';
-import { isPosSharpCorner } from '../point-on-shape';
+import { CpNode } from '../cp-node.js';
+import { isPosSharpCorner } from '../point-on-shape.js';
 
 
 /**

package/src/get-curve-to-next.ts

@@ -1,6 +1,5 @@
-
-import { CpNode } from "./cp-node";
-import { getCurveBetween } from "./get-curve/get-curve-between";
+import { CpNode } from './cp-node.js';
+import { getCurveBetween } from './get-curve/get-curve-between.js';
 
 
 /**

package/src/get-interface-ccw.ts

@@ -0,0 +1,112 @@
+import { orient2d } from 'big-float-ts';
+import { dot } from "flo-vector2d";
+import { compareCurvaturesAtInterface } from "./compare-curvatures-at-interface.js";
+
+
+/**
+ * Returns a positive value if the second bezier (of order 1, 2 or 3) curves 
+ * anti-clockwise with respect to the first at the point where the first bezier 
+ * ends and the second one starts. Returns a negative number if the turn is
+ * clockwise. Returns 0 otherwise. 
+ * 
+ * The algorithm is a generalization of `ccw`, a.k.a `orient2d`.
+ * 
+ * The above obviously necessitates that their endpoints coincide as described.
+ * 
+ * Preconditions (for robustness):
+ * * The beziers has control points with max bit-length of 25 and bit-aligned.
+ * * The bezier does not have infinite curvature at either endpoint
+ * 
+ * This is so the vectors between control points can be 
+ * calculated exactly without resorting to adaptive infinite precision floating 
+ * point operations. Note: aligned to 'grid' here means if you bitwise-and all
+ * values together the resulting bitlength === the max bithlength of any value.
+ * 
+ * @param psI The incoming bezier that ends at the interface
+ * @param psO The outgoing bezier that starts at the interface
+ */
+// TODO - improve and make at least 46-bitlength precondition
+function getInterfaceCcw(psI: number[][], psO: number[][]) {
+    let lenI = psI.length;
+
+    // second last control point of incoming curve
+    let p0 = psI[lenI-2];  
+    // last control point of incoming curve / first control point of outgoing
+    let p1 = psO[0];
+    // second control point of outgoing curve
+    let p2 = psO[1];
+
+    /*
+    if (typeof _bez_debug_ !== 'undefined') {
+        let maxBitLength = 25;
+        let p1_ = psI[lenI-1];
+        // ---- precondition: does endpoints coincide
+        if (p1_[0] !== p1[0] || p1_[1] !== p1[1]) {
+            throw new Error('Curve endpoints must coincide.');
+        }
+        // ---- precondition: are coordinates grid-aligned
+        // Get all coordinate values into an array
+        let xs: number[] = [];
+        [psI, psO].forEach(ps => ps.forEach(p => p.forEach(x => {
+            xs.push(x); 
+        })));
+        
+        let msb = xs.reduce((prevX, x) => Math.max(prevX, msbExponent(x)), Number.NEGATIVE_INFINITY);
+        let lsb = xs.reduce((prevX, x) => Math.min(prevX, lsbExponent(x)), Number.POSITIVE_INFINITY);
+        let bitlengthAll = msb - lsb + 1;
+        if (bitlengthAll > maxBitLength) {
+            throw new Error(
+                `Curve control point coordinates must be bit-aligned and <= ${maxBitLength}. bitlength === ${bitlengthAll}, coordinates: ${xs}`
+            );
+        }
+    }
+    */
+
+    // Max one bit can be added in the calculations below due to bit-alignment
+    let xE = p1[0] - p0[0];  // tangent x-coordinate
+	let yE = p1[1] - p0[1];  // tangent y-coordinate
+	let xS = p2[0] - p1[0];  // tangent x-coordinate
+    let yS = p2[1] - p1[1];  // tangent y-coordinate
+    
+	// If the tangent is to be found at t === 0 or t === 1 then using a basic 
+    // property of bezier curves we can find the tangents easily as below
+    
+    // (non-normalized) tangent of incoming curve at t === 1
+    let tangentAtEnd = [xE,yE];
+    // (non-normalized) tangent of outgoing curve at t === 0
+	let tangentAtStart = [xS,yS];
+
+    // The cross calculated below will have a max bitlength of 
+    // (2*(maxBitLength+1))+1 === e.g. (2*(25+1)) + 1 === 53
+    // If the preconditions are met it is exact
+    //let crossTangents = cross(tangentAtEnd, tangentAtStart);
+    
+    // The cross below is exact by adaptive infinite precision
+    let crossTangents = orient2d(p0, p1, p2);
+
+	if (crossTangents !== 0) {
+		return crossTangents;
+    } 
+    
+    // The dot calculated below will have a max bitlength of 
+    // (2*(maxBitLength+1))+1 === e.g. (2*(25+1)) + 1 === 53
+    // If the preconditions are met it is exact
+    let dotTangents = dot(tangentAtEnd, tangentAtStart);
+    if (dotTangents > 0) {
+        // Curves go in same direction at interface - neither clock or 
+        // anti-clockwise.
+        // Note: The above comment is not strictly true but as this case is not
+        // important for the algorithm we return 0
+        return 0;
+    } 
+
+    // Curves go in opposite directions at interface starting off with the exact
+    // same tangent - look now at curvature to see which has the largest 
+    // curvature so we can base the clock or anti-clockwise result on that
+    
+    // Look at curvature
+    return compareCurvaturesAtInterface(psI.slice().reverse(), psO);
+}
+
+
+export { getInterfaceCcw }

package/src/index.ts

@@ -1,52 +1,39 @@
-
-import { Mat } from './mat';
-import { Loop } from './loop';
-import { Curve } from './curve';
-import { CpNode } from './cp-node';
-import { PointOnShape, IPointOnShape } from './point-on-shape';
-import { Circle } from './circle';
-import { ContactPoint } from './contact-point';
-import { BezierPiece } from './mat/bezier-piece';
-
-import { findMats } from './find-mats';
-import { trimMat } from './mat/trim-mat';
-import { toScaleAxis } from './to-scale-axis';
-
-import { traverseEdges } from './traverse-edges';
-import { getBranches } from './get-branches';
-import { traverseVertices } from './traverse-vertices';
-
-import { Debug, enableDebugForMat } from './debug/debug';
-import { drawBranch } from './debug/functions/draw-elem/branch';
-import { drawMat } from './debug/functions/draw-elem/mat';
-
-import { IDebugElems } from './debug/debug-elem-types';
-import { TDrawElemFunctions } from './debug/functions/draw-elem/draw-elem';
-
-import { ICpNodeForDebugging } from './debug/cp-node-for-debugging';
-
-import { ITiming } from './debug/debug';
-
-import { getClosestBoundaryPoint } from 
-	'./mat/closest-boundary-point/get-closest-boundary-point';
-
 import { beziersToSvgPathStr, getPathsFromStr } from 'flo-boolean';	
-import { getShapeBounds } from './svg/get-shape-bounds';
-
-import { getBoundaryBeziersToNext } from './get-boundary-beziers-to-next';
-import { getBoundaryBezierPartsToNext } from './get-boundary-bezier-parts-to-next';
-import { getBoundaryPieceBeziers } from './mat/get-boundary-piece-beziers';
-import { simplifyMat } from './simplify-mat';
-import { simplifyMatMapOnly } from './mat/simplify-mat-map-only';
-
-import { drawElemFunctions } from './debug/functions/draw-elem/draw-elem'
 
-import { getCurveToNext } from './get-curve-to-next';
-import { getCurveBetween } from './get-curve/get-curve-between';
-import { sweepLine } from './sweep-line/sweep-line';
-import { areBoxesIntersecting } from './sweep-line/are-boxes-intersecting';
-import { getClosestSquareDistanceToRect } from './mat/geometry/get-closest-square-distance-to-rect';
-import { loopFromBeziers } from './loop';
+import { Mat } from './mat.js';
+import { Loop } from './loop.js';
+import { Curve } from './curve.js';
+import { CpNode } from './cp-node.js';
+import { PointOnShape, IPointOnShape } from './point-on-shape.js';
+import { Circle } from './circle.js';
+import { ContactPoint } from './contact-point.js';
+import { BezierPiece } from './mat/bezier-piece.js';
+import { findMats } from './find-mats.js';
+import { trimMat } from './mat/trim-mat.js';
+import { toScaleAxis } from './to-scale-axis.js';
+import { traverseEdges } from './traverse-edges.js';
+import { getBranches } from './get-branches.js';
+import { traverseVertices } from './traverse-vertices.js';
+import { Debug, enableDebugForMat } from './debug/debug.js';
+import { drawBranch } from './debug/functions/draw-elem/branch.js';
+import { drawMat } from './debug/functions/draw-elem/mat.js';
+import { IDebugElems } from './debug/debug-elem-types.js';
+import { TDrawElemFunctions } from './debug/functions/draw-elem/draw-elem.js';
+import { ICpNodeForDebugging } from './debug/cp-node-for-debugging.js';
+import { ITiming } from './debug/debug.js';
+import { getClosestBoundaryPoint } from './mat/closest-boundary-point/get-closest-boundary-point.js';
+import { getShapeBounds } from './svg/get-shape-bounds.js';
+import { getBoundaryBeziersToNext } from './get-boundary-beziers-to-next.js';
+import { getBoundaryBezierPartsToNext } from './get-boundary-bezier-parts-to-next.js';
+import { getBoundaryPieceBeziers } from './mat/get-boundary-piece-beziers.js';
+import { simplifyMat } from './simplify-mat.js';
+import { simplifyMatMapOnly } from './mat/simplify-mat-map-only.js';
+import { drawElemFunctions } from './debug/functions/draw-elem/draw-elem.js';
+import { getCurveToNext } from './get-curve-to-next.js';
+import { getCurveBetween } from './get-curve/get-curve-between.js';
+import { sweepLine } from './sweep-line/sweep-line.js';
+import { getClosestSquareDistanceToRect } from './mat/geometry/get-closest-square-distance-to-rect.js';
+import { loopFromBeziers } from './loop.js';
 
 
 export { 
@@ -96,7 +83,6 @@ export {
 	drawElemFunctions,
 
 	sweepLine,
-	areBoxesIntersecting,
 
 	getClosestSquareDistanceToRect,
 

package/src/loop/get-max-coordinate.ts

@@ -1,4 +1,3 @@
-
 const max = Math.max;
 const abs = Math.abs;
 

package/src/loop.ts

@@ -1,5 +1,4 @@
-
-import { Curve } from './curve';
+import { Curve } from './curve.js';
     
 
 /**

package/src/mat/add-to-cp-graph.ts

@@ -1,11 +1,10 @@
-
-import LlRbTree from 'flo-ll-rb-tree';
-import { Loop } from '../loop';
-import { Circle } from '../circle';
-import { ContactPoint } from '../contact-point';
-import { IPointOnShape } from '../point-on-shape';
-import { CpNode } from '../cp-node';
-import { getNeighbouringPoints } from './get-neighboring-cps';
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { Loop } from '../loop.js';
+import { Circle } from '../circle.js';
+import { ContactPoint } from '../contact-point.js';
+import { IPointOnShape } from '../point-on-shape.js';
+import { CpNode } from '../cp-node.js';
+import { getNeighbouringPoints } from './get-neighboring-cps.js';
 
 
 /**

package/src/mat/bezier-piece.ts

@@ -1,5 +1,4 @@
-
-import { Curve } from '../curve';
+import { Curve } from '../curve.js';
 
 
 /**

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

@@ -1,7 +1,9 @@
-
-import { deflateQuad, allRootsMultiWithErrBounds, RootInterval } from 'flo-poly';
-import { getTangentPolyFromPointExact, evalDeCasteljau, evaluate } from 'flo-bezier3';
-import { Curve } from "../../curve";
+// qqq import { deflateQuad, allRootsMultiWithErrBounds, RootInterval } from 'flo-poly';
+// qqq import { getTangentPolyFromPointExact, evalDeCasteljau, evaluate, getFootpointPolyExact } from 'flo-bezier3';
+import { ddDeflate, allRootsCertified, RootInterval } from 'flo-poly';
+import { evalDeCasteljau, evaluate, getFootpointPolyDd, getFootpointPolyExact } from 'flo-bezier3';
+import { Curve } from "../../curve.js";
+import { eToDd } from 'big-float-ts';
 
 
 /**
@@ -17,22 +19,22 @@ function closestPointsOnCurve(
         p: number[], 
         [tS,tE]: number[] = [0,1], 
         touchedCurve: Curve,
-        t: number) {
-
-    let poly = getTangentPolyFromPointExact(curve.ps, p);
+        t: number): {
+            p: number[];
+            t: number;
+        }[] {
 
-    if (curve === touchedCurve) {	
-        poly = deflateQuad(poly, t);
-    }
+    // qqq let poly = getTangentPolyFromPointExact(curve.ps, p);
+    const _poly = getFootpointPolyDd(curve.ps, p);
 
-    let roots: Omit<RootInterval,'multiplicity'>[] = allRootsMultiWithErrBounds(
-        poly, 
-        poly.map(c => 0),  // because all coefficients are exact
-        undefined,         // ...
-        tS,
-        tE
-    );
+    // qqq poly = deflateQuad(poly, t);
+    const poly = curve === touchedCurve
+        ? ddDeflate(_poly, t)
+        : _poly;
 
+    // let roots: Omit<RootInterval,'multiplicity'>[] = allRootsMultiWithErrBounds(
+    let roots: Omit<RootInterval,'multiplicity'>[];
+    roots = allRootsCertified(poly, tS, tE);
 
     // Also test the endpoints
     let push0 = true;

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

@@ -1,8 +1,7 @@
-
-import { BezierPiece } from "../bezier-piece";
-import { getBestDistanceSquared } from "./get-best-distance-squared";
-import { cullByLooseBoundingBox } from "./cull-by-loose-bounding-box";
-import { cullByTightBoundingBox } from "./cull-by-tight-boundary-box";
+import { BezierPiece } from '../bezier-piece.js';
+import { getBestDistanceSquared } from './get-best-distance-squared.js';
+import { cullByLooseBoundingBox } from './cull-by-loose-bounding-box.js';
+import { cullByTightBoundingBox } from './cull-by-tight-boundary-box.js';
 
 
 /**