@itwin/core-geometry 4.4.0-dev.9 → 4.5.0-dev.0

package/lib/cjs/topology/HalfEdgeGraphSearch.js

@@ -8,14 +8,17 @@ exports.HalfEdgeGraphSearch = exports.HalfEdgeMaskTester = void 0;
 /** @packageDocumentation
  * @module Topology
  */
+const Range_1 = require("../geometry3d/Range");
 const Graph_1 = require("./Graph");
 const SignedDataSummary_1 = require("./SignedDataSummary");
 const XYParitySearchContext_1 = require("./XYParitySearchContext");
 /**
+ * Class to test match of half edge mask.
+ * @internal
  */
 class HalfEdgeMaskTester {
     /**
-     *
+     * Constructor
      * @param mask mask to test in `testEdge` function
      * @param targetValue value to match for true return
      */
@@ -23,48 +26,31 @@ class HalfEdgeMaskTester {
         this._targetMask = mask;
         this._targetValue = targetValue;
     }
-    /** Return true if the value of the targetMask matches the targetValue */
+    /** Return true if the value of the targetMask matches the targetValue. */
     testEdge(edge) {
         return edge.isMaskSet(this._targetMask) === this._targetValue;
     }
 }
 exports.HalfEdgeMaskTester = HalfEdgeMaskTester;
-// Search services for HalfEdgeGraph
+/**
+ * Class for different types of searches for HalfEdgeGraph.
+ *  @internal
+ */
 class HalfEdgeGraphSearch {
     /**
-     * * for each node of face, set the mask push to allNodesStack
-     * * push the faceSeed on onePerFaceStack[]
-     */
-    static pushAndMaskAllNodesInFace(faceSeed, mask, allNodeStack, onePerFaceStack) {
-        onePerFaceStack.push(faceSeed);
-        faceSeed.collectAroundFace((node) => {
-            node.setMask(mask);
-            allNodeStack.push(node);
-        });
-    }
-    /**
-     * Search an array of faceSeed nodes for the face with the most negative area.
-     * @param oneCandidateNodePerFace array containing one node from each face to be considered.
-     * @returns node on the minimum area face, or undefined if no such face (e.g., all faces have zero area).
-     */
-    static findMinimumAreaFace(oneCandidateNodePerFace, faceAreaFunction) {
-        const summary = HalfEdgeGraphSearch.collectFaceAreaSummary(oneCandidateNodePerFace, false, faceAreaFunction);
-        return summary.largestNegativeItem;
-    }
-    /**
-     * static method for face area computation -- useful as function parameter in collect FaceAreaSummary.
-     * * This simply calls `node.signedFaceArea ()`
+     * Static method for face area computation -- useful as function parameter in `collectFaceAreaSummary`.
+     * * This simply calls `node.signedFaceArea()`
      * @param node instance for signedFaceArea call.
      */
-    static signedFaceArea(node) { return node.signedFaceArea(); }
+    static signedFaceArea(node) {
+        return node.signedFaceArea();
+    }
     /**
-     *
-     * Return a summary structure data about face (or other numeric quantity if the caller's areaFunction returns other value)
-     * * The default areaFunction computes area of polygonal face.
+     * Return a summary of face data (e.g., area) as computed by the callback on the faces of the graph.
      * * Callers with curved edge graphs must supply their own area function.
-     * @param source graph or array of nodes to examine
-     * @param collectAllNodes flag to pass to the SignedDataSummary constructor to control collection of nodes.
-     * @param areaFunction function to all to obtain area (or other numeric value)
+     * @param source graph or array of nodes to examine.
+     * @param collectAllNodes flag to pass to the `SignedDataSummary` constructor to control collection of nodes.
+     * @param areaFunction function to obtain area (or other numeric value). Default computes polygonal face area.
      */
     static collectFaceAreaSummary(source, collectAllNodes = false, areaFunction = (node) => HalfEdgeGraphSearch.signedFaceArea(node)) {
         const result = new SignedDataSummary_1.SignedDataSummary(collectAllNodes);
@@ -80,10 +66,19 @@ class HalfEdgeGraphSearch {
         return result;
     }
     /**
-     * * Test if the graph is triangulated.
-     * * Return false if:
-     *   * Positive area face with more than 3 edges
-     *   * more than 1 negative area face with `allowMultipleNegativeAreaFaces` false
+     * Search the graph for the face with the most negative area.
+     * @param oneCandidateNodePerFace graph or an array containing one node from each face to be considered.
+     * @returns node on the negative area face with largest absolute area, or `undefined` if no negative area face.
+     */
+    static findMinimumAreaFace(oneCandidateNodePerFace, faceAreaFunction) {
+        const summary = HalfEdgeGraphSearch.collectFaceAreaSummary(oneCandidateNodePerFace, false, faceAreaFunction);
+        return summary.largestNegativeItem;
+    }
+    /**
+     * Test if the graph is triangulated.
+     * * Return `false` if:
+     *   * number of positive area faces with more than 3 edges is larger than `numPositiveExceptionsAllowed`.
+     *   * graph has more than 1 negative area face when `allowMultipleNegativeAreaFaces` is `false`.
      * * 2-edge faces are ignored.
      */
     static isTriangulatedCCW(source, allowMultipleNegativeAreaFaces = true, numPositiveExceptionsAllowed = 0) {
@@ -117,24 +112,41 @@ class HalfEdgeGraphSearch {
         return true;
     }
     /**
-     * Search to all accessible faces from given seed.
-     * * The returned array contains one representative node in each face of the connected component.
-     * * If (nonnull) parity mask is given, on return:
-     *    * It is entirely set or entirely clear around each face
-     *    * It is entirely set on all faces that are an even number of face-to-face steps away from the seed.
-     *    * It is entirely clear on all faces that are an odd number of face-to-face steps away from the seed.
-     * @param seedEdge first edge to search.
+     * Process a face during graph traversal.
+     * @param faceSeed a node in the face.
+     * @param mask mask to set on each node of the face.
+     * @param allNodeStack array appended with each node of the face.
+     * @param onePerFaceStack array appended with `faceSeed`.
+     */
+    static pushAndMaskAllNodesInFace(faceSeed, mask, allNodeStack, onePerFaceStack) {
+        onePerFaceStack.push(faceSeed);
+        faceSeed.collectAroundFace((node) => {
+            node.setMask(mask);
+            allNodeStack.push(node);
+        });
+    }
+    /**
+     * Traverse (via Depth First Search) to all accessible faces from the given seed.
+     * @param faceSeed first node to start the traverse.
      * @param visitMask mask applied to all faces as visited.
-     * @param parityMask mask to apply (a) to first face, (b) to faces with alternating parity during the search.
+     * @param parityEdgeTester function to test if an edge is adjacent to two faces of opposite parity, e.g., a boundary
+     * edge that separates an "interior" face and an "exterior" face. If `parityEdgeTester` is not supplied and `parityMask`
+     * is supplied, the default parity rule is to alternate parity state in a "bullseye" pattern starting at the seed face,
+     * with each successive concentric ring of faces at constant topological distance from the seed face receiving the
+     * opposite parity state of the previous ring.
+     * @param parityMask mask to apply to the first face and faces that share the same parity as the first face, as
+     * determined by the parity rule. If this is `NULL_MASK`, there is no record of parity. If (non-null) parity mask
+     * is given, on return it is entirely set or entirely clear around each face.
+     * @returns an array that contains one representative node in each face of the connected component.
      */
-    static parityFloodFromSeed(seedEdge, visitMask, parityEdgeTester, parityMask) {
+    static parityFloodFromSeed(faceSeed, visitMask, parityEdgeTester, parityMask) {
         const faces = [];
-        if (seedEdge.isMaskSet(visitMask))
-            return faces; // empty
+        if (faceSeed.isMaskSet(visitMask))
+            return faces; // empty array
         const allMasks = parityMask | visitMask;
         const stack = [];
-        // arbitrarily call the seed face exterior ... others will alternate as visited.
-        HalfEdgeGraphSearch.pushAndMaskAllNodesInFace(seedEdge, allMasks, stack, faces); // Start with exterior as mask
+        // the seed face is arbitrarily assigned the parity mask
+        HalfEdgeGraphSearch.pushAndMaskAllNodesInFace(faceSeed, allMasks, stack, faces);
         while (stack.length > 0) {
             const p = stack.pop();
             const mate = p.edgeMate;
@@ -150,113 +162,216 @@ class HalfEdgeGraphSearch {
         return faces;
     }
     /**
-     * * Search the given faces for the one with the minimum area.
-     * * If the mask in that face is OFF, toggle it on (all half edges of) all the faces.
+     * * Correct the parity mask in the faces of a component.
+     * * It is assumed that the parity mask is applied _consistently_ throughout the supplied faces, but maybe
+     * not _correctly_.
+     * * A consistently applied parity mask is "correct" if it is set on the negative area ("exterior") face of
+     * a connected component.
+     * * This method finds a face with negative area and toggles the mask throughout the input faces if this face
+     * lacks the parity mask.
      * * In a properly merged planar subdivision there should be only one true negative area face per component.
-     * @param graph parent graph
-     * @param parityMask mask which was previously set with alternating parity, but with an arbitrary start face.
-     * @param faces array of faces to search.
      */
-    static correctParityInSingleComponent(_graph, mask, faces) {
+    static correctParityInSingleComponent(parityMask, faces) {
         const exteriorHalfEdge = HalfEdgeGraphSearch.findMinimumAreaFace(faces);
         if (!exteriorHalfEdge) {
+            // graph has all degenerate faces; do nothing
         }
-        else if (exteriorHalfEdge.isMaskSet(mask)) {
-            // all should be well .. nothing to do.
+        else if (exteriorHalfEdge.isMaskSet(parityMask)) {
+            // all should be well; nothing to do
         }
         else {
-            // TOGGLE around the face (assuming all are consistent with the seed)
             for (const faceSeed of faces) {
-                if (faceSeed.isMaskSet(mask)) {
-                    faceSeed.clearMaskAroundFace(mask);
+                if (faceSeed.isMaskSet(parityMask)) {
+                    faceSeed.clearMaskAroundFace(parityMask);
                 }
                 else {
-                    faceSeed.setMaskAroundFace(mask);
+                    faceSeed.setMaskAroundFace(parityMask);
                 }
             }
         }
     }
-    /** Apply correctParityInSingleComponent to each array in components. (Quick exit if mask in NULL_MASK) */
-    static correctParityInComponentArrays(graph, mask, components) {
-        if (mask === Graph_1.HalfEdgeMask.NULL_MASK)
+    /** Apply `correctParityInSingleComponent` to each array in components (quick exit if `parityMask` is `NULL_MASK`). */
+    static correctParityInComponentArrays(parityMask, components) {
+        if (parityMask === Graph_1.HalfEdgeMask.NULL_MASK)
             return;
         for (const facesInComponent of components)
-            HalfEdgeGraphSearch.correctParityInSingleComponent(graph, mask, facesInComponent);
+            HalfEdgeGraphSearch.correctParityInSingleComponent(parityMask, facesInComponent);
     }
     /**
-     * Collect arrays gathering faces by connected component.
-     * @param graph graph to inspect
-     * @param parityEdgeTester (optional) function to test if an edge is a parity change (e.g., a boundary edge).
-     * @param parityMask (optional, along with parityEdgeTester) mask to apply indicating parity.  If this is Mask.NULL_MASK, there is no record of parity.
+     * Collect connected components of the graph (via Depth First Search).
+     * @param graph graph to inspect.
+     * @param parityEdgeTester (optional) function to test if an edge is adjacent to two faces of opposite parity,
+     * e.g., a boundary edge that separates an "interior" face and an "exterior" face. If `parityEdgeTester` is not
+     * supplied and `parityMask` is supplied, the default parity rule is to alternate parity state in a "bullseye"
+     * pattern starting at the seed face, with each successive concentric ring of faces at constant topological
+     * distance from the seed face receiving the opposite parity state of the previous ring.
+     * @param parityMask (optional) mask to apply to the first face and faces that share the same parity as the
+     * first face, as determined by the parity rule. If this is `NULL_MASK`, there is no record of parity. If
+     * (non-null) parity mask is given, on return it is entirely set or entirely clear around each face.
+     * @returns the components of the graph, each component represented by an array of nodes, one node per face
+     * of the component. In other words, entry [i][j] is a HalfEdge in the j_th face loop of the i_th component.
      */
     static collectConnectedComponentsWithExteriorParityMasks(graph, parityEdgeTester, parityMask = Graph_1.HalfEdgeMask.NULL_MASK) {
+        // Illustration of the algorithm can be found at geometry/internaldocs/Graph.md
         const components = [];
         const visitMask = Graph_1.HalfEdgeMask.VISITED;
         const allMasks = parityMask | visitMask;
         graph.clearMask(allMasks);
         for (const faceSeed of graph.allHalfEdges) {
-            if (!faceSeed.isMaskSet(Graph_1.HalfEdgeMask.VISITED)) {
+            if (!faceSeed.isMaskSet(visitMask)) {
                 const newFaces = HalfEdgeGraphSearch.parityFloodFromSeed(faceSeed, visitMask, parityEdgeTester, parityMask);
+                // parityFloodFromSeed does not return an empty array because it is called on an unvisited faceSeed
                 components.push(newFaces);
             }
         }
-        HalfEdgeGraphSearch.correctParityInComponentArrays(graph, parityMask, components);
+        HalfEdgeGraphSearch.correctParityInComponentArrays(parityMask, components);
+        return components;
+    }
+    /**
+     * Breadth First Search through connected component of a graph.
+     * @param component vector of nodes, one per face.
+     * @param seed seed node in component.
+     * @param visitMask mask to apply to visited nodes. Assumed cleared throughout component.
+     * @param ignoreMask (optional) mask preset on faces to ignore. Default value is `HalfEdgeMask.EXTERIOR` to
+     * ignore exterior faces. Pass `HalfEdgeMask.NULL_MASK` to process all faces.
+     * @param maxFaceCount (optional) maximum number of faces in the component. Should be positive; otherwise
+     * `Infinity` is used.
+     * @returns node at which to start next component if maximum face count exceeded, or undefined.
+     */
+    static exploreComponent(component, seed, visitMask, ignoreMask = Graph_1.HalfEdgeMask.EXTERIOR, maxFaceCount = Infinity) {
+        if (maxFaceCount <= 0)
+            maxFaceCount = Infinity;
+        const boundaryMask = visitMask | ignoreMask;
+        let numFaces = 0;
+        const candidates = []; // the queue
+        candidates.push(seed);
+        while (candidates.length !== 0 && numFaces < maxFaceCount) {
+            // shift is O(n) and may be inefficient for large queues; if needed, we can replace
+            // queue by circular array or implement the queue using 2 stacks; both are O(1)
+            const node = candidates.shift();
+            if (node.isMaskSet(boundaryMask))
+                continue;
+            component.push(node);
+            ++numFaces;
+            const enqueueNeighboringFaces = (heNode) => {
+                heNode.setMask(visitMask);
+                const neighbor = heNode.vertexSuccessor;
+                if (!neighbor.isMaskSet(boundaryMask))
+                    candidates.push(neighbor);
+            };
+            node.collectAroundFace(enqueueNeighboringFaces);
+        }
+        if (candidates.length === 0)
+            return undefined;
+        else {
+            const front = candidates[0];
+            while (candidates.length !== 0) {
+                // try to find a node at the boundary of both the geometry and previous component
+                const node = candidates.shift(); // shift may be inefficient for large queues
+                if (node.vertexSuccessor.isMaskSet(ignoreMask))
+                    return node;
+                if (node.edgeMate.isMaskSet(ignoreMask))
+                    return node;
+            }
+            return front;
+        }
+    }
+    /**
+     * Collect connected components of the graph (via Breadth First Search).
+     * @param graph graph to inspect.
+     * @param maxFaceCount (optional) maximum number of faces in each component. Should be positive; otherwise
+     * `Infinity` is used.
+     * @param ignoreMask (optional) mask preset on faces to ignore. Default value is `HalfEdgeMask.EXTERIOR` to ignore
+     * exterior faces. Pass `HalfEdgeMask.NULL_MASK` to process all faces.
+     * @returns the components of the graph, each component represented by an array of nodes, one node per face
+     * of the component. In other words, entry [i][j] is a HalfEdge in the j_th face loop of the i_th component.
+     */
+    static collectConnectedComponents(graph, maxFaceCount = Infinity, ignoreMask = Graph_1.HalfEdgeMask.EXTERIOR) {
+        const components = [];
+        if (graph.countMask(ignoreMask) === 0)
+            ignoreMask = Graph_1.HalfEdgeMask.NULL_MASK;
+        const visitMask = Graph_1.HalfEdgeMask.VISITED;
+        const boundaryMask = visitMask | ignoreMask;
+        // Starting with the input node, look ahead for a boundary face. Failing that, return the input node.
+        // Starting all floods at the boundary reduces the chance of ending up with a ring-shaped component at the boundary.
+        const findNextFloodSeed = (index) => {
+            for (let i = index; i < graph.countNodes(); ++i) {
+                if (!graph.allHalfEdges[i].isMaskSet(boundaryMask)
+                    && graph.allHalfEdges[i].edgeMate.isMaskSet(boundaryMask)) {
+                    index = i;
+                    break;
+                }
+            }
+            return index;
+        };
+        for (let i = 0; i < graph.countNodes(); ++i) {
+            if (graph.allHalfEdges[i].isMaskSet(boundaryMask))
+                continue;
+            const i0 = findNextFloodSeed(i);
+            let seed = graph.allHalfEdges[i0];
+            do { // flood this component
+                const component = [];
+                seed = HalfEdgeGraphSearch.exploreComponent(component, seed, visitMask, ignoreMask, maxFaceCount);
+                if (component.length !== 0)
+                    components.push(component);
+            } while (seed !== undefined);
+            if (!graph.allHalfEdges[i].isMaskSet(visitMask))
+                --i; // reprocess this node
+        }
         return components;
     }
     /**
-     * Test if (x,y) is inside (1), on an edge (0) or outside (-1) a face.
-     * @param seedNode any node on the face loop
-     * @param x x coordinate of test point.
-     * @param y y coordinate of test point.
+     * Test if test point (xTest,yTest) is inside/outside a face or on an edge.
+     * @param seedNode any node on the face loop.
+     * @param xTest x coordinate of the test point.
+     * @param yTest y coordinate of the test point.
+     * @returns 0 if ON, 1 if IN, -1 if OUT.
      */
-    static pointInOrOnFaceXY(seedNode, x, y) {
-        const context = new XYParitySearchContext_1.XYParitySearchContext(x, y);
-        // walk around looking for an accepted node to start the search (seedNode is usually ok!)
+    static pointInOrOnFaceXY(seedNode, xTest, yTest) {
+        const context = new XYParitySearchContext_1.XYParitySearchContext(xTest, yTest);
+        // walk around looking for an accepted node to start the search (seedNode is usually ok)
         let nodeA = seedNode;
         let nodeB = seedNode.faceSuccessor;
         for (;; nodeA = nodeB) {
             if (context.tryStartEdge(nodeA.x, nodeA.y, nodeB.x, nodeB.y))
                 break;
             if (nodeB === seedNode) {
-                // umm.. the face is all on the x axis?
-                return context.classifyCounts();
+                // the test point and the face are all on line "y = yTest"
+                const range = Range_1.Range1d.createXX(nodeB.x, nodeB.faceSuccessor.x);
+                return range.containsX(xTest) ? 0 : -1;
             }
             nodeB = nodeA.faceSuccessor;
         }
-        // nodeB is the real start node for search ... emit ends of each edge around the face,
-        //   stopping after emitting nodeB as an edge end.
-        let node = nodeB.faceSuccessor;
+        // nodeB is the real start node for search, so stop when we revisit it. For each edge, accumulate parity and hits
+        let nodeC = nodeB.faceSuccessor;
         for (;;) {
-            if (!context.advance(node.x, node.y)) {
+            if (!context.advance(nodeC.x, nodeC.y)) {
                 return context.classifyCounts();
             }
-            if (node === nodeB)
+            if (nodeC === nodeB)
                 break;
-            node = node.faceSuccessor;
+            nodeC = nodeC.faceSuccessor;
         }
         return context.classifyCounts();
     }
     /**
-     * Announce nodes that are "extended face boundary" by conditions (usually mask of node and mate) in test functions.
-     * * After each node, the next candidate in reached by looking "around the head vertex loop" for the next boundary.
-     *   * "Around the vertex" from nodeA means
-     *      * First look at nodeA.faceSuccessor;
-     *      * Then look at vertexPredecessor around that vertex loop.
-     * * Each accepted node is passed to announceNode, and marked with the visit mask.
-     * * The counter of the announceEdge function is zero for the first edge, then increases with each edge.
+     * Collect boundary edges starting from `seed`.
+     * * If `seed` is not a boundary node or is already visited, the function exists early.
      * @param seed start node.
-     * @param isBoundaryEdge
-     * @param announceEdge
+     * @param visitMask mask to set on processed nodes.
+     * @param isBoundaryEdge function to test if an edge in a boundary edge.
+     * @param announceEdgeInBoundary callback invoked on each edge in the boundary loop in order. The counter is zero
+     * for the first edge, and incremented with each successive edge.
      */
-    static collectExtendedBoundaryLoopFromSeed(seed, visitMask, isBoundaryEdge, announceEdge) {
+    static collectExtendedBoundaryLoopFromSeed(seed, visitMask, isBoundaryEdge, announceEdgeInBoundary) {
         let counter = 0;
         while (!seed.getMask(visitMask) && isBoundaryEdge(seed)) {
-            announceEdge(seed, counter++);
+            announceEdgeInBoundary(seed, counter++);
             seed.setMask(visitMask);
             const vertexBase = seed.faceSuccessor;
             let candidateAroundVertex = vertexBase;
             for (;;) {
-                if (candidateAroundVertex.getMask(visitMask))
+                if (candidateAroundVertex.getMask(visitMask)) // end of boundary loop
                     return;
                 if (isBoundaryEdge(candidateAroundVertex)) {
                     seed = candidateAroundVertex;
@@ -264,23 +379,22 @@ class HalfEdgeGraphSearch {
                 }
                 candidateAroundVertex = candidateAroundVertex.vertexPredecessor;
                 if (candidateAroundVertex === vertexBase)
-                    break;
+                    break; // prevent infinite loop in case exteriorMask is not set on the edge mate of the boundary edge
             }
         }
     }
     /**
-     * Collect arrays of nodes "around the boundary" of a graph with extraneous (non-boundary) edges.
-     * * The "boundary" is nodes that do NOT have the exterior mask, but whose mates DO have the exterior mask.
-     * * After each node, the next candidate in reached by looking "around the head vertex loop" for the next boundary.
-     *   * "Around the vertex" from nodeA means
-     *      * First look at nodeA.faceSuccessor;
-     *      * Then look at vertexPredecessor around that vertex loop.
-     * * Each accepted node is passed to announceNode, and marked with the visit mask.
-     * @param seed start node.
-     * @param isBoundaryNode
-     * @param announceNode
+     * Collect boundary edges in the graph.
+     * * A boundary edge is defined by `exteriorMask` being set on only its "exterior" edge mate.
+     * * Each boundary edge is identified in the output by its edge mate that lacks `exteriorMask`.
+     * * Each inner array is ordered in the output so that its boundary edges form a connected path. If `exteriorMask`
+     * is preset consistently around each "exterior" face, these paths are loops.
+     * @param graph the graph to query
+     * @param exteriorMask mask preset on exactly one side of boundary edges
+     * @returns array of boundary loops, each loop an array of the unmasked mates of boundary edges
      */
     static collectExtendedBoundaryLoopsInGraph(graph, exteriorMask) {
+        // Illustration of the algorithm can be found at geometry/internaldocs/Graph.md
         const loops = [];
         const visitMask = graph.grabMask(true);
         const isBoundaryEdge = (edge) => {

package/lib/cjs/topology/HalfEdgeGraphSearch.js.map

@@ -1 +1 @@
-{"version":3,"file":"HalfEdgeGraphSearch.js","sourceRoot":"","sources":["../../../src/topology/HalfEdgeGraphSearch.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n\r\n/** @packageDocumentation\r\n * @module Topology\r\n */\r\n\r\nimport { HalfEdge, HalfEdgeGraph, HalfEdgeMask, HalfEdgeToBooleanFunction, NodeToNumberFunction } from \"./Graph\";\r\nimport { SignedDataSummary } from \"./SignedDataSummary\";\r\nimport { XYParitySearchContext } from \"./XYParitySearchContext\";\r\n\r\n/**\r\n * Interface for an object that executes boolean tests on edges.\r\n */\r\nexport interface HalfEdgeTestObject {\r\n  testEdge(h: HalfEdge): boolean;\r\n}\r\n/**\r\n */\r\nexport class HalfEdgeMaskTester {\r\n  private _targetMask: HalfEdgeMask;\r\n  private _targetValue: boolean;\r\n  /**\r\n   *\r\n   * @param mask mask to test in `testEdge` function\r\n   * @param targetValue value to match for true return\r\n   */\r\n  public constructor(mask: HalfEdgeMask, targetValue: boolean = true) {\r\n    this._targetMask = mask;\r\n    this._targetValue = targetValue;\r\n  }\r\n  /** Return true if the value of the targetMask matches the targetValue */\r\n  public testEdge(edge: HalfEdge): boolean {\r\n    return edge.isMaskSet(this._targetMask) === this._targetValue;\r\n  }\r\n\r\n}\r\n// Search services for HalfEdgeGraph\r\nexport class HalfEdgeGraphSearch {\r\n\r\n  /**\r\n   * * for each node of face, set the mask push to allNodesStack\r\n   * * push the faceSeed on onePerFaceStack[]\r\n   */\r\n  private static pushAndMaskAllNodesInFace(faceSeed: HalfEdge, mask: number, allNodeStack: HalfEdge[], onePerFaceStack: HalfEdge[]) {\r\n    onePerFaceStack.push(faceSeed);\r\n    faceSeed.collectAroundFace((node: HalfEdge) => {\r\n      node.setMask(mask);\r\n      allNodeStack.push(node);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Search an array of faceSeed nodes for the face with the most negative area.\r\n   * @param oneCandidateNodePerFace array containing one node from each face to be considered.\r\n   * @returns node on the minimum area face, or undefined if no such face (e.g., all faces have zero area).\r\n   */\r\n  public static findMinimumAreaFace(oneCandidateNodePerFace: HalfEdgeGraph | HalfEdge[], faceAreaFunction?: NodeToNumberFunction): HalfEdge | undefined {\r\n    const summary = HalfEdgeGraphSearch.collectFaceAreaSummary(oneCandidateNodePerFace, false, faceAreaFunction);\r\n    return summary.largestNegativeItem;\r\n  }\r\n\r\n  /**\r\n   * static method for face area computation -- useful as function parameter in collect FaceAreaSummary.\r\n   * * This simply calls `node.signedFaceArea ()`\r\n   * @param node instance for signedFaceArea call.\r\n   */\r\n  public static signedFaceArea(node: HalfEdge): number { return node.signedFaceArea(); }\r\n  /**\r\n   *\r\n   * Return a summary structure data about face (or other numeric quantity if the caller's areaFunction returns other value)\r\n   * * The default areaFunction computes area of polygonal face.\r\n   * * Callers with curved edge graphs must supply their own area function.\r\n   * @param source graph or array of nodes to examine\r\n   * @param collectAllNodes flag to pass to the SignedDataSummary constructor to control collection of nodes.\r\n   * @param areaFunction function to all to obtain area (or other numeric value)\r\n   */\r\n  public static collectFaceAreaSummary(source: HalfEdgeGraph | HalfEdge[], collectAllNodes: boolean = false,\r\n    areaFunction: NodeToNumberFunction = (node) => HalfEdgeGraphSearch.signedFaceArea(node)): SignedDataSummary<HalfEdge> {\r\n    const result = new SignedDataSummary<HalfEdge>(collectAllNodes);\r\n    let allFaces: HalfEdge[];\r\n\r\n    if (source instanceof HalfEdgeGraph)\r\n      allFaces = source.collectFaceLoops();\r\n    else\r\n      allFaces = source;\r\n\r\n    for (const node of allFaces) {\r\n      const area = areaFunction(node);\r\n      result.announceItem(node, area);\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * * Test if the graph is triangulated.\r\n   * * Return false if:\r\n   *   * Positive area face with more than 3 edges\r\n   *   * more than 1 negative area face with `allowMultipleNegativeAreaFaces` false\r\n   * * 2-edge faces are ignored.\r\n   */\r\n  public static isTriangulatedCCW(source: HalfEdgeGraph | HalfEdge[], allowMultipleNegativeAreaFaces: boolean = true, numPositiveExceptionsAllowed = 0): boolean {\r\n    let allFaces: HalfEdge[];\r\n\r\n    if (source instanceof HalfEdgeGraph)\r\n      allFaces = source.collectFaceLoops();\r\n    else\r\n      allFaces = source;\r\n    let numNegative = 0;\r\n    let numPositiveExceptions = 0;\r\n    for (const node of allFaces) {\r\n      const numEdges = node.countEdgesAroundFace();\r\n      if (numEdges >= 3) {\r\n        const area = node.signedFaceArea();\r\n        if (area > 0) {\r\n          if (numEdges > 3) {\r\n            numPositiveExceptions++;\r\n            if (numPositiveExceptions > numPositiveExceptionsAllowed)\r\n              return false;\r\n          }\r\n        } else {\r\n          numNegative++;\r\n          if (numNegative > 1) {\r\n            if (!allowMultipleNegativeAreaFaces)\r\n              return false;\r\n          }\r\n        }\r\n      }\r\n    }\r\n    return true;\r\n  }\r\n\r\n  /**\r\n   * Search to all accessible faces from given seed.\r\n   * * The returned array contains one representative node in each face of the connected component.\r\n   * * If (nonnull) parity mask is given, on return:\r\n   *    * It is entirely set or entirely clear around each face\r\n   *    * It is entirely set on all faces that are an even number of face-to-face steps away from the seed.\r\n   *    * It is entirely clear on all faces that are an odd number of face-to-face steps away from the seed.\r\n   * @param seedEdge first edge to search.\r\n   * @param visitMask mask applied to all faces as visited.\r\n   * @param parityMask mask to apply (a) to first face, (b) to faces with alternating parity during the search.\r\n   */\r\n  private static parityFloodFromSeed(seedEdge: HalfEdge, visitMask: HalfEdgeMask, parityEdgeTester: HalfEdgeTestObject | undefined, parityMask: HalfEdgeMask): HalfEdge[] {\r\n    const faces: HalfEdge[] = [];\r\n    if (seedEdge.isMaskSet(visitMask)) return faces; // empty\r\n\r\n    const allMasks = parityMask | visitMask;\r\n    const stack: HalfEdge[] = [];\r\n    // arbitrarily call the seed face exterior ... others will alternate as visited.\r\n    HalfEdgeGraphSearch.pushAndMaskAllNodesInFace(seedEdge, allMasks, stack, faces);  // Start with exterior as mask\r\n    while (stack.length > 0) {\r\n      const p = stack.pop()!;\r\n      const mate = p.edgeMate;\r\n      if (!mate)\r\n        continue;\r\n      if (!mate.isMaskSet(visitMask)) {\r\n        let newState = p.isMaskSet(parityMask);\r\n        if (!parityEdgeTester || parityEdgeTester.testEdge(p))\r\n          newState = !newState;\r\n        HalfEdgeGraphSearch.pushAndMaskAllNodesInFace(mate, newState ? allMasks : visitMask, stack, faces);\r\n      }\r\n    }\r\n    return faces;\r\n  }\r\n  /**\r\n   * * Search the given faces for the one with the minimum area.\r\n   * * If the mask in that face is OFF, toggle it on (all half edges of) all the faces.\r\n   * * In a properly merged planar subdivision there should be only one true negative area face per component.\r\n   * @param graph parent graph\r\n   * @param parityMask mask which was previously set with alternating parity, but with an arbitrary start face.\r\n   * @param faces array of faces to search.\r\n   */\r\n  private static correctParityInSingleComponent(_graph: HalfEdgeGraph, mask: HalfEdgeMask, faces: HalfEdge[]) {\r\n    const exteriorHalfEdge = HalfEdgeGraphSearch.findMinimumAreaFace(faces);\r\n    if (!exteriorHalfEdge) {\r\n    } else if (exteriorHalfEdge.isMaskSet(mask)) {\r\n      // all should be well .. nothing to do.\r\n    } else {\r\n      // TOGGLE around the face (assuming all are consistent with the seed)\r\n      for (const faceSeed of faces) {\r\n        if (faceSeed.isMaskSet(mask)) {\r\n          faceSeed.clearMaskAroundFace(mask);\r\n        } else {\r\n          faceSeed.setMaskAroundFace(mask);\r\n        }\r\n      }\r\n    }\r\n  }\r\n  /** Apply correctParityInSingleComponent to each array in components. (Quick exit if mask in NULL_MASK) */\r\n  private static correctParityInComponentArrays(graph: HalfEdgeGraph, mask: HalfEdgeMask, components: HalfEdge[][]) {\r\n    if (mask === HalfEdgeMask.NULL_MASK)\r\n      return;\r\n    for (const facesInComponent of components)\r\n      HalfEdgeGraphSearch.correctParityInSingleComponent(graph, mask, facesInComponent);\r\n  }\r\n  /**\r\n   * Collect arrays gathering faces by connected component.\r\n   * @param graph graph to inspect\r\n   * @param parityEdgeTester (optional) function to test if an edge is a parity change (e.g., a boundary edge).\r\n   * @param parityMask (optional, along with parityEdgeTester) mask to apply indicating parity.  If this is Mask.NULL_MASK, there is no record of parity.\r\n   */\r\n  public static collectConnectedComponentsWithExteriorParityMasks(graph: HalfEdgeGraph, parityEdgeTester: HalfEdgeTestObject | undefined, parityMask: HalfEdgeMask = HalfEdgeMask.NULL_MASK): HalfEdge[][] {\r\n    const components = [];\r\n    const visitMask = HalfEdgeMask.VISITED;\r\n    const allMasks = parityMask | visitMask;\r\n    graph.clearMask(allMasks);\r\n    for (const faceSeed of graph.allHalfEdges) {\r\n      if (!faceSeed.isMaskSet(HalfEdgeMask.VISITED)) {\r\n        const newFaces = HalfEdgeGraphSearch.parityFloodFromSeed(faceSeed, visitMask, parityEdgeTester, parityMask);\r\n        components.push(newFaces);\r\n      }\r\n    }\r\n    HalfEdgeGraphSearch.correctParityInComponentArrays(graph, parityMask, components);\r\n    return components;\r\n  }\r\n  /**\r\n   * Test if (x,y) is inside (1), on an edge (0) or outside (-1) a face.\r\n   * @param seedNode any node on the face loop\r\n   * @param x x coordinate of test point.\r\n   * @param y y coordinate of test point.\r\n   */\r\n  public static pointInOrOnFaceXY(seedNode: HalfEdge, x: number, y: number): number | undefined {\r\n    const context = new XYParitySearchContext(x, y);\r\n    // walk around looking for an accepted node to start the search (seedNode is usually ok!)\r\n    let nodeA = seedNode;\r\n    let nodeB = seedNode.faceSuccessor;\r\n    for (; ; nodeA = nodeB) {\r\n      if (context.tryStartEdge(nodeA.x, nodeA.y, nodeB.x, nodeB.y))\r\n        break;\r\n      if (nodeB === seedNode) {\r\n        // umm.. the face is all on the x axis?\r\n        return context.classifyCounts();\r\n      }\r\n      nodeB = nodeA.faceSuccessor;\r\n    }\r\n\r\n    // nodeB is the real start node for search ... emit ends of each edge around the face,\r\n    //   stopping after emitting nodeB as an edge end.\r\n    let node = nodeB.faceSuccessor;\r\n    for (; ;) {\r\n      if (!context.advance(node.x, node.y)) {\r\n        return context.classifyCounts();\r\n      }\r\n      if (node === nodeB)\r\n        break;\r\n      node = node.faceSuccessor;\r\n    }\r\n    return context.classifyCounts();\r\n  }\r\n  /**\r\n   * Announce nodes that are \"extended face boundary\" by conditions (usually mask of node and mate) in test functions.\r\n   * * After each node, the next candidate in reached by looking \"around the head vertex loop\" for the next boundary.\r\n   *   * \"Around the vertex\" from nodeA means\r\n   *      * First look at nodeA.faceSuccessor;\r\n   *      * Then look at vertexPredecessor around that vertex loop.\r\n   * * Each accepted node is passed to announceNode, and marked with the visit mask.\r\n   * * The counter of the announceEdge function is zero for the first edge, then increases with each edge.\r\n   * @param seed start node.\r\n   * @param isBoundaryEdge\r\n   * @param announceEdge\r\n   */\r\n  public static collectExtendedBoundaryLoopFromSeed(seed: HalfEdge, visitMask: HalfEdgeMask, isBoundaryEdge: HalfEdgeToBooleanFunction,\r\n    announceEdge: (edge: HalfEdge, counter: number) => void) {\r\n    let counter = 0;\r\n    while (!seed.getMask(visitMask) && isBoundaryEdge(seed)) {\r\n      announceEdge(seed, counter++);\r\n      seed.setMask(visitMask);\r\n      const vertexBase = seed.faceSuccessor;\r\n      let candidateAroundVertex = vertexBase;\r\n      for (; ;) {\r\n        if (candidateAroundVertex.getMask(visitMask))\r\n          return;\r\n        if (isBoundaryEdge(candidateAroundVertex)) {\r\n          seed = candidateAroundVertex;\r\n          break;\r\n        }\r\n        candidateAroundVertex = candidateAroundVertex.vertexPredecessor;\r\n        if (candidateAroundVertex === vertexBase)\r\n          break;\r\n      }\r\n    }\r\n  }\r\n  /**\r\n   * Collect arrays of nodes \"around the boundary\" of a graph with extraneous (non-boundary) edges.\r\n   * * The \"boundary\" is nodes that do NOT have the exterior mask, but whose mates DO have the exterior mask.\r\n   * * After each node, the next candidate in reached by looking \"around the head vertex loop\" for the next boundary.\r\n   *   * \"Around the vertex\" from nodeA means\r\n   *      * First look at nodeA.faceSuccessor;\r\n   *      * Then look at vertexPredecessor around that vertex loop.\r\n   * * Each accepted node is passed to announceNode, and marked with the visit mask.\r\n   * @param seed start node.\r\n   * @param isBoundaryNode\r\n   * @param announceNode\r\n   */\r\n  public static collectExtendedBoundaryLoopsInGraph(graph: HalfEdgeGraph, exteriorMask: HalfEdgeMask): HalfEdge[][] {\r\n    const loops: HalfEdge[][] = [];\r\n    const visitMask = graph.grabMask(true);\r\n    const isBoundaryEdge = (edge: HalfEdge): boolean => {\r\n      return edge.getMask(exteriorMask) === 0 && edge.edgeMate.getMask(exteriorMask) !== 0;\r\n    };\r\n    const announceEdgeInBoundary = (edge: HalfEdge, counter: number) => {\r\n      if (counter === 0)\r\n        loops.push([]);\r\n      loops[loops.length - 1].push(edge);\r\n    };\r\n    for (const seed of graph.allHalfEdges) {\r\n      this.collectExtendedBoundaryLoopFromSeed(seed, visitMask, isBoundaryEdge, announceEdgeInBoundary);\r\n    }\r\n    graph.dropMask(visitMask);\r\n    return loops;\r\n  }\r\n}\r\n"]}
+{"version":3,"file":"HalfEdgeGraphSearch.js","sourceRoot":"","sources":["../../../src/topology/HalfEdgeGraphSearch.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\n\n/** @packageDocumentation\n * @module Topology\n */\nimport { Range1d } from \"../geometry3d/Range\";\nimport { HalfEdge, HalfEdgeGraph, HalfEdgeMask, HalfEdgeToBooleanFunction, NodeFunction, NodeToNumberFunction } from \"./Graph\";\nimport { SignedDataSummary } from \"./SignedDataSummary\";\nimport { XYParitySearchContext } from \"./XYParitySearchContext\";\n\n// cspell:word internaldocs\n\n/**\n * Interface for an object that executes boolean tests on edges.\n * @internal\n */\nexport interface HalfEdgeTestObject {\n  testEdge(h: HalfEdge): boolean;\n}\n/**\n * Class to test match of half edge mask.\n * @internal\n */\nexport class HalfEdgeMaskTester {\n  private _targetMask: HalfEdgeMask;\n  private _targetValue: boolean;\n  /**\n   * Constructor\n   * @param mask mask to test in `testEdge` function\n   * @param targetValue value to match for true return\n   */\n  public constructor(mask: HalfEdgeMask, targetValue: boolean = true) {\n    this._targetMask = mask;\n    this._targetValue = targetValue;\n  }\n  /** Return true if the value of the targetMask matches the targetValue. */\n  public testEdge(edge: HalfEdge): boolean {\n    return edge.isMaskSet(this._targetMask) === this._targetValue;\n  }\n}\n/**\n * Class for different types of searches for HalfEdgeGraph.\n *  @internal\n */\nexport class HalfEdgeGraphSearch {\n  /**\n   * Static method for face area computation -- useful as function parameter in `collectFaceAreaSummary`.\n   * * This simply calls `node.signedFaceArea()`\n   * @param node instance for signedFaceArea call.\n   */\n  public static signedFaceArea(node: HalfEdge): number {\n    return node.signedFaceArea();\n  }\n  /**\n   * Return a summary of face data (e.g., area) as computed by the callback on the faces of the graph.\n   * * Callers with curved edge graphs must supply their own area function.\n   * @param source graph or array of nodes to examine.\n   * @param collectAllNodes flag to pass to the `SignedDataSummary` constructor to control collection of nodes.\n   * @param areaFunction function to obtain area (or other numeric value). Default computes polygonal face area.\n   */\n  public static collectFaceAreaSummary(\n    source: HalfEdgeGraph | HalfEdge[],\n    collectAllNodes: boolean = false,\n    areaFunction: NodeToNumberFunction = (node) => HalfEdgeGraphSearch.signedFaceArea(node),\n  ): SignedDataSummary<HalfEdge> {\n    const result = new SignedDataSummary<HalfEdge>(collectAllNodes);\n    let allFaces: HalfEdge[];\n    if (source instanceof HalfEdgeGraph)\n      allFaces = source.collectFaceLoops();\n    else\n      allFaces = source;\n    for (const node of allFaces) {\n      const area = areaFunction(node);\n      result.announceItem(node, area);\n    }\n    return result;\n  }\n  /**\n   * Search the graph for the face with the most negative area.\n   * @param oneCandidateNodePerFace graph or an array containing one node from each face to be considered.\n   * @returns node on the negative area face with largest absolute area, or `undefined` if no negative area face.\n   */\n  public static findMinimumAreaFace(\n    oneCandidateNodePerFace: HalfEdgeGraph | HalfEdge[], faceAreaFunction?: NodeToNumberFunction,\n  ): HalfEdge | undefined {\n    const summary = HalfEdgeGraphSearch.collectFaceAreaSummary(oneCandidateNodePerFace, false, faceAreaFunction);\n    return summary.largestNegativeItem;\n  }\n  /**\n   * Test if the graph is triangulated.\n   * * Return `false` if:\n   *   * number of positive area faces with more than 3 edges is larger than `numPositiveExceptionsAllowed`.\n   *   * graph has more than 1 negative area face when `allowMultipleNegativeAreaFaces` is `false`.\n   * * 2-edge faces are ignored.\n   */\n  public static isTriangulatedCCW(\n    source: HalfEdgeGraph | HalfEdge[],\n    allowMultipleNegativeAreaFaces: boolean = true,\n    numPositiveExceptionsAllowed: number = 0,\n  ): boolean {\n    let allFaces: HalfEdge[];\n    if (source instanceof HalfEdgeGraph)\n      allFaces = source.collectFaceLoops();\n    else\n      allFaces = source;\n    let numNegative = 0;\n    let numPositiveExceptions = 0;\n    for (const node of allFaces) {\n      const numEdges = node.countEdgesAroundFace();\n      if (numEdges >= 3) {\n        const area = node.signedFaceArea();\n        if (area > 0) {\n          if (numEdges > 3) {\n            numPositiveExceptions++;\n            if (numPositiveExceptions > numPositiveExceptionsAllowed)\n              return false;\n          }\n        } else {\n          numNegative++;\n          if (numNegative > 1) {\n            if (!allowMultipleNegativeAreaFaces)\n              return false;\n          }\n        }\n      }\n    }\n    return true;\n  }\n  /**\n   * Process a face during graph traversal.\n   * @param faceSeed a node in the face.\n   * @param mask mask to set on each node of the face.\n   * @param allNodeStack array appended with each node of the face.\n   * @param onePerFaceStack array appended with `faceSeed`.\n   */\n  private static pushAndMaskAllNodesInFace(\n    faceSeed: HalfEdge, mask: number, allNodeStack: HalfEdge[], onePerFaceStack: HalfEdge[],\n  ): void {\n    onePerFaceStack.push(faceSeed);\n    faceSeed.collectAroundFace((node: HalfEdge) => {\n      node.setMask(mask);\n      allNodeStack.push(node);\n    });\n  }\n  /**\n   * Traverse (via Depth First Search) to all accessible faces from the given seed.\n   * @param faceSeed first node to start the traverse.\n   * @param visitMask mask applied to all faces as visited.\n   * @param parityEdgeTester function to test if an edge is adjacent to two faces of opposite parity, e.g., a boundary\n   * edge that separates an \"interior\" face and an \"exterior\" face. If `parityEdgeTester` is not supplied and `parityMask`\n   * is supplied, the default parity rule is to alternate parity state in a \"bullseye\" pattern starting at the seed face,\n   * with each successive concentric ring of faces at constant topological distance from the seed face receiving the\n   * opposite parity state of the previous ring.\n   * @param parityMask mask to apply to the first face and faces that share the same parity as the first face, as\n   * determined by the parity rule. If this is `NULL_MASK`, there is no record of parity. If (non-null) parity mask\n   * is given, on return it is entirely set or entirely clear around each face.\n   * @returns an array that contains one representative node in each face of the connected component.\n   */\n  private static parityFloodFromSeed(\n    faceSeed: HalfEdge,\n    visitMask: HalfEdgeMask,\n    parityEdgeTester: HalfEdgeTestObject | undefined,\n    parityMask: HalfEdgeMask,\n  ): HalfEdge[] {\n    const faces: HalfEdge[] = [];\n    if (faceSeed.isMaskSet(visitMask))\n      return faces; // empty array\n    const allMasks = parityMask | visitMask;\n    const stack: HalfEdge[] = [];\n    // the seed face is arbitrarily assigned the parity mask\n    HalfEdgeGraphSearch.pushAndMaskAllNodesInFace(faceSeed, allMasks, stack, faces);\n    while (stack.length > 0) {\n      const p = stack.pop()!;\n      const mate = p.edgeMate;\n      if (!mate)\n        continue;\n      if (!mate.isMaskSet(visitMask)) {\n        let newState = p.isMaskSet(parityMask);\n        if (!parityEdgeTester || parityEdgeTester.testEdge(p))\n          newState = !newState;\n        HalfEdgeGraphSearch.pushAndMaskAllNodesInFace(mate, newState ? allMasks : visitMask, stack, faces);\n      }\n    }\n    return faces;\n  }\n  /**\n   * * Correct the parity mask in the faces of a component.\n   * * It is assumed that the parity mask is applied _consistently_ throughout the supplied faces, but maybe\n   * not _correctly_.\n   * * A consistently applied parity mask is \"correct\" if it is set on the negative area (\"exterior\") face of\n   * a connected component.\n   * * This method finds a face with negative area and toggles the mask throughout the input faces if this face\n   * lacks the parity mask.\n   * * In a properly merged planar subdivision there should be only one true negative area face per component.\n   */\n  private static correctParityInSingleComponent(parityMask: HalfEdgeMask, faces: HalfEdge[]): void {\n    const exteriorHalfEdge = HalfEdgeGraphSearch.findMinimumAreaFace(faces);\n    if (!exteriorHalfEdge) {\n      // graph has all degenerate faces; do nothing\n    } else if (exteriorHalfEdge.isMaskSet(parityMask)) {\n      // all should be well; nothing to do\n    } else {\n      for (const faceSeed of faces) {\n        if (faceSeed.isMaskSet(parityMask)) {\n          faceSeed.clearMaskAroundFace(parityMask);\n        } else {\n          faceSeed.setMaskAroundFace(parityMask);\n        }\n      }\n    }\n  }\n  /** Apply `correctParityInSingleComponent` to each array in components (quick exit if `parityMask` is `NULL_MASK`). */\n  private static correctParityInComponentArrays(parityMask: HalfEdgeMask, components: HalfEdge[][]): void {\n    if (parityMask === HalfEdgeMask.NULL_MASK)\n      return;\n    for (const facesInComponent of components)\n      HalfEdgeGraphSearch.correctParityInSingleComponent(parityMask, facesInComponent);\n  }\n  /**\n   * Collect connected components of the graph (via Depth First Search).\n   * @param graph graph to inspect.\n   * @param parityEdgeTester (optional) function to test if an edge is adjacent to two faces of opposite parity,\n   * e.g., a boundary edge that separates an \"interior\" face and an \"exterior\" face. If `parityEdgeTester` is not\n   * supplied and `parityMask` is supplied, the default parity rule is to alternate parity state in a \"bullseye\"\n   * pattern starting at the seed face, with each successive concentric ring of faces at constant topological\n   * distance from the seed face receiving the opposite parity state of the previous ring.\n   * @param parityMask (optional) mask to apply to the first face and faces that share the same parity as the\n   * first face, as determined by the parity rule. If this is `NULL_MASK`, there is no record of parity. If\n   * (non-null) parity mask is given, on return it is entirely set or entirely clear around each face.\n   * @returns the components of the graph, each component represented by an array of nodes, one node per face\n   * of the component. In other words, entry [i][j] is a HalfEdge in the j_th face loop of the i_th component.\n   */\n  public static collectConnectedComponentsWithExteriorParityMasks(\n    graph: HalfEdgeGraph,\n    parityEdgeTester: HalfEdgeTestObject | undefined,\n    parityMask: HalfEdgeMask = HalfEdgeMask.NULL_MASK,\n  ): HalfEdge[][] {\n    // Illustration of the algorithm can be found at geometry/internaldocs/Graph.md\n    const components = [];\n    const visitMask = HalfEdgeMask.VISITED;\n    const allMasks = parityMask | visitMask;\n    graph.clearMask(allMasks);\n    for (const faceSeed of graph.allHalfEdges) {\n      if (!faceSeed.isMaskSet(visitMask)) {\n        const newFaces = HalfEdgeGraphSearch.parityFloodFromSeed(faceSeed, visitMask, parityEdgeTester, parityMask);\n        // parityFloodFromSeed does not return an empty array because it is called on an unvisited faceSeed\n        components.push(newFaces);\n      }\n    }\n    HalfEdgeGraphSearch.correctParityInComponentArrays(parityMask, components);\n    return components;\n  }\n  /**\n   * Breadth First Search through connected component of a graph.\n   * @param component vector of nodes, one per face.\n   * @param seed seed node in component.\n   * @param visitMask mask to apply to visited nodes. Assumed cleared throughout component.\n   * @param ignoreMask (optional) mask preset on faces to ignore. Default value is `HalfEdgeMask.EXTERIOR` to\n   * ignore exterior faces. Pass `HalfEdgeMask.NULL_MASK` to process all faces.\n   * @param maxFaceCount (optional) maximum number of faces in the component. Should be positive; otherwise\n   * `Infinity` is used.\n   * @returns node at which to start next component if maximum face count exceeded, or undefined.\n   */\n  private static exploreComponent(\n    component: HalfEdge[],\n    seed: HalfEdge,\n    visitMask: HalfEdgeMask,\n    ignoreMask: HalfEdgeMask = HalfEdgeMask.EXTERIOR,\n    maxFaceCount: number = Infinity,\n  ): HalfEdge | undefined {\n    if (maxFaceCount <= 0)\n      maxFaceCount = Infinity;\n    const boundaryMask: HalfEdgeMask = visitMask | ignoreMask;\n    let numFaces = 0;\n    const candidates: HalfEdge[] = []; // the queue\n    candidates.push(seed);\n    while (candidates.length !== 0 && numFaces < maxFaceCount) {\n      // shift is O(n) and may be inefficient for large queues; if needed, we can replace\n      // queue by circular array or implement the queue using 2 stacks; both are O(1)\n      const node = candidates.shift()!;\n      if (node.isMaskSet(boundaryMask))\n        continue;\n      component.push(node);\n      ++numFaces;\n      const enqueueNeighboringFaces: NodeFunction = (heNode: HalfEdge) => {\n        heNode.setMask(visitMask);\n        const neighbor = heNode.vertexSuccessor;\n        if (!neighbor.isMaskSet(boundaryMask))\n          candidates.push(neighbor);\n      };\n      node.collectAroundFace(enqueueNeighboringFaces);\n    }\n    if (candidates.length === 0)\n      return undefined;\n    else {\n      const front = candidates[0];\n      while (candidates.length !== 0) {\n        // try to find a node at the boundary of both the geometry and previous component\n        const node = candidates.shift()!; // shift may be inefficient for large queues\n        if (node.vertexSuccessor.isMaskSet(ignoreMask))\n          return node;\n        if (node.edgeMate.isMaskSet(ignoreMask))\n          return node;\n      }\n      return front;\n    }\n  }\n  /**\n   * Collect connected components of the graph (via Breadth First Search).\n   * @param graph graph to inspect.\n   * @param maxFaceCount (optional) maximum number of faces in each component. Should be positive; otherwise\n   * `Infinity` is used.\n   * @param ignoreMask (optional) mask preset on faces to ignore. Default value is `HalfEdgeMask.EXTERIOR` to ignore\n   * exterior faces. Pass `HalfEdgeMask.NULL_MASK` to process all faces.\n   * @returns the components of the graph, each component represented by an array of nodes, one node per face\n   * of the component. In other words, entry [i][j] is a HalfEdge in the j_th face loop of the i_th component.\n   */\n  public static collectConnectedComponents(\n    graph: HalfEdgeGraph,\n    maxFaceCount: number = Infinity,\n    ignoreMask: HalfEdgeMask = HalfEdgeMask.EXTERIOR,\n  ): HalfEdge[][] {\n    const components: HalfEdge[][] = [];\n    if (graph.countMask(ignoreMask) === 0)\n      ignoreMask = HalfEdgeMask.NULL_MASK;\n    const visitMask = HalfEdgeMask.VISITED;\n    const boundaryMask: HalfEdgeMask = visitMask | ignoreMask;\n    // Starting with the input node, look ahead for a boundary face. Failing that, return the input node.\n    // Starting all floods at the boundary reduces the chance of ending up with a ring-shaped component at the boundary.\n    const findNextFloodSeed = (index: number) => {\n      for (let i = index; i < graph.countNodes(); ++i) {\n        if (!graph.allHalfEdges[i].isMaskSet(boundaryMask)\n          && graph.allHalfEdges[i].edgeMate.isMaskSet(boundaryMask)) {\n          index = i;\n          break;\n        }\n      }\n      return index;\n    };\n    for (let i = 0; i < graph.countNodes(); ++i) {\n      if (graph.allHalfEdges[i].isMaskSet(boundaryMask))\n        continue;\n      const i0 = findNextFloodSeed(i);\n      let seed: HalfEdge | undefined = graph.allHalfEdges[i0];\n      do { // flood this component\n        const component: HalfEdge[] = [];\n        seed = HalfEdgeGraphSearch.exploreComponent(component, seed, visitMask, ignoreMask, maxFaceCount);\n        if (component.length !== 0)\n          components.push(component);\n      } while (seed !== undefined);\n      if (!graph.allHalfEdges[i].isMaskSet(visitMask))\n        --i; // reprocess this node\n    }\n    return components;\n  }\n  /**\n   * Test if test point (xTest,yTest) is inside/outside a face or on an edge.\n   * @param seedNode any node on the face loop.\n   * @param xTest x coordinate of the test point.\n   * @param yTest y coordinate of the test point.\n   * @returns 0 if ON, 1 if IN, -1 if OUT.\n   */\n  public static pointInOrOnFaceXY(seedNode: HalfEdge, xTest: number, yTest: number): number | undefined {\n    const context = new XYParitySearchContext(xTest, yTest);\n    // walk around looking for an accepted node to start the search (seedNode is usually ok)\n    let nodeA = seedNode;\n    let nodeB = seedNode.faceSuccessor;\n    for (; ; nodeA = nodeB) {\n      if (context.tryStartEdge(nodeA.x, nodeA.y, nodeB.x, nodeB.y))\n        break;\n      if (nodeB === seedNode) {\n        // the test point and the face are all on line \"y = yTest\"\n        const range = Range1d.createXX(nodeB.x, nodeB.faceSuccessor.x);\n        return range.containsX(xTest) ? 0 : -1;\n      }\n      nodeB = nodeA.faceSuccessor;\n    }\n    // nodeB is the real start node for search, so stop when we revisit it. For each edge, accumulate parity and hits\n    let nodeC = nodeB.faceSuccessor;\n    for (; ;) {\n      if (!context.advance(nodeC.x, nodeC.y)) {\n        return context.classifyCounts();\n      }\n      if (nodeC === nodeB)\n        break;\n      nodeC = nodeC.faceSuccessor;\n    }\n    return context.classifyCounts();\n  }\n  /**\n   * Collect boundary edges starting from `seed`.\n   * * If `seed` is not a boundary node or is already visited, the function exists early.\n   * @param seed start node.\n   * @param visitMask mask to set on processed nodes.\n   * @param isBoundaryEdge function to test if an edge in a boundary edge.\n   * @param announceEdgeInBoundary callback invoked on each edge in the boundary loop in order. The counter is zero\n   * for the first edge, and incremented with each successive edge.\n   */\n  public static collectExtendedBoundaryLoopFromSeed(\n    seed: HalfEdge,\n    visitMask: HalfEdgeMask,\n    isBoundaryEdge: HalfEdgeToBooleanFunction,\n    announceEdgeInBoundary: (edge: HalfEdge, counter: number) => void,\n  ): void {\n    let counter = 0;\n    while (!seed.getMask(visitMask) && isBoundaryEdge(seed)) {\n      announceEdgeInBoundary(seed, counter++);\n      seed.setMask(visitMask);\n      const vertexBase = seed.faceSuccessor;\n      let candidateAroundVertex = vertexBase;\n      for (; ;) {\n        if (candidateAroundVertex.getMask(visitMask)) // end of boundary loop\n          return;\n        if (isBoundaryEdge(candidateAroundVertex)) {\n          seed = candidateAroundVertex;\n          break;\n        }\n        candidateAroundVertex = candidateAroundVertex.vertexPredecessor;\n        if (candidateAroundVertex === vertexBase)\n          break; // prevent infinite loop in case exteriorMask is not set on the edge mate of the boundary edge\n      }\n    }\n  }\n  /**\n   * Collect boundary edges in the graph.\n   * * A boundary edge is defined by `exteriorMask` being set on only its \"exterior\" edge mate.\n   * * Each boundary edge is identified in the output by its edge mate that lacks `exteriorMask`.\n   * * Each inner array is ordered in the output so that its boundary edges form a connected path. If `exteriorMask`\n   * is preset consistently around each \"exterior\" face, these paths are loops.\n   * @param graph the graph to query\n   * @param exteriorMask mask preset on exactly one side of boundary edges\n   * @returns array of boundary loops, each loop an array of the unmasked mates of boundary edges\n   */\n  public static collectExtendedBoundaryLoopsInGraph(graph: HalfEdgeGraph, exteriorMask: HalfEdgeMask): HalfEdge[][] {\n    // Illustration of the algorithm can be found at geometry/internaldocs/Graph.md\n    const loops: HalfEdge[][] = [];\n    const visitMask = graph.grabMask(true);\n    const isBoundaryEdge = (edge: HalfEdge): boolean => {\n      return edge.getMask(exteriorMask) === 0 && edge.edgeMate.getMask(exteriorMask) !== 0;\n    };\n    const announceEdgeInBoundary = (edge: HalfEdge, counter: number) => {\n      if (counter === 0)\n        loops.push([]);\n      loops[loops.length - 1].push(edge);\n    };\n    for (const seed of graph.allHalfEdges) {\n      this.collectExtendedBoundaryLoopFromSeed(seed, visitMask, isBoundaryEdge, announceEdgeInBoundary);\n    }\n    graph.dropMask(visitMask);\n    return loops;\n  }\n}\n"]}