@itwin/core-geometry 5.9.0-dev.15 → 5.9.0-dev.17

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

@@ -6,7 +6,7 @@
  * @module Curve
  */
 import { assert, DuplicatePolicy, SortedArray } from "@itwin/core-bentley";
-import { BSplineCurve3d, BSplineCurve3dBase } from "../../bspline/BSplineCurve";
+import { BSplineCurve3dBase } from "../../bspline/BSplineCurve";
 import { Geometry } from "../../Geometry";
 import { RecurseToCurvesGeometryHandler } from "../../geometry3d/GeometryHandler";
 import { GrowableFloat64Array } from "../../geometry3d/GrowableFloat64Array";
@@ -431,32 +431,6 @@ export class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
         // 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();
@@ -612,6 +586,91 @@ export class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
         });
         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) {
@@ -624,11 +683,8 @@ export class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
         else if (this._geometryB instanceof Arc3d) {
             this.computeSegmentArc(segmentA, this._geometryB, false);
         }
-        else if (this._geometryB instanceof BSplineCurve3d) {
-            this.dispatchSegmentBsplineCurve(segmentA, this._geometryB, false);
-        }
-        else if (this._geometryB instanceof TransitionSpiral3d) {
-            this.dispatchCurveSpiral(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));
@@ -649,11 +705,8 @@ export class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
         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._geometryB instanceof TransitionSpiral3d) {
-            this.dispatchCurveSpiral(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));
@@ -674,11 +727,8 @@ export class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
         else if (this._geometryB instanceof Arc3d) {
             this.dispatchArcArc(arcA, this._geometryB, false);
         }
-        else if (this._geometryB instanceof BSplineCurve3d) {
-            this.dispatchArcBsplineCurve3d(arcA, this._geometryB, false);
-        }
-        else if (this._geometryB instanceof TransitionSpiral3d) {
-            this.dispatchCurveSpiral(arcA, this._geometryB, false);
+        else if (this.needsStroking(this._geometryB)) {
+            this.dispatchCurveStrokedCurve(arcA, this._geometryB, false);
         }
         else if (this._geometryB instanceof CurveCollection) {
             this.dispatchCurveCollection(arcA, this.handleArc3d.bind(this));
@@ -690,117 +740,24 @@ export class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
     }
     /** Double dispatch handler for strongly typed bspline curve. */
     handleBSplineCurve3d(curveA) {
-        if (this._geometryB instanceof LineSegment3d) {
-            this.dispatchSegmentBsplineCurve(this._geometryB, curveA, true);
-        }
-        else if (this._geometryB instanceof LineString3d) {
-            this.dispatchLineStringBSplineCurve(this._geometryB, curveA, true);
-        }
-        else if (this._geometryB instanceof Arc3d) {
-            this.dispatchArcBsplineCurve3d(this._geometryB, curveA, true);
-        }
-        else if (this._geometryB instanceof BSplineCurve3dBase) {
-            this.dispatchBSplineCurve3dBSplineCurve3d(curveA, this._geometryB, false);
+        if (this._geometryB instanceof CurveChainWithDistanceIndex) {
+            this.dispatchCurveChainWithDistanceIndex(curveA, this.handleBSplineCurve3d.bind(this));
         }
-        else if (this._geometryB instanceof TransitionSpiral3d) {
-            this.dispatchCurveSpiral(curveA, this._geometryB, false);
+        else if (this._geometryB instanceof CurvePrimitive) {
+            this.dispatchCurveStrokedCurve(this._geometryB, curveA, true);
         }
         else if (this._geometryB instanceof CurveCollection) {
             this.dispatchCurveCollection(curveA, this.handleBSplineCurve3d.bind(this));
         }
-        else if (this._geometryB instanceof CurveChainWithDistanceIndex) {
-            this.dispatchCurveChainWithDistanceIndex(curveA, this.handleBSplineCurve3d.bind(this));
-        }
         return undefined;
     }
-    /**
-     * Process seeds for xy close approach between the curve and spiral.
-     * * Refine each result via Newton iteration. If it doesn't converge, remove it.
-     * @param seeds The initial seed results to refine.
-     * @param curveA The other curve primitive. May also be a transition spiral.
-     * @param spiralB The transition spiral.
-     * @param reversed whether `spiralB` data is in `detailA` of each recorded pair, and `curveA` data in `detailB`.
-     */
-    refineSpiralResultsByNewton(seeds, curveA, spiralB, reversed = false) {
-        const xyMatchingFunction = new CurveCurveCloseApproachXYRRtoRRD(curveA, spiralB);
-        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 spiral");
-            newtonSearcher.setUV(detailA.fraction, detailB.fraction); // use linestring fraction as spiral param; it generally yields a closer point than fractional length!
-            if (newtonSearcher.runIterations()) {
-                const fractionA = newtonSearcher.getU();
-                const fractionB = newtonSearcher.getV();
-                if (this.acceptFraction(fractionA) && this.acceptFraction(fractionB))
-                    this.testAndRecordPointPair(curveA, fractionA, undefined, spiralB, 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 a spiral.
-     * @param curveA curve to find its close approach with spiralB. May also be a transition spiral.
-     * @param spiralB transition spiral to find its close approach with curveA.
-     * @param reversed whether `spiralB` data will be recorded in `detailA` of each result, and `curveA` data in `detailB`.
-     */
-    dispatchCurveSpiral(curveA, spiralB, reversed) {
-        // explicit search for intersections (Newton converges too slowly on DirectSpiral3d tangent intersections)
-        const intersections = CurveCurve.intersectionXYPairs(curveA, false, spiralB, 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 (curveA instanceof TransitionSpiral3d)
-            cpA = this.strokeCurve(curveA);
-        const cpB = this.strokeCurve(spiralB);
-        const seeds = this.computeDiscreteCloseApproachResults(cpA, cpB, reversed);
-        this.refineSpiralResultsByNewton(seeds, curveA, spiralB, 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), spiralB, reversed);
-        }
-        this.testAndRecordEndPointApproaches(curveA, spiralB, reversed);
-    }
     /** 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 CurvePrimitive) {
-            this.dispatchCurveSpiral(this._geometryB, spiral, true);
+            this.dispatchCurveStrokedCurve(this._geometryB, spiral, true);
         }
         else if (this._geometryB instanceof CurveCollection) {
             this.dispatchCurveCollection(spiral, this.handleTransitionSpiral.bind(this));
@@ -819,19 +776,7 @@ export class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
     }
     /** 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;
     }
 }