flo-mat 3.0.9 → 3.0.11

package/src/contact-point/contact-point.ts

@@ -8,14 +8,14 @@ import { Circle } from '../geometry/circle.js';
  * calculated.  
  */
 interface ContactPoint {
-	/** Identifies the point on the shape boundary. */
-	pointOnShape: PointOnShape;
-	/** The maximal disk circle touching this point. */
-	circle: Circle;
-	/** Internally used to order two points lying at the same planar point. */
-	order: number;
-	/** Internally used to order two points lying at the same planar point. */
-	order2: number;
+    /** Identifies the point on the shape boundary. */
+    pointOnShape: PointOnShape;
+    /** The maximal disk circle touching this point. */
+    circle: Circle;
+    /** Internally used to order two points lying at the same planar point. */
+    order: number;
+    /** Internally used to order two points lying at the same planar point. */
+    order2: number;
 }
 
 
@@ -28,14 +28,14 @@ interface ContactPoint {
  * @param b The second contact point.
  */
 function compareCps(a: ContactPoint, b: ContactPoint) {
-	let res = comparePoss(a.pointOnShape, b.pointOnShape);
+    let res = comparePoss(a.pointOnShape, b.pointOnShape);
 
-	if (res !== 0) { return res; }
+    if (res !== 0) { return res; }
 
-	res = a.order - b.order;
-	if (res !== 0) { return res; }
+    res = a.order - b.order;
+    if (res !== 0) { return res; }
 
-	return a.order2 - b.order2;
+    return a.order2 - b.order2;
 } 
 
 

package/src/corner/get-corner.ts

@@ -8,11 +8,11 @@ import { getInterfaceCcw } from './get-interface-ccw.js';
  * Angle in degrees to radians.
  */
 const DEGREES = {
-	//'0'    : 0.0000,
-	0.25 : 0.0050,
-	1    : 0.0167,
-	4    : 0.0698,
-	16   : 0.2756,
+    //'0'    : 0.0000,
+    0.25 : 0.0050,
+    1    : 0.0167,
+    4    : 0.0698,
+    16   : 0.2756,
 };
 
 
@@ -35,45 +35,45 @@ const DEGREE_LIMIT = DEGREES[4];
  * @param psO The outgoing bezier that starts at the corner
  */
 function getCorner(
-		psI: number[][],
-		psO: number[][]): Corner {
+        psI: number[][],
+        psO: number[][]): Corner {
 
-	// getInterfaceCcw must return a number !== 0 if psI and psO are not the
-	// same as seen as a curve extension with t ∈ [-∞,+∞]
-	const { ccw, tangentI, tangentO, dotTangents } = getInterfaceCcw(psI, psO);
-	const isSharp = ccw < 0;
-	const isDull  = ccw > 0;
+    // getInterfaceCcw must return a number !== 0 if psI and psO are not the
+    // same as seen as a curve extension with t ∈ [-∞,+∞]
+    const { ccw, tangentI, tangentO, dotTangents } = getInterfaceCcw(psI, psO);
+    const isSharp = ccw < 0;
+    const isDull  = ccw > 0;
 
-	// These use square root and are thus not exact
-	const unitTangents = [
-		toUnitVector(tangentI.map(v => v[1])),
-		toUnitVector(tangentO.map(v => v[1])),
-	];
+    // These use square root and are thus not exact
+    const unitTangents = [
+        toUnitVector(tangentI.map(v => v[1])),
+        toUnitVector(tangentO.map(v => v[1])),
+    ];
 
-	// The cross calculated below should be exact due to beziers having been
-	// normalized!
-	const crossTangents = cross(unitTangents[0], unitTangents[1]);
+    // The cross calculated below should be exact due to beziers having been
+    // normalized!
+    const crossTangents = cross(unitTangents[0], unitTangents[1]);
 
-	let isQuiteSharp: boolean; 
-	let isQuiteDull: boolean; 
-	// const dotTangents = dot(tangentAtIncoming, tangentAtOutgoing);
-	if (dotTangents > 0) {
-		// Curves go in same direction
-		isQuiteSharp = crossTangents < -DEGREE_LIMIT;
-		isQuiteDull = crossTangents > +DEGREE_LIMIT;
-	} else {
-		isQuiteSharp = isSharp;
-		isQuiteDull  = isDull;
-	}
+    let isQuiteSharp: boolean; 
+    let isQuiteDull: boolean; 
+    // const dotTangents = dot(tangentAtIncoming, tangentAtOutgoing);
+    if (dotTangents > 0) {
+        // Curves go in same direction
+        isQuiteSharp = crossTangents < -DEGREE_LIMIT;
+        isQuiteDull = crossTangents > +DEGREE_LIMIT;
+    } else {
+        isQuiteSharp = isSharp;
+        isQuiteDull  = isDull;
+    }
 
-	return {
-		tangents: unitTangents, 
-		// crossTangents, 
-		isSharp,
-		isDull, 
-		isQuiteSharp,
-		isQuiteDull
-	};
+    return {
+        tangents: unitTangents, 
+        // crossTangents, 
+        isSharp,
+        isDull, 
+        isQuiteSharp,
+        isQuiteDull
+    };
 }
 
 

package/src/corner/get-interface-ccw.ts

@@ -48,8 +48,8 @@ function getInterfaceCcw(
     const crossTangents = crossPrecise(p0,p1,p2);  // sign will be correct
 
     const xI = twoDiff(p1[0],p0[0]);  // tangent x-coordinate
-	const yI = twoDiff(p1[1],p0[1]);  // tangent y-coordinate
-	const xO = twoDiff(p2[0],p1[0]);  // tangent x-coordinate
+    const yI = twoDiff(p1[1],p0[1]);  // tangent y-coordinate
+    const xO = twoDiff(p2[0],p1[0]);  // tangent x-coordinate
     const yO = twoDiff(p2[1],p1[1]);  // tangent y-coordinate
 
     const tangentI = [xI,yI];
@@ -57,7 +57,7 @@ function getInterfaceCcw(
     const dotTangents = dotPrecise(tangentI,tangentO);
 
     if (crossTangents !== 0 || dotTangents > 0) {
-		return {
+        return {
             ccw: crossTangents,
             tangentI,
             tangentO,

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-boundary-bezier-parts-to-next.ts

@@ -13,7 +13,7 @@ import type { Curve  } from '../../curve/curve.js';
  * @param cpNode 
  */
 function getBoundaryBezierPartsToNext(
-        cpNode: CpNode): BezierPiece[] | undefined {
+        cpNode: CpNode): BezierPiece[] {
 
     const cpThis = cpNode; 
     const cpNext = cpNode.next;
@@ -27,27 +27,22 @@ function getBoundaryBezierPartsToNext(
     if (curveThis.loop !== curveNext.loop) {
         // It is a hole-closer going over to the other loop - a kind of terminal
         // CpNode.
-        return undefined;
+        // return undefined;
+        return [];
     }
     
     const bezierPieces: BezierPiece[] = [];
 
     if (curveNext === curveThis) {
         bezierPieces.push(
-            {
-                ps: posThis.curve.ps,
-                ts: [posThis.t, posNext.t]
-            }
+            { ps: posThis.curve.ps, ts: [posThis.t, posNext.t] }
         );
     } else {
         bezierPieces.push(
-            {
-                ps: posThis.curve.ps,
-                ts: [posThis.t, 1]
-            }
+            { ps: posThis.curve.ps, ts: [posThis.t, 1] }
         );
         
-        addSkippedBeziers(
+        addSkippedBezierPiecess(
             bezierPieces,
             posThis.curve,
             posNext.curve,
@@ -60,10 +55,10 @@ function getBoundaryBezierPartsToNext(
 
 
 /**
- * @internal
  * Adds pieces of skipped beziers.
+ * @internal
  */
-function addSkippedBeziers(
+function addSkippedBezierPiecess(
         bezierPieces: BezierPiece[],
         curveStart: Curve,
         curveEnd: Curve,
@@ -72,11 +67,10 @@ function addSkippedBeziers(
     let curveThis = curveStart;
     do {
         curveThis = curveThis.next;
-        const bezierPart = curveThis === curveEnd 
-            ? { ps: curveThis.ps, ts: [0, t1] }
-            : { ps: curveThis.ps, ts: [0, 1] }
-
-        bezierPieces.push(bezierPart);
+        const tEnd = curveThis === curveEnd ? t1 : 1;
+        bezierPieces.push({
+            ps: curveThis.ps, ts: [0, tEnd]
+        });
     } while (curveThis !== curveEnd);
 }