@itwin/core-geometry 4.1.0-dev.73 → 4.1.0-dev.74

package/lib/esm/polyface/PolyfaceQuery.js

@@ -17,6 +17,7 @@ import { Geometry } from "../Geometry";
 import { Angle } from "../geometry3d/Angle";
 import { BarycentricTriangle } from "../geometry3d/BarycentricTriangle";
 import { FrameBuilder } from "../geometry3d/FrameBuilder";
+import { Point3dArrayCarrier } from "../geometry3d/Point3dArrayCarrier";
 import { Point3d, Vector3d } from "../geometry3d/Point3dVector3d";
 import { Point3dArray } from "../geometry3d/PointHelpers";
 import { PolygonOps } from "../geometry3d/PolygonOps";
@@ -36,7 +37,7 @@ import { IndexedEdgeMatcher, SortableEdge } from "./IndexedEdgeMatcher";
 import { IndexedPolyfaceSubsetVisitor } from "./IndexedPolyfaceVisitor";
 import { BuildAverageNormalsContext } from "./multiclip/BuildAverageNormalsContext";
 import { OffsetMeshContext } from "./multiclip/OffsetMeshContext";
-import { ClipSweptLineStringContext, SweepLineStringToFacetContext } from "./multiclip/SweepLineStringToFacetContext";
+import { ClipSweptLineStringContext, EdgeClipData, SweepLineStringToFacetContext } from "./multiclip/SweepLineStringToFacetContext";
 import { XYPointBuckets } from "./multiclip/XYPointBuckets";
 import { Polyface } from "./Polyface";
 import { PolyfaceBuilder } from "./PolyfaceBuilder";
@@ -879,13 +880,13 @@ class PolyfaceQuery {
         matcher.sortAndCollectClusters(allEdges, allEdges, allEdges, allEdges);
         return this.partitionFacetIndicesBySortableEdgeClusters(allEdges, numFacets);
     }
-    /** Find segments (within the linestring) which project to facets.
-     * * Assemble each segment pair as a facet in a new polyface
-     * * Facets are ASSUMED to be convex and planar, and not overlap in the z direction.
+    /** Find segments (within the line string) which project to facets.
+     * * Assemble each input segment paired with its projected segment/point as a quad/triangle facet in a new polyface.
+     * * Input facets are ASSUMED to be convex and planar, and not overlap in the z direction.
      */
-    static sweepLineStringToFacetsXYReturnSweptFacets(linestringPoints, polyface) {
+    static sweepLineStringToFacetsXYReturnSweptFacets(lineStringPoints, polyface) {
         const builder = PolyfaceBuilder.create();
-        this.announceSweepLinestringToConvexPolyfaceXY(linestringPoints, polyface, (_linestring, _segmentIndex, _polyface, _facetIndex, points) => {
+        this.announceSweepLinestringToConvexPolyfaceXY(lineStringPoints, polyface, (_linestring, _segmentIndex, _polyface, _facetIndex, points) => {
             if (points.length === 4)
                 builder.addQuadFacet(points);
             else if (points.length === 3)
@@ -898,13 +899,13 @@ class PolyfaceQuery {
         return this.sweepLineStringToFacetsXYReturnSweptFacets(linestringPoints, polyface);
     }
     /**
-     * Sweeps the linestring to intersections with a mesh.
+     * Sweep the line string to intersections with a mesh.
      * * Return collected line segments.
      * * If no options are given, the default sweep direction is the z-axis, and chains are assembled and returned.
      * * See [[SweepLineStringToFacetsOptions]] for input and output options, including filtering by forward/side/rear facets.
      * * Facets are ASSUMED to be convex and planar, and not overlap in the sweep direction.
      */
-    static sweepLineStringToFacets(linestringPoints, polyface, options) {
+    static sweepLineStringToFacets(linestringPoints, polyfaceOrVisitor, options) {
         let result = [];
         // setup default options:
         if (options === undefined)
@@ -916,7 +917,11 @@ class PolyfaceQuery {
             chainContext = ChainMergeContext.create();
         const context = ClipSweptLineStringContext.create(linestringPoints, options.vectorToEye);
         if (context) {
-            const visitor = polyface.createVisitor(0);
+            let visitor;
+            if (polyfaceOrVisitor instanceof Polyface)
+                visitor = polyfaceOrVisitor.createVisitor(0);
+            else
+                visitor = polyfaceOrVisitor;
             const workNormal = Vector3d.createZero();
             for (visitor.reset(); visitor.moveToNextFacet();) {
                 if (options.collectFromThisFacetNormal(PolygonOps.areaNormalGo(visitor.point, workNormal))) {
@@ -935,6 +940,54 @@ class PolyfaceQuery {
         }
         return result;
     }
+    /**
+     * Sweep the line string in the z-direction to intersections with a mesh, using a search object for speedup.
+     * @param lineStringPoints input line string to drape on the mesh
+     * @param polyfaceOrVisitor mesh, or mesh visitor to traverse only part of a mesh
+     * @param searchByReadIndex object for searching facet 2D ranges tagged by mesh read index
+     * @example Using a 5x5 indexed search grid:
+     * ```
+     * const xyRange = Range2d.createFrom(myPolyface.range());
+     * const searcher = GriddedRaggedRange2dSetWithOverflow.create<number>(xyRange, 5, 5)!;
+     * for (const visitor = myPolyface.createVisitor(0); visitor.moveToNextFacet();) {
+     *   searcher.addRange(visitor.point.getRange(), visitor.currentReadIndex());
+     * }
+     * const drapedLineStrings = PolyfaceQuery.sweepLineStringToFacetsXY(lineString, myPolyface, searcher);
+     * ```
+     * @returns collected line strings
+     */
+    static sweepLineStringToFacetsXY(lineStringPoints, polyfaceOrVisitor, searchByReadIndex) {
+        const chainContext = ChainMergeContext.create();
+        const sweepVector = Vector3d.create(0, 0, 1);
+        const searchRange = Range3d.create();
+        let visitor;
+        if (polyfaceOrVisitor instanceof Polyface)
+            visitor = polyfaceOrVisitor.createVisitor(0);
+        else
+            visitor = polyfaceOrVisitor;
+        let lineStringSource;
+        if (Array.isArray(lineStringPoints))
+            lineStringSource = new Point3dArrayCarrier(lineStringPoints);
+        else
+            lineStringSource = lineStringPoints;
+        for (let i = 1; i < lineStringSource.length; i++) {
+            const point0 = lineStringSource.getPoint3dAtUncheckedPointIndex(i - 1);
+            const point1 = lineStringSource.getPoint3dAtUncheckedPointIndex(i);
+            const edgeClipper = EdgeClipData.createPointPointSweep(point0, point1, sweepVector);
+            if (edgeClipper !== undefined) {
+                Range3d.createNull(searchRange);
+                searchRange.extendPoint(point0);
+                searchRange.extendPoint(point1);
+                searchByReadIndex.searchRange2d(searchRange, (_facetRange, readIndex) => {
+                    if (visitor.moveToReadIndex(readIndex))
+                        edgeClipper.processPolygon(visitor.point, (pointA, pointB) => chainContext.addSegment(pointA, pointB));
+                    return true;
+                });
+            }
+        }
+        chainContext.clusterAndMergeVerticesXYZ();
+        return chainContext.collectMaximalChains();
+    }
     /** Find segments (within the linestring) which project to facets.
       * * Return collected line segments.
       * * This calls [[sweepLineStringToFacets]] with options created by