flo-mat 3.0.15 → 4.0.2

package/src/find-2-prong/reduce-radius.ts

@@ -1,86 +1,63 @@
-import { evalDeCasteljau } from "flo-bezier3";
-import { dot, lineLineIntersection, squaredDistanceBetween } from "flo-vector2d";
-import { CurvePiece } from '../mat/curve-piece.js';
+import type { CurvePiece } from '../mat/curve-piece.js';
+import { getMedialPointCoeffsBez0 } from "flo-bezier3";
+import { lengthSquared, squaredDistanceBetween } from "flo-vector2d";
+
+const { abs } = Math;
+
+
+const TOLERANCE = 1 + 2**-20;
 
 
 /**
- * @internal
- * 
  * Reduces the circle radius initially as an optimization step.
+ * 
+ * @internal
  */
 function reduceRadius(
-        extreme: number,
+        maxCoordPowerOf2: number,
         curvePieces: CurvePiece[], 
-        p: number[],
-        x: number[]) {
+        y: number[],
+        nnorm: number[]): number {
 
-    const TOLERANCE = 1 + 2**-10;
+    let minRadius = Infinity;
+    let x = [y[0] + nnorm[0], y[1] + nnorm[1]];
 
-    let minRadius = Number.POSITIVE_INFINITY;
     for (let i=0; i<curvePieces.length; i++) {
         const curvePiece = curvePieces[i];
 
-        const ps = curvePiece.curve.ps;
-
-        // let min = Number.POSITIVE_INFINITY;
-        const num = 2;
-        for (let j=0; j<(num + 1); j++) {
-            const p_ = evalDeCasteljau(ps, curvePiece.ts[j/num]);
-            const cc = getCircleCenterFrom2PointsAndNormal(extreme, p, x, p_);
-            if (cc) {
-                let r = squaredDistanceBetween(p, cc);
-                if (r < minRadius) {
-                    minRadius = r;
-                }
-            }
-        }
-    }
-
-    // The extra bit is to account for floating point precision.
-    return TOLERANCE*minRadius;
-}
+        const { ps } = curvePiece.curve;
 
+        const pS = ps[0];
+        const pE = ps[ps.length - 1];
 
-/**
- * @internal
- * @param p A point on the circle with normal pointing to x towards the center
- * of the circle.
- * @param x
- * @param p1 Another point on the circle.
- */
-function getCircleCenterFrom2PointsAndNormal(
-        extreme: number, 
-        p: number[], 
-        x: number[],
-        p1: number[]) {
+        for (const P of [pS,pE]) {
+            if (squaredDistanceBetween(x,P) > minRadius) {
+                continue;  // short-circuit
+            }
 
-    const TOLERANCE = (2**-14*extreme)**2;
+            const { a0, b0 } = getMedialPointCoeffsBez0(y, nnorm, P);
 
-    // Ignore if p and p1 are too close together
-    if (squaredDistanceBetween(p,p1) < TOLERANCE) {
-        return undefined;
-    }
+            if (abs(a0) <= 2**-40 || abs(b0) <= 2**-40) {
+                continue;
+            }
 
-    /** The perpindicular bisector between the two given points on the circle */
-    const pb = [
-        (p[0] + p1[0]) / 2,
-        (p[1] + p1[1]) / 2,
-    ];
-    const tan = [p1[0] - p[0], p1[1] - p[1]];
-    const norm  = [-tan[1], tan[0]]; // Rotate by 90 degrees
-    const pb2 = [pb[0] + norm[0], pb[1] + norm[1]];
+            const w = -b0 / a0;
 
-    const res = lineLineIntersection([p,x], [pb, pb2]);
+            // too close to point of origin *or* negative;
+            if (w < 2**-40) { continue; }
 
-    if (!res) { return undefined; }
+            const N = [w*nnorm[0], w*nnorm[1]];
+            const r = lengthSquared(N);
 
-    const resO = [res[0] - p[0], res[1] - p[1]];
-    const xO = [x[0] - p[0], x[1] - p[1]];
-    if (dot(resO, xO) < 0) {
-        return undefined;
+            if (r < minRadius) {
+                minRadius = r;
+                x = [y[0] + N[0], y[1] + N[1]];
+            }
+        }
     }
 
-    return res;
+    // The extra bit is to account for floating point precision.
+    return TOLERANCE*minRadius;
 }
 
 

package/src/find-2-prong/x-for-debugging.ts

@@ -1,13 +1,13 @@
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+// import { PointOnShape } from '../point-on-shape/point-on-shape.js';
 
 
-/** @internal */
-type TXForDebugging = { 
-    x: number[]; 
-    y: PointOnShape; 
-    z: PointOnShape; 
-    t: number; 
-}
+// /** @internal */
+// type TXForDebugging = { 
+//     x: number[]; 
+//     y: PointOnShape; 
+//     z: PointOnShape; 
+//     t: number; 
+// }
 
 
-export { TXForDebugging }
+// export { TXForDebugging }

package/src/{find-3-prong.ts → find-3-prong}/calc-better-x.ts

@@ -1,39 +1,49 @@
-import { fromTo, circumCenter, len, scale, translate } from 'flo-vector2d';
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { CurvePiece  } from '../mat/curve-piece.js';
-import { getClosestPoints } from './get-closest-points.js';
+import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
+import type { CurvePiece } from '../mat/curve-piece.js';
+// import { fromTo, circumCenter, len, scale, translate } from 'flo-vector2d';
+import { fromTo, len, scale, translate } from 'flo-vector2d';
+import { circumCenter } from './timed-cc.js';  // TODO - testing - restore
+import { getCloseBoundaryPointsCertified } from '../closest-boundary-point/get-close-boundary-points-certified.js';
 
 
 /**
- * @internal
- * Find new x and ps that are a better estimate of the 3-prong circle.
+ * Find new `x` and `ps` that are better estimates of the 3-prong circle.
+ * 
  * The potential function, V, is defined as the distance to the actual 3 prong 
  * circle center.
+ * 
+ * @param maxCoordPowerOf2
  * @param curvePiece3s The three boundary pieces, each of which should contain 
  * a point of the 3-prong to be found.
  * @param x The currently best guess at the center of the 3-prong circle.
  * @param vectorToZeroV
- * @param extreme
+ * 
+ * @internal
  */
 function calcBetterX(
         curvePiece3s: CurvePiece[][], 
         x: number[], 
-        vectorToZeroV: number[]) {
+        vectorToZeroV: number[]): {
+            newX: number[];
+            newV: number;
+            newPoss: PrePointOnShape[];
+        } {
 
     const V = len(vectorToZeroV);
 
     let nu = 1;
     let better;
     let newX;
-    let newPoss: PointOnShape[];
+    let newPoss: PrePointOnShape[];
     let newV;
-    let i = 0; // Safeguard
+    let i = 0;  // Safeguard
     do { 
         const shift = scale(vectorToZeroV, nu);
         newX = translate(shift, x); 
-        
-        
-        newPoss = getClosestPoints(newX, curvePiece3s);
+
+        newPoss = curvePiece3s.map(curvePieces => 
+            getCloseBoundaryPointsCertified(curvePieces, x)[0]
+        );
 
         // Point of zero V
         const newCircleCenter = circumCenter(newPoss.map(pos => pos!.p)); 

package/src/{find-3-prong.ts → find-3-prong}/calc-initial-3-prong-center.ts

@@ -1,40 +1,37 @@
-/** @internal */
-import { circumCenter } from 'flo-vector2d';
-import { CpNode      } from '../cp-node/cp-node.js';
-import { CurvePiece } from '../mat/curve-piece.js';
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { CurvePiece } from '../mat/curve-piece.js';
+// import { circumCenter } from 'flo-vector2d';
+import { circumCenter } from './timed-cc.js';  // TODO - testing - restore
 import { getCloseBoundaryPointsCertified } from '../closest-boundary-point/get-close-boundary-points-certified.js';
-import { createPos } from '../point-on-shape/create-pos.js';
 
-const { max, ceil, log2 } = Math;
 
 /**
- * @internal
  * Finds an initial 3-prong circle center point from which to iterate. The point 
  * must be within the shape. 
- * @param δ3s - The three boundary pieces of which we need to find the three 
+ * 
+ * @param maxCoordPowerOf2
+ * @param δ3s the three boundary pieces of which we need to find the three 
  * 3-prong points.
  * @param curvePiece3s 
- * @param extreme 
+ * 
+ * @internal
  */
 function calcInitial3ProngCenter(
-        maxCoordinate: number,
         δ3s: CpNode[][], 
         curvePiece3s: CurvePiece[][]) {
 
-    const circle = δ3s[0][0].cp.circle;
+    const circle = δ3s[0][0].pointOnShape.circle;
     const twoProngCircleCenter = circle.center;
 
-    const pow = max(0,ceil(log2(maxCoordinate/circle.radius))) + 1;  // determines accuracy;
     const pos = getCloseBoundaryPointsCertified(
-        pow,
         curvePiece3s[1],
         twoProngCircleCenter
     )[0];
 
     const meanPoints = [
-        δ3s[0][0].cp.pointOnShape.p, 
+        δ3s[0][0].pointOnShape.p, 
         pos.p,
-        δ3s[2][1].cp.pointOnShape.p,
+        δ3s[2][1].pointOnShape.p,
     ];
 
     return circumCenter(meanPoints);

package/src/{find-3-prong.ts → find-3-prong}/find-3-prong-for-delta3s.ts

@@ -1,44 +1,42 @@
-import { 
-    fromTo, circumCenter, len, distanceBetween, toUnitVector, rotate90Degrees,
-    cross 
-} from 'flo-vector2d';
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { CurvePiece } from '../mat/curve-piece.js';
+import type { ThreeProngInfo } from './three-prong-info.js';
+import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
+// import { fromTo, circumCenter as getCircumCenter, len, distanceBetween, toUnitVector, rotate90Degrees, cross } from 'flo-vector2d';
+import { fromTo, len, distanceBetween, toUnitVector, rotate90Degrees, cross } from 'flo-vector2d';
+import { circumCenter as getCircumCenter } from './timed-cc.js';  // TODO - testing - restore
 import { tangent } from 'flo-bezier3';
-import { CpNode } from '../cp-node/cp-node.js';
-import { CpNodeFs } from '../cp-node/cp-node-fs.js';
-import { CurvePiece } from '../mat/curve-piece.js';
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
 import { calcInitial3ProngCenter } from './calc-initial-3-prong-center.js';
 import { getClosestPoints } from './get-closest-points.js';
 import { calcBetterX } from './calc-better-x.js';
 import { getCloseBoundaryPointsCertified } from '../closest-boundary-point/get-close-boundary-points-certified.js';
 import { getCorner } from '../corner/get-corner.js';
 import { isPosCorner } from '../point-on-shape/is-pos-corner.js';
-import { getPosCorner } from '../point-on-shape/get-pos-corner.js';
+import { getPosCorner$ } from '../point-on-shape/get-pos-corner.js';
+import { isSharp } from '../cp-node/fs/is-sharp.js';
 
-const { isSharp } = CpNodeFs;
-
-
-/** @internal */
-const calcVectorToZeroV_StraightToIt = fromTo;
+const { min, abs, asin } = Math;
 
 
 /**
- * @internal
  * Finds a 3-prong using only the 3 given δs.
- * @param δs The boundary pieces
+ * 
+ * @param δs the boundary pieces
  * @param idx δ identifier
+ * @param k δs identifier
  * @param curvePiecess
- * @param maxCoordinate The maximum coordinate value used to calculate floating point
- * tolerances.
+ * @param maxCoordPowerOf2
+ * 
+ * @internal
  */
 function find3ProngForDelta3s(
         δs: CpNode[][], 
         idx: number, 
         k: number,
         curvePiecess: CurvePiece[][],
-        maxCoordinate: number) {
+        maxCoordPowerOf2: number): { error: number, threeProngInfo: ThreeProngInfo } | undefined {
 
-    const TOLERANCE = 2**-32*maxCoordinate;
+    const TOLERANCE = 2**(maxCoordPowerOf2 - 32);
     const MAX_ITERATIONS = 10;
 
     const δs_ = [
@@ -71,33 +69,48 @@ function find3ProngForDelta3s(
 
     if (isSharp(δ3s[0][0])) { return undefined; }
 
-
-    let poss: PointOnShape[] = undefined!;
-    let circumCenter_;
-    let j = 0; // Safeguard for slow convergence
-    let x = calcInitial3ProngCenter(maxCoordinate, δ3s, curvePiece3s);
-
-    let tolerance = Number.POSITIVE_INFINITY;
+    // TODO
+    //----------------------------
+    // const l1 = curvePiece3s[0].length;
+    // const l2 = curvePiece3s[1].length;
+    // const l3 = curvePiece3s[2].length;
+    // if (l1 === 1 && l2 == 1 && l3 === 1) {
+    //     // console.log('aaa');
+    //     const A = curvePiece3s[0][0].curve.ps;
+    //     const B = curvePiece3s[1][0].curve.ps;
+    //     const C = curvePiece3s[2][0].curve.ps;
+
+    //     console.log(A.length, B.length, C.length);
+    // } else {
+    //     // console.log('bbb');
+    // }
+    //----------------------------
+
+
+    let poss: PrePointOnShape[] = undefined!;
+    let j = 0;  // Safeguard for slow convergence
+    let x = calcInitial3ProngCenter(δ3s, curvePiece3s);
+
+    let tolerance = Infinity;
     while (tolerance > TOLERANCE && j < MAX_ITERATIONS) { 
         j++;
         
         poss = getClosestPoints(x, curvePiece3s);
         if (!Number.isFinite(x[0]) || !Number.isFinite(x[1])) {
 
-            // TODO - the code can be cleaned up and sped up a lot if we don't
+            // FUTURE - the code can be cleaned up and sped up a lot if we don't
             // use this function as is but instead use δs[0] and δs[2] as is
             // and make δs[1] include all the rest of the beziers around the 
             // loop. This check, for instance, would be eliminated completely.
             return undefined;
         }
 
-        circumCenter_ = circumCenter(poss.map(x => x!.p));
-
-        const vectorToZeroV = calcVectorToZeroV_StraightToIt(x, circumCenter_);
+        const circumCenter = getCircumCenter(poss.map(x => x.p));
+        const vectorToZeroV = fromTo(x, circumCenter);
 
         if (!Number.isFinite(vectorToZeroV[0]) || !Number.isFinite(vectorToZeroV[1])) {
 
-            // TODO - the code can be cleaned up and sped up a lot if we don't
+            // FUTURE - the code can be cleaned up and sped up a lot if we don't
             // use this function as is but instead use δs[0] and δs[2] as is
             // and make δs[1] include all the rest of the beziers around the 
             // loop. This check, for instance, would be eliminated completely.
@@ -109,7 +122,7 @@ function find3ProngForDelta3s(
 
         const V = len(vectorToZeroV); // The 'potential'
         
-        tolerance = Math.abs(V - upds.newV);
+        tolerance = abs(V - upds.newV);
     }
 
     const radius = (distanceBetween(x, poss[0].p) + 
@@ -121,28 +134,28 @@ function find3ProngForDelta3s(
     //-------------------------------------------------------------------------
     // Calculate the unit tangent vector at 3-prong circle points - they should 
     // be very close to tangent to the boundary piece tangents at those points 
-    // (up to sign). Sharp corners are a common special case.
+    // (up to sign). Dull corners is a common special case.
     //-------------------------------------------------------------------------
     let totalAngleError = 0;
     for (let i=0; i<3; i++) {
-        const pos = poss![i];
+        const pos = poss[i];
         //----------------------------
         // Tangent of circle at point
         //----------------------------
-        const v = toUnitVector(fromTo(pos!.p, x));
+        const v = toUnitVector(fromTo(pos.p, x));
         const v1 = rotate90Degrees(v);
         
         
         //-----------------------------------
         // Check if point is on dull crorner
         //-----------------------------------
-        if (isPosCorner(pos!) && getPosCorner(pos!).isDull) {
-            const corner = getCorner(pos!.curve.ps, pos!.curve.next.ps);
+        if (isPosCorner(pos) && getPosCorner$(pos).isDull) {
+            const corner = getCorner(pos.curve.ps, pos.curve.next.ps);
             const tans = corner.tangents;
             const perps = tans.map( rotate90Degrees );
                 
-            const angleError1 = Math.asin( cross( perps[0], v ) );
-            const angleError2 = Math.asin( cross( v, perps[1] ) );
+            const angleError1 = asin( cross( perps[0], v ) );
+            const angleError2 = asin( cross( v, perps[1] ) );
             
             let angleError = 0;
             if (angleError1 > 0) { angleError += angleError1; }
@@ -153,18 +166,18 @@ function find3ProngForDelta3s(
             //---------------------------
             // Tangent of curve at point
             //---------------------------
-            const v2 = toUnitVector( tangent(pos!.curve.ps, pos!.t) );
+            const v2 = toUnitVector( tangent(pos.curve.ps, pos.t) );
             
             // Cross is more numerically stable than Vector.dot at angles a
-            // multiple of Math.PI **and** is close to the actual angle value
+            // multiple of `Math.PI` **and** is close to the actual angle value
             // and can thus just be added to cone method of looking at 
             // tolerance.
             
             // Should be close to zero and is close to the actual angle.
-            const cross_ = Math.abs( Math.asin( cross(v1, v2) ) );
+            const cross_ = abs( asin( cross(v1, v2) ) );
             
             totalAngleError += cross_;
-        }        
+        }
     }
 
     //-------------------------------------------------------------------------
@@ -174,22 +187,22 @@ function find3ProngForDelta3s(
     //-------------------------------------------------------------------------
     const closestDs = [];
     for (let i=0; i<curvePiecess.length; i++) {
-        const p = getCloseBoundaryPointsCertified(
-            5,  // TODO - see find-2-prong
-            curvePiecess[i], x
+        const pos = getCloseBoundaryPointsCertified(
+            curvePiecess[i],
+            x
         )[0];
 
-        closestDs.push( distanceBetween(p.p, x) );
+        closestDs.push( distanceBetween(pos.p, x) );
     }
-    const closestD = Math.min(...closestDs);
-    const radiusDelta = Math.abs(radius - closestD);
+    const closestD = min(...closestDs);
+    const radiusDelta = abs(radius - closestD);
 
     // Weights below still need to be optimized.
     const W1 = 1;
     const W2 = 1;
     const error = W1*radiusDelta + W2*totalAngleError;
 
-    return { poss: poss!, circle, error, δ3s };
+    return { threeProngInfo: { poss, circle, δ3s }, error };
 }
 
 

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

@@ -0,0 +1,52 @@
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { ThreeProngInfo } from './three-prong-info.js';
+import { find3ProngForDelta3s } from './find-3-prong-for-delta3s.js';
+import { getBoundaryPieceBeziers } from '../mat/get-boundary-piece-beziers.js';
+import { timeFunctionCalls } from '../utils/time-function-call.js';
+
+
+/**
+ * Find and return a 3-prong from the given boundary piece.
+ * 
+ * @param δs A boundary piece
+ * @param maxCoordPowerOf2 The maximum coordinate power of 2 value used to
+ * calculate floating point tolerances.
+ * 
+ * @internal
+ */ 
+function find3Prong(
+        δs: CpNode[][],
+        maxCoordPowerOf2: number): ThreeProngInfo {
+
+    // FUTURE if `δs.length > (some threshold (say 4 or 5))` then add two-prongs
+    // to reduced the number of permutations required
+    // if (δs.length > 3) { console.log(δs.length); }
+
+    const curvePiecess = δs.map(getBoundaryPieceBeziers);
+
+    // The best candidate amongst the different 'permutations' of the given δs.
+    let threeProng: ThreeProngInfo;
+
+    let smallestError = Infinity;
+    for (let i=1; i<δs.length - 1; i++) {
+        for (let k=0; k<3; k++) {
+            const r = find3ProngForDelta3s(
+                δs, i, k, curvePiecess, maxCoordPowerOf2
+            );
+
+            if (r === undefined) { continue; }
+
+            const { error, threeProngInfo } = r;
+
+            if (error < smallestError) {
+                smallestError = error;
+                threeProng = threeProngInfo;
+            }
+        }
+    }
+
+    return threeProng!;
+}
+
+
+export { find3Prong }

package/src/{find-3-prong.ts → find-3-prong}/find-and-add-3-prong.ts

@@ -1,14 +1,13 @@
-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 { calcPosOrder } from '../point-on-shape/calc-pos-order.js';
 import { find3Prong } from './find-3-prong.js';
-import { MatMeta } from '../mat/mat-meta.js';
 import { addToCpTree } from '../mat/add-to-cp-tree.js';
 import { getCloseByCpIfExist } from '../mat/get-closeby-cp-if-exist.js';
-import { getRealProngCount } from '../cp-node/fs/get-real-prong-count.js';
-import { removeVertex } from '../vertex/remove-vertex.js';
 import { getProngCount } from '../cp-node/fs/get-prong-count.js';
 
 
+let ii = 0;
 /**
  * @internal
  * Finds and add a 3-prong MAT circle to the given shape.
@@ -25,14 +24,29 @@ function findAndAdd3Prong(
     for (const visitedCp of visitedCps) {
         δs.push([visitedCp, visitedCp.next]);
     }
+
+    // TODO - remove - debugging
+    //-------------------------
+    // ii++;
+    // if (ii === 13) {
+    //     //@ts-ignore
+    //     if (_debug_.temp === undefined) { _debug_.temp = []; }
+    //     //@ts-ignore
+    //     _debug_.temp.push(δs);
+    // }
+    // //@ts-ignore
+    // if (_debug_.temp2 === undefined) { _debug_.temp2 = []; }
+    // //@ts-ignore
+    // _debug_.temp2.push(δs.length);
+    //-------------------------
     
-    const threeProngInfo = find3Prong(δs, meta.maxCoordinate);
+    const threeProngInfo = find3Prong(δs, meta.maxCoordPowerOf2);
 
     const { circle, poss, δ3s } = threeProngInfo;
     
     const orders: number[] = [];
     for (let i=0; i<3; i++) {
-        orders.push(calcPosOrder(circle, poss[i]));
+        orders.push(calcPosOrder(circle.center, poss[i]));
     }
 
     const closeBysFor3Prong: CpNode[] = [];

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

@@ -3,9 +3,6 @@ import type { MatMeta } from '../mat/mat-meta.js';
 import { findAndAdd3Prongs } from './find-and-add-3-prongs.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 { getAllOnCircle } from '../cp-node/fs/get-all-on-circle.js';
 
 
@@ -28,7 +25,6 @@ function findAndAdd3ProngsOnLoop(
         reLoop = false;
         const cpNodeSet = new Set(getAllOnLoop(cpStart));
         for (const cpNode of cpNodeSet) {
-
             const { closeBysFor3Prong, addedCpNodes } = 
                 findAndAdd3Prongs(meta, cpNode);
 
@@ -46,7 +42,7 @@ function findAndAdd3ProngsOnLoop(
         cpStart = getFirstItemOfSet(cpNodeGoodSet)!;
     }
 
-    return getFirstItemOfSet(cpNodeGoodSet);
+    return cpStart;
 }
 
 
@@ -60,30 +56,18 @@ function getFirstItemOfSet<T>(set: Set<T>) {
 }
 
 
-// Unfortunately O(n) until Javascript gives us the simple ability to
-// retrieve the first or last item of a set
-function getLastItemOfSet<T>(set: Set<T>) {
-    let item;
-    for (item of set) {}
-
-    return item;
-}
-
-
 function replaceCloseBys(
-        // cpTrees: Map<Loop,LlRbTree<CpNode>>,
         meta: MatMeta,
         closeBysFor3Prong: CpNode[],
         cpNodeSet: Set<CpNode>,
         cpNodeGoodSet: Set<CpNode>) {
 
-    for (const closeBy of [closeBysFor3Prong[0]]) {
-        getAllOnCircle(closeBy).forEach(v => {
-            cpNodeSet.delete(v);
-            cpNodeGoodSet.delete(v);
-        });
-        removeVertex(closeBy, meta);
-    }
+    const closeBy = closeBysFor3Prong[0];
+    getAllOnCircle(closeBy).forEach(v => {
+        cpNodeSet.delete(v);
+        cpNodeGoodSet.delete(v);
+    });
+    removeVertex(closeBy, meta);
 }