flo-mat 4.0.2 → 4.0.3

package/src/reconstruct-from-mat/reconstruct-from-mat.ts

@@ -0,0 +1,45 @@
+import type { BezierPiece } from 'flo-bezier3';
+import type { Mat } from '../mat/mat.js';
+import { getMbssByLoopPerSat } from './get-mbss-by-loop-per-sat.js';
+import { getMbssByLoopWithOppArr } from './get-mbss-by-loop-with-opp-arr.js';
+
+
+function reconstructFromMats(
+        mats: Mat[]) {
+
+    const loopss: number[][][][] = [];
+
+    const bzs: BezierPiece[] = [];
+
+    const mbssByLoopPerSat = getMbssByLoopPerSat(mats, 1.5)!;
+
+    for (const mbssByLoopPS of mbssByLoopPerSat) {
+        const { mbssByLoop, oppArr } = mbssByLoopPS;
+
+        for (let l=0; l<mbssByLoop.length; l++) {
+            const rs = mbssByLoop[l];
+
+            for (let i=0; i<rs.length; i++) {
+                const r = mbssByLoop[l][i];
+
+                if (r === undefined) { continue; }
+
+                const matchedBezierss = r;
+
+                for (let j=0; j<matchedBezierss.length; j++) {
+                    const mb = matchedBezierss[j];
+                    const { boundaryBezier, medialBezier } = mb;
+
+                    bzs.push(boundaryBezier)
+                }
+            }
+        }
+    }
+
+
+    return bzs;
+    // return loopss;
+}
+
+
+export { reconstructFromMats }

package/src/reconstruct-from-mat/remove-sat-induced-trivial-3prongs.ts

@@ -0,0 +1,62 @@
+import type { Mutable } from '../utils/mutable.js';
+import type { Mat } from '../mat/mat.js';
+import { isFullyTerminating } from './is-fully-terminating.js';
+
+
+/**
+ * In-place removes trivial 3-prongs from the SAT graph; just to simplify
+ * subsequent processing.
+ * 
+ * These are 3-prongs that are induced by the SAT construction, and do
+ * not correspond to actual 3-prongs in the shape.
+ * 
+ * @param sat the SAT
+ */
+function removeSatInducedTrivial3Prongs(
+        sat: Mat): Mat {
+
+    let { cpNode } = sat;
+
+    let cpStart = cpNode;
+    do {
+        if (isFullyTerminating(cpNode) ||
+            // cpNode.isHoleClosing ||  // hole-closers are fully terminating
+            cpNode.next !== cpNode.nextOnCircle) {
+
+            cpNode = cpNode.next;
+            continue;
+        }
+
+        //-----------------------------
+        // Delete the trivial 3-prong
+        //-----------------------------
+        // console.log('Removing SAT-induced trivial 3-prong');
+
+        const next = cpNode.next;
+        const nextNext = next.next;
+        const nextNextOC = cpNode.next.nextOnCircle;
+
+        //-------------------------------------------------------------
+        // In-place update of links to remove the trivial 3-prong node
+        //-------------------------------------------------------------
+        (cpNode as Mutable<typeof cpNode>).next = nextNext;
+        (cpNode as Mutable<typeof cpNode>).nextOnCircle = nextNextOC;
+        (nextNext as Mutable<typeof nextNext>).prev = cpNode;
+        (nextNextOC as Mutable<typeof nextNextOC>).prevOnCircle = cpNode;
+        //-------------------------------------------------------------
+
+        if (cpStart === next) {
+            cpStart = cpNode;  // ...otherwise the loop will never terminate
+        }
+
+        cpNode = cpNode.next;
+    } while (cpNode !== cpStart)
+
+    // ...otherwise the caller will have a reference to a node that has been removed from the graph
+    (sat as Mutable<Mat>).cpNode = cpNode;
+
+    return sat;
+}
+
+
+export { removeSatInducedTrivial3Prongs }

package/src/reconstruct-from-mat/split-tri-path.ts

@@ -0,0 +1,280 @@
+import type { BezierPiece } from 'flo-bezier3';
+import type { MatchedBeziers } from './matched-beziers.js';
+import { getTAtLength } from 'flo-bezier3';
+import { sum } from '../utils/sum.js';
+import { clip } from '../utils/clip.js';
+import { getBezierPieceLength } from './get-bezier-piece-length.js';
+
+
+const EPS = 1e-9;
+
+
+function splitTriPath(
+        boundaryBeziers: BezierPiece[],
+        medialBezier: BezierPiece,
+        boundaryBeziersOpp: BezierPiece[] | undefined): MatchedBeziers[] {
+
+    const _boundaryBeziersOpp = boundaryBeziersOpp ?? [];
+
+    const boundaryBeziersOpp_ =
+        _boundaryBeziersOpp.map(reverseBezierPiece).toReversed();
+
+    // Importantly, we need to split on boundaryBeziersOpp_ as well, to ensure
+    // the number of returned pieces is the same for both sides, so that they
+    // can be interpolated.
+    const _paths = boundaryBeziersOpp_.length > 0
+        ? [boundaryBeziers, [medialBezier], boundaryBeziersOpp_]
+        : [boundaryBeziers, [medialBezier]];
+
+    const paths = splitTriPath_(_paths);
+
+    const matchedBezierss: MatchedBeziers[] = [];
+    for (let i=0; i<paths.length; i++) {
+        const path = paths[i];
+        // const pathOpp = paths[paths.length - 1 - i];
+
+        const [boundaryBezier, medialBezier] = path;
+        // const boundaryBezierOpp = pathOpp[2];
+        const matchedBeziers: MatchedBeziers = {
+            boundaryBezier,
+            medialBezier,
+            // boundaryBezierOpp
+        };
+        matchedBezierss.push(matchedBeziers);
+    }
+
+    return matchedBezierss;
+}
+
+
+function reverseBezierPiece(
+        bezierPiece: BezierPiece) {
+
+    const { ps, ts: [tS, tE] } = bezierPiece;
+
+    return {
+        ps: ps.toReversed(),
+        ts: [1 - tE, 1 - tS]
+    };
+}
+
+
+/**
+ * Returns an array of arrays of `BezierPiece`s, where each inner array
+ * contains `BezierPiece`s that correspond to each other across the different
+ * paths by normalized length.
+ * 
+ * For example, if there are 3 paths, then each inner array will contain 3
+ * `BezierPiece`s, one from each path, that correspond to each other by normalized
+ * length.
+ * 
+ * @param bezierPiecess 
+ */
+function splitTriPath_(
+        bezierPiecess: BezierPiece[][]): BezierPiece[][] {
+
+    const lenss = mapmap(bezierPiecess, getBezierPieceLength);
+    const lens = lenss.map(sum);
+    const cums = lenss.map(getCumLengths);
+
+    const normCums = cums.map((cum,i) => {
+        const len = lens[i];
+        if (len <= EPS) {
+            return cum.map((_,j) => j === 0 ? 0 : 1);
+            // return cum.map(() => Number.POSITIVE_INFINITY);
+        }
+
+        return cum.map(l => l/len);
+    });
+
+
+    /** Current position of start t */
+    let ts = new Array(bezierPiecess.length).fill(0);
+    /** Current position of i */
+    let is = new Array(bezierPiecess.length).fill(0);
+
+    const matchedBezierss: BezierPiece[][] = [];
+
+    normCums;//?
+
+    let ii = 0;
+    const maxIterations = 100;
+    while (ts.some(t => t < 1) && ii++ < maxIterations) {
+        const normCumsNext: number[] = [];
+        for (let k=0; k<bezierPiecess.length; k++) {
+            const i_ = is[k];
+
+            const normCum_ = normCums[k][i_ + 1];//?
+            const normCum = normCum_ === undefined
+                ? Number.POSITIVE_INFINITY
+                : normCum_;
+
+            normCumsNext.push(normCum);
+        }
+
+        normCumsNext;//?
+
+        const minIdx = getMinIdx(normCumsNext)!;//?
+        const idxs = getIdxs(normCumsNext, normCumsNext[minIdx]);//?
+        const curCum = normCumsNext[minIdx];
+
+        // if (idxs.length === 0) {
+        //     throw new Error('splitTriPath_: unable to make progress');
+        // }
+
+        const nextPieces: BezierPiece[] = new Array(bezierPiecess.length).fill([]);
+        for (let m=0; m<bezierPiecess.length; m++) {
+            const bezierPieces = bezierPiecess[m];
+            const _i = is[m];
+
+            // This path is already finished; keep emitting a degenerate tail.
+            if (_i >= bezierPieces.length) {
+                const lastBezierPiece = bezierPieces[bezierPieces.length - 1];
+                nextPieces[m] = {
+                    ps: lastBezierPiece.ps,
+                    ts: [1, 1]
+                };
+                ts[m] = 1;
+                continue;
+            }
+
+            if (idxs.includes(m)) {
+                const _t = ts[m];
+                const bezierPiece = bezierPieces[_i];
+                const [pieceTS, pieceTE] = bezierPiece.ts;
+                const pieceDt = pieceTE - pieceTS;
+
+                nextPieces[m] = {
+                    ps: bezierPiece.ps,
+                    ts: [pieceTS + _t*pieceDt, pieceTE]
+                };
+
+                const nextI = _i + 1;
+                is[m] = nextI;
+                ts[m] = nextI >= bezierPieces.length ? 1 : 0;
+            } else {
+                const _t = ts[m];
+                const bezierPiece = bezierPieces[_i];
+                const [pieceTS, pieceTE] = bezierPiece.ts;
+                const pieceDt = pieceTE - pieceTS;
+                const bezierLen = getBezierPieceLength({ ps: bezierPiece.ps, ts: [0, 1] });
+
+                const normCumStart = normCums[m][_i];
+                const normCumEnd = normCums[m][_i + 1];
+                const normCumDt = normCumEnd - normCumStart;
+                const normWithinPiece = normCumDt <= EPS
+                    ? _t
+                    : clip((curCum - normCumStart) / normCumDt, _t, 1);
+
+                const t1 = bezierLen <= EPS
+                    ? _t
+                    : clip(getTAtLength(bezierPiece.ps, bezierLen * normWithinPiece), _t, 1);
+
+                nextPieces[m] = {
+                    ps: bezierPiece.ps,
+                    ts: [pieceTS + _t*pieceDt, pieceTS + t1*pieceDt]
+                };
+
+                if (closeToEps(t1, 1)) {
+                    const nextI = _i + 1;
+                    is[m] = nextI;
+                    ts[m] = nextI >= bezierPieces.length ? 1 : 0;
+                } else {
+                    is[m] = _i;
+                    ts[m] = t1;
+                }
+            }
+        }
+
+        matchedBezierss.push(nextPieces);
+    }
+
+    if (ts.some(t => t < 1)) {
+        throw new Error('splitTriPath_: exceeded maximum iterations');
+    }
+
+    return matchedBezierss;
+}
+
+
+function getCumLengths(lens: number[]) {
+    const cum: number[] = [0];
+    let cumLen = 0;
+    for (let j=0; j<lens.length; j++) {
+        cumLen += lens[j];
+        cum.push(cumLen);
+    }
+    return cum;
+}
+
+
+/**
+ * Returns the index within the given array of the number with the highest
+ * value.
+ * 
+ * * returns `undefined` if the array is empty
+ */
+function getMinIdx(
+        vs: number[]): number | undefined {
+
+    let minIdx: number | undefined = undefined;
+    let minVal = Number.POSITIVE_INFINITY;
+    for (let i=0; i<vs.length; i++) {
+        if (vs[i] <= minVal) {
+            minVal = vs[i];
+            minIdx = i;
+        }
+    }
+
+    return minIdx;
+}
+
+
+/**
+ * Returns the indices within the given array of the numbers that are equal to
+ * the given max value (within an EPS value).
+ * 
+ * @param vs 
+ * @param maxVal 
+ */
+function getIdxs(
+        vs: number[],
+        maxVal: number): number[] {
+
+    const maxIdxs: number[] = [];
+    for (let i=0; i<vs.length; i++) {
+        if (vs[i] === maxVal || closeToEps(vs[i], maxVal)) {
+            maxIdxs.push(i);
+        }
+    }
+
+    return maxIdxs;
+}
+
+
+function closeToEps(a: number, b: number) {
+    return Math.abs(a - b) <= EPS;
+}
+
+
+export { splitTriPath, getCumLengths };
+
+
+
+// KEEP FOR TESTING! - one in opentype-ts doesn't work with tests due to aliases
+function mapmap<T,U>(
+        tss: T[][],
+        f: (t: T) => U): U[][] {
+
+    const tss_: U[][] = [];
+    for (let i=0; i<tss.length; i++) {
+        const ts = tss[i];
+        const ts_: U[] = [];
+        for (let j=0; j<ts.length; j++) {
+            ts_.push(f(ts[j]));
+        }
+        tss_.push(ts_);
+    }
+
+    return tss_;
+}

package/src/sat/add-debug-info.ts

@@ -12,8 +12,7 @@ function addDebugInfo(
 
     if (typeof _debug_ === 'undefined') { return; }
 
-    const timing = _debug_.generated.timing;
-    timing.sats = performance.now() - timingStart;
+    _debug_.timing.sats = performance.now() - timingStart;
 }
 
 

package/src/utils/clip.ts

@@ -0,0 +1,13 @@
+
+const { max, min } = Math;
+
+function clip(
+        v: number,
+        vMin: number,
+        vMax: number): number {
+
+    return max(vMin, min(vMax, v));
+}
+
+
+export { clip }

package/node/debug/functions/general.d.ts

@@ -1,48 +0,0 @@
-import { CpNode } from '../../cp-node/cp-node.js';
-/** @internal */
-export interface IGeneralDebugFunctions {
-    nameObj: (obj: any, pre?: string) => void;
-    δToString: (cpNodes: CpNode[]) => string[];
-    δsToString: (cpNodes: CpNode[][]) => string[][];
-    pointToStr: (p: number[], decimalPlaces?: number) => string;
-    pointsToStr: (ps: number[][], decimalPlaces?: number) => string[];
-}
-/**
- * @internal
- * Name the given object - for debugging purposes only
- */
-declare function nameObj(o: any, pre?: string): void;
-/**
- * @internal
- * Transforms a boundary piece (δ) into a human readable string.
- * @param cpNodes A boundary piece given by two CpNodes.
- */
-declare function δToString(cpNodes: CpNode[]): string[];
-/**
- * @internal
- * Transforms an array of boundary pieces (δs) into a human readable string.
- * @param cpNodes An array of boundary pieces.
- */
-declare function δsToString(cpNodes: CpNode[][]): string[][];
-/**
- * @internal
- * Convert the given points into a human readable string.
- * @param ps
- */
-declare function pointsToStr(ps: number[][], decimalPlaces?: number): string[];
-/**
- * @internal
- * Converts the given point into a human readable string.
- * @param p The point
- * @param decimalPlaces number of decimal places
- */
-declare function pointToStr(p: number[], decimalPlaces?: number): string;
-/** @internal */
-declare const generalDebugFunctions: {
-    δToString: typeof δToString;
-    δsToString: typeof δsToString;
-    pointToStr: typeof pointToStr;
-    pointsToStr: typeof pointsToStr;
-    nameObj: typeof nameObj;
-};
-export { generalDebugFunctions };

package/node/debug/functions/general.js

@@ -1,53 +0,0 @@
-import { posToHumanString } from '../../point-on-shape/pos-to-human-string.js';
-/** @internal */
-let i = 0;
-/**
- * @internal
- * Name the given object - for debugging purposes only
- */
-function nameObj(o, pre = '') {
-    o.name = '' + pre + i++;
-}
-/**
- * @internal
- * Transforms a boundary piece (δ) into a human readable string.
- * @param cpNodes A boundary piece given by two CpNodes.
- */
-function δToString(cpNodes) {
-    return cpNodes.map(cpNode => posToHumanString(cpNode.pointOnShape));
-}
-/**
- * @internal
- * Transforms an array of boundary pieces (δs) into a human readable string.
- * @param cpNodes An array of boundary pieces.
- */
-function δsToString(cpNodes) {
-    return cpNodes.map(δToString);
-}
-/**
- * @internal
- * Convert the given points into a human readable string.
- * @param ps
- */
-function pointsToStr(ps, decimalPlaces = 3) {
-    return ps.map(p => pointToStr(p, decimalPlaces));
-}
-/**
- * @internal
- * Converts the given point into a human readable string.
- * @param p The point
- * @param decimalPlaces number of decimal places
- */
-function pointToStr(p, decimalPlaces = 3) {
-    return p[0].toFixed(decimalPlaces) + ', ' + p[1].toFixed(decimalPlaces);
-}
-/** @internal */
-const generalDebugFunctions /*: IGeneralDebugFunctions*/ = {
-    δToString,
-    δsToString,
-    pointToStr,
-    pointsToStr,
-    nameObj,
-};
-export { generalDebugFunctions };
-//# sourceMappingURL=general.js.map

package/node/debug/functions/general.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"general.js","sourceRoot":"","sources":["../../../src/debug/functions/general.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,6CAA6C,CAAC;AAa/E,gBAAgB;AAChB,IAAI,CAAC,GAAG,CAAC,CAAC;AACV;;;GAGG;AACH,SAAS,OAAO,CAAC,CAAM,EAAE,GAAG,GAAG,EAAE;IAC7B,CAAC,CAAC,IAAI,GAAG,EAAE,GAAG,GAAG,GAAG,CAAC,EAAE,CAAC;AAC5B,CAAC;AAGD;;;;GAIG;AACH,SAAS,SAAS,CAAC,OAAiB;IAChC,OAAO,OAAO,CAAC,GAAG,CACd,MAAM,CAAC,EAAE,CAAC,gBAAgB,CAAC,MAAM,CAAC,YAAY,CAAC,CAClD,CAAC;AACN,CAAC;AAGD;;;;GAIG;AACH,SAAS,UAAU,CAAC,OAAmB;IACnC,OAAO,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;AAClC,CAAC;AAGD;;;;GAIG;AACH,SAAS,WAAW,CAAC,EAAc,EAAE,aAAa,GAAG,CAAC;IAClD,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC;AACrD,CAAC;AAGD;;;;;GAKG;AACH,SAAS,UAAU,CAAC,CAAW,EAAE,aAAa,GAAG,CAAC;IAC9C,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;AAC5E,CAAC;AAGD,gBAAgB;AAChB,MAAM,qBAAqB,CAAA,4BAA4B,GAAG;IACtD,SAAS;IACT,UAAU;IACV,UAAU;IACV,WAAW;IACX,OAAO;CACV,CAAA;AAGD,OAAO,EAAE,qBAAqB,EAAE,CAAA"}

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

@@ -1,8 +0,0 @@
-import type { PointOnShape } from "./point-on-shape.js";
-/**
- * Returns a human-readable string of the given `PointOnShape`.
- * For debugging only.
- * @internal
- */
-declare function posToHumanString(pos: PointOnShape): string;
-export { posToHumanString };

package/node/point-on-shape/pos-to-human-string.js

@@ -1,12 +0,0 @@
-/**
- * Returns a human-readable string of the given `PointOnShape`.
- * For debugging only.
- * @internal
- */
-function posToHumanString(pos) {
-    return '' + pos.p[0] + ', ' + pos.p[1] +
-        ' | bz: ' + pos.curve.idx +
-        ' | t: ' + pos.t;
-}
-export { posToHumanString };
-//# sourceMappingURL=pos-to-human-string.js.map

package/node/point-on-shape/pos-to-human-string.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pos-to-human-string.js","sourceRoot":"","sources":["../../src/point-on-shape/pos-to-human-string.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,SAAS,gBAAgB,CACjB,GAAiB;IAErB,OAAO,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAClC,SAAS,GAAK,GAAG,CAAC,KAAK,CAAC,GAAG;QAC3B,QAAQ,GAAM,GAAG,CAAC,CAAC,CAAA;AAC3B,CAAC;AAGD,OAAO,EAAE,gBAAgB,EAAE,CAAA"}

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

@@ -1,8 +0,0 @@
-
-/** @internal */
-type ElemType_TwoProng =
-    | 'twoProng_regular'
-    | 'twoProng_holeClosing';
-
-
-export type { ElemType_TwoProng }

package/src/debug/functions/cmp-cp-on-delta.ts

@@ -1,54 +0,0 @@
-import type { CpNode } from '../../cp-node/cp-node.js';
-import { PointOnShape } from '../../point-on-shape/point-on-shape.js';
-
-
-/**
- * @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
- */
-function cmpCpOnδ(
-        δ: CpNode[], 
-        cp: PointOnShape) {
-
-    if (δ[0] === undefined) { 
-        return 1;
-    }
-
-    const cpBef = δ[0].cp;
-    const cpAft = δ[1].cp;
-
-    const cmp     = compareCps(cpBef, cpAft); 
-    const cmpPrev = compareCps(cpBef, cp);
-    const cmpNext = compareCps(cp,    cpAft);
-    
-    if (cmp < 0) {
-        if (cmpPrev > 0 || cmpNext > 0) {
-            // console.log(`2-PRONG (antipode) Order is wrong - cmpPrev and cmpNext should be > 0; cmp: ${cmp}, cmpPrev: ${cmpPrev}, cmpNext ${cmpNext}`);
-            return -1;
-        }
-    } else if (cmp > 0) {
-        if (cmpPrev > 0 && cmpNext > 0) {
-            // console.log(`2-PRONG (antipode) Order is wrong: ${cmpPrev}, ${cmpNext}`);
-            return -1;
-        }
-    } 
-
-    if (cmpPrev === 0 || cmpNext === 0) {
-        // console.log('2-PRONG orders are equal.');    
-        return 0;
-    }
-
-    return 1;
-}
-
-
-export { cmpCpOnδ }

package/src/debug/functions/general.ts

@@ -1,79 +0,0 @@
-import { CpNode } from '../../cp-node/cp-node.js';
-import { posToHumanString } from '../../point-on-shape/pos-to-human-string.js';
-
-
-/** @internal */
-export interface IGeneralDebugFunctions {
-    nameObj     : (obj: any, pre?: string) => void,
-    δToString   : (cpNodes: CpNode[]) => string[],
-    δsToString  : (cpNodes: CpNode[][]) => string[][],
-    pointToStr  : (p: number[], decimalPlaces?: number) => string
-    pointsToStr : (ps: number[][], decimalPlaces?: number) => string[],
-}
-
-
-/** @internal */
-let i = 0;
-/** 
- * @internal
- * Name the given object - for debugging purposes only 
- */
-function nameObj(o: any, pre = '') {
-    o.name = '' + pre + i++;
-}
-
-
-/**
- * @internal
- * Transforms a boundary piece (δ) into a human readable string.
- * @param cpNodes A boundary piece given by two CpNodes.
- */
-function δToString(cpNodes: CpNode[]) {
-    return cpNodes.map(
-        cpNode => posToHumanString(cpNode.pointOnShape)
-    );
-}
-
-
-/**
- * @internal
- * Transforms an array of boundary pieces (δs) into a human readable string. 
- * @param cpNodes An array of boundary pieces.
- */ 
-function δsToString(cpNodes: CpNode[][]) {
-    return cpNodes.map(δToString);
-}
-
-
-/**
- * @internal
- * Convert the given points into a human readable string.
- * @param ps
- */
-function pointsToStr(ps: number[][], decimalPlaces = 3) {
-    return ps.map(p => pointToStr(p, decimalPlaces));
-}
-
-
-/**
- * @internal
- * Converts the given point into a human readable string.
- * @param p The point
- * @param decimalPlaces number of decimal places
- */
-function pointToStr(p: number[], decimalPlaces = 3) {
-    return p[0].toFixed(decimalPlaces) + ', ' + p[1].toFixed(decimalPlaces); 
-}
-
-
-/** @internal */
-const generalDebugFunctions/*: IGeneralDebugFunctions*/ = {
-    δToString,
-    δsToString,
-    pointToStr,
-    pointsToStr,
-    nameObj,
-}    
-
-
-export { generalDebugFunctions }