@itwin/core-geometry 5.2.0-dev.29 → 5.2.0-dev.30

package/lib/esm/topology/Graph.js

@@ -5,7 +5,7 @@
 /** @packageDocumentation
  * @module Topology
  */
-import { OrderedSet } from "@itwin/core-bentley";
+import { assert, OrderedSet } from "@itwin/core-bentley";
 import { LineSegment3d } from "../curve/LineSegment3d";
 import { Geometry } from "../Geometry";
 import { Angle } from "../geometry3d/Angle";
@@ -135,9 +135,12 @@ export class HalfEdge {
     get edgeMate() {
         return this._edgeMate;
     }
+    /** HalfEdge ids are sequentially assigned per session (not per graph!). */
     static _totalNodesCreated = 0;
     constructor(x = 0, y = 0, z = 0, i = 0) {
         this._id = HalfEdge._totalNodesCreated++;
+        if (!Number.isSafeInteger(HalfEdge._totalNodesCreated))
+            HalfEdge._totalNodesCreated = 0;
         this.i = i;
         this.maskBits = 0x00000000;
         this.x = x;
@@ -367,6 +370,16 @@ export class HalfEdge {
     clearMask(mask) {
         this.maskBits &= ~mask;
     }
+    /** Set or clear mask bits from this HalfEdge.
+     * @param mask mask bits
+     * @param clear whether to clear the mask. Default is false (set the mask).
+     */
+    applyMask(mask, clear = false) {
+        if (clear)
+            this.clearMask(mask);
+        else
+            this.setMask(mask);
+    }
     /**
      * Set a mask at all nodes around a vertex.
      * @param mask mask to apply to the half edges around this HalfEdge's vertex loop.
@@ -642,21 +655,17 @@ export class HalfEdge {
     }
     /**
      * Create an edge with initial id,x,y at each end.
-     * @param id0 id for first node.
      * @param x0 x coordinate for first node.
      * @param y0 y coordinate for first node.
-     * @param id1 id for second node.
      * @param x1 x coordinate for second node.
      * @param y1 y coordinate for second node.
      * @returns the reference to the new node at (x0,y0).
      */
-    static createEdgeXYXY(id0, x0, y0, id1, x1, y1) {
+    static createEdgeXYXY(x0, y0, x1, y1) {
         const node0 = new HalfEdge(x0, y0);
         const node1 = new HalfEdge(x1, y1);
         node0._faceSuccessor = node0._facePredecessor = node0._edgeMate = node1;
         node1._faceSuccessor = node1._facePredecessor = node1._edgeMate = node0;
-        node0._id = id0;
-        node1._id = id1;
         return node0;
     }
     /**
@@ -970,18 +979,19 @@ export class HalfEdge {
     /**
      * Announce edges in the super face loop, starting with the instance.
      * * A super face admits a `faceSuccessor` traversal, where the next edge at the far vertex is the first one lacking `skipMask` in a `vertexPredecessor` traversal.
-     * @param skipMask mask on edges to skip.
-     * @param announceEdge function to call at each edge that is not skipped.
-     * @param announceSkipped optional function to call at each edge that is skipped.
-     * @return whether a super face was found. Specifically, if a vertex loop has all edges with `skipMask` set, the return value is `false`.
+     * @param skipEdge mask preset on edges to skip, or a function that is called to decide whether to skip an edge.
+     * @param announceEdge function that is called at each edge that is not skipped.
+     * @param announceSkipped optional function that is called at each edge that is skipped.
+     * @return whether a super face was found, or `false` if the traversal fails to return to the instance vertex.
      */
-    announceEdgesInSuperFace(skipMask, announceEdge, announceSkipped) {
-        const maxIter = 1000; // safeguard against infinite loops
+    announceEdgesInSuperFace(skipEdge, announceEdge, announceSkipped) {
+        const maxIter = 10000; // safeguard against infinite loops
         let iter = 0;
+        const mySkipEdge = skipEdge instanceof Function ? skipEdge : (he) => he.isMaskSet(skipEdge);
         const findNextNodeAroundVertex = (he) => {
             let vNode = he;
             do {
-                if (!vNode.isMaskSet(skipMask))
+                if (!mySkipEdge(vNode))
                     return vNode;
                 announceSkipped?.(vNode);
                 vNode = vNode.vertexPredecessor;
@@ -998,6 +1008,7 @@ export class HalfEdge {
             if (!node)
                 return false;
         } while (node !== firstNode && iter++ < maxIter);
+        assert(iter < maxIter, "Infinite loop detected in HalfEdge.announceEdgesInSuperFace");
         return iter < maxIter;
     }
     /**
@@ -1048,6 +1059,17 @@ export class HalfEdge {
         } while (node !== this);
         return nodes;
     }
+    /**
+     * Announce edges in the vertex loop, starting with the instance and proceeding in a `vertexSuccessor` traversal.
+     * @param announceEdge function to call at each edge
+     */
+    announceEdgesAroundVertex(announceEdge) {
+        let node = this;
+        do {
+            announceEdge(node);
+            node = node.vertexSuccessor;
+        } while (node !== this);
+    }
     /**
      * Evaluate `f(node)` at each node around `this` node's face loop. Sum the function values.
      * @param f node to number function.
@@ -1320,7 +1342,6 @@ export class HalfEdgeGraph {
     /** Simple array with pointers to all the half edges in the graph. */
     allHalfEdges;
     _maskManager;
-    _numNodesCreated = 0;
     constructor() {
         this.allHalfEdges = [];
         this._maskManager = MaskManager.create(HalfEdgeMask.ALL_GRAB_DROP_MASKS);
@@ -1447,13 +1468,24 @@ export class HalfEdgeGraph {
     }
     /**
      * Create two nodes of a new edge.
+     * @param x0 x-coordinate of the start node.
+     * @param y0 y-coordinate of the start node.
+     * @param x1 x-coordinate of the end node.
+     * @param y1 y-coordinate of the end node.
+     * @param edgeTag0 (optional) edge tag for the start node.
+     * @param edgeTag1 (optional) edge tag for the end node.
+     * @param faceTag0 (optional) face tag for the start node.
+     * @param faceTag1 (optional) face tag for the end node.
      * @returns the reference to the new node at (x0,y0).
      */
-    addEdgeXY(x0, y0, x1, y1) {
-        const baseNode = HalfEdge.createEdgeXYXY(this._numNodesCreated, x0, y0, this._numNodesCreated + 1, x1, y1);
-        this._numNodesCreated += 2;
-        this.allHalfEdges.push(baseNode);
-        this.allHalfEdges.push(baseNode.faceSuccessor);
+    addEdgeXY(x0, y0, x1, y1, edgeTag0, edgeTag1, faceTag0, faceTag1) {
+        const baseNode = HalfEdge.createEdgeXYXY(x0, y0, x1, y1);
+        const farNode = baseNode.faceSuccessor;
+        baseNode.edgeTag = edgeTag0;
+        baseNode.faceTag = faceTag0;
+        farNode.edgeTag = edgeTag1;
+        farNode.faceTag = faceTag1;
+        this.allHalfEdges.push(baseNode, farNode);
         return baseNode;
     }
     /** Clear selected `mask` bits in all nodes of the graph. */
@@ -1468,9 +1500,8 @@ export class HalfEdgeGraph {
     }
     /** Toggle selected `mask` bits in all nodes of the graph. */
     reverseMask(mask) {
-        for (const node of this.allHalfEdges) {
+        for (const node of this.allHalfEdges)
             node.maskBits ^= mask;
-        }
     }
     /**
      * Return the number of nodes that have a specified mask bit set.
@@ -1491,10 +1522,9 @@ export class HalfEdgeGraph {
      */
     collectSegments() {
         const segments = [];
-        for (const node of this.allHalfEdges) {
+        for (const node of this.allHalfEdges)
             if (node.id < node.edgeMate.id)
-                segments.push(LineSegment3d.create(Point3d.create(node.x, node.y), Point3d.create(node.faceSuccessor.x, node.faceSuccessor.y)));
-        }
+                segments.push(LineSegment3d.createXYXY(node.x, node.y, node.faceSuccessor.x, node.faceSuccessor.y));
         return segments;
     }
     /** Returns the number of vertex loops in a graph structure. */
@@ -1656,5 +1686,43 @@ export class HalfEdgeGraph {
         this.allHalfEdges.length = numAccepted;
         return numDeleted;
     }
+    /**
+     * Construct a map from id to vertex index.
+     * * For a given HalfEdge `e`, the key is `e.id` and the value is the minimum index in `graph.allHalfEdges` of all edges in the vertex loop of `e`.
+    */
+    constructIdToVertexIndexMap() {
+        const idToIndexMap = new Map();
+        this.allHalfEdges.forEach((e, i) => idToIndexMap.set(e.id, i));
+        this.announceVertexLoops((_g, vertex) => {
+            let minIndex = this.allHalfEdges.length;
+            vertex.announceEdgesAroundVertex((e) => {
+                const index = idToIndexMap.get(e.id);
+                if (index !== undefined && index < minIndex)
+                    minIndex = index;
+            });
+            vertex.announceEdgesAroundVertex((e) => idToIndexMap.set(e.id, minIndex));
+            return true;
+        });
+        return idToIndexMap;
+    }
+    /**
+     * Construct a map from id to face index.
+     * * For a given HalfEdge `e`, the key is `e.id` and the value is the minimum index in `graph.allHalfEdges` of all edges in the face loop of `e`.
+    */
+    constructIdToFaceIndexMap() {
+        const idToIndexMap = new Map();
+        this.allHalfEdges.forEach((e, i) => idToIndexMap.set(e.id, i));
+        this.announceFaceLoops((_g, face) => {
+            let minIndex = this.allHalfEdges.length;
+            face.announceEdgesInFace((e) => {
+                const index = idToIndexMap.get(e.id);
+                if (index !== undefined && index < minIndex)
+                    minIndex = index;
+            });
+            face.announceEdgesInFace((e) => idToIndexMap.set(e.id, minIndex));
+            return true;
+        });
+        return idToIndexMap;
+    }
 }
 //# sourceMappingURL=Graph.js.map