@itwin/core-geometry 5.1.0-dev.4 → 5.1.0-dev.41

package/lib/cjs/curve/internalContexts/CurveCurveIntersectXY.js

@@ -15,7 +15,6 @@ const CoincidentGeometryOps_1 = require("../../geometry3d/CoincidentGeometryOps"
 const GeometryHandler_1 = require("../../geometry3d/GeometryHandler");
 const GrowableFloat64Array_1 = require("../../geometry3d/GrowableFloat64Array");
 const Matrix3d_1 = require("../../geometry3d/Matrix3d");
-const Point2dVector2d_1 = require("../../geometry3d/Point2dVector2d");
 const Point3dVector3d_1 = require("../../geometry3d/Point3dVector3d");
 const Point4d_1 = require("../../geometry4d/Point4d");
 const BezierPolynomials_1 = require("../../numerics/BezierPolynomials");
@@ -47,7 +46,6 @@ class CurveCurveIntersectXY extends GeometryHandler_1.RecurseToCurvesGeometryHan
     _worldToLocalPerspective;
     _worldToLocalAffine;
     _coincidentGeometryContext;
-    static _workVector2dA = Point2dVector2d_1.Vector2d.create();
     static _workPointA0H = Point4d_1.Point4d.create();
     static _workPointA1H = Point4d_1.Point4d.create();
     static _workPointB0H = Point4d_1.Point4d.create();
@@ -199,21 +197,25 @@ class CurveCurveIntersectXY extends GeometryHandler_1.RecurseToCurvesGeometryHan
     }
     /** 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.
-        //  So do the overlap first.  This should do a quick exit in non-coincident case.
-        const overlap = this._coincidentGeometryContext.coincidentSegmentRangeXY(pointA0, pointA1, pointB0, pointB1, false);
-        if (overlap) { // the lines are coincident
-            if (this._coincidentGeometryContext.clampCoincidentOverlapToSegmentBounds(overlap, pointA0, pointA1, pointB0, pointB1, extendA0, extendA1, extendB0, extendB1)) {
+        const aDir = { x: pointA1.x - pointA0.x, y: pointA1.y - pointA0.y };
+        const bDir = { x: pointB1.x - pointB0.x, y: pointB1.y - pointB0.y };
+        const tol = this._coincidentGeometryContext.tolerance;
+        const fractions = SmallSystem_1.SmallSystem.lineSegmentXYUVIntersectionUnbounded(pointA0, aDir, pointB0, bDir, tol);
+        if (!fractions)
+            return;
+        if (fractions.f1) { // the lines are coincident
+            const detailA = CurveLocationDetail_1.CurveLocationDetail.createCurveFractionPoint(undefined, fractions.f0.x, pointA0.interpolate(fractions.f0.x, pointA1));
+            detailA.captureFraction1Point1(fractions.f1.x, pointA0.interpolate(fractions.f1.x, pointA1));
+            const detailB = CurveLocationDetail_1.CurveLocationDetail.createCurveFractionPoint(undefined, fractions.f0.y, pointB0.interpolate(fractions.f0.y, pointB1));
+            detailB.captureFraction1Point1(fractions.f1.y, pointB0.interpolate(fractions.f1.y, pointB1));
+            const overlap = CurveLocationDetail_1.CurveLocationDetailPair.createCapture(detailA, detailB);
+            if (this._coincidentGeometryContext.clampCoincidentOverlapToSegmentBounds(overlap, pointA0, pointA1, pointB0, pointB1, extendA0, extendA1, extendB0, extendB1))
                 this.recordPointWithLocalFractions(overlap.detailA.fraction, cpA, fractionA0, fractionA1, overlap.detailB.fraction, cpB, fractionB0, fractionB1, reversed, overlap);
-            }
         }
-        else if (SmallSystem_1.SmallSystem.lineSegment3dXYTransverseIntersectionUnbounded(pointA0, pointA1, pointB0, pointB1, uv)) {
-            if (this.acceptFractionOnLine(extendA0, uv.x, extendA1, pointA0, pointA1, this._coincidentGeometryContext.tolerance) &&
-                this.acceptFractionOnLine(extendB0, uv.y, extendB1, pointB0, pointB1, this._coincidentGeometryContext.tolerance)) {
-                this.recordPointWithLocalFractions(uv.x, cpA, fractionA0, fractionA1, uv.y, cpB, fractionB0, fractionB1, reversed);
+        else { // the lines have a transverse intersection
+            if (this.acceptFractionOnLine(extendA0, fractions.f0.x, extendA1, pointA0, pointA1, tol)) {
+                if (this.acceptFractionOnLine(extendB0, fractions.f0.y, extendB1, pointB0, pointB1, tol))
+                    this.recordPointWithLocalFractions(fractions.f0.x, cpA, fractionA0, fractionA1, fractions.f0.y, cpB, fractionB0, fractionB1, reversed);
             }
         }
     }
@@ -261,6 +263,8 @@ class CurveCurveIntersectXY extends GeometryHandler_1.RecurseToCurvesGeometryHan
     // 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, extendA0, pointA0, fractionA0, pointA1, fractionA1, extendA1, arc, extendB0, extendB1, reversed) {
+        const tol2 = this._coincidentGeometryContext.tolerance * this._coincidentGeometryContext.tolerance;
+        let dist2;
         // Arc: X = C + cU + sV
         // Line:  contains points A0,A1
         // Arc point colinear with line if det (A0, A1, X) = 0
@@ -271,6 +275,10 @@ class CurveCurveIntersectXY extends GeometryHandler_1.RecurseToCurvesGeometryHan
         // project back to line.
         if (this._worldToLocalPerspective) {
             const data = arc.toTransformedPoint4d(this._worldToLocalPerspective);
+            const radians0 = data.sweep.fractionToRadians(0);
+            const pointB0H = data.center.plus2Scaled(data.vector0, Math.cos(radians0), data.vector90, Math.sin(radians0));
+            const radians1 = data.sweep.fractionToRadians(1);
+            const pointB1H = data.center.plus2Scaled(data.vector0, Math.cos(radians1), data.vector90, Math.sin(radians1));
             const pointA0H = this._worldToLocalPerspective.multiplyPoint3d(pointA0, 1);
             const pointA1H = this._worldToLocalPerspective.multiplyPoint3d(pointA1, 1);
             const alpha = Geometry_1.Geometry.tripleProductPoint4dXYW(pointA0H, pointA1H, data.center);
@@ -280,19 +288,31 @@ class CurveCurveIntersectXY extends GeometryHandler_1.RecurseToCurvesGeometryHan
             const sines = new GrowableFloat64Array_1.GrowableFloat64Array(2);
             const radians = new GrowableFloat64Array_1.GrowableFloat64Array(2);
             const numRoots = Polynomials_1.AnalyticRoots.appendImplicitLineUnitCircleIntersections(alpha, beta, gamma, cosines, sines, radians);
+            if (numRoots <= 0)
+                return;
             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.radiansToSignedFraction(radians.atUncheckedIndex(i), extendB0);
+                let arcFraction = data.sweep.radiansToSignedFraction(radians.atUncheckedIndex(i), extendB0);
                 const lineFraction = SmallSystem_1.SmallSystem.lineSegment3dHXYClosestPointUnbounded(pointA0H, pointA1H, arcPoint);
-                if (lineFraction !== undefined &&
-                    this.acceptFraction(extendA0, lineFraction, extendA1) &&
-                    this.acceptFraction(extendB0, arcFraction, extendB1)) {
-                    this.recordPointWithLocalFractions(lineFraction, cpA, fractionA0, fractionA1, arcFraction, arc, 0, 1, reversed);
+                if (lineFraction !== undefined) {
+                    if (this.acceptFraction(extendA0, lineFraction, extendA1) && this.acceptFraction(extendB0, arcFraction, extendB1)) {
+                        this.recordPointWithLocalFractions(lineFraction, cpA, fractionA0, fractionA1, arcFraction, arc, 0, 1, reversed);
+                    }
+                    else { // check for endpoint intersections beyond parametric tolerance but within point tolerance
+                        const pointAH = lineFraction < 0.5 ? pointA0H : pointA1H;
+                        const pointBH = (arcFraction = data.sweep.fractionToSignedPeriodicFraction(arcFraction)) < 0.5 ? pointB0H : pointB1H;
+                        if ((dist2 = pointAH.realDistanceSquaredXY(pointBH)) !== undefined && Geometry_1.Geometry.isDistanceWithinTol(dist2, tol2))
+                            this.recordPointWithLocalFractions(lineFraction < 0.5 ? 0 : 1, cpA, fractionA0, fractionA1, arcFraction < 0.5 ? 0 : 1, arc, 0, 1, reversed);
+                    }
                 }
             }
         }
         else {
             const data = arc.toTransformedVectors(this._worldToLocalAffine);
+            const radians0 = data.sweep.fractionToRadians(0);
+            const pointB0Local = data.center.plus2Scaled(data.vector0, Math.cos(radians0), data.vector90, Math.sin(radians0));
+            const radians1 = data.sweep.fractionToRadians(1);
+            const pointB1Local = data.center.plus2Scaled(data.vector0, Math.cos(radians1), data.vector90, Math.sin(radians1));
             let pointA0Local = pointA0;
             let pointA1Local = pointA1;
             if (this._worldToLocalAffine) {
@@ -306,16 +326,22 @@ class CurveCurveIntersectXY extends GeometryHandler_1.RecurseToCurvesGeometryHan
             const sines = new GrowableFloat64Array_1.GrowableFloat64Array(2);
             const radians = new GrowableFloat64Array_1.GrowableFloat64Array(2);
             const numRoots = Polynomials_1.AnalyticRoots.appendImplicitLineUnitCircleIntersections(alpha, beta, gamma, cosines, sines, radians);
-            const lineFractionTol = 1.0e-10; // TODO: why are we loosening tolerances here?
-            const arcFractionTol = 1.0e-7;
+            if (numRoots <= 0)
+                return;
             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.radiansToSignedFraction(radians.atUncheckedIndex(i), extendB0);
+                let arcFraction = data.sweep.radiansToSignedFraction(radians.atUncheckedIndex(i), extendB0);
                 const lineFraction = SmallSystem_1.SmallSystem.lineSegment3dXYClosestPointUnbounded(pointA0Local, pointA1Local, arcPoint);
-                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);
+                if (lineFraction !== undefined) {
+                    if (this.acceptFraction(extendA0, lineFraction, extendA1) && this.acceptFraction(extendB0, arcFraction, extendB1)) {
+                        this.recordPointWithLocalFractions(lineFraction, cpA, fractionA0, fractionA1, arcFraction, arc, 0, 1, reversed);
+                    }
+                    else { // check for endpoint intersections beyond parametric tolerance but within point tolerance
+                        const pointALocal = lineFraction < 0.5 ? pointA0Local : pointA1Local;
+                        const pointBLocal = (arcFraction = data.sweep.fractionToSignedPeriodicFraction(arcFraction)) < 0.5 ? pointB0Local : pointB1Local;
+                        if ((dist2 = pointALocal.distanceSquaredXY(pointBLocal)) !== undefined && Geometry_1.Geometry.isDistanceWithinTol(dist2, tol2))
+                            this.recordPointWithLocalFractions(lineFraction < 0.5 ? 0 : 1, cpA, fractionA0, fractionA1, arcFraction < 0.5 ? 0 : 1, arc, 0, 1, reversed);
+                    }
                 }
             }
         }
@@ -483,7 +509,7 @@ class CurveCurveIntersectXY extends GeometryHandler_1.RecurseToCurvesGeometryHan
         }
         return ranges;
     }
-    dispatchBezierBezierStrokeFirst(bezierA, bcurveA, strokeCountA, bezierB, bcurveB, _strokeCountB, univariateBezierB, // caller-allocated for univariate coefficients.
+    dispatchBezierBezierStrokeFirst(bezierA, bcurveA, strokeCountA, bezierB, bcurveB, _strokeCountB, univariateBezierB, // caller-allocated for univariate coefficients
     reversed) {
         if (!this._xyzwA0)
             this._xyzwA0 = Point4d_1.Point4d.create();
@@ -527,7 +553,7 @@ class CurveCurveIntersectXY extends GeometryHandler_1.RecurseToCurvesGeometryHan
                     let bezierBFraction = r;
                     bezierB.fractionToPoint4d(bezierBFraction, this._xyzwB);
                     const segmentAFraction = SmallSystem_1.SmallSystem.lineSegment3dHXYClosestPointUnbounded(this._xyzwA0, this._xyzwA1, this._xyzwB);
-                    if (segmentAFraction && Geometry_1.Geometry.isIn01WithTolerance(segmentAFraction, intervalTolerance)) {
+                    if (segmentAFraction !== undefined && Geometry_1.Geometry.isIn01WithTolerance(segmentAFraction, intervalTolerance)) {
                         let bezierAFraction = Geometry_1.Geometry.interpolate(f0, segmentAFraction, f1);
                         // We have a near intersection at fractions on the two beziers
                         // Iterate on the curves for a true intersection
@@ -562,7 +588,7 @@ class CurveCurveIntersectXY extends GeometryHandler_1.RecurseToCurvesGeometryHan
             }
         }
     }
-    dispatchBSplineCurve3dBSplineCurve3d(bcurveA, bcurveB, _reversed) {
+    dispatchBSplineCurve3dBSplineCurve3d(bcurveA, bcurveB, reversed) {
         const bezierSpanA = bcurveA.collectBezierSpans(true);
         const bezierSpanB = bcurveB.collectBezierSpans(true);
         const numA = bezierSpanA.length;
@@ -581,9 +607,9 @@ class CurveCurveIntersectXY extends GeometryHandler_1.RecurseToCurvesGeometryHan
                     const strokeCountA = bezierSpanA[a].computeStrokeCountForOptions();
                     const strokeCountB = bezierSpanB[b].computeStrokeCountForOptions();
                     if (strokeCountA < strokeCountB)
-                        this.dispatchBezierBezierStrokeFirst(bezierSpanA[a], bcurveA, strokeCountA, bezierSpanB[b], bcurveB, strokeCountB, univariateCoffsB, _reversed);
+                        this.dispatchBezierBezierStrokeFirst(bezierSpanA[a], bcurveA, strokeCountA, bezierSpanB[b], bcurveB, strokeCountB, univariateCoffsB, reversed);
                     else
-                        this.dispatchBezierBezierStrokeFirst(bezierSpanB[b], bcurveB, strokeCountB, bezierSpanA[a], bcurveA, strokeCountA, univariateCoffsA, !_reversed);
+                        this.dispatchBezierBezierStrokeFirst(bezierSpanB[b], bcurveB, strokeCountB, bezierSpanA[a], bcurveA, strokeCountA, univariateCoffsA, !reversed);
                 }
             }
         }