flo-mat 3.0.14 → 4.0.1

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 }

package/src/find-mat/add-debug-info.ts

@@ -1,93 +0,0 @@
-import { getBoundingHull, getBoundingBoxTight } from 'flo-bezier3';
-import { Debug }   from '../debug/debug.js';
-import { Loop } from 'flo-boolean';
-import { Curve, getCornerAtEnd } from '../curve/curve.js';
-import { Mat } from '../mat/mat.js';
-import { getBoundingBox_ } from '../geometry/get-bounding-box-.js';
-
-
-/** @internal */
-declare const _debug_: Debug; 
-
-
-let timingStart: number;
-
-
-/** @internal */
-function addDebugInfo1(loops: Loop[]) {
-    if (typeof _debug_ === 'undefined') { return; }
-    
-    timingStart = performance.now();
-
-    for (const loop of loops) {
-        _debug_.fs.nameObj(loop,'l|');
-    }
-
-    const generated = _debug_.generated;
-
-    //generated.elems.loop.push(...loops);
-    //generated.elems.loops.push(loops);
-
-    for (const loop of loops) {
-        let i = 0;
-        loop.curves.forEach(function(curve: Curve) {
-            const ps = curve.ps;
-            const hull = getBoundingHull(ps)!; 
-
-            generated.elems.boundingHull.push(hull);
-
-            const looseBoundingBox = getBoundingBox_(ps);
-            generated.elems.looseBoundingBox.push(looseBoundingBox);
-
-            const tightBoundingBox = getBoundingBoxTight(ps);
-            generated.elems.tightBoundingBox.push(tightBoundingBox);
-
-            const corner = getCornerAtEnd(curve);
-            if (corner.isQuiteSharp) {
-                generated.elems.sharpCorner.push(curve);
-            } else if (corner.isQuiteDull) {
-                generated.elems.dullCorner.push(curve);
-            }
-
-            i++;
-        });
-    }
-}
-
-
-/** @internal */
-function addDebugInfo2() {
-    if (typeof _debug_ === 'undefined') { return; }
-
-    const timing = _debug_.generated.timing;
-    const now = performance.now();
-    timing.holeClosers += now - timingStart;
-    timingStart = now;
-}
-
-
-function addDebugInfo3() {
-    if (typeof _debug_ === 'undefined') { return; }
-
-    const generated = _debug_.generated;
-    const timing = generated.timing;
-    const now = performance.now();
-
-    timing.oneAnd2Prongs += now - timingStart;
-    timingStart = now;
-}
-
-
-function addDebugInfo4(mat: Mat) {
-    if (typeof _debug_ === 'undefined') { return; }
-
-    const generated = _debug_.generated;
-    const timing = generated.timing;
-
-    generated.elems.mat.push(mat);
-
-    timing.threeProngs += performance.now() - timingStart;
-}
-
-
-export { addDebugInfo1, addDebugInfo2, addDebugInfo3, addDebugInfo4 }

package/src/find-mat/cp-node-for-insertion.ts

@@ -1,13 +0,0 @@
-import { LlRbTree } from "flo-ll-rb-tree";
-import { CpNode } from "../cp-node/cp-node.js";
-
-
-interface CpNodeForInsertion {
-    cpTree: LlRbTree<CpNode>;
-    cpNode: CpNode;
-    prev: CpNode;
-    next: CpNode;
-}
-
-
-export { CpNodeForInsertion }

package/src/find-mat/get-dull-corners.ts

@@ -1,34 +0,0 @@
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { Loop } from 'flo-boolean';
-import { createPos } from '../point-on-shape/create-pos.js';
-import { getCornerAtEnd } from '../curve/curve.js';
-import { controlPointLinesLength } from 'flo-bezier3';
-
-
-/** @internal */
-function getDullCornersOnLoop(
-        minBezLength: number) {
-
-    return (loop: Loop) => {
-        const dullCorners: PointOnShape[] = [];
-
-        for (let i=0; i<loop.curves.length; i++) {
-            const curve = loop.curves[i];
-
-            if (controlPointLinesLength(curve.ps) < minBezLength) {
-                continue;
-            }
-            
-            if (getCornerAtEnd(curve).isQuiteDull) {
-                dullCorners.push(createPos(curve, 1, true));
-                dullCorners.push(createPos(curve.next, 0, true));
-            }
-        }
-
-        return dullCorners;
-    }
-}
-
-
-
-export { getDullCornersOnLoop }

package/src/find-mat/get-half-angles.ts

@@ -1,95 +0,0 @@
-import { tangent, toPowerBasis_1stDerivative } from "flo-bezier3";
-import { allRoots } from "flo-poly";
-import { CpNode } from "../cp-node/cp-node.js";
-import { createPos } from "../point-on-shape/create-pos.js";
-import { PointOnShape } from "../point-on-shape/point-on-shape.js";
-
-const { atan2, abs, sin, cos } = Math;
-
-
-const MIN_ANGLE = 1/180*Math.PI;
-
-
-function getHalfAngle(
-        cpNodeS: CpNode) {
-
-    const cpNodeE = cpNodeS.next;
-
-    // Get half angle
-    const { curve: curveS, t: tS } = cpNodeS.cp.pointOnShape;
-    const { curve: curveE, t: tE } = cpNodeE.cp.pointOnShape;
-    const { ps: psS } = curveS;
-    const { ps: psE } = curveE;
-
-    if (psS === psE && psS.length < 3) {
-        return createPos(curveS, (tS + tE)/2);
-        // return undefined;
-    }
-
-    const tanS = tangent(psS, tS);
-    const tanE = tangent(psE, tE);
-    const angleS = atan2(tanS[1], tanS[0]);
-    const angleE = atan2(tanE[1], tanE[0]);
-    const angle = angleS + angleE;
-
-    if (abs(angle) <= MIN_ANGLE) {
-        return curveS === curveE
-            ? createPos(curveS, (tS + tE)/2)
-            : tS < 1 - tE  // start closer to endpoint than end?
-            ? createPos(curveS, (1 - tS)/2)
-            : createPos(curveE, tE/2)
-    }
-
-    const halfAngle = angle/2;
-    const x = cos(halfAngle);
-    const y = sin(halfAngle);
-    const q = x/y;
-    /////////
-    
-    {
-        const tE_ = curveS === curveE ? tE : 1;
-        const roots = getHalfAngleRoots(psS, tS, tE_, q);
-        if (roots.length > 0) {
-            return createPos(curveS, roots[0]);
-        }
-    }
-    {
-        const tS_ = curveS === curveE ? tS : 0;
-        const roots = getHalfAngleRoots(psE, tS_, tE, q);
-        if (roots.length > 0) {
-            return createPos(curveE, roots[0]);
-        }
-    }
-
-    return undefined;
-}
-
-
-function getHalfAngleRoots(
-        ps: number[][],
-        tS: number,
-        tE: number,
-        q: number): number[] {
-
-    let roots: number[] = [];
-    if (ps.length === 3) {
-        const pbS = toPowerBasis_1stDerivative(ps);
-        const [[a,b],[c,d]] = pbS;
-        // Solve: (a - cq)t + b - dq = 0
-        roots = [(-b + d*q)/(a - c*q)];
-    } else if (ps.length === 4) {
-        const pbS = toPowerBasis_1stDerivative(ps);
-        const [[a,b,c],[d,e,f]] = pbS;
-        // Solve: (a - dq)t^2 + (b - eq)t + c - fq = 0
-        const ts = [a - d*q, b - e*q, c - f*q];;
-        roots = allRoots(ts)
-    }
-    
-    return roots.filter(r =>
-        r > tS &&
-        r < tE
-    );
-}
-
-
-export { getHalfAngle }