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

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

@@ -12,7 +12,6 @@ import { CoincidentGeometryQuery } from "../../geometry3d/CoincidentGeometryOps"
 import { RecurseToCurvesGeometryHandler } from "../../geometry3d/GeometryHandler";
 import { GrowableFloat64Array } from "../../geometry3d/GrowableFloat64Array";
 import { Matrix3d } from "../../geometry3d/Matrix3d";
-import { Vector2d } from "../../geometry3d/Point2dVector2d";
 import { Point3d } from "../../geometry3d/Point3dVector3d";
 import { Point4d } from "../../geometry4d/Point4d";
 import { UnivariateBezier } from "../../numerics/BezierPolynomials";
@@ -44,7 +43,6 @@ export class CurveCurveIntersectXY extends RecurseToCurvesGeometryHandler {
     _worldToLocalPerspective;
     _worldToLocalAffine;
     _coincidentGeometryContext;
-    static _workVector2dA = Vector2d.create();
     static _workPointA0H = Point4d.create();
     static _workPointA1H = Point4d.create();
     static _workPointB0H = Point4d.create();
@@ -196,21 +194,25 @@ export class CurveCurveIntersectXY extends RecurseToCurvesGeometryHandler {
     }
     /** 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.lineSegmentXYUVIntersectionUnbounded(pointA0, aDir, pointB0, bDir, tol);
+        if (!fractions)
+            return;
+        if (fractions.f1) { // the lines are coincident
+            const detailA = 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.createCurveFractionPoint(undefined, fractions.f0.y, pointB0.interpolate(fractions.f0.y, pointB1));
+            detailB.captureFraction1Point1(fractions.f1.y, pointB0.interpolate(fractions.f1.y, pointB1));
+            const overlap = 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.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);
             }
         }
     }
@@ -258,6 +260,8 @@ export class CurveCurveIntersectXY extends RecurseToCurvesGeometryHandler {
     // 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
@@ -268,6 +272,10 @@ export class CurveCurveIntersectXY extends RecurseToCurvesGeometryHandler {
         // 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.tripleProductPoint4dXYW(pointA0H, pointA1H, data.center);
@@ -277,19 +285,31 @@ export class CurveCurveIntersectXY extends RecurseToCurvesGeometryHandler {
             const sines = new GrowableFloat64Array(2);
             const radians = new GrowableFloat64Array(2);
             const numRoots = 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.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.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) {
@@ -303,16 +323,22 @@ export class CurveCurveIntersectXY extends RecurseToCurvesGeometryHandler {
             const sines = new GrowableFloat64Array(2);
             const radians = new GrowableFloat64Array(2);
             const numRoots = 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.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.isDistanceWithinTol(dist2, tol2))
+                            this.recordPointWithLocalFractions(lineFraction < 0.5 ? 0 : 1, cpA, fractionA0, fractionA1, arcFraction < 0.5 ? 0 : 1, arc, 0, 1, reversed);
+                    }
                 }
             }
         }
@@ -480,7 +506,7 @@ export class CurveCurveIntersectXY extends RecurseToCurvesGeometryHandler {
         }
         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.create();
@@ -524,7 +550,7 @@ export class CurveCurveIntersectXY extends RecurseToCurvesGeometryHandler {
                     let bezierBFraction = r;
                     bezierB.fractionToPoint4d(bezierBFraction, this._xyzwB);
                     const segmentAFraction = SmallSystem.lineSegment3dHXYClosestPointUnbounded(this._xyzwA0, this._xyzwA1, this._xyzwB);
-                    if (segmentAFraction && Geometry.isIn01WithTolerance(segmentAFraction, intervalTolerance)) {
+                    if (segmentAFraction !== undefined && Geometry.isIn01WithTolerance(segmentAFraction, intervalTolerance)) {
                         let bezierAFraction = Geometry.interpolate(f0, segmentAFraction, f1);
                         // We have a near intersection at fractions on the two beziers
                         // Iterate on the curves for a true intersection
@@ -559,7 +585,7 @@ export class CurveCurveIntersectXY extends RecurseToCurvesGeometryHandler {
             }
         }
     }
-    dispatchBSplineCurve3dBSplineCurve3d(bcurveA, bcurveB, _reversed) {
+    dispatchBSplineCurve3dBSplineCurve3d(bcurveA, bcurveB, reversed) {
         const bezierSpanA = bcurveA.collectBezierSpans(true);
         const bezierSpanB = bcurveB.collectBezierSpans(true);
         const numA = bezierSpanA.length;
@@ -578,9 +604,9 @@ export class CurveCurveIntersectXY extends RecurseToCurvesGeometryHandler {
                     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);
                 }
             }
         }