@itwin/core-geometry 3.0.0-dev.76 → 3.0.0-dev.80

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

@@ -0,0 +1 @@
+{"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 */\n\nimport { HalfEdge, HalfEdgeGraph, HalfEdgeMask, HalfEdgeToBooleanFunction, NodeToNumberFunction } from \"./Graph\";\nimport { SignedDataSummary } from \"./SignedDataSummary\";\nimport { XYParitySearchContext } from \"./XYParitySearchContext\";\n\n/**\n * Interface for an object that executes boolean tests on edges.\n */\nexport interface HalfEdgeTestObject {\n  testEdge(h: HalfEdge): boolean;\n}\n/**\n */\nexport class HalfEdgeMaskTester {\n  private _targetMask: HalfEdgeMask;\n  private _targetValue: boolean;\n  /**\n   *\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// Search services for HalfEdgeGraph\nexport class HalfEdgeGraphSearch {\n\n  /**\n   * * for each node of face, set the mask push to allNodesStack\n   * * push the faceSeed on onePerFaceStack[]\n   */\n  private static pushAndMaskAllNodesInFace(faceSeed: HalfEdge, mask: number, allNodeStack: HalfEdge[], onePerFaceStack: HalfEdge[]) {\n    onePerFaceStack.push(faceSeed);\n    faceSeed.collectAroundFace((node: HalfEdge) => {\n      node.setMask(mask);\n      allNodeStack.push(node);\n    });\n  }\n\n  /**\n   * Search an array of faceSeed nodes for the face with the most negative area.\n   * @param oneCandidateNodePerFace array containing one node from each face to be considered.\n   */\n  public static findMinimumAreaFace(oneCandidateNodePerFace: HalfEdgeGraph | HalfEdge[],\n    faceAreaFunction?: NodeToNumberFunction): HalfEdge {\n    const summary = HalfEdgeGraphSearch.collectFaceAreaSummary(oneCandidateNodePerFace, false, faceAreaFunction);\n    return summary.largestNegativeItem!;\n  }\n  /**\n   * static method for face area computation -- useful as function parameter in collect FaceAreaSummary.\n   * * This simply calls `node.signedFaceArea ()`\n   * @param node instance for signedFaceArea call.\n   */\n  public static signedFaceArea(node: HalfEdge): number { return node.signedFaceArea(); }\n  /**\n   *\n   * Return a summary structure data about face (or other numeric quantity if the caller's areaFunction returns other value)\n   * * The default areaFunction computes area of polygonal face.\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 all to obtain area (or other numeric value)\n   */\n  public static collectFaceAreaSummary(source: HalfEdgeGraph | HalfEdge[], collectAllNodes: boolean = false,\n    areaFunction: NodeToNumberFunction = HalfEdgeGraphSearch.signedFaceArea): SignedDataSummary<HalfEdge> {\n    const result = new SignedDataSummary<HalfEdge>(collectAllNodes);\n    let allFaces: HalfEdge[];\n\n    if (source instanceof HalfEdgeGraph)\n      allFaces = source.collectFaceLoops();\n    else\n      allFaces = source;\n\n    for (const node of allFaces) {\n      const area = areaFunction(node);\n      result.announceItem(node, area);\n    }\n    return result;\n  }\n\n  /**\n   * * Test if the graph is triangulated.\n   * * Return false if:\n   *   * Positive area face with more than 3 edges\n   *   * more than 1 negative area face with `allowMultipleNegativeAreaFaces` false\n   * * 2-edge faces are ignored.\n   */\n  public static isTriangulatedCCW(source: HalfEdgeGraph | HalfEdge[], allowMultipleNegativeAreaFaces: boolean = true, numPositiveExceptionsAllowed = 0): boolean {\n    let allFaces: HalfEdge[];\n\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  /**\n   * Search to all accessible faces from given seed.\n   * * The returned array contains one representative node in each face of the connected component.\n   * * If (nonnull) parity mask is given, on return:\n   *    * It is entirely set or entirely clear around each face\n   *    * It is entirely set on all faces that are an even number of face-to-face steps away from the seed.\n   *    * It is entirely clear on all faces that are an odd number of face-to-face steps away from the seed.\n   * @param seedEdge first edge to search.\n   * @param visitMask mask applied to all faces as visited.\n   * @param parityMask mask to apply (a) to first face, (b) to faces with alternating parity during the search.\n   */\n  private static parityFloodFromSeed(seedEdge: HalfEdge, visitMask: HalfEdgeMask, parityEdgeTester: HalfEdgeTestObject | undefined, parityMask: HalfEdgeMask): HalfEdge[] {\n    const faces: HalfEdge[] = [];\n    if (seedEdge.isMaskSet(visitMask)) return faces; // empty\n\n    const allMasks = parityMask | visitMask;\n    const stack: HalfEdge[] = [];\n    // arbitrarily call the seed face exterior ... others will alternate as visited.\n    HalfEdgeGraphSearch.pushAndMaskAllNodesInFace(seedEdge, allMasks, stack, faces);  // Start with exterior as mask\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   * * Search the given faces for the one with the minimum area.\n   * * If the mask in that face is OFF, toggle it on (all half edges of) all the faces.\n   * * In a properly merged planar subdivision there should be only one true negative area face per component.\n   * @param graph parent graph\n   * @param parityMask mask which was previously set with alternating parity, but with an arbitrary start face.\n   * @param faces array of faces to search.\n   */\n  private static correctParityInSingleComponent(_graph: HalfEdgeGraph, mask: HalfEdgeMask, faces: HalfEdge[]) {\n    const exteriorHalfEdge = HalfEdgeGraphSearch.findMinimumAreaFace(faces);\n    if (!exteriorHalfEdge) {\n    } else if (exteriorHalfEdge.isMaskSet(mask)) {\n      // all should be well .. nothing to do.\n    } else {\n      // TOGGLE around the face (assuming all are consistent with the seed)\n      for (const faceSeed of faces) {\n        if (faceSeed.isMaskSet(mask)) {\n          faceSeed.clearMaskAroundFace(mask);\n        } else {\n          faceSeed.setMaskAroundFace(mask);\n        }\n      }\n    }\n  }\n  /** Apply correctParityInSingleComponent to each array in components. (Quick exit if mask in NULL_MASK) */\n  private static correctParityInComponentArrays(graph: HalfEdgeGraph, mask: HalfEdgeMask, components: HalfEdge[][]) {\n    if (mask === HalfEdgeMask.NULL_MASK)\n      return;\n    for (const facesInComponent of components)\n      HalfEdgeGraphSearch.correctParityInSingleComponent(graph, mask, facesInComponent);\n  }\n  /**\n   * Collect arrays gathering faces by connected component.\n   * @param graph graph to inspect\n   * @param parityEdgeTester (optional) function to test of an edge is a parity change.\n   * @param parityMask (optional, along with boundaryTestFunction) mask to apply indicating parity.  If this is Mask.NULL_MASK, there is no record of parity.\n   */\n  public static collectConnectedComponentsWithExteriorParityMasks(graph: HalfEdgeGraph, parityEdgeTester: HalfEdgeTestObject | undefined, parityMask: HalfEdgeMask = HalfEdgeMask.NULL_MASK): HalfEdge[][] {\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(HalfEdgeMask.VISITED)) {\n        const newFaces = HalfEdgeGraphSearch.parityFloodFromSeed(faceSeed, visitMask, parityEdgeTester, parityMask);\n        components.push(newFaces);\n      }\n    }\n    HalfEdgeGraphSearch.correctParityInComponentArrays(graph, parityMask, components);\n    return components;\n  }\n  /**\n   * Test if (x,y) is inside (1), on an edge (0) or outside (-1) a face.\n   * @param seedNode any node on the face loop\n   * @param x x coordinate of test point.\n   * @param y y coordinate of test point.\n   */\n  public static pointInOrOnFaceXY(seedNode: HalfEdge, x: number, y: number): number | undefined {\n    const context = new XYParitySearchContext(x, y);\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        // umm.. the face is all on the x axis?\n        return context.classifyCounts();\n      }\n      nodeB = nodeA.faceSuccessor;\n    }\n\n    // nodeB is the real start node for search ... emit ends of each edge around the face,\n    //   stopping after emitting nodeB as an edge end.\n    let node = nodeB.faceSuccessor;\n    for (; ;) {\n      if (!context.advance(node.x, node.y)) {\n        return context.classifyCounts();\n      }\n      if (node === nodeB)\n        break;\n      node = node.faceSuccessor;\n    }\n    return context.classifyCounts();\n  }\n  /**\n   * Announce nodes that are \"extended face boundary\" by conditions (usually mask of node and mate) in test functions.\n   * * After each node, the next candidate in reached by looking \"around the head vertex loop\" for the next boundary.\n   *   * \"Around the vertex\" from nodeA means\n   *      * First look at nodeA.faceSuccessor;\n   *      * Then look at vertexPredecessor around that vertex loop.\n   * * Each accepted node is passed to announceNode, and marked with the visit mask.\n   * * The counter of the announceEdge function is zero for the first edge, then increases with each edge.\n   * @param seed start node.\n   * @param isBoundaryEdge\n   * @param announceEdge\n   */\n  public static collectExtendedBoundaryLoopFromSeed(seed: HalfEdge, visitMask: HalfEdgeMask, isBoundaryEdge: HalfEdgeToBooleanFunction,\n    announceEdge: (edge: HalfEdge, counter: number) => void) {\n    let counter = 0;\n    while (!seed.getMask(visitMask) && isBoundaryEdge(seed)) {\n      announceEdge(seed, counter++);\n      seed.setMask(visitMask);\n      const vertexBase = seed.faceSuccessor;\n      let candidateAroundVertex = vertexBase;\n      for (; ;) {\n        if (candidateAroundVertex.getMask(visitMask))\n          return;\n        if (isBoundaryEdge(candidateAroundVertex)) {\n          seed = candidateAroundVertex;\n          break;\n        }\n        candidateAroundVertex = candidateAroundVertex.vertexPredecessor;\n        if (candidateAroundVertex === vertexBase)\n          break;\n      }\n    }\n  }\n  /**\n   * Collect arrays of nodes \"around the boundary\" of a graph with extraneous (non-boundary) edges.\n   * * The \"boundary\" is nodes that do NOT have the exterior mask, but whose mates DO have the exterior mask.\n   * * After each node, the next candidate in reached by looking \"around the head vertex loop\" for the next boundary.\n   *   * \"Around the vertex\" from nodeA means\n   *      * First look at nodeA.faceSuccessor;\n   *      * Then look at vertexPredecessor around that vertex loop.\n   * * Each accepted node is passed to announceNode, and marked with the visit mask.\n   * @param seed start node.\n   * @param isBoundaryNode\n   * @param announceNode\n   */\n  public static collectExtendedBoundaryLoopsInGraph(graph: HalfEdgeGraph, exteriorMask: HalfEdgeMask): HalfEdge[][] {\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"]}

package/lib/esm/topology/HalfEdgeGraphSpineContext.d.ts

@@ -0,0 +1,98 @@
+import { HalfEdgeGraph } from "./Graph";
+import { Point3d } from "../geometry3d/Point3dVector3d";
+import { Angle } from "../geometry3d/Angle";
+/**
+ * Context manager to hold a vu graph and do spine operations
+ *
+ * Spine calculations determine both (a) a "skeletal" network of linework that follows the interior
+ *      path through within the boundaries, and (b) a block decomposition into quads and triangles.
+ *
+ * Usage pattern:
+ * ```
+ *    const sc = new HalfEdgeGraphSpineContext();
+ *   // Data setup ....
+ *    foreach polygon or polyline
+ *        {
+ *        sc.InsertEdges (edgePoints, bClosed)
+ *        }
+ *   // Analysis steps ...
+ *     * bParity = true to treat the data as a "polygon".  The interior is determined by parity rules
+ *                   and the triangulation and spine are only constructed "inside"
+ *     * bParity = false if "all" spaces are to be triangulated and spined.
+ *     * minSplitRadians -- suggested value 0.3.  If this value is large, it will encourage add internal
+ *     *     edges from a vertex to an edge 'across' the polygon even if it creates small angles.
+ *     * minDiagonalAngle -- suggested value 1.0.  If this value is large (up to about 1.5 as max) it favors
+ *     *     using triangles to navigate turns.  If it is small, it favors using skewed quadrilaterals.
+ *    sc.TriangulateForSpine (bParity, minSplitRadians)
+ *    sc.MarkBoxes (true, minDiagonalAngle);
+ *    edges = sc.GetSpineEdges ();
+ * ```
+ * @internal
+ */
+export declare class HalfEdgeGraphSpineContext {
+    /** The Evolving graph */
+    private _spineGraph;
+    /** mask marking edges that have been paired into quads */
+    private _diagonalMask;
+    private _boxMask;
+    get graph(): HalfEdgeGraph;
+    /**
+     * Create a context with an empty graph.
+     * * Reserve masks for specialized markup.
+     */
+    constructor();
+    /**
+     * Release resources to the graph.
+     */
+    teardown(): void;
+    private addEdge;
+    private getBoxCorners;
+    private diagonalKeyFunc;
+    private selectTriangleInteriorPoint;
+    private markBox;
+    private setSortedDiagonalMasks;
+    private splitOK;
+    private addPerpendicularsToBoundaries;
+    private getSpineEdgesInQuad;
+    private getSpineEdgesInTriangle;
+    /** Add a polyline to the graph.
+     * * This may be called multiple times
+     */
+    insertEdges(xyzIn: Point3d[], bClosed: boolean): void;
+    /**
+     * Look for trivial (2 edge) faces that have exteriorMask and non-masked on both sides.
+     * * clear the mask
+     * @param exteriorMask
+     */
+    private purgeNullFaces;
+    private static _regularize1;
+    private static _regularize2;
+    /**
+     * Triangulate the graph for the edges that have been inserted.
+     * @param applyParity if true ()
+     * @param minSplitRadians smallest allowed angle in the split sector that is split.
+     */
+    triangulateForSpine(applyParity?: boolean, minSplitRadians?: number): void;
+    /**
+     * Retrieve edges of the spine as arrays of points.
+     * @param bIncludeInterior true to include fully internal segments
+     * @param bIncludeFinal true to include segments that terminate at a boundary
+     * @param bIncludeCornerSpokes
+     * @return array of line data.
+     */
+    getSpineEdges(bIncludeInterior?: boolean, bIncludeFinal?: boolean, bIncludeCornerSpokes?: boolean): Point3d[][];
+    /**
+     * Intermediate markup step to identify quads between corresponding boundary edges.
+     * * search for and mark triangle edges that should be treated as diagonal of a quad
+     * * Angle logic is:
+     *   * In a candidate quad (formed by joining triangles that share an edge)
+     *   * form segments between opposite edges of the quad.
+     *   * compute angles between these segments and the edges of their quads.
+     *   * if this angle is larger than minAngleRadians, accept this as a quad.
+     *   * recommended angle is between 15 and 5 degrees; 50 degrees is typical
+     * @param bDeleteDiagonals if true, eliminate the diagonals.
+     * @param minAngleRadians angle tolerance, as described above.
+     */
+    consolidateTrianglesToQuads(bDeleteDiagonals: boolean, minAngle?: Angle): number;
+}
+//# sourceMappingURL=HalfEdgeGraphSpineContext.d.ts.map

package/lib/esm/topology/HalfEdgeGraphSpineContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HalfEdgeGraphSpineContext.d.ts","sourceRoot":"","sources":["../../../src/topology/HalfEdgeGraphSpineContext.ts"],"names":[],"mappings":"AAQA,OAAO,EAAY,aAAa,EAAgB,MAAM,SAAS,CAAC;AAChE,OAAO,EAAE,OAAO,EAAY,MAAM,+BAA+B,CAAC;AAKlE,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AA+B5C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,yBAAyB;IACpC,yBAAyB;IACzB,OAAO,CAAC,WAAW,CAAgB;IACnC,0DAA0D;IAC1D,OAAO,CAAC,aAAa,CAAe;IACpC,OAAO,CAAC,QAAQ,CAAe;IAC/B,IAAW,KAAK,kBAA+B;IAC/C;;;OAGG;;IAQH;;OAEG;IACI,QAAQ;IAOf,OAAO,CAAC,OAAO;IAOf,OAAO,CAAC,aAAa;IAyBrB,OAAO,CAAC,eAAe;IAsCvB,OAAO,CAAC,2BAA2B;IAoDnC,OAAO,CAAC,OAAO;IASf,OAAO,CAAC,sBAAsB;IA0B9B,OAAO,CAAC,OAAO;IAgBf,OAAO,CAAC,6BAA6B;IAwCrC,OAAO,CAAC,mBAAmB;IAqE3B,OAAO,CAAC,uBAAuB;IAgE/B;;OAEG;IACI,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI;IAmB5D;;;;OAIG;IACH,OAAO,CAAC,cAAc;IAgBtB,OAAO,CAAC,MAAM,CAAC,YAAY,CAAQ;IACnC,OAAO,CAAC,MAAM,CAAC,YAAY,CAAS;IACpC;;;;OAIG;IACI,mBAAmB,CAAC,WAAW,GAAE,OAAc,EAAE,eAAe,GAAE,MAAY,GAAG,IAAI;IAiC5F;;;;;;OAMG;IACI,aAAa,CAAC,gBAAgB,GAAE,OAAc,EAAE,aAAa,GAAE,OAAc,EAAE,oBAAoB,GAAE,OAAc,GAAG,OAAO,EAAE,EAAE;IAcxI;;;;;;;;;;;OAWG;IACI,2BAA2B,CAAC,gBAAgB,EAAE,OAAO,EAAE,QAAQ,GAAE,KAA+B,GAAG,MAAM;CASjH"}

package/lib/esm/topology/HalfEdgeGraphSpineContext.js

@@ -0,0 +1,519 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Topology
+ */
+import { Geometry } from "../Geometry";
+import { HalfEdge, HalfEdgeGraph, HalfEdgeMask } from "./Graph";
+import { Point3d, Vector3d } from "../geometry3d/Point3dVector3d";
+import { HalfEdgeGraphMerge } from "./Merging";
+import { Triangulator } from "./Triangulation";
+import { RegularizationContext } from "./RegularizeFace";
+import { HalfEdgeGraphSearch, HalfEdgeMaskTester } from "./HalfEdgeGraphSearch";
+import { Angle } from "../geometry3d/Angle";
+// cSpell:disable
+// const sSpineRelTol = 1.0e-8;
+// const sSpineGraphAbsTol = 0.0;
+// const sSpineGraphRelTol = 1.0e-10;
+function createNPoints(n) {
+    const points = [];
+    for (let i = 0; i < n; i++)
+        points.push(Point3d.create(0, 0, 0));
+    return points;
+}
+function createNVectors(n) {
+    const points = [];
+    for (let i = 0; i < n; i++)
+        points.push(Vector3d.create(0, 0, 0));
+    return points;
+}
+// Local struct to pair a graph node with a double as a sort key for std::sort
+class NodeSortKey {
+    constructor(node, b) {
+        this._node = node;
+        this._a = b;
+    }
+    get node() { return this._node; }
+    static compareForSort(dataA, dataB) { return dataA._a - dataB._a; }
+}
+/**
+ * Context manager to hold a vu graph and do spine operations
+ *
+ * Spine calculations determine both (a) a "skeletal" network of linework that follows the interior
+ *      path through within the boundaries, and (b) a block decomposition into quads and triangles.
+ *
+ * Usage pattern:
+ * ```
+ *    const sc = new HalfEdgeGraphSpineContext();
+ *   // Data setup ....
+ *    foreach polygon or polyline
+ *        {
+ *        sc.InsertEdges (edgePoints, bClosed)
+ *        }
+ *   // Analysis steps ...
+ *     * bParity = true to treat the data as a "polygon".  The interior is determined by parity rules
+ *                   and the triangulation and spine are only constructed "inside"
+ *     * bParity = false if "all" spaces are to be triangulated and spined.
+ *     * minSplitRadians -- suggested value 0.3.  If this value is large, it will encourage add internal
+ *     *     edges from a vertex to an edge 'across' the polygon even if it creates small angles.
+ *     * minDiagonalAngle -- suggested value 1.0.  If this value is large (up to about 1.5 as max) it favors
+ *     *     using triangles to navigate turns.  If it is small, it favors using skewed quadrilaterals.
+ *    sc.TriangulateForSpine (bParity, minSplitRadians)
+ *    sc.MarkBoxes (true, minDiagonalAngle);
+ *    edges = sc.GetSpineEdges ();
+ * ```
+ * @internal
+ */
+export class HalfEdgeGraphSpineContext {
+    /**
+     * Create a context with an empty graph.
+     * * Reserve masks for specialized markup.
+     */
+    constructor() {
+        this._spineGraph = new HalfEdgeGraph();
+        // vu_setTol (_spineGraph, sSpineGraphAbsTol, sSpineGraphRelTol);
+        this._diagonalMask = this._spineGraph.grabMask();
+        this._boxMask = this._spineGraph.grabMask();
+    }
+    get graph() { return this._spineGraph; }
+    /**
+     * Release resources to the graph.
+     */
+    teardown() {
+        this._spineGraph.dropMask(this._diagonalMask);
+        this._spineGraph.dropMask(this._boxMask);
+        this._spineGraph.decommission();
+    }
+    //  an edge (as new bvector<DPoint3d> at back, with cloned points>
+    addEdge(xyzOut, xyzA, xyzB) {
+        const newArray = [];
+        newArray.push(xyzA.clone());
+        newArray.push(xyzB.clone());
+        xyzOut.push(newArray);
+    }
+    getBoxCorners(diagonalNode, nodes, points) {
+        const diagonalMate = diagonalNode.edgeMate;
+        nodes.length = 0;
+        points.length = 0;
+        if (!diagonalNode.getMask(HalfEdgeMask.BOUNDARY_EDGE)
+            && diagonalNode.countEdgesAroundFace() === 3
+            && diagonalMate.countEdgesAroundFace() === 3) {
+            const nodeA = diagonalMate.faceSuccessor;
+            nodes.push(nodeA);
+            nodes.push(nodeA.faceSuccessor);
+            const nodeB = diagonalNode.faceSuccessor;
+            nodes.push(nodeB);
+            nodes.push(nodeB.faceSuccessor);
+            for (let i = 0; i < 4; i++)
+                points.push(Point3d.create(nodes[i].x, nodes[i].y));
+            return true;
+        }
+        return false;
+    }
+    // Compute bisectors of the quad.
+    // function key is the smaller absolute angle between the bisectors.
+    // (pi/2 is max possible value).
+    diagonalKeyFunc(pDiagonalNode) {
+        const nodes = [];
+        const points = [];
+        if (this.getBoxCorners(pDiagonalNode, nodes, points)) {
+            const xyzA = points[0];
+            const xyzB = points[1];
+            const xyzC = points[2];
+            const xyzD = points[3];
+            const xyzAB = xyzA.interpolate(0.5, xyzB);
+            const xyzBC = xyzB.interpolate(0.5, xyzC);
+            const xyzCD = xyzC.interpolate(0.5, xyzD);
+            const xyzDA = xyzD.interpolate(0.5, xyzA);
+            const vectorAB = Vector3d.createStartEnd(xyzA, xyzB);
+            const vectorBC = Vector3d.createStartEnd(xyzB, xyzC);
+            const vectorCD = Vector3d.createStartEnd(xyzC, xyzD);
+            const vectorDA = Vector3d.createStartEnd(xyzD, xyzA);
+            const vectorABToCD = Vector3d.createStartEnd(xyzCD, xyzAB);
+            const vectorBCToDA = Vector3d.createStartEnd(xyzDA, xyzBC);
+            vectorABToCD.z = 0.0;
+            vectorBCToDA.z = 0.0;
+            const thetaAB = vectorABToCD.smallerUnorientedAngleTo(vectorAB).radians;
+            const thetaBC = vectorBCToDA.smallerUnorientedAngleTo(vectorBC).radians;
+            const thetaCD = vectorABToCD.smallerUnorientedAngleTo(vectorCD).radians;
+            const thetaDA = vectorBCToDA.smallerUnorientedAngleTo(vectorDA).radians;
+            const alpha = thetaAB < thetaCD ? thetaAB : thetaCD;
+            const beta = thetaBC < thetaDA ? thetaBC : thetaDA;
+            return alpha < beta ? alpha : beta;
+        }
+        return Number.NEGATIVE_INFINITY;
+    }
+    // Select a branch point in a triangle.
+    // This may be the centroid or the midpoint of an edge joining midpoints of a pair of edges.
+    selectTriangleInteriorPoint(pXYZ) {
+        const xyz = createNPoints(6);
+        const xyzMid = createNPoints(6); // Midpoints of each edge.
+        const interiorCandidate = createNPoints(4); // for i in {012}, [i] is midpoint of midpoint[i+1] and midpoint[i+2].
+        // [3] is centroid.
+        const edgeVector = createNVectors(6);
+        const centroid = Point3d.create();
+        for (let i = 0; i < 3; i++) {
+            xyz[i] = xyz[i + 3] = pXYZ[i];
+            centroid.addInPlace(xyz[i]);
+        }
+        centroid.scaleInPlace(1.0 / 3.0);
+        // Edge midpoints ...
+        for (let i = 0; i < 3; i++) {
+            xyzMid[i] = xyz[i].interpolate(0.5, xyz[i + 1]);
+            xyzMid[i + 3] = xyzMid[i];
+            edgeVector[i] = Vector3d.createStartEnd(xyz[i], xyz[i + 1]); // use wraparound
+            edgeVector[i + 3] = edgeVector[i];
+        }
+        // Midpoints of midpoint-to-midpoint connections ..
+        for (let i = 0; i < 3; i++) {
+            const i1 = i + 1;
+            const i2 = i + 2;
+            interiorCandidate[i] = xyzMid[i1].interpolate(0.5, xyzMid[i2]);
+        }
+        interiorCandidate[3] = centroid;
+        let bestAngle = Number.NEGATIVE_INFINITY;
+        let bestIndex = -1;
+        const theta = [0, 0, 0];
+        let thetaMin;
+        for (let k = 0; k < 4; k++) {
+            // Measure angles from edge midpoints towards interior candidate.
+            thetaMin = Number.POSITIVE_INFINITY;
+            for (let i = 0; i < 3; i++) {
+                const edgeToInterior = Vector3d.createStartEnd(xyzMid[i], interiorCandidate[k]);
+                theta[i] = edgeVector[i].smallerUnorientedAngleTo(edgeToInterior).radians;
+                if (theta[i] < thetaMin)
+                    thetaMin = theta[i];
+            }
+            if (thetaMin > bestAngle) {
+                bestAngle = thetaMin;
+                bestIndex = k;
+            }
+        }
+        return interiorCandidate[bestIndex];
+    }
+    markBox(pA) {
+        const pB = pA.edgeMate;
+        pA.setMask(this._diagonalMask);
+        pB.setMask(this._diagonalMask);
+        pA.setMaskAroundFace(this._boxMask);
+        pB.setMaskAroundFace(this._boxMask);
+    }
+    setSortedDiagonalMasks(minA) {
+        const candidates = [];
+        let numDiagonal = 0;
+        for (const node of this._spineGraph.allHalfEdges) {
+            const b = this.diagonalKeyFunc(node);
+            if (b > minA)
+                candidates.push(new NodeSortKey(node, b));
+        }
+        candidates.sort(NodeSortKey.compareForSort);
+        let key;
+        while (undefined !== (key = candidates.pop())) {
+            const pA = key.node;
+            const pB = pA.edgeMate;
+            if (!pA.getMask(this._boxMask)
+                && !pB.getMask(this._boxMask)) {
+                this.markBox(pA);
+                numDiagonal++;
+            }
+        }
+        return numDiagonal;
+    }
+    /// <param name="xyzA">Vertex whose angle is being split</param>
+    splitOK(xyzA, xyzB, xyzQ, xyzC, minAngle) {
+        const vectorAB = Vector3d.createStartEnd(xyzA, xyzB);
+        const vectorAQ = Vector3d.createStartEnd(xyzA, xyzQ);
+        const vectorAC = Vector3d.createStartEnd(xyzA, xyzC);
+        const angleBAQ = vectorAB.angleToXY(vectorAQ).radians;
+        const angleQAC = vectorAQ.angleToXY(vectorAC).radians;
+        return Math.abs(angleBAQ) > minAngle && Math.abs(angleQAC) > minAngle;
+    }
+    // Search a triangulation for vertices which have
+    //   (a) pre-split angle greater than 90 degrees
+    // (b) the opposite edge is a boundary.
+    //  (c) each post split angle is less than minSplitRadians
+    // Drop a perpenedicular to that boundary.
+    // return the number of edges added.
+    addPerpendicularsToBoundaries(minSplitRadians, minCandidateRadians) {
+        let numAdd = 0;
+        for (const pA of this._spineGraph.allHalfEdges) {
+            const pB = pA.faceSuccessor;
+            const pC = pB.faceSuccessor;
+            if (!pA.getMask(HalfEdgeMask.EXTERIOR)
+                && !pA.getMask(HalfEdgeMask.BOUNDARY_EDGE) // ?? prevent deep recursion
+                && !pC.getMask(HalfEdgeMask.BOUNDARY_EDGE) // ?? prevent deep recursion
+                && pB.getMask(HalfEdgeMask.BOUNDARY_EDGE)
+                && pC.faceSuccessor === pA) {
+                const vectorAB = pA.getVector2dAlongEdge();
+                const vectorBC = pB.getVector2dAlongEdge();
+                const vectorCA = pC.getVector2dAlongEdge();
+                const candidateRadians = Math.PI - vectorCA.angleTo(vectorAB).radians;
+                // const candidateDot = vectorCA.DotProduct (vectorAB);
+                if (candidateRadians > minCandidateRadians) { // vectorCA.DotProduct (vectorAB) > 0.0)
+                    const bb = vectorBC.dotProduct(vectorBC);
+                    const ba = -vectorBC.dotProduct(vectorAB);
+                    const s = Geometry.conditionalDivideFraction(ba, bb);
+                    if (s !== undefined && s > 0.0 && s < 1.0) {
+                        const xyzA = pA.getPoint3d();
+                        const xyzB = pB.getPoint3d();
+                        const xyzC = pC.getPoint3d();
+                        const xyzE = xyzB.interpolate(s, xyzC);
+                        if (this.splitOK(xyzA, xyzB, xyzE, xyzC, minSplitRadians)) {
+                            const pE = this._spineGraph.splitEdgeAtFraction(pB, s);
+                            const pA1 = this._spineGraph.createEdgeHalfEdgeHalfEdge(pA, 0, pE, 0);
+                            pA1.setXYZFrom(pA);
+                            pE.setXYZAroundVertex(xyzE.x, xyzE.y, xyzE.z);
+                            numAdd++;
+                        }
+                    }
+                }
+            }
+        }
+        return numAdd;
+    }
+    getSpineEdgesInQuad(pFace, xyzOut, bIncludeInterior, 
+    // true to include the edge to boundary when the qued is a dead end.
+    bIncludeFinal, 
+    // true to include the two adjacent edges to boundary if the quad is at a corner.
+    bIncludeCornerSpokes) {
+        if (pFace.countEdgesAroundFace() !== 4)
+            return false;
+        const pNode = [];
+        const xyz = createNPoints(8);
+        const midpoint = createNPoints(8);
+        pNode[0] = pNode[4] = pFace;
+        pNode[1] = pNode[5] = pNode[0].faceSuccessor;
+        pNode[2] = pNode[6] = pNode[1].faceSuccessor;
+        pNode[3] = pNode[7] = pNode[2].faceSuccessor;
+        let numBoundary = 0;
+        let numInterior = 0;
+        const iBoundary = [];
+        const iInterior = [];
+        const bIsBoundary = [];
+        const centroid = Point3d.create();
+        for (let i = 0; i < 4; i++) {
+            bIsBoundary[i] = 0 !== pNode[i].getMask(HalfEdgeMask.BOUNDARY_EDGE);
+            if (pNode[i].getMask(HalfEdgeMask.BOUNDARY_EDGE))
+                iBoundary[numBoundary++] = i;
+            else
+                iInterior[numInterior++] = i;
+            xyz[i] = pNode[i].getPoint3d();
+            xyz[i + 4] = xyz[i];
+            centroid.addInPlace(xyz[i]);
+        }
+        for (let i = 0; i < 4; i++) {
+            midpoint[i] = xyz[i].interpolate(0.5, xyz[i + 1]);
+            midpoint[i + 4] = midpoint[i];
+        }
+        centroid.scaleInPlace(0.25);
+        if (numBoundary === 0 || numBoundary === 1) {
+            for (let i = 0; i < numInterior; i++)
+                if (bIncludeInterior)
+                    this.addEdge(xyzOut, midpoint[iInterior[i]], centroid);
+        }
+        else if (numBoundary === 4) {
+            for (let i = 0; i < numBoundary; i++)
+                if (bIncludeFinal)
+                    this.addEdge(xyzOut, midpoint[i], centroid);
+        }
+        else if (numBoundary === 2) {
+            if (iInterior[1] === iInterior[0] + 2) {
+                // Spine enters one end, exits the other ..
+                if (bIncludeInterior)
+                    this.addEdge(xyzOut, midpoint[iInterior[0]], midpoint[iInterior[1]]);
+            }
+            else {
+                // Block sits as exterior corner.  Let the two spines continue to their opposite faces ..
+                for (let i = 0; i < 4; i++)
+                    if ((bIsBoundary[i] && bIncludeCornerSpokes)
+                        || (!bIsBoundary[i] && bIncludeInterior))
+                        this.addEdge(xyzOut, midpoint[i], centroid);
+            }
+        }
+        else if (numBoundary === 3) {
+            if (bIncludeInterior)
+                this.addEdge(xyzOut, midpoint[iInterior[0]], centroid);
+            if (bIncludeFinal)
+                this.addEdge(xyzOut, centroid, midpoint[iInterior[0] + 2]);
+        }
+        return true;
+    }
+    getSpineEdgesInTriangle(pFace, xyzOut, bIncludeInterior, bIncludeFinal) {
+        if (pFace.countEdgesAroundFace() !== 3)
+            return false;
+        let n = 0;
+        const xyzMidpoint = createNPoints(6);
+        const xyz = createNPoints(6);
+        const xyzCentroid = Point3d.createZero();
+        const isBoundary = [];
+        let numBoundary = 0;
+        let lastBoundary = -1;
+        let lastInterior = -1;
+        let currentEdge = pFace;
+        do {
+            xyz[n] = currentEdge.getPoint3d();
+            xyzCentroid.addInPlace(xyz[n]);
+            isBoundary[n] = false;
+            if (currentEdge.getMask(HalfEdgeMask.BOUNDARY_EDGE)) {
+                isBoundary[n] = true;
+                numBoundary++;
+                lastBoundary = n;
+            }
+            else {
+                lastInterior = n;
+            }
+            xyz[n + 3] = xyz[n];
+            isBoundary[n + 3] = isBoundary[n];
+            n++;
+        } while ((currentEdge = currentEdge.faceSuccessor) !== pFace);
+        for (let i = 0; i < 3; i++) {
+            xyzMidpoint[i] = xyz[i].interpolate(0.5, xyz[i + 1]);
+            xyzMidpoint[i + 3] = xyzMidpoint[i];
+        }
+        xyzCentroid.scaleInPlace(1.0 / 3.0);
+        if (numBoundary === 0) {
+            // Interior branch
+            const xyzInterior = this.selectTriangleInteriorPoint(xyz);
+            if (bIncludeInterior) {
+                this.addEdge(xyzOut, xyzMidpoint[0], xyzInterior);
+                this.addEdge(xyzOut, xyzMidpoint[1], xyzInterior);
+                this.addEdge(xyzOut, xyzMidpoint[2], xyzInterior);
+            }
+        }
+        else if (numBoundary === 1) {
+            if (bIncludeInterior)
+                this.addEdge(xyzOut, xyzMidpoint[lastBoundary + 1], xyzMidpoint[lastBoundary + 2]);
+        }
+        else if (numBoundary === 2) {
+            if (bIncludeFinal && lastInterior >= 0)
+                this.addEdge(xyzOut, xyzMidpoint[lastInterior], xyz[lastInterior + 2]);
+        }
+        else if (numBoundary === 3) {
+            const xyzInterior = this.selectTriangleInteriorPoint(xyz);
+            if (bIncludeFinal) {
+                this.addEdge(xyzOut, xyzMidpoint[0], xyzInterior);
+                this.addEdge(xyzOut, xyzMidpoint[1], xyzInterior);
+                this.addEdge(xyzOut, xyzMidpoint[2], xyzInterior);
+            }
+        }
+        return true;
+    }
+    /** Add a polyline to the graph.
+     * * This may be called multiple times
+     */
+    insertEdges(xyzIn, bClosed) {
+        let pPreviousB, pFirstA;
+        for (let i = 1; i < xyzIn.length; i++) {
+            const nodeA = this._spineGraph.createEdgeXYZXYZ(xyzIn[i - 1].x, xyzIn[i - 1].y, 0, 0, xyzIn[i].x, xyzIn[i].y, 0, 0);
+            const nodeB = nodeA.faceSuccessor;
+            nodeA.setMask(HalfEdgeMask.BOUNDARY_EDGE);
+            nodeB.setMask(HalfEdgeMask.BOUNDARY_EDGE);
+            if (pPreviousB === undefined) {
+                pFirstA = nodeA;
+            }
+            else {
+                HalfEdge.pinch(pPreviousB, nodeA);
+            }
+            pPreviousB = nodeB;
+        }
+        if (bClosed && pFirstA !== undefined && pPreviousB !== undefined)
+            HalfEdge.pinch(pPreviousB, pFirstA);
+    }
+    /**
+     * Look for trivial (2 edge) faces that have exteriorMask and non-masked on both sides.
+     * * clear the mask
+     * @param exteriorMask
+     */
+    purgeNullFaces(exteriorMask) {
+        for (const nodeA of this._spineGraph.allHalfEdges) {
+            const nodeB = nodeA.faceSuccessor;
+            const nodeC = nodeB.faceSuccessor;
+            if (nodeB !== nodeA && nodeC === nodeA) {
+                if (nodeA.getMask(exteriorMask) && nodeB.getMask(exteriorMask)) {
+                    const mateA = nodeA.edgeMate;
+                    const mateB = nodeB.edgeMate;
+                    if (!mateA.getMask(exteriorMask) && !mateB.getMask(exteriorMask)) {
+                        nodeA.clearMask(exteriorMask);
+                        nodeB.clearMask(exteriorMask);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Triangulate the graph for the edges that have been inserted.
+     * @param applyParity if true ()
+     * @param minSplitRadians smallest allowed angle in the split sector that is split.
+     */
+    triangulateForSpine(applyParity = true, minSplitRadians = 0.3) {
+        const sMaxSplit = 20;
+        const sMinCandidateRadians = 1.0;
+        let numSplit = 0;
+        HalfEdgeGraphMerge.splitIntersectingEdges(this.graph);
+        HalfEdgeGraphMerge.clusterAndMergeXYTheta(this.graph);
+        const context1 = new RegularizationContext(this.graph);
+        context1.regularizeGraph(HalfEdgeGraphSpineContext._regularize1, false);
+        const context2 = new RegularizationContext(this.graph);
+        context2.regularizeGraph(false, HalfEdgeGraphSpineContext._regularize2);
+        if (applyParity) {
+            HalfEdgeGraphSearch.collectConnectedComponentsWithExteriorParityMasks(this.graph, new HalfEdgeMaskTester(HalfEdgeMask.BOUNDARY_EDGE), HalfEdgeMask.EXTERIOR);
+            this.purgeNullFaces(HalfEdgeMask.EXTERIOR);
+        }
+        Triangulator.triangulateAllPositiveAreaFaces(this.graph);
+        Triangulator.flipTriangles(this.graph);
+        while (numSplit++ < sMaxSplit) {
+            const numPerp = this.addPerpendicularsToBoundaries(minSplitRadians, sMinCandidateRadians);
+            if (numPerp <= 0)
+                break;
+            Triangulator.flipTriangles(this.graph);
+        }
+    }
+    // Find pseudo spine edges
+    // Optionally include pure internal midline segments.
+    // Optionally include midline segments into "dead end"
+    // Optionally include adjacent spokes to corner.
+    /**
+     * Retrieve edges of the spine as arrays of points.
+     * @param bIncludeInterior true to include fully internal segments
+     * @param bIncludeFinal true to include segments that terminate at a boundary
+     * @param bIncludeCornerSpokes
+     * @return array of line data.
+     */
+    getSpineEdges(bIncludeInterior = true, bIncludeFinal = true, bIncludeCornerSpokes = true) {
+        const xyzOut = [];
+        this._spineGraph.announceFaceLoops((_graph, faceSeed) => {
+            if (!faceSeed.getMask(HalfEdgeMask.EXTERIOR)) {
+                if (this.getSpineEdgesInTriangle(faceSeed, xyzOut, bIncludeInterior, bIncludeFinal)) {
+                }
+                else if (this.getSpineEdgesInQuad(faceSeed, xyzOut, bIncludeInterior, bIncludeFinal, bIncludeCornerSpokes)) {
+                }
+            }
+            return true;
+        });
+        return xyzOut;
+    }
+    /**
+     * Intermediate markup step to identify quads between corresponding boundary edges.
+     * * search for and mark triangle edges that should be treated as diagonal of a quad
+     * * Angle logic is:
+     *   * In a candidate quad (formed by joining triangles that share an edge)
+     *   * form segments between opposite edges of the quad.
+     *   * compute angles between these segments and the edges of their quads.
+     *   * if this angle is larger than minAngleRadians, accept this as a quad.
+     *   * recommended angle is between 15 and 5 degrees; 50 degrees is typical
+     * @param bDeleteDiagonals if true, eliminate the diagonals.
+     * @param minAngleRadians angle tolerance, as described above.
+     */
+    consolidateTrianglesToQuads(bDeleteDiagonals, minAngle = Angle.createDegrees(50)) {
+        const numDiagonal = this.setSortedDiagonalMasks(minAngle.radians);
+        if (bDeleteDiagonals && numDiagonal > 0) {
+            this.graph.yankAndDeleteEdges((node) => node.getMask(this._diagonalMask));
+        }
+        return numDiagonal;
+    }
+}
+HalfEdgeGraphSpineContext._regularize1 = true;
+HalfEdgeGraphSpineContext._regularize2 = false;
+//# sourceMappingURL=HalfEdgeGraphSpineContext.js.map