flo-mat 3.0.15 → 4.0.2

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 }

package/src/find-mat/get-size-params.ts

@@ -1,34 +0,0 @@
-import { getLoopsMetrics } from '../loop/get-max-coordinate.js';
-
-
-function getSizeParams(
-        bezierLoops: number[][][][],
-        maxCurviness: number,
-        maxLength: number) {
-
-    // Gather some shape metrics
-    const { maxCoordinate, maxRadius } = getLoopsMetrics(bezierLoops);
-    const expMax = Math.ceil(Math.log2(maxCoordinate));
-    const minBezLengthSigBits = 16;
-    /** 
-     * If a curve is shorter than this value then no points on it will be 
-     * selected for the purpose of finding the MAT.
-     */
-    const minBezLength = 2**expMax * 2**(-minBezLengthSigBits);
-
-    // Limit the tolerance to a reasonable level
-    if (maxCurviness < 0.05) { maxCurviness = 0.05; }
-    if (maxCurviness > 3   ) { maxCurviness = 3;    }
-    // Limit the tolerance to a reasonable level
-    if (maxLength < 0.1) { maxLength = 0.1; }
-    if (maxLength > 100) { maxLength = 100; }
-    // Adjust length tolerance according to a reference max coordinate
-    const expMaxRadius = Math.ceil(Math.log2(maxRadius));
-    const maxLengthSigBits = 10;  // 1024 x 1024
-    maxLength = maxLength * (2**expMaxRadius * 2**(-maxLengthSigBits));
-
-    return { maxCurviness, maxLength, maxCoordinate, minBezLength };
-}
-
-
-export { getSizeParams }

package/src/find-mat/get-total-by.ts

@@ -1,27 +0,0 @@
-import type { Loop } from 'flo-boolean';
-import type { Curve } from '../curve/curve.js';
-
-
-/**
- * @internal
- * Helper function.
- * @internal
- * @param totalByF
- */
-function getTotalBy(totalByF: (curve: Curve) => number) {
-    
-    return function(loop: Loop) {
-        let node = loop.curves[0];
-        let total = 0;
-        do {
-            total += totalByF(node);
-            
-            node = node.next;
-        } while (node !== loop.curves[0]);
-        
-        return total;        
-    }
-}
-
-
-export { getTotalBy }

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

@@ -1,80 +0,0 @@
-import { 
-    fromTo, dot, cross, rotate90Degrees, interpolate, translate,
-    lineLineIntersection
-} from 'flo-vector2d';
-import { CpNode } from '../cp-node/cp-node.js';
-import { getEdgeDirection } from './get-edge-direction.js';
-
-
-/** @internal */
-const TOLERANCE_ADD_2PRONG = 0.01;
-/** @internal */
-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.
- * @param cpNodeFrom 
- * @param cpNodeTo 
- */
-function getCurveBetween(
-        cpNodeFrom: CpNode, 
-        cpNodeTo: CpNode): number[][] {
-
-    const fromCc = cpNodeFrom.cp.circle.center;
-    const fromL = getEdgeDirection(cpNodeFrom);
-
-    const toCc = cpNodeTo.cp.circle.center;
-    const toL = getEdgeDirection(cpNodeTo.prevOnCircle);
-
-    const mid = lineLineIntersection(fromL, toL);
-
-    const c = fromTo(fromCc,toCc);
-
-    let twisted: boolean;
-    if (!mid) {
-        twisted = true;
-    } else {
-        const a = fromTo(fromCc, mid);
-        const b = fromTo(toCc,   mid);
-        
-        twisted = dot(a,c) < 0 || dot(b,c) > 0;            
-    }
-    
-    if (!twisted) {
-        return [fromCc, mid!, toCc];
-    } 
-        
-    const r = rotate90Degrees(c);
-    const w1 = fromTo(fromL[0], fromL[1]); // This is a unit vector
-    const w2 = fromTo(toL[0],  toL[1]);  // This is a unit vector
-
-    const d1 = Math.abs(cross(c, w1)) / (3*3); 
-    const d2 = Math.abs(cross(c, w2)) / (3*3); 
-
-    if (d1 > TOLERANCE_ADD_2PRONG || d2 > TOLERANCE_ADD_2PRONG) {
-        // TODO - not within tolerance - must add additional 2-prong
-        return [fromCc, toCc];
-    } 
-
-    if (d1 > TOLERANCE_USE_LINE || d2 > TOLERANCE_USE_LINE) {
-        // approximate with cubic bezier
-        const m1 = interpolate(fromCc,toCc,1/3);
-        const m2 = interpolate(fromCc,toCc,2/3);
-        const v1 = translate(r, m1);
-        const v2 = translate(r, m2);
-        const l1 = [m1,v1];
-        const l2 = [m2,v2];
-        const mid1 = lineLineIntersection(fromL, l1)!;
-        const mid2 = lineLineIntersection(toL,   l2)!;
-
-        return [fromCc, mid1, mid2, toCc];
-    } 
-
-    // Within tolerance - approximate with a straight line.
-    return [fromCc, toCc];
-}
-
-
-export { getCurveBetween }

package/src/get-curve/get-edge-direction.ts

@@ -1,70 +0,0 @@
-import { 
-    toUnitVector, fromTo, rotate, translate, rotate90Degrees, reverse, dot
-} from 'flo-vector2d';
-import { tangent } from 'flo-bezier3';
-import { CpNode } from '../cp-node/cp-node.js';
-import { isPosSharpCorner } from '../point-on-shape/is-pos-sharp-corner.js';
-import { Curve } from '../curve/curve.js';
-
-
-/**
- * @internal
- * Returns a line segment of unit length starting in the given Vertex center and
- * pointing in the direction of the medial axis (viewed as a rooted tree).
- * @param cpNode 
- */
-function getEdgeDirection(cpNode: CpNode) {
-    const circleCenter = cpNode.cp.circle.center;
-
-    const cp1 = cpNode;
-    const cp2 = cpNode.nextOnCircle;
-
-    const pos1 = cp1.cp.pointOnShape;
-    const pos2 = cp2.cp.pointOnShape;
-
-    const p1 = pos1.p;
-    const p2 = pos2.p;
-
-    let vDir;
-    
-    if (!isPosSharpCorner(pos1)) {
-        if (p1[0] === p2[0] && p1[1] === p2[1]) {
-            vDir = fromTo(p1, circleCenter); // A 1-prong
-        } else {
-            vDir = rotate90Degrees( fromTo(p1, p2) ); // not a 1-prong.
-        }
-    } else {
-        let curve1: Curve;
-        let curve2: Curve;
-
-        if (pos1.t === 0) {
-            curve1 = pos1.curve;
-            curve2 = pos1.curve.prev;
-        } else if (pos1.t === 1) {
-            curve1 = pos1.curve.next; 
-            curve2 = pos1.curve;
-        }
-
-        const tan1 = toUnitVector(tangent(curve1!.ps, 0));
-        const tan2 = reverse( toUnitVector(tangent(curve2!.ps, 1)) );
-        
-        const x = dot(tan1, tan2);
-        // Recall the identities sin(acos(x)) = sqrt(1-x^2), etc. Also 
-        // recall the half angle formulas. Then the rotation matrix, R, can 
-        // be calculated.
-        const cosθ = Math.sqrt((1 + x)/2);
-        const sinθ = Math.sqrt((1 - x)/2);
-        
-        vDir = rotate(sinθ, cosθ, tan2);
-    }
-
-    const v = translate(
-        toUnitVector(vDir),
-        circleCenter 
-    );
-
-    return [circleCenter, v];
-}
-
-
-export { getEdgeDirection }

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

@@ -1,60 +0,0 @@
-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, insertCpNode } from '../cp-node/cp-node.js';
-import { getNeighbouringPoints } from './get-neighboring-cps.js';
-
-
-/**
- * @internal
- *
- * @param circle 
- * @param orders 
- * @param cpTrees 
- * @param poss 
- * @param neighbors 
- * @internal
- */
-function addToCpGraph(
-        circle  : Circle, 
-        orders  : number[],
-        cpTrees : Map<Loop,LlRbTree<CpNode>>,
-        poss    : PointOnShape[],
-        neighbors? : CpNode[][]) {
-
-    const newCps = poss.map((pos, i) => {
-        const cpTree = cpTrees.get(pos.curve.loop)!;
-
-        const newCp_: ContactPoint = { pointOnShape: pos, circle, order: orders[i], order2: 0 };
-
-        const neighboringCp = neighbors 
-            ? neighbors[i]
-            : getNeighbouringPoints(cpTree, pos, orders[i], 0);
-
-        const newCp = insertCpNode(
-                false,
-                false,
-                cpTree,
-                newCp_,
-                neighboringCp[0]
-        );
-
-        return newCp;
-    });
-
-    const len = poss.length;
-    for (let i=0; i<len; i++) {
-        const indxPrev = i === 0     ? len - 1 : i - 1;
-        const indxNext = i === len - 1 ? 0     : i + 1;
-
-        newCps[i].prevOnCircle = newCps[indxPrev];
-        newCps[i].nextOnCircle = newCps[indxNext];
-    }
-
-    return newCps;
-}
-
-
-export { addToCpGraph }

package/src/mat/cmp-cp-on-delta.ts

@@ -1,56 +0,0 @@
-import { CpNode } from '../cp-node/cp-node.js';
-import { ContactPoint, compareCps } from '../contact-point/contact-point.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: ContactPoint) {
-
-    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}`);
-            //_debug_.fs.draw.dot(cp.pointOnShape.p, 1, "blue");
-            return -1;
-        }
-    } else if (cmp > 0) {
-        if (cmpPrev > 0 && cmpNext > 0) {
-            console.log(`2-PRONG (antipode) Order is wrong: ${cmpPrev}, ${cmpNext}`);
-            //_debug_.fs.draw.dot(cp.pointOnShape.p, 1, "blue");
-            return -1;
-        }
-    } 
-
-    if (cmpPrev === 0 || cmpNext === 0) {
-        console.log('2-PRONG orders are equal.');    
-        return 0;
-    }
-
-    return 1;
-}
-
-
-export { cmpCpOnδ }

package/src/mat/connect-hole-closers.ts

@@ -1,9 +0,0 @@
-import { Mat } from "./mat.js";
-
-
-function connectHoleClosers(mat: Mat) {
-    return mat;
-}
-
-
-export { connectHoleClosers }

package/src/mat/create-new-cp-tree.ts

@@ -1,32 +0,0 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { Loop } from 'flo-boolean';
-import { CpNode } from '../cp-node/cp-node.js';
-import { CpNodeFs } from '../cp-node/cp-node-fs.js';
-
-const { cpNodeComparator, getAllOnLoop } = CpNodeFs;
-
-
-/**
- * @internal
- * @param cpNode 
- */
-function createNewCpTree(cpNode: CpNode) {
-    const newCpTrees: Map<Loop,LlRbTree<CpNode>> = new Map();
-
-    getAllOnLoop(cpNode).forEach(createNewCpTree_);
-
-    function createNewCpTree_(cpNode: CpNode) {
-        const loop = cpNode.cp.pointOnShape.curve.loop;
-        let cpTree = newCpTrees.get(loop);
-        if (!cpTree) { 
-            cpTree = new LlRbTree(cpNodeComparator, false); 
-            newCpTrees.set(loop, cpTree);
-        }
-        cpTree.insert(cpNode);
-    }
-
-    return newCpTrees;
-}
-
-
-export { createNewCpTree }

package/src/mat/get-edges-as-array.ts

@@ -1,18 +0,0 @@
-// import { CpNode } from '../cp-node/cp-node.js';
-// import { traverseEdges } from '../cp-node/traverse-edges.js';
-
-
-// /** @internal */
-// function getEdgesAsArray(cpNode: CpNode) {    
-//     const cpNodes: CpNode[] = [];
-    
-//     traverseEdges(
-//         cpNode, 
-//         function(cpNode) { cpNodes.push(cpNode) }
-//     );
-    
-//     return cpNodes;
-// }
-
-
-// export { getEdgesAsArray };

package/src/mat/get-largest-three-prong.ts

@@ -1,14 +0,0 @@
-import { CpNode } from '../cp-node/cp-node.js';
-
-
-/** @internal */
-function getLargestThreeProng(cpNodes: CpNode[]) {
-    return cpNodes.reduce(function(maxCpNode: CpNode, cpNode: CpNode) {
-        return cpNode === undefined || maxCpNode.cp.circle.radius >= cpNode.cp.circle.radius
-            ? maxCpNode
-            : cpNode;
-    }, undefined!);
-}
-
-
-export { getLargestThreeProng }

package/src/mat/get-neighboring-cps.ts

@@ -1,49 +0,0 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { CpNode } from '../cp-node/cp-node.js';
-import { createCpNode } from '../cp-node/create-cp-node.js';
-
-
-/**
- * @internal
- * 
- * Returns the boundary piece that starts at the immediate previous point on the 
- * shape and ends at the immediate next point.  
- * 
- * @param cpTree 
- * @param pos 
- * @param order 
- * @param order2 
- */
-function getNeighbouringPoints(
-        cpTree: LlRbTree<CpNode>,
-        pos: PointOnShape,
-        order: number,
-        order2: number) {
-
-    const cps = cpTree.findBounds(
-        createCpNode({ pointOnShape: pos, circle: undefined!, order, order2 }, false, false)
-    );
-
-    if (!cps[0] && !cps[1]) { 
-        // The tree is still empty
-        return [undefined!, undefined!] as CpNode[];
-    }
-
-    if (!cps[0] || !cps[1]) { 
-        // Smaller than all -> cptree.min() === cps[1].data OR
-        // Larger  than all -> cptree.max() === cps[0].data
-        return [
-            cpTree.max(cpTree.root), 
-            cpTree.min(cpTree.root) 
-        ] as CpNode[];
-    }
-
-    return [
-        cps[0].datum, 
-        cps[1].datum
-    ] as CpNode[];  
-}
-
-
-export { getNeighbouringPoints }