@itwin/core-geometry 5.1.0-dev.9 → 5.2.0-dev.2

package/lib/esm/curve/RegionOpsClassificationSweeps.js

@@ -9,7 +9,7 @@ import { Geometry } from "../Geometry";
 import { Point3d, Vector3d } from "../geometry3d/Point3dVector3d";
 import { Range2d, Range3d } from "../geometry3d/Range";
 import { Ray3d } from "../geometry3d/Ray3d";
-import { HalfEdgeGraph, HalfEdgeMask } from "../topology/Graph";
+import { HalfEdge, HalfEdgeGraph, HalfEdgeMask } from "../topology/Graph";
 import { HalfEdgeGraphSearch } from "../topology/HalfEdgeGraphSearch";
 import { HalfEdgeGraphMerge } from "../topology/Merging";
 import { RegularizationContext } from "../topology/RegularizeFace";
@@ -18,6 +18,7 @@ import { CurveCurve } from "./CurveCurve";
 import { CurveLocationDetail } from "./CurveLocationDetail";
 import { GeometryQuery } from "./GeometryQuery";
 import { PlaneAltitudeRangeContext } from "./internalContexts/PlaneAltitudeRangeContext";
+import { TransferWithSplitArcs } from "./internalContexts/TransferWithSplitArcs";
 import { LineSegment3d } from "./LineSegment3d";
 import { Loop } from "./Loop";
 import { ParityRegion } from "./ParityRegion";
@@ -40,14 +41,22 @@ import { UnionRegion } from "./UnionRegion";
  * @internal
  */
 class RegionOpsFaceToFaceSearchCallbacks {
-    /** Announce a representative node on the outer face of a component */
-    startComponent(_node) { return true; }
-    /** Announce return to outer face */
-    finishComponent(_node) { return true; }
-    /** Announce face entry */
-    enterFace(_facePathStack, _newFaceNode) { return true; }
-    /** Announce face exit */
-    leaveFace(_facePathStack, _newFaceNode) { return true; }
+    /** Announce a representative node on the outer face of a component. */
+    startComponent(_node) {
+        return true;
+    }
+    /** Announce return to outer face. */
+    finishComponent(_node) {
+        return true;
+    }
+    /** Announce face entry. */
+    enterFace(_facePathStack, _newFaceNode) {
+        return true;
+    }
+    /** Announce face exit. */
+    leaveFace(_facePathStack, _newFaceNode) {
+        return true;
+    }
 }
 /**
  * Implementation of `RegionOpsFaceToFaceSearchCallbacks` for binary boolean sweep with polygonal regions.
@@ -110,14 +119,14 @@ class RegionOpsBinaryBooleanSweepCallbacks extends RegionOpsFaceToFaceSearchCall
  */
 export class RegionOpsFaceToFaceSearch {
     /**
-     * run a DFS with face-to-face step announcements.
+     * Run a DFS with face-to-face step announcements.
      * * false return from any function terminates search immediately.
      * * all reachable nodes assumed to have both visit masks clear.
      * @param graph containing graph.
      * @param seed first node to visit.
      * @param faceHasBeenVisited mask marking faces that have been seen.
      * @param nodeHasBeenVisited mask marking node-to-node step around face.
-     *
+     * @param callbacks callbacks.
      */
     static faceToFaceSearchFromOuterLoop(_graph, seed, faceHasBeenVisited, nodeHasBeenVisited, callbacks) {
         if (seed.isMaskSet(faceHasBeenVisited))
@@ -131,10 +140,10 @@ export class RegionOpsFaceToFaceSearch {
             let entryNode = faceWalker;
             let mate = faceWalker.edgeMate;
             if (!mate.isMaskSet(faceHasBeenVisited)) {
-                // the faceWalker seed is always on the base of the stack.
-                // the stack then contains even-odd pairs of (entryNode, currentNode)
-                // * entryNode is the node where a face was entered.
-                // * faceNode is another node around that face.
+                // The faceWalker seed is always on the base of the stack.
+                // The stack then contains even-odd pairs of (entryNode, faceNode).
+                // entryNode is the node where a face was entered.
+                // faceNode is another node around that face.
                 facePathStack.push(faceWalker);
                 facePathStack.push(mate);
                 let faceNode = mate.faceSuccessor;
@@ -165,13 +174,13 @@ export class RegionOpsFaceToFaceSearch {
                             entryNode = facePathStack[facePathStack.length - 1];
                         }
                         if (faceNode.isMaskSet(nodeHasBeenVisited)) {
-                            // this is disaster !!!
+                            // this is disaster
                             return;
                         }
                     }
                 }
             }
-            // continue at outermost level .....
+            // continue at outermost level
             faceWalker = faceWalker.faceSuccessor;
         } while (faceWalker !== seed);
         callbacks.finishComponent(seed);
@@ -292,7 +301,7 @@ export var RegionGroupOpType;
  * * a reference to the parent group (which in turn leads back to the `RegionBooleanContext`)
  * @internal
  */
-class RegionGroupMember {
+export class RegionGroupMember {
     region;
     sweepState;
     parentGroup;
@@ -301,7 +310,9 @@ class RegionGroupMember {
         this.parentGroup = parentGroup;
         this.sweepState = 0;
     }
-    clearState() { this.sweepState = 0; }
+    clearState() {
+        this.sweepState = 0;
+    }
 }
 /**
  * A `RegionGroup` is
@@ -340,8 +351,7 @@ export class RegionGroup {
         }
         return range;
     }
-    /** Ask if the current _numIn count qualifies as an "in" for this operation type.
-     */
+    /** Ask if the current _numIn count qualifies as an "in" for this operation type. */
     getInOut() {
         // UNION is true if one or more members are IN
         if (this.groupOpType === RegionGroupOpType.Union)
@@ -357,8 +367,9 @@ export class RegionGroup {
     // push new members into the group.
     addMember(data, allowLineSegment = false) {
         if (data instanceof Loop || data instanceof ParityRegion) {
-            const cleanerData = data.clone();
+            let cleanerData = data.clone();
             RegionOps.consolidateAdjacentPrimitives(cleanerData);
+            cleanerData = TransferWithSplitArcs.clone(cleanerData);
             this.members.push(new RegionGroupMember(cleanerData, this));
         }
         else if (data instanceof UnionRegion) {
@@ -388,28 +399,29 @@ export class RegionGroup {
 /**
  * A `RegionBooleanContext` carries structure and operations for binary operations between two sets of regions.
  * * In the binary operation OP (union, intersection, parity, difference), the left and right operands
- *     are each a composite union, difference, or parity among multiple inputs, i.e.
+ * are each a composite union, difference, or parity among multiple inputs, i.e.,
  *   * (operationA among Ai) OP (operationB among Bi)
  *   * where the Ai are one set of regions, being combined by operationA
- *   * and the Bi are the another set of regions, being combined by operationB
- * * Each group of Ai and Bi is a `RegionGroup`
+ *   * and the Bi are the another set of regions, being combined by operationB.
+ * * Each group of Ai and Bi is a `RegionGroup`.
  * * This is an extremely delicate structure.
  * * Members are public because of the unique variety of queries, but should only be used for queries.
  * * The graph and curves in the booleans are connected by an extended pointer chain:
- *    * (HalfEdge in Graph).edgeTag points to a CurveLocationDetail
- *    * (CurveLocationDetail).curve points to a curve
- *    * (Curve).parent points to RegionGroupMember
- *    * (RegionGroupMember) points to RegionGroup
- *    * (RegionGroup) points to RegionBooleanBinaryContext
- * * So..when a graph sweep crosses an edge,
- *    * the chain leads to a parity count in the RegionGroupMember
- *    * that can change the number of members active in the RegionGroup
+ *    * (HalfEdge in Graph).edgeTag points to a CurveLocationDetail.
+ *    * (CurveLocationDetail).curve points to a curve.
+ *    * (Curve).parent points to RegionGroupMember.
+ *    * (RegionGroupMember) points to RegionGroup.
+ *    * (RegionGroup) points to RegionBooleanBinaryContext.
+ * * So when a graph sweep crosses an edge
+ *    * the chain leads to a parity count in the RegionGroupMember.
+ *    * that can change the number of members active in the RegionGroup.
  *    * which can change the state of the context.
  * @internal
  */
 export class RegionBooleanContext {
     groupA;
     groupB;
+    /** bridge edges */
     extraGeometry;
     graph;
     faceAreaFunction;
@@ -418,7 +430,7 @@ export class RegionBooleanContext {
         this.groupA = new RegionGroup(this, groupTypeA);
         this.groupB = new RegionGroup(this, groupTypeB);
         this.extraGeometry = new RegionGroup(this, RegionGroupOpType.NonBounding);
-        this.binaryOp = RegionBinaryOpType.Union; // it will be revised on can calls.
+        this.binaryOp = RegionBinaryOpType.Union; // revised in runClassificationSweep
     }
     /**
      * Create a context with both A and B groups empty.
@@ -432,8 +444,6 @@ export class RegionBooleanContext {
     addMembers(dataA, dataB) {
         this.groupA.addMember(dataA);
         this.groupB.addMember(dataB);
-        // const doConnectives = 1;
-        // if (doConnectives !== 0)
         this.addConnectives();
     }
     _workSegment;
@@ -477,18 +487,106 @@ export class RegionBooleanContext {
         }
         const ray = Ray3d.createZero();
         for (const p of maxPoints) {
-            // Make a line from...
-            //  1) exactly the max point of the loops to
-            //  2) a point clearly outside the big range
-            // If p came from some inner loop this will...
-            //  1) create a bridge from the inner loop through any containing loops (always)
-            //  2) avoid crossing any containing loop at a vertex. (with high probability, but not absolutely always)
+            // Make a line from
+            //    1) exactly the max point of the loops to
+            //    2) a point clearly outside the big range
+            // If p came from some inner loop this will
+            //    1) create a bridge from the inner loop through any containing loops (always)
+            //    2) avoid crossing any containing loop at a vertex. (with high probability, but not absolutely always)
             const bridgeLength = margin + Ray3d.create(p, RegionBooleanContext._bridgeDirection, ray).intersectionWithRange3d(rangeAB).high;
             const outside = Point3d.createAdd2Scaled(p, 1.0, RegionBooleanContext._bridgeDirection, bridgeLength);
             const bridgeLine = LineSegment3d.createXYXY(p.x, p.y, outside.x, outside.y);
             this.extraGeometry.addMember(bridgeLine, true);
         }
     }
+    /**
+     * Simplify the graph by removing bridge edges that do not serve to connect inner and outer loops, i.e.:
+     * * the bridge edge is dangling
+     * * the bridge edge is adjacent to multiple faces
+     * * the bridge edge is adjacent to a negative area face
+     * @returns the number of extraneous bridge edges removed from the graph.
+     */
+    removeExtraneousBridgeEdges() {
+        const toHeal = [];
+        const interiorBridges = [];
+        // lambda test for boundary edge. Relies only on face loop orientation. Doesn't use HalfEdgeMasks!
+        const isExteriorEdge = (node) => {
+            if (this.faceAreaFunction(node) < 0.0)
+                return true;
+            if (!node.findAroundFace(node.edgeMate))
+                return this.faceAreaFunction(node.edgeMate) < 0.0;
+            return false;
+        };
+        // isolate dangling bridges, bridges separating different faces, and "exterior" bridges in the negative area face
+        this.graph.announceEdges((_graph, node) => {
+            if (node.edgeTag !== undefined) {
+                if (node.edgeTag instanceof CurveLocationDetail) {
+                    if (node.edgeTag.curve) {
+                        if (node.edgeTag.curve.parent instanceof RegionGroupMember) {
+                            if (node.edgeTag.curve.parent.parentGroup === this.extraGeometry) {
+                                if (node.isDangling || node.edgeMate.isDangling || !node.findAroundFace(node.edgeMate) || this.faceAreaFunction(node) < 0.0) {
+                                    toHeal.push(node.vertexSuccessor);
+                                    toHeal.push(node.edgeMate.vertexSuccessor);
+                                    node.isolateEdge();
+                                }
+                                else {
+                                    interiorBridges.push(node);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return true;
+        });
+        // At this point, all bridges that were exterior are isolated, but this may have caused formerly
+        // interior bridges to become exterior. Now we successively isolate exterior bridges until none remain.
+        let numIsolatedThisPass;
+        do {
+            numIsolatedThisPass = 0;
+            for (const node of interiorBridges) {
+                if (!node.isIsolatedEdge && isExteriorEdge(node)) {
+                    toHeal.push(node.vertexSuccessor);
+                    toHeal.push(node.edgeMate.vertexSuccessor);
+                    node.isolateEdge();
+                    numIsolatedThisPass++;
+                }
+            }
+        } while (numIsolatedThisPass > 0);
+        // lambda to extend the detail interval on a side of a healed edge
+        const mergeDetails = (he, newFraction, newPoint) => {
+            if (he && he.edgeTag instanceof CurveLocationDetail && he.sortData !== undefined && newFraction !== undefined && newPoint) {
+                if (he.sortData > 0)
+                    he.edgeTag.captureFraction1Point1(newFraction, newPoint);
+                else
+                    he.edgeTag.captureFractionPoint(newFraction, newPoint);
+            }
+        };
+        // At this point all removable bridges are isolated. Clean up their original vertex loops, if possible.
+        for (const doomedA of toHeal) {
+            const doomedB = doomedA.vertexSuccessor;
+            if ( // are the geometries mergeable?
+            doomedA !== doomedB &&
+                doomedA.edgeTag instanceof CurveLocationDetail && doomedA.sortData !== undefined &&
+                doomedB.edgeTag instanceof CurveLocationDetail && doomedB.sortData !== undefined &&
+                doomedA.edgeTag.curve === doomedB.edgeTag.curve &&
+                doomedA.edgeTag.hasFraction1 && doomedB.edgeTag.hasFraction1 &&
+                doomedA.sortData * doomedB.sortData < 0 &&
+                ((doomedA.sortData > 0 && Geometry.isSmallRelative(doomedA.edgeTag.fraction - doomedB.edgeTag.fraction1)) ||
+                    (doomedA.sortData < 0 && Geometry.isSmallRelative(doomedA.edgeTag.fraction1 - doomedB.edgeTag.fraction)))) {
+                const survivorA = HalfEdge.healEdge(doomedA, false);
+                if (survivorA) {
+                    const endFractionA = (doomedA.sortData > 0) ? doomedA.edgeTag.fraction1 : doomedA.edgeTag.fraction;
+                    const endPointA = (doomedA.sortData > 0) ? doomedA.edgeTag.point1 : doomedA.edgeTag.point;
+                    mergeDetails(survivorA, endFractionA, endPointA);
+                    const endFractionB = (doomedB.sortData > 0) ? doomedB.edgeTag.fraction1 : doomedB.edgeTag.fraction;
+                    const endPointB = (doomedB.sortData > 0) ? doomedB.edgeTag.point1 : doomedB.edgeTag.point;
+                    mergeDetails(survivorA.edgeMate, endFractionB, endPointB);
+                }
+            }
+        }
+        return this.graph.deleteIsolatedEdges();
+    }
     /**
      * Markup and assembly steps for geometry in the RegionGroups.
      * * Annotate connection from group to curves.
@@ -499,7 +597,7 @@ export class RegionBooleanContext {
      */
     annotateAndMergeCurvesInGraph(mergeTolerance = Geometry.smallMetricDistance) {
         const allPrimitives = [];
-        // ASSUME loops have fine-grained types -- no linestrings !!
+        // ASSUME loops have fine-grained types (no linestrings)
         for (const group of [this.groupA, this.groupB, this.extraGeometry]) {
             for (const member of group.members) {
                 let k = allPrimitives.length;
@@ -510,11 +608,11 @@ export class RegionBooleanContext {
                 }
             }
         }
-        //    const range = RegionOps.curveArrayRange(allPrimitives);
         const intersections = CurveCurve.allIntersectionsAmongPrimitivesXY(allPrimitives, mergeTolerance);
         const graph = PlanarSubdivision.assembleHalfEdgeGraph(allPrimitives, intersections, mergeTolerance);
         this.graph = graph;
         this.faceAreaFunction = faceAreaFromCurvedEdgeData;
+        this.removeExtraneousBridgeEdges();
     }
     _announceFaceFunction;
     /**
@@ -529,9 +627,8 @@ export class RegionBooleanContext {
         this._announceFaceFunction = announceFaceFunction;
         this.binaryOp = binaryOp;
         this.graph.clearMask(HalfEdgeMask.EXTERIOR);
-        for (const group of [this.groupA, this.groupB]) {
+        for (const group of [this.groupA, this.groupB])
             group.clearState();
-        }
         const faceHasBeenVisitedMask = this.graph.grabMask();
         const nodeHasBeenVisitedMask = this.graph.grabMask();
         const componentArray = GraphComponentArray.create(this.graph);
@@ -612,18 +709,19 @@ export class RegionBooleanContext {
         return undefined;
     }
     // obligations to act as sweep callback ...
-    /** Announce a representative node on the outer face of a component */
+    /** Announce a representative node on the outer face of a component. */
     startComponent(outerFaceNode) {
         outerFaceNode.setMaskAroundFace(HalfEdgeMask.EXTERIOR);
         if (this._announceFaceFunction)
             this._announceFaceFunction(this.graph, outerFaceNode, -1, faceAreaFromCurvedEdgeData(outerFaceNode));
         return true;
     }
-    /** Announce return to outer face */
+    /** Announce return to outer face. */
     finishComponent(_node) {
         return true;
     }
-    /** Announce entry to a graph face.
+    /**
+     * Announce entry to a graph face.
      * * Both both sides of a graph edge are from the same RegionGroupMember.
      * * Hence "crossing that edge" changes the parity count for the RegionGroupMember that owns that edge by 1.
      * * The parity count for other RegionGroupMembers are never affected by this crossing.
@@ -644,8 +742,9 @@ export class RegionBooleanContext {
         return true;
     }
 }
-/** return xy area between a (part of a) curve and the x axis through a reference point.
- * If detail is undefined or does not have both start and end fractions, just do trapezoid area
+/**
+ * Return xy area between (part of) a curve and the x axis through a reference point.
+ * If detail is undefined or does not have both start and end fractions, just do trapezoid area.
  */
 function areaUnderPartialCurveXY(detail, xyStart, xyEnd, referencePoint) {
     // area between trapezoid and axis
@@ -659,15 +758,21 @@ function areaUnderPartialCurveXY(detail, xyStart, xyEnd, referencePoint) {
     let areaToChord = 0.0;
     if (detail && detail.curve && detail.hasFraction1) {
         if (detail.curve instanceof LineSegment3d) {
-            // ah .. nothing to do for a line segment
+            // nothing to do for a line segment
         }
         else if (detail.curve instanceof Arc3d) {
             areaToChord = detail.curve.areaToChordXY(detail.fraction, detail.fraction1);
         }
+        else {
+            const partial = detail.curve.clonePartialCurve(detail.fraction, detail.fraction1);
+            areaToChord = partial ?
+                RegionOps.computeXYArea(Loop.create(partial, LineSegment3d.create(detail.point1, detail.point))) ?? 0
+                : 0;
+        }
     }
     return trapezoidArea + areaToChord;
 }
-/** Compute face area for a face whose edges are decorated with CurveLocationDetail for their (partial) curves */
+/** Compute face area for a face whose edges are decorated with CurveLocationDetail for their (partial) curves. */
 function faceAreaFromCurvedEdgeData(faceSeed) {
     let area = 0.0;
     let edge = faceSeed;
@@ -690,8 +795,7 @@ export class GraphComponent {
         this.faceAreas = [];
     }
     /**
-     * visit all vertices and edges in the component to build face area array and composite range.
-     *
+     * Visit all vertices and edges in the component to build face area array and composite range.
      * @param extendRangeForEdge optional function to compute edge range.  If undefined, linear edge is assumed.
      * @param faceAreaFunction optional function to compute face area.  If undefined, linear edges are assumed.
      */
@@ -715,7 +819,8 @@ export class GraphComponent {
         }
     }
 }
-/** build and hold an array of component data for a HalfEdgeGraph.
+/**
+ * Build and hold an array of component data for a HalfEdgeGraph.
  * @internal
  */
 export class GraphComponentArray {