@itwin/core-geometry 4.9.0-dev.2 → 4.9.0-dev.20

package/lib/cjs/polyface/PolyfaceQuery.js

@@ -10,6 +10,7 @@ exports.PolyfaceQuery = exports.DuplicateFacetClusterSelector = exports.OffsetMe
  */
 /* eslint-disable @typescript-eslint/naming-convention, no-empty */
 // cspell:word internaldocs
+const core_bentley_1 = require("@itwin/core-bentley");
 const CurveCollection_1 = require("../curve/CurveCollection");
 const CurveOps_1 = require("../curve/CurveOps");
 const MultiChainCollector_1 = require("../curve/internalContexts/MultiChainCollector");
@@ -20,12 +21,13 @@ const StrokeOptions_1 = require("../curve/StrokeOptions");
 const Geometry_1 = require("../Geometry");
 const Angle_1 = require("../geometry3d/Angle");
 const BarycentricTriangle_1 = require("../geometry3d/BarycentricTriangle");
-const FrameBuilder_1 = require("../geometry3d/FrameBuilder");
 const Point3dArrayCarrier_1 = require("../geometry3d/Point3dArrayCarrier");
 const Point3dVector3d_1 = require("../geometry3d/Point3dVector3d");
 const PointHelpers_1 = require("../geometry3d/PointHelpers");
 const PolygonOps_1 = require("../geometry3d/PolygonOps");
 const Range_1 = require("../geometry3d/Range");
+const Ray3d_1 = require("../geometry3d/Ray3d");
+const Transform_1 = require("../geometry3d/Transform");
 const Matrix4d_1 = require("../geometry4d/Matrix4d");
 const MomentData_1 = require("../geometry4d/MomentData");
 const UnionFind_1 = require("../numerics/UnionFind");
@@ -445,9 +447,9 @@ class PolyfaceQuery {
     }
     /**
      * Test edges pairing in `source` mesh.
-     * * For `allowSimpleBoundaries === false` true return means this is a closed 2-manifold surface.
-     * * For `allowSimpleBoundaries === true` true means this is a 2-manifold surface which may have boundary, but is
-     * still properly matched internally.
+     * * For `allowSimpleBoundaries === false`, a return value of `true` means this is a closed 2-manifold surface.
+     * * For `allowSimpleBoundaries === true`, a return value of `true` means this is a 2-manifold surface which may have
+     * a boundary, but is still properly matched internally.
      * * Any edge with 3 or more adjacent facets triggers `false` return.
      * * Any edge with 2 adjacent facets in the same direction triggers a `false` return.
     */
@@ -480,8 +482,8 @@ class PolyfaceQuery {
      * @param includeNull true to announce edges with identical start and end vertex indices.
      */
     static announceBoundaryEdges(source, announceEdge, includeTypical = true, includeMismatch = true, includeNull = true) {
-        if (source === undefined)
-            return undefined;
+        if (source === undefined || (!includeTypical && !includeMismatch && !includeNull))
+            return;
         const edges = new IndexedEdgeMatcher_1.IndexedEdgeMatcher();
         const visitor = source instanceof Polyface_1.Polyface ? source.createVisitor(1) : source;
         visitor.setNumWrap(1);
@@ -493,29 +495,18 @@ class PolyfaceQuery {
             }
         }
         const boundaryEdges = [];
-        const nullEdges = [];
-        const allOtherEdges = [];
-        edges.sortAndCollectClusters(undefined, boundaryEdges, nullEdges, allOtherEdges);
-        const badList = [];
-        if (includeTypical && boundaryEdges.length > 0)
-            badList.push(boundaryEdges);
-        if (includeNull && nullEdges.length > 0)
-            badList.push(nullEdges);
-        if (includeMismatch && allOtherEdges.length > 0)
-            badList.push(allOtherEdges);
-        if (badList.length === 0)
-            return undefined;
+        edges.sortAndCollectClusters(undefined, includeTypical ? boundaryEdges : undefined, includeNull ? boundaryEdges : undefined, includeMismatch ? boundaryEdges : undefined);
+        if (boundaryEdges.length === 0)
+            return;
         const sourcePolyface = visitor.clientPolyface();
         const pointA = Point3dVector3d_1.Point3d.create();
         const pointB = Point3dVector3d_1.Point3d.create();
-        for (const list of badList) {
-            for (const e of list) {
-                const e1 = e instanceof IndexedEdgeMatcher_1.SortableEdge ? e : e[0];
-                const indexA = e1.vertexIndexA;
-                const indexB = e1.vertexIndexB;
-                if (sourcePolyface.data.getPoint(indexA, pointA) && sourcePolyface.data.getPoint(indexB, pointB))
-                    announceEdge(pointA, pointB, indexA, indexB, e1.facetIndex);
-            }
+        for (const e of boundaryEdges) {
+            const e1 = e instanceof IndexedEdgeMatcher_1.SortableEdge ? e : e[0];
+            const indexA = e1.vertexIndexA;
+            const indexB = e1.vertexIndexB;
+            if (sourcePolyface.data.getPoint(indexA, pointA) && sourcePolyface.data.getPoint(indexB, pointB))
+                announceEdge(pointA, pointB, indexA, indexB, e1.facetIndex);
         }
     }
     /**
@@ -540,7 +531,7 @@ class PolyfaceQuery {
      * Collect boundary edges.
      * * Return the edges as the simplest collection of chains of line segments.
      * @param source polyface or visitor.
-     * @param includeTypical true to in include typical boundary edges with a single adjacent facet.
+     * @param includeTypical true to include typical boundary edges with a single adjacent facet.
      * @param includeMismatch true to include edges with more than 2 adjacent facets.
      * @param includeNull true to include edges with identical start and end vertex indices.
      */
@@ -785,18 +776,18 @@ class PolyfaceQuery {
     }
     /**
      * Search for edges with only 1 adjacent facet.
-     * * Chain them into loops.
-     * * Emit the loops to the announceLoop function.
+     * * Accumulate them into chains.
+     * * Emit the chains to the `announceChain` callback.
      */
-    static announceBoundaryChainsAsLineString3d(mesh, announceLoop) {
-        const collector = new MultiChainCollector_1.MultiChainCollector(Geometry_1.Geometry.smallMetricDistance, 1000);
+    static announceBoundaryChainsAsLineString3d(mesh, announceChain) {
+        const collector = new MultiChainCollector_1.MultiChainCollector(Geometry_1.Geometry.smallMetricDistance); // no planarity tolerance needed
         PolyfaceQuery.announceBoundaryEdges(mesh, (pointA, pointB, _indexA, _indexB) => collector.captureCurve(LineSegment3d_1.LineSegment3d.create(pointA, pointB)), true, false, false);
-        collector.announceChainsAsLineString3d(announceLoop);
+        collector.announceChainsAsLineString3d(announceChain);
     }
     /**
      * Return a mesh with
-     *  * clusters of adjacent, coplanar facets merged into larger facets.
-     *  * other facets included unchanged.
+     *  * clusters of adjacent, coplanar facets merged into larger (possibly non-convex) facets.
+     *  * other facets are unchanged.
      * @param mesh existing mesh or visitor.
      * @param maxSmoothEdgeAngle maximum dihedral angle across an edge between facets deemed coplanar. If undefined,
      * uses `Geometry.smallAngleRadians`.
@@ -810,42 +801,58 @@ class PolyfaceQuery {
         const builder = PolyfaceBuilder_1.PolyfaceBuilder.create();
         const visitor = mesh;
         const planarPartitions = [];
+        const partitionNormals = []; // average normal in each nontrivial partition
+        const normal = Point3dVector3d_1.Vector3d.createZero();
         for (const partition of partitions) {
             if (partition.length === 1) {
                 if (visitor.moveToReadIndex(partition[0]))
                     builder.addFacetFromVisitor(visitor);
             }
-            else {
-                // This is a non-trivial set of contiguous coplanar facets
+            else if (partition.length > 1) { // nontrivial set of contiguous coplanar facets
+                const averageNormal = Point3dVector3d_1.Vector3d.createZero();
+                const point0 = Point3dVector3d_1.Point3d.createZero();
+                if (visitor.moveToReadIndex(partition[0]))
+                    visitor.point.getPoint3dAtCheckedPointIndex(0, point0);
+                for (const facetIndex of partition) {
+                    if (visitor.moveToReadIndex(facetIndex))
+                        if (PolygonOps_1.PolygonOps.areaNormalGo(visitor.point, normal))
+                            averageNormal.addInPlace(normal);
+                }
+                partitionNormals.push(Ray3d_1.Ray3d.createCapture(point0, averageNormal));
                 planarPartitions.push(partition);
             }
         }
         const fragmentPolyfaces = PolyfaceQuery.clonePartitions(mesh, planarPartitions);
+        (0, core_bentley_1.assert)(planarPartitions.length === partitionNormals.length);
+        (0, core_bentley_1.assert)(planarPartitions.length === fragmentPolyfaces.length);
         const gapTolerance = 1.0e-4;
         const planarityTolerance = 1.0e-4;
-        for (const fragment of fragmentPolyfaces) {
+        const localToWorld = Transform_1.Transform.createIdentity();
+        const worldToLocal = Transform_1.Transform.createIdentity();
+        for (let i = 0; i < fragmentPolyfaces.length; ++i) {
+            const fragment = fragmentPolyfaces[i];
             const edges = [];
             const edgeStrings = [];
             PolyfaceQuery.announceBoundaryEdges(fragment, (pointA, pointB, _indexA, _indexB) => {
                 edges.push(LineSegment3d_1.LineSegment3d.create(pointA, pointB));
                 edgeStrings.push([pointA.clone(), pointB.clone()]);
-            });
+            }, true, false, false);
             const chains = CurveOps_1.CurveOps.collectChains(edges, gapTolerance, planarityTolerance);
             if (chains) {
-                const frameBuilder = new FrameBuilder_1.FrameBuilder();
-                frameBuilder.announce(chains);
-                const frame = frameBuilder.getValidatedFrame(false);
-                if (frame !== undefined) {
-                    const inverseFrame = frame.inverse();
-                    if (inverseFrame !== undefined) {
-                        inverseFrame.multiplyPoint3dArrayArrayInPlace(edgeStrings);
-                        const graph = Merging_1.HalfEdgeGraphMerge.formGraphFromChains(edgeStrings, true, Graph_1.HalfEdgeMask.BOUNDARY_EDGE);
-                        if (graph) {
-                            HalfEdgeGraphSearch_1.HalfEdgeGraphSearch.collectConnectedComponentsWithExteriorParityMasks(graph, new HalfEdgeGraphSearch_1.HalfEdgeMaskTester(Graph_1.HalfEdgeMask.BOUNDARY_EDGE), Graph_1.HalfEdgeMask.EXTERIOR);
-                            // this.purgeNullFaces(HalfEdgeMask.EXTERIOR);
-                            const polyface1 = PolyfaceBuilder_1.PolyfaceBuilder.graphToPolyface(graph);
-                            builder.addIndexedPolyface(polyface1, false, frame);
-                        }
+                // avoid FrameBuilder: it can flip the normal of a nonconvex facet!
+                partitionNormals[i].toRigidZFrame(localToWorld);
+                if (localToWorld.inverse(worldToLocal)) {
+                    worldToLocal.multiplyPoint3dArrayArrayInPlace(edgeStrings);
+                    // Regularize adds bridge edges to holes, and adds other edges to aid triangulation.
+                    // But we aren't triangulating here. So if we don't have holes, we can skip regularization
+                    // to avoid splitting the loop.
+                    const regularize = !(chains instanceof Loop_1.Loop);
+                    const graph = Merging_1.HalfEdgeGraphMerge.formGraphFromChains(edgeStrings, regularize, Graph_1.HalfEdgeMask.BOUNDARY_EDGE);
+                    if (graph) {
+                        HalfEdgeGraphSearch_1.HalfEdgeGraphSearch.collectConnectedComponentsWithExteriorParityMasks(graph, new HalfEdgeGraphSearch_1.HalfEdgeMaskTester(Graph_1.HalfEdgeMask.BOUNDARY_EDGE), Graph_1.HalfEdgeMask.EXTERIOR);
+                        // this.purgeNullFaces(HalfEdgeMask.EXTERIOR);
+                        const polyface1 = PolyfaceBuilder_1.PolyfaceBuilder.graphToPolyface(graph);
+                        builder.addIndexedPolyface(polyface1, false, localToWorld);
                     }
                 }
             }