flo-mat 3.0.6 → 3.0.7

package/src/find-3-prong.ts/find-and-add-3-prong.ts

@@ -50,7 +50,7 @@ function findAndAdd3Prong(
 
 	const cpNodes = closeBysFor3Prong.length === 0
 		? addToCpTree(
-			true, false, circle, orders, meta.cpTrees, poss, δ3s.map(v => v[0])
+			true, false, circle, orders, meta, poss, δ3s.map(v => v[0])
 		).cpNodes
 		: [];
 

package/src/find-3-prong.ts/find-and-add-3-prongs-on-loop.ts

@@ -1,11 +1,11 @@
-import { CpNode } from '../cp-node/cp-node.js';
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { MatMeta } from '../mat/mat-meta.js';
 import { findAndAdd3Prongs } from './find-and-add-3-prongs.js';
-import { MatMeta } from '../mat/mat-meta.js';
 import { getAllOnLoop } from '../cp-node/fs/get-all-on-loop.js';
 import { removeVertex } from '../vertex/remove-vertex.js';
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { Loop } from 'flo-boolean';
-import { drawFs } from 'flo-draw';
+// import { LlRbTree } from 'flo-ll-rb-tree';
+// import { Loop } from 'flo-boolean';
+// import { drawFs } from 'flo-draw';
 import { getAllOnCircle } from '../cp-node/fs/get-all-on-circle.js';
 
 
@@ -38,7 +38,7 @@ function findAndAdd3ProngsOnLoop(
                 cpNodeGoodSet.add(cpNode);
             } else {
                 reLoop = true;
-                replaceCloseBys(meta.cpTrees, closeBysFor3Prong, cpNodeSet, cpNodeGoodSet);
+                replaceCloseBys(meta, closeBysFor3Prong, cpNodeSet, cpNodeGoodSet);
             }
 
             addedCpNodes.forEach(cpNodes => cpNodes.forEach(cpNode => cpNodeGoodSet.add(cpNode)));
@@ -71,7 +71,8 @@ function getLastItemOfSet<T>(set: Set<T>) {
 
 
 function replaceCloseBys(
-        cpTrees: Map<Loop,LlRbTree<CpNode>>,
+        // cpTrees: Map<Loop,LlRbTree<CpNode>>,
+        meta: MatMeta,
         closeBysFor3Prong: CpNode[],
         cpNodeSet: Set<CpNode>,
         cpNodeGoodSet: Set<CpNode>) {
@@ -81,7 +82,7 @@ function replaceCloseBys(
             cpNodeSet.delete(v);
             cpNodeGoodSet.delete(v);
         });
-        removeVertex(closeBy, cpTrees);
+        removeVertex(closeBy, meta);
     }
 }
 

package/src/find-mat/create-initial-cp-tree.ts

@@ -5,6 +5,7 @@ import { CpNodeFs } from '../cp-node/cp-node-fs.js';
 import { PointOnShape } from '../point-on-shape/point-on-shape.js';
 import { ContactPoint } from '../contact-point/contact-point.js';
 import { insertCpNode } from '../cp-node/fs/insert-cp-node.js';
+import { MatMeta } from '../index.js';
 
 const { cpNodeComparator } = CpNodeFs;
 
@@ -13,17 +14,20 @@ const { cpNodeComparator } = CpNodeFs;
  * @internal
  * Creates the initial ContactPoint loops from the given sharp corners.
  * 
- * * modifies `cpTrees`
+ * * modifies `cpTrees` and `lastInsertId` of `meta`
  * 
- * @param shape
+ * @param loops
+ * @param cpTrees
  * @param sharpCornerss
+ * @param lastInsertId
  */
 function createInitialCpTree(
         loops: Loop[], 
         cpTrees: Map<Loop, LlRbTree<CpNode>>,
-        sharpCornerss: PointOnShape[][]) {
+        sharpCornerss: PointOnShape[][],
+        lastInsertId: { id: number }) {
 
-    let cpNode;
+    let cpNode: CpNode | undefined;
     for (let k=0; k<sharpCornerss.length; k++) {
         const sharpCorners = sharpCornerss[k];
 
@@ -37,8 +41,8 @@ function createInitialCpTree(
             const cp1: ContactPoint = { pointOnShape: pos, circle, order: -1, order2: 0 };
             const cp2: ContactPoint = { pointOnShape: pos, circle, order: +1, order2: 0 };
 
-            cpNode1 = insertCpNode(true, false, false, cpTree, cp1, cpNode2)!;
-            cpNode2 = insertCpNode(true, false, false, cpTree, cp2, cpNode1)!;
+            cpNode1 = insertCpNode(true, false, false, cpTree, cp1, cpNode2, lastInsertId)!;
+            cpNode2 = insertCpNode(true, false, false, cpTree, cp2, cpNode1, lastInsertId)!;
             
             cpNode1.prevOnCircle = cpNode2; 
             cpNode2.prevOnCircle = cpNode1; 

package/src/find-mat/find-mat.ts

@@ -7,7 +7,7 @@ import { CpNode } from '../cp-node/cp-node.js';
 import { Loop } from 'flo-boolean';
 import { findAndAdd3ProngsOnLoop } from '../find-3-prong.ts/find-and-add-3-prongs-on-loop.js';
 import { createInitialCpTree } from './create-initial-cp-tree.js';
-import { getMeta, addDebugInfo2, addDebugInfo3, addDebugInfo4 } from './get-meta.js';
+import { getPointToCpNode, getPartialMeta, addDebugInfo2, addDebugInfo3, addDebugInfo4 } from './get-meta.js';
 import { getSharpCornersOnLoop } from './get-sharp-corners.js';
 import { getDullCornersOnLoop } from './get-dull-corners-on-loop.js';
 import { findAndAdd2ProngsOnAllLoops } from '../find-2-prong/find-and-add-2-prongs-on-all-loops.js';
@@ -16,6 +16,7 @@ import { getFor1ProngsOnLoop } from './get-for-1-prongs-on-loop.js';
 import { findAndAddHoleClosing2Prongs } from '../find-2-prong/find-and-add-hole-closing-2-prongs.js';
 import { getShapeBounds } from '../svg/get-shape-bounds.js';
 import { MatOptions } from './mat-options.js';
+import { MatMeta } from '../mat/mat-meta.js';
 
 
 /**
@@ -38,15 +39,21 @@ function findMat(
 
     const sharpCornersPerLoop = loops.map(getSharpCornersOnLoop_);
 
-    const cpTrees: Map<Loop, LlRbTree<CpNode>> = new Map();
-    createInitialCpTree(loops, cpTrees, sharpCornersPerLoop);
-
     const bounds = getShapeBounds(loops);
     const squaredDiagonalLength = 
         (bounds.maxX.p[0] - bounds.minX.p[0])**2 +
         (bounds.maxY.p[1] - bounds.minY.p[1])**2;
 
-    const meta = getMeta(maxCoordinate, squaredDiagonalLength, loops, cpTrees);
+    const cpTrees: Map<Loop, LlRbTree<CpNode>> = new Map();
+    const lastInsertId = { id: 0 };
+    createInitialCpTree(loops, cpTrees, sharpCornersPerLoop, lastInsertId);
+
+    const _meta = getPartialMeta(loops);
+    const pointToCpNode = getPointToCpNode(loops, cpTrees);
+    const meta: MatMeta = {
+        maxCoordinate, squaredDiagonalLength, loops, cpTrees, pointToCpNode,
+        lastInsertId, ..._meta
+    };
 
     let cpNode: CpNode | undefined;
 

package/src/find-mat/get-meta.ts

@@ -18,23 +18,14 @@ let timingStart: number;
 
 
 /** @internal */
-function getMeta(
-        maxCoordinate: number,
-        squaredDiagonalLength: number,
+function getPointToCpNode(
         loops: Loop[],
-        cpTrees: Map<Loop, LlRbTree<CpNode>>): MatMeta {
+        cpTrees: Map<Loop, LlRbTree<CpNode>>): TriMap<Loop,number,number,CpNode> {
 
     timingStart = performance.now();
 
     const pointToCpNode: TriMap<Loop,number,number,CpNode> = new Map();
-
-    const looseBoundingBoxes: number[][][] = [];
-    const tightBoundingBoxes: number[][][] = [];
-    const boundingHulls: number[][][] = [];
-    const sharpCorners: Curve[] = [];
-    const dullCorners: Curve[] = [];
-
-    for (const loop of loops) {
+        for (const loop of loops) {
         // Populate `posMap`
         const cpTree = cpTrees.get(loop)!;
         const cpNodes = cpTree.toArrayInOrder();
@@ -42,8 +33,32 @@ function getMeta(
             const { p, t } = cpNode.cp.pointOnShape;
             TriMapFs.set(pointToCpNode,loop,p[0],p[1],cpNode);
         }
+    }
+
+    return pointToCpNode;
+}
 
-        for (let curve of loop.curves) {
+
+/** @internal */
+function getPartialMeta(
+        loops: Loop[]): Omit<
+            MatMeta,
+            | 'cpTrees'
+            | 'pointToCpNode'
+            | 'loops'
+            | 'maxCoordinate'
+            | 'squaredDiagonalLength'
+            | 'lastInsertId'
+        > {
+
+    const looseBoundingBoxes: number[][][] = [];
+    const tightBoundingBoxes: number[][][] = [];
+    const boundingHulls: number[][][] = [];
+    const sharpCorners: Curve[] = [];
+    const dullCorners: Curve[] = [];
+
+    for (const loop of loops) {
+        for (const curve of loop.curves) {
             const ps = curve.ps;
             const hull = getBoundingHull(ps, true)!;
 
@@ -65,16 +80,11 @@ function getMeta(
     }
 
     return {
-        maxCoordinate,
-        squaredDiagonalLength,
         looseBoundingBoxes,
         tightBoundingBoxes,
         boundingHulls,
         sharpCorners,
-        dullCorners,
-        loops,
-        cpTrees,
-        pointToCpNode
+        dullCorners
     }
 }
 
@@ -112,4 +122,4 @@ function addDebugInfo4() {
 }
 
 
-export { getMeta, addDebugInfo2, addDebugInfo3, addDebugInfo4 }
+export { getPointToCpNode, getPartialMeta, addDebugInfo2, addDebugInfo3, addDebugInfo4 }

package/src/get-curve/get-curve-between.ts

@@ -13,8 +13,8 @@ const TOLERANCE_USE_LINE = 0.0001; // else cubic
 
 
 /**
- * Returns the bezier curve from the maximal disk of one [[CpNode]] to another
- * [[CpNode]]'s maximal disk.
+ * Returns the bezier curve from the maximal disk of one `CpNode` to another
+ * `CpNode`'s maximal disk.
  * @param cpNodeFrom 
  * @param cpNodeTo 
  */

package/src/index.ts

@@ -49,5 +49,5 @@ export { getSharpCornersOnLoop } from './find-mat/get-sharp-corners.js';
 export { getFor2ProngsOnLoop } from './find-mat/get-for-2-prongs-on-loop.js';
 export { getPotentialClosestPointsOnCurveCertified } from './closest-boundary-point/get-potential-closest-points-on-curve-certified.js';
 export { getCloseBoundaryPointsCertified } from './closest-boundary-point/get-close-boundary-points-certified.js';
-export { getMeta } from './find-mat/get-meta.js';
+// export { getMeta } from './find-mat/get-meta.js';
 export { findAndAddHoleClosing2Prongs } from './find-2-prong/find-and-add-hole-closing-2-prongs.js';

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

@@ -1,10 +1,8 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-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 } from '../cp-node/cp-node.js';
-import { CpNodeFs } from '../cp-node/cp-node-fs.js';
+import type  { Circle } from '../geometry/circle.js';
+import type  { ContactPoint } from '../contact-point/contact-point.js';
+import type  { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import type  { CpNode } from '../cp-node/cp-node.js';
+import type { MatMeta } from '../index.js';
 import { getCpNodeToLeftOrSame } from './get-cp-node-to-left-or-same.js';
 import { insertCpNode } from '../cp-node/fs/insert-cp-node.js';
 import { joinSpokes } from '../add-n-prong.ts/join-spokes.js';
@@ -24,10 +22,13 @@ function addToCpTree(
         isHoleClosing: boolean,
         circle: Circle, 
         orders: number[],
-        cpTrees: Map<Loop,LlRbTree<CpNode>>,
+        // cpTrees: Map<Loop,LlRbTree<CpNode>>,
+        meta: MatMeta,
         poss: PointOnShape[],
         neighbors? : CpNode[]): { anyFailed: boolean, cpNodes: (CpNode | undefined) [] } {
 
+    const { cpTrees } = meta;
+
     let anyFailed = false;
     const cpNodes = poss.map((pos,i) => {
         const order = orders[i];
@@ -38,7 +39,15 @@ function addToCpTree(
             ? getCpNodeToLeftOrSame(cpTree, pos, order, 0)
             : neighbors[i];
 
-        const cpNode = insertCpNode(insertIfOrderIsWrong, isHoleClosing, false, cpTree, cp, pred);
+        const cpNode = insertCpNode(
+            insertIfOrderIsWrong,
+            isHoleClosing,
+            false,
+            cpTree,
+            cp,
+            pred,
+            meta.lastInsertId
+        );
 
         if (cpNode === undefined) { anyFailed = true; }
 

package/src/mat/get-branches.ts

@@ -3,44 +3,51 @@ import { getBranch } from '../cp-node/fs/get-branch.js';
 import { getNonTerminatingOnCircle } from '../cp-node/fs/get-non-terminating-on-circle.js';
 
 
+/**
+ * Returns all branches associated with the give cpNode.
+ * 
+ * * the final `CpNode` of each branch is not returned to improve symmetry
+ * 
+ * @param cpNode `CpNode` representing the start vertex.
+ */
 function getBranches(
-		cpNode: CpNode): CpNode[][] {
+        cpNode: CpNode): CpNode[][] {
 
-	const branches: CpNode[][] = [];
-	const cpNodeStack: CpNode[] = [cpNode];
-	const takenBranches: Set<CpNode> = new Set();
-	while (cpNodeStack.length > 0) {
-		const cpNode = cpNodeStack.pop()!;
-		const branch = getBranch(cpNode);
+    const branches: CpNode[][] = [];
+    const cpNodeStack: CpNode[] = [cpNode];
+    const takenBranches: Set<CpNode> = new Set();
+    while (cpNodeStack.length > 0) {
+        const cpNode = cpNodeStack.pop()!;
+        const branch = getBranch(cpNode);
 
-		if (branch.length === 0) {
-			continue;
-		}
+        if (branch.length === 0) {
+            continue;
+        }
 
-		branches.push(branch);
+        branches.push(branch);
 
-		const cpNodeS = branch[0];
-		const cpNodeE = branch[branch.length-1].next.prevOnCircle;
+        const cpNodeS = branch[0];
+        const cpNodeE = branch[branch.length-1].next.prevOnCircle;
 
-		takenBranches.add(cpNodeS);
-		takenBranches.add(cpNodeE);
+        takenBranches.add(cpNodeS);
+        takenBranches.add(cpNodeE);
 
-		const _cpNodesS = getNonTerminatingOnCircle(cpNodeS, true);
-		const _cpNodesE = getNonTerminatingOnCircle(cpNodeE, true);
-		const cpNodesS = _cpNodesS.filter(cpNode => !takenBranches.has(cpNode));
-		const cpNodesE = _cpNodesE.filter(cpNode => !takenBranches.has(cpNode));
+        const _cpNodesS = getNonTerminatingOnCircle(cpNodeS, true);
+        const _cpNodesE = getNonTerminatingOnCircle(cpNodeE, true);
+        const cpNodesS = _cpNodesS.filter(cpNode => !takenBranches.has(cpNode));
+        const cpNodesE = _cpNodesE.filter(cpNode => !takenBranches.has(cpNode));
 
-		for (const cpNode of cpNodesS) {
-			takenBranches.add(cpNode);
-		}
-		for (const cpNode of cpNodesE) {
-			takenBranches.add(cpNode);
-		}
+        for (const cpNode of cpNodesS) {
+            takenBranches.add(cpNode);
+        }
+        for (const cpNode of cpNodesE) {
+            takenBranches.add(cpNode);
+        }
 
-		cpNodeStack.push(...cpNodesS, ...cpNodesE);
-	}
+        cpNodeStack.push(...cpNodesS, ...cpNodesE);
+    }
 
-	return branches;
+    return branches;
 }
 
 

package/src/mat/mat-meta.ts

@@ -19,12 +19,17 @@ interface MatMeta {
     
     /** 
      * Primarily for internal use. A tree structure storing the
-     * [[CpNode]]s of the MAT by their compare order, i.e. their cyclic order
+     * `CpNode`s of the MAT by their compare order, i.e. their cyclic order
      * around the shape boundary.
      */
     readonly cpTrees: Map<Loop, LlRbTree<CpNode>>;
     /** A map from a bezier and t value to a `PointOnShape` */
     readonly pointToCpNode: TriMap<Loop,number,number,CpNode>;
+    /**
+     * Stores the last insert id so each `CpNode` can have a unique id for
+     * debugging purposes
+     */
+    readonly lastInsertId: { id: number };
 }
 
 

package/src/mat/mat.ts

@@ -5,13 +5,13 @@ import { MatMeta } from './mat-meta.js';
 /**
  * Represents a complete Medial Axis Transform (MAT).
  * 
- * The MAT is fully described through its [[CpNode]] property. The [[cpTrees]]
+ * The MAT is fully described through its `CpNode` property. The `cpTrees`
  * property is only added to facilitate extension of the MAT, e.g. by adding
- * extra maximal disks and is typically not used. See [[CpNode]] for more
+ * extra maximal disks and is typically not used. See `CpNode` for more
  * details.
  */
 interface Mat {
-    /** A complete representation of the MAT. See [[CpNode]]. */
+    /** A complete representation of the MAT. See `CpNode`. */
     cpNode: CpNode;
     /**
      * Stores additional info about the shape that could be useful for various

package/src/mat/simplify-mat.ts

@@ -75,7 +75,7 @@ function simplifyMat(
                 !cpNode.isHoleClosing
             )(cpNode)) {
 
-            removeVertex(cpNode, mat.meta.cpTrees);
+            removeVertex(cpNode, mat.meta);
         }
     }
 

package/src/point-on-shape/compare-poss.ts

@@ -2,10 +2,10 @@ import { PointOnShape } from "./point-on-shape.js";
 
 
 /**
- * Compares two [[PointOnShape]]s according to their cyclic ordering imposed
+ * Compares two `PointOnShape`s according to their cyclic ordering imposed
  * by their relative positions on the shape boundary. 
- * @param a The first [[PointOnShape]].
- * @param b The second [[PointOnShape]].
+ * @param a The first `PointOnShape`.
+ * @param b The second `PointOnShape`.
  * @internal
  */
 function comparePoss(

package/src/point-on-shape/get-osculating-circle.ts

@@ -9,7 +9,7 @@ import { PointOnShape } from './point-on-shape.js';
  * 
  * @param minCurvature If not Number.POSITIVE_INFINITY then the
  * circle radius will be limited to this value.
- * @param pos The [[PointOnShape]] identifying the point.
+ * @param pos The `PointOnShape` identifying the point.
  * @param useMaxRadius
  */
 function getOsculatingCircle(

package/src/point-on-shape/point-on-shape.ts

@@ -2,7 +2,7 @@ import { Curve } from '../curve/curve.js';
 
 
 interface PointOnShape {
-    /** The [[ICurve]] on the shape boundary this points belong to. */
+    /** The `Curve` on the shape boundary this points belong to. */
     curve: Curve;
     /** The bezier parameter value on the curve identifying the point coordinates. */
     t: number;

package/src/point-on-shape/pos-to-human-string.ts

@@ -2,7 +2,7 @@ import { PointOnShape } from "./point-on-shape.js"
 
 
 /**
- * Returns a human-readable string of the given [[PointOnShape]]. 
+ * Returns a human-readable string of the given `PointOnShape`.
  * For debugging only.
  * @internal
  */

package/src/sat/to-scale-axis.ts

@@ -20,7 +20,7 @@ import { getSatCulls } from './get-sat-culls.js';
  * boundary of the shape. The SAT is a simplification of the MAT that preserves
  * less detail the higher the applied scale factor. The severity at which noise
  * are removed depends on the local scale of the shape.
- * @param mat The Medial Axis Transform ([[Mat]]) on which to apply the SAT. 
+ * @param mat The Medial Axis Transform (`Mat`) on which to apply the SAT. 
  * @param s The scale factor >= 1 (e.g. 1.3)
  */
 function toScaleAxis(

package/src/vertex/remove-vertex.ts

@@ -1,6 +1,7 @@
-import { Loop } from 'flo-boolean';
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { CpNode } from "../cp-node/cp-node.js";
+// import { Loop } from 'flo-boolean';
+// import { LlRbTree } from 'flo-ll-rb-tree';
+import type { CpNode } from "../cp-node/cp-node.js";
+import type { MatMeta } from '../mat/mat-meta.js';
 import { getAllOnCircle } from '../cp-node/fs/get-all-on-circle.js';
 import { getProngCount } from '../cp-node/fs/get-prong-count.js';
 import { removeCpNode } from '../cp-node/fs/remove-cp-node.js';
@@ -8,14 +9,15 @@ import { removeCpNode } from '../cp-node/fs/remove-cp-node.js';
 
 function removeVertex(
         cpNode: CpNode,
-        cpTrees: Map<Loop, LlRbTree<CpNode>>): void {
+        meta: MatMeta): void {
+        // cpTrees: Map<Loop, LlRbTree<CpNode>>): void {
 
     const prongCount = getProngCount(cpNode);
     if (prongCount !== 2) {
         throw new Error(`Cannot delete \`CpNode\` on ${prongCount}-prong`)
     }
 
-    getAllOnCircle(cpNode).forEach(cpNode => removeCpNode(cpNode, cpTrees));
+    getAllOnCircle(cpNode).forEach(cpNode => removeCpNode(cpNode, meta));
 }
 
 

package/.mocharc.cjs

@@ -1,17 +0,0 @@
-'use strict';
-
-module.exports = {
-    extension: ['ts', 'tsx'],
-    spec: ['__tests__/**/*.spec.ts'],
-    recursive: true,
-    loader: ['ts-node/esm'],
-    // slow: '75',
-    // timeout: '2000',
-    // ignore: ['/path/to/some/ignored/file'],
-    color: true,
-    diff: true,
-    exit: false,
-    parallel: true,
-    timeout: '2000',
-    'v8-stack-trace-limit': 100 // V8 flags are prepended with "v8-"
-};

package/src/debug/functions/draw-elem/branch.ts

@@ -1,26 +0,0 @@
-import { drawFs } from 'flo-draw';
-import { CpNode, isTerminating } from '../../../cp-node/cp-node.js';
-import { getCurveToNext } from '../../../cp-node/get-curve-to-next.js';
-
-
-/** @internal */
-function drawBranch(g: SVGGElement, branch: CpNode[], delay?: number) {
-
-    const classes = 'thin5 purple nofill';
-
-    const $svgs: SVGElement[] = [];
-    let i = 0;
-
-    for (const cpNode of branch) {
-        if (isTerminating(cpNode)) { continue; }
-        const bezier = getCurveToNext(cpNode);
-        if (!bezier) { continue; }
-        i++;
-        $svgs.push( ...drawFs.bezier(g, bezier, classes, delay));
-    }
-    
-    return $svgs;
-}
-
-
-export { drawBranch }

package/src/find-mat/create-initial-cp-graph.ts

@@ -1,59 +0,0 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { Loop } from 'flo-boolean';
-import { CpNode, cpNodeComparator, insertCpNode } from '../cp-node/cp-node.js';
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { ContactPoint } from '../contact-point/contact-point.js';
-
-
-/**
- * @internal
- * Creates the initial ContactPoint loops from the given sharp corners.
- * @param shape
- * @param sharpCornerss
- */
-function createInitialCpGraph(
-        loops: Loop[], 
-        cpTrees: Map<Loop, LlRbTree<CpNode>>,
-        sharpCornerss: PointOnShape[][]/*,
-        xMap: Map<number[][],{ ps: number[][] }>*/) {
-
-    let cpNode;
-
-    for (let k=0; k<sharpCornerss.length; k++) {
-        const sharpCorners = sharpCornerss[k];
-
-        const cpTree = new LlRbTree(cpNodeComparator, false);
-        
-        let cpNode1: CpNode = undefined!;
-        let cpNode2: CpNode = undefined!;
-        for (const pos of sharpCorners) {
-            const ps = pos.curve.next.ps;
-            //const x = xMap.get(ps);
-            //const isIntersection = !!x;
-            
-            const circle = { center: pos.p, radius: 0 };
-
-            const cp1: ContactPoint = { pointOnShape: pos, circle, order: -1, order2: 0 };
-            const cp2: ContactPoint = { pointOnShape: pos, circle, order: +1, order2: 0 };
-
-            cpNode1 = insertCpNode(false, /*isIntersection*/ false, cpTree, cp1, cpNode2!);
-            cpNode2 = insertCpNode(false, /*isIntersection*/ false, cpTree, cp2, cpNode1);
-            
-            cpNode1.prevOnCircle = cpNode2; 
-            cpNode2.prevOnCircle = cpNode1; 
-
-            cpNode1.nextOnCircle = cpNode2; 
-            cpNode2.nextOnCircle = cpNode1; 
-        }
-
-        if (!cpNode) { cpNode = cpNode1; }
-
-        const loop = loops[k];
-        cpTrees.set(loop, cpTree);
-    }
-
-    return cpNode;
-}
-
-
-export { createInitialCpGraph }