flo-mat 3.0.10 → 3.0.12

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

@@ -1,4 +1,3 @@
-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";
@@ -34,111 +33,109 @@ 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);
+import { cpNodeComparator } from './fs/cp-node-comparator.js';
 
 
 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,
+    /**
+     * 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 
@@ -196,38 +193,38 @@ const CpNodeFs = {
      * @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
+    /**
+     * 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
 }
 
 

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

@@ -50,37 +50,37 @@ import { ContactPoint } from '../contact-point/contact-point.js';
  * in opposite directions.
  */
 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;
-	/** true if this cpNode is at a shape boundary intersection point, false otherwise */
-	isIntersection: boolean;
-	/** The previous (going clockwise around the boundary) contact point (`CpNode`).*/
-	prev: CpNode;
-	/** The next (going anti-clockwise around the boundary) contact point (`CpNode`). */
-	next: CpNode;
-	/**
-	 * The previous `CpNode` (going clockwise around the inscribed circle
-	 * defined by the maximal disk).
-	 */
-	prevOnCircle: CpNode;
-	/**
-	 * The next `CpNode` (going anti-clockwise around 
-	 * the inscribed circle defined by the maximal disk).
-	 */
-	nextOnCircle: CpNode;
-	/**
-	 * For hole closers only - the next `CpNode` ignoring the hole closer
-	 */
-	holeCloserNext?: CpNode | undefined;
-	/**
-	 * For hole closers only - the prev `CpNode` ignoring the hole closer
-	 */
-	holeCloserPrev?: CpNode | undefined;
+    /** 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;
+    /** true if this cpNode is at a shape boundary intersection point, false otherwise */
+    isIntersection: boolean;
+    /** The previous (going clockwise around the boundary) contact point (`CpNode`).*/
+    prev: CpNode;
+    /** The next (going anti-clockwise around the boundary) contact point (`CpNode`). */
+    next: CpNode;
+    /**
+     * The previous `CpNode` (going clockwise around the inscribed circle
+     * defined by the maximal disk).
+     */
+    prevOnCircle: CpNode;
+    /**
+     * The next `CpNode` (going anti-clockwise around 
+     * the inscribed circle defined by the maximal disk).
+     */
+    nextOnCircle: CpNode;
+    /**
+     * For hole closers only - the next `CpNode` ignoring the hole closer
+     */
+    holeCloserNext?: CpNode | undefined;
+    /**
+     * For hole closers only - the prev `CpNode` ignoring the hole closer
+     */
+    holeCloserPrev?: CpNode | undefined;
 
-	/** Only used in export */
-	id: number;
+    /** Only used in export */
+    id: number;
 }
 
 

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

@@ -4,9 +4,9 @@ import { CpNode } from "../cp-node.js";
 /** @internal */
 type Edge =
     | 'prev'
-	| 'next'
-	| 'prevOnCircle'
-	| 'nextOnCircle';
+    | 'next'
+    | 'prevOnCircle'
+    | 'nextOnCircle';
 
 /** @internal */
 const EDGES: Edge[] = ['prev', 'next', 'prevOnCircle', 'nextOnCircle'];
@@ -38,7 +38,7 @@ function clone(cpNode: CpNode): CpNode {
         for (const edge of EDGES) {
             const node = cpNode[edge];
             let newNode = nodeMap.get(node);
-            if (!newNode) {	
+            if (!newNode) {    
                 newNode = cloneWithoutLinks(node);
                 
                 nodeMap.set(node, newNode);

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

@@ -0,0 +1,13 @@
+import type { CpNode } from "../cp-node.js";
+import { compareCps } from "../../contact-point/contact-point.js";
+
+
+function cpNodeComparator(
+        a: CpNode,
+        b: CpNode) {
+
+    return compareCps(a.cp, b.cp);
+}
+
+
+export { cpNodeComparator }

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

@@ -10,15 +10,15 @@ function findFirst(
 
     if (f(cpStart)) { return cpStart; }
 
-	let cpNode_ = cpNode.next;
-	while (cpNode_ !== cpStart) {
-		if (f(cpNode_)) {
+    let cpNode_ = cpNode.next;
+    while (cpNode_ !== cpStart) {
+        if (f(cpNode_)) {
             return cpNode_;
         }
-		cpNode_ = cpNode_.next;
-	}
+        cpNode_ = cpNode_.next;
+    }
 
-	return undefined;
+    return undefined;
 }
 
 

package/src/cp-node/fs/get-all-on-loop.ts

@@ -2,7 +2,7 @@ import type { CpNode } from "../cp-node.js";
 
 
 function getAllOnLoop(
-		cpNode: CpNode) {
+        cpNode: CpNode) {
 
     const cpStart = cpNode;
     const cpNodes: CpNode[] = [cpStart];

package/src/cp-node/fs/get-branch-beziers.ts

@@ -9,7 +9,7 @@ import { getMatCurveToNext } from './get-mat-curve-to-next.js';
  * @param cpNode `CpNode` representing the start vertex.
  */
 function getBranchBeziers(
-		cpNode: CpNode): number[][][] {
+        cpNode: CpNode): number[][][] {
 
     return getBranch(cpNode).map(b => getMatCurveToNext(b));
 }

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

@@ -13,7 +13,7 @@ import { isTrivial } from './is-trivial.js';
  * @param cpNode `CpNode` representing the start vertex.
  */
 function getBranch(
-		cpNode: CpNode): CpNode[] {
+        cpNode: CpNode): CpNode[] {
 
     if (isTrivial(cpNode)) {
         return [];

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

@@ -2,16 +2,16 @@ import { CpNode } from "../cp-node.js";
 
 
 function getChildren(cpNode: CpNode) {
-	const children: CpNode[] = [];
+    const children: CpNode[] = [];
 
-	const cp = cpNode.next;
-	let cpNode_ = cp;
-	do {
-		children.push(cpNode_); 
-		cpNode_ = cpNode_.nextOnCircle;
-	} while (cpNode_.nextOnCircle !== cp);
+    const cp = cpNode.next;
+    let cpNode_ = cp;
+    do {
+        children.push(cpNode_); 
+        cpNode_ = cpNode_.nextOnCircle;
+    } while (cpNode_.nextOnCircle !== cp);
 
-	return children;
+    return children;
 }
 
 

package/src/cp-node/fs/get-first-exit.ts

@@ -2,20 +2,20 @@ import { CpNode } from "../cp-node.js";
 
 
 function getFirstExit(cpNode: CpNode) {
-	// const startNode = this as CpNode;
-	const startNode = cpNode;
-	let cpNode_ = startNode;
+    // const startNode = this as CpNode;
+    const startNode = cpNode;
+    let cpNode_ = startNode;
 
-	while (cpNode_.next === cpNode_.prevOnCircle) {
-		cpNode_ = cpNode_.next;
+    while (cpNode_.next === cpNode_.prevOnCircle) {
+        cpNode_ = cpNode_.next;
 
-		if (cpNode_ === startNode) {
-			// The very special case the MAT is a single point.
-			return undefined; 
-		}
-	}
+        if (cpNode_ === startNode) {
+            // The very special case the MAT is a single point.
+            return undefined; 
+        }
+    }
 
-	return cpNode_;
+    return cpNode_;
 }
 
 

package/src/cp-node/fs/get-mat-curve-to-next.ts

@@ -4,7 +4,7 @@ import { getMatCurveBetween } from './get-mat-curve-between.js';
 
 
 function getMatCurveToNext(cpNode: CpNode) {
-	return getMatCurveBetween(cpNode, cpNode.next);
+    return getMatCurveBetween(cpNode, cpNode.next);
 }
 
 

package/src/cp-node/fs/get-mat-curves-between.ts

@@ -9,7 +9,7 @@ function getMatCurvesBetween(
     let cpNode = cpNodeS;
     const pss: number[][][] = [];
     while (cpNode !== cpNodeE) {
-	    const ps = getMatCurveBetween(cpNode, cpNode.next);
+        const ps = getMatCurveBetween(cpNode, cpNode.next);
         pss.push(ps);
 
         cpNode = cpNode.next;

package/src/cp-node/fs/get-prong-count.ts

@@ -2,16 +2,16 @@ import { CpNode } from "../cp-node.js";
 
 
 function getProngCount(cpNode: CpNode) {
-	const startCpNode = cpNode;
-	let cpNode_ = startCpNode;
+    const startCpNode = cpNode;
+    let cpNode_ = startCpNode;
 
-	let i = 0;
-	do {
-		i++;
-		cpNode_ = cpNode_.nextOnCircle;
-	} while (cpNode_ !== startCpNode)
+    let i = 0;
+    do {
+        i++;
+        cpNode_ = cpNode_.nextOnCircle;
+    } while (cpNode_ !== startCpNode)
 
-	return i;
+    return i;
 }
 
 

package/src/cp-node/fs/get-real-prong-count.ts

@@ -4,10 +4,10 @@ import { isTerminating } from "./is-terminating.js";
 
 
 function getRealProngCount(cpNode: CpNode) {
-	const nonTerminatingCpNodes = getAllOnCircle(cpNode)
-	.filter(cpNode => !isTerminating(cpNode));
+    const nonTerminatingCpNodes = getAllOnCircle(cpNode)
+    .filter(cpNode => !isTerminating(cpNode));
 
-	return nonTerminatingCpNodes.length;
+    return nonTerminatingCpNodes.length;
 }
 
 

package/src/cp-node/fs/get-vertex-forward-children.ts

@@ -3,19 +3,19 @@ import { isTerminating } from "./is-terminating.js";
 
 
 function getVertexForwardChildren(cpNode: CpNode) {
-	const children: CpNode[] = [];
+    const children: CpNode[] = [];
 
-	const cpStart = cpNode;
+    const cpStart = cpNode;
 
-	let cpNode_ = cpStart;
-	while (cpNode_ !== cpStart.prevOnCircle) {
-		if (!isTerminating(cpNode_)) {
-			children.push(cpNode_.next);
-		}
-		cpNode_ = cpNode_.nextOnCircle;
-	}
+    let cpNode_ = cpStart;
+    while (cpNode_ !== cpStart.prevOnCircle) {
+        if (!isTerminating(cpNode_)) {
+            children.push(cpNode_.next);
+        }
+        cpNode_ = cpNode_.nextOnCircle;
+    }
 
-	return children;
+    return children;
 }
 
 

package/src/cp-node/fs/is-fully-terminating.ts

@@ -1,4 +1,4 @@
-import { CpNode } from "../cp-node.js";
+import type { CpNode } from "../cp-node.js";
 import { getAllOnCircle } from "./get-all-on-circle.js";
 import { isTerminating } from "./is-terminating.js";
 
@@ -11,9 +11,9 @@ import { isTerminating } from "./is-terminating.js";
  * @param cpNode 
  */
 function isFullyTerminating(cpNode: CpNode) {
-	const otherOnCircle = getAllOnCircle(cpNode.prevOnCircle, true);
+    const otherOnCircle = getAllOnCircle(cpNode.prevOnCircle, true);
 
-	return otherOnCircle.every(isTerminating);
+    return otherOnCircle.every(isTerminating);
 }
 
 

package/src/cp-node/fs/is-one-prong.ts

@@ -3,18 +3,18 @@ import { CpNode } from "../cp-node.js";
 
 // TODO2 - remove - or replace with `getRealProngCount === 1`
 function isOneProng(cpNode: CpNode) {
-	const cp1 = cpNode;
+    const cp1 = cpNode;
 
-	if (cp1.cp.circle.radius === 0) {
-		return true;
-	}
+    if (cp1.cp.circle.radius === 0) {
+        return true;
+    }
 
-	const cp2 = cp1.nextOnCircle;
+    const cp2 = cp1.nextOnCircle;
 
-	const p1 = cp1.cp.pointOnShape.p;
-	const p2 = cp2.cp.pointOnShape.p;
+    const p1 = cp1.cp.pointOnShape.p;
+    const p2 = cp2.cp.pointOnShape.p;
 
-	return (p1[0] === p2[0] && p1[1] === p2[1]);
+    return (p1[0] === p2[0] && p1[1] === p2[1]);
 }
 
 

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

@@ -2,7 +2,7 @@ import { CpNode } from "../cp-node.js";
 
 
 function isSharp(cpNode: CpNode) {
-	return cpNode.cp.circle.radius === 0;
+    return cpNode.cp.circle.radius === 0;
 }