@ccpc/math 0.1.0

package/dist/intersections/solvers/polyline_pair_intersector.js

@@ -0,0 +1,731 @@
+import { Interval } from '../../curves/interval';
+import { Precision } from '../../utils/precision';
+import { certifyOverlapMonotone, certifyParamPair, projectRangeToCurve } from '../internal/certification';
+import { collectIntervalClipSeeds } from '../internal/interval_clipping';
+import { intersectSegments, lerp, makeSegment, segmentBoxesMayIntersect, segmentDistance } from '../internal/segment';
+import { sampleCurveAdaptive } from '../internal/sampling';
+import { makeIntersectionTolerance } from '../internal/tolerance';
+class SegmentHashIndex {
+    constructor(segments, pad) {
+        this.segments = segments;
+        this.map = new Map();
+        this.overflow = [];
+        let minX = Number.POSITIVE_INFINITY;
+        let minY = Number.POSITIVE_INFINITY;
+        let maxX = Number.NEGATIVE_INFINITY;
+        let maxY = Number.NEGATIVE_INFINITY;
+        for (const s of segments) {
+            minX = Math.min(minX, s.seg.minX);
+            minY = Math.min(minY, s.seg.minY);
+            maxX = Math.max(maxX, s.seg.maxX);
+            maxY = Math.max(maxY, s.seg.maxY);
+        }
+        if (!Number.isFinite(minX) || !Number.isFinite(minY) || !Number.isFinite(maxX) || !Number.isFinite(maxY)) {
+            minX = minY = 0;
+            maxX = maxY = 1;
+        }
+        const count = Math.max(1, segments.length);
+        const grid = clampInt(Math.round(Math.sqrt(count)), 8, 64);
+        const spanX = Math.max(maxX - minX, pad * 2, Precision.CURVE_LENGTH_EPS);
+        const spanY = Math.max(maxY - minY, pad * 2, Precision.CURVE_LENGTH_EPS);
+        this.minX = minX - pad;
+        this.minY = minY - pad;
+        this.gridX = grid;
+        this.gridY = grid;
+        this.cellSizeX = spanX / this.gridX;
+        this.cellSizeY = spanY / this.gridY;
+        const maxCellsPerSegment = 64;
+        for (let i = 0; i < segments.length; i++) {
+            const seg = segments[i].seg;
+            const ix0 = this.toX(seg.minX - pad);
+            const ix1 = this.toX(seg.maxX + pad);
+            const iy0 = this.toY(seg.minY - pad);
+            const iy1 = this.toY(seg.maxY + pad);
+            const cells = (ix1 - ix0 + 1) * (iy1 - iy0 + 1);
+            if (cells > maxCellsPerSegment) {
+                this.overflow.push(i);
+                continue;
+            }
+            for (let ix = ix0; ix <= ix1; ix++) {
+                for (let iy = iy0; iy <= iy1; iy++) {
+                    const key = this.key(ix, iy);
+                    const list = this.map.get(key);
+                    if (list) {
+                        list.push(i);
+                    }
+                    else {
+                        this.map.set(key, [i]);
+                    }
+                }
+            }
+        }
+    }
+    query(seg, pad, marks, stamp) {
+        const ret = [];
+        const ix0 = this.toX(seg.seg.minX - pad);
+        const ix1 = this.toX(seg.seg.maxX + pad);
+        const iy0 = this.toY(seg.seg.minY - pad);
+        const iy1 = this.toY(seg.seg.maxY + pad);
+        for (let ix = ix0; ix <= ix1; ix++) {
+            for (let iy = iy0; iy <= iy1; iy++) {
+                const list = this.map.get(this.key(ix, iy));
+                if (!list)
+                    continue;
+                for (const j of list) {
+                    if (marks[j] === stamp)
+                        continue;
+                    marks[j] = stamp;
+                    ret.push(j);
+                }
+            }
+        }
+        for (const j of this.overflow) {
+            if (marks[j] === stamp)
+                continue;
+            marks[j] = stamp;
+            ret.push(j);
+        }
+        return ret;
+    }
+    toX(x) {
+        const raw = Math.floor((x - this.minX) / this.cellSizeX);
+        return clampInt(raw, 0, this.gridX - 1);
+    }
+    toY(y) {
+        const raw = Math.floor((y - this.minY) / this.cellSizeY);
+        return clampInt(raw, 0, this.gridY - 1);
+    }
+    key(ix, iy) {
+        return `${ix},${iy}`;
+    }
+}
+const polylineDiagnostics = {
+    numericClosestFallbackCount: 0,
+    analyticClosestFallbackCount: 0,
+    recursiveNodesVisited: 0,
+    recursiveAbortCount: 0,
+    refineFailureCount: 0,
+    certificationRejectCount: 0,
+    certificationMissCount: 0,
+    degenerateRescueCount: 0,
+    rescuePassCount: 0,
+    rescueSeedCount: 0,
+    rescueHitCount: 0,
+    candidateSeedCount: 0,
+    certifiedPointCount: 0,
+    certifiedOverlapCount: 0,
+    newtonIterationsTotal: 0,
+    projectionIterationsTotal: 0,
+    maxResidual: 0,
+};
+export class PolylinePairIntersector {
+    static resetDiagnostics() {
+        polylineDiagnostics.numericClosestFallbackCount = 0;
+        polylineDiagnostics.analyticClosestFallbackCount = 0;
+        polylineDiagnostics.recursiveNodesVisited = 0;
+        polylineDiagnostics.recursiveAbortCount = 0;
+        polylineDiagnostics.refineFailureCount = 0;
+        polylineDiagnostics.certificationRejectCount = 0;
+        polylineDiagnostics.certificationMissCount = 0;
+        polylineDiagnostics.degenerateRescueCount = 0;
+        polylineDiagnostics.rescuePassCount = 0;
+        polylineDiagnostics.rescueSeedCount = 0;
+        polylineDiagnostics.rescueHitCount = 0;
+        polylineDiagnostics.candidateSeedCount = 0;
+        polylineDiagnostics.certifiedPointCount = 0;
+        polylineDiagnostics.certifiedOverlapCount = 0;
+        polylineDiagnostics.newtonIterationsTotal = 0;
+        polylineDiagnostics.projectionIterationsTotal = 0;
+        polylineDiagnostics.maxResidual = 0;
+    }
+    static getDiagnostics() {
+        return { ...polylineDiagnostics };
+    }
+    static recordAnalyticClosestFallback() {
+        polylineDiagnostics.analyticClosestFallbackCount++;
+    }
+    constructor(segmentsPerCurve, maxNewtonIter = Precision.CURVE_MAX_ITER) {
+        this.segmentsPerCurve = segmentsPerCurve;
+        this.maxNewtonIter = maxNewtonIter;
+        this.runPointSeedLimit = 0;
+        this.runOverlapSeedLimit = 0;
+    }
+    intersect(c1, c2) {
+        const tol = makeIntersectionTolerance(c1, c2);
+        const pairTol = tol.pointTol;
+        const hasBSpline = c1.isBSpline() || c2.isBSpline();
+        // Keep strict certification only for BSpline-BSpline.
+        // Mixed pairs (Line/Circle/Arc/Ellipse with BSpline) prioritize recall first.
+        const strictCertify = c1.isBSpline() && c2.isBSpline();
+        const enableNearMissSeeding = hasBSpline || c1.isEllipseArc() || c2.isEllipseArc();
+        const nearSeedBudget = Math.max(48, Math.floor(this.segmentsPerCurve * 0.75));
+        this.runPointSeedLimit = Math.max(320, this.segmentsPerCurve * 2);
+        this.runOverlapSeedLimit = Math.max(24, Math.ceil(this.segmentsPerCurve / 8));
+        const s1 = sampleCurveAdaptive(c1, this.segmentsPerCurve, {
+            chordErrorTol: pairTol * 0.75,
+            maxSamples: this.segmentsPerCurve * 8,
+        });
+        const s2 = sampleCurveAdaptive(c2, this.segmentsPerCurve, {
+            chordErrorTol: pairTol * 0.75,
+            maxSamples: this.segmentsPerCurve * 8,
+        });
+        if (s1.length < 2 || s2.length < 2)
+            return [];
+        const segs1 = this.buildSegments(s1);
+        const segs2 = this.buildSegments(s2);
+        const candidates = this.buildPairCandidates(segs1, segs2, pairTol);
+        const pointSeeds = [];
+        const overlapSeeds = [];
+        let minNearDistance = Number.POSITIVE_INFINITY;
+        let nearSeedCount = 0;
+        const refineFailureBefore = polylineDiagnostics.refineFailureCount;
+        const ret = [];
+        for (const candidate of candidates) {
+            const sA = segs1[candidate.i];
+            const sB = segs2[candidate.j];
+            const hit = intersectSegments(sA.seg, sB.seg);
+            if (hit.kind === 'none') {
+                const near = segmentDistance(sA.seg, sB.seg);
+                minNearDistance = Math.min(minNearDistance, near);
+                if (enableNearMissSeeding &&
+                    near <= pairTol * 0.8 &&
+                    nearSeedCount < nearSeedBudget &&
+                    pointSeeds.length <= nearSeedBudget * 2) {
+                    this.addNearMissSeeds(pointSeeds, sA, sB, tol.seedParamTol);
+                    nearSeedCount++;
+                }
+                continue;
+            }
+            minNearDistance = 0;
+            if (hit.kind === 'point') {
+                const u1 = lerp(sA.u0, sA.u1, hit.t1);
+                const u2 = lerp(sB.u0, sB.u1, hit.t2);
+                this.addPointSeed(pointSeeds, u1, u2, tol.seedParamTol);
+                continue;
+            }
+            const u1s = lerp(sA.u0, sA.u1, hit.t1s);
+            const u1e = lerp(sA.u0, sA.u1, hit.t1e);
+            const u2s = lerp(sB.u0, sB.u1, hit.t2s);
+            const u2e = lerp(sB.u0, sB.u1, hit.t2e);
+            this.addOverlapSeed(overlapSeeds, {
+                range1: new Interval(Math.min(u1s, u1e), Math.max(u1s, u1e)),
+                range2: new Interval(Math.min(u2s, u2e), Math.max(u2s, u2e)),
+            });
+            this.addPointSeed(pointSeeds, (u1s + u1e) * 0.5, (u2s + u2e) * 0.5, tol.seedParamTol);
+            this.addPointSeed(pointSeeds, u1s, u2s, tol.seedParamTol);
+            this.addPointSeed(pointSeeds, u1e, u2e, tol.seedParamTol);
+        }
+        if (pointSeeds.length <= 8 && overlapSeeds.length <= 4) {
+            const clipped = collectIntervalClipSeeds(c1, c2, {
+                pointTol: pairTol,
+                seedParamTol: tol.seedParamTol,
+                maxDepth: Math.max(8, Math.ceil(Math.log2(Math.max(8, this.segmentsPerCurve))) + 6),
+                maxNodes: this.recursiveMaxNodes(c1, c2),
+                pointSeedLimit: Math.max(8, this.runPointSeedLimit - pointSeeds.length),
+                overlapSeedLimit: Math.max(4, this.runOverlapSeedLimit - overlapSeeds.length),
+            });
+            polylineDiagnostics.recursiveNodesVisited += clipped.diagnostics.nodesVisited;
+            if (clipped.diagnostics.aborted) {
+                polylineDiagnostics.recursiveAbortCount++;
+            }
+            for (const seed of clipped.pointSeeds) {
+                this.addPointSeed(pointSeeds, seed.u1, seed.u2, tol.seedParamTol);
+            }
+            for (const overlap of clipped.overlapSeeds) {
+                this.addOverlapSeed(overlapSeeds, overlap);
+            }
+        }
+        polylineDiagnostics.candidateSeedCount += pointSeeds.length;
+        for (const seed of pointSeeds) {
+            const refined = this.refinePair(c1, c2, seed.u1, seed.u2, pairTol, strictCertify);
+            if (!refined)
+                continue;
+            this.pushUnique(ret, {
+                point: refined.point,
+                u1: refined.u1,
+                u2: refined.u2,
+                isOverlap: false,
+            });
+            polylineDiagnostics.certifiedPointCount++;
+        }
+        for (const overlap of overlapSeeds) {
+            const overlapInfo = this.refineOverlap(c1, c2, overlap, pairTol, tol.paramTol);
+            if (overlapInfo) {
+                this.pushUnique(ret, overlapInfo);
+                if (overlapInfo.isOverlap) {
+                    polylineDiagnostics.certifiedOverlapCount++;
+                }
+                else {
+                    polylineDiagnostics.certifiedPointCount++;
+                }
+            }
+        }
+        const refineFailureDelta = polylineDiagnostics.refineFailureCount - refineFailureBefore;
+        if (hasBSpline &&
+            ret.length === 0 &&
+            (pointSeeds.length > 0 || overlapSeeds.length > 0 || minNearDistance <= pairTol * 2)) {
+            const rescued = this.runRescuePass(c1, c2, pairTol, tol.seedParamTol, strictCertify);
+            if (rescued.length > 0) {
+                for (const hit of rescued) {
+                    this.pushUnique(ret, hit);
+                }
+                polylineDiagnostics.rescueHitCount += rescued.length;
+            }
+            // For BSpline-BSpline, strict certification can reject true roots on noisy seeds.
+            // Add a non-strict rescue pass as a recall-oriented fallback.
+            if (ret.length === 0 && strictCertify) {
+                const relaxedRescued = this.runRescuePass(c1, c2, pairTol, tol.seedParamTol, false);
+                if (relaxedRescued.length > 0) {
+                    for (const hit of relaxedRescued) {
+                        this.pushUnique(ret, hit);
+                    }
+                    polylineDiagnostics.rescueHitCount += relaxedRescued.length;
+                }
+            }
+        }
+        if (hasBSpline && ret.length === 0) {
+            const relaxed = this.runPolylineRelaxedFallback(c1, c2, pairTol, tol.seedParamTol);
+            for (const hit of relaxed) {
+                this.pushUnique(ret, hit);
+            }
+        }
+        if (hasBSpline &&
+            ret.length === 0 &&
+            (pointSeeds.length > 0 || overlapSeeds.length > 0) &&
+            minNearDistance <= pairTol * 0.2 &&
+            refineFailureDelta >= 3) {
+            polylineDiagnostics.certificationMissCount++;
+        }
+        return ret;
+    }
+    runPolylineRelaxedFallback(c1, c2, pointTol, seedParamTol) {
+        const ret = [];
+        const dense = Math.min(2048, Math.max(512, this.segmentsPerCurve * 2));
+        const s1 = sampleCurveAdaptive(c1, dense, {
+            chordErrorTol: pointTol * 1.5,
+            maxSamples: dense * 8,
+        });
+        const s2 = sampleCurveAdaptive(c2, dense, {
+            chordErrorTol: pointTol * 1.5,
+            maxSamples: dense * 8,
+        });
+        if (s1.length < 2 || s2.length < 2)
+            return ret;
+        const seeds = [];
+        const segs1 = this.buildSegments(s1);
+        const segs2 = this.buildSegments(s2);
+        const candidates = this.buildPairCandidates(segs1, segs2, pointTol * 4);
+        for (const candidate of candidates) {
+            const a = segs1[candidate.i];
+            const b = segs2[candidate.j];
+            const hit = intersectSegments(a.seg, b.seg);
+            if (hit.kind === 'none')
+                continue;
+            if (hit.kind === 'point') {
+                this.addPointSeed(seeds, lerp(a.u0, a.u1, hit.t1), lerp(b.u0, b.u1, hit.t2), seedParamTol * 4);
+                continue;
+            }
+            this.addPointSeed(seeds, lerp(a.u0, a.u1, 0.5 * (hit.t1s + hit.t1e)), lerp(b.u0, b.u1, 0.5 * (hit.t2s + hit.t2e)), seedParamTol * 4);
+        }
+        for (const seed of seeds) {
+            const refined = this.refinePair(c1, c2, seed.u1, seed.u2, pointTol, false);
+            if (!refined)
+                continue;
+            this.pushUnique(ret, {
+                point: refined.point,
+                u1: refined.u1,
+                u2: refined.u2,
+                isOverlap: false,
+            });
+        }
+        return ret;
+    }
+    buildSegments(samples) {
+        const ret = [];
+        for (let i = 0; i < samples.length - 1; i++) {
+            const a = samples[i];
+            const b = samples[i + 1];
+            ret.push({
+                u0: a.u,
+                u1: b.u,
+                seg: makeSegment(a.p, b.p),
+            });
+        }
+        return ret;
+    }
+    addNearMissSeeds(seeds, a, b, paramTol) {
+        this.addPointSeed(seeds, 0.5 * (a.u0 + a.u1), 0.5 * (b.u0 + b.u1), paramTol);
+    }
+    buildPairCandidates(segs1, segs2, pad) {
+        if (segs1.length === 0 || segs2.length === 0)
+            return [];
+        const index = new SegmentHashIndex(segs2, pad);
+        const marks = new Int32Array(segs2.length);
+        const ret = [];
+        let stamp = 1;
+        for (let i = 0; i < segs1.length; i++) {
+            const s1 = segs1[i];
+            const js = index.query(s1, pad, marks, stamp++);
+            if (stamp >= 0x7fffffff) {
+                marks.fill(0);
+                stamp = 1;
+            }
+            for (const j of js) {
+                const s2 = segs2[j];
+                if (!segmentBoxesMayIntersect(s1.seg, s2.seg, pad))
+                    continue;
+                ret.push({ i, j });
+            }
+        }
+        return ret;
+    }
+    addPointSeed(seeds, u1, u2, paramTol) {
+        if (this.runPointSeedLimit > 0 && seeds.length >= this.runPointSeedLimit)
+            return;
+        for (const seed of seeds) {
+            if (Math.abs(seed.u1 - u1) <= paramTol &&
+                Math.abs(seed.u2 - u2) <= paramTol) {
+                return;
+            }
+        }
+        seeds.push({ u1, u2 });
+    }
+    addOverlapSeed(seeds, next) {
+        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 (this.runOverlapSeedLimit > 0 && seeds.length >= this.runOverlapSeedLimit)
+            return;
+        seeds.push(next);
+    }
+    refinePair(c1, c2, u1Seed, u2Seed, tol, strictCertify = false) {
+        const newton = this.refineByNewton(c1, c2, u1Seed, u2Seed, tol);
+        if (newton && newton.residual <= tol * 2) {
+            if (!strictCertify) {
+                polylineDiagnostics.maxResidual = Math.max(polylineDiagnostics.maxResidual, newton.residual);
+                return newton;
+            }
+            const certified = certifyParamPair(c1, c2, newton, tol, (curve, p, t) => this.safeClosestPoint(curve, p, t));
+            if (certified) {
+                polylineDiagnostics.maxResidual = Math.max(polylineDiagnostics.maxResidual, certified.pair.residual);
+                if (certified.usedDegenerateRescue)
+                    polylineDiagnostics.degenerateRescueCount++;
+                return certified.pair;
+            }
+            polylineDiagnostics.certificationRejectCount++;
+        }
+        const proj = this.refineByProjection(c1, c2, newton?.u1 ?? u1Seed, newton?.u2 ?? u2Seed, tol);
+        if (proj && proj.residual <= tol * 2) {
+            if (!strictCertify) {
+                polylineDiagnostics.maxResidual = Math.max(polylineDiagnostics.maxResidual, proj.residual);
+                return proj;
+            }
+            const certified = certifyParamPair(c1, c2, proj, tol, (curve, p, t) => this.safeClosestPoint(curve, p, t));
+            if (certified) {
+                polylineDiagnostics.maxResidual = Math.max(polylineDiagnostics.maxResidual, certified.pair.residual);
+                if (certified.usedDegenerateRescue)
+                    polylineDiagnostics.degenerateRescueCount++;
+                return certified.pair;
+            }
+            polylineDiagnostics.certificationRejectCount++;
+        }
+        const best = this.pickBest(newton, proj);
+        if (!best || best.residual > tol * 8) {
+            polylineDiagnostics.refineFailureCount++;
+            return undefined;
+        }
+        if (!strictCertify) {
+            polylineDiagnostics.maxResidual = Math.max(polylineDiagnostics.maxResidual, best.residual);
+            return best;
+        }
+        const certified = certifyParamPair(c1, c2, best, tol, (curve, p, t) => this.safeClosestPoint(curve, p, t));
+        if (!certified) {
+            polylineDiagnostics.certificationRejectCount++;
+            polylineDiagnostics.refineFailureCount++;
+            return undefined;
+        }
+        polylineDiagnostics.maxResidual = Math.max(polylineDiagnostics.maxResidual, certified.pair.residual);
+        if (certified.usedDegenerateRescue)
+            polylineDiagnostics.degenerateRescueCount++;
+        return certified.pair;
+    }
+    refineByNewton(c1, c2, u1Seed, u2Seed, tol) {
+        const r1 = c1.getRange();
+        const r2 = c2.getRange();
+        const span1 = Math.max(r1.length(), Precision.CURVE_PARAM_EPS);
+        const span2 = Math.max(r2.length(), Precision.CURVE_PARAM_EPS);
+        let u1 = r1.clamp(u1Seed);
+        let u2 = r2.clamp(u2Seed);
+        let best = this.measure(c1, c2, u1, u2);
+        let lastDelta = Number.POSITIVE_INFINITY;
+        for (let i = 0; i < this.maxNewtonIter; i++) {
+            polylineDiagnostics.newtonIterationsTotal++;
+            const p1 = c1.pointAt(u1);
+            const p2 = c2.pointAt(u2);
+            const diff = p1.subtracted(p2);
+            if (diff.len() <= tol)
+                return this.measure(c1, c2, u1, u2);
+            const t1 = c1.tangentAt(u1);
+            const t2 = c2.tangentAt(u2);
+            const det = t1.cross(t2);
+            if (Math.abs(det) <= Precision.CURVE_NEWTON_EPS) {
+                break;
+            }
+            // [t1.x -t2.x; t1.y -t2.y] * [du, dv]^T = -diff
+            const bx = -diff.x;
+            const by = -diff.y;
+            let du = (bx * (-t2.y) - by * (-t2.x)) / det;
+            let dv = (t1.x * by - t1.y * bx) / det;
+            if (!Number.isFinite(du) || !Number.isFinite(dv)) {
+                break;
+            }
+            const limit1 = Math.max(span1 * 0.25, Precision.CURVE_PARAM_EPS * 8);
+            const limit2 = Math.max(span2 * 0.25, Precision.CURVE_PARAM_EPS * 8);
+            du = clamp(du, -limit1, limit1);
+            dv = clamp(dv, -limit2, limit2);
+            let nextU1 = r1.clamp(u1 + du);
+            let nextU2 = r2.clamp(u2 + dv);
+            let candidate = this.measure(c1, c2, nextU1, nextU2);
+            // Damping if raw Newton step does not improve.
+            if (candidate.residual > best.residual + tol * 0.2) {
+                let accepted = false;
+                for (let damp = 0; damp < 4; damp++) {
+                    const f = Math.pow(0.5, damp + 1);
+                    const dU1 = du * f;
+                    const dU2 = dv * f;
+                    nextU1 = r1.clamp(u1 + dU1);
+                    nextU2 = r2.clamp(u2 + dU2);
+                    candidate = this.measure(c1, c2, nextU1, nextU2);
+                    if (candidate.residual <= best.residual + tol * 0.1) {
+                        accepted = true;
+                        break;
+                    }
+                }
+                if (!accepted && candidate.residual > best.residual + tol * 0.25) {
+                    break;
+                }
+            }
+            const delta = Math.abs(nextU1 - u1) + Math.abs(nextU2 - u2);
+            u1 = nextU1;
+            u2 = nextU2;
+            if (candidate.residual < best.residual)
+                best = candidate;
+            if (delta <= Precision.CURVE_PARAM_EPS * 8) {
+                break;
+            }
+            if (delta >= lastDelta - Precision.CURVE_PARAM_EPS * 8) {
+                break;
+            }
+            lastDelta = delta;
+        }
+        const final = this.measure(c1, c2, u1, u2);
+        return this.pickBest(best, final);
+    }
+    refineByProjection(c1, c2, u1Seed, u2Seed, tol) {
+        const r1 = c1.getRange();
+        const r2 = c2.getRange();
+        let u1 = r1.clamp(u1Seed);
+        let u2 = r2.clamp(u2Seed);
+        let best = this.measure(c1, c2, u1, u2);
+        for (let i = 0; i < this.maxNewtonIter; i++) {
+            polylineDiagnostics.projectionIterationsTotal++;
+            const p1 = c1.pointAt(u1);
+            const cp2 = this.safeClosestPoint(c2, p1, tol);
+            if (!cp2)
+                break;
+            const nextU2 = r2.clamp(cp2.param);
+            const p2 = c2.pointAt(nextU2);
+            const cp1 = this.safeClosestPoint(c1, p2, tol);
+            if (!cp1)
+                break;
+            const nextU1 = r1.clamp(cp1.param);
+            const candidate = this.measure(c1, c2, nextU1, nextU2);
+            if (candidate.residual < best.residual)
+                best = candidate;
+            if (candidate.residual <= tol)
+                return candidate;
+            const du = Math.abs(nextU1 - u1);
+            const dv = Math.abs(nextU2 - u2);
+            u1 = nextU1;
+            u2 = nextU2;
+            if (du + dv <= Precision.CURVE_PARAM_EPS * 8)
+                break;
+        }
+        return best;
+    }
+    runRescuePass(c1, c2, pointTol, seedParamTol, strictCertify) {
+        polylineDiagnostics.rescuePassCount++;
+        const ret = [];
+        const seeds = [];
+        const r1 = c1.getRange();
+        const r2 = c2.getRange();
+        const baseSamples = Math.max(24, Math.min(96, Math.floor(this.segmentsPerCurve / 2)));
+        for (let i = 0; i <= baseSamples; i++) {
+            const t = i / baseSamples;
+            const u1 = r1.start + (r1.end - r1.start) * t;
+            const p1 = c1.pointAt(u1);
+            const cp2 = this.safeClosestPoint(c2, p1, pointTol * 3);
+            if (!cp2 || cp2.distance > pointTol * 2.5)
+                continue;
+            this.addPointSeed(seeds, u1, r2.clamp(cp2.param), seedParamTol);
+        }
+        for (let i = 0; i <= baseSamples; i++) {
+            const t = i / baseSamples;
+            const u2 = r2.start + (r2.end - r2.start) * t;
+            const p2 = c2.pointAt(u2);
+            const cp1 = this.safeClosestPoint(c1, p2, pointTol * 3);
+            if (!cp1 || cp1.distance > pointTol * 2.5)
+                continue;
+            this.addPointSeed(seeds, r1.clamp(cp1.param), u2, seedParamTol);
+        }
+        polylineDiagnostics.rescueSeedCount += seeds.length;
+        for (const seed of seeds) {
+            const refined = this.refinePair(c1, c2, seed.u1, seed.u2, pointTol, strictCertify);
+            if (!refined)
+                continue;
+            this.pushUnique(ret, {
+                point: refined.point,
+                u1: refined.u1,
+                u2: refined.u2,
+                isOverlap: false,
+            });
+        }
+        return ret;
+    }
+    measure(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),
+        };
+    }
+    refineOverlap(c1, c2, overlap, tol, paramTol) {
+        const midU1 = 0.5 * (overlap.range1.start + overlap.range1.end);
+        const midU2 = 0.5 * (overlap.range2.start + overlap.range2.end);
+        const mid = this.refinePair(c1, c2, midU1, midU2, tol, false);
+        if (!mid)
+            return undefined;
+        const range2 = projectRangeToCurve(c1, c2, overlap.range1, tol, (curve, p, t) => this.safeClosestPoint(curve, p, t));
+        if (!range2)
+            return undefined;
+        if (overlap.range1.length() <= paramTol || range2.length() <= paramTol) {
+            return {
+                point: mid.point,
+                u1: mid.u1,
+                u2: mid.u2,
+                isOverlap: false,
+            };
+        }
+        const quality = certifyOverlapMonotone(c1, c2, overlap.range1, tol, paramTol, (curve, p, t) => this.safeClosestPoint(curve, p, t));
+        if (!quality) {
+            return {
+                point: mid.point,
+                u1: mid.u1,
+                u2: mid.u2,
+                isOverlap: false,
+            };
+        }
+        return {
+            point: mid.point,
+            u1: mid.u1,
+            u2: mid.u2,
+            isOverlap: true,
+            range1: overlap.range1,
+            range2,
+        };
+    }
+    safeClosestPoint(curve, p, tol) {
+        try {
+            return curve.closestPoint(p, tol);
+        }
+        catch {
+            polylineDiagnostics.numericClosestFallbackCount++;
+            return this.sampleClosestPoint(curve, p, 48);
+        }
+    }
+    sampleClosestPoint(curve, p, sampleCount) {
+        const range = curve.getRange();
+        let bestParam = range.start;
+        let bestPoint = curve.pointAt(bestParam);
+        let bestDist = bestPoint.distanceTo(p);
+        const total = Math.max(8, sampleCount);
+        for (let i = 1; i <= total; i++) {
+            const t = i / total;
+            const u = range.start + (range.end - range.start) * t;
+            const q = curve.pointAt(u);
+            const d = q.distanceTo(p);
+            if (d < bestDist) {
+                bestDist = d;
+                bestPoint = q;
+                bestParam = u;
+            }
+        }
+        // Local Newton refinement around sampled best parameter.
+        let u = bestParam;
+        for (let i = 0; i < 12; i++) {
+            const cp = curve.pointAt(u).subtracted(p);
+            const d1 = curve.derivativeAt(u, 1);
+            const d2 = curve.derivativeAt(u, 2);
+            const f = cp.dot(d1);
+            const fp = d1.dot(d1) + cp.dot(d2);
+            if (!Number.isFinite(f) || !Number.isFinite(fp) || Math.abs(fp) <= Precision.CURVE_NEWTON_EPS)
+                break;
+            const next = range.clamp(u - f / fp);
+            if (Math.abs(next - u) <= Precision.CURVE_PARAM_EPS * 4) {
+                u = next;
+                break;
+            }
+            u = next;
+        }
+        bestParam = u;
+        bestPoint = curve.pointAt(bestParam);
+        bestDist = bestPoint.distanceTo(p);
+        return {
+            point: bestPoint,
+            param: bestParam,
+            distance: bestDist,
+        };
+    }
+    pickBest(a, b) {
+        if (!a)
+            return b;
+        if (!b)
+            return a;
+        return a.residual <= b.residual ? a : b;
+    }
+    pushUnique(out, next) {
+        for (const item of out) {
+            if (Math.abs(item.u1 - next.u1) <= Precision.CURVE_PARAM_EPS * 8 &&
+                Math.abs(item.u2 - next.u2) <= Precision.CURVE_PARAM_EPS * 8 &&
+                item.point.distanceTo(next.point) <= Precision.CURVE_LENGTH_EPS * 4 &&
+                item.isOverlap === next.isOverlap) {
+                return;
+            }
+        }
+        out.push(next);
+    }
+    recursiveMaxNodes(c1, c2) {
+        const heavy = c1.isBSpline() || c2.isBSpline() || c1.isEllipseArc() || c2.isEllipseArc();
+        return heavy
+            ? Math.max(5000, this.segmentsPerCurve * 28)
+            : Math.max(2500, this.segmentsPerCurve * 16);
+    }
+}
+function clamp(x, min, max) {
+    return Math.min(max, Math.max(min, x));
+}
+function clampInt(x, min, max) {
+    return Math.min(max, Math.max(min, x | 0));
+}