@itwin/core-geometry 4.1.0-dev.8 → 4.1.0-dev.81

package/lib/esm/curve/CurveCurveCloseApproachXY.js

@@ -18,32 +18,16 @@ import { LineSegment3d } from "./LineSegment3d";
 import { LineString3d } from "./LineString3d";
 // cspell:word XYRR
 /**
- * Set bits for comparison to range xy
- * * bit 0x01 => x smaller than range.low.x
- * * bit 0x02 => x larger than range.high.x
- * * bit 0x04 => x smaller than range.low.y
- * * bit 0x08 => x larger than range.high.y
- * @param xy point to test
- * @param range range for comparison
- */
-function classifyBitsPointRangeXY(x, y, range) {
-    let result = 0;
-    if (x < range.low.x)
-        result = 0x01;
-    else if (x > range.high.x)
-        result = 0x02;
-    if (y < range.low.y)
-        result |= 0x04;
-    else if (y > range.high.y)
-        result |= 0x08;
-    return result;
-}
-/**
+ * Handler class for XY close approach between _geometryB and another geometry.
+ * * Approach means the distance between _geometryB and another geometry.
+ * * **NOTE:** GeometryQuery input (_geometryB) should really be AnyCurve.
+ * * Closest approach is a measure of the proximity of one curve to another. It's the length of the shortest line
+ * segment perpendicular to both curves; if the curves intersect, the closest approach is zero. In the context of
+ * this class, z-coordinates are ignored, so the closest approach is as seen in the top view. If you have coplanar
+ * input curves, rotate them first into a plane parallel to the xy-plane, then afterward, you should rotate the
+ * results back as required.
  * * Instances are initialized and called from CurveCurve.
- * * Constructor is told two geometry items A and B
- *   * geometryB is saved for later reference
- *   * type-specific handler methods will "see" geometry A repeatedly.
- *   * Hence geometryA is NOT saved by the constructor.
+ * * geometryB is saved for later reference.
  * @internal
  */
 class CurveCurveCloseApproachXY extends NullGeometryHandler {
@@ -59,36 +43,38 @@ class CurveCurveCloseApproachXY extends NullGeometryHandler {
             }
         }
     }
-    // private _coincidentGeometryContext: CoincidentGeometryQuery;
     reinitialize() {
         this._results = [];
     }
     /**
-     * @param _geometryA first curve for intersection.  This is NOT saved.
-     * @param geometryB second curve for intersection.  Saved for reference by specific handler methods.
+     * Constructor.
+     * @param geometryB second curve for intersection. Saved for reference by specific handler methods.
      */
-    constructor(_geometryA, geometryB) {
+    constructor(geometryB) {
         super();
-        // this.geometryA = _geometryA;
         this.setGeometryB(geometryB);
         this._maxDistanceSquared = Geometry.smallMetricDistanceSquared;
-        // this._coincidentGeometryContext = CoincidentGeometryQuery.create();
         this.reinitialize();
     }
-    /** Access the (possibly undefined) max distance to accept. */
+    /** Set the (possibly undefined) max distance to accept. */
     set maxDistanceToAccept(value) {
         this._maxDistanceToAccept = value;
         if (this._maxDistanceToAccept !== undefined && this._maxDistanceToAccept > 0)
             this._maxDistanceSquared = this._maxDistanceToAccept * this._maxDistanceToAccept;
     }
-    /** Set the (possibly undefined) max distance to accept. */
-    get maxDistanceToAccept() { return this._maxDistanceToAccept; }
+    /** Access the (possibly undefined) max distance to accept. */
+    get maxDistanceToAccept() {
+        return this._maxDistanceToAccept;
+    }
     /** Ask if the maxDistanceToAccept value is defined and positive */
-    get isMaxDistanceSet() { return this._maxDistanceToAccept !== undefined && this._maxDistanceToAccept > 0; }
+    get isMaxDistanceSet() {
+        return this._maxDistanceToAccept !== undefined && this._maxDistanceToAccept > 0;
+    }
     /** Reset the geometry and flags, leaving all other parts unchanged (and preserving accumulated intersections) */
-    resetGeometry(_geometryA, geometryB) {
+    resetGeometry(geometryB) {
         this.setGeometryB(geometryB);
     }
+    /** @returns whether the `fraction` is in [0,1] within tolerance */
     acceptFraction(fraction, fractionTol = 1.0e-12) {
         if (fraction < -fractionTol)
             return false;
@@ -97,9 +83,8 @@ class CurveCurveCloseApproachXY extends NullGeometryHandler {
         return true;
     }
     /**
-     * * Return the results structure for the intersection calculation, structured as an array of CurveLocationDetailPair
+     * 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;
@@ -107,6 +92,7 @@ class CurveCurveCloseApproachXY extends NullGeometryHandler {
             this.reinitialize();
         return result;
     }
+    /** Returns `true` if `detail` has same curve and fraction. */
     sameCurveAndFraction(cp, fraction, detail) {
         return cp === detail.curve && Geometry.isAlmostEqualNumber(fraction, detail.fraction);
     }
@@ -121,15 +107,17 @@ class CurveCurveCloseApproachXY extends NullGeometryHandler {
             this._results.push(pair);
         }
     }
-    /** compute intersection of two line segments.
-     * filter by extension rules.
-     * record with fraction mapping.
+    /**
+     * Compute intersection of two line segments.
+     * Filter by extension rules.
+     * Record with fraction mapping.
      */
     recordPointWithLocalFractions(localFractionA, cpA, fractionA0, fractionA1, localFractionB, // Computed intersection fraction
     cpB, fractionB0, fractionB1, reversed, intervalDetails) {
         let globalFractionA, globalFractionB;
         let globalFractionA1, globalFractionB1;
-        const isInterval = intervalDetails !== undefined && intervalDetails.detailA.hasFraction1 && intervalDetails.detailB.hasFraction1;
+        const isInterval = (intervalDetails !== undefined) &&
+            intervalDetails.detailA.hasFraction1 && intervalDetails.detailB.hasFraction1;
         if (isInterval) {
             globalFractionA = Geometry.interpolate(fractionA0, intervalDetails.detailA.fraction, fractionA1);
             globalFractionB = Geometry.interpolate(fractionB0, intervalDetails.detailB.fraction, fractionB1);
@@ -146,11 +134,13 @@ class CurveCurveCloseApproachXY extends NullGeometryHandler {
             const oldDetailA = this._results[numPrevious - 1].detailA;
             const oldDetailB = this._results[numPrevious - 1].detailB;
             if (reversed) {
-                if (this.sameCurveAndFraction(cpA, globalFractionA, oldDetailB) && this.sameCurveAndFraction(cpB, globalFractionB, oldDetailA))
+                if (this.sameCurveAndFraction(cpA, globalFractionA, oldDetailB) &&
+                    this.sameCurveAndFraction(cpB, globalFractionB, oldDetailA))
                     return;
             }
             else {
-                if (this.sameCurveAndFraction(cpA, globalFractionA, oldDetailA) && this.sameCurveAndFraction(cpB, globalFractionB, oldDetailB))
+                if (this.sameCurveAndFraction(cpA, globalFractionA, oldDetailA) &&
+                    this.sameCurveAndFraction(cpB, globalFractionB, oldDetailB))
                     return;
             }
         }
@@ -172,8 +162,8 @@ class CurveCurveCloseApproachXY extends NullGeometryHandler {
         }
     }
     /**
-     * capture a close approach pair that has point and local fraction but not curve.
-     * record with fraction mapping.
+     * Capture a close approach pair that has point and local fraction but not curve.
+     * Record with fraction mapping.
      */
     capturePairWithLocalFractions(pair, cpA, fractionA0, fractionA1, cpB, fractionB0, fractionB1, reversed) {
         const globalFractionA = Geometry.interpolate(fractionA0, pair.detailA.fraction, fractionA1);
@@ -184,11 +174,13 @@ class CurveCurveCloseApproachXY extends NullGeometryHandler {
             const oldDetailA = this._results[numPrevious - 1].detailA;
             const oldDetailB = this._results[numPrevious - 1].detailB;
             if (reversed) {
-                if (this.sameCurveAndFraction(cpA, globalFractionA, oldDetailB) && this.sameCurveAndFraction(cpB, globalFractionB, oldDetailA))
+                if (this.sameCurveAndFraction(cpA, globalFractionA, oldDetailB) &&
+                    this.sameCurveAndFraction(cpB, globalFractionB, oldDetailA))
                     return;
             }
             else {
-                if (this.sameCurveAndFraction(cpA, globalFractionA, oldDetailA) && this.sameCurveAndFraction(cpB, globalFractionB, oldDetailB))
+                if (this.sameCurveAndFraction(cpA, globalFractionA, oldDetailA) &&
+                    this.sameCurveAndFraction(cpB, globalFractionB, oldDetailB))
                     return;
             }
         }
@@ -203,9 +195,9 @@ class CurveCurveCloseApproachXY extends NullGeometryHandler {
         }
     }
     /**
-     * emit recordPoint for multiple pairs (on full curve!)
-     * @param cpA first curve primitive.   (possibly different from curve in detailA, but fraction compatible)
-     * @param cpB second curve primitive.   (possibly different from curve in detailA, but fraction compatible)
+     * Emit recordPoint for multiple pairs (on full curve!)
+     * @param cpA first curve primitive (possibly different from curve in detailA, but fraction compatible)
+     * @param cpB second curve primitive (possibly different from curve in detailA, but fraction compatible)
      * @param pairs array of pairs
      * @param reversed true to have order reversed in final structures.
      */
@@ -217,7 +209,7 @@ class CurveCurveCloseApproachXY extends NullGeometryHandler {
         }
     }
     /**
-     * record fully assembled (but possibly reversed) detail pair.
+     * Record fully assembled (but possibly reversed) detail pair.
      * @param detailA first detail
      * @param detailB second detail
      * @param reversed true to have order reversed in final structures.
@@ -232,44 +224,35 @@ class CurveCurveCloseApproachXY extends NullGeometryHandler {
             }
         }
     }
-    /**
-     *
-     * @param fractionA
-     * @param pointA
-     * @param pointB0
-     * @param pointB1
-     * @param fractionB
-     * @param minDistanceSquared
-     * @param closestApproach
-     */
     static updatePointToSegmentDistance(fractionA, pointA, pointB0, pointB1, fractionB, minDistanceSquared, closestApproach) {
         if (fractionB < 0)
             fractionB = 0;
         else if (fractionB > 1)
             fractionB = 1;
-        this._workPointB0 = pointB0.interpolate(fractionB, pointB1, this._workPointB0);
-        const distanceSquared = this._workPointB0.distanceSquaredXY(pointA);
+        this._workPointB = pointB0.interpolate(fractionB, pointB1, this._workPointB);
+        const distanceSquared = this._workPointB.distanceSquaredXY(pointA);
         if (distanceSquared < minDistanceSquared) {
             if (closestApproach === undefined || distanceSquared < closestApproach.detailA.a) {
                 if (closestApproach === undefined)
                     closestApproach = CurveLocationDetailPair.createCapture(CurveLocationDetail.create(), CurveLocationDetail.create());
                 closestApproach.detailA.setFP(fractionA, pointA);
                 closestApproach.detailA.a = distanceSquared;
-                closestApproach.detailB.setFP(fractionB, this._workPointB0);
+                closestApproach.detailB.setFP(fractionB, this._workPointB);
                 closestApproach.detailA.a = distanceSquared;
             }
         }
         return closestApproach;
     }
     /**
-     * Return fractions of close approach within minDistance between two line segments( a0,a1) and (b0, b1)
-     * * minDistance is assumed positive
+     * Return fractions of close approach within minDistance between two line segments (a0,a1) and (b0, b1).
+     * * minDistanceSquared is assumed positive.
      * Return the fractional (not xy) coordinates in result.x, result.y
      * @param a0 start point of line a
      * @param a1  end point of line a
      * @param b0  start point of line b
      * @param b1 end point of line b
-     * @param result point to receive fractional coordinates of intersection.   result.x is fraction on line a. result.y is fraction on line b.
+     * @param result point to receive fractional coordinates of intersection. result.x is fraction on line a.
+     * result.y is fraction on line b.
      */
     static segmentSegmentBoundedApproach(a0, a1, b0, b1, minDistanceSquared) {
         const ux = a1.x - a0.x;
@@ -307,16 +290,6 @@ class CurveCurveCloseApproachXY extends NullGeometryHandler {
             closestApproach = this.updatePointToSegmentDistance(1, a1, b0, b1, -Geometry.dotProductXYXY(vx, vy, e10x, e10y) / vv, minDistanceSquared, closestApproach);
         return closestApproach;
     }
-    /**
-     * Return fractions of close approach within minDistance between two line segments( a0,a1) and (b0, b1)
-     * * minDistance is assumed positive
-     * Return the fractional (not xy) coordinates in result.x, result.y
-     * @param a0 start point of line a
-     * @param a1  end point of line a
-     * @param b0  start point of line b
-     * @param b1 end point of line b
-     * @param result point to receive fractional coordinates of intersection.   result.x is fraction on line a. result.y is fraction on line b.
-     */
     testAndRecordFractionalPairApproach(cpA, fA0, fA1, testProjectionOnA, cpB, fB0, fB1, testProjectionOnB, reversed) {
         const pointA0 = cpA.fractionToPoint(fA0);
         const pointA1 = cpA.fractionToPoint(fA1);
@@ -345,9 +318,10 @@ class CurveCurveCloseApproachXY extends NullGeometryHandler {
             }
         }
     }
-    /** compute intersection of two line segments.
-     * filter by extension rules.
-     * record with fraction mapping.
+    /**
+     * Compute intersection of two line segments.
+     * Filter by extension rules.
+     * 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) {
@@ -356,15 +330,15 @@ class CurveCurveCloseApproachXY extends NullGeometryHandler {
             this.capturePairWithLocalFractions(approach, cpA, fractionA0, fractionA1, cpB, fractionB0, fractionB1, reversed);
     }
     // Caller accesses data from a line segment and passes to here.
-    // (The line segment in question might be (a) a full line segment or (b) a fragment within a linestring.  The fraction and extend parameters
-    // allow all combinations to be passed in)
+    // (The line segment in question might be (a) a full line segment or (b) a fragment within a linestring.
+    // The fraction and extend parameters allow all combinations to be passed in)
     // This method applies transform.
     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);
     }
     // Caller accesses data from a linestring or segment and passes it here.
-    // (The line segment in question might be (a) a full line segment or (b) a fragment within a linestring.  The fraction and extend parameters
-    // allow all combinations to be passed in)
+    // (The line segment in question might be (a) a full line segment or (b) a fragment within a linestring.
+    // The fraction and extend parameters allow all combinations to be passed in)
     dispatchSegmentArc(cpA, pointA0, fractionA0, pointA1, fractionA1, arc, reversed) {
         // To consider:
         // 1) endpoint to endpoint or projection
@@ -414,16 +388,14 @@ class CurveCurveCloseApproachXY extends NullGeometryHandler {
     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) // widely separated
             return;
         // To consider:
         // 1) endpoint to endpoint or projection
         // 2) true intersection
         // 3) line parallel to arc tangent.
         this.testAndRecordFractionalPairApproach(cpA, 0, 1, false, cpB, 0, 1, false, reversed);
-        if (Geometry.isSmallMetricDistance(c)) {
-        }
-        else {
+        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);
@@ -448,8 +420,9 @@ class CurveCurveCloseApproachXY extends NullGeometryHandler {
             }
         }
     }
-    /** 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 an arc, known to be circular and displayed from the center in the
+     * direction of a scaled vector.
      */
     resolveDirectionToArcXYFraction(arc, radialVector, scale) {
         // The scale ultimately only affects the direction --- easiest way to use it is two multiplies
@@ -476,7 +449,6 @@ class CurveCurveCloseApproachXY extends NullGeometryHandler {
                 return;
             }
         }
-        // Fall through for
     }
     // Caller accesses data from two arcs.
     // Selects the best conditioned arc (in xy parts) as "circle after inversion"
@@ -496,13 +468,13 @@ class CurveCurveCloseApproachXY extends NullGeometryHandler {
         bcurveB.emitStrokes(lsB);
         this.computeLineStringLineString(lsA, lsB, reversed);
     }
-    /** low level dispatch of linestring with (beziers of) a bspline curve */
+    /** 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 linestring with (beziers of) a bspline curve */
+    /** Low level dispatch of segment with (beziers of) a bspline curve */
     dispatchSegmentBsplineCurve(lsA, curveB, reversed) {
         const lsB = LineString3d.create();
         curveB.emitStrokes(lsB);
@@ -561,7 +533,7 @@ class CurveCurveCloseApproachXY extends NullGeometryHandler {
         this.testAndRecordFractionalPairApproach(lsA, 0, 1, true, lsB, 0, 1, false, reversed);
         return undefined;
     }
-    /** Detail computation for arcA intersecting lsB. */
+    /** Detail computation for arc approaching linestring. */
     computeArcLineString(arcA, lsB, reversed) {
         const pointB0 = CurveCurveCloseApproachXY._workPointBB0;
         const pointB1 = CurveCurveCloseApproachXY._workPointBB1;
@@ -580,8 +552,7 @@ class CurveCurveCloseApproachXY extends NullGeometryHandler {
         }
         return undefined;
     }
-    // private static _workPointB1 = Point3d.create();
-    /** double dispatch handler for strongly typed segment.. */
+    /** Double dispatch handler for strongly typed segment. */
     handleLineSegment3d(segmentA) {
         if (this._geometryB instanceof LineSegment3d) {
             const segmentB = this._geometryB;
@@ -597,6 +568,27 @@ class CurveCurveCloseApproachXY extends NullGeometryHandler {
             this.dispatchSegmentBsplineCurve(segmentA, this._geometryB, false);
         }
     }
+    /**
+     * Set bits for comparison to range xy
+     * * bit 0x01 => x smaller than range.low.x
+     * * bit 0x02 => x larger than range.high.x
+     * * bit 0x04 => y smaller than range.low.y
+     * * bit 0x08 => y larger than range.high.y
+     * @param xy point to test
+     * @param range range for comparison
+     */
+    classifyBitsPointRangeXY(x, y, range) {
+        let result = 0;
+        if (x < range.low.x)
+            result = 0x01;
+        else if (x > range.high.x)
+            result = 0x02;
+        if (y < range.low.y)
+            result |= 0x04;
+        else if (y > range.high.y)
+            result |= 0x08;
+        return result;
+    }
     computeLineStringLineString(lsA, lsB, reversed) {
         const rangeA = lsA.range();
         const rangeB = lsB.range();
@@ -617,9 +609,7 @@ class CurveCurveCloseApproachXY extends NullGeometryHandler {
             const dfA = 1.0 / (numA - 1);
             const dfB = 1.0 / (numB - 1);
             let fA0 = 0.0;
-            let fB0;
-            let fA1;
-            let fB1;
+            let fA1, fB0, fB1;
             lsA.pointAt(0, pointA0);
             for (let ia = 1; ia < numA; ia++, pointA0.setFrom(pointA1), fA0 = fA1) {
                 fA1 = ia * dfA;
@@ -631,10 +621,10 @@ class CurveCurveCloseApproachXY extends NullGeometryHandler {
                 rangeA1.expandInPlace(this._maxDistanceToAccept);
                 if (rangeA1.intersectsRangeXY(rangeB)) {
                     lsB.pointAt(0, pointB0);
-                    bitB0 = classifyBitsPointRangeXY(pointB0.x, pointB0.y, rangeA1);
+                    bitB0 = this.classifyBitsPointRangeXY(pointB0.x, pointB0.y, rangeA1);
                     for (let ib = 1; ib < numB; ib++, pointB0.setFrom(pointB1), fB0 = fB1, bitB0 = bitB1) {
                         lsB.pointAt(ib, pointB1);
-                        bitB1 = classifyBitsPointRangeXY(pointB1.x, pointB1.y, rangeA1);
+                        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) {
@@ -645,7 +635,7 @@ class CurveCurveCloseApproachXY extends NullGeometryHandler {
             }
         }
     }
-    /** double dispatch handler for strongly typed linestring.. */
+    /** Double dispatch handler for strongly typed linestring. */
     handleLineString3d(lsA) {
         if (this._geometryB instanceof LineString3d) {
             const lsB = this._geometryB;
@@ -662,7 +652,7 @@ class CurveCurveCloseApproachXY extends NullGeometryHandler {
         }
         return undefined;
     }
-    /** double dispatch handler for strongly typed arc .. */
+    /** Double dispatch handler for strongly typed arc. */
     handleArc3d(arc0) {
         if (this._geometryB instanceof LineSegment3d) {
             this.dispatchSegmentArc(this._geometryB, this._geometryB.point0Ref, 0.0, this._geometryB.point1Ref, 1.0, arc0, true);
@@ -678,7 +668,7 @@ class CurveCurveCloseApproachXY extends NullGeometryHandler {
         }
         return undefined;
     }
-    /** double dispatch handler for strongly typed bspline curve .. */
+    /** Double dispatch handler for strongly typed bspline curve. */
     handleBSplineCurve3d(curve) {
         if (this._geometryB instanceof LineSegment3d) {
             this.dispatchSegmentBsplineCurve(this._geometryB, curve, true);
@@ -694,9 +684,11 @@ class CurveCurveCloseApproachXY extends NullGeometryHandler {
         }
         return undefined;
     }
-    /** double dispatch handler for strongly typed homogeneous bspline curve .. */
+    /** 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
+        /*
+        //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,
@@ -716,6 +708,6 @@ CurveCurveCloseApproachXY._workPointBB0 = Point3d.create();
 CurveCurveCloseApproachXY._workPointBB1 = Point3d.create();
 CurveCurveCloseApproachXY._workPointBB2 = Point3d.create();
 CurveCurveCloseApproachXY._workVectorA = Vector3d.create();
-CurveCurveCloseApproachXY._workPointB0 = Point3d.create();
+CurveCurveCloseApproachXY._workPointB = Point3d.create();
 export { CurveCurveCloseApproachXY };
 //# sourceMappingURL=CurveCurveCloseApproachXY.js.map