@itwin/core-geometry 5.9.0-dev.8 → 5.9.0

package/lib/esm/curve/internalContexts/CurveCurveCloseApproachXY.js

@@ -5,22 +5,26 @@
 /** @packageDocumentation
  * @module Curve
  */
-import { assert } from "@itwin/core-bentley";
-import { BSplineCurve3d, BSplineCurve3dBase } from "../../bspline/BSplineCurve";
+import { assert, DuplicatePolicy, SortedArray } from "@itwin/core-bentley";
+import { BSplineCurve3dBase } from "../../bspline/BSplineCurve";
 import { Geometry } from "../../Geometry";
 import { RecurseToCurvesGeometryHandler } from "../../geometry3d/GeometryHandler";
 import { GrowableFloat64Array } from "../../geometry3d/GrowableFloat64Array";
 import { Point3d } from "../../geometry3d/Point3dVector3d";
 import { Range3d } from "../../geometry3d/Range";
-import { CurveCurveCloseApproachXYRRtoRRD, CurvePointCloseApproachXYRtoRD, Newton1dUnbounded, Newton2dUnboundedWithDerivative, } from "../../numerics/Newton";
+import { CurveCurveCloseApproachXYRRtoRRD, Newton2dUnboundedWithDerivative } from "../../numerics/Newton";
 import { AnalyticRoots } from "../../numerics/Polynomials";
 import { SmallSystem } from "../../numerics/SmallSystem";
 import { Arc3d } from "../Arc3d";
 import { CurveChainWithDistanceIndex } from "../CurveChainWithDistanceIndex";
 import { CurveCollection } from "../CurveCollection";
+import { CurveCurve } from "../CurveCurve";
 import { CurveIntervalRole, CurveLocationDetail, CurveLocationDetailPair } from "../CurveLocationDetail";
+import { CurvePrimitive } from "../CurvePrimitive";
 import { LineSegment3d } from "../LineSegment3d";
 import { LineString3d } from "../LineString3d";
+import { ProxyCurve } from "../ProxyCurve";
+import { TransitionSpiral3d } from "../spiral/TransitionSpiral3d";
 // cspell:word XYRR currentdFdX
 /**
  * Handler class for XY close approach between _geometryB and another geometry.
@@ -38,9 +42,6 @@ import { LineString3d } from "../LineString3d";
  */
 export class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
     _geometryB;
-    setGeometryB(geometryB) {
-        this._geometryB = geometryB;
-    }
     /**
      * Maximum XY distance (z is ignored). Approach larger than this is not interesting.
      * This is caller defined and can be undefined.
@@ -48,6 +49,8 @@ export class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
     _maxDistanceToAccept;
     /** Squared max distance. Default is [[Geometry.smallMetricDistanceSquared]]. */
     _maxDistanceSquared;
+    _xyTolerance;
+    _newtonTolerance;
     /**
      * Start and end points of line segments that meet closest approach criteria, i.e., they are perpendicular to
      * both curves and their length is smaller than _maxDistanceToAccept.
@@ -61,18 +64,28 @@ export class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
     /**
      * Constructor.
      * @param geometryB second curve for intersection. Saved for reference by specific handler methods.
+     * @param xyTolerance optional tolerance for comparing xy points (default [[Geometry.smallMetricDistance]]).
+     * @param newtonTolerance optional relative fraction tolerance for Newton iteration (default [[Geometry.smallNewtonStep]]).
      */
-    constructor(geometryB) {
+    constructor(geometryB, xyTolerance = Geometry.smallMetricDistance, newtonTolerance = Geometry.smallNewtonStep) {
         super();
-        this.setGeometryB(geometryB);
+        this._geometryB = geometryB instanceof ProxyCurve ? geometryB.proxyCurve : geometryB;
         this._maxDistanceSquared = Geometry.smallMetricDistanceSquared;
-        this._results = [];
+        this._xyTolerance = xyTolerance;
+        this._newtonTolerance = newtonTolerance;
+        const compare = CurveLocationDetailPair.comparePairsByPoints(xyTolerance, true);
+        this._results = new SortedArray(compare, DuplicatePolicy.Retain);
     }
     /** Set the (possibly undefined) max XY distance (z is ignored) to accept. */
     set maxDistanceToAccept(value) {
-        this._maxDistanceToAccept = value;
-        if (this._maxDistanceToAccept !== undefined && this._maxDistanceToAccept > 0)
-            this._maxDistanceSquared = this._maxDistanceToAccept * this._maxDistanceToAccept;
+        if (value === undefined) {
+            this._maxDistanceToAccept = undefined;
+            this._maxDistanceSquared = Geometry.smallMetricDistanceSquared;
+        }
+        else {
+            this._maxDistanceToAccept = Math.abs(value);
+            this._maxDistanceSquared = value * value;
+        }
     }
     /** Access the (possibly undefined) max XY distance (z is ignored) to accept. */
     get maxDistanceToAccept() {
@@ -82,9 +95,14 @@ export class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
     get isMaxDistanceSet() {
         return this._maxDistanceToAccept !== undefined && this._maxDistanceToAccept > 0;
     }
-    /** Reset the geometry and flags, leaving all other parts unchanged (and preserving accumulated intersections) */
+    /**
+     * Reset the geometry.
+     * * Undefined inputs are ignored.
+     * * All other instance data is unchanged, including accumulated intersections.
+     */
     resetGeometry(geometryB) {
-        this.setGeometryB(geometryB);
+        if (geometryB)
+            this._geometryB = geometryB;
     }
     /** returns true if `fraction` is in [0,1] within tolerance */
     acceptFraction(fraction, fractionTol = 1.0e-12) {
@@ -94,131 +112,103 @@ export class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
             return false;
         return true;
     }
-    /**
-     * Return the results structure for the intersection calculation, structured as an array of CurveLocationDetailPair.
-     * @param reinitialize if true, a new results structure is created for use by later calls.
-     */
-    grabPairedResults(reinitialize = false) {
-        const result = this._results;
-        if (reinitialize)
-            this._results = [];
-        return result;
+    /** Extract (and clear) the results, structured as an array of CurveLocationDetailPair. */
+    grabPairedResults() {
+        return this._results.extractArray();
     }
     /**
-     * If distance between pointA and pointB is less than maxDistance, record CurveLocationDetailPair which is
-     * the approach from pointA to pointB.
+     * Create and record a close-approach pair from raw curve/fraction/point data.
+     * * If points are undefined, they are computed from the fractions via `fractionToPoint`.
+     * * Fractions are global (i.e., relative to the full curve, not a sub-segment).
+     * * The pair is recorded only if the XY distance is within `_maxDistanceSquared`.
+     * @param cpA first curve
+     * @param fA global fraction on cpA
+     * @param pointA point on cpA at fA, or undefined to compute from fA
+     * @param cpB second curve
+     * @param fB global fraction on cpB
+     * @param pointB point on cpB at fB, or undefined to compute from fB
+     * @param reversed if true, swap detailA and detailB before recording
      */
-    testAndRecordPointPairApproach(cpA, fA, pointA, cpB, fB, pointB, reversed) {
+    testAndRecordPointPair(cpA, fA, pointA, cpB, fB, pointB, reversed) {
+        if (!pointA)
+            pointA = cpA.fractionToPoint(fA);
+        if (!pointB)
+            pointB = cpB.fractionToPoint(fB);
         const d2 = pointA.distanceSquaredXY(pointB);
-        if (d2 < this._maxDistanceSquared) {
+        if (d2 <= this._maxDistanceSquared) {
             const d = Math.sqrt(d2);
             const detailA = CurveLocationDetail.createCurveFractionPointDistance(cpA, fA, pointA, d);
             const detailB = CurveLocationDetail.createCurveFractionPointDistance(cpB, fB, pointB, d);
+            detailA.setIntervalRole(CurveIntervalRole.isolated);
+            detailB.setIntervalRole(CurveIntervalRole.isolated);
             const pair = CurveLocationDetailPair.createCapture(detailA, detailB);
             if (reversed)
                 pair.swapDetails();
-            this._results.push(pair);
+            this._results.insert(pair);
         }
     }
     /**
-     * Create a close approach pair if XY distance is within maxDistance.
-     * @param localFractionA a fraction on first curve
-     * @param cpA the first curve
-     * @param fractionA0 start of the first curve
-     * @param fractionA1 end of the first curve
-     * @param localFractionB a fraction on second curve
-     * @param cpB the second curve
-     * @param fractionB0 start of the second curve
-     * @param fractionB1 end of the second curve
-     * @param reversed whether to reverse the details in the pair (e.g., so that detailB refers to geometryB).
+     * Record a pre-built close-approach pair with global fractions already set.
+     * * Computes and stores the XY distance on both details.
+     * * The pair is recorded only if the XY distance is within `_maxDistanceSquared`.
+     * @param pair details with global fractions and points already set; modified in place
+     * @param reversed if true, swap detailA and detailB before recording
      */
-    recordPointWithLocalFractions(localFractionA, cpA, fractionA0, fractionA1, localFractionB, cpB, fractionB0, fractionB1, reversed) {
-        const globalFractionA = Geometry.interpolate(fractionA0, localFractionA, fractionA1);
-        const globalFractionB = Geometry.interpolate(fractionB0, localFractionB, fractionB1);
-        // ignore duplicate of most recent approach
-        const numPrevious = this._results.length;
-        if (numPrevious > 0) {
-            const oldDetailA = this._results[numPrevious - 1].detailA;
-            const oldDetailB = this._results[numPrevious - 1].detailB;
-            if (reversed) {
-                if (oldDetailB.isSameCurveAndFraction({ curve: cpA, fraction: globalFractionA }) &&
-                    oldDetailA.isSameCurveAndFraction({ curve: cpB, fraction: globalFractionB }))
-                    return;
-            }
-            else {
-                if (oldDetailA.isSameCurveAndFraction({ curve: cpA, fraction: globalFractionA }) &&
-                    oldDetailB.isSameCurveAndFraction({ curve: cpB, fraction: globalFractionB }))
-                    return;
-            }
-        }
-        const pointA = cpA.fractionToPoint(globalFractionA);
-        const pointB = cpB.fractionToPoint(globalFractionB);
-        const d2 = pointA.distanceSquaredXY(pointB);
+    testAndRecordPair(pair, reversed) {
+        const d2 = pair.detailA.point.distanceSquaredXY(pair.detailB.point);
         if (d2 > this._maxDistanceSquared)
             return;
         const d = Math.sqrt(d2);
-        const detailA = CurveLocationDetail.createCurveFractionPointDistance(cpA, globalFractionA, pointA, d);
-        const detailB = CurveLocationDetail.createCurveFractionPointDistance(cpB, globalFractionB, pointB, d);
-        detailA.setIntervalRole(CurveIntervalRole.isolated);
-        detailB.setIntervalRole(CurveIntervalRole.isolated);
+        pair.detailA.a = pair.detailB.a = d;
+        pair.detailA.setIntervalRole(CurveIntervalRole.isolated);
+        pair.detailB.setIntervalRole(CurveIntervalRole.isolated);
         if (reversed)
-            this._results.push(new CurveLocationDetailPair(detailB, detailA));
-        else
-            this._results.push(new CurveLocationDetailPair(detailA, detailB));
+            pair.swapDetails();
+        this._results.insert(pair);
     }
     /**
-     * Capture a close approach pair that has point and local fraction but not curve.
-     * * Record the pair, each detail modified with global fraction and input curve.
-     * * Pair is neither modified nor recorded if it would be a duplicate of the last recorded pair.
-     * @param pair details computed with local fractions
-     * @param cpA curveA
-     * @param fractionA0 global start fraction on curveA
-     * @param fractionA1 global end fraction on curveA
-     * @param cpB curveB
-     * @param fractionB0 global start fraction on curveB
-     * @param fractionB1 global end fraction on curveB
-     * @param reversed whether to reverse the details in the pair (e.g., so that detailB refers to geometryB).
+     * Convert a close-approach pair from local (sub-segment) fractions to global fractions, then record it.
+     * * Local fractions in the pair are interpolated into the global fraction ranges.
+     * * Points are recomputed from the parent curves at the global fractions.
+     * * The pair is recorded only if the XY distance is within `_maxDistanceSquared`.
+     * @param pair local details (curve unspecified); modified in place with global fractions, curves, and points
+     * @param cpA parent curve A
+     * @param fractionA0 global fraction corresponding to local fraction 0 on curve A
+     * @param fractionA1 global fraction corresponding to local fraction 1 on curve A
+     * @param cpB parent curve B
+     * @param fractionB0 global fraction corresponding to local fraction 0 on curve B
+     * @param fractionB1 global fraction corresponding to local fraction 1 on curve B
+     * @param reversed if true, swap detailA and detailB before recording
      */
-    capturePairWithLocalFractions(pair, cpA, fractionA0, fractionA1, cpB, fractionB0, fractionB1, reversed) {
+    testAndRecordLocalPair(pair, cpA, fractionA0, fractionA1, cpB, fractionB0, fractionB1, reversed) {
         const globalFractionA = Geometry.interpolate(fractionA0, pair.detailA.fraction, fractionA1);
         const globalFractionB = Geometry.interpolate(fractionB0, pair.detailB.fraction, fractionB1);
-        // ignore duplicate of most recent pair
-        const numPrevious = this._results.length;
-        if (numPrevious > 0) {
-            const oldDetailA = this._results[numPrevious - 1].detailA;
-            const oldDetailB = this._results[numPrevious - 1].detailB;
-            if (reversed) {
-                if (oldDetailB.isSameCurveAndFraction({ curve: cpA, fraction: globalFractionA }) &&
-                    oldDetailA.isSameCurveAndFraction({ curve: cpB, fraction: globalFractionB }))
-                    return;
-            }
-            else {
-                if (oldDetailA.isSameCurveAndFraction({ curve: cpA, fraction: globalFractionA }) &&
-                    oldDetailB.isSameCurveAndFraction({ curve: cpB, fraction: globalFractionB }))
-                    return;
-            }
-        }
-        // recompute the points just in case
-        CurveLocationDetail.createCurveEvaluatedFraction(cpA, globalFractionA, pair.detailA);
-        CurveLocationDetail.createCurveEvaluatedFraction(cpB, globalFractionB, pair.detailB);
-        pair.detailA.a = pair.detailB.a = pair.detailA.point.distanceXY(pair.detailB.point);
+        const pointA = cpA.fractionToPoint(globalFractionA);
+        const pointB = cpB.fractionToPoint(globalFractionB);
+        const d2 = pointA.distanceSquaredXY(pointB);
+        if (d2 > this._maxDistanceSquared)
+            return;
+        const d = Math.sqrt(d2);
+        CurveLocationDetail.createCurveFractionPointDistance(cpA, globalFractionA, pointA, d, pair.detailA);
+        CurveLocationDetail.createCurveFractionPointDistance(cpB, globalFractionB, pointB, d, pair.detailB);
         pair.detailA.setIntervalRole(CurveIntervalRole.isolated);
         pair.detailB.setIntervalRole(CurveIntervalRole.isolated);
         if (reversed)
             pair.swapDetails();
-        this._results.push(pair);
+        this._results.insert(pair);
     }
-    static updatePointToSegmentDistance(fractionA, pointA, pointB0, pointB1, fractionB, maxDistanceSquared, closestApproach) {
+    /** Modify the current closest approach if the inputs are closer. */
+    static updatePointToSegmentDistance(closestApproach, fractionA, pointA, fractionB, pointB0, pointB1, maxDistanceSquared) {
         let updated = false;
         if (fractionB < 0)
             fractionB = 0;
         else if (fractionB > 1)
             fractionB = 1;
-        this._workPointB = pointB0.interpolate(fractionB, pointB1, this._workPointB);
-        const distanceSquared = this._workPointB.distanceSquaredXY(pointA);
+        const pointB = pointB0.interpolate(fractionB, pointB1, this._workPointB);
+        const distanceSquared = pointB.distanceSquaredXY(pointA);
         if (distanceSquared <= Math.min(maxDistanceSquared, closestApproach.detailA.a)) {
             closestApproach.detailA.setFP(fractionA, pointA, undefined, distanceSquared);
-            closestApproach.detailB.setFP(fractionB, this._workPointB, undefined, distanceSquared);
+            closestApproach.detailB.setFP(fractionB, pointB, undefined, distanceSquared);
             updated = true;
         }
         return updated;
@@ -231,8 +221,9 @@ export class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
      * @param b0 start point of line b
      * @param b1 end point of line b
      * @param maxDistanceSquared maximum distance squared (assumed to be positive)
-     * @returns the fractional (not xy) coordinates in result.x and result.y. result.x is fraction on line a.
-     * result.y is fraction on line b.
+     * @returns a pair of details for the closest approach, or `undefined` if no approach is within `maxDistanceSquared`.
+      * `detailA.fraction` is the fraction on segment a; `detailB.fraction` is the fraction on segment b. Returned
+      * details store the *squared* distance in the `a` property.
      */
     static segmentSegmentBoundedApproach(a0, a1, b0, b1, maxDistanceSquared) {
         const ux = a1.x - a0.x;
@@ -261,23 +252,23 @@ export class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
         const uu = Geometry.hypotenuseSquaredXY(ux, uy);
         if (hab0 * hab0 <= maxDistanceSquared * uu) { // test distance of b0 to u
             const fractionA = Geometry.safeDivideFraction(Geometry.dotProductXYXY(ux, uy, e00x, e00y), uu, 0.0);
-            if (this.updatePointToSegmentDistance(0, b0, a0, a1, fractionA, maxDistanceSquared, closestApproach))
+            if (this.updatePointToSegmentDistance(closestApproach, 0, b0, fractionA, a0, a1, maxDistanceSquared))
                 reversed = true;
         }
         if (hab1 * hab1 <= maxDistanceSquared * uu) { // test distance of b1 to u
             const fractionA = Geometry.safeDivideFraction(Geometry.dotProductXYXY(ux, uy, e01x, e01y), uu, 0.0);
-            if (this.updatePointToSegmentDistance(1, b1, a0, a1, fractionA, maxDistanceSquared, closestApproach))
+            if (this.updatePointToSegmentDistance(closestApproach, 1, b1, fractionA, a0, a1, maxDistanceSquared))
                 reversed = true;
         }
         const vv = Geometry.hypotenuseSquaredXY(vx, vy);
         if (hba0 * hba0 <= maxDistanceSquared * vv) { // test distance of a0 to v
             const fractionB = Geometry.safeDivideFraction(-Geometry.dotProductXYXY(vx, vy, e00x, e00y), vv, 0.0);
-            if (this.updatePointToSegmentDistance(0, a0, b0, b1, fractionB, maxDistanceSquared, closestApproach))
+            if (this.updatePointToSegmentDistance(closestApproach, 0, a0, fractionB, b0, b1, maxDistanceSquared))
                 reversed = false;
         }
         if (hba1 * hba1 <= maxDistanceSquared * vv) { // test distance of a1 to v
             const fractionB = Geometry.safeDivideFraction(-Geometry.dotProductXYXY(vx, vy, e10x, e10y), vv, 0.0);
-            if (this.updatePointToSegmentDistance(1, a1, b0, b1, fractionB, maxDistanceSquared, closestApproach))
+            if (this.updatePointToSegmentDistance(closestApproach, 1, a1, fractionB, b0, b1, maxDistanceSquared))
                 reversed = false;
         }
         if (closestApproach.detailA.a > maxDistanceSquared)
@@ -287,96 +278,30 @@ export class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
         return closestApproach;
     }
     /**
-     * Check different combination of fractions on curveA and curveB. If distance between points at 2 fractions
-     * is less than maxDistance, record CurveLocationDetailPair which is the approach between the 2 points.
-     * Optionally, record close approaches of one curve's points if they fall between the other curve's points.
-     * * If an input curve is a LineString3d, then the corresponding fractions must define a segment of the line string.
+     * Compute closest approaches from the endpoints of each curve (if open) to the other curve.
+     * Record a [[CurveLocationDetailPair]] if such a distance is less than [[maxDistance]].
      * @param cpA curveA
-     * @param fA0 fraction0 on curveA
-     * @param fA1 fraction1 on curveA
-     * @param testProjectionOnA whether to record projections of the given curveB points onto curveA
      * @param cpB curveB
-     * @param fB0 fraction0 on curveB
-     * @param fB1 fraction0 on curveB
-     * @param testProjectionOnB whether to record projections of the given curveA points onto curveB
-     * @param reversed whether to reverse the details in the pair (e.g., so that detailB refers to geometryB).
+     * @param reversed whether to reverse the details in the pair (e.g., so that detailB refers to curveA).
      */
-    testAndRecordFractionalPairApproach(cpA, fA0, fA1, testProjectionOnA, cpB, fB0, fB1, testProjectionOnB, reversed) {
-        const pointA0 = cpA.fractionToPoint(fA0);
-        const pointA1 = cpA.fractionToPoint(fA1);
-        const pointB0 = cpB.fractionToPoint(fB0);
-        const pointB1 = cpB.fractionToPoint(fB1);
-        this.testAndRecordPointPairApproach(cpA, fA0, pointA0, cpB, fB0, pointB0, reversed);
-        this.testAndRecordPointPairApproach(cpA, fA1, pointA1, cpB, fB0, pointB0, reversed);
-        this.testAndRecordPointPairApproach(cpA, fA0, pointA0, cpB, fB1, pointB1, reversed);
-        this.testAndRecordPointPairApproach(cpA, fA1, pointA1, cpB, fB1, pointB1, reversed);
-        if (testProjectionOnB) {
-            this.testAndRecordProjection(cpA, fA0, pointA0, cpB, fB0, fB1, reversed);
-            this.testAndRecordProjection(cpA, fA1, pointA1, cpB, fB0, fB1, reversed);
-        }
-        if (testProjectionOnA) {
-            this.testAndRecordProjection(cpB, fB0, pointB0, cpA, fA0, fA1, !reversed);
-            this.testAndRecordProjection(cpB, fB1, pointB1, cpA, fA0, fA1, !reversed);
+    testAndRecordEndPointApproaches(cpA, cpB, reversed) {
+        const pt = CurveCurveCloseApproachXY._workPointB;
+        // in closest approach context, endpoints of full sweep arcs are artificial locations, and thus ignored
+        const isClosedArc = (curve) => curve instanceof Arc3d && curve.sweep.isFullCircle;
+        if (!isClosedArc(cpA)) {
+            this.testAndRecordProjection(cpA, 0, cpA.startPoint(pt), cpB, reversed);
+            this.testAndRecordProjection(cpA, 1, cpA.endPoint(pt), cpB, reversed);
         }
-    }
-    /**
-     * Return XY closest approach between a curve primitive and a point.
-     * Currently, this function only supports Arc3d and LineSegment.
-     * Note that this function doesn't handle endpoints.
-     */
-    getPointCurveClosestApproachXYNewton(curveP, pointQ) {
-        if (!(curveP instanceof Arc3d) && !(curveP instanceof LineSegment3d)) {
-            assert(false, "getPointCurveClosestApproachXYNewton only supports Arc3d and LineSegment");
-        }
-        const seeds = [0.2, 0.4, 0.6, 0.8]; // HEURISTIC: arcs have up to 4 perpendiculars; lines have only 1
-        const newtonEvaluator = new CurvePointCloseApproachXYRtoRD(curveP, pointQ);
-        const newtonSearcher = new Newton1dUnbounded(newtonEvaluator, 100); // observed convergence to 1.0e-11 in 66 iters
-        let minCloseApproachLength = Geometry.largeCoordinateResult;
-        let minCurvePFraction;
-        let minPointP;
-        for (const seed of seeds) {
-            newtonSearcher.setX(seed);
-            if (newtonSearcher.runIterations()) {
-                const curvePFraction = newtonSearcher.getX();
-                if (this.acceptFraction(curvePFraction)) {
-                    const pointP = curveP.fractionToPoint(curvePFraction);
-                    const closeApproachLength = pointP.distanceSquaredXY(pointQ);
-                    if (closeApproachLength < minCloseApproachLength) {
-                        minCloseApproachLength = closeApproachLength;
-                        minCurvePFraction = curvePFraction;
-                        minPointP = pointP;
-                    }
-                }
-            }
+        if (!isClosedArc(cpB)) {
+            this.testAndRecordProjection(cpB, 0, cpB.startPoint(pt), cpA, !reversed);
+            this.testAndRecordProjection(cpB, 1, cpB.endPoint(pt), cpA, !reversed);
         }
-        if (minCurvePFraction && minPointP)
-            return CurveLocationDetail.createCurveFractionPoint(curveP, minCurvePFraction, minPointP);
-        return undefined;
     }
-    /**
-     * Find the closest xy approach between `pointA` and `cpB`. Add the approach if it's within `fB0` and `fB1`.
-     * * Does not test the endpoints of `cpB`.
-     * * The only types supported for `cpB` are Arc3d, LineSegment3d, and LineString3d.
-     * * If `cpB` is a LineString3d, then the interval `[fB0, fB1]` must correspond to a segment of the line string.
-    */
-    testAndRecordProjection(cpA, fA, pointA, cpB, fB0, fB1, reversed) {
-        let detail;
-        if (cpB instanceof LineString3d) {
-            const segParamsB = cpB.globalFractionToSegmentIndexAndLocalFraction(fB0 <= fB1 ? fB0 : fB1);
-            const segIndexB = (segParamsB.fraction < 0.999999) ? segParamsB.index : segParamsB.index + 1;
-            const segmentB = cpB.getIndexedSegment(segIndexB);
-            if (segmentB && (detail = this.getPointCurveClosestApproachXYNewton(segmentB, pointA)))
-                LineString3d.convertLocalToGlobalDetail(detail, segIndexB, cpB.numEdges(), cpB);
-        }
-        else {
-            detail = this.getPointCurveClosestApproachXYNewton(cpB, pointA);
-        }
-        if (detail) {
-            const fB = Geometry.restrictToInterval(detail.fraction, fB0, fB1);
-            if (fB === detail.fraction) { // if fraction is within fB0 and fB1
-                this.testAndRecordPointPairApproach(cpA, fA, pointA, cpB, detail.fraction, detail.point, reversed);
-            }
-        }
+    /** Find the closest xy approach between `pointA` and `cpB`. */
+    testAndRecordProjection(cpA, fA, pointA, cpB, reversed) {
+        const detail = cpB.closestPointXY(pointA);
+        if (detail)
+            this.testAndRecordPointPair(cpA, fA, pointA, cpB, detail.fraction, detail.point, reversed);
     }
     /**
      * Compute closest xy approach of two line segments.
@@ -384,63 +309,50 @@ export class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
      * Record with fraction mapping.
      * * The fraction mappings allow portions of a linestring to be passed here.
      */
-    computeSegmentSegment3D(cpA, pointA0, fractionA0, pointA1, fractionA1, cpB, pointB0, fractionB0, pointB1, fractionB1, reversed) {
+    computeSegmentSegment(cpA, pointA0, fractionA0, pointA1, fractionA1, cpB, pointB0, fractionB0, pointB1, fractionB1, reversed) {
         // compute a pair with fractions local to segments
         const approach = CurveCurveCloseApproachXY.segmentSegmentBoundedApproach(pointA0, pointA1, pointB0, pointB1, this._maxDistanceSquared);
         // adjust the pair to refer to input curves and global fractions, then record it if new
         if (approach) {
             approach.detailA.setCurve(cpA);
             approach.detailB.setCurve(cpB);
-            this.capturePairWithLocalFractions(approach, cpA, fractionA0, fractionA1, cpB, fractionB0, fractionB1, reversed);
+            this.testAndRecordLocalPair(approach, cpA, fractionA0, fractionA1, cpB, fractionB0, fractionB1, reversed);
         }
     }
-    /** Low level dispatch of segment with segment. */
-    dispatchSegmentSegment(cpA, pointA0, fractionA0, pointA1, fractionA1, cpB, pointB0, fractionB0, pointB1, fractionB1, reversed) {
-        this.computeSegmentSegment3D(cpA, pointA0, fractionA0, pointA1, fractionA1, cpB, pointB0, fractionB0, pointB1, fractionB1, reversed);
-    }
     /**
      * Compute the perpendiculars between a line segment and an arc, without extending either curve.
      * * One or two perpendiculars will be found.
      * * Each perpendicular segment starts or ends on the arc where the arc tangent is parallel to the line tangent.
-     * * Perpendiculars from an endpoint are not explicitly computed.
-     * @param cpA line segment or line string; if it is a line string, then the fractions must specify a segment
-     * @param pointA0 start point of the segment
-     * @param fractionA0 fraction of the start of the segment
-     * @param pointA1 end point of the segment
-     * @param fractionA1 fraction of the end of the segment
-     * @param arc the arc
-     * @param reversed swap the details in the recorded pair (default: false)
+     * @param startA line segment start point
+     * @param endA line segment end point
+     * @param arcB the arc
+     * @param announce callback to receive line and arc fractions and optional points of each perpendicular segment computed.
      */
-    allPerpendicularsSegmentArcBounded(cpA, pointA0, fractionA0, pointA1, fractionA1, arc, reversed = false) {
-        const dotUT = arc.vector0.crossProductStartEndXY(pointA0, pointA1);
-        const dotVT = arc.vector90.crossProductStartEndXY(pointA0, pointA1);
+    announceAllPerpendicularsSegmentArcBounded(startA, endA, arcB, announce) {
+        const dotUT = arcB.vector0.crossProductStartEndXY(startA, endA);
+        const dotVT = arcB.vector90.crossProductStartEndXY(startA, endA);
         const parallelRadians = Math.atan2(dotVT, dotUT);
         for (const radians1 of [parallelRadians, parallelRadians + Math.PI]) {
-            const arcPoint = arc.radiansToPoint(radians1);
-            const fArc = arc.sweep.radiansToSignedPeriodicFraction(radians1);
-            if (this.acceptFraction(fArc)) { // reject solution outside arc sweep
-                const fLine = SmallSystem.lineSegment3dXYClosestPointUnbounded(pointA0, pointA1, arcPoint);
-                if (fLine !== undefined && this.acceptFraction(fLine))
-                    this.recordPointWithLocalFractions(fLine, cpA, fractionA0, fractionA1, fArc, arc, 0, 1, reversed);
+            const arcPoint = arcB.radiansToPoint(radians1);
+            const arcFraction = arcB.sweep.radiansToSignedPeriodicFraction(radians1);
+            if (this.acceptFraction(arcFraction)) { // reject solution outside arc sweep
+                const lineFraction = SmallSystem.lineSegment3dXYClosestPointUnbounded(startA, endA, arcPoint);
+                if (lineFraction !== undefined && this.acceptFraction(lineFraction))
+                    announce(lineFraction, undefined, arcFraction, arcPoint);
             }
         }
     }
     /**
-     * Low level dispatch of line segment with arc.
-     * Find close approaches within maxDistance between a line segments (pointA0, pointA1) and an arc.
+     * Find close approaches within maxDistance between a line segment and an arc.
      * To consider:
      * 1) intersection between arc and segment.
-     * 2) endpoints to endpoints or endpoints projection to the other curve.
-     * 3) arc tangent parallel to line segment (or line string).
-     * @param cpA curve A (line segment or line string; if it is a line string, then the fractions must specify a segment)
-     * @param pointA0 start point of the segment
-     * @param fractionA0 fraction of the start of the segment
-     * @param pointA1 end point of the segment
-     * @param fractionA1 fraction of the end of the segment
-     * @param arc the arc
-     * @param reversed whether to reverse the details in the pair (e.g., so that detailB refers to geometryB).
+     * 2) endpoints to endpoints, or endpoints projection to the other curve.
+     * 3) arc tangent parallel to line segment
+     * @param lineA the line segment
+     * @param arcB the arc
+     * @param reversed whether to reverse the details in the pair (e.g., so that detailB refers to arcA).
      */
-    dispatchSegmentArc(cpA, pointA0, fractionA0, pointA1, fractionA1, arc, reversed) {
+    computeSegmentArc(lineA, arcB, reversed) {
         // 1) intersection between arc and line segment (or string).
         // Suppose:
         // Arc: X = C + cU + sV where c = cos(theta) and s = sin(theta)
@@ -451,45 +363,45 @@ export class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
         // evaluate points.
         // project back to line.
         let intersectionFound = false;
-        const data = arc.toTransformedVectors();
-        const pointA0Local = pointA0;
-        const pointA1Local = pointA1;
-        const alpha = Geometry.tripleProductXYW(pointA0Local, 1, pointA1Local, 1, data.center, 1); //  det(A0, A1, C)
-        const beta = Geometry.tripleProductXYW(pointA0Local, 1, pointA1Local, 1, data.vector0, 0); // det(A0, A1, U)
-        const gamma = Geometry.tripleProductXYW(pointA0Local, 1, pointA1Local, 1, data.vector90, 0); // det(A0, A1, V)
+        const data = arcB.toTransformedVectors();
+        const alpha = Geometry.tripleProductXYW(lineA.point0Ref, 1, lineA.point1Ref, 1, data.center, 1); //  det(A0, A1, C)
+        const beta = Geometry.tripleProductXYW(lineA.point0Ref, 1, lineA.point1Ref, 1, data.vector0, 0); // det(A0, A1, U)
+        const gamma = Geometry.tripleProductXYW(lineA.point0Ref, 1, lineA.point1Ref, 1, data.vector90, 0); // det(A0, A1, V)
         const cosines = new GrowableFloat64Array(2);
         const sines = new GrowableFloat64Array(2);
         const radians = new GrowableFloat64Array(2);
-        const numRoots = AnalyticRoots.appendImplicitLineUnitCircleIntersections(// solve the equation
-        alpha, beta, gamma, cosines, sines, radians);
+        const numRoots = AnalyticRoots.appendImplicitLineUnitCircleIntersections(alpha, beta, gamma, cosines, sines, radians);
         for (let i = 0; i < numRoots; i++) {
             const arcPoint = data.center.plus2Scaled(data.vector0, cosines.atUncheckedIndex(i), data.vector90, sines.atUncheckedIndex(i));
             const arcFraction = data.sweep.radiansToSignedPeriodicFraction(radians.atUncheckedIndex(i));
-            const lineFraction = SmallSystem.lineSegment3dXYClosestPointUnbounded(pointA0Local, pointA1Local, arcPoint);
-            // only add if the point is within the start and end fractions of both line segment and arc
-            if (lineFraction !== undefined && this.acceptFraction(lineFraction) && this.acceptFraction(arcFraction)) {
-                this.recordPointWithLocalFractions(lineFraction, cpA, fractionA0, fractionA1, arcFraction, arc, 0, 1, reversed);
-                intersectionFound = true;
+            if (this.acceptFraction(arcFraction)) { // reject solution outside arc sweep
+                const lineFraction = SmallSystem.lineSegment3dXYClosestPointUnbounded(lineA.point0Ref, lineA.point1Ref, arcPoint);
+                if (lineFraction !== undefined && this.acceptFraction(lineFraction)) {
+                    this.testAndRecordPointPair(lineA, lineFraction, undefined, arcB, arcFraction, arcPoint, reversed);
+                    intersectionFound = true;
+                }
             }
         }
         if (intersectionFound)
             return;
-        // 2) endpoints to endpoints or endpoints projection to the other curve.
-        this.testAndRecordFractionalPairApproach(cpA, fractionA0, fractionA1, true, arc, 0, 1, true, reversed);
-        // 3) arc tangent parallel to line segment (or string).
+        // 2) endpoints to endpoints, or endpoints projection to the other curve.
+        this.testAndRecordEndPointApproaches(lineA, arcB, reversed);
+        // 3) arc tangent parallel to line segment.
         // If line does not intersect the arc, then the closest (and/or the furthest) point on arc to the line is a
         // point where the tangent line on arc at that point is parallel to the line.
-        this.allPerpendicularsSegmentArcBounded(cpA, pointA0, fractionA0, pointA1, fractionA1, arc, reversed);
+        this.announceAllPerpendicularsSegmentArcBounded(lineA.point0Ref, lineA.point1Ref, arcB, (lineFraction, linePoint, arcFraction, arcPoint) => this.testAndRecordPointPair(lineA, lineFraction, linePoint, arcB, arcFraction, arcPoint, reversed));
     }
     /**
      * Compute segments perpendicular to two elliptical arcs, without extending either curve.
      * * Perpendiculars from an endpoint are not explicitly computed.
      * * Intersections are also found by this search: they are reported as zero-length segments.
+     * @param arcA first arc
+     * @param arcB second arc
      * @param reversed swap the details in the recorded pair (default: false)
      */
-    allPerpendicularsArcArcBounded(arc0, arc1, reversed = false) {
-        const newtonEvaluator = new CurveCurveCloseApproachXYRRtoRRD(arc0, arc1);
-        // HEURISTIC: 2 ellipses have up to 8 perpendiculars and up to 4 intersections
+    allPerpendicularsArcArcBounded(arcA, arcB, reversed = false) {
+        const newtonEvaluator = new CurveCurveCloseApproachXYRRtoRRD(arcA, arcB);
+        // HEURISTIC: 2 ellipses have up to 8 perpendiculars
         const seedDelta = 1 / 10; // denominator 9 fails the unit test
         const seedStart = seedDelta / 2;
         const newtonSearcher = new Newton2dUnboundedWithDerivative(newtonEvaluator, 100); // observed convergence to 1.0e-11 in 49 iters
@@ -497,10 +409,10 @@ export class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
             for (let seedV = seedStart; seedV < 1; seedV += seedDelta) {
                 newtonSearcher.setUV(seedU, seedV);
                 if (newtonSearcher.runIterations()) {
-                    const frac0 = newtonSearcher.getU();
-                    const frac1 = newtonSearcher.getV();
-                    if (this.acceptFraction(frac0) && this.acceptFraction(frac1)) {
-                        this.recordPointWithLocalFractions(frac0, arc0, 0, 1, frac1, arc1, 0, 1, reversed);
+                    const fractionA = newtonSearcher.getU();
+                    const fractionB = newtonSearcher.getV();
+                    if (this.acceptFraction(fractionA) && this.acceptFraction(fractionB)) {
+                        this.testAndRecordPointPair(arcA, fractionA, undefined, arcB, fractionB, undefined, reversed);
                     }
                 }
             }
@@ -515,36 +427,10 @@ export class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
         if (!rangeB.intersectsRangeXY(rangeA))
             return;
         // 1) endpoints to endpoints or endpoints projection to the other curve
-        this.testAndRecordFractionalPairApproach(cpA, 0, 1, true, cpB, 0, 1, true, reversed);
+        this.testAndRecordEndPointApproaches(cpA, cpB, reversed);
         // 2) perpendicular line between 2 arcs (includes intersections)
         this.allPerpendicularsArcArcBounded(cpA, cpB, reversed);
     }
-    /** Low level dispatch of arc with (beziers of) a bspline curve */
-    dispatchArcBsplineCurve3d(cpA, cpB, reversed) {
-        const ls = LineString3d.create();
-        cpB.emitStrokes(ls);
-        this.computeArcLineString(cpA, ls, reversed);
-    }
-    /** Low level dispatch of (beziers of) a bspline curve with (beziers of) a bspline curve */
-    dispatchBSplineCurve3dBSplineCurve3d(bcurveA, bcurveB, reversed) {
-        const lsA = LineString3d.create();
-        bcurveA.emitStrokes(lsA);
-        const lsB = LineString3d.create();
-        bcurveB.emitStrokes(lsB);
-        this.computeLineStringLineString(lsA, lsB, reversed);
-    }
-    /** Low level dispatch of linestring with (beziers of) a bspline curve */
-    dispatchLineStringBSplineCurve(lsA, curveB, reversed) {
-        const lsB = LineString3d.create();
-        curveB.emitStrokes(lsB);
-        this.computeLineStringLineString(lsA, lsB, reversed);
-    }
-    /** Low level dispatch of segment with (beziers of) a bspline curve */
-    dispatchSegmentBsplineCurve(segA, curveB, reversed) {
-        const lsB = LineString3d.create();
-        curveB.emitStrokes(lsB);
-        this.computeSegmentLineString(segA, lsB, reversed);
-    }
     /** Detail computation for segment approaching linestring. */
     computeSegmentLineString(segA, lsB, reversed) {
         const numB = lsB.numPoints();
@@ -558,7 +444,7 @@ export class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
             const fB1 = (i + 1 === numB - 1) ? 1.0 : (i + 1) * deltaFracB; // make sure we nail the end fraction
             lsB.packedPoints.getPoint3dAtUncheckedPointIndex(i, pointB0);
             lsB.packedPoints.getPoint3dAtUncheckedPointIndex(i + 1, pointB1);
-            this.dispatchSegmentSegment(segA, pointA0, 0.0, pointA1, 1.0, lsB, pointB0, fB0, pointB1, fB1, reversed);
+            this.computeSegmentSegment(segA, pointA0, 0.0, pointA1, 1.0, lsB, pointB0, fB0, pointB1, fB1, reversed);
         }
     }
     /** Detail computation for arc approaching linestring. */
@@ -569,72 +455,28 @@ export class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
             rangeA.expandInPlace(this._maxDistanceToAccept);
         if (!rangeB.intersectsRangeXY(rangeA))
             return;
-        const pointB0 = CurveCurveCloseApproachXY._workPointBB0;
-        const pointB1 = CurveCurveCloseApproachXY._workPointBB1;
-        const numB = lsB.numPoints();
-        if (numB > 1) {
-            const dfB = 1.0 / (numB - 1);
-            let fB0;
-            let fB1;
-            fB0 = 0.0;
-            lsB.pointAt(0, pointB0);
-            for (let ib = 1; ib < numB; ib++, pointB0.setFrom(pointB1), fB0 = fB1) {
-                lsB.pointAt(ib, pointB1);
-                fB1 = ib * dfB;
-                this.dispatchSegmentArc(lsB, pointB0, fB0, pointB1, fB1, arcA, !reversed);
-            }
+        const v0 = CurveCurveCloseApproachXY._workPointBB0;
+        const v1 = CurveCurveCloseApproachXY._workPointBB1;
+        // 1. record intersections
+        const intersections = CurveCurve.intersectionXYPairs(arcA, false, lsB, false, this._xyTolerance);
+        for (const intersection of intersections)
+            this.testAndRecordPair(intersection, reversed);
+        // 2. record linestring interior vertex projections onto arc
+        const fStep = Geometry.safeDivideFraction(1.0, lsB.numEdges(), 0);
+        for (let i = 1; i < lsB.numEdges(); ++i)
+            this.testAndRecordProjection(lsB, i * fStep, lsB.pointAtUnchecked(i, v0), arcA, !reversed);
+        // 3. record arc/linestring endpoint projections onto linestring/arc
+        this.testAndRecordEndPointApproaches(arcA, lsB, reversed);
+        // 4. record perpendiculars from within a segment to the arc
+        lsB.startPoint(v0);
+        for (let iSeg = 0; iSeg < lsB.numEdges(); ++iSeg, v0.setFrom(v1)) {
+            lsB.pointAtUnchecked(iSeg + 1, v1);
+            this.announceAllPerpendicularsSegmentArcBounded(v0, v1, arcA, (lineFraction, linePoint, arcFraction, arcPoint) => {
+                const fLineString = lsB.segmentIndexAndLocalFractionToGlobalFraction(iSeg, lineFraction);
+                this.testAndRecordPointPair(arcA, arcFraction, arcPoint, lsB, fLineString, linePoint, reversed);
+            });
         }
     }
-    /** Low level dispatch of curve collection. */
-    dispatchCurveCollection(geomA, geomAHandler) {
-        const geomB = this._geometryB; // save
-        if (!geomB || !geomB.children || !(geomB instanceof CurveCollection))
-            return;
-        for (const child of geomB.children) {
-            this.resetGeometry(child);
-            geomAHandler(geomA);
-        }
-        this._geometryB = geomB; // restore
-    }
-    /** Low level dispatch to geomA given a CurveChainWithDistanceIndex in geometryB. */
-    dispatchCurveChainWithDistanceIndex(geomA, geomAHandler) {
-        if (!this._geometryB || !(this._geometryB instanceof CurveChainWithDistanceIndex))
-            return;
-        if (geomA instanceof CurveChainWithDistanceIndex) {
-            assert(false, "call handleCurveChainWithDistanceIndex(geomA) instead");
-        }
-        const index0 = this._results.length;
-        const geomB = this._geometryB; // save
-        for (const child of geomB.path.children) {
-            this.resetGeometry(child);
-            geomAHandler(geomA);
-        }
-        this.resetGeometry(geomB); // restore
-        this._results = CurveChainWithDistanceIndex.convertChildDetailToChainDetail(this._results, index0, undefined, geomB, true);
-    }
-    /** Double dispatch handler for strongly typed segment. */
-    handleLineSegment3d(segmentA) {
-        if (this._geometryB instanceof LineSegment3d) {
-            const segmentB = this._geometryB;
-            this.dispatchSegmentSegment(segmentA, segmentA.point0Ref, 0.0, segmentA.point1Ref, 1.0, segmentB, segmentB.point0Ref, 0.0, segmentB.point1Ref, 1.0, false);
-        }
-        else if (this._geometryB instanceof LineString3d) {
-            this.computeSegmentLineString(segmentA, this._geometryB, false);
-        }
-        else if (this._geometryB instanceof Arc3d) {
-            this.dispatchSegmentArc(segmentA, segmentA.point0Ref, 0.0, segmentA.point1Ref, 1.0, this._geometryB, false);
-        }
-        else if (this._geometryB instanceof BSplineCurve3d) {
-            this.dispatchSegmentBsplineCurve(segmentA, this._geometryB, false);
-        }
-        else if (this._geometryB instanceof CurveCollection) {
-            this.dispatchCurveCollection(segmentA, this.handleLineSegment3d.bind(this));
-        }
-        else if (this._geometryB instanceof CurveChainWithDistanceIndex) {
-            this.dispatchCurveChainWithDistanceIndex(segmentA, this.handleLineSegment3d.bind(this));
-        }
-        return undefined;
-    }
     /**
      * Set bits for comparison to range xy
      * * bit 0x01 => x smaller than range.low.x
@@ -707,26 +549,164 @@ export class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
                         // DO NOT study the segment in detail if both bitB bits are on for any of the 4 planes
                         // (i.e., no intersection between rangeA1 and the range around line segment [B0,B1])
                         if ((bitB0 & bitB1) === 0)
-                            this.dispatchSegmentSegment(lsA, pointA0, fA0, pointA1, fA1, lsB, pointB0, fB0, pointB1, fB1, reversed);
+                            this.computeSegmentSegment(lsA, pointA0, fA0, pointA1, fA1, lsB, pointB0, fB0, pointB1, fB1, reversed);
                     }
                 }
             }
         }
     }
+    /** Low level dispatch of curve collection. */
+    dispatchCurveCollection(geomA, geomAHandler) {
+        const geomB = this._geometryB; // save
+        if (!geomB || !geomB.children || !(geomB instanceof CurveCollection))
+            return;
+        for (const child of geomB.children) {
+            this.resetGeometry(child);
+            geomAHandler(geomA);
+        }
+        this._geometryB = geomB; // restore
+    }
+    /** Low level dispatch to geomA given a CurveChainWithDistanceIndex in geometryB. */
+    dispatchCurveChainWithDistanceIndex(geomA, geomAHandler) {
+        if (!this._geometryB || !(this._geometryB instanceof CurveChainWithDistanceIndex))
+            return;
+        if (geomA instanceof CurveChainWithDistanceIndex)
+            assert(false, "call handleCurveChainWithDistanceIndex(geomA) instead");
+        const saveResults = this.grabPairedResults();
+        const geomB = this._geometryB;
+        for (const child of geomB.path.children) {
+            this.resetGeometry(child);
+            geomAHandler(geomA);
+        }
+        this.resetGeometry(geomB);
+        const childResults = this._results.extractArray();
+        childResults.forEach((pair) => {
+            CurveChainWithDistanceIndex.convertChildDetailToChainDetailSingle(pair, undefined, geomB);
+            this._results.insert(pair);
+        });
+        saveResults.forEach((pair) => this._results.insert(pair));
+    }
+    /** Specifies whether the curve needs to be stroked for close approach computation. */
+    needsStroking(curve) {
+        return curve instanceof BSplineCurve3dBase || curve instanceof TransitionSpiral3d;
+    }
+    /**
+     * Process seeds for xy close approach between one curve and another curve to be stroked.
+     * * Refine each result via Newton iteration. If it doesn't converge, remove it.
+     * @param seeds the initial seed results to refine.
+     * @param curveA curve to find its XY close approach with curveB.
+     * @param curveB the other curve to be stroked.
+     * @param reversed whether `curveB` data is in `detailA` of each recorded pair, and `curveA` data in `detailB`.
+     */
+    refineStrokedResultsByNewton(seeds, curveA, curveB, reversed = false) {
+        const xyMatchingFunction = new CurveCurveCloseApproachXYRRtoRRD(curveA, curveB);
+        const newtonSearcher = new Newton2dUnboundedWithDerivative(xyMatchingFunction, 50, this._newtonTolerance); // seen: 47
+        for (const seed of seeds) {
+            const detailA = reversed ? seed.detailB : seed.detailA;
+            const detailB = reversed ? seed.detailA : seed.detailB;
+            assert(detailB.curve instanceof LineString3d, "Caller has discretized the curve");
+            newtonSearcher.setUV(detailA.fraction, detailB.fraction); // use the linestring fraction as initial curveB fraction (ASSUME it's close enough)
+            if (newtonSearcher.runIterations()) {
+                const fractionA = newtonSearcher.getU();
+                const fractionB = newtonSearcher.getV();
+                if (this.acceptFraction(fractionA) && this.acceptFraction(fractionB))
+                    this.testAndRecordPointPair(curveA, fractionA, undefined, curveB, fractionB, undefined, reversed);
+            } // ignore failure to converge
+        }
+    }
+    /**
+     * Append stroke points and return the line string.
+     * * This is a convenient wrapper for [[CurvePrimitive.emitStrokes]] but the analogous instance method cannot be added
+     * to that class due to the ensuing recursion with subclass [[LineString3d]].
+     * @param options options for stroking the instance curve.
+     * @param result object to receive appended stroke points; if omitted, a new object is created, populated, and returned.
+     */
+    strokeCurve(curve, options, result) {
+        const ls = result ? result : LineString3d.create();
+        curve.emitStrokes(ls, options);
+        return ls;
+    }
+    /** Find and return the close approaches between curveA and the discretization of curveB. */
+    computeDiscreteCloseApproachResults(curveA, lsB, reversed) {
+        const maxDist = this.maxDistanceToAccept;
+        const saveResults = this.grabPairedResults(); // save current results
+        const geomB = this._geometryB;
+        this.maxDistanceToAccept = maxDist ? maxDist * 1.2 : undefined; // HEURISTIC: allow slack for Newton seeds
+        this.resetGeometry(curveA);
+        this.handleLineString3d(lsB); // populate empty results with discrete solutions
+        if (!reversed) {
+            // handleLineString3d put lsB data into detailA, so if we aren't reversing, we need to swap
+            for (const result of this._results)
+                result.swapDetails();
+        }
+        this.resetGeometry(geomB);
+        this.maxDistanceToAccept = maxDist;
+        const discreteResults = this._results.extractArray();
+        saveResults.forEach((pair) => this._results.insert(pair)); // restore current results
+        return discreteResults;
+    }
+    /**
+     * Compute the XY close approach of a curve and another curve to be stroked.
+     * @param curveA curve to find its XY close approach with curveB.
+     * @param curveB the other curve to be stroked.
+     * @param reversed whether `curveB` data will be recorded in `detailA` of each result, and `curveA` data in `detailB`.
+     */
+    dispatchCurveStrokedCurve(curveA, curveB, reversed) {
+        // explicit search for intersections (Newton converges too slowly on DirectSpiral3d tangent intersections)
+        const intersections = CurveCurve.intersectionXYPairs(curveA, false, curveB, false, this._xyTolerance);
+        for (const intersection of intersections)
+            this.testAndRecordPair(intersection, reversed);
+        // append seeds computed by solving the discretized spiral close approach problem, then refine the seeds via Newton
+        let cpA = curveA;
+        if (this.needsStroking(curveA))
+            cpA = this.strokeCurve(curveA);
+        const cpB = this.strokeCurve(curveB);
+        const seeds = this.computeDiscreteCloseApproachResults(cpA, cpB, reversed);
+        this.refineStrokedResultsByNewton(seeds, curveA, curveB, reversed);
+        if (curveA instanceof LineString3d) { // explicitly test corners (where Newton converges too slowly)
+            const fStep = Geometry.safeDivideFraction(1.0, curveA.numEdges(), 0);
+            const v0 = CurveCurveCloseApproachXY._workPointBB0;
+            for (let i = 1; i < curveA.numEdges(); ++i)
+                this.testAndRecordProjection(curveA, i * fStep, curveA.pointAtUnchecked(i, v0), curveB, reversed);
+        }
+        this.testAndRecordEndPointApproaches(curveA, curveB, reversed);
+    }
+    /** Double dispatch handler for strongly typed segment. */
+    handleLineSegment3d(segmentA) {
+        if (this._geometryB instanceof LineSegment3d) {
+            const segmentB = this._geometryB;
+            this.computeSegmentSegment(segmentA, segmentA.point0Ref, 0.0, segmentA.point1Ref, 1.0, segmentB, segmentB.point0Ref, 0.0, segmentB.point1Ref, 1.0, false);
+        }
+        else if (this._geometryB instanceof LineString3d) {
+            this.computeSegmentLineString(segmentA, this._geometryB, false);
+        }
+        else if (this._geometryB instanceof Arc3d) {
+            this.computeSegmentArc(segmentA, this._geometryB, false);
+        }
+        else if (this.needsStroking(this._geometryB)) {
+            this.dispatchCurveStrokedCurve(segmentA, this._geometryB, false);
+        }
+        else if (this._geometryB instanceof CurveCollection) {
+            this.dispatchCurveCollection(segmentA, this.handleLineSegment3d.bind(this));
+        }
+        else if (this._geometryB instanceof CurveChainWithDistanceIndex) {
+            this.dispatchCurveChainWithDistanceIndex(segmentA, this.handleLineSegment3d.bind(this));
+        }
+        return undefined;
+    }
     /** Double dispatch handler for strongly typed linestring. */
     handleLineString3d(lsA) {
-        if (this._geometryB instanceof LineString3d) {
-            const lsB = this._geometryB;
-            this.computeLineStringLineString(lsA, lsB, false);
-        }
-        else if (this._geometryB instanceof LineSegment3d) {
+        if (this._geometryB instanceof LineSegment3d) {
             this.computeSegmentLineString(this._geometryB, lsA, true);
         }
+        else if (this._geometryB instanceof LineString3d) {
+            this.computeLineStringLineString(lsA, this._geometryB, false);
+        }
         else if (this._geometryB instanceof Arc3d) {
             this.computeArcLineString(this._geometryB, lsA, true);
         }
-        else if (this._geometryB instanceof BSplineCurve3d) {
-            this.dispatchLineStringBSplineCurve(lsA, this._geometryB, false);
+        else if (this.needsStroking(this._geometryB)) {
+            this.dispatchCurveStrokedCurve(lsA, this._geometryB, false);
         }
         else if (this._geometryB instanceof CurveCollection) {
             this.dispatchCurveCollection(lsA, this.handleLineString3d.bind(this));
@@ -737,46 +717,50 @@ export class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
         return undefined;
     }
     /** Double dispatch handler for strongly typed arc. */
-    handleArc3d(arc0) {
+    handleArc3d(arcA) {
         if (this._geometryB instanceof LineSegment3d) {
-            this.dispatchSegmentArc(this._geometryB, this._geometryB.point0Ref, 0.0, this._geometryB.point1Ref, 1.0, arc0, true);
+            this.computeSegmentArc(this._geometryB, arcA, true);
         }
         else if (this._geometryB instanceof LineString3d) {
-            this.computeArcLineString(arc0, this._geometryB, false);
+            this.computeArcLineString(arcA, this._geometryB, false);
         }
         else if (this._geometryB instanceof Arc3d) {
-            this.dispatchArcArc(arc0, this._geometryB, false);
+            this.dispatchArcArc(arcA, this._geometryB, false);
         }
-        else if (this._geometryB instanceof BSplineCurve3d) {
-            this.dispatchArcBsplineCurve3d(arc0, this._geometryB, false);
+        else if (this.needsStroking(this._geometryB)) {
+            this.dispatchCurveStrokedCurve(arcA, this._geometryB, false);
         }
         else if (this._geometryB instanceof CurveCollection) {
-            this.dispatchCurveCollection(arc0, this.handleArc3d.bind(this));
+            this.dispatchCurveCollection(arcA, this.handleArc3d.bind(this));
         }
         else if (this._geometryB instanceof CurveChainWithDistanceIndex) {
-            this.dispatchCurveChainWithDistanceIndex(arc0, this.handleArc3d.bind(this));
+            this.dispatchCurveChainWithDistanceIndex(arcA, this.handleArc3d.bind(this));
         }
         return undefined;
     }
     /** Double dispatch handler for strongly typed bspline curve. */
-    handleBSplineCurve3d(curve) {
-        if (this._geometryB instanceof LineSegment3d) {
-            this.dispatchSegmentBsplineCurve(this._geometryB, curve, true);
+    handleBSplineCurve3d(curveA) {
+        if (this._geometryB instanceof CurveChainWithDistanceIndex) {
+            this.dispatchCurveChainWithDistanceIndex(curveA, this.handleBSplineCurve3d.bind(this));
         }
-        else if (this._geometryB instanceof LineString3d) {
-            this.dispatchLineStringBSplineCurve(this._geometryB, curve, true);
+        else if (this._geometryB instanceof CurvePrimitive) {
+            this.dispatchCurveStrokedCurve(this._geometryB, curveA, true);
         }
-        else if (this._geometryB instanceof Arc3d) {
-            this.dispatchArcBsplineCurve3d(this._geometryB, curve, true);
+        else if (this._geometryB instanceof CurveCollection) {
+            this.dispatchCurveCollection(curveA, this.handleBSplineCurve3d.bind(this));
+        }
+        return undefined;
+    }
+    /** Double dispatch handler for strongly typed spiral curve. */
+    handleTransitionSpiral(spiral) {
+        if (this._geometryB instanceof CurveChainWithDistanceIndex) {
+            this.dispatchCurveChainWithDistanceIndex(spiral, this.handleTransitionSpiral.bind(this));
         }
-        else if (this._geometryB instanceof BSplineCurve3dBase) {
-            this.dispatchBSplineCurve3dBSplineCurve3d(curve, this._geometryB, false);
+        else if (this._geometryB instanceof CurvePrimitive) {
+            this.dispatchCurveStrokedCurve(this._geometryB, spiral, true);
         }
         else if (this._geometryB instanceof CurveCollection) {
-            this.dispatchCurveCollection(curve, this.handleBSplineCurve3d.bind(this));
-        }
-        else if (this._geometryB instanceof CurveChainWithDistanceIndex) {
-            this.dispatchCurveChainWithDistanceIndex(curve, this.handleBSplineCurve3d.bind(this));
+            this.dispatchCurveCollection(spiral, this.handleTransitionSpiral.bind(this));
         }
         return undefined;
     }
@@ -784,23 +768,15 @@ export class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
     handleCurveChainWithDistanceIndex(chain) {
         super.handleCurveChainWithDistanceIndex(chain);
         // if _geometryB is also a CurveChainWithDistanceIndex, it will already have been converted by dispatchCurveChainWithDistanceIndex
-        this._results = CurveChainWithDistanceIndex.convertChildDetailToChainDetail(this._results, 0, chain, undefined, true);
+        const childResults = this._results.extractArray();
+        childResults.forEach((pair) => {
+            CurveChainWithDistanceIndex.convertChildDetailToChainDetailSingle(pair, chain, undefined);
+            this._results.insert(pair);
+        });
     }
     /** Double dispatch handler for strongly typed homogeneous bspline curve .. */
     handleBSplineCurve3dH(_curve) {
-        /*
-        //NEEDS WORK -- make "dispatch" methods tolerant of both 3d and 3dH.
-        // "easy" if both present BezierCurve3dH span loaders
-        if (this._geometryB instanceof LineSegment3d) {
-          this.dispatchSegmentBsplineCurve(
-            this._geometryB, this._extendB, this._geometryB.point0Ref, 0.0, this._geometryB.point1Ref, 1.0, this._extendB,
-            curve, this._extendA, true);
-        } else if (this._geometryB instanceof LineString3d) {
-          this.dispatchLineStringBSplineCurve(this._geometryB, this._extendB, curve, this._extendA, true);
-        } else if (this._geometryB instanceof Arc3d) {
-          this.dispatchArcBsplineCurve3d(this._geometryB, this._extendB, curve, this._extendA, true);
-        }
-        */
+        // NEEDS WORK -- make "dispatch" methods tolerant of both 3d and 3dH
         return undefined;
     }
 }