flo-mat 4.1.5 → 5.0.2

package/src/find-2-prong/cull-bezier-pieces.ts

@@ -1,61 +0,0 @@
-import type { CurvePiece } from '../mat/curve-piece.js';
-import { getClosestSquareDistanceToRect } from '../geometry/get-closest-square-distance-to-rect.js';
-import { getBoundingBox$ } from '../geometry/get-bounding-box-.js';
-import { memoize } from 'flo-memoize';
-import { getBoundingBoxTight } from 'flo-bezier3';
-import { getClosestSquaredDistanceToRotatedRect } from '../geometry/get-closest-squared-distance-to-rotated-rect.js';
-
-
-const TOLERANCE = 1 + 2**-20;
-const getBoundingBoxTight$ = memoize(getBoundingBoxTight);
-
-
-/**
- * Cull all `curvePieces` not within the given radius of a given point.
- * 
- * @param extreme
- * @param curvePieces
- * @param xO
- * @param xy2
- * 
- * @internal
- */
-function cullCurvePieces(
-        curvePieces: CurvePiece[], 
-        xO: number[], 
-        xy2: number): CurvePiece[] {
-
-    if (curvePieces.length <= 2) {
-        // Curve pieces can never be less than 2 at this stage since a curve
-        // endpoint will be shared between 2 curves
-        return curvePieces as CurvePiece[];
-    }
-
-    let lastIdx = 0;
-    for (let i=0; i<curvePieces.length; i++) {
-        const curvePiece = curvePieces[i];
-        const { ps } = curvePiece.curve;
-        
-        const rect = getBoundingBox$(ps);
-        const d = getClosestSquareDistanceToRect(rect, xO);
-        if (d <= TOLERANCE*xy2) {
-            const tightBoundingBox = getBoundingBoxTight$(ps);
-            const d2 = getClosestSquaredDistanceToRotatedRect(
-                tightBoundingBox,
-                xO
-            );
-
-            if (d2 <= TOLERANCE*xy2) {
-                curvePieces[lastIdx] = curvePiece;
-                lastIdx++;
-            }
-        } 
-    }
-
-    curvePieces.length = lastIdx;
-
-    return curvePieces;
-}
-
-
-export { cullCurvePieces }

package/src/find-2-prong/find-and-add-2-prong.ts

@@ -1,30 +0,0 @@
-// import type { CpNode } from "../cp-node/cp-node.js";
-// import type { MatMeta } from "../mat/mat-meta.js";
-// import type { PrePointOnShape } from "../point-on-shape/point-on-shape.js";
-// import { add2Prong } from "./add-2-prong.js";
-// import { find2Prong } from "./find-2-prong.js";
-
-
-// /**
-//  * Just to simplify `find2Prong` a bit.
-//  * 
-//  * * Cannot be used with holeClosers or angles other than 0
-//  * * Can be used after the mat has been found
-//  */
-// function findAndAdd2Prong(
-//         meta: MatMeta,
-//         y: PrePointOnShape): CpNode | undefined {
-
-//     const twoProngInfo = find2Prong(meta, false, false, 0, y);
-//     if (twoProngInfo === undefined) {
-//         return undefined;
-//     }
-
-//     const { circle, z } = twoProngInfo;
-//     const cpNode = add2Prong(meta, circle, y, z, false);
-
-//     return cpNode;
-// }
-
-
-// export { findAndAdd2Prong }

package/src/find-2-prong/get-medial/get-closest-points-d.ts

@@ -1,213 +0,0 @@
-import type { RootInterval } from 'flo-poly';
-import type { CurvePiece } from "../../mat/curve-piece.js";
-import type { PrePointOnShape } from "../../point-on-shape/point-on-shape.js";
-import type { AntipodalPoint } from './antipodal-point.js';
-import { lengthSquared } from "flo-vector2d";
-import { roots, Horner } from 'flo-poly';
-import { evalDeCasteljau, getMedialPointCoeffs, getMedialPointCoeffsBez0, getMedialPointCoeffsBez2_SameCurve, getMedialPointCoeffsBez3_SameCurve } from 'flo-bezier3';
-
-const { sqrt, abs, max } = Math;
-
-
-/**
- * @param maxCoordPowerOf2
- * @param nnorm
- * @param yPos The point on the shape
- * @param for1Prong defaults to `false`;
- * @param angle defaults to `0`;
- * @param curvePiece The curve piece
- * 
- * @internal
- */
-function getClosestPoint(
-        maxCoordPowerOf2: number,
-        nnorm: number[], 
-        nnormDd: number[][],
-        yPos: PrePointOnShape,
-        for1Prong: boolean,
-        angle: number,
-        curvePiece: CurvePiece): AntipodalPoint[] {
-
-    const { curve, ts: [tS,tE] } = curvePiece;
-    const { ps } = curve;
-    const { curve: touchedCurve, t, p: y, pDd: yDd } = yPos;
-
-    const isTouched = curve === touchedCurve;
-    const shouldDeflate = angle === 0 && isTouched;
-
-    const infos: AntipodalPoint[] = [];
-    let startPushed = false;
-    let endPushed = false;
-
-    let ss: RootInterval[];
-    if (tS !== tE &&
-        !(shouldDeflate && ps.length === 2) &&
-        !(isTouched && ps.length === 3 && for1Prong)) {
-
-        const { A, B, H } = shouldDeflate
-            ? ps.length === 3
-                ? getMedialPointCoeffsBez2_SameCurve(t, nnorm, ps)
-                : getMedialPointCoeffsBez3_SameCurve(t, nnorm, ps)
-            : getMedialPointCoeffs(y, nnorm, ps);
-        
-        ss = roots(H, tS, tE) || [];
-        //-----------------------
-
-        for (let i=0; i<ss.length; i++) {
-            const ri = ss[i];
-            const { tS: sS, tE: sE, t: _s } = ri;
-            if (ri.multiplicity > 1) {
-                continue;
-            }
-
-            if (sE < tS || sS > tE) { continue; }  // outside curve piece
-            if (sS < 0) { continue; }  // outside curve piece
-
-            // clip to [0,1]
-            const s = sE > 1 ? 1 : _s;
-
-            //-----------------------
-            const AS = Horner(A, s);
-            const BS = Horner(B, s);
-            // const CS = Horner(C, s);
-            // const DS = Horner(D, s);
-
-            const _AS = abs(AS);
-            // const _CS = abs(CS);
-
-            // if (max(_AS, _CS) < 2**-40) { continue; }
-            if (max(_AS) < 2**-40) { continue; }
-
-            // const w = _AS > _CS
-            //     ? -BS / AS
-            //     : -DS / CS;  // alternative
-            const w = -BS / AS;
-
-            if (w <= 0) {
-                // If `w` is negative the circle radius is negative -> discard
-                continue;
-            }
-
-            const V = [w*nnorm[0], w*nnorm[1]];
-            const d = sqrt(lengthSquared(V));
-
-            if (d <= 2**(maxCoordPowerOf2 - 40)) {
-                // If `w` <= 2**-40 -> discard
-                continue;
-            }
-
-            const x = [y[0] + V[0], y[1] + V[1]];
-            //-----------------------
-
-            if (ri.tS <= tS && ri.tE >= tS) {
-                startPushed = true;
-            }
-            if (ri.tS <= tE && ri.tE >= tE) {
-                endPushed = true;
-            }
-
-
-            // If the point is the first control point of the curve then we
-            // ensure the point becomes the last control point of the prior
-            // curve to induce some symmetery and simplify the algorithm.
-            const s_ = s === 0 ? 1 : s;
-            const curve_ = s === 0 ? curve.prev : curve;
-
-            const info: AntipodalPoint = {
-                curve: curve_,
-                s: s_,
-                d, x
-            };
-
-            infos.push(info);
-        }
-    }
-    
-
-
-    //------------------------------------------
-    const pLast = ps[ps.length - 1];
-
-    let dontPush1 = (
-        (t === 0 && curve === touchedCurve!.prev) ||
-        (t === 1 && curve === touchedCurve)
-    );
-
-    
-    //--------------------------------------
-    // Also check curve start control point
-    //--------------------------------------
-    const PS: { P: number[], t: number }[] = [];
-    if (tS === 0) {
-        // We never check points at `t === 0` since they are covered by the previous curve's endpoint
-        // which cannot be culled if this curve`s `t === 0` is included
-    } else if (tS === 1) {
-        if (!dontPush1 && !startPushed) {
-            PS.push({ P: pLast, t: 1 });
-        }
-    } else {
-        if (!startPushed) {
-            const pp = evalDeCasteljau(ps, tS);
-            PS.push({ P: pp, t: tS });
-        }
-    }
-
-    //--------------------------------------
-    // Also check curve end control point
-    //--------------------------------------
-    if (tS !== tE) {
-        if (tE === 0) {
-            // We never check points at `t === 0` since they are covered by the previous curve's endpoint
-            // which cannot be culled if this curve`s `t === 0` is included
-        } else if (tE === 1) {
-            if (!dontPush1 && !endPushed) {
-                PS.push({ P: pLast, t: 1 }); dontPush1 = true;
-            }
-        } else {
-            if (!endPushed) {
-                const pp = evalDeCasteljau(ps, tE);
-                PS.push({ P: pp, t: tE });
-            }
-        }
-    }
-    //------------------------------------------
-
-
-    for (let i=0; i<PS.length; i++) {
-        //-----------------------
-        const { P, t: s } = PS[i];
-        const { a0, b0 } = getMedialPointCoeffsBez0(y,nnorm,P);
-
-        if (abs(a0) <= 2**-40 || abs(b0) <= 2**-40) {
-            continue;
-        }
-
-        const w = -b0 / a0;
-
-        // too close to point of origin *or* negative;
-        if (w < 2**-40) {
-            continue;
-        }
-
-        const V = [w*nnorm[0], w*nnorm[1]];
-        const d = sqrt(lengthSquared(V));
-
-        const x = [y[0] + V[0], y[1] + V[1]];
-
-        const s_ = s === 0 ? 1 : s;
-        const curve_ = s === 0 ? curve.prev : curve;
-
-        const info: AntipodalPoint = {
-            curve: curve_,
-            s: s_,
-            d, x
-        };
-
-        infos.push(info);
-    }
-
-    return infos;
-}
-
-
-export { getClosestPoint }

package/src/find-2-prong/x-for-debugging.ts

@@ -1,13 +0,0 @@
-// import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-
-
-// /** @internal */
-// type TXForDebugging = { 
-//     x: number[]; 
-//     y: PointOnShape; 
-//     z: PointOnShape; 
-//     t: number; 
-// }
-
-
-// export { TXForDebugging }

package/src/floyd-warshall/get-hole-closer-pairs.ts

@@ -1,35 +0,0 @@
-import type { CpNode } from "../cp-node/cp-node.js";
-
-
-/**
- * 
- * @param holeClosers 
- * @returns 
- */
-// FUTURE - this function is currently O(n^2) but could be made O(n).
-// FUTURE - only `pointOnShape.p` is checked but `pointOnShape.t` should also be checked
-// or better yet, `CpNode.cp.order` and `CpNode.cp.order2`, etc.
-function getHoleCloserPairs(
-        holeClosers: CpNode[]): Map<CpNode,CpNode> {
-
-    const pairs: Map<CpNode,CpNode> = new Map();
-    for (let hcA of holeClosers) {
-        for (let hcB of holeClosers) {
-            const cA = hcA.pointOnShape!.circle!.center;
-            const cB = hcB.pointOnShape!.circle!.center;
-            const cpA = hcA.pointOnShape!.p;
-            const cpB = hcB.pointOnShape!.p;
-            if (hcB !== hcA &&
-                cA[0] === cB[0] && cA[1] === cB[1] &&
-                cpA[0] === cpB[0] && cpA[1] === cpB[1]) {
-
-                pairs.set(hcA,hcB);
-            }
-        }
-    }
-
-    return pairs;
-}
-
-
-export { getHoleCloserPairs }

package/src/mat/get-two-prong-type.ts

@@ -1,13 +0,0 @@
-// import { TwoProngForDebugging } from '../debug/two-prong-for-debugging.js';
-// import { ElemType_TwoProng } from './elem-type-two-prong.js';
-
-
-// /** @internal */
-// function getTwoProngType(e: TwoProngForDebugging): ElemType_TwoProng {
-//     if (e.holeClosing) { return 'twoProng_holeClosing' }
-    
-//     return 'twoProng_regular';
-// }
-
-
-// export { getTwoProngType }

package/src/point-on-shape/is-pos-dull-corner.ts

@@ -1,18 +0,0 @@
-import type { PointOnShape } from "./point-on-shape.js";
-import { getPosCorner$ } from "./get-pos-corner.js";
-import { isPosCorner } from "./is-pos-corner.js";
-
-
-/**
- * @internal
- */
-function isPosDullCorner(
-        pos: PointOnShape) {
-
-    if (!isPosCorner(pos)) { return false; }
-
-    return getPosCorner$(pos).isDull;
-}
-
-
-export { isPosDullCorner }

package/src/point-on-shape/is-pos-quite-dull-corner.ts

@@ -1,18 +0,0 @@
-import type { PointOnShape } from "./point-on-shape.js";
-import { isPosCorner } from './is-pos-corner.js';
-import { getPosCorner$ } from './get-pos-corner.js';
-
-
-/**
- * @internal
- */
-function isPosQuiteDullCorner(
-        pos: PointOnShape) {
-
-    if (!isPosCorner(pos)) { return false; }
-
-    return getPosCorner$(pos).isQuiteDull;
-}
-
-
-export { isPosQuiteDullCorner }

package/src/point-on-shape/is-pos-quite-sharp-corner.ts

@@ -1,18 +0,0 @@
-import type { PointOnShape } from "./point-on-shape.js";
-import { isPosCorner } from './is-pos-corner.js';
-import { getPosCorner$ } from './get-pos-corner.js';
-
-
-/**
- * @internal
- */
-function isPosQuiteSharpCorner(
-        pos: PointOnShape) {
-
-    if (!isPosCorner(pos)) { return false; }
-
-    return getPosCorner$(pos).isQuiteSharp;
-}
-
-
-export { isPosQuiteSharpCorner }

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

@@ -1,18 +0,0 @@
-import type { PointOnShape } from "./point-on-shape.js";
-
-
-/**
- * Returns a human-readable string of the given `PointOnShape`.
- * For debugging only.
- * @internal
- */
-function posToHumanString(
-        pos: PointOnShape) {
-
-    return '' + pos.p[0] + ', ' + pos.p[1] + 
-        ' | bz: '   + pos.curve.idx + 
-        ' | t: '    + pos.t 
-}
-
-
-export { posToHumanString }

package/src/sweep-line/are-boxes-intersecting.ts

@@ -1,37 +0,0 @@
-
-/**
- * Returns true if the 2 given (closed) boxes intersect. At this stage we already
- * know their x-axis intersect.
- * @param a A rectangular box
- * @param a Another rectangular box
- * @param closed (defaults to true) Interpret boxes as being closed (i.e. they
- * contain their border) or open.
- * 
- * @internal
- */
-function areBoxesIntersecting(closed: boolean) {
-    return (a: number[][], b: number[][]): boolean => {
-
-        let [[ax0, ay0],[ax1, ay1]] = a;
-        let [[bx0, by0],[bx1, by1]] = b;
-
-        // Swap so smaller coordinate comes first
-        if (ay0 > ay1) { [ay0,ay1] = [ay1,ay0] }
-        if (by0 > by1) { [by0,by1] = [by1,by0] }
-        if (ax0 > ax1) { [ax0,ax1] = [ax1,ax0] }
-        if (bx0 > bx1) { [bx0,bx1] = [bx1,bx0] }
-
-        return closed
-            ? (
-                ax0 <= bx1 && ax1 >= bx0 && 
-                by0 <= ay1 && by1 >= ay0
-            )
-            : (
-                ax0 < bx1 && ax1 > bx0 && 
-                by0 < ay1 && by1 > ay0
-            );
-    }
-}
-
-
-export { areBoxesIntersecting }