@ccpc/math 0.1.0 → 0.1.7

package/dist/intersections/internal/result.js

@@ -1,125 +0,0 @@
-import { Interval } from '../../curves/interval';
-import { Precision } from '../../utils/precision';
-export function swapCurveXInfos(items) {
-    return items.map((item) => ({
-        point: item.point.clone(),
-        u1: item.u2,
-        u2: item.u1,
-        isOverlap: item.isOverlap,
-        range1: item.range2 ? new Interval(item.range2.start, item.range2.end) : undefined,
-        range2: item.range1 ? new Interval(item.range1.start, item.range1.end) : undefined,
-    }));
-}
-export function postprocessCurveXInfos(items, pointTol = Precision.CURVE_LENGTH_EPS * 8) {
-    const deduped = deduplicateCurveXInfos(items, pointTol);
-    const merged = mergeOverlaps(deduped);
-    return merged.sort((a, b) => a.u1 - b.u1 || a.u2 - b.u2);
-}
-export function analyzeCurveXInfosQuality(items, pointTol = Precision.CURVE_LENGTH_EPS * 8) {
-    const rawCount = items.length;
-    const overlapCount = items.filter((x) => x.isOverlap).length;
-    const uniquePoints = [];
-    for (const item of items) {
-        if (item.isOverlap)
-            continue;
-        const dup = uniquePoints.some((u) => u.point.distanceTo(item.point) <= pointTol);
-        if (!dup)
-            uniquePoints.push(item);
-    }
-    const uniquePointCount = uniquePoints.length;
-    const uniqueCount = uniquePointCount + overlapCount;
-    const duplicatePointCount = Math.max(0, rawCount - overlapCount - uniquePointCount);
-    return {
-        rawCount,
-        uniqueCount,
-        overlapCount,
-        uniquePointCount,
-        duplicatePointCount,
-    };
-}
-function deduplicateCurveXInfos(items, pointTol) {
-    const sorted = [...items].sort((a, b) => a.u1 - b.u1 || a.u2 - b.u2);
-    const ret = [];
-    for (const cur of sorted) {
-        let merged = false;
-        for (const prev of ret) {
-            if (!isSameCurveXInfo(prev, cur, pointTol))
-                continue;
-            if (prev.isOverlap) {
-                prev.range1 = mergeRange(prev.range1, cur.range1);
-                prev.range2 = mergeRange(prev.range2, cur.range2);
-            }
-            merged = true;
-            break;
-        }
-        if (!merged)
-            ret.push(cur);
-    }
-    return ret;
-}
-function mergeOverlaps(items) {
-    const points = items.filter((x) => !x.isOverlap);
-    const overlaps = items.filter((x) => x.isOverlap);
-    if (overlaps.length <= 1)
-        return [...points, ...overlaps];
-    overlaps.sort((a, b) => (a.range1?.start ?? a.u1) - (b.range1?.start ?? b.u1));
-    const merged = [normalizeOverlap(overlaps[0])];
-    for (let i = 1; i < overlaps.length; i++) {
-        const cur = normalizeOverlap(overlaps[i]);
-        const prev = merged[merged.length - 1];
-        if (!prev.range1 || !cur.range1 || !prev.range2 || !cur.range2) {
-            merged.push(cur);
-            continue;
-        }
-        if (cur.range1.start <= prev.range1.end + Precision.CURVE_PARAM_EPS) {
-            prev.range1 = new Interval(prev.range1.start, Math.max(prev.range1.end, cur.range1.end));
-            prev.range2 = new Interval(prev.range2.start, Math.max(prev.range2.end, cur.range2.end));
-            continue;
-        }
-        merged.push(cur);
-    }
-    return [...points, ...merged];
-}
-function mergeRange(a, b) {
-    if (!a)
-        return b ? new Interval(b.start, b.end) : undefined;
-    if (!b)
-        return new Interval(a.start, a.end);
-    return new Interval(Math.min(a.start, b.start), Math.max(a.end, b.end));
-}
-function isSameCurveXInfo(a, b, pointTol) {
-    if (a.isOverlap !== b.isOverlap)
-        return false;
-    const paramTol = Precision.CURVE_PARAM_EPS * 8;
-    if (!a.isOverlap && a.point.distanceTo(b.point) <= pointTol) {
-        return true;
-    }
-    if (Math.abs(a.u1 - b.u1) <= paramTol * 8 &&
-        Math.abs(a.u2 - b.u2) <= paramTol * 8 &&
-        a.point.distanceTo(b.point) <= pointTol * 2) {
-        return true;
-    }
-    if (!a.isOverlap || !a.range1 || !a.range2 || !b.range1 || !b.range2) {
-        return false;
-    }
-    const a1 = normalizeRange(a.range1);
-    const a2 = normalizeRange(a.range2);
-    const b1 = normalizeRange(b.range1);
-    const b2 = normalizeRange(b.range2);
-    return (Math.abs(a1.start - b1.start) <= paramTol &&
-        Math.abs(a1.end - b1.end) <= paramTol &&
-        Math.abs(a2.start - b2.start) <= paramTol &&
-        Math.abs(a2.end - b2.end) <= paramTol);
-}
-function normalizeOverlap(item) {
-    if (!item.isOverlap)
-        return item;
-    return {
-        ...item,
-        range1: item.range1 ? normalizeRange(item.range1) : undefined,
-        range2: item.range2 ? normalizeRange(item.range2) : undefined,
-    };
-}
-function normalizeRange(x) {
-    return x.start <= x.end ? x : new Interval(x.end, x.start);
-}

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

@@ -1,15 +0,0 @@
-import type { Curve2 } from '../../curves/curve2';
-import { Vec2 } from '../../core/vec2';
-export type CurveSample = {
-    u: number;
-    p: Vec2;
-};
-export declare function sampleCurveByParam(curve: Curve2, segmentCount: number): CurveSample[];
-export type AdaptiveSampleOptions = {
-    maxDepth?: number;
-    chordErrorTol?: number;
-    tangentAngleTol?: number;
-    maxSamples?: number;
-};
-export declare function sampleCurveAdaptive(curve: Curve2, targetSegmentCount: number, options?: AdaptiveSampleOptions): CurveSample[];
-//# sourceMappingURL=sampling.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sampling.d.ts","sourceRoot":"","sources":["../../../src/intersections/internal/sampling.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AACjD,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAItC,MAAM,MAAM,WAAW,GAAG;IACtB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,IAAI,CAAA;CACV,CAAA;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,WAAW,EAAE,CAUrF;AAED,MAAM,MAAM,qBAAqB,GAAG;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,UAAU,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,EAAE,OAAO,GAAE,qBAA0B,GAAG,WAAW,EAAE,CA4CjI"}

package/dist/intersections/internal/sampling.js

@@ -1,131 +0,0 @@
-import { Precision } from '../../utils/precision';
-import { MathUtils } from '../../utils/math_utils';
-export function sampleCurveByParam(curve, segmentCount) {
-    const range = curve.getRange();
-    const total = Math.max(2, segmentCount);
-    const samples = [];
-    for (let i = 0; i <= total; i++) {
-        const t = i / total;
-        const u = range.start + (range.end - range.start) * t;
-        samples.push({ u, p: curve.pointAt(u) });
-    }
-    return collapseDuplicateSamplePoints(samples);
-}
-export function sampleCurveAdaptive(curve, targetSegmentCount, options = {}) {
-    const range = curve.getRange();
-    if (range.length() <= Precision.CURVE_PARAM_EPS) {
-        return [{ u: range.start, p: curve.pointAt(range.start) }];
-    }
-    const bbox = curve.boundingBox();
-    const diag = Math.hypot(bbox.width(), bbox.height());
-    const scale = Math.max(diag, 1);
-    const segCount = Math.max(8, targetSegmentCount);
-    const maxDepth = options.maxDepth ?? (Math.ceil(Math.log2(segCount)) + 8);
-    const chordErrorTol = options.chordErrorTol ?? Math.max(Precision.CURVE_LENGTH_EPS * 8, scale / (segCount * 10));
-    const tangentAngleTol = options.tangentAngleTol ?? 0.22;
-    const maxSamples = options.maxSamples ?? segCount * 8;
-    const cutParams = collectCutParams(curve);
-    const samples = [];
-    for (let i = 0; i < cutParams.length - 1; i++) {
-        const u0 = cutParams[i];
-        const u1 = cutParams[i + 1];
-        if (u1 - u0 <= Precision.CURVE_PARAM_EPS)
-            continue;
-        const p0 = curve.pointAt(u0);
-        const p1 = curve.pointAt(u1);
-        subdivideAdaptive(curve, u0, p0, u1, p1, 0, maxDepth, chordErrorTol, tangentAngleTol, maxSamples, samples);
-    }
-    // Ensure terminal endpoint is present.
-    const end = cutParams[cutParams.length - 1];
-    samples.push({ u: end, p: curve.pointAt(end) });
-    return collapseDuplicateSamplePoints(samples);
-}
-function collectCutParams(curve) {
-    const range = curve.getRange();
-    const cuts = [range.start];
-    if (curve.isBSpline()) {
-        for (const u of curve.getContinuityBreakParams(Precision.CURVE_PARAM_EPS)) {
-            if (u > range.start + Precision.CURVE_PARAM_EPS && u < range.end - Precision.CURVE_PARAM_EPS) {
-                cuts.push(u);
-            }
-        }
-    }
-    cuts.push(range.end);
-    cuts.sort((a, b) => a - b);
-    const unique = [];
-    for (const u of cuts) {
-        if (unique.length === 0 || Math.abs(unique[unique.length - 1] - u) > Precision.CURVE_PARAM_EPS) {
-            unique.push(u);
-        }
-    }
-    return unique;
-}
-function subdivideAdaptive(curve, u0, p0, u1, p1, depth, maxDepth, chordErrorTol, tangentAngleTol, maxSamples, out) {
-    if (out.length >= maxSamples) {
-        out.push({ u: u0, p: p0 });
-        return;
-    }
-    if (!shouldSplit(curve, u0, p0, u1, p1, depth, maxDepth, chordErrorTol, tangentAngleTol)) {
-        out.push({ u: u0, p: p0 });
-        return;
-    }
-    const um = 0.5 * (u0 + u1);
-    if (um <= u0 + Precision.CURVE_PARAM_EPS || um >= u1 - Precision.CURVE_PARAM_EPS) {
-        out.push({ u: u0, p: p0 });
-        return;
-    }
-    const pm = curve.pointAt(um);
-    subdivideAdaptive(curve, u0, p0, um, pm, depth + 1, maxDepth, chordErrorTol, tangentAngleTol, maxSamples, out);
-    subdivideAdaptive(curve, um, pm, u1, p1, depth + 1, maxDepth, chordErrorTol, tangentAngleTol, maxSamples, out);
-}
-function shouldSplit(curve, u0, p0, u1, p1, depth, maxDepth, chordErrorTol, tangentAngleTol) {
-    if (depth >= maxDepth)
-        return false;
-    if (u1 - u0 <= Precision.CURVE_PARAM_EPS * 2)
-        return false;
-    const chord = p1.subtracted(p0);
-    const chordLen = chord.len();
-    if (chordLen <= Precision.CURVE_LENGTH_EPS)
-        return true;
-    const um = 0.5 * (u0 + u1);
-    const pm = curve.pointAt(um);
-    const midError = pointToLineDistance(pm, p0, p1, chordLen);
-    if (midError > chordErrorTol)
-        return true;
-    const t0 = curve.tangentAt(u0);
-    const t1 = curve.tangentAt(u1);
-    if (t0.len() <= Precision.CURVE_NEWTON_EPS || t1.len() <= Precision.CURVE_NEWTON_EPS)
-        return true;
-    const a0 = vectorAngle(t0, chord);
-    const a1 = vectorAngle(t1, chord);
-    const ae = vectorAngle(t0, t1);
-    return a0 > tangentAngleTol || a1 > tangentAngleTol || ae > tangentAngleTol * 2;
-}
-function pointToLineDistance(p, a, b, abLen) {
-    if (abLen <= Precision.CURVE_LENGTH_EPS)
-        return p.distanceTo(a);
-    const ap = p.subtracted(a);
-    const ab = b.subtracted(a);
-    return Math.abs(ap.cross(ab)) / abLen;
-}
-function vectorAngle(v1, v2) {
-    const l1 = v1.len();
-    const l2 = v2.len();
-    if (l1 <= Precision.CURVE_NEWTON_EPS || l2 <= Precision.CURVE_NEWTON_EPS)
-        return Math.PI;
-    const x = v1.dot(v2) / (l1 * l2);
-    return Math.acos(MathUtils.clamp(x, -1, 1));
-}
-function collapseDuplicateSamplePoints(samples) {
-    if (samples.length <= 1)
-        return samples;
-    const ret = [samples[0]];
-    for (let i = 1; i < samples.length; i++) {
-        const prev = ret[ret.length - 1];
-        const cur = samples[i];
-        if (prev.p.distanceTo(cur.p) <= Precision.CURVE_LENGTH_EPS)
-            continue;
-        ret.push(cur);
-    }
-    return ret;
-}

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

@@ -1,32 +0,0 @@
-import { Vec2 } from '../../core/vec2';
-export type Segment = {
-    p0: Vec2;
-    p1: Vec2;
-    v: Vec2;
-    len: number;
-    unit: Vec2;
-    minX: number;
-    minY: number;
-    maxX: number;
-    maxY: number;
-};
-export type SegmentHit = {
-    kind: 'none';
-} | {
-    kind: 'point';
-    t1: number;
-    t2: number;
-} | {
-    kind: 'overlap';
-    t1s: number;
-    t1e: number;
-    t2s: number;
-    t2e: number;
-};
-export declare function makeSegment(p0: Vec2, p1: Vec2): Segment;
-export declare function segmentBoxesMayIntersect(s1: Segment, s2: Segment, pad?: number): boolean;
-export declare function segmentDistance(s1: Segment, s2: Segment): number;
-export declare function intersectSegments(s1: Segment, s2: Segment): SegmentHit;
-export declare function pointAtSegmentUnit(seg: Segment, t: number): Vec2;
-export declare function lerp(a: number, b: number, t: number): number;
-//# sourceMappingURL=segment.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"segment.d.ts","sourceRoot":"","sources":["../../../src/intersections/internal/segment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAGtC,MAAM,MAAM,OAAO,GAAG;IAClB,EAAE,EAAE,IAAI,CAAA;IACR,EAAE,EAAE,IAAI,CAAA;IACR,CAAC,EAAE,IAAI,CAAA;IACP,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,IAAI,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;CACf,CAAA;AAED,MAAM,MAAM,UAAU,GAChB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GACzC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAA;AAE7E,wBAAgB,WAAW,CAAC,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,GAAG,OAAO,CAmBvD;AAED,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,GAAG,SAA6B,WAElG;AAED,wBAAgB,eAAe,CAAC,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,UAoBvD;AAED,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,GAAG,UAAU,CAqBtE;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,QAEzD;AAED,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,UAEnD"}

package/dist/intersections/internal/segment.js

@@ -1,137 +0,0 @@
-import { Vec2 } from '../../core/vec2';
-import { Precision } from '../../utils/precision';
-export function makeSegment(p0, p1) {
-    const v = p1.subtracted(p0);
-    const len = v.len();
-    const unit = len > Precision.CURVE_LENGTH_EPS ? v.scaled(1 / len) : Vec2.zero();
-    const minX = Math.min(p0.x, p1.x);
-    const minY = Math.min(p0.y, p1.y);
-    const maxX = Math.max(p0.x, p1.x);
-    const maxY = Math.max(p0.y, p1.y);
-    return {
-        p0: p0.clone(),
-        p1: p1.clone(),
-        v,
-        len,
-        unit,
-        minX,
-        minY,
-        maxX,
-        maxY,
-    };
-}
-export function segmentBoxesMayIntersect(s1, s2, pad = Precision.CURVE_LENGTH_EPS) {
-    return !(s1.maxX + pad < s2.minX || s2.maxX + pad < s1.minX || s1.maxY + pad < s2.minY || s2.maxY + pad < s1.minY);
-}
-export function segmentDistance(s1, s2) {
-    if (s1.len <= Precision.CURVE_LENGTH_EPS && s2.len <= Precision.CURVE_LENGTH_EPS) {
-        return s1.p0.distanceTo(s2.p0);
-    }
-    if (s1.len <= Precision.CURVE_LENGTH_EPS) {
-        return pointSegmentDistance(s1.p0, s2);
-    }
-    if (s2.len <= Precision.CURVE_LENGTH_EPS) {
-        return pointSegmentDistance(s2.p0, s1);
-    }
-    const hit = intersectSegments(s1, s2);
-    if (hit.kind !== 'none')
-        return 0;
-    return Math.min(pointSegmentDistance(s1.p0, s2), pointSegmentDistance(s1.p1, s2), pointSegmentDistance(s2.p0, s1), pointSegmentDistance(s2.p1, s1));
-}
-export function intersectSegments(s1, s2) {
-    if (s1.len <= Precision.CURVE_LENGTH_EPS || s2.len <= Precision.CURVE_LENGTH_EPS) {
-        return { kind: 'none' };
-    }
-    const cross = s1.v.cross(s2.v);
-    const delta = s2.p0.subtracted(s1.p0);
-    const collinear = delta.cross(s1.v);
-    const crossTol = crossTolerance(s1, s2);
-    const collinearTol = collinearTolerance(s1, s2, delta.len());
-    const rangeTol = paramRangeTolerance(s1, s2);
-    if (Math.abs(cross) <= crossTol) {
-        if (Math.abs(collinear) > collinearTol)
-            return { kind: 'none' };
-        return intersectCollinearSegments(s1, s2, rangeTol);
-    }
-    const t1Raw = delta.cross(s2.v) / cross;
-    const t2Raw = delta.cross(s1.v) / cross;
-    if (!inRange01(t1Raw, rangeTol) || !inRange01(t2Raw, rangeTol))
-        return { kind: 'none' };
-    return { kind: 'point', t1: clamp01(t1Raw), t2: clamp01(t2Raw) };
-}
-export function pointAtSegmentUnit(seg, t) {
-    return seg.p0.added(seg.v.scaled(t));
-}
-export function lerp(a, b, t) {
-    return a + (b - a) * t;
-}
-function intersectCollinearSegments(s1, s2, tol) {
-    const x0 = s2.p0.subtracted(s1.p0).dot(s1.unit);
-    const x1 = s2.p1.subtracted(s1.p0).dot(s1.unit);
-    const os = Math.max(0, Math.min(x0, x1));
-    const oe = Math.min(s1.len, Math.max(x0, x1));
-    if (oe < os - tol)
-        return { kind: 'none' };
-    if (Math.abs(oe - os) <= tol) {
-        const pos1 = clamp(os, 0, s1.len);
-        const p = s1.p0.added(s1.unit.scaled(pos1));
-        const pos2 = clamp(p.subtracted(s2.p0).dot(s2.unit), 0, s2.len);
-        return {
-            kind: 'point',
-            t1: s1.len > 0 ? pos1 / s1.len : 0,
-            t2: s2.len > 0 ? pos2 / s2.len : 0,
-        };
-    }
-    const p1s = clamp(os, 0, s1.len);
-    const p1e = clamp(oe, 0, s1.len);
-    const ps = s1.p0.added(s1.unit.scaled(p1s));
-    const pe = s1.p0.added(s1.unit.scaled(p1e));
-    const p2s = clamp(ps.subtracted(s2.p0).dot(s2.unit), 0, s2.len);
-    const p2e = clamp(pe.subtracted(s2.p0).dot(s2.unit), 0, s2.len);
-    return {
-        kind: 'overlap',
-        t1s: s1.len > 0 ? p1s / s1.len : 0,
-        t1e: s1.len > 0 ? p1e / s1.len : 0,
-        t2s: s2.len > 0 ? p2s / s2.len : 0,
-        t2e: s2.len > 0 ? p2e / s2.len : 0,
-    };
-}
-function inRange01(t, eps) {
-    return t >= -eps && t <= 1 + eps;
-}
-function clamp01(t) {
-    return clamp(t, 0, 1);
-}
-function clamp(x, min, max) {
-    return Math.min(max, Math.max(min, x));
-}
-function pointSegmentDistance(p, s) {
-    if (s.len <= Precision.CURVE_LENGTH_EPS)
-        return p.distanceTo(s.p0);
-    const t = clamp(p.subtracted(s.p0).dot(s.v) / (s.len * s.len), 0, 1);
-    const q = pointAtSegmentUnit(s, t);
-    return p.distanceTo(q);
-}
-function segmentScale(s1, s2) {
-    const maxCoord = Math.max(Math.abs(s1.p0.x), Math.abs(s1.p0.y), Math.abs(s1.p1.x), Math.abs(s1.p1.y), Math.abs(s2.p0.x), Math.abs(s2.p0.y), Math.abs(s2.p1.x), Math.abs(s2.p1.y), 1);
-    return {
-        maxLen: Math.max(s1.len, s2.len, 1),
-        maxCoord,
-    };
-}
-function crossTolerance(s1, s2) {
-    const { maxLen, maxCoord } = segmentScale(s1, s2);
-    const lenProd = Math.max(s1.len * s2.len, 1);
-    const base = Math.max(Precision.CURVE_LENGTH_EPS * maxLen, maxCoord * 1e-12 * maxLen);
-    return Math.max(base, lenProd * 1e-12);
-}
-function collinearTolerance(s1, s2, deltaLen) {
-    const { maxLen, maxCoord } = segmentScale(s1, s2);
-    const lever = Math.max(deltaLen, maxLen, 1);
-    const base = Math.max(Precision.CURVE_LENGTH_EPS * lever, maxCoord * 1e-12 * lever);
-    return Math.max(base, maxLen * lever * 1e-12);
-}
-function paramRangeTolerance(s1, s2) {
-    const { maxLen } = segmentScale(s1, s2);
-    return Math.max(Precision.CURVE_PARAM_EPS, 1e-10 / maxLen);
-}

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

@@ -1,10 +0,0 @@
-import type { Curve2 } from '../../curves/curve2';
-export type IntersectionTolerance = {
-    pointTol: number;
-    paramTol: number;
-    seedParamTol: number;
-    overlapPointTol: number;
-};
-export declare function makeIntersectionTolerance(c1: Curve2, c2: Curve2): IntersectionTolerance;
-export declare function curvePointTolerance(curve: Curve2): number;
-//# sourceMappingURL=tolerance.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"tolerance.d.ts","sourceRoot":"","sources":["../../../src/intersections/internal/tolerance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAGjD,MAAM,MAAM,qBAAqB,GAAG;IAChC,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,YAAY,EAAE,MAAM,CAAA;IACpB,eAAe,EAAE,MAAM,CAAA;CAC1B,CAAA;AAED,wBAAgB,yBAAyB,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,qBAAqB,CAevF;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,UAKhD"}

package/dist/intersections/internal/tolerance.js

@@ -1,20 +0,0 @@
-import { Precision } from '../../utils/precision';
-export function makeIntersectionTolerance(c1, c2) {
-    const b1 = c1.boundingBox();
-    const b2 = c2.boundingBox();
-    const diag = Math.hypot(Math.max(b1.maxX, b2.maxX) - Math.min(b1.minX, b2.minX), Math.max(b1.maxY, b2.maxY) - Math.min(b1.minY, b2.minY));
-    const scaleTol = (Number.isFinite(diag) && diag > 0) ? diag * 1e-7 : 0;
-    const pointTol = Math.max(Precision.CURVE_LENGTH_EPS * 8, scaleTol);
-    return {
-        pointTol,
-        paramTol: Precision.CURVE_PARAM_EPS * 8,
-        seedParamTol: Precision.CURVE_PARAM_EPS * 8,
-        overlapPointTol: pointTol * 2.5,
-    };
-}
-export function curvePointTolerance(curve) {
-    const box = curve.boundingBox();
-    const diag = Math.hypot(box.width(), box.height());
-    const scaleTol = (Number.isFinite(diag) && diag > 0) ? diag * 1e-9 : 0;
-    return Math.max(Precision.CURVE_LENGTH_EPS * 8, scaleTol);
-}

package/dist/intersections/intersector.d.ts

@@ -1,6 +0,0 @@
-import type { Curve2 } from '../curves/curve2';
-import type { CurveXInfo } from './types';
-export interface ICurvePairIntersector {
-    intersect(c1: Curve2, c2: Curve2): CurveXInfo[];
-}
-//# sourceMappingURL=intersector.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"intersector.d.ts","sourceRoot":"","sources":["../../src/intersections/intersector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC,MAAM,WAAW,qBAAqB;IAClC,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,UAAU,EAAE,CAAA;CAClD"}

package/dist/intersections/intersector.js

@@ -1 +0,0 @@
-export {};

package/dist/intersections/numeric_x_algorithm.d.ts

@@ -1,10 +0,0 @@
-import type { Curve2 } from '../curves/curve2';
-import type { CurveXInfo } from './types';
-export declare class NumericXAlgorithm {
-    private readonly map;
-    private readonly retryMap;
-    intersect(c1: Curve2, c2: Curve2): CurveXInfo[];
-    private shouldRetry;
-    private boxesLikelyIntersect;
-}
-//# sourceMappingURL=numeric_x_algorithm.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"numeric_x_algorithm.d.ts","sourceRoot":"","sources":["../../src/intersections/numeric_x_algorithm.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAgB9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC,qBAAa,iBAAiB;IAC1B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAOnB;IAED,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAOxB;IAEM,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,UAAU,EAAE;IA2BtD,OAAO,CAAC,WAAW;IAmBnB,OAAO,CAAC,oBAAoB;CAM/B"}

package/dist/intersections/numeric_x_algorithm.js

@@ -1,73 +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 { ArcBSplinePairSolver, BSplineBSplinePairSolver, CircleBSplinePairSolver, EllipseArcBSplinePairSolver, EllipseBSplinePairSolver, LineBSplinePairSolver, } from './solvers/pair_solvers';
-import { PolylinePairIntersector } from './solvers/polyline_pair_intersector';
-export class NumericXAlgorithm {
-    constructor() {
-        this.map = {
-            'line|bspline': new LineBSplinePairSolver(),
-            'circle|bspline': new CircleBSplinePairSolver(),
-            'arc|bspline': new ArcBSplinePairSolver(),
-            'ellipse|bspline': new EllipseBSplinePairSolver(),
-            'ellipseArc|bspline': new EllipseArcBSplinePairSolver(),
-            'bspline|bspline': new BSplineBSplinePairSolver(),
-        };
-        this.retryMap = {
-            'line|bspline': new PolylinePairIntersector(640, 96),
-            'circle|bspline': new PolylinePairIntersector(640, 96),
-            'arc|bspline': new PolylinePairIntersector(640, 96),
-            'ellipse|bspline': new PolylinePairIntersector(704, 96),
-            'ellipseArc|bspline': new PolylinePairIntersector(704, 96),
-            'bspline|bspline': new PolylinePairIntersector(768, 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(`NumericXAlgorithm: 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/solvers/bspline_self_solver.d.ts

@@ -1,7 +0,0 @@
-import type { BSpline2 } from '../../curves/bspline2';
-import type { CurveXInfo } from '../types';
-export declare class BSplineSelfSolver {
-    intersect(curve: BSpline2): CurveXInfo[];
-}
-export declare function intersectBSplineSelf(curve: BSpline2): CurveXInfo[];
-//# sourceMappingURL=bspline_self_solver.d.ts.map

package/dist/intersections/solvers/bspline_self_solver.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bspline_self_solver.d.ts","sourceRoot":"","sources":["../../../src/intersections/solvers/bspline_self_solver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAGrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAwB1C,qBAAa,iBAAiB;IACnB,SAAS,CAAC,KAAK,EAAE,QAAQ,GAAG,UAAU,EAAE;CAmBlD;AAID,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,QAAQ,GAAG,UAAU,EAAE,CAElE"}