@ccpc/math 0.1.0

package/dist/intersections/internal/result.js

@@ -0,0 +1,125 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,131 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,137 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1 @@
+{"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

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

package/dist/intersections/numeric_x_algorithm.d.ts

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,73 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1 @@
+{"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"}