flo-mat 2.0.4 → 3.0.0

package/src/index.ts

@@ -1,19 +1,40 @@
 import { beziersToSvgPathStr, getPathsFromStr } from 'flo-boolean';	
 
-import { Mat } from './mat.js';
-import { Loop } from './loop.js';
-import { Curve } from './curve.js';
-import { CpNode } from './cp-node.js';
-import { PointOnShape, IPointOnShape } from './point-on-shape.js';
-import { Circle } from './circle.js';
-import { ContactPoint } from './contact-point.js';
+import { Mat } from './mat/mat.js';
+import { Loop } from 'flo-boolean';
+import { Curve } from './curve/curve.js';
+import {
+	CpNode,
+	matCurveToNextVertex,
+	getChildren,
+	vertexChildren,
+	getAllOnLoop,
+	insertCpNode,
+	getCpNodesOnCircle,
+	isOnSameCircle,
+	isTerminating,
+	isFullyTerminating,
+	getFirstExit,
+	isSharp,
+	getProngCount,
+	getRealProngCount,
+	cpNodeComparator,
+	removeCpNode
+} from './cp-node/cp-node.js';
+import { createCpNode } from './cp-node/create-cp-node.js';
+import { enhanceCpNode } from './cp-node/enhance-cp-node.js';
+import { traverseCp } from './cp-node/traverse-cp.js';
+import { PointOnShape } from './point-on-shape/point-on-shape.js';
+import { createPos } from './point-on-shape/create-pos.js';
+import { Circle } from './geometry/circle.js';
+import { ContactPoint } from './contact-point/contact-point.js';
 import { BezierPiece } from './mat/bezier-piece.js';
-import { findMats } from './find-mats.js';
+import { findMats } from './find-mat/find-mats.js';
 import { trimMat } from './mat/trim-mat.js';
-import { toScaleAxis } from './to-scale-axis.js';
-import { traverseEdges } from './traverse-edges.js';
-import { getBranches } from './get-branches.js';
-import { traverseVertices } from './traverse-vertices.js';
+import { toScaleAxis } from './sat/to-scale-axis.js';
+import { traverseEdges } from './cp-node/traverse-edges.js';
+import { getBranches } from './mat/get-branches.js';
+import { traverseVertices } from './cp-node/traverse-vertices.js';
 import { Debug, enableDebugForMat } from './debug/debug.js';
 import { drawBranch } from './debug/functions/draw-elem/branch.js';
 import { drawMat } from './debug/functions/draw-elem/mat.js';
@@ -21,26 +42,26 @@ import { IDebugElems } from './debug/debug-elem-types.js';
 import { TDrawElemFunctions } from './debug/functions/draw-elem/draw-elem.js';
 import { ICpNodeForDebugging } from './debug/cp-node-for-debugging.js';
 import { ITiming } from './debug/debug.js';
-import { getClosestBoundaryPoint } from './mat/closest-boundary-point/get-closest-boundary-point.js';
+import { getClosestBoundaryPointCertified } from './closest-boundary-point/get-closest-boundary-point-certified.js';
 import { getShapeBounds } from './svg/get-shape-bounds.js';
-import { getBoundaryBeziersToNext } from './get-boundary-beziers-to-next.js';
-import { getBoundaryBezierPartsToNext } from './get-boundary-bezier-parts-to-next.js';
+import { getBoundaryBeziersToNext } from './cp-node/get-boundary-beziers-to-next.js';
+import { getBoundaryBezierPartsToNext } from './cp-node/get-boundary-bezier-parts-to-next.js';
 import { getBoundaryPieceBeziers } from './mat/get-boundary-piece-beziers.js';
-import { simplifyMat } from './simplify-mat.js';
+import { simplifyMat } from './mat/simplify-mat.js';
 import { simplifyMatMapOnly } from './mat/simplify-mat-map-only.js';
 import { drawElemFunctions } from './debug/functions/draw-elem/draw-elem.js';
-import { getCurveToNext } from './get-curve-to-next.js';
+import { getCurveToNext } from './cp-node/get-curve-to-next.js';
 import { getCurveBetween } from './get-curve/get-curve-between.js';
 import { sweepLine } from './sweep-line/sweep-line.js';
-import { getClosestSquareDistanceToRect } from './mat/geometry/get-closest-square-distance-to-rect.js';
-import { loopFromBeziers } from './loop.js';
+import { getClosestSquareDistanceToRect } from './geometry/get-closest-square-distance-to-rect.js';
+import { loopFromBeziers } from 'flo-boolean';
 
 
 export { 
 	// Data structures
 	Mat,
 	PointOnShape,
-	IPointOnShape,
+	// IPointOnShape,
 	Curve,
 	Loop,
 	CpNode,
@@ -60,6 +81,27 @@ export {
 	simplifyMat,
 	simplifyMatMapOnly,
 
+	// CpNode
+	createCpNode,
+	matCurveToNextVertex,
+	getChildren,
+	vertexChildren,
+	getAllOnLoop,
+	insertCpNode,
+	getCpNodesOnCircle,
+	isOnSameCircle,
+	isTerminating,
+	isFullyTerminating,
+	getFirstExit,
+	isSharp,
+	getProngCount,
+	getRealProngCount,
+	cpNodeComparator,
+	removeCpNode,
+	enhanceCpNode,
+	traverseCp,
+
+
 	// SVG functions
 	beziersToSvgPathStr,
 	getPathsFromStr,
@@ -68,8 +110,9 @@ export {
 	drawMat,
 
 	// Other functions
-	getClosestBoundaryPoint, 
+	getClosestBoundaryPointCertified,
 	getCurveToNext, getCurveBetween,
+	createPos,
 
 	// Debug
 	Debug,

package/src/loop/get-max-coordinate.ts

@@ -3,7 +3,7 @@ const abs = Math.abs;
 
 
 /**
- * @hidden
+ * @internal
  * Returns the maximum control point coordinate value (x or y) within any loop.
  * @param loops The array of loops
  */

package/src/mat/add-to-cp-graph.ts

@@ -1,30 +1,31 @@
 import { LlRbTree } from 'flo-ll-rb-tree';
-import { Loop } from '../loop.js';
-import { Circle } from '../circle.js';
-import { ContactPoint } from '../contact-point.js';
-import { IPointOnShape } from '../point-on-shape.js';
-import { CpNode } from '../cp-node.js';
+import { Loop } from 'flo-boolean';
+import { Circle } from '../geometry/circle.js';
+import { ContactPoint } from '../contact-point/contact-point.js';
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import { CpNode, insertCpNode } from '../cp-node/cp-node.js';
 import { getNeighbouringPoints } from './get-neighboring-cps.js';
 
 
 /**
- * @hidden
+ * @internal
+ *
  * @param circle 
  * @param orders 
  * @param cpTrees 
  * @param poss 
  * @param neighbors 
- * @hidden
+ * @internal
  */
 function addToCpGraph(
         circle  : Circle, 
         orders  : number[],
         cpTrees : Map<Loop,LlRbTree<CpNode>>,
-        poss    : IPointOnShape[],
+        poss    : PointOnShape[],
         neighbors? : CpNode[][]) {
 
     const newCps = poss.map((pos, i) => {
-        const cpTree = cpTrees.get(pos.curve.loop);
+        const cpTree = cpTrees.get(pos.curve.loop)!;
 
         const newCp_: ContactPoint = { pointOnShape: pos, circle, order: orders[i], order2: 0 };
 
@@ -32,7 +33,7 @@ function addToCpGraph(
             ? neighbors[i]
             : getNeighbouringPoints(cpTree, pos, orders[i], 0);
 
-        const newCp = CpNode.insert(
+        const newCp = insertCpNode(
                 false,
                 false,
                 cpTree,
@@ -45,12 +46,14 @@ function addToCpGraph(
 
     const len = poss.length;
     for (let i=0; i<len; i++) {
-        const indxPrev = i === 0     ? len-1 : i-1;
-        const indxNext = i === len-1 ? 0     : i+1;
+        const indxPrev = i === 0     ? len - 1 : i - 1;
+        const indxNext = i === len - 1 ? 0     : i + 1;
 
         newCps[i].prevOnCircle = newCps[indxPrev];
         newCps[i].nextOnCircle = newCps[indxNext];
     }
+
+    return newCps;
 }
 
 

package/src/mat/bezier-piece.ts

@@ -1,8 +1,8 @@
-import { Curve } from '../curve.js';
+import { Curve } from '../curve/curve.js';
 
 
 /**
- * @hidden
+ * @internal
  * Represents a part of a bezier within the shape boundary.
  */
 interface BezierPiece {

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

@@ -1,14 +1,17 @@
-import { CpNode } from '../cp-node.js';
-import { ContactPoint, compareCps } from '../contact-point.js';
+import { CpNode } from '../cp-node/cp-node.js';
+import { ContactPoint, compareCps } from '../contact-point/contact-point.js';
 
 
 /**
- * @hidden
+ * @internal
+ * 
  * 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/create-new-cp-tree.ts

@@ -1,25 +1,22 @@
 import { LlRbTree } from 'flo-ll-rb-tree';
-import { CpNode } from '../cp-node.js';
-import { Loop } from '../loop.js';
+import { CpNode, cpNodeComparator, getAllOnLoop } from '../cp-node/cp-node.js';
+import { Loop } from 'flo-boolean';
 
 
 /**
- * @hidden
+ * @internal
  * @param cpNode 
  */
 function createNewCpTree(cpNode: CpNode) {
 	const newCpTrees: Map<Loop,LlRbTree<CpNode>> = new Map();
 
-	const cps = cpNode.getAllOnLoop();
+	getAllOnLoop(cpNode).forEach(createNewCpTree_);
 
-	cps.forEach(f);
-
-	function f(cpNode: CpNode) {
+	function createNewCpTree_(cpNode: CpNode) {
 		const loop = cpNode.cp.pointOnShape.curve.loop;
 		let cpTree = newCpTrees.get(loop);
 		if (!cpTree) { 
-			// qqq cpTree = new LlRbTree(CpNode.comparator, [], true); 
-			cpTree = new LlRbTree(CpNode.comparator, false); 
+			cpTree = new LlRbTree(cpNodeComparator, false); 
 			newCpTrees.set(loop, cpTree);
 		}
 		cpTree.insert(cpNode);

package/src/mat/elem-type-two-prong.ts

@@ -1,5 +1,5 @@
 
-/** @hidden */
+/** @internal */
 type ElemType_TwoProng =
     | 'twoProng_regular'
     | 'twoProng_holeClosing';

package/src/mat/get-boundary-piece-beziers.ts

@@ -1,12 +1,12 @@
-import { CpNode } from '../cp-node.js';
-import { Curve } from '../curve.js';
+import { CpNode } from '../cp-node/cp-node.js';
+import { Curve } from '../curve/curve.js';
 import { BezierPiece } from './bezier-piece.js';
-import { isPosQuiteSharpCorner } from '../point-on-shape.js';
-import { compareCps } from '../contact-point.js';
+import { isPosQuiteSharpCorner } from '../point-on-shape/is-pos-quite-sharp-corner.js';
+import { compareCps } from '../contact-point/contact-point.js';
 
 
 /**
- * @hidden
+ * @internal
  * Returns the ordered cubic bezier pieces (i.e a bezier with a t range) 
  * from the given boundary piece.
  * @param cpNodes - An ordered pair that represents the start and end points of 
@@ -16,7 +16,7 @@ function getBoundaryPieceBeziers(cpNodes: CpNode[]): BezierPiece[] {
     let cpThis = cpNodes[0]; 
     const cpEnd  = cpNodes[1];
     
-    const bezierPieces = [];
+    const bezierPieces: BezierPiece[] = [];
 
     // As opposed to going around the circle and taking the last exit
     let goStraight = true; 
@@ -69,7 +69,7 @@ function getBoundaryPieceBeziers(cpNodes: CpNode[]): BezierPiece[] {
 
 
 /**
- * @hidden
+ * @internal
  * Adds pieces of skipped beziers
  */
 function addSkippedBeziers(

package/src/{get-branches.ts → mat/get-branches.ts}

@@ -1,10 +1,10 @@
 import { tangent } from 'flo-bezier3';
 import { cross, toUnitVector } from 'flo-vector2d';
-import { CpNode } from './cp-node.js';
-import { getCurveToNext } from './get-curve-to-next.js';
+import { CpNode, getChildren, isFullyTerminating, isTerminating } from '../cp-node/cp-node.js';
+import { getCurveToNext } from '../cp-node/get-curve-to-next.js';
 
 
-/** @hidden */
+/** @internal */
 const defaultTolerance = 1; // 1 degree
 
 
@@ -22,7 +22,7 @@ function getBranches(
 		tolerance: number = defaultTolerance): CpNode[][] {
 
 	// Start from a leaf
-	while (!cpNode.isFullyTerminating()) {
+	while (!isFullyTerminating(cpNode)) {
 		cpNode = cpNode.next;
 	}
 
@@ -34,12 +34,12 @@ function getBranches(
 
 	let branchCpNodes: CpNode[] = [];
 	while (cps.length) {
-		const cp = cps.pop();
+		const cp = cps.pop()!;
 		branchCpNodes.push(cp);
 
-		let children = cp.getChildren();
+		let children = getChildren(cp);
 
-		if (cp.isFullyTerminating()) {
+		if (isFullyTerminating(cp)) {
 			if (branchCpNodes.length > 1) {
 				branches.push(branchCpNodes);
 			}
@@ -52,7 +52,7 @@ function getBranches(
 			continue;
 		}
 
-		children = children.filter(cpNode => !cpNode.isTerminating());
+		children = children.filter(cpNode => !isTerminating(cpNode));
 
 		if (children.length === 0) {
 			branches.push(branchCpNodes);

package/src/mat/get-edges-as-array.ts

@@ -1,5 +1,5 @@
-import { CpNode } from '../cp-node.js';
-import { traverseEdges } from '../traverse-edges.js';
+import { CpNode } from '../cp-node/cp-node.js';
+import { traverseEdges } from '../cp-node/traverse-edges.js';
 
 
 /** @internal */

package/src/mat/get-largest-three-prong.ts

@@ -1,13 +1,13 @@
-import { CpNode } from '../cp-node.js';
+import { CpNode } from '../cp-node/cp-node.js';
 
 
-/** @hidden */
+/** @internal */
 function getLargestThreeProng(cpNodes: CpNode[]) {
 	return cpNodes.reduce(function(maxCpNode: CpNode, cpNode: CpNode) {
 		return cpNode === undefined || maxCpNode.cp.circle.radius >= cpNode.cp.circle.radius
 			? maxCpNode
 			: cpNode;
-	}, undefined);
+	}, undefined!);
 }
 
 

package/src/mat/get-largest-vertex.ts

@@ -1,7 +1,7 @@
-import { CpNode } from '../cp-node.js';
+import { CpNode } from '../cp-node/cp-node.js';
 
 
-/** @hidden */
+/** @internal */
 function getLargestVertex(cpNodes: CpNode[]) {
 	return cpNodes.reduce(function(maxCpNode: CpNode, cpNode: CpNode) {
 		return maxCpNode.cp.circle.radius >= cpNode.cp.circle.radius

package/src/mat/get-neighboring-cps.ts

@@ -1,12 +1,15 @@
 import { LlRbTree } from 'flo-ll-rb-tree';
-import { IPointOnShape } from '../point-on-shape.js';
-import { CpNode } from '../cp-node.js';
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import { CpNode } from '../cp-node/cp-node.js';
+import { createCpNode } from '../cp-node/create-cp-node.js';
 
 
 /**
- * @hidden
+ * @internal
+ * 
  * Returns the boundary piece that starts at the immediate previous point on the 
  * shape and ends at the immediate next point.  
+ * 
  * @param cpTree 
  * @param pos 
  * @param order 
@@ -14,17 +17,17 @@ import { CpNode } from '../cp-node.js';
  */
 function getNeighbouringPoints(
         cpTree: LlRbTree<CpNode>,
-        pos: IPointOnShape,
+        pos: PointOnShape,
         order: number,
         order2: number) {
 
     const cps = cpTree.findBounds(
-        new CpNode({ pointOnShape: pos, circle: undefined, order, order2 }, false, false)
+        createCpNode({ pointOnShape: pos, circle: undefined!, order, order2 }, false, false)
     );
 
     if (!cps[0] && !cps[1]) { 
         // The tree is still empty
-        return [undefined, undefined] as CpNode[];
+        return [undefined!, undefined!] as CpNode[];
     }
 
     if (!cps[0] || !cps[1]) { 

package/src/mat/get-two-prong-type.ts

@@ -2,7 +2,7 @@ import { TwoProngForDebugging } from '../debug/two-prong-for-debugging.js';
 import { ElemType_TwoProng } from './elem-type-two-prong.js';
 
 
-/** @hidden */
+/** @internal */
 function getTwoProngType(e: TwoProngForDebugging): ElemType_TwoProng {
 	if (e.holeClosing) { return 'twoProng_holeClosing' }
 	

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

@@ -1,25 +1,22 @@
 import { LlRbTree } from 'flo-ll-rb-tree';
 import { distanceBetween, toUnitVector, fromTo, dot } from 'flo-vector2d';
-import { Loop } from '../loop.js';
-import { CpNode } from '../cp-node.js';
-import { IPointOnShape } from '../point-on-shape.js';
-import { Circle } from '../circle.js';
+import { Loop } from 'flo-boolean';
+import { CpNode } from '../cp-node/cp-node.js';
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import { Circle } from '../geometry/circle.js';
 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)   
+/** @internal */
+const DEGREES = 3;
+const ANGLE_THRESHOLD = Math.cos(DEGREES * (Math.PI / 180));
 
 
 /**
- * @hidden
- * Returns true if another CpNode is close to the given implied (via pos, order
- * and order2) CpNode.
+ * @internal
+ * If another `CpNode` is close by (to the given implied (via `pos`, `order` and
+ * `order2`) then return it, else return `undefined`.
+ * 
  * @param cpTrees 
  * @param pos 
  * @param circle 
@@ -31,53 +28,41 @@ const ANGLE_THRESHOLD = 0.9986295347545738; // === Math.cos(3  degrees)
  */
 function isAnotherCpCloseby(
         cpTrees: Map<Loop,LlRbTree<CpNode>>,
-        pos: IPointOnShape,
+        pos: PointOnShape,
         circle: Circle,
         order: number,
         order2: number,
-        extreme: number,
-        color: string): boolean {
+        extreme: number): CpNode | undefined {
 
-    //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 DISTANCE_THRESHOLD = extreme * 2e-14;
+    const DISTANCE_THRESHOLD_2 = DISTANCE_THRESHOLD * 2e-2;
 
-    const cpTree = cpTrees.get(pos.curve.loop);
+    const cpTree = cpTrees.get(pos.curve.loop)!;
     const cpNodes = getNeighbouringPoints(cpTree, pos, order, order2);
-    if (!cpNodes[0]) { return false }
+    if (!cpNodes[0]) { return undefined; }
 
+    const { p, t } = pos;
     for (const cpNode of cpNodes) {
         const pos2 = cpNode.cp.pointOnShape;
-        const p1 = pos.p;
         const p2 = pos2.p;
-        
-        if (distanceBetween(p1,p2) > DISTANCE_THRESHOLD) {
+        const d = distanceBetween(p,p2);
+        if (d > DISTANCE_THRESHOLD) {
             continue;
         }
 
-        const v1 = toUnitVector(fromTo(
-            cpNode.cp.pointOnShape.p, 
-            cpNode.cp.circle.center
-        ));
-        const v2 = toUnitVector(fromTo(
-            p1,
-            circle.center
-        ));
+        const v1 = toUnitVector(fromTo(p2, cpNode.cp.circle.center));
+        const v2 = toUnitVector(fromTo(p, circle.center));
         const cosTheta = dot(v1,v2);
-                            
-        if (cosTheta > ANGLE_THRESHOLD) {
-            //console.log(`%c${cosTheta} - ${distanceBetween(p1,p2)}`, `color: ${color}`);
-            return true;
+
+        if (cosTheta > ANGLE_THRESHOLD ||
+            (d < DISTANCE_THRESHOLD_2 && t !== 0 && t !== 1)) {
+
+            // console.log(d, DISTANCE_THRESHOLD2)
+            return cpNode;
         }
     }
 
-    return false;
+    return undefined;
 }
 
 

package/src/{mat.ts → mat/mat.ts}

@@ -1,6 +1,6 @@
 import { LlRbTree } from 'flo-ll-rb-tree';
-import { CpNode } from './cp-node.js';
-import { Loop   } from './loop.js';
+import { CpNode } from '../cp-node/cp-node.js';
+import { Loop } from 'flo-boolean';
 
 
 /**

package/src/mat/simplify-mat-map-only.ts

@@ -1,7 +1,7 @@
 import { closestPointOnBezier, hausdorffDistance, toCubic } from 'flo-bezier3';
-import { CpNode } from '../cp-node.js';
-import { getBranches } from '../get-branches.js';
-import { getCurveToNext } from '../get-curve-to-next.js';
+import { CpNode, isTerminating } from '../cp-node/cp-node.js';
+import { getBranches } from './get-branches.js';
+import { getCurveToNext } from '../cp-node/get-curve-to-next.js';
 import { getCurveBetween } from '../get-curve/get-curve-between.js';
 
 
@@ -28,7 +28,7 @@ function simplifyMatMapOnly(
     const simpleMap: Map<CpNode, { ps: number[][], ts: number[] }> = new Map();
 
     // Start from a leaf
-    while (!cpNode.isTerminating()) {
+    while (!isTerminating(cpNode)) {
         cpNode = cpNode.next;
     }
 
@@ -56,7 +56,7 @@ function simplifyMatMapOnly(
                 }
             }
 
-            if (i+1 === j) { 
+            if (i + 1 === j) { 
                 // no simplification occured
             } else {
                 const branStart = branch[i];

package/src/{simplify-mat.ts → mat/simplify-mat.ts}

@@ -1,8 +1,8 @@
 import { hausdorffDistance } from 'flo-bezier3';
-import { CpNode } from './cp-node.js';
+import { CpNode, getCpNodesOnCircle, isTerminating, removeCpNode } from '../cp-node/cp-node.js';
 import { getBranches } from './get-branches.js';
-import { getCurveToNext } from './get-curve-to-next.js';
-import { getCurveBetween } from './get-curve/get-curve-between.js';
+import { getCurveToNext } from '../cp-node/get-curve-to-next.js';
+import { getCurveBetween } from '../get-curve/get-curve-between.js';
 import { Mat } from './mat.js';
 
 
@@ -13,11 +13,9 @@ import { Mat } from './mat.js';
  * @param anlgeTolerance Tolerance given as the degrees difference of the unit 
  * direction vectors at the interface between curves. A tolerance of zero means
  * perfect smoothness is required - defaults to 15.
- * TODO - the next two params are wrong??
- * @param hausdorffTolerance The approximate maximum Hausdorff Distance tolerance -
- * defaults to 0.1
- * @param maxIterations The spacing on the curves used to calculate the Hausdorff
- * Distance - defaults to 1
+  * @param hausdorffTolerance The approximate maximum Hausdorff Distance tolerance -
+ * defaults to `2**-3`
+ * @param maxIterations The max iterations, defaults to `50`
  */
 function simplifyMat(
         mat: Mat,
@@ -28,7 +26,7 @@ function simplifyMat(
     let cpNode = mat.cpNode;
     
     // Start from a leaf
-    while (!cpNode.isTerminating()) { cpNode = cpNode.next; }
+    while (!isTerminating(cpNode)) { cpNode = cpNode.next; }
 
     const branches = getBranches(cpNode, anlgeTolerance);
 
@@ -62,17 +60,17 @@ function simplifyMat(
     }
 
     for (const cpNode of canDeletes) {
-        const isTerminating = cpNode.isTerminating();
-        const onCircleCount = cpNode.getCpNodesOnCircle().length;
-        if (isTerminating || onCircleCount !== 2) { 
+        const isTerminating_ = isTerminating(cpNode);
+        const onCircleCount = getCpNodesOnCircle(cpNode).length;
+        if (isTerminating_ || onCircleCount !== 2) { 
             continue; 
         }
 
-        CpNode.remove(cpNode);
+        removeCpNode(cpNode);
     }
     
     //return { cpNode, cpTrees: createNewCpTree(cpNode) }; 
-    return { cpNode, cpTrees: undefined }; 
+    return { cpNode, cpTrees: undefined! }; 
 }