@itwin/core-geometry 4.0.0-dev.23 → 4.0.0-dev.28

package/lib/cjs/polyface/PolyfaceQuery.js

@@ -8,7 +8,6 @@ exports.PolyfaceQuery = exports.DuplicateFacetClusterSelector = exports.OffsetMe
 /** @packageDocumentation
  * @module Polyface
  */
-// import { Point2d } from "./Geometry2d";
 /* eslint-disable @typescript-eslint/naming-convention, no-empty */
 const PointHelpers_1 = require("../geometry3d/PointHelpers");
 const CurveCollection_1 = require("../curve/CurveCollection");
@@ -42,6 +41,8 @@ const RangeLengthData_1 = require("./RangeLengthData");
 const SpaceTriangulation_1 = require("../topology/SpaceTriangulation");
 const HalfEdgeGraphFromIndexedLoopsContext_1 = require("../topology/HalfEdgeGraphFromIndexedLoopsContext");
 const OffsetMeshContext_1 = require("./multiclip/OffsetMeshContext");
+const FacetLocationDetail_1 = require("./FacetLocationDetail");
+const BarycentricTriangle_1 = require("../geometry3d/BarycentricTriangle");
 /**
  * Options carrier for [[PolyfaceQuery.cloneOffset]].
  * * Default options are strongly recommended.
@@ -1315,7 +1316,7 @@ class PolyfaceQuery {
     *   * Compute simple average of those normals
     *   * Index to the averages
     * * For typical meshes, this correctly clusters adjacent normals.
-    * * One cam imagine a vertex with multiple "smooth cone-like" sets of incident facets such that averaging occurs among two nonadjacent cones.  But this does not seem to be a problem in practice.
+    * * One can imagine a vertex with multiple "smooth cone-like" sets of incident facets such that averaging occurs among two nonadjacent cones.  But this does not seem to be a problem in practice.
     * @param polyface polyface to update.
     * @param toleranceAngle averaging is done between normals up to this angle.
     */
@@ -1335,6 +1336,55 @@ class PolyfaceQuery {
         OffsetMeshContext_1.OffsetMeshContext.buildOffsetMeshWithEdgeChamfers(source, offsetBuilder, signedOffsetDistance, offsetOptions);
         return offsetBuilder.claimPolyface();
     }
+    /** Search facets for the first one that intersects the infinite line.
+     * * To process _all_ intersections, callers can supply an `options.acceptIntersection` callback that always returns false.
+     * In this case, `intersectRay3d` will return undefined, but the callback will be invoked for each intersection.
+     * * Example callback logic:
+     *    * Accept the first found facet that intersects the half-line specified by the ray: `return detail.a >= 0.0;`
+     *    * Collect all intersections: `myIntersections.push(detail.clone()); return false;` Then after `intersectRay3d` returns, sort along `ray` with `myIntersections.sort((d0, d1) => d0.a - d1.a);`
+     * @param visitor facet iterator
+     * @param ray infinite line parameterized as a ray. The returned `detail.a` is the intersection parameter on the ray, e.g., zero at `ray.origin` and increasing in `ray.direction`.
+     * @param options options for computing and populating an intersection detail, and an optional callback for accepting one
+     * @return detail for the (accepted) intersection with `detail.IsInsideOrOn === true`, or `undefined` if no (accepted) intersection
+     * @see PolygonOps.intersectRay3d
+    */
+    static intersectRay3d(visitor, ray, options) {
+        if (visitor instanceof Polyface_1.Polyface)
+            return PolyfaceQuery.intersectRay3d(visitor.createVisitor(0), ray, options);
+        let detail;
+        visitor.setNumWrap(0);
+        while (visitor.moveToNextFacet()) {
+            const numEdges = visitor.pointCount; // #vertices = #edges since numWrap is zero
+            const vertices = visitor.point;
+            if (3 === numEdges) {
+                const tri = this._workTriangle = BarycentricTriangle_1.BarycentricTriangle.create(vertices.getPoint3dAtUncheckedPointIndex(0), vertices.getPoint3dAtUncheckedPointIndex(1), vertices.getPoint3dAtUncheckedPointIndex(2), this._workTriangle);
+                const detail3 = this._workTriDetail = tri.intersectRay3d(ray, this._workTriDetail);
+                tri.snapLocationToEdge(detail3, options?.distanceTolerance, options?.parameterTolerance);
+                detail = this._workFacetDetail3 = FacetLocationDetail_1.TriangularFacetLocationDetail.create(visitor.currentReadIndex(), detail3, this._workFacetDetail3);
+            }
+            else {
+                const detailN = this._workPolyDetail = PolygonOps_1.PolygonOps.intersectRay3d(vertices, ray, options?.distanceTolerance, this._workPolyDetail);
+                if (PolygonOps_1.PolygonOps.isConvex(vertices))
+                    detail = this._workFacetDetailC = FacetLocationDetail_1.ConvexFacetLocationDetail.create(visitor.currentReadIndex(), numEdges, detailN, this._workFacetDetailC);
+                else
+                    detail = this._workFacetDetailNC = FacetLocationDetail_1.NonConvexFacetLocationDetail.create(visitor.currentReadIndex(), numEdges, detailN, this._workFacetDetailNC);
+            }
+            if (detail.isInsideOrOn) { // set optional caches, process the intersection
+                if (options?.needNormal && visitor.normal)
+                    detail.getNormal(visitor.normal, vertices, options?.distanceTolerance);
+                if (options?.needParam && visitor.param)
+                    detail.getParam(visitor.param, vertices, options?.distanceTolerance);
+                if (options?.needColor && visitor.color)
+                    detail.getColor(visitor.color, vertices, options?.distanceTolerance);
+                if (options?.needBarycentricCoordinates)
+                    detail.getBarycentricCoordinates(vertices, options?.distanceTolerance);
+                if (options?.acceptIntersection && !options.acceptIntersection(detail, visitor))
+                    continue;
+                return detail;
+            }
+        }
+        return undefined; // no intersection
+    }
 }
 exports.PolyfaceQuery = PolyfaceQuery;
 // amount of computation to do per step of async methods.