@itwin/core-geometry 5.2.0-dev.3 → 5.2.0-dev.31

package/lib/cjs/polyface/PolyfaceBuilder.js

@@ -4,7 +4,7 @@
 * See LICENSE.md in the project root for license terms and full copyright notice.
 *--------------------------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PolyfaceBuilder = void 0;
+exports.HalfEdgeGraphSearch = exports.PolyfaceBuilder = void 0;
 /** @packageDocumentation
  * @module Polyface
  */
@@ -46,6 +46,7 @@ const IndexedEdgeMatcher_1 = require("./IndexedEdgeMatcher");
 const IndexedPolyfaceVisitor_1 = require("./IndexedPolyfaceVisitor");
 const Polyface_1 = require("./Polyface");
 const PolyfaceQuery_1 = require("./PolyfaceQuery");
+const PolyfaceRangeTreeContext_1 = require("./RangeTree/PolyfaceRangeTreeContext");
 /**
  * A FacetSector.
  * * Initially holds coordinate data for a place where xyz and sectionDerivative are known.
@@ -284,7 +285,7 @@ class PolyfaceBuilder extends GeometryHandler_1.NullGeometryHandler {
     }
     /**
      * Add triangles from the first point of the linestring to the subsequent edges of the linestring.
-     * * No checks are made for polygon convexity or edge collinearity, conditions which would ensure positive area triangles.
+     * * No checks are made for polygon convexity or edge colinearity, conditions which would ensure positive area triangles.
      * @param ls linestring with point coordinates.
      * @param reverse if `true`, wrap the triangle creation in toggleReversedFacetFlag.
      */
@@ -1564,8 +1565,8 @@ class PolyfaceBuilder extends GeometryHandler_1.NullGeometryHandler {
      * * Accepted face edge visibility is determined by `isEdgeVisibleFunction`.
      * * Rely on the builder's compress step to find common vertex coordinates.
      * @param graph faces to add as facets.
-     * @param acceptFaceFunction optional test for whether to add a given face. Default: ignore exterior faces.
-     * @param isEdgeVisibleFunction optional test for whether to hide an edge. Default: hide interior edges.
+     * @param acceptFaceFunction (optional) callback invoked once per graph face to test for whether to add a given face to the mesh. Default: accept only interior faces.
+     * @param isEdgeVisibleFunction (optional) callback invoked once per edge of each accepted face to test for whether to hide an edge. Default: only boundary edges are visible.
      * @internal
      */
     addGraph(graph, acceptFaceFunction = (node) => Graph_1.HalfEdge.testNodeMaskNotExterior(node), isEdgeVisibleFunction = (node) => Graph_1.HalfEdge.testMateMaskExterior(node)) {
@@ -1619,17 +1620,19 @@ class PolyfaceBuilder extends GeometryHandler_1.NullGeometryHandler {
     /**
      * Create a polyface containing the faces of a HalfEdgeGraph, with test functions to filter faces and hide edges.
      * * This is a static wrapper of [[addGraph]].
+     * * Default callbacks assume graph is appropriately masked with HalfEdgeMask.EXTERIOR.
      * @param graph faces to add as facets.
      * @param options (optional) options for the polyface.
-     * @param acceptFaceFunction optional test for whether to add a given face. Default: ignore exterior faces.
-     * @param isEdgeVisibleFunction optional test for whether to hide an edge. Default: hide interior edges.
+     * @param acceptFaceFunction (optional) callback invoked once per graph face to test for whether to add a given face to the mesh. Default: accept only interior faces.
+     * @param isEdgeVisibleFunction (optional) callback invoked once per edge of each accepted face to test for whether to hide an edge. Default: only boundary edges are visible.
+     * @param clusterTol optional distance tolerance for mesh compression. Default is [[Geometry.smallMetricDistance]].
      * @internal
      */
-    static graphToPolyface(graph, options, acceptFaceFunction = (node) => Graph_1.HalfEdge.testNodeMaskNotExterior(node), isEdgeVisibleFunction = (node) => Graph_1.HalfEdge.testMateMaskExterior(node)) {
+    static graphToPolyface(graph, options, acceptFaceFunction = (node) => Graph_1.HalfEdge.testNodeMaskNotExterior(node), isEdgeVisibleFunction = (node) => Graph_1.HalfEdge.testMateMaskExterior(node), clusterTol = Geometry_1.Geometry.smallMetricDistance) {
         const builder = PolyfaceBuilder.create(options);
         builder.addGraph(graph, acceptFaceFunction, isEdgeVisibleFunction);
         builder.endFace();
-        return builder.claimPolyface();
+        return builder.claimPolyface(true, clusterTol); // always compress; addGraph does not share vertices!
     }
     /**
      * Create a polyface containing the faces of a HalfEdgeGraph that are specified by the HalfEdge array.
@@ -1971,4 +1974,52 @@ function resolveToIndexedXYZCollectionOrCarrier(points) {
 function distinctIndices(i0, i1, i2) {
     return i0 !== i1 && i1 !== i2 && i2 !== i0;
 }
+/**
+ * In this file to avoid topology -> polyface dependency.
+ * @internal
+ */
+var HalfEdgeGraphSearch;
+(function (HalfEdgeGraphSearch) {
+    /**
+     * Search the graph for an interior face containing the test point(s).
+     * * For best results:
+     *   * the graph exterior face(s) should be masked with HalfEdgeMask.EXTERIOR
+     *   * the graph should contain no vertical faces
+     * @param graph input topology, z-coordinates ignored
+     * @param testPoint xy point(s) to search
+     * @returns edge in the face loop of the containing face, or `undefined` if `testPoint` is in an exterior face,
+     * or an array of the same in 1-1 correspondence with the input points.
+     */
+    function findContainingFaceXY(graph, testPoint) {
+        const results = [];
+        const idToFaceIndexMap = graph.constructIdToFaceIndexMap();
+        const facetIndexToFaceIndex = [];
+        const acceptFace = (face) => {
+            if (face.isMaskSet(Graph_1.HalfEdgeMask.EXTERIOR))
+                return false; // skip exterior face
+            facetIndexToFaceIndex.push(idToFaceIndexMap.get(face.id) ?? -1);
+            return true;
+        };
+        const clusterTol = Geometry_1.Geometry.smallFloatingPoint; // don't want clustering to destroy edges
+        const mesh = PolyfaceBuilder.graphToPolyface(graph, undefined, acceptFace, () => true, clusterTol);
+        mesh.data.point.multiplyMatrix3dInPlace(Matrix3d_1.Matrix3d.createScale(1, 1, 0)); // flatten
+        const searcher = PolyfaceRangeTreeContext_1.PolyfaceRangeTreeContext.createCapture(mesh, undefined, undefined, false);
+        if (searcher) {
+            const testPoints = Array.isArray(testPoint) ? testPoint : [testPoint];
+            for (const testPt of testPoints) {
+                let result;
+                const closestDetail = searcher.searchForClosestPoint(testPt, undefined, true);
+                // closest point on the mesh should have zero distance to testPt, but allow for minute slop
+                if (closestDetail && closestDetail.a < Geometry_1.Geometry.smallFloatingPoint) {
+                    const faceIndex = facetIndexToFaceIndex[closestDetail.facetIndex];
+                    if (faceIndex >= 0 && faceIndex < graph.allHalfEdges.length)
+                        result = graph.allHalfEdges[faceIndex];
+                }
+                results.push(result);
+            }
+        }
+        return results.length === 0 ? undefined : (results.length === 1 ? results[0] : results);
+    }
+    HalfEdgeGraphSearch.findContainingFaceXY = findContainingFaceXY;
+})(HalfEdgeGraphSearch || (exports.HalfEdgeGraphSearch = HalfEdgeGraphSearch = {}));
 //# sourceMappingURL=PolyfaceBuilder.js.map