@itwin/core-geometry 4.2.0-dev.16 → 4.2.0-dev.18

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

@@ -13,7 +13,7 @@ import { Point3d, Vector3d } from "../../geometry3d/Point3dVector3d";
 import { Range3d } from "../../geometry3d/Range";
 import { AnalyticRoots, SmallSystem } from "../../numerics/Polynomials";
 import { Arc3d } from "../Arc3d";
-import { CurveChain } from "../CurveCollection";
+import { CurveCollection } from "../CurveCollection";
 import { CurveIntervalRole, CurveLocationDetail, CurveLocationDetailPair } from "../CurveLocationDetail";
 import { LineSegment3d } from "../LineSegment3d";
 import { LineString3d } from "../LineString3d";
@@ -257,7 +257,7 @@ class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
             fractionB = 1;
         this._workPointB = pointB0.interpolate(fractionB, pointB1, this._workPointB);
         const distanceSquared = this._workPointB.distanceSquaredXY(pointA);
-        if (distanceSquared < Math.min(maxDistanceSquared, closestApproach.detailA.a)) {
+        if (distanceSquared <= Math.min(maxDistanceSquared, closestApproach.detailA.a)) {
             closestApproach.detailA.setFP(fractionA, pointA, undefined, distanceSquared);
             closestApproach.detailB.setFP(fractionB, this._workPointB, undefined, distanceSquared);
             updated = true;
@@ -300,23 +300,23 @@ class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
         closestApproach.detailA.a = 2 * maxDistanceSquared; // init to an approach that's too far away
         let reversed = false;
         const uu = Geometry.hypotenuseSquaredXY(ux, uy);
-        if (hab0 * hab0 < maxDistanceSquared * uu) { // test distance of b0 to u
+        if (hab0 * hab0 <= maxDistanceSquared * uu) { // test distance of b0 to u
             const fractionA = Geometry.dotProductXYXY(ux, uy, e00x, e00y) / uu;
             if (this.updatePointToSegmentDistance(0, b0, a0, a1, fractionA, maxDistanceSquared, closestApproach))
                 reversed = true;
         }
-        if (hab1 * hab1 < maxDistanceSquared * uu) { // test distance of b1 to u
+        if (hab1 * hab1 <= maxDistanceSquared * uu) { // test distance of b1 to u
             const fractionA = Geometry.dotProductXYXY(ux, uy, e01x, e01y) / uu;
             if (this.updatePointToSegmentDistance(1, b1, a0, a1, fractionA, maxDistanceSquared, closestApproach))
                 reversed = true;
         }
         const vv = Geometry.hypotenuseSquaredXY(vx, vy);
-        if (hba0 * hba0 < maxDistanceSquared * vv) { // test distance of a0 to v
+        if (hba0 * hba0 <= maxDistanceSquared * vv) { // test distance of a0 to v
             const fractionB = -Geometry.dotProductXYXY(vx, vy, e00x, e00y) / vv;
             if (this.updatePointToSegmentDistance(0, a0, b0, b1, fractionB, maxDistanceSquared, closestApproach))
                 reversed = false;
         }
-        if (hba1 * hba1 < maxDistanceSquared * vv) { // test distance of a1 to v
+        if (hba1 * hba1 <= maxDistanceSquared * vv) { // test distance of a1 to v
             const fractionB = -Geometry.dotProductXYXY(vx, vy, e10x, e10y) / vv;
             if (this.updatePointToSegmentDistance(1, a1, b0, b1, fractionB, maxDistanceSquared, closestApproach))
                 reversed = false;
@@ -394,10 +394,10 @@ class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
      * Low level dispatch of segment with arc.
      * Find close approaches within maxDistance between a line segments (pointA0, pointA1) and an arc.
      * To consider:
-     * 1) arc endpoints to segment endpoints or arc endpoints projection to the segment.
-     * 2) intersection between arc and segment.
+     * 1) intersection between arc and segment.
+     * 2) arc endpoints to segment endpoints or arc endpoints projection to the segment.
      * 3) line parallel to arc tangent.
-     * @param cpA the segment
+     * @param cpA curve A (line segment or line string)
      * @param pointA0 start point of the segment
      * @param fractionA0 fraction of the start of the segment
      * @param pointA1 end point of the segment
@@ -406,9 +406,7 @@ class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
      * @param reversed true to have order reversed in final structures
      */
     dispatchSegmentArc(cpA, pointA0, fractionA0, pointA1, fractionA1, arc, reversed) {
-        // 1) arc endpoints to segment endpoints or arc endpoints projection to the segment
-        this.testAndRecordFractionalPairApproach(cpA, 0, 1, true, arc, 0, 1, false, reversed);
-        // 2) intersection between arc and segment
+        // 1) intersection between arc and segment
         // Suppose:
         // Arc: X = C + cU + sV where c = cos(theta) and s = sin(theta)
         // Line: contains points A0 and A1
@@ -417,6 +415,7 @@ class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
         // solve for theta.
         // evaluate points.
         // project back to line.
+        let intersectionFound = false;
         const data = arc.toTransformedVectors();
         const pointA0Local = pointA0;
         const pointA1Local = pointA1;
@@ -435,8 +434,13 @@ class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
             // 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 (intersectionFound)
+            return;
+        // 2) endpoints to endpoints or endpoints projection to the other curve
+        this.testAndRecordFractionalPairApproach(cpA, fractionA0, fractionA1, true, arc, 0, 1, false, reversed);
         // 3) line parallel to arc tangent.
         // 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.
@@ -453,48 +457,37 @@ class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
             }
         }
     }
-    // Caller accesses data from two arcs, ensures circular, and orders with radiusA >= radiusB
+    /** Low level dispatch of circular arc with circular arc. radiusA must be larger than or equal to radiusB. */
     dispatchCircularCircularOrdered(cpA, radiusA, cpB, radiusB, reversed) {
         const c = cpA.center.distance(cpB.center);
         const e = this._maxDistanceToAccept !== undefined ? this._maxDistanceToAccept : Geometry.smallMetricDistance;
-        if (c > radiusA + radiusB + e) // widely separated
+        if (c > radiusA + radiusB + e) // distance between circles is more than max distance
             return;
-        // To consider:
-        // 1) endpoint to endpoint or projection
-        // 2) true intersection
-        // 3) line parallel to arc tangent.
+        // TODO: 1) intersection between arcs
+        // 2) endpoints to endpoints
         this.testAndRecordFractionalPairApproach(cpA, 0, 1, false, cpB, 0, 1, false, reversed);
+        // 3) line from one arc to another (perpendicular to arc tangents along center-center line)
         if (!Geometry.isSmallMetricDistance(c)) {
-            // ?? endpoint hits are recorded.  Maybe also need overlap?
             const vectorAB = Vector3d.createStartEnd(cpA.center, cpB.center);
             vectorAB.scaleInPlace(1.0 / c);
-            if (c - radiusA - radiusB > e) {
-                // no approaches possible
-            }
-            else {
-                for (const rA of [-radiusA, radiusA]) {
-                    for (const rB of [-radiusB, radiusB]) {
-                        const tangentDistance = c - rA + rB;
-                        if (tangentDistance < e) {
-                            const detailA = this.resolveDirectionToArcXYFraction(cpA, vectorAB, rA);
-                            if (detailA) {
-                                const detailB = this.resolveDirectionToArcXYFraction(cpB, vectorAB, rB);
-                                if (detailB) {
-                                    this.captureDetailPair(detailA, detailB, reversed);
-                                }
-                            }
+            for (const rA of [-radiusA, radiusA]) {
+                for (const rB of [-radiusB, radiusB]) {
+                    const tangentDistance = c - rA + rB;
+                    if (tangentDistance < e) {
+                        const detailA = this.resolveDirectionToArcXYFraction(cpA, vectorAB, rA);
+                        if (detailA) {
+                            const detailB = this.resolveDirectionToArcXYFraction(cpB, vectorAB, rB);
+                            if (detailB)
+                                this.captureDetailPair(detailA, detailB, reversed);
                         }
                     }
                 }
             }
         }
     }
-    /**
-     * Find the fractional point (if any) on an arc, known to be circular and displayed from the center in the
-     * direction of a scaled vector.
-     */
+    /** Find the fractional point (if any) on the circular `arc` in the direction of `radialVector`. */
     resolveDirectionToArcXYFraction(arc, radialVector, scale) {
-        // The scale ultimately only affects the direction --- easiest way to use it is two multiplies
+        // The scale ultimately only affects the direction --- easiest way to use it is two multiplies.
         const c = scale * arc.matrixRef.columnDotXYZ(0, radialVector.x, radialVector.y, 0);
         const s = scale * arc.matrixRef.columnDotXYZ(1, radialVector.x, radialVector.y, 0);
         const radians = Math.atan2(s, c);
@@ -503,10 +496,13 @@ class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
             return CurveLocationDetail.createCurveEvaluatedFraction(arc, fraction);
         return undefined;
     }
-    // Caller accesses data from two arcs.
-    // Selects the best conditioned arc (in xy parts) as "circle after inversion"
-    // Solves the arc-arc equations
+    /** Low level dispatch of arc with arc. Only circular arcs are supported. */
     dispatchArcArc(cpA, cpB, reversed) {
+        const rangeA = cpA.range();
+        const rangeB = cpB.range();
+        rangeA.expandInPlace(this._maxDistanceToAccept);
+        if (!rangeB.intersectsRangeXY(rangeA))
+            return;
         if (this._circularArcB) {
             const radiusB = this._circularRadiusB;
             const radiusA = cpA.circularRadiusXY();
@@ -519,17 +515,13 @@ class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
             }
         }
     }
-    // Caller accesses data from two arcs.
-    // Selects the best conditioned arc (in xy parts) as "circle after inversion"
-    // Solves the arc-arc equations
+    /** 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);
     }
-    // Caller accesses data from two arcs.
-    // Selects the best conditioned arc (in xy parts) as "circle after inversion"
-    // Solves the arc-arc equations
+    /** 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);
@@ -567,6 +559,11 @@ class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
     }
     /** Detail computation for arc approaching linestring. */
     computeArcLineString(arcA, lsB, reversed) {
+        const rangeA = arcA.range();
+        const rangeB = lsB.range();
+        rangeA.expandInPlace(this._maxDistanceToAccept);
+        if (!rangeB.intersectsRangeXY(rangeA))
+            return;
         const pointB0 = CurveCurveCloseApproachXY._workPointBB0;
         const pointB1 = CurveCurveCloseApproachXY._workPointBB1;
         const numB = lsB.numPoints();
@@ -584,10 +581,10 @@ class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
         }
         return undefined;
     }
-    /** Low level dispatch of curve chain.  */
-    dispatchCurveChain(geomA, geomAHandler) {
+    /** Low level dispatch of curve collection. */
+    dispatchCurveCollection(geomA, geomAHandler) {
         const geomB = this._geometryB; // save
-        if (!geomB || !(geomB instanceof CurveChain))
+        if (!geomB || !geomB.children || !(geomB instanceof CurveCollection))
             return;
         for (const child of geomB.children) {
             this.resetGeometry(child);
@@ -610,9 +607,10 @@ class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
         else if (this._geometryB instanceof BSplineCurve3d) {
             this.dispatchSegmentBsplineCurve(segmentA, this._geometryB, false);
         }
-        else if (this._geometryB instanceof CurveChain) {
-            this.dispatchCurveChain(segmentA, this.handleLineSegment3d.bind(this));
+        else if (this._geometryB instanceof CurveCollection) {
+            this.dispatchCurveCollection(segmentA, this.handleLineSegment3d.bind(this));
         }
+        return undefined;
     }
     /**
      * Set bits for comparison to range xy
@@ -620,6 +618,13 @@ class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
      * * bit 0x02 => x larger than range.high.x
      * * bit 0x04 => y smaller than range.low.y
      * * bit 0x08 => y larger than range.high.y
+     * * If we divide XY plane into 9 areas using the range, the function returns 0 for points
+     * inside the range. Below is other binary numbers returned by the function for all 9 areas:
+     *   1001 | 1000 | 1010
+     *   ------------------
+     *    1   |  0   |  10
+     *   ------------------
+     *   101  | 100  | 110
      * @param xy point to test
      * @param range range for comparison
      */
@@ -629,12 +634,14 @@ class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
             result = 0x01;
         else if (x > range.high.x)
             result = 0x02;
+        // note the OR operation
         if (y < range.low.y)
             result |= 0x04;
         else if (y > range.high.y)
             result |= 0x08;
         return result;
     }
+    /** Low level dispatch of line string with line string. */
     computeLineStringLineString(lsA, lsB, reversed) {
         const rangeA = lsA.range();
         const rangeB = lsB.range();
@@ -651,7 +658,6 @@ class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
         const numA = lsA.numPoints();
         const numB = lsB.numPoints();
         if (numA > 1 && numB > 1) {
-            lsA.pointAt(0, pointA0);
             const dfA = 1.0 / (numA - 1);
             const dfB = 1.0 / (numB - 1);
             let fA0 = 0.0;
@@ -661,6 +667,7 @@ class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
                 fA1 = ia * dfA;
                 fB0 = 0.0;
                 lsA.pointAt(ia, pointA1);
+                // rangeA1 is around line segment [A0,A1] expanded by max distance
                 rangeA1.setNull();
                 rangeA1.extendPoint(pointA0);
                 rangeA1.extendPoint(pointA1);
@@ -672,10 +679,10 @@ class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
                         lsB.pointAt(ib, pointB1);
                         bitB1 = this.classifyBitsPointRangeXY(pointB1.x, pointB1.y, rangeA1);
                         fB1 = ib * dfB;
-                        // Do NOT study the segment in detail if both bitB bits are on for any of the 4 planes . ..
-                        if ((bitB0 & bitB1) === 0) {
+                        // 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);
-                        }
                     }
                 }
             }
@@ -696,8 +703,8 @@ class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
         else if (this._geometryB instanceof BSplineCurve3d) {
             this.dispatchLineStringBSplineCurve(lsA, this._geometryB, false);
         }
-        else if (this._geometryB instanceof CurveChain) {
-            this.dispatchCurveChain(lsA, this.handleLineString3d.bind(this));
+        else if (this._geometryB instanceof CurveCollection) {
+            this.dispatchCurveCollection(lsA, this.handleLineString3d.bind(this));
         }
         return undefined;
     }
@@ -715,8 +722,8 @@ class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
         else if (this._geometryB instanceof BSplineCurve3d) {
             this.dispatchArcBsplineCurve3d(arc0, this._geometryB, false);
         }
-        else if (this._geometryB instanceof CurveChain) {
-            this.dispatchCurveChain(arc0, this.handleArc3d.bind(this));
+        else if (this._geometryB instanceof CurveCollection) {
+            this.dispatchCurveCollection(arc0, this.handleArc3d.bind(this));
         }
         return undefined;
     }
@@ -734,8 +741,8 @@ class CurveCurveCloseApproachXY extends RecurseToCurvesGeometryHandler {
         else if (this._geometryB instanceof BSplineCurve3dBase) {
             this.dispatchBSplineCurve3dBSplineCurve3d(curve, this._geometryB, false);
         }
-        else if (this._geometryB instanceof CurveChain) {
-            this.dispatchCurveChain(curve, this.handleBSplineCurve3d.bind(this));
+        else if (this._geometryB instanceof CurveCollection) {
+            this.dispatchCurveCollection(curve, this.handleBSplineCurve3d.bind(this));
         }
         return undefined;
     }