flo-mat 3.0.0 → 3.0.2

package/src/cp-node/cp-node-fs.ts

@@ -0,0 +1,234 @@
+import { compareCps } from "../contact-point/contact-point.js";
+import { CpNode } from "./cp-node.js";
+import { getHoleClosers } from "./fs/get-hole-closers.js";
+import { getSpeed } from "./fs/get-speed.js";
+import { getSmoothedSpeed$ } from "./fs/get-smoothed-speed.js";
+import { enhanceCpNode } from "./fs/enhance-cp-node.js";
+import { traverseCp } from './fs/traverse-cp.js';
+import { traverseEdges } from './fs/traverse-edges.js';
+import { traverseVertices } from './fs/traverse-vertices.js';
+import { clone } from './fs/clone.js';
+import { getBoundaryBezierPartsToNext } from './fs/get-boundary-bezier-parts-to-next.js';
+import { getBoundaryBeziersToNext } from './fs/get-boundary-beziers-to-next.js';
+import { removeVertex } from '../vertex/remove-vertex.js';
+import { getProngCount } from './fs/get-prong-count.js';
+import { getChildren } from './fs/get-children.js';
+import { getAllOnLoop } from './fs/get-all-on-loop.js';
+import { getAllOnCircle } from './fs/get-all-on-circle.js';
+import { getMatCurveToNext } from './fs/get-mat-curve-to-next.js';
+import { getFirstExit } from './fs/get-first-exit.js';
+import { getRealProngCount } from './fs/get-real-prong-count.js';
+import { isFullyTerminating } from './fs/is-fully-terminating.js';
+import { isOnSameCircle } from './fs/is-on-same-circle.js';
+import { isOneProng } from './fs/is-one-prong.js';
+import { isSharp } from './fs/is-sharp.js';
+import { isTerminating } from './fs/is-terminating.js';
+import { getVertexForwardChildren } from './fs/get-vertex-forward-children.js';
+import { isTwoProng } from './fs/is-two-prong.js';
+import { getBranch } from './fs/get-branch.js';
+import { getBranchBeziers } from './fs/get-branch-beziers.js';
+import { getSalience } from './fs/get-salience.js';
+import { getMatCurveBetween } from './fs/get-mat-curve-between.js';
+import { getEdgeDirection } from './fs/get-edge-direction.js';
+import { getBoundaryBeziersBetween } from './fs/get-boundary-beziers-between.js';
+import { getMatCurvesBetween } from './fs/get-mat-curves-between.js';
+import { getInitialDegAngleBetweenMatCurves } from "./fs/get-angle-between-mat-curves.js";
+import { getAllVertices } from "./fs/get-all-vertices.js";
+
+
+const cpNodeComparator = (a: CpNode, b: CpNode) => compareCps(a.cp, b.cp);
+
+
+const CpNodeFs = {
+	/**
+	 * 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,
+	/**
+	 * 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 
+	 * [[getMatCurveToNext]] on each returned edge).
+	 */
+	getVertexForwardChildren,
+	/**
+	 * 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.
+	 */
+	getAllOnLoop,
+	/**
+	 * 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]].
+	 */
+	getAllOnCircle,
+	/**
+	 * Returns true if the 2 given [[CpNode]]s are on the same maximal disk 
+	 * circle.
+	 * @param cpNode1 A [[CpNode]].
+	 * @param cpNode2 Another [[CpNode]]
+	 */
+	isOnSameCircle,
+	/**
+	 * 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.
+	 */
+	isTerminating,
+	/**
+	 * Like isTerminating() but only returns true if all cpNodes on the circle
+	 * (except this.prevOnCircle) is terminating.
+	 */
+	isFullyTerminating,
+	/**
+	 * Returns the first [[CpNode]] (from this one by successively applying 
+	 * .nextOnCircle) that exits the circle.
+	 */
+	getFirstExit,
+	/**
+	 * 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.
+	 */
+	isSharp,
+	/**
+	 * 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.
+	 */
+	isOneProng,
+	/**
+	 * 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.
+	 */
+	getProngCount,
+	/**
+	 * Returns the number of contact points (up to planar coordinates) on the 
+	 * maximal disk circle implied by this [[CpNode]]. 
+	 * 
+	 * See also [[getProngCount]].
+	 */
+	getRealProngCount,
+	/**
+	 * 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.
+	 */
+	cpNodeComparator,
+    /**
+     * For debugging
+     * @param cpNode 
+     */
+    enhanceCpNode,
+    /**
+     * @internal
+     * 
+     * Traverses the shape from the given `CpNode` going around the shortest path
+     * so that only a piece of the shape is traversed and returns the visited 
+     * `CpNode`s (starting from the given `CpNode`).
+     * 
+     * @param cpStart The `CpNode` from where to start the traversal.
+     */
+    traverseCp,
+    /**
+     * Traverses all edges (depth first) of the given MAT tree starting at the given 
+     * vertex (represented by a [[CpNode]]).
+     * @param cpNode Any [[CpNode]] representing the start vertex.
+     * @param traverseEdgesCallback A callback function for each CpNode representing the vertex at the 
+     * start of an edge.
+     */
+    traverseEdges,
+    /**
+     * Traverses the MAT tree and calls the given callback function for each vertex
+     * (represented by a [[CpNode]]) on the MAT.
+     * 
+     * It is usually preferable to use [[traverseEdges]] as it allows for the 
+     * traversal of all the smooth curves representing the MAT.
+     * @param cpNode Any [[CpNode]] representing the start vertex.
+     * @param traverseVerticesCallback A callback function taking a single [[CpNode]] as parameter.
+     */
+    traverseVertices,
+    /**
+     * Returns a deep clone of this [[CpNode]]. Can be used to copy the MAT 
+     * since cloning a single [[CpNode]] necessarily implies cloning all 
+     * [[CpNode]]s on the same MAT tree.
+     */
+    clone,
+    /**
+     * Returns the ordered bezier curves from this CpNode to the next CpNode 
+     * on the boundary.
+     * @param cpNode
+     */
+    getBoundaryBezierPartsToNext,
+    /**
+     * Returns the ordered bezier curves from this CpNode to the next CpNode 
+     * on the boundary.
+     * @param cpNode
+     */
+    getBoundaryBeziersToNext,
+    /**
+     * Removes a cpNode from the MAT.
+     * @param cpTree The tree graph holding the [[CpNodes]] of the MAT.
+     * @param cpNode The [[CpNode]] to remove.
+     */
+    removeVertex,
+	/**
+	 * Returns the bezier curve from the maximal disk of the given [[CpNode]] to the 
+	 * next [[CpNode]]'s maximal disk and thus directly represents a piece of the 
+	 * medial axis.
+	 * @param cpNode 
+	 */
+	getMatCurveToNext,
+	isTwoProng,
+	getBranch,
+	getBranchBeziers,
+	getSalience,
+	/**
+	 * Returns the bezier curve from the maximal disk of one [[CpNode]] to another
+	 * [[CpNode]]'s maximal disk.
+	 * @param cpNodeFrom 
+	 * @param cpNodeTo 
+	 */
+	getMatCurveBetween,
+	/**
+	 * @internal
+	 * Returns a line segment of unit length starting in the given Vertex center and
+	 * pointing in the direction of the medial axis (viewed as a rooted tree).
+	 * @param cpNode 
+	 */
+	getEdgeDirection,
+	getBoundaryBeziersBetween,
+	getMatCurvesBetween,
+	getHoleClosers,
+	getSpeed,
+	getSmoothedSpeed$,
+	getInitialDegAngleBetweenMatCurves,
+	getAllVertices
+}
+
+
+export { CpNodeFs }

package/src/cp-node/cp-node.ts

@@ -1,12 +1,4 @@
-/** @internal */
-declare const _debug_: Debug; 
-
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { Debug } from '../debug/debug.js';
-import { ContactPoint, compareCps } from '../contact-point/contact-point.js';
-import { removeCpNode } from './remove.js';
-import { getCurveToNext } from './get-curve-to-next.js';
-import { createCpNode } from './create-cp-node.js';
+import { ContactPoint } from '../contact-point/contact-point.js';
 
 
 /**
@@ -32,7 +24,7 @@ import { createCpNode } from './create-cp-node.js';
  * 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) 
+ * Call [[getMatCurveBetween]](cpNodeFrom, cpNodeTo) or getMatCurveToNext(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.
@@ -45,12 +37,12 @@ import { createCpNode } from './create-cp-node.js';
  * 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 
+ * The getter, [[getVertexForwardChildren]], 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).
+ * [[getMatCurveToNext]] 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
@@ -61,362 +53,49 @@ interface CpNode {
 	/** The shape boundary contact point, i.e. a [[CpNode]] without its edges. */
 	cp: ContactPoint;
 	/** If true, this [[CpNode]] belongs to a hole-closing maximal disk. */
-	isHoleClosing  : boolean;
+	isHoleClosing: boolean;
 	/** true if this cpNode is at a shape boundary intersection point, false otherwise */
-	isIntersection : boolean;
+	isIntersection: boolean;
 	/** The previous (going clockwise around the boundary) contact point ([[CpNode]]).*/
-	prev           : CpNode;
+	prev: CpNode;
 	/** The next (going anti-clockwise around the boundary) contact point ([[CpNode]]). */
-	next           : CpNode;
+	next: CpNode;
 	/**
 	 * The previous [[CpNode]] (going clockwise around the inscribed circle
 	 * defined by the maximal disk).
 	 */
-	prevOnCircle   : CpNode;
+	prevOnCircle: CpNode;
 	/**
 	 * The next [[CpNode]] (going anti-clockwise around 
 	 * the inscribed circle defined by the maximal disk).
 	 */
-	nextOnCircle   : CpNode;
-
+	nextOnCircle: 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).
+	 * For hole closers only - the next `CpNode` ignoring the hole closer
 	 */
-}
-
-
-/**
- * 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 
- */
-function matCurveToNextVertex(cpNode: CpNode) {
-	return getCurveToNext(cpNode);
-}
-
-
-/**
- * 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.
- */
-const cpNodeComparator = (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.
- */
-function getChildren(cpNode: CpNode) {
-	const children: CpNode[] = [];
-
-	const cp = cpNode.next;
-	let cp_ = cp;
-	do {
-		children.push(cp_); 
-		cp_ = cp_.nextOnCircle;
-	} while (cp_.nextOnCircle !== cp);
-
-	return children;
-}
-
-
-/**
- * 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).
- */
-function vertexChildren(cpNode: CpNode) {
-	if (isTerminating(cpNode)) { return []; }
-
-	const children: CpNode[] = [];
-
-	let cp_ = cpNode;
-	while (cp_ !== cpNode.prevOnCircle) {
-		if (!isTerminating(cp_)) { 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.
- */
-function getAllOnLoop(cpNode: CpNode) {
-	const cpStart = cpNode;
-	const cpNodes: CpNode[] = [cpStart];
-	let cpNode_ = cpNode.next;
-
-	while (cpNode_ !== cpStart) {
-		cpNodes.push(cpNode_);
-		cpNode_ = cpNode_.next;
-	}
-
-	return cpNodes;
-}
-
-
-/**
- * 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. 
- */
-function insertCpNode(
-		isHoleClosing: boolean,
-		isIntersection: boolean,
-		cpTree: LlRbTree<CpNode>, 
-		cp: ContactPoint, 
-		prev_: CpNode) {
-
-	// const cpNode = new CpNode(cp, isHoleClosing, isIntersection);
-	const cpNode = createCpNode(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]].
- */
-function getCpNodesOnCircle(
-		cpNode: CpNode,
-		exclThis = false) {
-
-	// const startCp = this as CpNode;
-	const startCpNode = cpNode;
-	let cpNode_ = startCpNode;
-	
-	const cpNodes: CpNode[] = [];
-	do {
-		if (exclThis) {
-			exclThis = false;
-		} else {
-			cpNodes.push(cpNode_);
-		}
-		cpNode_ = cpNode_.nextOnCircle;
-	} while (cpNode_ !== startCpNode)
-
-	return cpNodes;
-}
-
-
-/**
- * Returns true if the 2 given [[CpNode]]s are on the same maximal disk 
- * circle.
- * @param cpNode1 A [[CpNode]].
- * @param cpNode2 Another [[CpNode]]
- */
-function isOnSameCircle(cpNode1: CpNode, cpNode2: CpNode) {
-	const cpNodes = getCpNodesOnCircle(cpNode1, 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.
- */
-function isTerminating(cpNode: CpNode) {
-	// return this === this.next.prevOnCircle;
-	return cpNode === cpNode.next.prevOnCircle;
-}
-
-
-/**
- * Like isTerminating() but only returns true if all cpNodes on the circle
- * (except this.prevOnCircle) is terminating.
- */
-function isFullyTerminating(cpNode:CpNode) {
-	const otherOnCircle = getCpNodesOnCircle(cpNode.prevOnCircle, true);
-	const isFullyTerminating = otherOnCircle.every(cpn => isTerminating(cpn));
-
-	return isFullyTerminating;
-}
-
-
-/**
- * Returns the first [[CpNode]] (from this one by successively applying 
- * .nextOnCircle) that exits the circle.
- */
-function getFirstExit(cpNode: CpNode) {
-	// const startNode = this as CpNode;
-	const startNode = 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.
- */
-function isSharp(cpNode: CpNode) {
-	return cpNode.cp.circle.radius === 0;
-}
-
-
-/**
- * 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.
- */
-function getProngCount(cpNode: CpNode) {
-	// const startCp = this as CpNode;
-	const startCpNode = cpNode;
-	let cpNode_ = startCpNode;
-
-	let i = 0;
+	holeCloserNext?: CpNode | undefined;
+	/**
+	 * For hole closers only - the prev `CpNode` ignoring the hole closer
+	 */
+	holeCloserPrev?: CpNode | undefined;
 
-	do {
-		i++;
-		cpNode_ = cpNode_.nextOnCircle;
-	} while (cpNode_ !== startCpNode)
+	/** Only used in export */
+	id?: number;
 
-	return i;
-}
+	/** Only used in export */
+	children?: number[];
 
+	/** Only used in export */
+	isRoot?: boolean;
 
-/**
- * Returns the number of contact points (up to planar coordinates) on the 
- * maximal disk circle implied by this [[CpNode]]. 
- * 
- * See also [[getProngCount]].
- */
-function getRealProngCount(cpNode: CpNode) {
-	if (isOneProng(cpNode)) { return 1; }
+	/** Only used in export */
+	parentId?: number;
 
-	return getProngCount(cpNode);
+	/** Only used in export */
+	childId?: number;
 }
 
 
-/**
- * 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.
- */
-function isOneProng(cpNode: CpNode) {
-	const cp1 = cpNode;
+export { CpNode }
 
-	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]);
-}
-
-
-export {
-	CpNode,
-	matCurveToNextVertex,
-	getChildren,
-	vertexChildren,
-	getAllOnLoop,
-	insertCpNode,
-	getCpNodesOnCircle,
-	isOnSameCircle,
-	isTerminating,
-	isFullyTerminating,
-	getFirstExit,
-	isSharp,
-	isOneProng,
-	getProngCount,
-	getRealProngCount,
-	cpNodeComparator,
-	removeCpNode
-}

package/src/cp-node/fs/add-distance-from.ts

@@ -0,0 +1,50 @@
+import { getTAtLength, length } from "flo-bezier3";
+import { createPos } from "../../point-on-shape/create-pos.js";
+import { CpNode } from "../cp-node.js";
+
+
+function addDistanceFrom(
+        d: number,
+        cpNode: CpNode) {
+
+    const posS = cpNode.cp.pointOnShape;
+    const curveS = posS.curve;
+
+    let tS = posS.t;
+    let cumL = 0;
+    let dist = 0;
+    let curve = curveS;
+    let ps;
+    let dLeft = d;
+    while (true) {
+        ps = curve.ps;
+        dist = length([tS,1], ps);
+        cumL += dist;
+
+        if (cumL < d) {
+            tS = 0;
+            dLeft -= dist;
+            curve = curve.next;
+        } else {
+            break;
+        }
+    }
+
+    // const overshoot = cumL - d;
+    const lL = length([0,tS], curve.ps);
+    const l = lL + dLeft;
+
+    const t = getTAtLength(curve.ps, l);
+
+    const posE = createPos(curve, t);
+
+    return posE;
+}
+
+
+
+export { addDistanceFrom }
+
+
+// TESTING
+