flo-mat 2.0.4 → 2.0.5

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

@@ -1,9 +1,6 @@
-// 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 { evalDeCasteljau, evalDeCasteljauDd, evaluate, getFootpointPolyDd, getFootpointPolyExact } from 'flo-bezier3';
 import { Curve } from "../../curve.js";
-import { eToDd } from 'big-float-ts';
 
 
 /**
@@ -24,15 +21,12 @@ function closestPointsOnCurve(
             t: number;
         }[] {
 
-    // qqq let poly = getTangentPolyFromPointExact(curve.ps, p);
     const _poly = getFootpointPolyDd(curve.ps, p);
 
-    // qqq poly = deflateQuad(poly, t);
     const poly = curve === touchedCurve
         ? ddDeflate(_poly, t)
         : _poly;
 
-    // let roots: Omit<RootInterval,'multiplicity'>[] = allRootsMultiWithErrBounds(
     const roots: Omit<RootInterval,'multiplicity'>[] = allRootsCertified(poly, tS, tE);
 
     // Also test the endpoints
@@ -72,8 +66,18 @@ function closestPointsOnCurve(
                 ? 0
                 : tE > 1 ? 1 : (tS + tE)/2;
             // TODO - why does evalDeCasteljau not work here?
-            return { p: evaluate(curve.ps,t), t }
             //return { p: evalDeCasteljau(curve.ps,t), t }
+
+            // TODO2 - will make it slower
+            // const aa = evaluate(curve.ps,t);
+            // const bb = evalDeCasteljauDd(curve.ps,[0,t]).map(v => v[1]);
+            // if (aa[0] !== bb[0] || aa[1] !== bb[1]) {
+            //     console.log(aa);
+            //     console.log(bb);
+            // }
+            return { p: evaluate(curve.ps,t), t }
+            // return { p: evalDeCasteljauDd(curve.ps,[0,t]).map(v => v[1]), t }
+            
         }
     );
 

package/src/mat/closest-boundary-point/get-close-boundary-points.ts

@@ -69,11 +69,7 @@ function getCloseBoundaryPoints(
 		// comparing closeness!
 		const indexesToCheck: number[] = [];
 		for (let i=0; i<posInfos.length; i++) {
-			const pi = posInfos[i];
-			// Only check if they are close to the edges. Why??
-			//if (pi.pos.t < 1e-2 || 1-pi.pos.t < 1e-2) {
-				indexesToCheck.push(i);
-			//}
+			indexesToCheck.push(i);
 		}
 		const indexesToRemove: number[] = [];
 		for (let i=0; i<indexesToCheck.length; i++) {

package/src/mat/closest-boundary-point/get-closest-boundary-point-dd.ts

@@ -0,0 +1,62 @@
+import { distanceBetween, getObjClosestTo } from 'flo-vector2d';
+import { Curve } from '../../curve.js';
+import { PointOnShape, IPointOnShape } from '../../point-on-shape.js';
+import { BezierPiece  } from '../bezier-piece.js';
+import { cullBezierPieces } from './cull-bezier-pieces.js';
+import { closestPointsOnCurve } from './closest-points-on-curve.js';
+  
+
+/**
+ * @hidden
+ * Returns the closest boundary point to the given point, limited to the given 
+ * bezier pieces, including the beziers actually checked after culling.
+ * @param bezierPieces
+ * @param point
+ * @param touchedCurve
+ * @param t
+ * @param extreme
+ */
+function getClosestBoundaryPointDd(
+        bezierPieces: BezierPiece[], 
+        point: number[], 
+		touchedCurve: Curve, 
+		t: number) {
+	
+	let bestDistance = Number.POSITIVE_INFINITY;
+	let posInfo: { pos: IPointOnShape; d: number };
+	for (let i=0; i<bezierPieces.length; i++) {
+		const bezierPiece = bezierPieces[i];
+
+        const ps = closestPointsOnCurve(
+            bezierPiece.curve, 
+            point, 
+            bezierPiece.ts, 
+            touchedCurve, 
+            t
+        );
+
+		const p = getObjClosestTo(point, ps, p => p.p)
+
+		if (p === undefined) { continue; }
+
+		const d = distanceBetween(p.p, point);
+
+		let curve = bezierPiece.curve;
+		let t_= p.t;
+
+		if (d < bestDistance) {
+			if (t_ === 0) {
+				t_ = 1;
+				curve = bezierPiece.curve.prev;
+			}
+			
+			posInfo = { pos: new PointOnShape(curve, t_), d };
+			bestDistance = d;
+		}
+	}
+
+	return posInfo;
+}
+
+
+export { getClosestBoundaryPointDd };

package/src/mat/closest-boundary-point/get-closest-boundary-point.ts

@@ -29,13 +29,13 @@ function getClosestBoundaryPoint(
 	for (let i=0; i<bezierPieces.length; i++) {
 		const bezierPiece = bezierPieces[i];
 
-		const ps = closestPointsOnCurve(
-				bezierPiece.curve, 
-				point, 
-				bezierPiece.ts, 
-				touchedCurve, 
-				t
-		);
+        const ps = closestPointsOnCurve(
+            bezierPiece.curve, 
+            point, 
+            bezierPiece.ts, 
+            touchedCurve, 
+            t
+        );
 
 		const p = getObjClosestTo(point, ps, p => p.p)
 

package/src/mat/cmp-cp-on-delta.ts

@@ -4,11 +4,14 @@ import { ContactPoint, compareCps } from '../contact-point.js';
 
 /**
  * @hidden
+ * 
  * Note: For debugging only
+ * 
  * Checks the position of the ContactPoint (cp) on the boundary piece. 
  * Returns < 0 if the cp is not on δ, > 0 if it is on the boundary piece 
  * excluding the endpoints and 0 if it is on the endpoints. Also returns > 0 if
  * δ === undefined.
+ * 
  * @param δ The boundary piece
  * @param cp The contact point
  */

package/src/mat/find-mat/add-3-prong.ts

@@ -1,10 +1,14 @@
+declare const _debug_: Debug;
+
+import { Debug } from '../../debug/debug.js';
 import { LlRbTree } from 'flo-ll-rb-tree';
 import { CpNode } from '../../cp-node.js';
 import { Loop } from '../../loop.js';
 import { Circle } from '../../circle.js';
-import { IPointOnShape } from '../../point-on-shape.js';
+import { comparePoss, IPointOnShape, PointOnShape } from '../../point-on-shape.js';
 import { addToCpGraph } from '../add-to-cp-graph.js';
 import { isAnotherCpCloseby } from '../is-another-cp-closeby.js';
+import { compareCps } from '../../contact-point.js';
 
 
 /**
@@ -27,27 +31,31 @@ function add3Prong(
 	const { circle, ps: poss, δ3s } = threeProng;
 
 	// Keep for possible future debugging.	
+
 	/*
 	if (typeof _debug_ !== 'undefined') {
 		for (let i=0; i<3; i++) {
-			let cpBef = threeProng.δ3s[i][0].cp;
-			let cpAft = threeProng.δ3s[i][1].cp;
-			//let cmpBef = PointOnShape.compareInclOrder(cpBef.pointOnShape, ps[i], cpBef.order, orders[i]);
-			//let cmpAft = PointOnShape.compareInclOrder(cpAft.pointOnShape, ps[i], cpAft.order, orders[i]); 
+			const cpBef = threeProng.δ3s[i][0].cp;
+			const cpAft = threeProng.δ3s[i][1].cp;
 
-			let cmpBef = PointOnShape.compare(cpBef.pointOnShape, ps[i]);
-			let cmpAft = PointOnShape.compare(cpAft.pointOnShape, ps[i]); 
+			//let cmpBef = PointOnShape.compareInclOrder(cpBef.pointOnShape, poss[i], cpBef.order, orders[i]);
+			//let cmpAft = PointOnShape.compareInclOrder(cpAft.pointOnShape, poss[i], cpAft.order, orders[i]); 
+			const cmpBef = compareCps(cpBef, { pointOnShape: poss[i], order: orders[i], order2: 0, circle: undefined });
+			const cmpAft = compareCps(cpAft, { pointOnShape: poss[i], order: orders[i], order2: 0, circle: undefined });
+
+			// const cmpBef = comparePoss(cpBef.pointOnShape, poss[i]);
+			// const cmpAft = comparePoss(cpAft.pointOnShape, poss[i]); 
 
 			// len is used by debug functions to reference a particular 
 			// three-prong.
-			let len = _debug_.generated.elems.threeProng.length-1; 
+			const len = _debug_.generated.elems.threeProng.length-1; 
 			if (cmpBef > 0) {
 				console.log('----------------------------------------');
 				console.log(`3-prong order is wrong (bef) : i: ${i} - cmp: ${cmpBef} - n: ${len}`);
 				console.log(threeProng);
 				console.log(cpBef);
 				console.log(cpAft);
-				console.log(ps[i]);
+				console.log(poss[i]);
 			}
 			if (cmpAft < 0) {
 				console.log('----------------------------------------');
@@ -55,16 +63,18 @@ function add3Prong(
 				console.log(threeProng);
 				console.log(cpBef);
 				console.log(cpAft);
-				console.log(ps[i]);
+				console.log(poss[i]);
 			}
 		}
 	}
 	*/
 
 	// TODO - replace 1000 below with correct value
-	isAnotherCpCloseby(cpTrees, poss[0], circle, orders[0], 0, 1000, 'blue');
-	isAnotherCpCloseby(cpTrees, poss[1], circle, orders[1], 0, 1000, 'blue');
-	isAnotherCpCloseby(cpTrees, poss[2], circle, orders[2], 0, 1000, 'blue');
+	const c1 = isAnotherCpCloseby(cpTrees, poss[0], circle, orders[0], 0, 1000, 'blue');
+	const c2 = isAnotherCpCloseby(cpTrees, poss[1], circle, orders[1], 0, 1000, 'blue');
+	const c3 = isAnotherCpCloseby(cpTrees, poss[2], circle, orders[2], 0, 1000, 'blue');
+
+	// console.log(c1,c2,c3);
 
 	addToCpGraph(circle, orders, cpTrees, poss, δ3s); 
 

package/src/mat/find-mat/create-get-interesting-points-on-loop.ts

@@ -53,10 +53,11 @@ function getInterestingPointsOnLoop(
                 ...maxAbsCurvatures,
             );
 
-            let ts = splitByCurvatureAndLength(curve.ps, maxCurviness, maxLength);
-            if (ts.length === 2) {
-                ts = [0, 0.5, 1];
-            }
+            const ts = splitByCurvatureAndLength(curve.ps, maxCurviness, maxLength);
+            // if (ts.length > 10) { console.log(ts); }
+            // if (ts.length === 2) {
+            //     ts = [0, 0.5, 1];
+            // }
 
             for (let i=1; i<ts.length-1; i++) {
                 allPoints.push( new PointOnShape(curve, ts[i]) );

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

@@ -1,10 +1,10 @@
 /** @internal */
 declare const _debug_: Debug;
 
+import { Debug } from '../../../debug/debug.js';
 import { LlRbTree } from 'flo-ll-rb-tree';
 import { lineLineIntersection, distanceBetween, squaredDistanceBetween, interpolate, dot } from 'flo-vector2d';
 import { evalDeCasteljau as evalDeCasteljau_ } from 'flo-bezier3';
-import { Debug } from '../../../debug/debug.js';
 import { getClosestBoundaryPoint } from 
     '../../closest-boundary-point/get-closest-boundary-point.js';
 import { CpNode } from '../../../cp-node.js';
@@ -17,6 +17,7 @@ import { addDebugInfo } from './add-debug-info.js';
 import { TXForDebugging } from './x-for-debugging.js';
 import { cullBezierPieces } from './cull-bezier-pieces.js';
 import { findEquidistantPointOnLine } from './find-equidistant-point-on-line.js';
+import { findEquidistantPointOnLineDd } from './find-equidistant-point-on-line-dd.js';
 import { getInitialBezierPieces } from './get-initial-bezier-pieces.js';
 import { getCloseBoundaryPoints } from '../../closest-boundary-point/get-close-boundary-points.js';
 
@@ -59,9 +60,11 @@ function find2Prong(
 		k: number) {
 
 	const MAX_ITERATIONS = 25;
-	const squaredSeperationTolerance = (1e-6 * extreme)**2;
+	const squaredSeperationTolerance = (1e-5 * extreme)**2;
 	// TODO - base deltas on theory or remove
 	const oneProngTolerance = (1e-4)**2;
+	// const oneProngTolerance = (1e-5)**2;
+	// const oneProngTolerance = 0;
 	const squaredErrorTolerance = 1e-2 * squaredSeperationTolerance;
 	const maxOsculatingCircleRadiusSquared = squaredDiagonalLength;
 
@@ -82,7 +85,6 @@ function find2Prong(
 		r = maxOsculatingCircleRadiusSquared;
 	} else {
 		p = y.p;
-		//x = PointOnShape.getOsculatingCircle(maxOsculatingCircleRadiusSquared, y).center;
 		x = getOsculatingCircle(maxOsculatingCircleRadiusSquared, y).center;
 		r = squaredDistanceBetween(p,x);
 	}
@@ -107,9 +109,9 @@ function find2Prong(
 		i++
 
 		/** squared distance between source boundary point and circle center */
-		const r = squaredDistanceBetween(x, y.p);
+		const xy = squaredDistanceBetween(x, y.p);
 
-		bezierPieces_ = cullBezierPieces(bezierPieces_, x, r);
+		bezierPieces_ = cullBezierPieces(bezierPieces_, x, xy);
 
 		z = getClosestBoundaryPoint(
 			bezierPieces_,
@@ -140,17 +142,19 @@ function find2Prong(
 		}
 		
 		/** squared distance between anti-pode boundary point and circle center */
-		const d = squaredDistanceBetween(x, z.pos.p);
+		const xz = squaredDistanceBetween(x, z.pos.p);
 		//if (i === 1 && d*oneProngTolerance >= r) {
-		if (i === 1 && r < d+oneProngTolerance) {
+		if (i === 1 && xy < xz+oneProngTolerance) {
 			// It is a 1-prong.
+			// TODO2 - below line was removed (maybe)
 			add1Prong(Math.sqrt(maxOsculatingCircleRadiusSquared), cpTrees, y); 
 			return undefined; 
 		}
 		
 		// TODO - squaredSeperationTolerance should in future be replaced with
 		// a relative error, i.e. distance between y (or z) / length(y (or z)).
-		if (!isHoleClosing && squaredDistanceBetween(y.p, z.pos.p) <= squaredSeperationTolerance) {
+		const yz = squaredDistanceBetween(y.p, z.pos.p);
+		if (!isHoleClosing && yz <= squaredSeperationTolerance) {
 			if (typeof _debug_ !== 'undefined') {
 				/*
 				let elems = _debug_.generated.elems;
@@ -174,9 +178,10 @@ function find2Prong(
 
 		// Find the point on the line connecting y with x that is  
 		// equidistant from y and z. This will be our next x.
+		// const nextX = findEquidistantPointOnLineDd(x, y.p, z.pos.p);
 		const nextX = findEquidistantPointOnLine(x, y.p, z.pos.p);
-		
 		const squaredError = squaredDistanceBetween(x, nextX);
+		// const squaredError = Math.abs(xy - xz);
 		
 		x = nextX;
 
@@ -189,6 +194,32 @@ function find2Prong(
 		}
 	} while (done < 1);
 
+
+	/************************************************************************ */
+	/* Do one more double-double precision iteration
+	/************************************************************************ */
+	/*
+	z = getClosestBoundaryPoint(
+		bezierPieces_, x, y.curve, y.t
+	);
+
+	if (z === undefined) {
+		failed = true;
+	}
+	
+	if (typeof _debug_ !== 'undefined') { 
+		xs.push({ x, y, z: z.pos, t: y.t });	
+	}
+	
+	if (!isHoleClosing && squaredDistanceBetween(y.p, z.pos.p) <= squaredSeperationTolerance) {
+		failed = true;
+	} else {
+		x = findEquidistantPointOnLineDd(x, y.p, z.pos.p);
+	}
+	/************************************************************************ */
+	/************************************************************************ */
+
+
 	// TODO - Optimization: only do this if second closest point is within the
 	// tolerance which can be checked in getClosestBoundaryPoint algorithm
 	let zs: { pos: IPointOnShape; d: number; }[] = [];
@@ -211,6 +242,10 @@ function find2Prong(
 		circle = { center: x, radius: distanceBetween(x, z.pos.p) };
 	}
 
+
+	// TODO2
+	// if (Math.random() > 0.8 && !isHoleClosing) { return undefined; }
+
 	if (typeof _debug_ !== 'undefined' && !failed) { 
 		xs.push({ x, y, z: z.pos, t: y.t });
 		addDebugInfo(bezierPieces, failed, y, circle, z.pos, δ, xs, isHoleClosing);

package/src/mat/find-mat/find-2-prong/find-equidistant-point-on-line-dd.ts

@@ -0,0 +1,79 @@
+import {
+	twoDiff, twoSum, twoProduct, doubleDivDouble, ddDivDd,
+	ddAddDd, ddDiffDd, ddMultDd, ddMultBy2, ddMultDouble1
+} from "double-double";
+
+
+const { abs } = Math;
+
+const td = twoDiff;
+const ts = twoSum;
+const tp = twoProduct;
+
+
+
+/**
+ * @hidden
+ * @param x
+ * @param y
+ * @param z
+ * @returns The point on the line from y to x that is equidistant from y and z. 
+ */
+function findEquidistantPointOnLineDd(x: number[], y: number[], z: number[]) {
+	// Some basic algebra (not shown) finds the required point.
+	
+	// Swap axes if x and y are more aligned to y-axis than to x-axis.
+	// TODO2 - changed
+	// const swapAxes = abs((x[1] - y[1]) / (x[0] - y[0])) > 1;
+	const swapAxes = abs(x[1] - y[1]) > abs(x[0] - y[0]);
+	
+	// Cache
+	let x1: number;
+	let x2: number;
+	let y1: number;
+	let y2: number;
+	let z1: number;
+	let z2: number;
+	
+	if (swapAxes) {
+		x1 = x[1];	x2 = x[0];
+		y1 = y[1];	y2 = y[0];
+		z1 = z[1];	z2 = z[0];	
+	} else {
+		x1 = x[0];	x2 = x[1];
+		y1 = y[0];	y2 = y[1];
+		z1 = z[0];	z2 = z[1];
+	}
+	
+	// a <= 1 (due to swapped axes)
+	// const a = (x2 - y2) / (x1 - y1); 
+	// const b = y2 - a*y1;
+	// const c = (y1*y1 + y2*y2 - z1*z1 - z2*z2) + 2*b*(z2 - y2);
+	// const d = y1 - z1 + a*(y2 - z2);
+	// const t1 = c/(2*d);
+	// const t2 = a*t1 + b;
+
+	
+	const a = ddDivDd(td(x2,y2),td(x1,y1)); 
+	const b = ddDiffDd([0,y2], ddMultDouble1(y1,a));
+
+	 
+
+	const c = ddAddDd(
+		(ddDiffDd(
+			ddAddDd(tp(y1,y1), tp(y2,y2)),
+			ddAddDd(tp(z1,z1), tp(z2,z2))
+		)),
+		ddMultBy2(ddMultDd(b,(td(z2,y2))))
+	);
+
+	
+	const d = ddAddDd(td(y1,z1), ddMultDd(a,td(y2,z2)));
+	const t1 = ddDivDd(c,ddMultBy2(d));
+	const t2 = ddAddDd(ddMultDd(a,t1), b);
+	
+	return swapAxes ? [t2[1],t1[1]] : [t1[1],t2[1]];
+}
+
+
+export { findEquidistantPointOnLineDd }

package/src/mat/find-mat/find-3-prong/find-3-prong-for-delta3s.ts

@@ -14,7 +14,7 @@ import { getClosestBoundaryPoint } from '../../closest-boundary-point/get-closes
 import { calcInitial3ProngCenter } from './calc-initial-3-prong-center.js';
 import { getClosestPoints } from './get-closest-points.js';
 import { calcBetterX } from './calc-better-x.js';
-import { Curve, getCornerAtEnd } from '../../../curve.js';
+import { getCornerAtEnd } from '../../../curve.js';
 
 
 /** @hidden */

package/src/mat/find-mat/get-sharp-corners.ts

@@ -9,7 +9,6 @@ function getSharpCorners(possPerLoop: IPointOnShape[][]) {
         const sharpCorners = [];
         
         for (const pos of poss) {
-            //if (PointOnShape.isQuiteSharpCorner(pos)) {
             if (isPosQuiteSharpCorner(pos)) {
                 sharpCorners.push(pos);
             }

package/src/mat/is-another-cp-closeby.ts

@@ -8,12 +8,7 @@ import { getNeighbouringPoints } from './get-neighboring-cps.js';
 
 
 /** @hidden */
-//const ANGLE_THRESHOLD = Math.cos(3 * (Math.PI / 180)); // 3 degrees
-const ANGLE_THRESHOLD = 0.9986295347545738; // === Math.cos(3  degrees)
-//const ANGLE_THRESHOLD = 0.9848077530122080; // === Math.cos(10 degrees)
-//const ANGLE_THRESHOLD = 0.9998476951563913; // === Math.cos(1 degrees)
-//const ANGLE_THRESHOLD = 0.9999984769132877; // === Math.cos(0.1 degrees)   
-//const ANGLE_THRESHOLD = 0.9999999847691291  // === Math.cos(0.01 degrees)   
+const ANGLE_THRESHOLD = Math.cos(15 * (Math.PI / 180));  // 15 degrees
 
 
 /**
@@ -38,15 +33,7 @@ function isAnotherCpCloseby(
         extreme: number,
         color: string): boolean {
 
-    //console.log(extreme)
-    //const DISTANCE_THRESHOLD = extreme * 1e-1; 
-    //const DISTANCE_THRESHOLD = extreme * 1e-1;
     const DISTANCE_THRESHOLD = extreme * 1e-4;
-    //const DISTANCE_THRESHOLD = extreme * 1e-4; - was this
-    //const DISTANCE_THRESHOLD = extreme * 1e-6;
-    //const DISTANCE_THRESHOLD = extreme * 1e-12;
-    // It seems this can be zero else the ordering should be correct
-    //const DISTANCE_THRESHOLD = 0;
 
     const cpTree = cpTrees.get(pos.curve.loop);
     const cpNodes = getNeighbouringPoints(cpTree, pos, order, order2);
@@ -61,18 +48,15 @@ function isAnotherCpCloseby(
             continue;
         }
 
-        const v1 = toUnitVector(fromTo(
-            cpNode.cp.pointOnShape.p, 
-            cpNode.cp.circle.center
-        ));
-        const v2 = toUnitVector(fromTo(
-            p1,
-            circle.center
-        ));
+        // TODO2
+        return true;
+
+        const v1 = toUnitVector(fromTo(p2, cpNode.cp.circle.center));
+        const v2 = toUnitVector(fromTo(p1, circle.center));
         const cosTheta = dot(v1,v2);
-                            
+
         if (cosTheta > ANGLE_THRESHOLD) {
-            //console.log(`%c${cosTheta} - ${distanceBetween(p1,p2)}`, `color: ${color}`);
+            // console.log(`%c${cosTheta} - ${distanceBetween(p1,p2)}`, `color: ${color}`);
             return true;
         }
     }

package/src/point-on-shape.ts

@@ -3,6 +3,7 @@ import { memoize } from 'flo-memoize';
 import { curvature, evalDeCasteljau, tangent }   from 'flo-bezier3';
 import { Curve, getCornerAtEnd } from './curve.js';
 import { Circle } from './circle.js';
+import { Corner } from './mat/corner.js';
 
 
 interface IPointOnShape {
@@ -55,7 +56,7 @@ function isPosCorner(pos: IPointOnShape) {
 /**
  * @hidden
  */
-function getPosCorner(pos: IPointOnShape) {
+function getPosCorner(pos: IPointOnShape): Corner {
     return getCornerAtEnd(
         pos.t === 1 ? pos.curve : pos.curve.prev
     );

package/src/mat/closest-boundary-point/closest-point-on-curve-old.ts_

@@ -1,88 +0,0 @@
-
-import { deflate, allRootsPrecise } from 'flo-poly';
-
-import { getObjClosestTo } from 'flo-vector2d';
-import { evaluate, getTangentPolyFromPoint } from 'flo-bezier3';
-
-import { Curve } from "../../curve";
-
-
-/** @hidden */
-// TODO - remove delta
-let DELTA = 1e-11;
-
-
-/**
- * @hidden
- * @param curve The curve
- * @param p The point from which to check
- * @param tRange The allowed t range
- * @param touchedCurve The bezier on which p is located
- * @param t The t value of the bezier that locates p
- */
-function closestPointOnCurve(
-        curve: Curve, 
-        p: number[], 
-        tRange: number[] = [0,1], 
-        touchedCurve?: Curve,
-        t?: number) {
-
-    let poly = getTangentPolyFromPoint(curve.ps, p);
-
-    if (curve === touchedCurve) {		
-        poly = deflate(poly, t);
-    }
-
-    let roots = allRootsPrecise(poly, tRange[0], tRange[1]); 
-
-    // Also test the endpoints
-    let push0 = true;
-    let push1 = true;
-    if ((t === 1 && curve === touchedCurve.next) ||
-        (t === 0 && curve === touchedCurve)) {
-        push0 = false;
-    }
-    if ((t === 0 && curve === touchedCurve.prev) ||
-        (t === 1 && curve === touchedCurve)) {
-        push1 = false;
-    }
-
-    if (tRange[0] === 0) {
-        if (push0) { roots.push(0); }
-    } else if (tRange[0] === 1) {
-        if (push1) { roots.push(1); }
-    } else {
-        roots.push(tRange[0]);
-    }
-
-    if (tRange[1] === 0) {
-        if (push0) { roots.push(0); }
-    } else if (tRange[1] === 1) {
-        if (push1) { roots.push(1); }
-    } else {
-        roots.push(tRange[1]);
-    }
-
-    // This is to take care of a numerical issue - see shape p1.svg.
-    let roots_: number[] = [];
-    for (let i=0; i<roots.length; i++) {
-        let root = roots[i];
-        if (root !== 0 && root < DELTA) {
-            root = 0;
-        } else if (root !== 1 && 1-root < DELTA) {
-            root = 1;
-        }
-        roots_.push(root);
-    }
-
-    let ev = evaluate(curve.ps);
-    let ps = roots_.map(
-    //let ps = roots.map(
-        root => ({ p: ev(root), t: root })
-    );
-
-    return getObjClosestTo(p, ps, p => p.p);
-}
-
-
-export { closestPointOnCurve }