flo-mat 3.0.15 → 4.0.2

package/src/mat/is-another-cp-closeby.ts

@@ -1,69 +0,0 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { distanceBetween, toUnitVector, fromTo, dot } from 'flo-vector2d';
-import { Loop } from 'flo-boolean';
-import { CpNode } from '../cp-node/cp-node.js';
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { Circle } from '../geometry/circle.js';
-import { getNeighbouringPoints } from './get-neighboring-cps.js';
-
-
-/** @internal */
-const DEGREES = 3;
-const ANGLE_THRESHOLD = Math.cos(DEGREES * (Math.PI / 180));
-
-
-/**
- * @internal
- * If another `CpNode` is close by (to the given implied (via `pos`, `order` and
- * `order2`) then return it, else return `undefined`.
- * 
- * @param cpTrees 
- * @param pos 
- * @param circle 
- * @param order 
- * @param order2 
- * @param extreme The maximum coordinate value used to calculate floating point
- * tolerances.
- * @param color Used for debugging only
- */
-function isAnotherCpCloseby(
-        cpTrees: Map<Loop,LlRbTree<CpNode>>,
-        pos: PointOnShape,
-        circle: Circle,
-        order: number,
-        order2: number,
-        extreme: number): CpNode | undefined {
-
-    const DISTANCE_THRESHOLD = extreme * 2e-14;
-    const DISTANCE_THRESHOLD_2 = DISTANCE_THRESHOLD * 2e-2;
-
-    const cpTree = cpTrees.get(pos.curve.loop)!;
-    const cpNodes = getNeighbouringPoints(cpTree, pos, order, order2);
-    if (!cpNodes[0]) { return undefined; }
-
-    const { p, t } = pos;
-    for (const cpNode of cpNodes) {
-        const pos2 = cpNode.cp.pointOnShape;
-        const p2 = pos2.p;
-        const d = distanceBetween(p,p2);
-        if (d > DISTANCE_THRESHOLD) {
-            continue;
-        }
-
-        const v1 = toUnitVector(fromTo(p2, cpNode.cp.circle.center));
-        const v2 = toUnitVector(fromTo(p, circle.center));
-        const cosTheta = dot(v1,v2);
-
-        if (cosTheta > ANGLE_THRESHOLD ||
-            (d < DISTANCE_THRESHOLD_2 && t !== 0 && t !== 1)) {
-
-            // console.log(d, DISTANCE_THRESHOLD2)
-            return cpNode;
-        }
-    }
-
-    return undefined;
-}
-
-
-export { isAnotherCpCloseby }

package/src/mat/simplify-mat-map-only.ts

@@ -1,110 +0,0 @@
-// import { closestPointOnBezier, hausdorffDistance, toCubic } from 'flo-bezier3';
-// import { CpNode, isTerminating } from '../cp-node/cp-node.js';
-// import { getBranches } from './get-branches.js';
-// import { getCurveToNext } from '../cp-node/get-curve-to-next.js';
-// import { getCurveBetween } from '../get-curve/get-curve-between.js';
-
-
-// /**
-//  * Simplifies the given MAT by replacing the piecewise quad beziers composing 
-//  * the MAT with fewer ones to within a given tolerance. Returns the map of
-//  * to be deleted nodes only - does not actually delete them. Use simplifyMat
-//  * instead if you want to delete the nodes.
-//  * @param cpNode A representation of the MAT
-//  * @param anlgeTolerance Tolerance given as the degrees difference of the unit 
-//  * direction vectors at the interface between curves. A tolerance of zero means
-//  * perfect smoothness is required - defaults to 15.
-//  * @param hausdorffTolerance The approximate maximum Hausdorff Distance tolerance -
-//  * defaults to 0.1
-//  * @param hausdorffSpacing The spacing on the curves used to calculate the Hausdorff
-//  * Distance - defaults to 1
-//  */
-// function simplifyMatMapOnly(
-//         cpNode: CpNode,
-//         anlgeTolerance = 15,
-//         hausdorffTolerance = 1e-1,
-//         hausdorffSpacing = 1e0) {
-
-//     const simpleMap: Map<CpNode, { ps: number[][], ts: number[] }> = new Map();
-
-//     // Start from a leaf
-//     while (!isTerminating(cpNode)) {
-//         cpNode = cpNode.next;
-//     }
-
-//     const branches = getBranches(cpNode, anlgeTolerance);
-
-//     const canDeletes: CpNode[] = [];
-//     for (let k=0; k<branches.length; k++) {
-//         const branch = branches[k];
-
-//         // Try to remove some
-//         let j = 0;
-//         while (j < branch.length) {
-//             const i = j;
-//             while (true) {
-//                 j++;
-
-//                 if (j === branch.length) { break; }
-
-//                 const hd = getTotalHausdorffDistance(i, j, branch, hausdorffSpacing);
-
-//                 if (hd > hausdorffTolerance) {
-//                     break;
-//                 } else {
-//                     canDeletes.push(branch[j]);
-//                 }
-//             }
-
-//             if (i + 1 === j) { 
-//                 // no simplification occured
-//             } else {
-//                 const branStart = branch[i];
-//                 const branEnd = branch[j-1];
-
-//                 const medial = toCubic(getCurveBetween(branStart, branEnd.next));
-//                 const rev = medial.slice().reverse();
-//                 let curCpNode = branStart;
-//                 let prevT = 0;
-//                 while (curCpNode !== branEnd) {
-//                     const t = closestPointOnBezier(medial, curCpNode.next.cp.circle.center).t;
-//                     simpleMap.set(curCpNode, { ps: medial, ts: [prevT, t] });
-//                     const oppositeCpNode = curCpNode.nextOnCircle.prev;
-//                     simpleMap.set(oppositeCpNode, { ps: rev, ts: [1-t, 1-prevT] });
-
-//                     prevT = t;
-//                     curCpNode = curCpNode.next;
-//                 }
-//                 simpleMap.set(curCpNode, { ps: medial, ts: [prevT, 1] });
-
-//                 const oppositeCpNode = curCpNode.nextOnCircle.prev;
-//                 simpleMap.set(oppositeCpNode, { ps: rev, ts: [0, 1-prevT] });
-//             }
-//         }
-//     }
-
-//     return { simpleMap, cpNode };
-// }
-
-
-// function getTotalHausdorffDistance(
-//         i: number, 
-//         j: number, 
-//         branch: CpNode[],
-//         hausdorffSpacing: number) {
-
-//     const hds: number[] = [];
-//     const longCurve = getCurveBetween(branch[i], branch[j].next);
-//     for (let m=i; m<j+1; m++) {
-//         hds.push(hausdorffDistance(
-//             getCurveToNext(branch[m]), 
-//             longCurve,
-//             hausdorffSpacing
-//         ));
-//     }
-
-//     return Math.max(...hds);
-// }
-
-
-// export { simplifyMatMapOnly }

package/src/memoize-primitive.ts

@@ -1,31 +0,0 @@
-
-
-/**
- * Memoize (by reference on the input parameter) the given arity 1 function.
- * 
- * * also works with primitive keys
- * * keys will *never* be garbage collected (even if they're not
- * primitive); this may or may not be ok, depending on the use case
- * * will also work with `object`s but since this will hold a reference and
- * prevent garbage collection, rather use `memoize` instead
- */
-function memoizePrimitive<T, U>(f: (a: T) => U): (a: T) => U {
-    const results = new Map<T,U>();
-    
-    return function(a: T): U {
-        let result = results.get(a);
-        if (result !== undefined) {
-            //console.log('cache hit');
-            return result; 
-        }
-
-        //console.log('cache miss');
-        result = f(a);
-        results.set(a, result);
-        
-        return result;
-    }
-}
-
-
-export { memoizePrimitive }

package/src/point-on-shape/create-pos.ts

@@ -1,20 +0,0 @@
-import type { Curve } from "flo-boolean";
-import type { PointOnShape } from "./point-on-shape.js";
-import { evalDeCasteljauDd } from "flo-bezier3";
-
-
-function createPos(
-        curve: Curve,
-        t: number,
-        isSource?: boolean): PointOnShape {
-
-    return {
-        curve,
-        t,
-        p: evalDeCasteljauDd(curve.ps, [0,t]).map(c => c[1]),
-        isSource: isSource === undefined ? false : isSource
-    }
-}
-
-
-export { createPos }

package/src/sat/cull-by-salience.ts

@@ -1,115 +0,0 @@
-import { CpNode } from "../cp-node/cp-node.js";
-import { clone } from "../cp-node/fs/clone.js";
-import { getAllOnCircle } from "../cp-node/fs/get-all-on-circle.js";
-import { getAllOnLoop } from "../cp-node/fs/get-all-on-loop.js";
-import { getNonTerminatingOnCircle } from "../cp-node/fs/get-non-terminating-on-circle.js";
-import { getProngCount } from "../cp-node/fs/get-prong-count.js";
-import { getSalience } from "../cp-node/fs/get-salience.js";
-import { traverseAllForward } from "../cp-node/fs/traverse-all-forward.js";
-import { createNewCpTree } from "../mat/create-new-cp-tree.js";
-import { getLargest3Prong } from "../mat/get-largest-3-prong.js";
-import { Mat } from "../mat/mat.js";
-
-
-function cullBySalience(
-        minSalience: number,
-        mat: Mat) {
-
-    // get largest 3-prong
-    const cpNode = getLargest3Prong(clone(mat.cpNode));
-    if (cpNode === undefined) {
-        return mat;
-    }
-
-    // get all 3-prongs (even if having terminal prongs)
-    const cpNodesOnThreeProngs = new Set(
-        getAllOnLoop(cpNode)
-        .filter(cpNode => getProngCount(cpNode) > 2)
-    );
-
-
-    // add culls according to salience
-    const culls: Set<CpNode> = new Set();
-    for (const cpNode of cpNodesOnThreeProngs) {
-        const cpNodesOC = getNonTerminatingOnCircle(cpNode);
-        for (const cpNodeOC of cpNodesOC) {
-            const salience = getSalience(cpNodeOC)
-            if (salience < minSalience) {
-                culls.add(cpNodeOC);
-            }
-        }
-    }
-
-
-    // Get all 3-prongs that have been culled, including those on culled
-    // branches.
-    const culled3ProngCpNodes: Set<CpNode> = new Set();
-    for (const cull of culls) {
-        // cull branch and return all 3-prong cp-nodes on the culled branch
-        const culled3ProngsToAdd = cullBranch(cull);
-        for (const cpNode of culled3ProngsToAdd) {
-            culled3ProngCpNodes.add(cpNode);
-        }
-    }
-
-    // Find 3-prong not culled and assign to `cpNodeT`
-    let cpNodeT: CpNode | undefined = undefined;
-    for (const cpNode of cpNodesOnThreeProngs) {
-        if (!culled3ProngCpNodes.has(cpNode)) {
-            cpNodeT = cpNode;
-            break;
-        }
-    }
-
-    // Special case: only one completely terminating 3-prong survives
-    if (cpNodeT === undefined) {
-        // Return the largest 3-prong with all branches snipped
-        cpNodeT = cpNode;
-        for (const b of getAllOnCircle(cpNode)) {
-            b.next = b.nextOnCircle;
-            b.prev = b.prevOnCircle;
-        }
-    }
-
-    const sat: Mat = {
-        cpNode: cpNodeT,
-        meta: {
-            ...mat.meta,
-            cpTrees: createNewCpTree(cpNodeT)
-        }
-    };
-
-    return sat;
-}
-
-
-/**
- * Cull branch and return all 3-prong cp-nodes on the culled branch
- */ 
-function cullBranch(
-        cpNode: CpNode): Set<CpNode> {
-
-    const cull = cpNode;
-    const culledCpNodes = new Set<CpNode>();
-
-    culledCpNodes.add(cull);
-    traverseAllForward(cull, cpNode_ => {
-        if (getProngCount(cpNode_) >= 3 &&
-            cpNode_ !== cull) {
-
-            for (const cpN of getAllOnCircle(cpNode_)) {
-                culledCpNodes.add(cpN);
-            }
-        }
-    });
-
-    const cpNodeNOC = cull.nextOnCircle;
-
-    cull.next = cpNodeNOC;
-    cpNodeNOC.prev = cull;
-
-    return culledCpNodes;
-}
-
-
-export { cullBySalience }

package/src/svg/get-extreme.ts

@@ -1,23 +0,0 @@
-import { Loop } from 'flo-boolean';
-import { getShapeBounds } from './get-shape-bounds.js';
-
-
-/**
- * @hidden
- * Returns the max extreme point coordinate value for the given shape. This is
- * used for floating point tolerance calculations.
- * @param loops 
- */
-function getExtreme(loops: Loop[]) {
-    const bounds = getShapeBounds(loops);
-    
-    return Math.max(  
-            Math.abs(bounds.minX.p[0]),
-            Math.abs(bounds.minY.p[1]),
-            Math.abs(bounds.maxX.p[0]),
-            Math.abs(bounds.maxY.p[1])
-    );
-}
-
-
-export { getExtreme }

package/src/utils/bezier-piece-to-bezier.ts

@@ -1,13 +0,0 @@
-// import { BezierPiece, fromTo } from "flo-bezier3";
-
-
-// function bezierPieceToBezier(
-//         piece: BezierPiece) {
-
-//     const { ps, ts } = piece;
-
-//     return fromTo(ps, ts[0], ts[1]);
-// }
-
-
-// export { bezierPieceToBezier }

package/src/utils/sleep.ts

@@ -1,7 +0,0 @@
-
-function sleep(ms: number) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-
-export { sleep }