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

package/lib/esm/polyface/PolyfaceBuilder.js

@@ -34,7 +34,7 @@ import { Segment1d } from "../geometry3d/Segment1d";
 import { Transform } from "../geometry3d/Transform";
 import { UVSurfaceOps } from "../geometry3d/UVSurfaceOps";
 import { SweepContour } from "../solid/SweepContour";
-import { HalfEdge } from "../topology/Graph";
+import { HalfEdge, HalfEdgeMask } from "../topology/Graph";
 import { InsertedVertexZOptions } from "../topology/InsertAndRetriangulateContext";
 import { Triangulator } from "../topology/Triangulation";
 import { BoxTopology } from "./BoxTopology";
@@ -43,6 +43,7 @@ import { SortableEdge } from "./IndexedEdgeMatcher";
 import { IndexedPolyfaceSubsetVisitor } from "./IndexedPolyfaceVisitor";
 import { IndexedPolyface } from "./Polyface";
 import { PolyfaceQuery } from "./PolyfaceQuery";
+import { PolyfaceRangeTreeContext } from "./RangeTree/PolyfaceRangeTreeContext";
 /**
  * A FacetSector.
  * * Initially holds coordinate data for a place where xyz and sectionDerivative are known.
@@ -281,7 +282,7 @@ export class PolyfaceBuilder extends 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.
      */
@@ -1561,8 +1562,8 @@ export class PolyfaceBuilder extends 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) => HalfEdge.testNodeMaskNotExterior(node), isEdgeVisibleFunction = (node) => HalfEdge.testMateMaskExterior(node)) {
@@ -1616,17 +1617,19 @@ export class PolyfaceBuilder extends 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) => HalfEdge.testNodeMaskNotExterior(node), isEdgeVisibleFunction = (node) => HalfEdge.testMateMaskExterior(node)) {
+    static graphToPolyface(graph, options, acceptFaceFunction = (node) => HalfEdge.testNodeMaskNotExterior(node), isEdgeVisibleFunction = (node) => HalfEdge.testMateMaskExterior(node), clusterTol = 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.
@@ -1967,4 +1970,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
+ */
+export 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(HalfEdgeMask.EXTERIOR))
+                return false; // skip exterior face
+            facetIndexToFaceIndex.push(idToFaceIndexMap.get(face.id) ?? -1);
+            return true;
+        };
+        const clusterTol = Geometry.smallFloatingPoint; // don't want clustering to destroy edges
+        const mesh = PolyfaceBuilder.graphToPolyface(graph, undefined, acceptFace, () => true, clusterTol);
+        mesh.data.point.multiplyMatrix3dInPlace(Matrix3d.createScale(1, 1, 0)); // flatten
+        const searcher = 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.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 || (HalfEdgeGraphSearch = {}));
 //# sourceMappingURL=PolyfaceBuilder.js.map