@itwin/core-geometry 5.1.0-dev.3 → 5.1.0-dev.32

package/lib/esm/curve/RegionOps.js

@@ -5,14 +5,17 @@
 /** @packageDocumentation
  * @module Curve
  */
+import { assert } from "@itwin/core-bentley";
 import { Geometry } from "../Geometry";
+import { FrameBuilder } from "../geometry3d/FrameBuilder";
 import { GrowableXYZArray } from "../geometry3d/GrowableXYZArray";
 import { IndexedReadWriteXYZCollection, IndexedXYZCollection, } from "../geometry3d/IndexedXYZCollection";
 import { Point3dArrayCarrier } from "../geometry3d/Point3dArrayCarrier";
-import { Point3d } from "../geometry3d/Point3dVector3d";
+import { Point3d, Vector3d } from "../geometry3d/Point3dVector3d";
 import { PolygonOps } from "../geometry3d/PolygonOps";
 import { PolylineCompressionContext } from "../geometry3d/PolylineCompressionByEdgeOffset";
 import { Range3d } from "../geometry3d/Range";
+import { Ray3d } from "../geometry3d/Ray3d";
 import { SortablePolygon } from "../geometry3d/SortablePolygon";
 import { Transform } from "../geometry3d/Transform";
 import { MomentData } from "../geometry4d/MomentData";
@@ -29,6 +32,7 @@ import { CurveWireMomentsXYZ } from "./CurveWireMomentsXYZ";
 import { GeometryQuery } from "./GeometryQuery";
 import { ChainCollectorContext } from "./internalContexts/ChainCollectorContext";
 import { PolygonWireOffsetContext } from "./internalContexts/PolygonOffsetContext";
+import { TransferWithSplitArcs } from "./internalContexts/TransferWithSplitArcs";
 import { LineString3d } from "./LineString3d";
 import { Loop } from "./Loop";
 import { OffsetOptions } from "./OffsetOptions";
@@ -55,25 +59,29 @@ export var RegionBinaryOpType;
 })(RegionBinaryOpType || (RegionBinaryOpType = {}));
 /**
  * Class `RegionOps` has static members for calculations on regions (areas).
- * * Regions are represented by these `CurveCollection` subclasses:
- *   * `Loop` -- a single loop
- *   * `ParityRegion` -- a collection of loops, interpreted by parity rules.
- * The common "One outer loop and many Inner loops" is a parity region.
- *   * `UnionRegion` -- a collection of `Loop` and `ParityRegion` objects understood as a (probably disjoint) union.
- * * **NOTE:** Most of the methods in this class ignore z-coordinates, so callers should ensure that input geometry has
- * been rotated parallel to the xy-plane.
+ * * Regions are represented by these [[CurveCollection]] subclasses:
+ *   * [[Loop]] -- a single loop
+ *   * [[ParityRegion]] -- a collection of loops, interpreted by parity rules.
+ * The common "One outer loop and many inner loops" is a parity region.
+ *   * [[UnionRegion]] -- a collection of `Loop` and `ParityRegion` objects understood as a (probably disjoint) union.
+ * * Most of the methods in this class:
+ *   * Ignore z-coordinates, so callers should ensure that input geometry has been rotated parallel to the xy-plane.
+ *   * Assume consistent Loop orientation: "solid" Loops are counterclockwise; "hole" Loops are clockwise.
  * @public
  */
 export class RegionOps {
     /**
      * Return moment sums for a loop, parity region, or union region.
+     * * The input region should lie in a plane parallel to the xy-plane, as z-coords will be ignored.
      * * If `rawMomentData` is the MomentData returned by computeXYAreaMoments, convert to principal axes and moments with
-     *    call `principalMomentData = MomentData.inertiaProductsToPrincipalAxes (rawMomentData.origin, rawMomentData.sums);`
-     * @param root any Loop, ParityRegion, or UnionRegion.
+     * call `principalMomentData = MomentData.inertiaProductsToPrincipalAxes(rawMomentData.origin, rawMomentData.sums);`
+     * * `rawMomentData.origin` is the centroid of `region`.
+     * * `rawMomentData.sums.weight()` is the signed area of `region`.
+     * @param region any [[Loop]], [[ParityRegion]], or [[UnionRegion]].
      */
-    static computeXYAreaMoments(root) {
+    static computeXYAreaMoments(region) {
         const handler = new RegionMomentsXY();
-        const result = root.dispatchToGeometryHandler(handler);
+        const result = region.dispatchToGeometryHandler(handler);
         if (result instanceof MomentData) {
             result.shiftOriginAndSumsToCentroidOfSums();
             return result;
@@ -82,8 +90,8 @@ export class RegionOps {
     }
     /**
      * Return an area tolerance for a given xy-range and optional distance tolerance.
-     * @param range range of planar region to tolerance
-     * @param distanceTolerance optional absolute distance tolerance
+     * @param range range of planar region to tolerance.
+     * @param distanceTolerance optional absolute distance tolerance.
     */
     static computeXYAreaTolerance(range, distanceTolerance = Geometry.smallMetricDistance) {
         // if A = bh and e is distance tolerance, then A' := (b+e/2)(h+e/2) = A + e/2(b+h+e/2), so A'-A = e/2(b+h+e/2).
@@ -92,12 +100,14 @@ export class RegionOps {
     }
     /**
      * Return a (signed) xy area for a region.
-     * * The area is negative if and only if the region is oriented clockwise with respect to the positive z-axis.
-     * @param root any Loop, ParityRegion, or UnionRegion.
+     * * The input region should lie in a plane parallel to the xy-plane, as z-coords will be ignored.
+     * * For a non-self-intersecting Loop, the returned area is negative if and only if the Loop is oriented clockwise
+     * with respect to the positive z-axis.
+     * @param region any [[Loop]], [[ParityRegion]], or [[UnionRegion]].
      */
-    static computeXYArea(root) {
+    static computeXYArea(region) {
         const handler = new RegionMomentsXY();
-        const result = root.dispatchToGeometryHandler(handler);
+        const result = region.dispatchToGeometryHandler(handler);
         if (result instanceof MomentData) {
             return result.quantitySum;
         }
@@ -105,17 +115,56 @@ export class RegionOps {
     }
     /**
      * Return MomentData with the sums of wire moments.
+     * * The input curve should lie in a plane parallel to the xy-plane, as z-coords will be ignored.
      * * If `rawMomentData` is the MomentData returned by computeXYAreaMoments, convert to principal axes and moments with
-     *    call `principalMomentData = MomentData.inertiaProductsToPrincipalAxes (rawMomentData.origin, rawMomentData.sums);`
-     * @param root any CurveCollection or CurvePrimitive.
+     * call `principalMomentData = MomentData.inertiaProductsToPrincipalAxes (rawMomentData.origin, rawMomentData.sums);`
+     * * `rawMomentData.origin` is the wire centroid of `curve`.
+     * * `rawMomentData.sums.weight()` is the signed length of `curve`.
+     * @param curve any [[CurveCollection]] or [[CurvePrimitive]].
      */
-    static computeXYZWireMomentSums(root) {
+    static computeXYZWireMomentSums(curve) {
         const handler = new CurveWireMomentsXYZ();
-        handler.visitLeaves(root);
+        handler.visitLeaves(curve);
         const result = handler.momentData;
         result.shiftOriginAndSumsToCentroidOfSums();
         return result;
     }
+    /**
+     * Return a [[Ray3d]] with:
+     * * `origin` is the centroid of the region,
+     * * `direction` is a unit vector perpendicular to the region plane,
+     * * `a` is the region area.
+     * @param region the region to process. Can lie in any plane.
+     * @param result optional pre-allocated result to populate and return.
+     */
+    static centroidAreaNormal(region, result) {
+        const localToWorld = FrameBuilder.createRightHandedFrame(undefined, region);
+        if (!localToWorld)
+            return undefined;
+        const normal = localToWorld.matrix.columnZ(result?.direction);
+        const regionIsXY = normal.isParallelTo(Vector3d.unitZ(), true);
+        let regionXY = region;
+        if (!regionIsXY) { // rotate the region to be parallel to the xy-plane
+            regionXY = region.cloneTransformed(localToWorld.inverse());
+            if (!regionXY)
+                return undefined;
+        }
+        const momentData = RegionOps.computeXYAreaMoments(regionXY);
+        if (!momentData)
+            return undefined;
+        const centroid = momentData.origin.clone(result?.origin);
+        if (!regionIsXY) // rotate centroid back (area is unchanged)
+            localToWorld.multiplyPoint3d(centroid, centroid);
+        let area = momentData.sums.weight();
+        if (area < 0.0) {
+            area = -area;
+            normal.scale(-1.0, normal);
+        }
+        if (!result)
+            result = Ray3d.createCapture(centroid, normal);
+        result.a = area;
+        return result;
+    }
     /**
      * Create loops in the graph.
      * @internal
@@ -233,21 +282,73 @@ export class RegionOps {
         const graph = RegionOpsFaceToFaceSearch.doPolygonBoolean(loopsA, loopsB, (inA, inB) => (inA && !inB), this._graphCheckPointFunction);
         return this.finishGraphToPolyface(graph, triangulate);
     }
+    /**
+     * Return the region's simplest representation by stripping redundant parent(s).
+     * * No Boolean operations are performed.
+     * @param region input region (unchanged). Assumed to have at least one child.
+     * @returns
+     * * For a [[UnionRegion]] with exactly one child, return the child if it is a [[Loop]],
+     * or if it is a [[ParityRegion]] with multiple children; otherwise return the `ParityRegion`'s `Loop`.
+     * * For a `ParityRegion` with exactly one child, return the `Loop`.
+     * * All other inputs returned unchanged.
+     * @see [[simplifyRegion]]
+     */
+    static simplifyRegionType(region) {
+        if (region instanceof UnionRegion) {
+            if (region.children.length === 1)
+                return this.simplifyRegionType(region.children[0]);
+        }
+        else if (region instanceof ParityRegion) {
+            if (region.children.length === 1)
+                return region.children[0];
+        }
+        return region;
+    }
+    /**
+     * Simplify the region's parent/child hierarchy in place:
+     * * Regions with exactly one child are simplified as per [[simplifyRegionType]].
+     * * Regions without children are removed.
+     * * No Boolean operations are performed.
+     * @param region region to simplify in place
+     * @returns reference to the updated input region
+     * @see [[simplifyRegionType]]
+     */
+    static simplifyRegion(region) {
+        if (region instanceof Loop)
+            return region.children.length > 0 ? region : undefined;
+        // remove childless Parity/UnionRegion
+        for (let i = 0; i < region.children.length; ++i) {
+            const child = region.children[i];
+            const newChild = this.simplifyRegion(child);
+            if (!newChild) {
+                region.children.splice(i--, 1);
+            }
+            else if (newChild !== child) {
+                assert(!(newChild instanceof UnionRegion));
+                region.children.splice(i--, 1, newChild);
+            }
+        }
+        if (region.children.length === 0)
+            return undefined;
+        // remove redundant Parity/UnionRegion parent
+        if (region.children.length === 1)
+            return region.children.splice(0, 1)[0];
+        return region;
+    }
     /**
      * Return areas defined by a boolean operation.
-     * * If there are multiple regions in loopsA, they are treated as a union.
-     * * If there are multiple regions in loopsB, they are treated as a union.
-     * @param loopsA first set of loops
-     * @param loopsB second set of loops
+     * @note For best results, input regions should have correctly oriented loops. See [[sortOuterAndHoleLoopsXY]].
+     * @note A common use case of this method is to convert a region with overlapping children into one with
+     * non-overlapping children: `regionOut = RegionOps.regionBooleanXY(regionIn, undefined, RegionBinaryOpType.Union)`.
+     * @param loopsA first set of loops (treated as a union)
+     * @param loopsB second set of loops (treated as a union)
      * @param operation indicates Union, Intersection, Parity, AMinusB, or BMinusA
      * @param mergeTolerance absolute distance tolerance for merging loops
      * @returns a region resulting from merging input loops and the boolean operation. May contain bridge edges added
      * to connect interior loops to exterior loops.
      */
     static regionBooleanXY(loopsA, loopsB, operation, mergeTolerance = Geometry.smallMetricDistance) {
-        // Always return UnionRegion for now. But keep return type as AnyRegion:
-        // in the future, we might return the *simplest* region type.
-        const result = UnionRegion.create();
+        let result;
         const context = RegionBooleanContext.create(RegionGroupOpType.Union, RegionGroupOpType.Union);
         context.addMembers(loopsA, loopsB);
         context.annotateAndMergeCurvesInGraph(mergeTolerance);
@@ -261,11 +362,14 @@ export class RegionOps {
                 return;
             if (faceType === 1) {
                 const loop = PlanarSubdivision.createLoopInFace(face);
-                if (loop)
+                if (loop) {
+                    if (!result)
+                        result = UnionRegion.create();
                     result.tryAddChild(loop);
+                }
             }
         });
-        return result;
+        return result ? this.simplifyRegion(result) : undefined;
     }
     /**
      * Return a polyface whose facets are a boolean operation between the input regions.
@@ -556,14 +660,15 @@ export class RegionOps {
         curves.dispatchToGeometryHandler(context);
     }
     /**
-     * Reverse and reorder loops in the xy-plane for consistency and containment.
-     * @param loops multiple loops in any order and orientation, z-coordinates ignored
+     * Reverse and reorder loops in the xy-plane for consistent orientation and containment.
+     * @param loops multiple loops in any order and orientation, z-coordinates ignored.
+     * * For best results, all overlaps should be containments, i.e., loop boundaries can touch, but should not cross.
      * @returns a region that captures the input pointers. This region is a:
-     * * `Loop` if there is exactly one input loop. It is oriented counterclockwise.
-     * * `ParityRegion` if input consists of exactly one outer loop with at least one hole loop.
+     * * [[Loop]] if there is exactly one input loop. It is oriented counterclockwise.
+     * * [[ParityRegion]] if input consists of exactly one outer loop with at least one hole loop.
      * Its first child is an outer loop oriented counterclockwise; all subsequent children are holes oriented
      * clockwise.
-     * * `UnionRegion` if any other input configuration. Its children are individually ordered/oriented as in
+     * * [[UnionRegion]] if any other input configuration. Its children are individually ordered/oriented as in
      * the above cases.
      * @see [[PolygonOps.sortOuterAndHoleLoopsXY]]
      */
@@ -583,14 +688,14 @@ export class RegionOps {
      * Find all xy-areas bounded by the unstructured, possibly intersecting curves.
      * * For best results, input curves should be parallel to the xy-plane, as z-coordinates are ignored.
      * * A common use case of this method is to assemble the bounding "exterior" loop (or loops) containing the
-     * input curves.
+     * input curves. Note that "holes" implied by inputs are _not_ preserved in output.
      * * This method does not add bridge edges to connect outer loops to inner loops. Each disconnected loop,
      * regardless of its containment, is returned as its own SignedLoops object. Pre-process with [[regionBooleanXY]]
      * to add bridge edges so that [[constructAllXYRegionLoops]] will return outer and inner loops in the same
      * SignedLoops object.
      * @param curvesAndRegions Any collection of curves. Each Loop/ParityRegion/UnionRegion contributes its curve
-     * primitives.
-     * @param tolerance optional distance tolerance for coincidence
+     * primitives, stripped of parity context. This means holes are _not_ preserved in output.
+     * @param tolerance optional distance tolerance for coincidence.
      * @returns array of [[SignedLoops]], each entry of which describes the faces in a single connected component:
      *    * `positiveAreaLoops` contains "interior" loops, _including holes in ParityRegion input_. These loops have
      * positive area and counterclockwise orientation.
@@ -600,7 +705,8 @@ export class RegionOps {
      * to the edge and a constituent curve in each.
      */
     static constructAllXYRegionLoops(curvesAndRegions, tolerance = Geometry.smallMetricDistance) {
-        const primitives = RegionOps.collectCurvePrimitives(curvesAndRegions, undefined, true, true);
+        let primitives = RegionOps.collectCurvePrimitives(curvesAndRegions, undefined, true, true);
+        primitives = TransferWithSplitArcs.clone(BagOfCurves.create(...primitives)).children;
         const range = this.curveArrayRange(primitives);
         const areaTol = this.computeXYAreaTolerance(range, tolerance);
         const intersections = CurveCurve.allIntersectionsAmongPrimitivesXY(primitives, tolerance);
@@ -753,12 +859,10 @@ export class RegionOps {
     }
     /**
      * Facet the region according to stroke options.
+     * @note For best results, [[UnionRegion]] input should consist of non-overlapping children. See [[regionBooleanXY]].
+     * @note For best results, [[ParityRegion]] input should be correctly oriented. See [[sortOuterAndHoleLoopsXY]].
      * @param region a closed xy-planar region, possibly with holes.
      * * The z-coordinates of the region are ignored. Caller is responsible for rotating the region into plane local coordinates beforehand, and reversing the rotation afterwards.
-     * * For best results, `UnionRegion` input should consist of non-overlapping children.
-     * Caller can ensure this by passing in `region = RegionOps.regionBooleanXY(unionRegion, undefined, RegionBinaryOpType.Union)`.
-     * * For best results, `ParityRegion` input should be correctly oriented (holes have opposite orientation to their containing loop).
-     * Caller can ensure this for non-intersecting loops by passing in `region = RegionOps.sortOuterAndHoleLoopsXY(loops)`.
      * @param options primarily how to stroke the region boundary, but also how to facet the region interior.
      * * By default, a triangulation is returned, but if `options.maximizeConvexFacets === true`, edges between coplanar triangles are removed to return maximally convex facets.
      * @returns facets for the region, or undefined if facetting failed
@@ -821,17 +925,19 @@ function pushToInOnOutArrays(curve, select, arrayNegative, array0, arrayPositive
         array0.push(curve);
 }
 /**
- * * Options to control method `RegionOps.consolidateAdjacentPrimitives`
+ * * Options to control method `RegionOps.consolidateAdjacentPrimitives`.
  * @public
  */
 export class ConsolidateAdjacentCurvePrimitivesOptions {
-    /** True to consolidate adjacent linear geometry into a single LineString3d */
+    /** True to consolidate adjacent linear geometry into a single LineString3d. */
     consolidateLinearGeometry = true;
-    /** True to consolidate contiguous compatible arcs into a single Arc3d */
+    /** True to consolidate contiguous compatible arcs into a single Arc3d. */
     consolidateCompatibleArcs = true;
-    /** Tolerance for collapsing identical points */
+    /** Disable LineSegment3d and LineString3d point compression. */
+    disableLinearCompression = false;
+    /** Tolerance for collapsing identical points (if `!disableLinearCompression`). */
     duplicatePointTolerance = Geometry.smallMetricDistance;
-    /** Tolerance for removing interior colinear points. */
+    /** Tolerance for removing interior colinear points (if `!disableLinearCompression`). */
     colinearPointTolerance = Geometry.smallMetricDistance;
 }
 //# sourceMappingURL=RegionOps.js.map