@ccpc/math 0.1.0 → 0.1.7

package/dist/intersections/analytic_x_algorithm.js

@@ -1,83 +0,0 @@
-import { MathError } from '../utils/math_error';
-import { getCurveKind } from './internal/kind';
-import { normalizePair } from './internal/pair';
-import { analyzeCurveXInfosQuality, postprocessCurveXInfos, swapCurveXInfos } from './internal/result';
-import { makeIntersectionTolerance } from './internal/tolerance';
-import { ArcArcPairSolver, ArcEllipseArcPairSolver, ArcEllipsePairSolver, CircleArcPairSolver, CircleCirclePairSolver, CircleEllipseArcPairSolver, CircleEllipsePairSolver, EllipseArcEllipseArcPairSolver, EllipseEllipseArcPairSolver, EllipseEllipsePairSolver, LineArcPairSolver, LineCirclePairSolver, LineEllipseArcPairSolver, LineEllipsePairSolver, LineLinePairSolver, } from './solvers/pair_solvers';
-import { PolylinePairIntersector } from './solvers/polyline_pair_intersector';
-export class AnalyticXAlgorithm {
-    constructor() {
-        this.map = {
-            'line|line': new LineLinePairSolver(),
-            'line|circle': new LineCirclePairSolver(),
-            'line|arc': new LineArcPairSolver(),
-            'line|ellipse': new LineEllipsePairSolver(),
-            'line|ellipseArc': new LineEllipseArcPairSolver(),
-            'circle|circle': new CircleCirclePairSolver(),
-            'circle|arc': new CircleArcPairSolver(),
-            'circle|ellipse': new CircleEllipsePairSolver(),
-            'circle|ellipseArc': new CircleEllipseArcPairSolver(),
-            'arc|arc': new ArcArcPairSolver(),
-            'arc|ellipse': new ArcEllipsePairSolver(),
-            'arc|ellipseArc': new ArcEllipseArcPairSolver(),
-            'ellipse|ellipse': new EllipseEllipsePairSolver(),
-            'ellipse|ellipseArc': new EllipseEllipseArcPairSolver(),
-            'ellipseArc|ellipseArc': new EllipseArcEllipseArcPairSolver(),
-        };
-        this.retryMap = {
-            'circle|ellipse': new PolylinePairIntersector(320, 96),
-            'circle|ellipseArc': new PolylinePairIntersector(320, 96),
-            'arc|ellipse': new PolylinePairIntersector(320, 96),
-            'arc|ellipseArc': new PolylinePairIntersector(320, 96),
-            'ellipse|ellipse': new PolylinePairIntersector(352, 96),
-            'ellipse|ellipseArc': new PolylinePairIntersector(352, 96),
-            'ellipseArc|ellipseArc': new PolylinePairIntersector(352, 96),
-        };
-    }
-    intersect(c1, c2) {
-        const k1 = getCurveKind(c1);
-        const k2 = getCurveKind(c2);
-        const pair = normalizePair(k1, k2);
-        const solver = this.map[pair.key];
-        if (!solver) {
-            MathError.throw(`AnalyticXAlgorithm: unsupported pair ${c1.getType()}|${c2.getType()}`);
-        }
-        const tol = makeIntersectionTolerance(c1, c2);
-        const diagBefore = PolylinePairIntersector.getDiagnostics();
-        const raw = pair.swapped ? solver.intersect(c2, c1) : solver.intersect(c1, c2);
-        const ordered = pair.swapped ? swapCurveXInfos(raw) : raw;
-        const primary = postprocessCurveXInfos(ordered, tol.pointTol);
-        const quality = analyzeCurveXInfosQuality(ordered, tol.pointTol);
-        if (!this.shouldRetry(pair.key, c1, c2, quality, diagBefore, PolylinePairIntersector.getDiagnostics())) {
-            return primary;
-        }
-        const retrySolver = this.retryMap[pair.key];
-        if (!retrySolver)
-            return primary;
-        const retryRaw = pair.swapped ? retrySolver.intersect(c2, c1) : retrySolver.intersect(c1, c2);
-        if (retryRaw.length === 0)
-            return primary;
-        const retryOrdered = pair.swapped ? swapCurveXInfos(retryRaw) : retryRaw;
-        return postprocessCurveXInfos([...ordered, ...retryOrdered], tol.pointTol);
-    }
-    shouldRetry(key, c1, c2, quality, before, after) {
-        if (!this.retryMap[key])
-            return false;
-        if (!this.boxesLikelyIntersect(c1, c2))
-            return false;
-        if (quality.rawCount === 0)
-            return true;
-        if (quality.duplicatePointCount > 0)
-            return true;
-        const certificationMissDelta = after.certificationMissCount - before.certificationMissCount;
-        const refineFailDelta = after.refineFailureCount - before.refineFailureCount;
-        const rejectDelta = after.certificationRejectCount - before.certificationRejectCount;
-        return certificationMissDelta > 0 || refineFailDelta > 0 || rejectDelta > 0;
-    }
-    boxesLikelyIntersect(c1, c2) {
-        const t = makeIntersectionTolerance(c1, c2);
-        const b1 = c1.boundingBox().expandByScalar(t.pointTol * 2);
-        const b2 = c2.boundingBox().expandByScalar(t.pointTol * 2);
-        return b1.intersects(b2);
-    }
-}

package/dist/intersections/curve_x_engine.d.ts

@@ -1,9 +0,0 @@
-import type { Curve2 } from '../curves/curve2';
-import type { CurveXInfo } from './types';
-export declare class CurveXEngine {
-    private readonly analytic;
-    private readonly numeric;
-    intersect(c1: Curve2, c2: Curve2): CurveXInfo[];
-    private shouldUseNumeric;
-}
-//# sourceMappingURL=curve_x_engine.d.ts.map

package/dist/intersections/curve_x_engine.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"curve_x_engine.d.ts","sourceRoot":"","sources":["../../src/intersections/curve_x_engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAI9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC,qBAAa,YAAY;IACrB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA2B;IACpD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0B;IAE3C,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,UAAU,EAAE;IAkBtD,OAAO,CAAC,gBAAgB;CAG3B"}

package/dist/intersections/curve_x_engine.js

@@ -1,27 +0,0 @@
-import { MathError } from '../utils/math_error';
-import { AnalyticXAlgorithm } from './analytic_x_algorithm';
-import { NumericXAlgorithm } from './numeric_x_algorithm';
-export class CurveXEngine {
-    constructor() {
-        this.analytic = new AnalyticXAlgorithm();
-        this.numeric = new NumericXAlgorithm();
-    }
-    intersect(c1, c2) {
-        if (this.shouldUseNumeric(c1, c2)) {
-            return this.numeric.intersect(c1, c2);
-        }
-        try {
-            return this.analytic.intersect(c1, c2);
-        }
-        catch (error) {
-            if (error instanceof MathError &&
-                error.message.startsWith('AnalyticXAlgorithm: unsupported pair')) {
-                return this.numeric.intersect(c1, c2);
-            }
-            throw error;
-        }
-    }
-    shouldUseNumeric(c1, c2) {
-        return c1.isBSpline() || c2.isBSpline();
-    }
-}

package/dist/intersections/index.d.ts

@@ -1,5 +0,0 @@
-import type { Curve2 } from '../curves/curve2';
-export type { CurveXInfo } from './types';
-export declare function intersectCurveCurve(c1: Curve2, c2: Curve2): import("./types").CurveXInfo[];
-export declare function intersectCurveSelf(curve: Curve2): import("./types").CurveXInfo[];
-//# sourceMappingURL=index.d.ts.map

package/dist/intersections/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/intersections/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAI9C,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAIzC,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,kCAEzD;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,kCAG/C"}

package/dist/intersections/index.js

@@ -1,11 +0,0 @@
-import { CurveXEngine } from './curve_x_engine';
-import { intersectBSplineSelf } from './solvers/bspline_self_solver';
-const curveXEngine = new CurveXEngine();
-export function intersectCurveCurve(c1, c2) {
-    return curveXEngine.intersect(c1, c2);
-}
-export function intersectCurveSelf(curve) {
-    if (!curve.isBSpline())
-        return [];
-    return intersectBSplineSelf(curve);
-}

package/dist/intersections/internal/certification.d.ts

@@ -1,34 +0,0 @@
-import { Interval } from '../../curves/interval';
-import type { Curve2 } from '../../curves/curve2';
-import type { Vec2 } from '../../core/vec2';
-export type ClosestPointLike = {
-    param: number;
-    distance: number;
-};
-export type ClosestPointProvider = (curve: Curve2, p: Vec2, tol: number) => ClosestPointLike | undefined;
-export type ParamPairCandidate = {
-    u1: number;
-    u2: number;
-    residual: number;
-};
-export type CertifiedParamPair = {
-    point: Vec2;
-    u1: number;
-    u2: number;
-    residual: number;
-};
-export type ResidualEnvelope = {
-    lowerBound: number;
-    upperBound: number;
-    minSample: number;
-    maxSample: number;
-};
-export type CertificationOutcome = {
-    pair: CertifiedParamPair;
-    usedDegenerateRescue: boolean;
-    envelopeUpperBound: number;
-};
-export declare function certifyParamPair(c1: Curve2, c2: Curve2, candidate: ParamPairCandidate, tol: number, closestPoint: ClosestPointProvider): CertificationOutcome | undefined;
-export declare function projectRangeToCurve(baseCurve: Curve2, otherCurve: Curve2, rangeOnBase: Interval, tol: number, closestPoint: ClosestPointProvider): Interval | undefined;
-export declare function certifyOverlapMonotone(baseCurve: Curve2, otherCurve: Curve2, rangeOnBase: Interval, tol: number, paramTol: number, closestPoint: ClosestPointProvider): boolean;
-//# sourceMappingURL=certification.d.ts.map

package/dist/intersections/internal/certification.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"certification.d.ts","sourceRoot":"","sources":["../../../src/intersections/internal/certification.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AACjD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAE3C,MAAM,MAAM,gBAAgB,GAAG;IAC3B,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,KAAK,gBAAgB,GAAG,SAAS,CAAA;AAExG,MAAM,MAAM,kBAAkB,GAAG;IAC7B,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,QAAQ,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC7B,KAAK,EAAE,IAAI,CAAA;IACX,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,QAAQ,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC3B,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IAC/B,IAAI,EAAE,kBAAkB,CAAA;IACxB,oBAAoB,EAAE,OAAO,CAAA;IAC7B,kBAAkB,EAAE,MAAM,CAAA;CAC7B,CAAA;AAED,wBAAgB,gBAAgB,CAC5B,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,SAAS,EAAE,kBAAkB,EAC7B,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,oBAAoB,GACnC,oBAAoB,GAAG,SAAS,CAwBlC;AAED,wBAAgB,mBAAmB,CAC/B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,QAAQ,EACrB,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,oBAAoB,GACnC,QAAQ,GAAG,SAAS,CAOtB;AAED,wBAAgB,sBAAsB,CAClC,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,QAAQ,EACrB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,oBAAoB,WAuBrC"}

package/dist/intersections/internal/certification.js

@@ -1,238 +0,0 @@
-import { Interval } from '../../curves/interval';
-import { Precision } from '../../utils/precision';
-export function certifyParamPair(c1, c2, candidate, tol, closestPoint) {
-    const cp2 = closestPoint(c2, c1.pointAt(candidate.u1), tol * 2);
-    const cp1 = closestPoint(c1, c2.pointAt(candidate.u2), tol * 2);
-    if (!cp1 || !cp2)
-        return undefined;
-    if (cp1.distance > tol * 3 || cp2.distance > tol * 3)
-        return undefined;
-    const measured = measureParamPair(c1, c2, cp1.param, cp2.param);
-    if (measured.residual > tol * 3)
-        return undefined;
-    const envelope = estimateResidualEnvelopeAdaptive(c1, c2, measured.u1, measured.u2, 4);
-    if (envelope.upperBound <= tol * 6) {
-        return {
-            pair: measured,
-            usedDegenerateRescue: false,
-            envelopeUpperBound: envelope.upperBound,
-        };
-    }
-    if (!isNearDegenerate(c1, c2, measured.u1, measured.u2))
-        return undefined;
-    const rescued = tryDegenerateRescue(c1, c2, measured, tol, closestPoint);
-    if (!rescued)
-        return undefined;
-    return {
-        pair: rescued.pair,
-        usedDegenerateRescue: true,
-        envelopeUpperBound: rescued.envelope.upperBound,
-    };
-}
-export function projectRangeToCurve(baseCurve, otherCurve, rangeOnBase, tol, closestPoint) {
-    const startOnBase = baseCurve.pointAt(rangeOnBase.start);
-    const endOnBase = baseCurve.pointAt(rangeOnBase.end);
-    const cpStart = closestPoint(otherCurve, startOnBase, tol);
-    const cpEnd = closestPoint(otherCurve, endOnBase, tol);
-    if (!cpStart || !cpEnd)
-        return undefined;
-    return new Interval(Math.min(cpStart.param, cpEnd.param), Math.max(cpStart.param, cpEnd.param));
-}
-export function certifyOverlapMonotone(baseCurve, otherCurve, rangeOnBase, tol, paramTol, closestPoint) {
-    const samples = [0, 0.25, 0.5, 0.75, 1];
-    let pass = 0;
-    const paramsOnOther = [];
-    for (const t of samples) {
-        const u = rangeOnBase.start + (rangeOnBase.end - rangeOnBase.start) * t;
-        const p = baseCurve.pointAt(u);
-        const cp = closestPoint(otherCurve, p, tol);
-        if (!cp)
-            continue;
-        paramsOnOther.push(cp.param);
-        if (cp.distance <= tol * 2.5)
-            pass++;
-    }
-    if (pass < 4 || paramsOnOther.length < 4)
-        return false;
-    let nonDecreasing = true;
-    let nonIncreasing = true;
-    for (let i = 1; i < paramsOnOther.length; i++) {
-        if (paramsOnOther[i] < paramsOnOther[i - 1] - paramTol)
-            nonDecreasing = false;
-        if (paramsOnOther[i] > paramsOnOther[i - 1] + paramTol)
-            nonIncreasing = false;
-    }
-    return nonDecreasing || nonIncreasing;
-}
-function measureParamPair(c1, c2, u1, u2) {
-    const p1 = c1.pointAt(u1);
-    const p2 = c2.pointAt(u2);
-    return {
-        u1,
-        u2,
-        point: p1.added(p2).scale(0.5),
-        residual: p1.distanceTo(p2),
-    };
-}
-function estimateResidualEnvelopeAdaptive(c1, c2, u1, u2, maxDepth) {
-    let w1 = buildCertificationWindow(c1, u1, 1);
-    let w2 = buildCertificationWindow(c2, u2, 1);
-    let upper = Number.POSITIVE_INFINITY;
-    let lower = 0;
-    let minSample = Number.POSITIVE_INFINITY;
-    let maxSample = 0;
-    for (let depth = 0; depth <= maxDepth; depth++) {
-        const env = evaluateWindowEnvelope(c1, c2, w1, w2);
-        lower = Math.max(lower, env.lowerBound);
-        upper = Math.min(upper, env.upperBound);
-        minSample = Math.min(minSample, env.minSample);
-        maxSample = Math.max(maxSample, env.maxSample);
-        if (w1.length() <= Precision.CURVE_PARAM_EPS * 32 && w2.length() <= Precision.CURVE_PARAM_EPS * 32) {
-            break;
-        }
-        w1 = shrinkWindowAroundParam(c1, w1, u1, 0.5);
-        w2 = shrinkWindowAroundParam(c2, w2, u2, 0.5);
-    }
-    const half1 = 0.5 * (w1.end - w1.start);
-    const half2 = 0.5 * (w2.end - w2.start);
-    const l1 = maxTangentNorm(c1, w1);
-    const l2 = maxTangentNorm(c2, w2);
-    const drift = l1 * half1 + l2 * half2;
-    const conservativeUpper = Number.isFinite(upper) ? upper + drift * 0.25 : maxSample + drift;
-    const conservativeLower = Math.max(0, lower - drift * 0.25);
-    return {
-        lowerBound: conservativeLower,
-        upperBound: Math.max(conservativeUpper, maxSample),
-        minSample,
-        maxSample,
-    };
-}
-function tryDegenerateRescue(c1, c2, measured, tol, closestPoint) {
-    const w1 = buildCertificationWindow(c1, measured.u1, 2);
-    const w2 = buildCertificationWindow(c2, measured.u2, 2);
-    const grid = sampleInterval5(w1);
-    const grid2 = sampleInterval5(w2);
-    let best = measured;
-    for (const u of grid) {
-        const p1 = c1.pointAt(u);
-        for (const v of grid2) {
-            const p2 = c2.pointAt(v);
-            const d = p1.distanceTo(p2);
-            if (d >= best.residual)
-                continue;
-            best = {
-                u1: u,
-                u2: v,
-                point: p1.added(p2).scale(0.5),
-                residual: d,
-            };
-        }
-    }
-    const cp2 = closestPoint(c2, c1.pointAt(best.u1), tol * 3);
-    if (cp2) {
-        const cp1 = closestPoint(c1, c2.pointAt(cp2.param), tol * 3);
-        if (cp1) {
-            best = measureParamPair(c1, c2, cp1.param, cp2.param);
-        }
-    }
-    if (best.residual > tol * 2.8)
-        return undefined;
-    const envelope = evaluateWindowEnvelope(c1, c2, buildCertificationWindow(c1, best.u1, 1), buildCertificationWindow(c2, best.u2, 1));
-    if (envelope.upperBound > tol * 8)
-        return undefined;
-    return {
-        pair: best,
-        envelope,
-    };
-}
-function evaluateWindowEnvelope(c1, c2, w1, w2) {
-    const uSamples = sampleInterval5(w1);
-    const vSamples = sampleInterval5(w2);
-    let minSample = Number.POSITIVE_INFINITY;
-    let maxSample = 0;
-    for (const a of uSamples) {
-        const p1 = c1.pointAt(a);
-        for (const b of vSamples) {
-            const p2 = c2.pointAt(b);
-            const r = p1.distanceTo(p2);
-            if (r < minSample)
-                minSample = r;
-            if (r > maxSample)
-                maxSample = r;
-        }
-    }
-    const half1 = 0.5 * (w1.end - w1.start);
-    const half2 = 0.5 * (w2.end - w2.start);
-    const l1 = maxTangentNorm(c1, w1);
-    const l2 = maxTangentNorm(c2, w2);
-    const drift = l1 * half1 + l2 * half2;
-    return {
-        lowerBound: Math.max(0, minSample - drift),
-        upperBound: maxSample + drift,
-        minSample,
-        maxSample,
-    };
-}
-function buildCertificationWindow(curve, u, scale) {
-    const range = curve.getRange();
-    const span = Math.max(range.length(), Precision.CURVE_PARAM_EPS);
-    const half = Math.max(Precision.CURVE_PARAM_EPS * 16, span * 1e-4 * scale);
-    const start = Math.max(range.start, u - half);
-    const end = Math.min(range.end, u + half);
-    if (end <= start + Precision.CURVE_PARAM_EPS) {
-        const clamped = range.clamp(u);
-        return new Interval(clamped, clamped);
-    }
-    return new Interval(start, end);
-}
-function sampleInterval3(x) {
-    if (x.end - x.start <= Precision.CURVE_PARAM_EPS) {
-        return [x.start];
-    }
-    return [x.start, 0.5 * (x.start + x.end), x.end];
-}
-function sampleInterval5(x) {
-    if (x.end - x.start <= Precision.CURVE_PARAM_EPS) {
-        return [x.start];
-    }
-    const a = x.start;
-    const b = x.end;
-    return [
-        a,
-        a + 0.25 * (b - a),
-        a + 0.5 * (b - a),
-        a + 0.75 * (b - a),
-        b,
-    ];
-}
-function maxTangentNorm(curve, x) {
-    const samples = sampleInterval3(x);
-    let ret = Precision.CURVE_NEWTON_EPS;
-    for (const u of samples) {
-        const n = curve.tangentAt(u).len();
-        if (Number.isFinite(n))
-            ret = Math.max(ret, n);
-    }
-    return ret;
-}
-function isNearDegenerate(c1, c2, u1, u2) {
-    const t1 = c1.tangentAt(u1);
-    const t2 = c2.tangentAt(u2);
-    const n1 = t1.len();
-    const n2 = t2.len();
-    if (n1 <= Precision.CURVE_NEWTON_EPS || n2 <= Precision.CURVE_NEWTON_EPS)
-        return true;
-    const sin = Math.abs(t1.cross(t2)) / (n1 * n2);
-    return sin <= 1e-3;
-}
-function shrinkWindowAroundParam(curve, window, center, factor) {
-    const range = curve.getRange();
-    const half = Math.max(Precision.CURVE_PARAM_EPS * 8, 0.5 * window.length() * factor);
-    const u = range.clamp(center);
-    const start = Math.max(range.start, u - half);
-    const end = Math.min(range.end, u + half);
-    if (end <= start + Precision.CURVE_PARAM_EPS) {
-        return new Interval(u, u);
-    }
-    return new Interval(start, end);
-}

package/dist/intersections/internal/interval_clipping.d.ts

@@ -1,29 +0,0 @@
-import { Interval } from '../../curves/interval';
-import type { Curve2 } from '../../curves/curve2';
-export type ClipPointSeed = {
-    u1: number;
-    u2: number;
-};
-export type ClipOverlapSeed = {
-    range1: Interval;
-    range2: Interval;
-};
-export type IntervalClipOptions = {
-    pointTol: number;
-    seedParamTol: number;
-    maxDepth: number;
-    maxNodes: number;
-    pointSeedLimit: number;
-    overlapSeedLimit: number;
-};
-export type IntervalClipDiagnostics = {
-    nodesVisited: number;
-    aborted: boolean;
-};
-export type IntervalClipResult = {
-    pointSeeds: ClipPointSeed[];
-    overlapSeeds: ClipOverlapSeed[];
-    diagnostics: IntervalClipDiagnostics;
-};
-export declare function collectIntervalClipSeeds(c1: Curve2, c2: Curve2, options: IntervalClipOptions): IntervalClipResult;
-//# sourceMappingURL=interval_clipping.d.ts.map

package/dist/intersections/internal/interval_clipping.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"interval_clipping.d.ts","sourceRoot":"","sources":["../../../src/intersections/internal/interval_clipping.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAKjD,MAAM,MAAM,aAAa,GAAG;IACxB,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC1B,MAAM,EAAE,QAAQ,CAAA;IAChB,MAAM,EAAE,QAAQ,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG;IAC9B,QAAQ,EAAE,MAAM,CAAA;IAChB,YAAY,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,cAAc,EAAE,MAAM,CAAA;IACtB,gBAAgB,EAAE,MAAM,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG;IAClC,YAAY,EAAE,MAAM,CAAA;IACpB,OAAO,EAAE,OAAO,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC7B,UAAU,EAAE,aAAa,EAAE,CAAA;IAC3B,YAAY,EAAE,eAAe,EAAE,CAAA;IAC/B,WAAW,EAAE,uBAAuB,CAAA;CACvC,CAAA;AAOD,wBAAgB,wBAAwB,CACpC,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,mBAAmB,GAC7B,kBAAkB,CAoHpB"}

package/dist/intersections/internal/interval_clipping.js

@@ -1,123 +0,0 @@
-import { Interval } from '../../curves/interval';
-import { Precision } from '../../utils/precision';
-import { intersectSegments, lerp, makeSegment, segmentBoxesMayIntersect, segmentDistance } from './segment';
-export function collectIntervalClipSeeds(c1, c2, options) {
-    const r1 = c1.getRange();
-    const r2 = c2.getRange();
-    if (r1.length() <= Precision.CURVE_PARAM_EPS || r2.length() <= Precision.CURVE_PARAM_EPS) {
-        return {
-            pointSeeds: [],
-            overlapSeeds: [],
-            diagnostics: { nodesVisited: 0, aborted: false },
-        };
-    }
-    const pointSeeds = [];
-    const overlapSeeds = [];
-    const state = {
-        nodes: 0,
-        aborted: false,
-    };
-    const cache1 = new Map();
-    const cache2 = new Map();
-    const getPoint = (curve, cache, u) => {
-        const key = u.toPrecision(15);
-        const found = cache.get(key);
-        if (found)
-            return found;
-        const p = curve.pointAt(u);
-        cache.set(key, p);
-        return p;
-    };
-    const recurse = (u0, u1, v0, v1, depth) => {
-        if (state.aborted)
-            return;
-        if (state.nodes++ > options.maxNodes) {
-            state.aborted = true;
-            return;
-        }
-        if (u1 - u0 <= Precision.CURVE_PARAM_EPS && v1 - v0 <= Precision.CURVE_PARAM_EPS)
-            return;
-        const p10 = getPoint(c1, cache1, u0);
-        const p11 = getPoint(c1, cache1, u1);
-        const p20 = getPoint(c2, cache2, v0);
-        const p21 = getPoint(c2, cache2, v1);
-        const s1 = makeSegment(p10, p11);
-        const s2 = makeSegment(p20, p21);
-        if (!segmentBoxesMayIntersect(s1, s2, options.pointTol))
-            return;
-        const hit = intersectSegments(s1, s2);
-        if (hit.kind === 'point') {
-            addPointSeed(pointSeeds, lerp(u0, u1, hit.t1), lerp(v0, v1, hit.t2), options.seedParamTol, options.pointSeedLimit);
-        }
-        else if (hit.kind === 'overlap') {
-            addOverlapSeed(overlapSeeds, {
-                range1: new Interval(lerp(u0, u1, hit.t1s), lerp(u0, u1, hit.t1e)),
-                range2: new Interval(lerp(v0, v1, hit.t2s), lerp(v0, v1, hit.t2e)),
-            }, options.overlapSeedLimit);
-            addPointSeed(pointSeeds, 0.5 * (lerp(u0, u1, hit.t1s) + lerp(u0, u1, hit.t1e)), 0.5 * (lerp(v0, v1, hit.t2s) + lerp(v0, v1, hit.t2e)), options.seedParamTol, options.pointSeedLimit);
-        }
-        const dist = segmentDistance(s1, s2);
-        const uSpan = u1 - u0;
-        const vSpan = v1 - v0;
-        const paramTiny = uSpan <= Precision.CURVE_PARAM_EPS * 32 && vSpan <= Precision.CURVE_PARAM_EPS * 32;
-        const geomTiny = Math.max(s1.len, s2.len) <= options.pointTol * 1.25;
-        if (depth >= options.maxDepth || paramTiny || geomTiny) {
-            if (dist <= options.pointTol * 1.75) {
-                addPointSeed(pointSeeds, 0.5 * (u0 + u1), 0.5 * (v0 + v1), options.seedParamTol, options.pointSeedLimit);
-            }
-            return;
-        }
-        if (dist > Math.max(s1.len, s2.len) + options.pointTol * 3)
-            return;
-        const splitU = s1.len >= s2.len;
-        if (splitU) {
-            const um = 0.5 * (u0 + u1);
-            if (um <= u0 + Precision.CURVE_PARAM_EPS || um >= u1 - Precision.CURVE_PARAM_EPS)
-                return;
-            recurse(u0, um, v0, v1, depth + 1);
-            recurse(um, u1, v0, v1, depth + 1);
-            return;
-        }
-        const vm = 0.5 * (v0 + v1);
-        if (vm <= v0 + Precision.CURVE_PARAM_EPS || vm >= v1 - Precision.CURVE_PARAM_EPS)
-            return;
-        recurse(u0, u1, v0, vm, depth + 1);
-        recurse(u0, u1, vm, v1, depth + 1);
-    };
-    recurse(r1.start, r1.end, r2.start, r2.end, 0);
-    return {
-        pointSeeds,
-        overlapSeeds,
-        diagnostics: {
-            nodesVisited: state.nodes,
-            aborted: state.aborted,
-        },
-    };
-}
-function addPointSeed(seeds, u1, u2, paramTol, limit) {
-    if (limit > 0 && seeds.length >= limit)
-        return;
-    for (const seed of seeds) {
-        if (Math.abs(seed.u1 - u1) <= paramTol && Math.abs(seed.u2 - u2) <= paramTol) {
-            return;
-        }
-    }
-    seeds.push({ u1, u2 });
-}
-function addOverlapSeed(seeds, next, limit) {
-    for (let i = 0; i < seeds.length; i++) {
-        const cur = seeds[i];
-        const overlap1 = next.range1.intersect(cur.range1, Precision.CURVE_PARAM_EPS * 8);
-        const overlap2 = next.range2.intersect(cur.range2, Precision.CURVE_PARAM_EPS * 8);
-        if (overlap1.length === 0 || overlap2.length === 0)
-            continue;
-        seeds[i] = {
-            range1: new Interval(Math.min(cur.range1.start, next.range1.start), Math.max(cur.range1.end, next.range1.end)),
-            range2: new Interval(Math.min(cur.range2.start, next.range2.start), Math.max(cur.range2.end, next.range2.end)),
-        };
-        return;
-    }
-    if (limit > 0 && seeds.length >= limit)
-        return;
-    seeds.push(next);
-}

package/dist/intersections/internal/kind.d.ts

@@ -1,4 +0,0 @@
-import type { Curve2 } from '../../curves/curve2';
-import type { CurveKind } from './pair';
-export declare function getCurveKind(curve: Curve2): CurveKind;
-//# sourceMappingURL=kind.d.ts.map

package/dist/intersections/internal/kind.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"kind.d.ts","sourceRoot":"","sources":["../../../src/intersections/internal/kind.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAEjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAEvC,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAQrD"}

package/dist/intersections/internal/kind.js

@@ -1,16 +0,0 @@
-import { MathError } from '../../utils/math_error';
-export function getCurveKind(curve) {
-    if (curve.isLine())
-        return 'line';
-    if (curve.isCircle())
-        return 'circle';
-    if (curve.isArc())
-        return 'arc';
-    if (curve.isEllipse())
-        return 'ellipse';
-    if (curve.isEllipseArc())
-        return 'ellipseArc';
-    if (curve.isBSpline())
-        return 'bspline';
-    MathError.throw(`CurveX: unsupported curve type ${curve.getType()}`);
-}

package/dist/intersections/internal/pair.d.ts

@@ -1,9 +0,0 @@
-export type CurveKind = 'line' | 'circle' | 'arc' | 'ellipse' | 'ellipseArc' | 'bspline';
-export type PairKey = `${CurveKind}|${CurveKind}`;
-type PairNormalizeResult = {
-    key: PairKey;
-    swapped: boolean;
-};
-export declare function normalizePair(k1: CurveKind, k2: CurveKind): PairNormalizeResult;
-export {};
-//# sourceMappingURL=pair.d.ts.map

package/dist/intersections/internal/pair.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pair.d.ts","sourceRoot":"","sources":["../../../src/intersections/internal/pair.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,SAAS,GAAG,YAAY,GAAG,SAAS,CAAA;AAExF,MAAM,MAAM,OAAO,GAAG,GAAG,SAAS,IAAI,SAAS,EAAE,CAAA;AAEjD,KAAK,mBAAmB,GAAG;IACvB,GAAG,EAAE,OAAO,CAAA;IACZ,OAAO,EAAE,OAAO,CAAA;CACnB,CAAA;AAWD,wBAAgB,aAAa,CAAC,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,SAAS,GAAG,mBAAmB,CAK/E"}

package/dist/intersections/internal/pair.js

@@ -1,14 +0,0 @@
-const kindOrder = {
-    line: 0,
-    circle: 1,
-    arc: 2,
-    ellipse: 3,
-    ellipseArc: 4,
-    bspline: 5,
-};
-export function normalizePair(k1, k2) {
-    if (kindOrder[k1] <= kindOrder[k2]) {
-        return { key: `${k1}|${k2}`, swapped: false };
-    }
-    return { key: `${k2}|${k1}`, swapped: true };
-}

package/dist/intersections/internal/result.d.ts

@@ -1,20 +0,0 @@
-import { Interval } from '../../curves/interval';
-import type { CurveXInfo } from '../types';
-export type CurveXQuality = {
-    rawCount: number;
-    uniqueCount: number;
-    overlapCount: number;
-    uniquePointCount: number;
-    duplicatePointCount: number;
-};
-export declare function swapCurveXInfos(items: CurveXInfo[]): {
-    point: import("../..").Vec2;
-    u1: number;
-    u2: number;
-    isOverlap: boolean;
-    range1: Interval | undefined;
-    range2: Interval | undefined;
-}[];
-export declare function postprocessCurveXInfos(items: CurveXInfo[], pointTol?: number): CurveXInfo[];
-export declare function analyzeCurveXInfosQuality(items: CurveXInfo[], pointTol?: number): CurveXQuality;
-//# sourceMappingURL=result.d.ts.map

package/dist/intersections/internal/result.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../../src/intersections/internal/result.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAEhD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAE1C,MAAM,MAAM,aAAa,GAAG;IACxB,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,CAAA;IACnB,YAAY,EAAE,MAAM,CAAA;IACpB,gBAAgB,EAAE,MAAM,CAAA;IACxB,mBAAmB,EAAE,MAAM,CAAA;CAC9B,CAAA;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,EAAE;;;;;;;IASlD;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,QAAQ,SAAiC,gBAIpG;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,QAAQ,SAAiC,GAAG,aAAa,CAmBvH"}