flo-mat 2.0.4 → 3.0.0

package/node/traverse-vertices.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"traverse-vertices.js","sourceRoot":"","sources":["../src/traverse-vertices.ts"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,SAAS,gBAAgB,CACvB,MAAc,EACd,CAA2B;IAE5B,CAAC,CAAC,MAAM,CAAC,CAAC;IAEV,wEAAwE;IACxE,iBAAiB;IACjB,MAAM,CAAC,kBAAkB,EAAE;SACzB,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC;SACzC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC;SAC1B,OAAO,CAAC,EAAE,CAAC,CAAC;IAEd,SAAS,EAAE,CAAC,MAAc;QACzB,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC;QACrB,OAAO,GAAG,CAAC,MAAM,EAAE;YAClB,MAAM,EAAE,GAAG,GAAG,CAAC,GAAG,EAAE,CAAC;YACrB,CAAC,CAAC,EAAE,CAAC,CAAC;YACN,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,cAAc,CAAC,CAAC;SAC/B;IACF,CAAC;AACF,CAAC;AAGD,OAAO,EAAE,gBAAgB,EAAE,CAAA"}

package/src/cp-node.ts

@@ -1,388 +0,0 @@
-/** @internal */
-declare const _debug_: Debug; 
-
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { Debug } from './debug/debug.js';
-import { ContactPoint, compareCps } from './contact-point.js';
-import { removeCpNode } from './cp-node/remove.js';
-import { getCurveToNext } from './get-curve-to-next.js';
-
-
-/**
- * The primary class of the library.
- * 
- * Since the MAT is a full representation of the shape boundary an instance of
- * this class contains both the information of a boundary point and a medial 
- * axis point (and edge to the next point(s)). It also contains edges to other 
- * [[CpNode]]s which allows for traversal of the MAT and thus implictly 
- * represents the entire MAT.
- * 
- * To get the maximal disk circle (of which the center is on the medial axis)
- * use [[cp]].circle.
- * 
- * To get the boundary point, use [[cp]].pointOnShape.
- * 
- * The edge [[next]] (resp. [[prev]]) allows one to move anti-clockwise (resp.
- * clockwise) on the shape boundary to the next [[CpNode]]. This also imposes a 
- * direction of traversal of the MAT edges and vertices. 
- * 
- * The edge [[nextOnCircle]] (resp. [[prevOnCircle]]) allows one to go 
- * anti-clockwise (resp. clockwise) around the maximal disks implied by
- * the CpNode to the next maximal disk contact point. This is equivalent to 
- * following other branches on the MAT.
- * 
- * Call [[getCurveBetween]](cpNodeFrom, cpNodeTo) or getCurveToNext(cpNode) 
- * (replacing the older CpNode.[[matCurveToNextVertex]]) to get a bezier curve 
- * from the maximal disk of this [[CpNode]] to the next [[CpNode]]'s 
- * maximal disk and thus directly representing a piece of the medial axis.
- * 
- * The function, [[getChildren]], returns the children of this [[CpNode]] when
- * seen as a MAT edge. Only children in a 'forward' direction are returned. These
- * include all edges except the 'backward' edge given by [[prevOnCircle]]. For
- * [[CpNode]]s having a maximal disk with 2 contact points (a 2-prong, the usual 
- * case) the children will be the single edge [[next]]. For a 3-prong this will
- * be the edges [[next]] and [[nextOnCircle]], etc. [[getChildren]] allows one to
- * easily traverse the MAT tree - see e.g. the implementation of [[traverseEdges]].
- * 
- * The getter, [[vertexChildren]], is similar to [[getChildren]] but returns the 
- * child nodes of the tree when [[CpNode]] is seen as a MAT vertex point (as 
- * opposed to edge). In this way the dual graph of the tree can easily be 
- * traversed - see e.g. [[traverseVertices]]. Generally, however, traversing the 
- * edges is preferred as it returns the entire Medial Axis (by utilizing 
- * [[getCurveToNext]] on each returned edge).
- * 
- * It may be worth mentioning that by traversing from the CpNode by following
- * [[next]] repeatedly until one is back at the same CpNode allows one
- * to 'go around' the shape boundary and at the same time traverse the MAT twice 
- * in opposite directions.
- */
-class CpNode {
-
-	/**
-	 * Primarily for internal use.
-	 * @param cp The shape boundary contact point, i.e. a [[CpNode]] without its
-	 * edges.
-	 * @param isHoleClosing If true, this [[CpNode]] belongs to a hole-closing
-	 * maximal disk.
-	 * @param isIntersection true if this cpNode is at a shape boundary 
-	 * intersection point, false otherwise
-	 * @param prev The previous (going clockwise around the boundary) contact 
-	 * point ([[CpNode]]).
-	 * @param next The next (going anti-clockwise around the boundary) contact 
-	 * point ([[CpNode]]).
-	 * @param prevOnCircle The previous [[CpNode]] (going clockwise around 
-	 * the inscribed circle defined by the maximal disk).
-	 * @param nextOnCircle The next [[CpNode]] (going anti-clockwise around 
-	 * the inscribed circle defined by the maximal disk).
-	 */
-    constructor(
-			public readonly cp    : ContactPoint,
-			public isHoleClosing  : boolean,
-			public isIntersection : boolean,
-			public prev           : CpNode = undefined,
-			public next           : CpNode = undefined,
-			public prevOnCircle   : CpNode = undefined,
-			public nextOnCircle   : CpNode = undefined) {
-	}
-
-
-	/**
-	 * Returns the bezier curve from the maximal disk of this [[CpNode]] to the 
-	 * next [[CpNode]]'s maximal disk and thus directly represents a piece of the 
-	 * medial axis.
-	 * @deprecated Use [[getCurveToNext]] instead
-	 * @param cpNode 
-	 */
-	get matCurveToNextVertex() {
-		return getCurveToNext(this);
-	}
-
-
-	/**
-	 * Primarily for internal use.
-	 * 
-	 * Compares the order of two [[CpNode]]s. The order is cyclic and depends
-	 * on a [[CpNode]]'s relative position along the shape boundary.
-	 */
-	static comparator = 
-		(a: CpNode, b: CpNode) => compareCps(a.cp, b.cp);
-
-
-	/**
-	 * Returns the children of this [[CpNode]] when seen as a MAT edge. Only 
-	 * children in a 'forward' direction are returned. These include all edges 
-	 * except the 'backward' edge given by [[prevOnCircle]], even terminating
-	 * edges.
-	 */
-	getChildren() {
-		const children: CpNode[] = [];
-
-		const cp = this.next;
-		let cp_ = cp;
-		do {
-			children.push(cp_); 
-			cp_ = cp_.nextOnCircle;
-		} while (cp_.nextOnCircle !== cp);
-
-		return children;
-	}
-
-	static remove = removeCpNode;
-
-
-	/**
-	 * Similar to [[getChildren]] but returns the child nodes of the tree when 
-	 * [[CpNode]] is seen as a MAT vertex point (as opposed to edge). In this 
-	 * way the dual graph of the tree can easily be traversed - see e.g. 
-	 * [[traverseVertices]]. Generally, however, traversing the edges is 
-	 * preferred as it returns the entire Medial Axis (by utilizing 
-	 * [[getCurveToNext]] on each returned edge).
-	 */
-	get vertexChildren() {
-		if (this.isTerminating()) { return []; }
-
-		const cp: CpNode = this;
-		const children: CpNode[] = [];
-
-		let cp_ = cp;
-		while (cp_ !== cp.prevOnCircle) {
-			if (!cp_.isTerminating()) { children.push(cp_.next); }
-			cp_ = cp_.nextOnCircle;
-		}
-
-		return children;
-	}
-
-
-	/**
-	 * Returns all [[CpNode]]s on the MAT that this [[CpNode]] is part of 
-	 * starting from the current one and going anti-clockwise around the shape.
-	 */
-	public getAllOnLoop() {
-		const cpStart: CpNode = this;
-		const cps: CpNode[] = [cpStart];
-		let cp: CpNode = this.next;
-
-		while (cp !== cpStart) {
-			cps.push(cp);
-			cp = cp.next;
-		}
-
-		return cps;
-	}
-
-
-	/**
-	 * Primarily for internal use.
-	 * 
-	 * Insert a [[CpNode]] into the MAT tree graph after the specified point 
-	 * and returns the freshly inserted [[CpNode]].
-	 * @param isHoleClosing True if this is a hole closing contact point.
-	 * @param isIntersection True if this is a contact point at a shape boundary
-	 * intersection point.
-	 * @param cpTree The tree graph holding the [[CpNodes]] of the MAT.
-	 * @param cp [[ContactPoint]] defining the [[CpNode]].
-	 * @param prev_ Inserts the new [[CpNode]] right after this item if the 
-	 * loop is not empty, else insert the new [[CpNode]] as the only item in the 
-	 * loop. 
-	 */
-	public static insert(
-			isHoleClosing: boolean,
-			isIntersection: boolean,
-			cpTree: LlRbTree<CpNode>, 
-			cp: ContactPoint, 
-			prev_: CpNode) {
-	
-		const cpNode = new CpNode(cp, isHoleClosing, isIntersection);
-		if (typeof _debug_ !== 'undefined') {
-			_debug_.generated.elems.cpNode.push({
-				generated: _debug_.generated,
-				cpNode
-			});
-		}
-		
-		let prev;
-		let next;
-		
-		if (!prev_) {
-			prev = cpNode;
-			next = cpNode;
-		} else {
-			prev = prev_;
-			next = prev.next;
-		}
-	
-		next.prev = cpNode;
-		prev.next = cpNode;
-
-		cpNode.prev = prev;
-		cpNode.next = next;
-			
-		cpTree.insert(cpNode);
-		
-		return cpNode;
-	}
-
-
-	/**
-	 * Return this (except if exclThis is truthy) and the the other CpNodes 
-	 * around the maximal disk vertex circle in an anti-clockwise order.
-	 * @param exclThis If true the returned array does not include this 
-	 * [[CpNode]].
-	 */
-	public getCpNodesOnCircle(exclThis = false) {
-		const startCp = this as CpNode;
-		let cp = startCp;
-		
-		const cps: CpNode[] = [];
-		do {
-			if (exclThis) {
-				exclThis = false;
-			} else {
-				cps.push(cp);
-			}
-			cp = cp.nextOnCircle;
-		} while (cp !== startCp)
-
-		return cps;
-	}
-
-
-	/**
-	 * Returns true if the 2 given [[CpNode]]s are on the same maximal disk 
-	 * circle.
-	 * @param cpNode1 A [[CpNode]].
-	 * @param cpNode2 Another [[CpNode]]
-	 */
-	static isOnSameCircle(cpNode1: CpNode, cpNode2: CpNode) {
-		const cpNodes = cpNode1.getCpNodesOnCircle(true);
-
-		return cpNodes.indexOf(cpNode2) >= 0;
-	}
-
-
-	/**
-	 * Returns true if this [[CpNode]] is terminating, i.e. implies a leaf MAT 
-	 * vertex.
-	 * 
-	 * This is always the case for sharp corners and maximal disks with
-	 * a single contact point. Note, however, that even in these cases there are
-	 * two contact points stored (sitting 'on top' of each other) for the 
-	 * maximal disk. It can be seen as a limiting case of a two-prong where the
-	 * distance between two of the contact points tend to zero. One point 
-	 * (represented by a [[CpNode]] of course) will be terminating with the 
-	 * other point being its [[next]], whereas the other point will *not* be 
-	 * terminating and 'points' back into the shape.
-	 */
-	public isTerminating() {
-		return this === this.next.prevOnCircle;
-	}
-
-
-	/**
-	 * Like isTerminating() but only returns true if all cpNodes on the circle
-	 * (except this.prevOnCircle) is terminating.
-	 */
-	public isFullyTerminating() {
-		const otherOnCircle = this.prevOnCircle.getCpNodesOnCircle(true);
-		const isFullyTerminating = otherOnCircle.every(cpNode => cpNode.isTerminating());
-
-		return isFullyTerminating;
-	}
-
-
-	/**
-	 * Returns the first [[CpNode]] (from this one by successively applying 
-	 * .nextOnCircle) that exits the circle.
-	 */
-	public getFirstExit() {
-		const startNode = this as CpNode;
-		let cpNode = startNode;
-
-		while (cpNode.next === cpNode.prevOnCircle) {
-			cpNode = cpNode.next;
-
-			if (cpNode === startNode) {
-				// The very special case the MAT is a single point.
-				return undefined; 
-			}
-		}
-
-		return cpNode;
-	}
-
-
-	/**
-	 * Returns true if this [[CpNode]] represents a sharp corner, i.e. the 
-	 * limiting case of a two-prong having zero radius. 
-	 * 
-	 * Note that two [[CpNode]]s are stored for each sharp corner, one being
-	 * terminating and one not. See [[isTerminating]] for more details.
-	 */
-	public isSharp() {
-		return this.cp.circle.radius === 0;
-	}
-
-
-	/**
-	 * Returns true if this [[CpNode]]'s maximal disk has only one contact point
-	 * on the shape boundary (up to planar coordinates). These includes sharp 
-	 * corners.
-	 * 
-	 * Note, however, that two [[CpNode]]s are stored for each such point to
-	 * preserve symmetry - see [[isTerminating]] for more details.
-	 */
-	public isOneProng() {
-		const cp1 = this;
-
-		if (cp1.cp.circle.radius === 0) {
-			return true;
-		}
-
-		const cp2 = cp1.nextOnCircle;
-
-		const p1 = cp1.cp.pointOnShape.p;
-		const p2 = cp2.cp.pointOnShape.p;
-
-		return (p1[0] === p2[0] && p1[1] === p2[1]);
-	}
-
-
-	/**
-	 * Returns the number of contact points on the maximal disk circle implied
-	 * by this [[CpNode]]. 
-	 * 
-	 * Note, however, that even one-prongs and sharp corners will return 2 (see
-	 * [[isTerminating]] for more details); if this is not desired use 
-	 * [[getRealProngCount]] instead which will return 1 in these cases.
-	 */
-	public getProngCount() {
-		const startCp = this as CpNode;
-		let cp = startCp;
-
-		let i = 0;
-
-		do {
-			i++;
-			cp = cp.nextOnCircle;
-		} while (cp !== startCp)
-
-		return i;
-	}
-
-
-	/**
-	 * Returns the number of contact points (up to planar coordinates) on the 
-	 * maximal disk circle implied by this [[CpNode]]. 
-	 * 
-	 * See also [[getProngCount]].
-	 */
-	public getRealProngCount() {
-		if (this.isOneProng()) { return 1; }
-
-		return this.getProngCount();
-	}
-}
-
-
-export { CpNode }

package/src/find-mats.ts

@@ -1,171 +0,0 @@
-/** @internal */
-declare const _debug_: Debug; 
-
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { simplifyPaths } from 'flo-boolean';
-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 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 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[][][][], 
-		maxCurviness = 0.4,
-        maxLength = 4): Mat[] {
-
-	// if (typeof _debug_ !== 'undefined') { var timingStart = performance.now(); }
-
-	let maxCoordinate: number;
-	let minBezLength: number;
-	({ maxCurviness, maxLength, maxCoordinate, minBezLength } = 
-		getSizeParams(bezierLoops, maxCurviness, maxLength));
-
-	const loopss = simplifyPaths(bezierLoops, maxCoordinate);
-
-	const mats: Mat[] = [];
-	for (const loops of loopss) {
-		const mat = findMat(
-			loops, 
-			minBezLength, 
-			maxCurviness, 
-			maxLength,
-			maxCoordinate
-		);
-		if (mat) { mats.push(mat); }
-	}
-
-	return mats;
-}
-
-
-function getSizeParams(
-		bezierLoops: number[][][][],
-		maxCurviness: number,
-        maxLength: number) {
-
-	// Gather some shape metrics
-	const { maxCoordinate, maxRadius } = getLoopsMetrics(bezierLoops);
-	const expMax = Math.ceil(Math.log2(maxCoordinate));
-	const minBezLengthSigBits = 14;
-	/** 
-	 * If a curve is shorter than this value then no points on it will be 
-	 * selected for the purpose of finding the MAT.
-	 */
-	const minBezLength = 2**expMax * 2**(-minBezLengthSigBits);
-
-	// Limit the tolerance to a reasonable level
-	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; }
-	// Adjust length tolerance according to a reference max coordinate
-	const expMaxRadius = Math.ceil(Math.log2(maxRadius));
-	const maxLengthSigBits = 10;  // 1024 x 1024
-	maxLength = maxLength * (2**expMaxRadius * 2**(-maxLengthSigBits));
-
-	return { maxCurviness, maxLength, maxCoordinate, minBezLength };
-}
-
-
-/**
- * @hidden
- * 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)
- */
-function findMat(
-		loops: Loop[], 
-		minBezLength: number,
-		maxCurviness: number,
-		maxLength: number,
-		maxCoordinate: number): Mat {
-
-	addDebugInfo1(loops);
-		
-	// Gets interesting points on the shape, i.e. those that makes sense to use 
-	// for the 2-prong procedure.
-	const pointsPerLoop = loops.map(
-		getInterestingPointsOnLoop(minBezLength, maxCurviness, maxLength)
-	);
-
-	const for2ProngsPerLoop = getPotential2Prongs(pointsPerLoop);
-	const sharpCornersPerLoop = getSharpCorners(pointsPerLoop);
-
-	const cpTrees: Map<Loop, LlRbTree<CpNode>> = new Map();
-	let cpNode = createInitialCpGraph(loops, cpTrees, sharpCornersPerLoop);
-	
-	findAndAddHoleClosing2Prongs(loops, cpTrees, maxCoordinate);
-
-	if (typeof _debug_ !== 'undefined') {
-		if (_debug_.directives.stopAfterHoleClosers) {
-			return undefined;
-		}
-	}
-
-	addDebugInfo2();
-	
-	cpNode = findAndAdd2ProngsOnAllPaths(
-		loops, cpTrees, for2ProngsPerLoop, maxCoordinate
-	);
-
-	addDebugInfo3();
-
-	if (typeof _debug_ !== 'undefined') {
-		if (_debug_.directives.stopAfterTwoProngs) {
-			return undefined;
-		}
-	}
-	
-	if (cpNode === undefined) { return undefined; }
-	
-	findAndAddAll3Prongs(cpTrees, cpNode, maxCoordinate);
-
-	if (typeof _debug_ !== 'undefined') {
-		if (_debug_.directives.stopAfterThreeProngs) {
-			return undefined;
-		}
-	}
-
-	const mat = { cpNode, cpTrees };
-
-	addDebugInfo4(mat);
-	
-	return mat;
-}
-
-
-export { findMats }

package/src/loop.ts

@@ -1,56 +0,0 @@
-import { Curve } from './curve.js';
-    
-
-/**
- * Represents a two-way linked loop of [[ICurve]]s - mostly used internally to 
- * conveniently represent shape boundaries.
- */
-interface Loop {
-    /** The curves that represent the shape boundary as an array. */
-    curves: Curve[];
-    /** A pre-ordered array of bezier curves to add initially.*/
-    beziers: number[][][];
-}
-
-
-/**
- * @param beziers A pre-ordered array of bezier curves to add initially.
- */
-function loopFromBeziers(beziers: number[][][] = []) {
-    const curves: Curve[] = [];
-
-    const loop: Loop = {
-        beziers,
-        curves
-    };
-
-    if (!beziers.length) { return loop; }
-
-    let prev: Curve;
-    
-    for (let i=0; i<beziers.length; i++) {
-
-        const curve: Curve = {
-            loop,
-            ps: beziers[i],
-            prev,
-            next: undefined,
-            idx: i                
-        };
-
-        if (prev) { prev.next = curve; }
-        prev = curve; 
-
-        curves.push(curve);
-    }
-
-    // close loop
-    const lastCurve = curves[curves.length-1];
-    curves[0].prev = lastCurve;
-    lastCurve.next = curves[0];
-
-    return loop;
-}
-
-
-export { Loop, loopFromBeziers }

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 }