flo-mat 3.0.15 → 4.0.2

package/src/find-2-prong/find-equidistant-point-on-line-dd.ts

@@ -1,77 +0,0 @@
-import {
-    twoDiff, twoSum, twoProduct, doubleDivDouble, ddDivDd,
-    ddAddDd, ddDiffDd, ddMultDd, ddMultBy2, ddMultDouble1
-} from "double-double";
-
-
-const { abs } = Math;
-
-const td = twoDiff;
-const tp = twoProduct;
-
-
-
-/**
- * Returns the point on the line from y to x that is equidistant from y and z.
- * 
- * @internal
- * @param x
- * @param y
- * @param z
-  */
-function findEquidistantPointOnLineDd(
-        x: number[],
-        y: number[],
-        z: number[]) {
-    // Some basic algebra (not shown) finds the required point.
-    
-    // Swap axes if x and y are more aligned to y-axis than to x-axis.
-    const swapAxes = abs(x[1] - y[1]) > abs(x[0] - y[0]);
-    
-    // Cache
-    let x1: number;
-    let x2: number;
-    let y1: number;
-    let y2: number;
-    let z1: number;
-    let z2: number;
-    
-    if (swapAxes) {
-        x1 = x[1];    x2 = x[0];
-        y1 = y[1];    y2 = y[0];
-        z1 = z[1];    z2 = z[0];    
-    } else {
-        x1 = x[0];    x2 = x[1];
-        y1 = y[0];    y2 = y[1];
-        z1 = z[0];    z2 = z[1];
-    }
-    
-    // a <= 1 (due to swapped axes)
-    // const a = (x2 - y2) / (x1 - y1); 
-    // const b = y2 - a*y1;
-    // const c = (y1*y1 + y2*y2 - z1*z1 - z2*z2) + 2*b*(z2 - y2);
-    // const d = y1 - z1 + a*(y2 - z2);
-    // const t1 = c/(2*d);
-    // const t2 = a*t1 + b;
-
-    
-    const a = ddDivDd(td(x2,y2),td(x1,y1)); 
-    const b = ddDiffDd([0,y2], ddMultDouble1(y1,a));
-
-    const c = ddAddDd(
-        (ddDiffDd(
-            ddAddDd(tp(y1,y1), tp(y2,y2)),
-            ddAddDd(tp(z1,z1), tp(z2,z2))
-        )),
-        ddMultBy2(ddMultDd(b,(td(z2,y2))))
-    );
-
-    const d = ddAddDd(td(y1,z1), ddMultDd(a,td(y2,z2)));
-    const t1 = ddDivDd(c,ddMultBy2(d));
-    const t2 = ddAddDd(ddMultDd(a,t1), b);
-    
-    return swapAxes ? [t2[1],t1[1]] : [t1[1],t2[1]];
-}
-
-
-export { findEquidistantPointOnLineDd }

package/src/find-2-prong/find-equidistant-point-on-line.ts

@@ -1,40 +0,0 @@
-
-/**
- * @internal
- * @param x
- * @param y
- * @param z
- * @returns The point on the line from y to x that is equidistant from y and z. 
- */
-function findEquidistantPointOnLine(x: number[], y: number[], z: number[]) {
-    // Some basic algebra (not shown) finds the required point.
-    
-    // Swap axes if x and y are more aligned to y-axis than to x-axis.
-    const swapAxes = Math.abs((x[1] - y[1]) / (x[0] - y[0])) > 1;
-    
-    // Cache
-    let x1, x2, y1, y2, z1, z2;
-    
-    if (swapAxes) {
-        x1 = x[1];    x2 = x[0];
-        y1 = y[1];    y2 = y[0];
-        z1 = z[1];    z2 = z[0];    
-    } else {
-        x1 = x[0];    x2 = x[1];
-        y1 = y[0];    y2 = y[1];
-        z1 = z[0];    z2 = z[1];
-    }
-    
-    // a <= 1 (due to swapped axes)
-    const a = (x2 - y2) / (x1 - y1); 
-    const b = y2 - a*y1;
-    const c = (y1*y1 + y2*y2 - z1*z1 - z2*z2) + 2*b*(z2 - y2);
-    const d = y1 - z1 + a*(y2 - z2);
-    const t1 = c/(2*d);
-    const t2 = a*t1 + b;
-    
-    return swapAxes ? [t2,t1] : [t1,t2];
-}
-
-
-export { findEquidistantPointOnLine }

package/src/find-2-prong/pyth-trips.ts

@@ -1,146 +0,0 @@
-import { primitivePart } from "flo-poly";
-
-/**
- * From https://www.geeksforgeeks.org/generate-pythagorean-triplets/
- * 
- * Function to generate pythagorean triplets smaller than limit
- */
-function pythagoreanTriplets(
-        limit: number): number[][] {
-
-    // Triplet: a^2 + b^2 = c^2
-    let a = 0;
-    let b = 0;
-    let c = 0;
-
-    // Loop from 2 to max_limit
-    let m = 2;
-
-    const triples: number[][] = [];
-    // Limiting c would limit all a, b and c
-    while (c < limit) {
-        for(let n=1; n<m; ++n) {
-            a = m*m - n*n;
-            b = 2*m*n;
-            c = m*m + n*n;
-
-            if (c > limit) { break; }
-
-            triples.push([a,b,c]);
-        }
-        m++;
-    }
-
-    return triples;
-}
-
-
-function get1DegreeSpacingTriples() {
-    let limit = 10000;
-    const triplesRaw = pythagoreanTriplets(limit);
-    const triplesRed = triplesRaw.map(triple => {
-        let [x,y] = triple;
-        [x,y] = primitivePart([x,y]);
-        if (x > y) { [x,y] = [y,x]; }
-
-        return [x,y];
-    });
-
-    triplesRed.sort((a,b) => {
-        let res = a[0] - b[0];
-
-        if (res !== 0) { return res; }
-
-        return a[1] - b[1];
-    });
-
-    const triples: number[][] = [];
-    for (let i=0; i<triplesRed.length; i++) {
-        const tripleRedPrev = triplesRed[i-1];
-        const tripleRed = triplesRed[i];
-        if (tripleRedPrev === undefined ||
-            tripleRed[0] !== tripleRedPrev[0] ||
-            tripleRed[1] !== tripleRedPrev[1]) {
-
-            triples.push(tripleRed);
-        }
-    }
-
-
-    function toDeg(angle: number) {
-        return angle*180/Math.PI;
-    }
-
-    const triplesWithAngles = triples.map(triple => {
-        const [x,y] = triple;
-
-        return [x,y,toDeg(Math.atan2(y,x))];
-    }).sort((a,b) => a[2] - b[2]);//?
-
-    triplesWithAngles.length;//?
-    triplesWithAngles[0];//?
-    triplesWithAngles[triplesWithAngles.length-1];//?
-
-    const trips: number[][] = [];
-    const GAP = 1;
-    let prev = 45;
-    for (let t of triplesWithAngles) {
-        if (t[2] - prev > GAP) {
-            trips.push(t);
-            prev = t[2];
-        }
-    }
-
-    return trips;
-}
-
-
-// get1DegreeSpacingTriples();
-
-const triples = [
-    [ 2184, 2263, 46.017740165645755 ],
-    [ 2928, 3145, 47.046418040919235 ],
-    [ 2760, 3071, 48.0530131573584 ],
-    [ 1675, 1932, 49.075456953155594 ],
-    [ 3003, 3596, 50.13492687612096 ],
-    [ 3885, 4828, 51.177026282632845 ],
-    [ 1825, 2352, 52.19084831477669 ],
-    [ 3220, 4371, 53.621908600697374 ],
-    [ 3036, 4277, 54.63121594688451 ],
-    [ 935, 1368, 55.64819276850652 ],
-    [ 2813, 4284, 56.70992357064812 ],
-    [ 836, 1323, 57.71132243943304 ],
-    [ 175, 288, 58.715507085582544 ],
-    [ 1955, 3348, 59.718032329846196 ],
-    [ 276, 493, 60.75825202273669 ],
-    [ 8, 15, 61.92751306414704 ],
-    [ 1404, 2747, 62.92828726173151 ],
-    [ 39, 80, 64.01076641616699 ],
-    [ 2825, 6072, 65.04978057558209 ],
-    [ 1144, 2583, 66.11164562310735 ],
-    [ 5, 12, 67.38013505195958 ],
-    [ 168, 425, 68.4314042648748 ],
-    [ 1995, 5332, 69.48636031660722 ],
-    [ 1408, 3975, 70.49515011669244 ],
-    [ 301, 900, 71.5077745088735 ],
-    [ 1887, 6016, 72.5852594569592 ],
-    [ 7, 24, 73.73979529168804 ],
-    [ 2159, 7920, 74.75161499109633 ],
-    [ 1815, 7208, 75.86654056719784 ],
-    [ 1469, 6300, 76.87460298212505 ],
-    [ 924, 4307, 77.89161621177033 ],
-    [ 1008, 5135, 78.8940579339264 ],
-    [ 204, 1147, 79.91509786165818 ],
-    [ 315, 1972, 80.92445498418671 ],
-    [ 355, 2508, 81.94347266702972 ],
-    [ 520, 4209, 82.95709324615554 ],
-    [ 19, 180, 83.97442499163333 ],
-    [ 23, 264, 85.0208941560017 ],
-    [ 29, 420, 86.05013197823607 ],
-    [ 39, 760, 87.06239857122834 ],
-    [ 120, 3599, 88.09031749225564 ],
-    [ 127, 8064, 89.09772290642545 ]
-];
-
-
-export { triples }

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

@@ -1,113 +0,0 @@
-declare const _debug_: Debug;
-
-import { Debug } from '../debug/debug.js';
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { CpNode } from '../cp-node/cp-node.js';
-import { Loop } from 'flo-boolean';
-import { Circle } from '../geometry/circle.js';
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { addToCpGraph } from '../mat/add-to-cp-graph.js';
-import { isAnotherCpCloseby } from '../mat/is-another-cp-closeby.js';
-import { MatMeta } from '../mat/mat-meta.js';
-
-
-/**
- * @internal
- * 
- * Adds a 3-prong MAT circle according to the 3 given (previously calculated) 
- * points on the shape. 
- * 
- * Returns 3 CpNodes if successful, else return one CpNode that is an offending
- * too close existing CpNode.
- * 
- * @param cpTrees 
- * @param orders 
- * @param threeProng 
- */
-function add3Prong(
-        // cpTrees: Map<Loop,LlRbTree<CpNode>>,
-        meta: MatMeta,
-        orders: number[],
-        threeProng: { 
-            circle: Circle, 
-            ps: PointOnShape[],
-            δ3s: CpNode[][]
-        }): CpNode[] {
-    
-    const { cpTrees } = meta;
-    const { circle, ps: poss, δ3s } = threeProng;
-
-    // Keep for possible future debugging.    
-
-    /*
-    let ii = -1;
-    if (typeof _debug_ !== 'undefined') {
-        for (let i=0; i<3; i++) {
-            const cpBef = threeProng.δ3s[i][0].cp;
-            const cpAft = threeProng.δ3s[i][1].cp;
-
-            //let cmpBef = PointOnShape.compareInclOrder(cpBef.pointOnShape, poss[i], cpBef.order, orders[i]);
-            //let cmpAft = PointOnShape.compareInclOrder(cpAft.pointOnShape, poss[i], cpAft.order, orders[i]); 
-            const cmpBef = compareCps(cpBef, { pointOnShape: poss[i], order: orders[i], order2: 0, circle: undefined });
-            const cmpAft = compareCps(cpAft, { pointOnShape: poss[i], order: orders[i], order2: 0, circle: undefined });
-
-            // const cmpBef = comparePoss(cpBef.pointOnShape, poss[i]);
-            // const cmpAft = comparePoss(cpAft.pointOnShape, poss[i]); 
-
-            // len is used by debug functions to reference a particular 
-            // three-prong.
-            const len = _debug_.generated.elems.threeProng.length-1; 
-            if (cmpBef > 0) {
-                console.log('----------------------------------------');
-                console.log(`3-prong order is wrong (bef) : i: ${i} - cmp: ${cmpBef} - n: ${len}`);
-                console.log(threeProng);
-                console.log(cpBef);
-                console.log(cpAft);
-                console.log(poss[i]);
-                ii = i;
-            }
-            if (cmpAft < 0) {
-                console.log('----------------------------------------');
-                console.log(`3-prong order is wrong (aft) : i: ${i} - cmp: ${cmpAft} - n: ${len}`);
-                console.log(threeProng);
-                console.log(cpBef);
-                console.log(cpAft);
-                console.log(poss[i]);
-            }
-        }
-    }
-    */
-
-    // TODO - replace 1000 below with correct value
-    const c1 = isAnotherCpCloseby(cpTrees, poss[0], circle, orders[0], 0, 1000);
-    const c2 = isAnotherCpCloseby(cpTrees, poss[1], circle, orders[1], 0, 1000);
-    const c3 = isAnotherCpCloseby(cpTrees, poss[2], circle, orders[2], 0, 1000);
-
-    // for (let pos of poss) {
-    //     if (pos.t === 0.9978869234519733) {
-    //         console.log(pos)
-    //     }
-    // }
-    
-
-    // if (!!c1) {
-    //     console.log(getRealProngCount(c1));
-    // }
-    // if (!!c2) {
-    //     console.log(getRealProngCount(c2));
-    // }
-    // if (!!c3) {
-    //     console.log(getRealProngCount(c3));
-    // }
-
-    // if (!!c1) { return [c1]; }
-    // if (!!c2) { return [c2]; }
-    // if (!!c3) { return [c3]; }
-
-    const cps = addToCpGraph(circle, orders, cpTrees, poss, δ3s); 
-    
-    return cps;
-}
-
-
-export { add3Prong }

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

@@ -1,47 +0,0 @@
-
-// interface ArraySet<T> {
-//     idxMap: Map<T,number>;
-//     arr: T[];
-// }
-
-
-// function add<T>(
-//         arraySet: ArraySet<T>,
-//         t: T) {
-
-//     const { arr, idxMap } = arraySet;
-//     arr.push(t);
-//     idxMap.set(t, arr.length-1);
-// }
-
-
-// function addAll<T>(
-//         arraySet: ArraySet<T>,
-//         ts: T[]) {
-
-//     for (const t of ts) {
-//         add(arraySet, t);
-//     }
-// }
-
-
-// function remove<T>(
-//         arraySet: ArraySet<T>,
-//         t: T) {
-
-//     const { arr, idxMap } = arraySet;
-//     const idx = idxMap.get(t);
-//     if (idx === undefined) {
-//         return false;
-//     }
-
-
-// }
-
-
-// const ArraySetFs = {
-//     add, addAll, remove
-// }
-
-
-// export { ArraySetFs }

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

@@ -1,48 +0,0 @@
-import { CpNode } from '../cp-node/cp-node.js';
-import { Circle } from '../geometry/circle.js';
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { find3ProngForDelta3s } from './find-3-prong-for-delta3s.js';
-import { getBoundaryPieceBeziers } from '../mat/get-boundary-piece-beziers.js';
-
-
-/**
- * @internal
- * Find and return a 3-prong from the given boundary piece.
- * @param δs A boundary piece
- * @param extreme The maximum coordinate value used to calculate floating point
- * tolerances.
- */ 
-function find3Prong(
-        δs: CpNode[][], extreme: number) {
-
-    const curvePiecess = δs.map(getBoundaryPieceBeziers);
-
-    // The best candidate amongst the different 'permutations' of the given δs.
-    let threeProng: { 
-        circle: Circle, 
-        poss: PointOnShape[], 
-        δ3s: CpNode[][] 
-    };
-    let smallestError = Number.POSITIVE_INFINITY;
-    for (let i=1; i<δs.length-1; i++) {
-        for (let k=0; k<3; k++) {
-            const threeProngInfo = 
-                find3ProngForDelta3s(δs, i, k, curvePiecess, extreme);
-            if (!threeProngInfo) { continue; }
-
-            const { circle, poss: poss, error, δ3s } = threeProngInfo;
-            
-            if (error < smallestError) {
-                smallestError = error;
-                
-                threeProng = { circle, poss: poss as PointOnShape[], δ3s };
-            }
-        }
-    }
-    
-
-    return threeProng!;
-}
-
-
-export { find3Prong }

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

@@ -1,109 +0,0 @@
-/** @internal */
-declare const _debug_: Debug; 
-
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { Debug } from '../debug/debug.js';
-import { CpNode, getCpNodesOnCircle } from '../cp-node/cp-node.js';
-import { Loop } from 'flo-boolean';
-import { isPosSharpCorner } from '../point-on-shape/is-pos-sharp-corner.js';
-import { fixOrdering } from '../find-mat/fix-ordering.js';
-import { findAndAdd3Prongs } from './find-and-add-3-prongs.js';
-
-
-interface Edge {
-    fromCpNode: CpNode;
-    cpStart: CpNode;
-}
-
-
-/**
- * @internal
- * Finds and adds all 3-prongs.
- * @param cpGraphs
- * @param cpStart The CpNode to start traversing from. 
- * @param extreme The maximum coordinate value used to calculate floating point
- * tolerances.
- */
-function findAndAddAll3Prongs(
-        cpGraphs: Map<Loop,LlRbTree<CpNode>>,
-        cpStart: CpNode,
-        extreme: number) {
-
-    // Don't change this function to be recursive, the call stack may overflow 
-    // if there are too many two-prongs.
-
-    const visitedEdges = new Map<CpNode, Set<CpNode>>();
-
-    const edgesToCheck: Edge[] = [{ fromCpNode: undefined! as CpNode, cpStart }];
-
-    while (edgesToCheck.length) {
-        const { fromCpNode, cpStart } = edgesToCheck.shift()!;
-
-        markEdgeAsTaken(visitedEdges, fromCpNode, cpStart);
-        
-        for (const cpNode of getCpNodesOnCircle(cpStart)) {
-
-            if (!isPosSharpCorner(cpNode.cp.pointOnShape)) {
-                if (findAndAdd3Prongs(cpGraphs, cpNode, extreme) === undefined) {
-                    console.log('Unable to find 3-prong');
-                    return; // only for debugging purposes
-                }
-            }
-
-            if (hasEdgeBeenTaken(visitedEdges, cpNode, cpNode.next)) {
-                continue; // We already visited this edge
-            }
-
-            edgesToCheck.push({ fromCpNode: cpStart, cpStart: cpNode.next }); 
-        }
-    }
-
-    // for (const [k,v] of cpGraphs) {
-    //     fixOrdering(v.root!.datum);
-    // }
-}
-
-
-/**
- * @internal
- * Marks the given edge as already taken.
- */
-function markEdgeAsTaken(
-        visitedEdges: Map<CpNode, Set<CpNode>>,
-        cp1: CpNode, 
-        cp2: CpNode) {
-
-    if (cp1 === undefined) { return; }
-
-    markEdgeAsTaken_(cp1, cp2);
-    markEdgeAsTaken_(cp2, cp1);
-
-    function markEdgeAsTaken_(cp1: CpNode, cp2: CpNode) {
-        let visited = visitedEdges.get(cp1);
-        if (!visited) { 
-            visited = new Set<CpNode>();
-            visitedEdges.set(cp1, visited);
-        }  
-        visited.add(cp2);
-    }
-}
-
-
-/** @internal */
-function hasEdgeBeenTaken(
-        visitedEdges: Map<CpNode, Set<CpNode>>,
-        cp1: CpNode, 
-        cp2: CpNode) {
-
-    let cps: Set<CpNode> | undefined;
-
-    cps = visitedEdges.get(cp1);
-    const takenForward = cps && cps.has(cp2); 
-
-    cps = visitedEdges.get(cp2);
-    const takenBackwards = cps && cps.has(cp1); 
-
-    return takenForward || takenBackwards;
-}
-
-export { findAndAddAll3Prongs }

package/src/find-mat/add-2-prongs-by-error.ts

@@ -1,122 +0,0 @@
-// import { drawFs } from "flo-draw";
-import { closestPointOnBezier } from "flo-bezier3";
-import { CpNode } from "../cp-node/cp-node.js";
-import { findAndAdd2Prong } from "../find-2-prong/find-and-add-2-prong.js";
-import { MatMeta } from "../mat/mat-meta.js";
-import { getHalfAngle } from "./get-half-angles.js";
-import { getMatCurveToNext } from "../cp-node/fs/get-mat-curve-to-next.js";
-// import { getAllOnCircle } from "../cp-node/fs/get-all-on-circle.js";
-import { isTerminating } from "../cp-node/fs/is-terminating.js";
-// import { findAndAdd3Prongs } from "../find-3-prong.ts/find-and-add-3-prongs.js";
-// import { getBoundaryBezierPartsToNext } from "../cp-node/fs/get-boundary-bezier-parts-to-next.js";
-// import { drawBezierPieces } from "../debug/functions/draw/draw-bezier-pieces.js";
-import { getAllOnLoop } from "../cp-node/fs/get-all-on-loop.js";
-// import { PointOnShape } from "../point-on-shape/point-on-shape.js";
-// import { getBoundaryBeziersToNext } from "../cp-node/fs/get-boundary-beziers-to-next.js";
-import { isPosQuiteDullCorner } from "../point-on-shape/is-pos-quite-dull-corner.js";
-import { MatOptions } from "./mat-options.js";
-
-
-const draw = false;
-const scale = 2/50;
-const classes = [
-    'red thin10 nofill',
-    'green thin10 nofill',
-    'deeppink thin10 nofill'
-];
-
-function add2rongsByError(
-        options: Required<MatOptions>,
-        tolerance: number,
-        meta: MatMeta,
-        cpStart: CpNode): number {
-
-    // const g = document.getElementsByTagName('g')[0];
-
-    let maxError = Number.NEGATIVE_INFINITY;
-
-    const cpNodes = getAllOnLoop(cpStart);
-    for (const cpNode of cpNodes) {
-        const { t: tS } = cpNode.cp.pointOnShape;
-        const { t: tE } = cpNode.next.cp.pointOnShape;
-        if (((tS === 0 || tS === 1 || tE === 0 || tE === 1) &&
-             isPosQuiteDullCorner(cpNode.cp.pointOnShape)) ||
-            cpNode.isHoleClosing) {
-
-            continue;
-        }
-
-        // don't check dull corners or hole closers
-        if (isTerminating(cpNode)) {
-            continue;
-        }
-
-        // drawFs.dot(g, cpNode.cp.circle.center, scale*2, 'darkgreen', 0)
-
-        // let threeProngAdded = false;
-        // if (draw) { drawFs.dot(g, cpNode.cp.circle.center, scale*1, 'darkgreen', 0); }
-
-        const q = getMatCurveToNext(cpNode);
-
-        const d = checkAndMaybeAddAnother(q, meta, tolerance, cpNodes, cpNode);
-        if (d > maxError) {
-            maxError = d;
-        }
-    }
-
-    if (maxError > 0) {
-        // console.log(maxError);
-    }
-    return maxError;
-}
-
-
-function checkAndMaybeAddAnother(
-        q: number[][],
-        meta: MatMeta,
-        tolerance: number,
-        cpNodes: CpNode[],
-        cpNode: CpNode): number {
-
-    // const g = document.getElementsByTagName('g')[0];
-
-    const pos = getHalfAngle(cpNode);
-    if (pos === undefined) { return 0; }
-
-    // if (draw) { drawFs.bezier(g, q, 'thin50 deeppink nofill', 0); }
-
-    const _newCpNode = findAndAdd2Prong(meta, pos);
-    if (_newCpNode === undefined) { return 0; }
-
-    // ...since a 3-prong might be revealed
-    // const { closeByss: closeBys, addedCpNodes: threeProngCpNodes } = 
-    //     findAndAdd3Prongs(meta, _newCpNode);
-    // if (threeProngCpNodes.length > 0) {
-    //     threeProngAdded = true;
-    //     console.log('threeProngAdded')
-    //     continue;
-    // }
-
-    // if (draw) { drawFs.dot(g, _newCpNode.cp.circle.center!, scale*1, 'red', 0); }
-
-    const p = _newCpNode.cp.circle.center;
-    const { d, p: pq } = closestPointOnBezier(q, p);
-    // if (draw) { drawFs.line(g, [p,pq], 'thin2 darkgreen nofill', 0); }
-
-    if (d < tolerance) {
-        return 0;
-    }
-
-    // console.log(d);
-    cpNodes.push(_newCpNode, cpNode);
-
-    // if (draw) { drawFs.line(g, [p,pq], 'thin5 darkgreen nofill', 0); }
-    // if (draw) { drawFs.dot(g, _newCpNode.cp.circle.center!, scale*3, 'red', 0); }
-    // drawFs.line(g, [p,pq], 'thin20 darkgreen nofill', 0);
-    // drawFs.dot(g, _newCpNode.cp.circle.center!, scale*3, 'red', 0);
-
-    return d;
-}
-
-
-export { add2rongsByError }