@itwin/core-geometry 4.1.0-dev.77 → 4.1.0-dev.80

package/lib/esm/curve/CurveCurveIntersectXY.js

@@ -21,7 +21,7 @@ import { LineSegment3d } from "./LineSegment3d";
 import { LineString3d } from "./LineString3d";
 // cspell:word XYRR
 /**
- * * Private class for refining bezier-bezier intersections.
+ * Private class for refining bezier-bezier intersections.
  * * The inputs are assumed pre-transformed so that the target condition is to match x and y coordinates.
  * @internal
  */
@@ -52,11 +52,10 @@ export class CurveLocationDetailArrayPair {
     }
 }
 /**
+ * Handler class for XY intersections between _geometryB and another geometry.
+ * * **NOTE:** GeometryQuery input (_geometryB) should really be AnyCurve.
  * * 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 CurveCurveIntersectXY extends NullGeometryHandler {
@@ -65,15 +64,13 @@ class CurveCurveIntersectXY extends NullGeometryHandler {
     }
     /**
      * @param worldToLocal optional transform (possibly perspective) to project to xy plane for intersection.
-     * @param _geometryA first curve for intersection.  This is NOT saved.
-     * @param extendA flag to enable using extension of geometryA.
+     * @param extendA flag to enable using extension of the other geometry.
      * @param geometryB second curve for intersection.  Saved for reference by specific handler methods.
      * @param extendB flag for extension of geometryB.
      * @param tolerance optional distance tolerance for coincidence
      */
-    constructor(worldToLocal, _geometryA, extendA, geometryB, extendB, tolerance = Geometry.smallMetricDistance) {
+    constructor(worldToLocal, extendA, geometryB, extendB, tolerance = Geometry.smallMetricDistance) {
         super();
-        // this.geometryA = _geometryA;
         this._extendA = extendA;
         this._geometryB = geometryB;
         this._extendB = extendB;
@@ -88,7 +85,7 @@ class CurveCurveIntersectXY extends NullGeometryHandler {
         this.reinitialize();
     }
     /** Reset the geometry and flags, leaving all other parts unchanged (and preserving accumulated intersections) */
-    resetGeometry(_geometryA, extendA, geometryB, extendB) {
+    resetGeometry(extendA, geometryB, extendB) {
         this._extendA = extendA;
         this._geometryB = geometryB;
         this._extendB = extendB;
@@ -100,7 +97,8 @@ class CurveCurveIntersectXY extends NullGeometryHandler {
             return false;
         return true;
     }
-    /** Test the fraction by strict parameter, but allow toleranced distance test at ends.
+    /**
+     * Test the fraction by strict parameter, but allow toleranced distance test at ends.
      * @param tolerance optional distance tolerance to check proximity to start/end point
      */
     acceptFractionOnLine(extend0, fraction, extend1, pointA, pointB, tolerance = Geometry.smallMetricDistance) {
@@ -114,7 +112,6 @@ class CurveCurveIntersectXY extends NullGeometryHandler {
     /**
      * * 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;
@@ -125,15 +122,17 @@ class CurveCurveIntersectXY extends NullGeometryHandler {
     sameCurveAndFraction(cp, fraction, detail) {
         return cp === detail.curve && Geometry.isAlmostEqualNumber(fraction, detail.fraction);
     }
-    /** 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);
@@ -150,11 +149,13 @@ class CurveCurveIntersectXY 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;
             }
         }
@@ -176,9 +177,9 @@ class CurveCurveIntersectXY 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.
      */
@@ -189,15 +190,16 @@ class CurveCurveIntersectXY 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.
      */
     computeSegmentSegment3D(cpA, extendA0, pointA0, fractionA0, pointA1, fractionA1, extendA1, cpB, extendB0, pointB0, fractionB0, pointB1, fractionB1, extendB1, reversed) {
         const uv = CurveCurveIntersectXY._workVector2dA;
         // Problem: Normal practice is to do the (quick, simple) transverse intersection first
-        // But the transverse intersector notion of coincidence is based on the determinant ratios, which are hard to relate
-        //     to physical tolerance.
+        // But the transverse intersector notion of coincidence is based on the determinant ratios, which are hard
+        // to relate to physical tolerance.
         //  So do the overlap first.  This should do a quick exit in non-coincident case.
         const overlap = this._coincidentGeometryContext.coincidentSegmentRangeXY(pointA0, pointA1, pointB0, pointB1);
         if (overlap) {
@@ -231,8 +233,8 @@ class CurveCurveIntersectXY extends NullGeometryHandler {
         }
     }
     // 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, extendA0, pointA0, fractionA0, pointA1, fractionA1, extendA1, cpB, extendB0, pointB0, fractionB0, pointB1, fractionB1, extendB1, reversed) {
         if (this._worldToLocalAffine) {
@@ -274,7 +276,8 @@ class CurveCurveIntersectXY extends NullGeometryHandler {
                 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.lineSegment3dHXYClosestPointUnbounded(pointA0H, pointA1H, arcPoint);
-                if (lineFraction !== undefined && this.acceptFraction(extendA0, lineFraction, extendA1) && this.acceptFraction(extendB0, arcFraction, extendB1)) {
+                if (lineFraction !== undefined && this.acceptFraction(extendA0, lineFraction, extendA1) &&
+                    this.acceptFraction(extendB0, arcFraction, extendB1)) {
                     this.recordPointWithLocalFractions(lineFraction, cpA, fractionA0, fractionA1, arcFraction, arc, 0, 1, reversed);
                 }
             }
@@ -300,7 +303,8 @@ class CurveCurveIntersectXY extends NullGeometryHandler {
                 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);
-                if (lineFraction !== undefined && this.acceptFraction(extendA0, lineFraction, extendA1, lineFractionTol) && this.acceptFraction(extendB0, arcFraction, extendB1, arcFractionTol)) {
+                if (lineFraction !== undefined && this.acceptFraction(extendA0, lineFraction, extendA1, lineFractionTol)
+                    && this.acceptFraction(extendB0, arcFraction, extendB1, arcFractionTol)) {
                     this.recordPointWithLocalFractions(lineFraction, cpA, fractionA0, fractionA1, arcFraction, arc, 0, 1, reversed);
                 }
             }
@@ -366,10 +370,13 @@ class CurveCurveIntersectXY extends NullGeometryHandler {
             this.dispatchArcArcThisOrder(cpB, matrixB, extendB, cpA, matrixA, extendA, !reversed);
         // overlap handling .. perspective is not handled . . .
         if (!this._coincidentGeometryContext) {
+            // do nothing
         }
         else if (this._worldToLocalPerspective) {
+            // do nothing
         }
         else if (this._worldToLocalAffine) {
+            // do nothing
         }
         else {
             const pairs = this._coincidentGeometryContext.coincidentArcIntersectionXY(cpA, cpB, true);
@@ -440,7 +447,8 @@ class CurveCurveIntersectXY extends NullGeometryHandler {
                             const c = bcurvePoint4d.dotProductXYZW(axx, axy, axz, axw);
                             const s = bcurvePoint4d.dotProductXYZW(ayx, ayy, ayz, ayw);
                             const arcFraction = cpA.sweep.radiansToSignedPeriodicFraction(Math.atan2(s, c));
-                            if (this.acceptFraction(extendA, arcFraction, extendA) && this.acceptFraction(extendB, fractionB, extendB)) {
+                            if (this.acceptFraction(extendA, arcFraction, extendA) &&
+                                this.acceptFraction(extendB, fractionB, extendB)) {
                                 this.recordPointWithLocalFractions(arcFraction, cpA, 0, 1, fractionB, cpB, 0, 1, reversed);
                             }
                         }
@@ -449,9 +457,7 @@ class CurveCurveIntersectXY extends NullGeometryHandler {
             }
         }
     }
-    /** apply the transformation to bezier curves. optionally construct ranges.
-     *
-     */
+    /** Apply the transformation to bezier curves. optionally construct ranges. */
     transformBeziers(beziers) {
         if (this._worldToLocalAffine) {
             for (const bezier of beziers)
@@ -481,21 +487,20 @@ class CurveCurveIntersectXY extends NullGeometryHandler {
         if (!this._xyzwB)
             this._xyzwB = Point4d.create();
         /*
-    
-                  const roots = univariateBezierG.roots(0.0, true);
-                  if (roots) {
-                    for (const root of roots) {
-                      const fractionB = bezier.fractionToParentFraction(root);
-                      // The univariate bezier (which has been transformed by the view transform) evaluates into xyw space
-                      const bcurvePoint4d = bezier.fractionToPoint4d(root);
-                      const c = bcurvePoint4d.dotProductXYZW(axx, axy, axz, axw);
-                      const s = bcurvePoint4d.dotProductXYZW(ayx, ayy, ayz, ayw);
-                      const arcFraction = cpA.sweep.radiansToSignedPeriodicFraction(Math.atan2(s, c));
-                      if (this.acceptFraction(extendA, arcFraction, extendA) && this.acceptFraction(extendB, fractionB, extendB)) {
-                        this.recordPointWithLocalFractions(arcFraction, cpA, 0, 1,
-                          fractionB, cpB, 0, 1, reversed);
-                      }
-                    }
+        const roots = univariateBezierG.roots(0.0, true);
+        if (roots) {
+          for (const root of roots) {
+            const fractionB = bezier.fractionToParentFraction(root);
+            // The univariate bezier (which has been transformed by the view transform) evaluates into xyw space
+            const bcurvePoint4d = bezier.fractionToPoint4d(root);
+            const c = bcurvePoint4d.dotProductXYZW(axx, axy, axz, axw);
+            const s = bcurvePoint4d.dotProductXYZW(ayx, ayy, ayz, ayw);
+            const arcFraction = cpA.sweep.radiansToSignedPeriodicFraction(Math.atan2(s, c));
+            if (this.acceptFraction(extendA, arcFraction, extendA) && this.acceptFraction(extendB, fractionB, extendB)) {
+              this.recordPointWithLocalFractions(arcFraction, cpA, 0, 1,
+                fractionB, cpB, 0, 1, reversed);
+            }
+          }
         */
         bezierA.fractionToPoint4d(0.0, this._xyzwA0);
         let f0 = 0.0;
@@ -540,7 +545,8 @@ class CurveCurveIntersectXY extends NullGeometryHandler {
                             errors++;
                         if (errors > 0 && !xyzA1.isAlmostEqual(xyzB1))
                             errors++;
-                        if (this.acceptFraction(false, bcurveAFraction, false) && this.acceptFraction(false, bcurveBFraction, false)) {
+                        if (this.acceptFraction(false, bcurveAFraction, false) &&
+                            this.acceptFraction(false, bcurveBFraction, false)) {
                             this.recordPointWithLocalFractions(bcurveAFraction, bcurveA, 0, 1, bcurveBFraction, bcurveB, 0, 1, reversed);
                         }
                     }
@@ -579,7 +585,7 @@ class CurveCurveIntersectXY extends NullGeometryHandler {
     /**
      * Apply the projection transform (if any) to (xyz, w)
      * @param xyz xyz parts of input point.
-     * @param w   weight to use for homogeneous effects
+     * @param w weight to use for homogeneous effects
      */
     projectPoint(xyz, w = 1.0) {
         if (this._worldToLocalPerspective)
@@ -615,19 +621,22 @@ class CurveCurveIntersectXY extends NullGeometryHandler {
         // NOW .. we have a plane in world space.  Intersect it with the bspline:
         const intersections = [];
         bcurve.appendPlaneIntersectionPoints(planeCoffs, intersections);
-        // intersections has WORLD points with bspline fractions.   (The bspline fractions are all good 0..1 fractions within the spline.)
+        // intersections has WORLD points with bspline fractions.
+        // (the bspline fractions are all good 0..1 fractions within the spline).
         // accept those that are within the segment range.
         for (const detail of intersections) {
             const fractionB = detail.fraction;
             const curvePoint = detail.point;
             const curvePointH = this.projectPoint(curvePoint);
             const lineFraction = SmallSystem.lineSegment3dHXYClosestPointUnbounded(pointA0H, pointA1H, curvePointH);
-            if (lineFraction !== undefined && this.acceptFraction(extendA0, lineFraction, extendA1) && this.acceptFraction(extendB, fractionB, extendB)) {
+            if (lineFraction !== undefined &&
+                this.acceptFraction(extendA0, lineFraction, extendA1) &&
+                this.acceptFraction(extendB, fractionB, extendB)) {
                 this.recordPointWithLocalFractions(lineFraction, cpA, fractionA0, fractionA1, fractionB, bcurve, 0, 1, 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, extendA, curveB, extendB, reversed) {
         const numA = lsA.numPoints();
         if (numA > 1) {
@@ -667,7 +676,7 @@ class CurveCurveIntersectXY extends NullGeometryHandler {
         }
         return undefined;
     }
-    /** Detail computation for arcA intersecting lsB. */
+    /** Detail computation for arc intersecting linestring. */
     computeArcLineString(arcA, extendA, lsB, extendB, reversed) {
         const pointB0 = CurveCurveIntersectXY._workPointBB0;
         const pointB1 = CurveCurveIntersectXY._workPointBB1;
@@ -692,7 +701,7 @@ class CurveCurveIntersectXY extends NullGeometryHandler {
         transform.multiplyPoint3d(pointB0, this._workPointB0);
         transform.multiplyPoint3d(pointB1, this._workPointB1);
     }
-    /** 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;
@@ -708,7 +717,7 @@ class CurveCurveIntersectXY extends NullGeometryHandler {
             this.dispatchSegmentBsplineCurve(segmentA, this._extendA, segmentA.point0Ref, 0.0, segmentA.point1Ref, 1.0, this._extendA, this._geometryB, this._extendB, false);
         }
     }
-    /** 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;
@@ -753,7 +762,7 @@ class CurveCurveIntersectXY 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._extendB, this._geometryB.point0Ref, 0.0, this._geometryB.point1Ref, 1.0, this._extendB, arc0, this._extendA, this._extendA, true);
@@ -769,7 +778,7 @@ class CurveCurveIntersectXY 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, this._extendB, this._geometryB.point0Ref, 0.0, this._geometryB.point1Ref, 1.0, this._extendB, curve, this._extendA, true);
@@ -785,9 +794,11 @@ class CurveCurveIntersectXY 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,