@itwin/core-geometry 5.0.0-dev.92 → 5.0.0-dev.94

package/lib/esm/polyface/IndexedPolyfaceWalker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IndexedPolyfaceWalker.d.ts","sourceRoot":"","sources":["../../../src/polyface/IndexedPolyfaceWalker.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,qBAAa,qBAAqB;IAChC,oCAAoC;IACpC,OAAO,CAAC,SAAS,CAAkB;IACnC,+CAA+C;IAC/C,OAAO,CAAC,UAAU,CAAqB;IACvC,kBAAkB;IAClB,OAAO;IAIP;;;;OAIG;IACH,IAAW,SAAS,IAAI,MAAM,GAAG,SAAS,CAEzC;IAED,0CAA0C;IAC1C,IAAW,QAAQ,IAAI,eAAe,GAAG,SAAS,CAEjD;IACD;;;OAGG;IACH,IAAW,OAAO,IAAI,OAAO,CAE5B;IACD;;;;;;OAMG;IACH,IAAW,WAAW,IAAI,OAAO,CAEhC;IACD;;;;;;OAMG;WACW,iBAAiB,CAAC,QAAQ,EAAE,eAAe,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,qBAAqB;IAKrG;;;;;;;;OAQG;WACW,kBAAkB,CAAC,QAAQ,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,EAAE,iBAAiB,GAAE,MAAU,GAAG,qBAAqB;IASrI;;;;;OAKG;WACW,eAAe,CAAC,OAAO,EAAE,sBAAsB,EAAE,iBAAiB,GAAE,MAAU,GAAG,qBAAqB;IAIpH;;;;;;OAMG;IACI,KAAK,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,qBAAqB,GAAG,SAAS;IAOnE;;;OAGG;IACI,WAAW,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO;IAM5D;;;;;;OAMG;IACI,6BAA6B,CAAC,KAAK,EAAE,qBAAqB,GAAG,OAAO;IAK3E;;;;;OAKG;IACI,UAAU,CAAC,KAAK,EAAE,qBAAqB,GAAG,OAAO;IAIxD;;;;OAIG;IACH,OAAO,CAAC,YAAY;IAOpB;;;;;;OAMG;IACI,eAAe,CAAC,MAAM,CAAC,EAAE,qBAAqB,GAAG,qBAAqB;IAa7E;;;;;;OAMG;IACI,mBAAmB,CAAC,MAAM,CAAC,EAAE,qBAAqB,GAAG,qBAAqB;IAcjF;;;;;;;OAOG;IACI,QAAQ,CAAC,MAAM,CAAC,EAAE,qBAAqB,GAAG,qBAAqB;IAGtE;;;;;;;;;OASG;IACI,gBAAgB,CAAC,MAAM,CAAC,EAAE,qBAAqB,GAAG,qBAAqB;IAI9E;;;;;;;;;OASG;IACI,oBAAoB,CAAC,MAAM,CAAC,EAAE,qBAAqB,GAAG,qBAAqB;IAKlF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;WACW,oBAAoB,CAAC,QAAQ,EAAE,eAAe;CA8B7D"}
+{"version":3,"file":"IndexedPolyfaceWalker.d.ts","sourceRoot":"","sources":["../../../src/polyface/IndexedPolyfaceWalker.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,qBAAa,qBAAqB;IAChC,oCAAoC;IACpC,OAAO,CAAC,SAAS,CAAkB;IACnC,+CAA+C;IAC/C,OAAO,CAAC,UAAU,CAAqB;IACvC,kBAAkB;IAClB,OAAO;IAIP;;;;OAIG;IACH,IAAW,SAAS,IAAI,MAAM,GAAG,SAAS,CAEzC;IAED,0CAA0C;IAC1C,IAAW,QAAQ,IAAI,eAAe,GAAG,SAAS,CAEjD;IACD;;;OAGG;IACH,IAAW,OAAO,IAAI,OAAO,CAE5B;IACD;;;;;;OAMG;IACH,IAAW,WAAW,IAAI,OAAO,CAEhC;IACD;;;;;;OAMG;WACW,iBAAiB,CAAC,QAAQ,EAAE,eAAe,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,qBAAqB;IAKrG;;;;;;;;OAQG;WACW,kBAAkB,CAAC,QAAQ,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,EAAE,iBAAiB,GAAE,MAAU,GAAG,qBAAqB;IASrI;;;;;OAKG;WACW,eAAe,CAAC,OAAO,EAAE,sBAAsB,EAAE,iBAAiB,GAAE,MAAU,GAAG,qBAAqB;IAIpH;;;;;;OAMG;IACI,KAAK,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,qBAAqB,GAAG,SAAS;IAOnE;;;OAGG;IACI,WAAW,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO;IAM5D;;;;;;OAMG;IACI,6BAA6B,CAAC,KAAK,EAAE,qBAAqB,GAAG,OAAO;IAK3E;;;;;OAKG;IACI,UAAU,CAAC,KAAK,EAAE,qBAAqB,GAAG,OAAO;IAIxD;;;;OAIG;IACH,OAAO,CAAC,YAAY;IAOpB;;;;;;OAMG;IACI,eAAe,CAAC,MAAM,CAAC,EAAE,qBAAqB,GAAG,qBAAqB;IAa7E;;;;;;OAMG;IACI,mBAAmB,CAAC,MAAM,CAAC,EAAE,qBAAqB,GAAG,qBAAqB;IAcjF;;;;;;;OAOG;IACI,QAAQ,CAAC,MAAM,CAAC,EAAE,qBAAqB,GAAG,qBAAqB;IAGtE;;;;;;;;;OASG;IACI,gBAAgB,CAAC,MAAM,CAAC,EAAE,qBAAqB,GAAG,qBAAqB;IAI9E;;;;;;;;;OASG;IACI,oBAAoB,CAAC,MAAM,CAAC,EAAE,qBAAqB,GAAG,qBAAqB;IAKlF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;WACW,oBAAoB,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI;CA8BpE"}

package/lib/esm/polyface/IndexedPolyfaceWalker.js.map

@@ -1 +1 @@
-{"version":3,"file":"IndexedPolyfaceWalker.js","sourceRoot":"","sources":["../../../src/polyface/IndexedPolyfaceWalker.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 Polyface\n */\n\nimport { IndexedEdgeMatcher, SortableEdgeCluster } from \"./IndexedEdgeMatcher\";\nimport { IndexedPolyfaceVisitor } from \"./IndexedPolyfaceVisitor\";\nimport { IndexedPolyface } from \"./Polyface\";\n\n/**\n * The `IndexedPolyfaceWalker` class supports navigation around facets, across edges, and around vertices in an\n * [[IndexedPolyface]].\n * * Compare to the [[IndexedPolyfaceVisitor]] class, which supports the iteration of facets in an `IndexedPolyface`.\n * * A one-time call to [[buildEdgeMateIndices]] creates and populates the `data.edgeMateIndex` array on the input.\n *   * This array essentially completes the topology of the `IndexedPolyface` by storing facet adjacency.\n * * After this setup, caller code can create `IndexedPolyfaceWalker` objects via:\n *   * `walker = IndexedPolyfaceWalker.createAtFacetIndex(polyface, facetIndex, offsetWithinFacet)`\n *   * `walker = IndexedPolyfaceWalker.createAtEdgeIndex(polyface, edgeIndex)`\n *   * `walker = IndexedPolyfaceWalker.createAtVisitor(visitor, offsetWithinFacet)`\n * * Once you have a walker object, you can traverse the facet, edge, and vertex loops it references. For\n * example, if `walker.edgeIndex === A`, referring to the right edge of the upper left facet pictured below, then\n * the following are true:\n *   * `walker.nextAroundFacet().edgeIndex === B`\n *   * `walker.previousAroundFacet().edgeIndex === C`\n *   * `walker.edgeMate().edgeIndex === F`\n *   * `walker.nextAroundVertex().edgeIndex === E`\n *   * `walker.previousAroundVertex().edgeIndex === D`\n* ```\n *      # --------- # --------- #\n *      |   < < < B | F         |\n *      |         ^ | v         |\n *      |         ^ | v         |\n *      |         ^ | v         |\n *      | C > > > A | D > > >   |\n *      # --------- # --------- #\n *      |   < < < E |           |\n *      |           |           |\n *      |           |           |\n *      |           |           |\n *      # --------- # --------- #\n * ```\n* * When facets are viewed so that the face loops stored in the [[PolyfaceData]] `pointIndex` array have\n * counterclockwise ordering, an edge \"from A to B\" has facet area to the left and the edge to the right. Likewise,\n * the edges \"out of\" locations B, C, E, F, D are directed as depicted above.\n * * With this conventional counterclockwise ordering of face loops, \"next\" is counterclockwise, and \"previous\" is\n * clockwise:\n *   * The [[nextAroundFacet]] step is counterclockwise around the facet.\n *   * The [[previousAroundFacet]] step is clockwise around the facet.\n *   * The [[nextAroundVertex]] step is counterclockwise around the vertex.\n *   * The [[previousAroundVertex]] step is clockwise around the vertex.\n * * The `nextAroundFacet` steps for a walker and its [[edgeMate]] are in opposite directions along their shared edge,\n * when that edge is interior. Thus the `edgeMate` step can be seen to iterate an \"edge loop\" of two locations for an\n * interior edges.\n * * Invalid Walkers:\n *   * An invalid walker has undefined [[edgeIndex]]. For these walkers, [[isUndefined]] returns true, and [[isValid]]\n * returns false. Traversal operations on an invalid walker return an invalid walker.\n *   * Invalid walkers are expected during traversals of a mesh with boundary edges, so calling code must be prepared.\n * Boundary edges have exactly one adjacent facet, so for these edges the `edgeMate` step returns an invalid walker.\n * In the diagram above, the `edgeMate` of boundary edge B is undefined.\n *   * Invalid walkers can occur while traversing boundary vertices as well. If an edge lacks an `edgeMate`, then the\n * `previousAroundVertex` step yields an invalid walker, because `previousAroundVertex` is implemented as `edgeMate`\n * followed by `nextAroundFacet`. In the diagram above, the `previousAroundVertex` step at boundary edge B yields\n * undefined walker. Similarly, the `nextAroundVertex` step at edge F yields undefined walker.\n *   * Invalid walkers can also occur while traversing a non-manifold mesh. Such meshes feature edge(s) with more than\n * two adjacent facets, or with two adjacent facets that have opposite orientations. These meshes are uncommon, and\n * usually indicate a construction problem.\n * * See [[buildEdgeMateIndices]] for further description of the topological relations.\n * @public\n */\nexport class IndexedPolyfaceWalker {\n  /** The polyface being traversed. */\n  private _polyface: IndexedPolyface;\n  /** The current edgeIndex into the polyface. */\n  private _edgeIndex: number | undefined;\n  /** Constructor */\n  private constructor(polyface: IndexedPolyface, edgeIndex: number | undefined) {\n    this._polyface = polyface;\n    this._edgeIndex = edgeIndex;\n  }\n  /**\n   * Return the edge index of this walker.\n   * * This is an index into the polyface's `data.pointIndex` array.\n   * * Can be undefined.\n   */\n  public get edgeIndex(): number | undefined {\n    return this._edgeIndex;\n  }\n\n  /** Return the polyface of this walker. */\n  public get polyface(): IndexedPolyface | undefined {\n    return this._polyface;\n  }\n  /**\n   * Return true if the walker's edgeIndex is defined.\n   * * This method is the opposite of [[isUndefined]].\n   */\n  public get isValid(): boolean {\n    return this._edgeIndex !== undefined;\n  }\n  /**\n   * Return true if the walker's edgeIndex is undefined.\n   * * This method is the opposite of [[isValid]].\n   * * This can happen during a walk when the walker `w` reaches an exterior edge, for then\n   * `w.edgeMate(w).isUndefined === true`.\n   * * This can also happen when methods that return a walker receive invalid input.\n   */\n  public get isUndefined(): boolean {\n    return this._edgeIndex === undefined;\n  }\n  /**\n   * Create a walker for a given polyface at an optional edge.\n   * @param polyface reference to the client polyface. This reference is captured (the polyface is not copied).\n   * @param edgeIndex optional indication of where to start the walker within the mesh.\n   * * If the edgeIndex is valid for the input polyface, the new walker is started there.\n   * * If the edgeIndex is undefined or invalid for the input polyface, the walker returns true for [[isUndefined]].\n   */\n  public static createAtEdgeIndex(polyface: IndexedPolyface, edgeIndex?: number): IndexedPolyfaceWalker {\n    if (!polyface.data.isValidEdgeIndex(edgeIndex))\n      edgeIndex = undefined;\n    return new IndexedPolyfaceWalker(polyface, edgeIndex);\n  }\n  /**\n   * Create a walker for a given polyface at a specified facet.\n   * * If `facetIndex` or `offsetWithinFacet` is invalid for the input polyface, the walker returns true for\n   * [[isUndefined]].\n   * @param polyface the polyface to reference\n   * @param facetIndex index of the facet to reference\n   * @param offsetWithinFacet optional 0-based offset within the face loop of the facet (default 0). This allows\n   * the caller to start the walker at a particular edge of the facet.\n   */\n  public static createAtFacetIndex(polyface: IndexedPolyface, facetIndex: number, offsetWithinFacet: number = 0): IndexedPolyfaceWalker {\n    if (polyface.isValidFacetIndex(facetIndex)) {\n      const k0 = polyface.facetIndex0(facetIndex);\n      const k1 = polyface.facetIndex1(facetIndex);\n      if (0 <= offsetWithinFacet && k0 + offsetWithinFacet < k1)\n        return new IndexedPolyfaceWalker(polyface, k0 + offsetWithinFacet);\n    }\n    return new IndexedPolyfaceWalker(polyface, undefined);\n  }\n  /**\n   * Create a walker at the facet specified by a visitor.\n   * @param visitor visitor whose currentReadIndex identifies the facet.\n   * @param offsetWithinFacet optional 0-based offset within the face loop of the facet (default 0). This allows\n   * the caller to start the walker at a particular edge of the facet.\n   */\n  public static createAtVisitor(visitor: IndexedPolyfaceVisitor, offsetWithinFacet: number = 0): IndexedPolyfaceWalker {\n    const facetIndex = visitor.currentReadIndex();\n    return IndexedPolyfaceWalker.createAtFacetIndex(visitor.clientPolyface(), facetIndex, offsetWithinFacet);\n  }\n  /**\n   * Create a new IndexedPolyfaceWalker from the instance.\n   * * The returned walker refers to the same polyface.\n   * * If `edgeIndex` is undefined, the returned walker refers to the same edge as the instance.\n   * * If `edgeIndex` is defined and valid, the returned walker refers to this edge.\n   * * If `edgeIndex` is defined but invalid, return undefined.\n   */\n  public clone(edgeIndex?: number): IndexedPolyfaceWalker | undefined {\n    if (edgeIndex === undefined)\n      edgeIndex = this._edgeIndex;\n    if (this._polyface.data.isValidEdgeIndex(edgeIndex))\n      return new IndexedPolyfaceWalker(this._polyface, edgeIndex);\n    return undefined;\n  }\n  /**\n   * Load the walker's facet into the given visitor.\n   * @returns true if the visitor and walker reference the same polyface and the walker has a valid edge index.\n   */\n  public loadVisitor(visitor: IndexedPolyfaceVisitor): boolean {\n    if (visitor.clientPolyface() !== this._polyface)\n      return false;\n    const facetIndex = this._polyface.edgeIndexToFacetIndex(this._edgeIndex);\n    return (facetIndex !== undefined) ? visitor.moveToReadIndex(facetIndex) : false;\n  }\n  /**\n   * Test if two walkers are at different edges in the same polyface.\n   * * If either has undefined edge, return false.\n   * * If they are in different polyfaces, return false.\n   * * If they are the same edge in the same polyface, return false.\n   * * Otherwise return true.\n   */\n  public isDifferentEdgeInSamePolyface(other: IndexedPolyfaceWalker): boolean {\n    if (this.isUndefined || other.isUndefined)\n      return false;\n    return this._polyface === other._polyface && this._edgeIndex !== other.edgeIndex;\n  }\n  /**\n   * Test if two walkers are in the same polyface at the same edge.\n   * * If either has undefined edge, return false.\n   * * If they are in different polyfaces, return false.\n   * * If they are the same edge in the same polyface, return true.\n   */\n  public isSameEdge(other: IndexedPolyfaceWalker): boolean {\n    return this._polyface === other._polyface && this.isValid && this._edgeIndex === other._edgeIndex;\n  }\n\n  /**\n   * Return a walker with given edgeIndex and polyface from the calling instance.\n   * * If `result` is supplied, that walker is filled and returned.\n   * * If `result` is not supplied, a new walker is created.\n   */\n  private createResult(result: undefined | IndexedPolyfaceWalker, edgeIndex: undefined | number): IndexedPolyfaceWalker {\n    if (result === undefined)\n      return new IndexedPolyfaceWalker(this._polyface, edgeIndex);\n    result._polyface = this._polyface;\n    result._edgeIndex = edgeIndex;\n    return result;\n  }\n  /**\n   * Return a walker (new or reused) at the next edge around the facet.\n   * * \"Next\" is in the order of indices in the face loop of this facet.\n   * * If the instance has undefined edgeIndex, the result also has undefined edgeIndex.\n   * @param result optional receiver to modify and return. May be the same as `this` to move the instance walker\n   * to the new location and return it.\n   */\n  public nextAroundFacet(result?: IndexedPolyfaceWalker): IndexedPolyfaceWalker {\n    const k = this._edgeIndex;\n    if (k === undefined)\n      return this.createResult(result, undefined);\n    const facetIndex = this._polyface.edgeIndexToFacetIndex(k);\n    if (facetIndex === undefined)\n      return this.createResult(result, undefined);\n    const k2 = this._polyface.facetIndex1(facetIndex);\n    const k1 = k + 1;\n    if (k1 < k2)\n      return this.createResult(result, k1);\n    return this.createResult(result, this._polyface.facetIndex0(facetIndex));\n  }\n  /**\n   * Return a walker (new or reused) at the previous edge around the facet.\n   * * \"Previous\" is in the reverse order of indices in the face loop of this facet.\n   * * If the instance has undefined edgeIndex, the result also has undefined edgeIndex.\n   * @param result optional receiver to modify and return. May be the same as `this` to move the instance walker\n   * to the new location and return it.\n   */\n  public previousAroundFacet(result?: IndexedPolyfaceWalker): IndexedPolyfaceWalker {\n    let k = this._edgeIndex;\n    if (k === undefined)\n      return this.createResult(result, undefined);\n    const facetIndex = this._polyface.edgeIndexToFacetIndex(k);\n    if (facetIndex === undefined)\n      return this.createResult(result, undefined);\n    const k0 = this._polyface.facetIndex0(facetIndex);\n    if (k === k0)\n      k = this._polyface.facetIndex1(facetIndex) - 1;\n    else\n      k--;\n    return this.createResult(result, k);\n  }\n  /**\n   * Return a walker (new or reused) at the edge mate of this walker's edge.\n   * * The returned walker has undefined edgeIndex if:\n   *   * the instance is at a boundary edge, i.e., there is no facet on the other side, or\n   *   * the instance has undefined edgeIndex.\n   * @param result optional receiver to modify and return. May be the same as `this` to move the instance walker\n   * to the new location and return it.\n   */\n  public edgeMate(result?: IndexedPolyfaceWalker): IndexedPolyfaceWalker {\n    return this.createResult(result, this._polyface.data.edgeIndexToEdgeMateIndex(this._edgeIndex));\n  }\n  /**\n   * Return a walker (new or reused) at the next outbound edge around the vertex at the base of this walker's edge.\n   * * If the facet is viewed so that its \"nextAroundFacet\" direction appears counterclockwise, then the \"next\"\n   * outbound edge is counterclockwise around the base vertex.\n   * * The returned walker has undefined edgeIndex if:\n   *   * the previous edge around the facet is a boundary edge, i.e., there is no facet on the other side, or\n   *   * the instance has undefined edgeIndex.\n   * @param result optional receiver to modify and return. May be the same as `this` to move the instance walker\n   * to the new location and return it.\n   */\n  public nextAroundVertex(result?: IndexedPolyfaceWalker): IndexedPolyfaceWalker {\n    const result1 = this.previousAroundFacet(result);\n    return result1.edgeMate(result1);\n  }\n  /**\n   * Return a walker (new or reused) at the previous outbound edge around the vertex at the base of this walker's edge.\n   * * If the facet is viewed so that its \"nextAroundFacet\" direction appears counterclockwise, then the \"previous\"\n   * outbound edge is clockwise around the base vertex.\n   * * The returned walker has undefined edgeIndex if:\n   *   * the instance edge is a boundary edge, i.e., there is no facet on the other side, or\n   *   * the instance has undefined edgeIndex.\n   * @param result optional receiver to modify and return. May be the same as `this` to move the instance walker\n   * to the new location and return it.\n   */\n  public previousAroundVertex(result?: IndexedPolyfaceWalker): IndexedPolyfaceWalker {\n    const result1 = this.edgeMate(result);\n    return result1.nextAroundFacet(result1);\n  }\n\n  /**\n   * Build the edgeMate index array into the polyface's [[PolyfaceData]].\n   * After this method:\n   * * The array `polyface.data.edgeMateIndex` is defined with the same length as the other PolyfaceData index arrays.\n   * * For each interior edge, `polyface.data.edgeIndexToEdgeMateIndex` returns the edgeIndex on the other side of the\n   * edge in the adjacent facet.\n   * * The conditions for edgeMate matching are:\n   *   * Given facetIndex f, let `k0 = polyface.facetIndex0(f)` and `k1 = polyface.facetIndex1(f)`.\n   *   * Every edgeIndex k in the face loop of facet f satisfies `k0 <= k < k1`.\n   *   * The edge with edgeIndex k starts at the point with index `polyface.data.pointIndex[k]`.\n   *   * Let kA be an edgeIndex in this range [k0,k1), and let kB be its in-range successor with cyclic wrap, i.e.,\n   * `kB === (kA + 1 === k1) ? k0 : kA + 1`.\n   *   * Then `polyface.data.pointIndex[kA]` and `polyface.data.pointIndex[kB]` are the indices of the points at the\n   * start and end of an edge of that facet.\n   *   * We call kA the _edgeIndex_ for that edge, and kB the _edgeIndex_ for the next edge around the facet.\n   *   * If kA is an interior edge in a 2-manifold mesh with properly oriented facets, then there is an adjacent facet\n   * whose face loop contains edgeIndices kC and kD referencing the same edge vertices in reverse order, i.e.,\n   *     * `polyface.data.pointIndex[kA] === polyface.data.pointIndex[kD]`\n   *     * `polyface.data.pointIndex[kB] === polyface.data.pointIndex[kC]`\n   *   * Given this relationship, we say that edgeIndices kA and kC are _edge mates_.\n   *   * A non-interior edge either lies on the boundary of the mesh or is non-manifold (having more than two adjacent\n   * facets, or one with the wrong orientation). These edges have no edge mate.\n   * * These conditions define a conventional manifold mesh where each edge of a facet has at most one partner edge with\n   * opposite orientation in an adjacent facet.\n   * * After calling this method, the caller can construct `IndexedPolyfaceWalker` objects to traverse the mesh by\n   * walking across edges, around faces, and around vertices. Let walkerA have edgeIndex value kA. Then with the\n   * aforementioned edgeIndices:\n   *   * `walkerC = walkerA.edgeMate()` moves across the edge to its other end, at kC.\n   *   * `walkerB = walkerA.nextAroundFacet()` moves around the facet to the next edge, at kB.\n   *   * `walkerB.previousAroundFacet()` moves from kB back to kA.\n   *   * `walkerD = walkerA.previousAroundVertex()` moves around the vertex to the next edge kD.\n   *   * `walkerD1 = walkerC.nextAroundFacet()` also moves to kD.\n   *   * `walkerD.nextAroundVertex()` moves from kD back to kA.\n   */\n  public static buildEdgeMateIndices(polyface: IndexedPolyface) {\n    const matcher = new IndexedEdgeMatcher();\n    const numFacet = polyface.facetCount;\n    for (let facetIndex = 0; facetIndex < numFacet; facetIndex++) {\n      const kStart = polyface.facetIndex0(facetIndex);\n      const kEnd = polyface.facetIndex1(facetIndex);\n      let k0 = kEnd - 1;\n      // sneaky: addEdge 3rd arg is edgeIndex k0 instead of facetIndex; it gets carried around during matching\n      for (let k1 = kStart; k1 < kEnd; k0 = k1, k1++)\n        matcher.addEdge(polyface.data.pointIndex[k0], polyface.data.pointIndex[k1], k0);\n    }\n    const matchedPairs: SortableEdgeCluster[] = [];\n    const singletons: SortableEdgeCluster[] = [];\n    const nullEdges: SortableEdgeCluster[] = [];\n    const allOtherClusters: SortableEdgeCluster[] = [];\n    matcher.sortAndCollectClusters(matchedPairs, singletons, nullEdges, allOtherClusters);\n\n    const numIndex = polyface.data.pointIndex.length;\n    polyface.data.edgeMateIndex = new Array<number | undefined>(numIndex);\n    for (let i = 0; i < numIndex; i++)\n      polyface.data.edgeMateIndex[i] = undefined;\n    for (const pair of matchedPairs) {\n      if (Array.isArray(pair) && pair.length === 2) {\n        const k0 = pair[0].facetIndex;\n        const k1 = pair[1].facetIndex;\n        polyface.data.edgeMateIndex[k0] = k1;\n        polyface.data.edgeMateIndex[k1] = k0;\n      }\n    }\n  }\n}\n\n"]}
+{"version":3,"file":"IndexedPolyfaceWalker.js","sourceRoot":"","sources":["../../../src/polyface/IndexedPolyfaceWalker.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 Polyface\n */\n\nimport { IndexedEdgeMatcher, SortableEdgeCluster } from \"./IndexedEdgeMatcher\";\nimport { IndexedPolyfaceVisitor } from \"./IndexedPolyfaceVisitor\";\nimport { IndexedPolyface } from \"./Polyface\";\n\n/**\n * The `IndexedPolyfaceWalker` class supports navigation around facets, across edges, and around vertices in an\n * [[IndexedPolyface]].\n * * Compare to the [[IndexedPolyfaceVisitor]] class, which supports the iteration of facets in an `IndexedPolyface`.\n * * A one-time call to [[buildEdgeMateIndices]] creates and populates the `data.edgeMateIndex` array on the input.\n *   * This array essentially completes the topology of the `IndexedPolyface` by storing facet adjacency.\n * * After this setup, caller code can create `IndexedPolyfaceWalker` objects via:\n *   * `walker = IndexedPolyfaceWalker.createAtFacetIndex(polyface, facetIndex, offsetWithinFacet)`\n *   * `walker = IndexedPolyfaceWalker.createAtEdgeIndex(polyface, edgeIndex)`\n *   * `walker = IndexedPolyfaceWalker.createAtVisitor(visitor, offsetWithinFacet)`\n * * Once you have a walker object, you can traverse the facet, edge, and vertex loops it references. For\n * example, if `walker.edgeIndex === A`, referring to the right edge of the upper left facet pictured below, then\n * the following are true:\n *   * `walker.nextAroundFacet().edgeIndex === B`\n *   * `walker.previousAroundFacet().edgeIndex === C`\n *   * `walker.edgeMate().edgeIndex === F`\n *   * `walker.nextAroundVertex().edgeIndex === E`\n *   * `walker.previousAroundVertex().edgeIndex === D`\n* ```\n *      # --------- # --------- #\n *      |   < < < B | F         |\n *      |         ^ | v         |\n *      |         ^ | v         |\n *      |         ^ | v         |\n *      | C > > > A | D > > >   |\n *      # --------- # --------- #\n *      |   < < < E |           |\n *      |           |           |\n *      |           |           |\n *      |           |           |\n *      # --------- # --------- #\n * ```\n* * When facets are viewed so that the face loops stored in the [[PolyfaceData]] `pointIndex` array have\n * counterclockwise ordering, an edge \"from A to B\" has facet area to the left and the edge to the right. Likewise,\n * the edges \"out of\" locations B, C, E, F, D are directed as depicted above.\n * * With this conventional counterclockwise ordering of face loops, \"next\" is counterclockwise, and \"previous\" is\n * clockwise:\n *   * The [[nextAroundFacet]] step is counterclockwise around the facet.\n *   * The [[previousAroundFacet]] step is clockwise around the facet.\n *   * The [[nextAroundVertex]] step is counterclockwise around the vertex.\n *   * The [[previousAroundVertex]] step is clockwise around the vertex.\n * * The `nextAroundFacet` steps for a walker and its [[edgeMate]] are in opposite directions along their shared edge,\n * when that edge is interior. Thus the `edgeMate` step can be seen to iterate an \"edge loop\" of two locations for an\n * interior edges.\n * * Invalid Walkers:\n *   * An invalid walker has undefined [[edgeIndex]]. For these walkers, [[isUndefined]] returns true, and [[isValid]]\n * returns false. Traversal operations on an invalid walker return an invalid walker.\n *   * Invalid walkers are expected during traversals of a mesh with boundary edges, so calling code must be prepared.\n * Boundary edges have exactly one adjacent facet, so for these edges the `edgeMate` step returns an invalid walker.\n * In the diagram above, the `edgeMate` of boundary edge B is undefined.\n *   * Invalid walkers can occur while traversing boundary vertices as well. If an edge lacks an `edgeMate`, then the\n * `previousAroundVertex` step yields an invalid walker, because `previousAroundVertex` is implemented as `edgeMate`\n * followed by `nextAroundFacet`. In the diagram above, the `previousAroundVertex` step at boundary edge B yields\n * undefined walker. Similarly, the `nextAroundVertex` step at edge F yields undefined walker.\n *   * Invalid walkers can also occur while traversing a non-manifold mesh. Such meshes feature edge(s) with more than\n * two adjacent facets, or with two adjacent facets that have opposite orientations. These meshes are uncommon, and\n * usually indicate a construction problem.\n * * See [[buildEdgeMateIndices]] for further description of the topological relations.\n * @public\n */\nexport class IndexedPolyfaceWalker {\n  /** The polyface being traversed. */\n  private _polyface: IndexedPolyface;\n  /** The current edgeIndex into the polyface. */\n  private _edgeIndex: number | undefined;\n  /** Constructor */\n  private constructor(polyface: IndexedPolyface, edgeIndex: number | undefined) {\n    this._polyface = polyface;\n    this._edgeIndex = edgeIndex;\n  }\n  /**\n   * Return the edge index of this walker.\n   * * This is an index into the polyface's `data.pointIndex` array.\n   * * Can be undefined.\n   */\n  public get edgeIndex(): number | undefined {\n    return this._edgeIndex;\n  }\n\n  /** Return the polyface of this walker. */\n  public get polyface(): IndexedPolyface | undefined {\n    return this._polyface;\n  }\n  /**\n   * Return true if the walker's edgeIndex is defined.\n   * * This method is the opposite of [[isUndefined]].\n   */\n  public get isValid(): boolean {\n    return this._edgeIndex !== undefined;\n  }\n  /**\n   * Return true if the walker's edgeIndex is undefined.\n   * * This method is the opposite of [[isValid]].\n   * * This can happen during a walk when the walker `w` reaches an exterior edge, for then\n   * `w.edgeMate(w).isUndefined === true`.\n   * * This can also happen when methods that return a walker receive invalid input.\n   */\n  public get isUndefined(): boolean {\n    return this._edgeIndex === undefined;\n  }\n  /**\n   * Create a walker for a given polyface at an optional edge.\n   * @param polyface reference to the client polyface. This reference is captured (the polyface is not copied).\n   * @param edgeIndex optional indication of where to start the walker within the mesh.\n   * * If the edgeIndex is valid for the input polyface, the new walker is started there.\n   * * If the edgeIndex is undefined or invalid for the input polyface, the walker returns true for [[isUndefined]].\n   */\n  public static createAtEdgeIndex(polyface: IndexedPolyface, edgeIndex?: number): IndexedPolyfaceWalker {\n    if (!polyface.data.isValidEdgeIndex(edgeIndex))\n      edgeIndex = undefined;\n    return new IndexedPolyfaceWalker(polyface, edgeIndex);\n  }\n  /**\n   * Create a walker for a given polyface at a specified facet.\n   * * If `facetIndex` or `offsetWithinFacet` is invalid for the input polyface, the walker returns true for\n   * [[isUndefined]].\n   * @param polyface the polyface to reference\n   * @param facetIndex index of the facet to reference\n   * @param offsetWithinFacet optional 0-based offset within the face loop of the facet (default 0). This allows\n   * the caller to start the walker at a particular edge of the facet.\n   */\n  public static createAtFacetIndex(polyface: IndexedPolyface, facetIndex: number, offsetWithinFacet: number = 0): IndexedPolyfaceWalker {\n    if (polyface.isValidFacetIndex(facetIndex)) {\n      const k0 = polyface.facetIndex0(facetIndex);\n      const k1 = polyface.facetIndex1(facetIndex);\n      if (0 <= offsetWithinFacet && k0 + offsetWithinFacet < k1)\n        return new IndexedPolyfaceWalker(polyface, k0 + offsetWithinFacet);\n    }\n    return new IndexedPolyfaceWalker(polyface, undefined);\n  }\n  /**\n   * Create a walker at the facet specified by a visitor.\n   * @param visitor visitor whose currentReadIndex identifies the facet.\n   * @param offsetWithinFacet optional 0-based offset within the face loop of the facet (default 0). This allows\n   * the caller to start the walker at a particular edge of the facet.\n   */\n  public static createAtVisitor(visitor: IndexedPolyfaceVisitor, offsetWithinFacet: number = 0): IndexedPolyfaceWalker {\n    const facetIndex = visitor.currentReadIndex();\n    return IndexedPolyfaceWalker.createAtFacetIndex(visitor.clientPolyface(), facetIndex, offsetWithinFacet);\n  }\n  /**\n   * Create a new IndexedPolyfaceWalker from the instance.\n   * * The returned walker refers to the same polyface.\n   * * If `edgeIndex` is undefined, the returned walker refers to the same edge as the instance.\n   * * If `edgeIndex` is defined and valid, the returned walker refers to this edge.\n   * * If `edgeIndex` is defined but invalid, return undefined.\n   */\n  public clone(edgeIndex?: number): IndexedPolyfaceWalker | undefined {\n    if (edgeIndex === undefined)\n      edgeIndex = this._edgeIndex;\n    if (this._polyface.data.isValidEdgeIndex(edgeIndex))\n      return new IndexedPolyfaceWalker(this._polyface, edgeIndex);\n    return undefined;\n  }\n  /**\n   * Load the walker's facet into the given visitor.\n   * @returns true if the visitor and walker reference the same polyface and the walker has a valid edge index.\n   */\n  public loadVisitor(visitor: IndexedPolyfaceVisitor): boolean {\n    if (visitor.clientPolyface() !== this._polyface)\n      return false;\n    const facetIndex = this._polyface.edgeIndexToFacetIndex(this._edgeIndex);\n    return (facetIndex !== undefined) ? visitor.moveToReadIndex(facetIndex) : false;\n  }\n  /**\n   * Test if two walkers are at different edges in the same polyface.\n   * * If either has undefined edge, return false.\n   * * If they are in different polyfaces, return false.\n   * * If they are the same edge in the same polyface, return false.\n   * * Otherwise return true.\n   */\n  public isDifferentEdgeInSamePolyface(other: IndexedPolyfaceWalker): boolean {\n    if (this.isUndefined || other.isUndefined)\n      return false;\n    return this._polyface === other._polyface && this._edgeIndex !== other.edgeIndex;\n  }\n  /**\n   * Test if two walkers are in the same polyface at the same edge.\n   * * If either has undefined edge, return false.\n   * * If they are in different polyfaces, return false.\n   * * If they are the same edge in the same polyface, return true.\n   */\n  public isSameEdge(other: IndexedPolyfaceWalker): boolean {\n    return this._polyface === other._polyface && this.isValid && this._edgeIndex === other._edgeIndex;\n  }\n\n  /**\n   * Return a walker with given edgeIndex and polyface from the calling instance.\n   * * If `result` is supplied, that walker is filled and returned.\n   * * If `result` is not supplied, a new walker is created.\n   */\n  private createResult(result: undefined | IndexedPolyfaceWalker, edgeIndex: undefined | number): IndexedPolyfaceWalker {\n    if (result === undefined)\n      return new IndexedPolyfaceWalker(this._polyface, edgeIndex);\n    result._polyface = this._polyface;\n    result._edgeIndex = edgeIndex;\n    return result;\n  }\n  /**\n   * Return a walker (new or reused) at the next edge around the facet.\n   * * \"Next\" is in the order of indices in the face loop of this facet.\n   * * If the instance has undefined edgeIndex, the result also has undefined edgeIndex.\n   * @param result optional receiver to modify and return. May be the same as `this` to move the instance walker\n   * to the new location and return it.\n   */\n  public nextAroundFacet(result?: IndexedPolyfaceWalker): IndexedPolyfaceWalker {\n    const k = this._edgeIndex;\n    if (k === undefined)\n      return this.createResult(result, undefined);\n    const facetIndex = this._polyface.edgeIndexToFacetIndex(k);\n    if (facetIndex === undefined)\n      return this.createResult(result, undefined);\n    const k2 = this._polyface.facetIndex1(facetIndex);\n    const k1 = k + 1;\n    if (k1 < k2)\n      return this.createResult(result, k1);\n    return this.createResult(result, this._polyface.facetIndex0(facetIndex));\n  }\n  /**\n   * Return a walker (new or reused) at the previous edge around the facet.\n   * * \"Previous\" is in the reverse order of indices in the face loop of this facet.\n   * * If the instance has undefined edgeIndex, the result also has undefined edgeIndex.\n   * @param result optional receiver to modify and return. May be the same as `this` to move the instance walker\n   * to the new location and return it.\n   */\n  public previousAroundFacet(result?: IndexedPolyfaceWalker): IndexedPolyfaceWalker {\n    let k = this._edgeIndex;\n    if (k === undefined)\n      return this.createResult(result, undefined);\n    const facetIndex = this._polyface.edgeIndexToFacetIndex(k);\n    if (facetIndex === undefined)\n      return this.createResult(result, undefined);\n    const k0 = this._polyface.facetIndex0(facetIndex);\n    if (k === k0)\n      k = this._polyface.facetIndex1(facetIndex) - 1;\n    else\n      k--;\n    return this.createResult(result, k);\n  }\n  /**\n   * Return a walker (new or reused) at the edge mate of this walker's edge.\n   * * The returned walker has undefined edgeIndex if:\n   *   * the instance is at a boundary edge, i.e., there is no facet on the other side, or\n   *   * the instance has undefined edgeIndex.\n   * @param result optional receiver to modify and return. May be the same as `this` to move the instance walker\n   * to the new location and return it.\n   */\n  public edgeMate(result?: IndexedPolyfaceWalker): IndexedPolyfaceWalker {\n    return this.createResult(result, this._polyface.data.edgeIndexToEdgeMateIndex(this._edgeIndex));\n  }\n  /**\n   * Return a walker (new or reused) at the next outbound edge around the vertex at the base of this walker's edge.\n   * * If the facet is viewed so that its \"nextAroundFacet\" direction appears counterclockwise, then the \"next\"\n   * outbound edge is counterclockwise around the base vertex.\n   * * The returned walker has undefined edgeIndex if:\n   *   * the previous edge around the facet is a boundary edge, i.e., there is no facet on the other side, or\n   *   * the instance has undefined edgeIndex.\n   * @param result optional receiver to modify and return. May be the same as `this` to move the instance walker\n   * to the new location and return it.\n   */\n  public nextAroundVertex(result?: IndexedPolyfaceWalker): IndexedPolyfaceWalker {\n    const result1 = this.previousAroundFacet(result);\n    return result1.edgeMate(result1);\n  }\n  /**\n   * Return a walker (new or reused) at the previous outbound edge around the vertex at the base of this walker's edge.\n   * * If the facet is viewed so that its \"nextAroundFacet\" direction appears counterclockwise, then the \"previous\"\n   * outbound edge is clockwise around the base vertex.\n   * * The returned walker has undefined edgeIndex if:\n   *   * the instance edge is a boundary edge, i.e., there is no facet on the other side, or\n   *   * the instance has undefined edgeIndex.\n   * @param result optional receiver to modify and return. May be the same as `this` to move the instance walker\n   * to the new location and return it.\n   */\n  public previousAroundVertex(result?: IndexedPolyfaceWalker): IndexedPolyfaceWalker {\n    const result1 = this.edgeMate(result);\n    return result1.nextAroundFacet(result1);\n  }\n\n  /**\n   * Build the edgeMate index array into the polyface's [[PolyfaceData]].\n   * After this method:\n   * * The array `polyface.data.edgeMateIndex` is defined with the same length as the other PolyfaceData index arrays.\n   * * For each interior edge, `polyface.data.edgeIndexToEdgeMateIndex` returns the edgeIndex on the other side of the\n   * edge in the adjacent facet.\n   * * The conditions for edgeMate matching are:\n   *   * Given facetIndex f, let `k0 = polyface.facetIndex0(f)` and `k1 = polyface.facetIndex1(f)`.\n   *   * Every edgeIndex k in the face loop of facet f satisfies `k0 <= k < k1`.\n   *   * The edge with edgeIndex k starts at the point with index `polyface.data.pointIndex[k]`.\n   *   * Let kA be an edgeIndex in this range [k0,k1), and let kB be its in-range successor with cyclic wrap, i.e.,\n   * `kB === (kA + 1 === k1) ? k0 : kA + 1`.\n   *   * Then `polyface.data.pointIndex[kA]` and `polyface.data.pointIndex[kB]` are the indices of the points at the\n   * start and end of an edge of that facet.\n   *   * We call kA the _edgeIndex_ for that edge, and kB the _edgeIndex_ for the next edge around the facet.\n   *   * If kA is an interior edge in a 2-manifold mesh with properly oriented facets, then there is an adjacent facet\n   * whose face loop contains edgeIndices kC and kD referencing the same edge vertices in reverse order, i.e.,\n   *     * `polyface.data.pointIndex[kA] === polyface.data.pointIndex[kD]`\n   *     * `polyface.data.pointIndex[kB] === polyface.data.pointIndex[kC]`\n   *   * Given this relationship, we say that edgeIndices kA and kC are _edge mates_.\n   *   * A non-interior edge either lies on the boundary of the mesh or is non-manifold (having more than two adjacent\n   * facets, or one with the wrong orientation). These edges have no edge mate.\n   * * These conditions define a conventional manifold mesh where each edge of a facet has at most one partner edge with\n   * opposite orientation in an adjacent facet.\n   * * After calling this method, the caller can construct `IndexedPolyfaceWalker` objects to traverse the mesh by\n   * walking across edges, around faces, and around vertices. Let walkerA have edgeIndex value kA. Then with the\n   * aforementioned edgeIndices:\n   *   * `walkerC = walkerA.edgeMate()` moves across the edge to its other end, at kC.\n   *   * `walkerB = walkerA.nextAroundFacet()` moves around the facet to the next edge, at kB.\n   *   * `walkerB.previousAroundFacet()` moves from kB back to kA.\n   *   * `walkerD = walkerA.previousAroundVertex()` moves around the vertex to the next edge kD.\n   *   * `walkerD1 = walkerC.nextAroundFacet()` also moves to kD.\n   *   * `walkerD.nextAroundVertex()` moves from kD back to kA.\n   */\n  public static buildEdgeMateIndices(polyface: IndexedPolyface): void {\n    const matcher = new IndexedEdgeMatcher();\n    const numFacet = polyface.facetCount;\n    for (let facetIndex = 0; facetIndex < numFacet; facetIndex++) {\n      const kStart = polyface.facetIndex0(facetIndex);\n      const kEnd = polyface.facetIndex1(facetIndex);\n      let k0 = kEnd - 1;\n      // sneaky: addEdge 3rd arg is edgeIndex k0 instead of facetIndex; it gets carried around during matching\n      for (let k1 = kStart; k1 < kEnd; k0 = k1, k1++)\n        matcher.addEdge(polyface.data.pointIndex[k0], polyface.data.pointIndex[k1], k0);\n    }\n    const matchedPairs: SortableEdgeCluster[] = [];\n    const singletons: SortableEdgeCluster[] = [];\n    const nullEdges: SortableEdgeCluster[] = [];\n    const allOtherClusters: SortableEdgeCluster[] = [];\n    matcher.sortAndCollectClusters(matchedPairs, singletons, nullEdges, allOtherClusters);\n\n    const numIndex = polyface.data.pointIndex.length;\n    polyface.data.edgeMateIndex = new Array<number | undefined>(numIndex);\n    for (let i = 0; i < numIndex; i++)\n      polyface.data.edgeMateIndex[i] = undefined;\n    for (const pair of matchedPairs) {\n      if (Array.isArray(pair) && pair.length === 2) {\n        const k0 = pair[0].facetIndex;\n        const k1 = pair[1].facetIndex;\n        polyface.data.edgeMateIndex[k0] = k1;\n        polyface.data.edgeMateIndex[k1] = k0;\n      }\n    }\n  }\n}\n\n"]}

package/lib/esm/polyface/Polyface.d.ts

@@ -27,7 +27,9 @@ export declare abstract class Polyface extends GeometryQuery {
      * @param numWrap the number of vertices to replicate in visitor arrays.
      */
     abstract createVisitor(numWrap: number): PolyfaceVisitor;
-    /** Flag indicating if the mesh display must assume both sides are visible. */
+    /**
+     * The [[PolyfaceData.twoSided]] flag.
+     */
     get twoSided(): boolean;
     set twoSided(value: boolean);
     /**
@@ -81,29 +83,13 @@ export declare class IndexedPolyface extends Polyface {
      * @param facetToFacetData optional array of face identifiers (e.g. known during clone)
      */
     protected constructor(data: PolyfaceData, facetStart?: number[], facetToFaceData?: number[]);
-    /**
-     * Given an array of strictly increasing numbers, find the index of the largest number that is less than or equal
-     * to `value`.
-     * * Get an initial estimate by proportions of `value` and the first and last entries.
-     * * Linear search from there for final value.
-     * * For regularly spaced numbers (e.g., `data` is the `_facetStart` indices for a triangulated mesh or a quad mesh),
-     * the proportional estimate will be immediately correct.
-     */
-    static searchStrictlyIncreasingNumbers(data: number[], value: number): number | undefined;
     /** Given an edgeIndex (index into `data.pointIndex`), return the index of the facet containing the edge. */
     edgeIndexToFacetIndex(k: number | undefined): number | undefined;
     /**
      * Given an edgeIndex (index into `data.pointIndex`), return the range of the edgeIndices of the containing facet.
-     * * A "face loop" is a contiguous block of edgeIndices in the polyface index arrays representing a facet.
      * * If an edge with edgeIndex `k` is found in the facet with facetIndex `f`, then the returned range `r` satisfies
      * `r.low = this.facetIndex0(f) <= k < this.facetIndex1(f) = r.high` and can be used to iterate the facet's face
-     * loop, e.g.:
-     * ````
-     * for (let k1 = r.low; k1 < r.high; k1++) {
-     *   const edgeIndex = myPolyface.data.pointIndex[k1];
-     *   // process this edge
-     * }
-     * ````
+     * loop. See [[facetIndex0]].
      */
     edgeIndexToFaceLoop(k: number | undefined): Range1d | undefined;
     /** Test if other is an instance of `IndexedPolyface` */
@@ -159,7 +145,7 @@ export declare class IndexedPolyface extends Polyface {
      * @param needNormals `true` to allocate empty normal data and index arrays; `false` (default) to leave undefined.
      * @param needParams `true` to allocate empty uv parameter data and index arrays; `false` (default) to leave undefined.
      * @param needColors `true` to allocate empty color data and index arrays; `false` (default) to leave undefined.
-     * @param twoSided `true` if the facets are to be considered viewable from the back; `false` (default) if not.
+     * @param twoSided `true` (default) if the facets are to be considered viewable from the back; `false` if they are amenable to backface culling.
      */
     static create(needNormals?: boolean, needParams?: boolean, needColors?: boolean, twoSided?: boolean): IndexedPolyface;
     /**
@@ -260,10 +246,28 @@ export declare class IndexedPolyface extends Polyface {
     isValidFacetIndex(facetIndex: number): boolean;
     /** Return the number of edges in a particular facet. */
     numEdgeInFacet(facetIndex: number): number;
-    /** Given a valid facet index, return the index at which its face loop starts in the index arrays. */
+    /**
+     * Given a valid facet index, return the index at which its face loop starts in the index arrays.
+     * * A "face loop" is a contiguous block of indices into the parallel polyface index arrays.
+     * * Each of these indices represents an edge of a facet, thus it is sometimes called an "edgeIndex".
+     * * Together with [[facetIndex1]], this method can be used to iterate the face loop of the facet
+     * with index `iFacet` as follows:
+     * ````
+     * for (let iEdge = this.facetIndex0(iFacet); iEdge < this.facetIndex1(iFacet); iEdge++) {
+     *   const iPoint = this.data.pointIndex[iEdge];
+     *   const p = this.data.point[iPoint];
+     *   // ... process the edge of this facet starting at point p
+     * }
+     * ````
+     */
     facetIndex0(facetIndex: number): number;
-    /** Given a valid facet index, return one past the index at which its face loop ends in the index arrays. */
+    /**
+     * Given a valid facet index, return one past the index at which its face loop ends in the index arrays.
+     * * For details, see [[facetIndex0]].
+     */
     facetIndex1(facetIndex: number): number;
+    /** Return a readonly reference to the facetStart array accessed by [[facetIndex0]] and [[facetIndex1]]. */
+    get facetStart(): ReadonlyArray<number>;
     /** create a visitor for this polyface */
     createVisitor(numWrap?: number): IndexedPolyfaceVisitor;
     /** Return the range of (optionally transformed) points in this mesh. */
@@ -315,7 +319,7 @@ export interface PolyfaceVisitor extends PolyfaceData {
     clientPolyface(): Polyface | undefined;
     /**
      * Set the number of vertices replicated in visitor arrays (both data and index arrays).
-     * * 0,1,2 are the most common as numWrap.
+     * * 0,1,2 are the most common values.
      * * Example: suppose `[6,7,8]` is the pointIndex array representing a triangle. First edge would be `6,7`. Second
      * edge is `7,8`. Third edge is `8,6`. To access `6` for the third edge, we have to go back to the start of array.
      * Therefore, it is useful to store `6` at the end of pointIndex array, i.e., `[6,7,8,6]` meaning `numWrap = 1`.
@@ -323,7 +327,7 @@ export interface PolyfaceVisitor extends PolyfaceData {
      * the next two points, e.g., to form two adjacent vectors for a cross product.
      */
     setNumWrap(numWrap: number): void;
-    /** Clear the contents of all arrays. Use this along with `pushDataFrom` to build up new facets. */
+    /** Clear the contents of the data arrays. Use this along with `pushDataFrom` to build up new facets. */
     clearArrays(): void;
     /** Transfer data from a specified index of the other visitor as new data in this visitor. */
     pushDataFrom(other: PolyfaceVisitor, index: number): void;

package/lib/esm/polyface/Polyface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Polyface.d.ts","sourceRoot":"","sources":["../../../src/polyface/Polyface.ts"],"names":[],"mappings":"AAKA;;GAEG;AAIH,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAEvD,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAGhE,OAAO,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAC;AACxD,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAElE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C;;;;GAIG;AACH,8BAAsB,QAAS,SAAQ,aAAa;IAClD,wCAAwC;IACxC,SAAgB,gBAAgB,cAAc;IAC9C,gCAAgC;IACzB,IAAI,EAAE,YAAY,CAAC;IAC1B,kBAAkB;IAClB,SAAS,aAAa,IAAI,EAAE,YAAY;IAIxC;;;OAGG;aACa,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe;IAC/D,8EAA8E;IAC9E,IAAW,QAAQ,IAGQ,OAAO,CADjC;IACD,IAAW,QAAQ,CAAC,KAAK,EAAE,OAAO,EAEjC;IACD;;;;OAIG;IACH,IAAW,eAAe,IAAI,MAAM,CAEnC;IACD,IAAW,eAAe,CAAC,KAAK,EAAE,MAAM,EAEvC;IACD;;;;;;;;;;OAUG;WACW,eAAe,CAC3B,OAAO,EAAE,MAAM,EAAE,GAAG,SAAS,EAC7B,cAAc,EAAE,MAAM,EACtB,cAAc,EAAE,MAAM,EACtB,IAAI,EAAE,GAAG,EACT,UAAU,EAAE,MAAM,GACjB,OAAO;IAcV,mDAAmD;IACnD,aAAoB,OAAO,IAAI,OAAO,CAAC;IACvC,iFAAiF;IACjF,IAAW,UAAU,IAAI,MAAM,GAAG,SAAS,CAE1C;CACF;AAED;;;;GAIG;AACH,qBAAa,eAAgB,SAAQ,QAAQ;IAC3C;;;;;;;OAOG;IACH,SAAS,CAAC,WAAW,EAAE,MAAM,EAAE,CAAC;IAChC;;;OAGG;IACH,SAAS,CAAC,gBAAgB,EAAE,MAAM,EAAE,CAAC;IACrC;;;;;OAKG;IACH,SAAS,aAAa,IAAI,EAAE,YAAY,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,EAAE,eAAe,CAAC,EAAE,MAAM,EAAE;IAc3F;;;;;;;OAOG;WACW,+BAA+B,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAWhG,4GAA4G;IACrG,qBAAqB,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS;IAKvE;;;;;;;;;;;;OAYG;IACI,mBAAmB,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS;IAOtE,wDAAwD;IACjD,mBAAmB,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO;IAG/C,0DAA0D;IAC1C,aAAa,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO;IAQlD,gFAAgF;IAChF,IAAW,OAAO,IAAI,OAAO,CAE5B;IACD;;;;;OAKG;IACI,mBAAmB,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO;IAMzD,0CAA0C;IACnC,kBAAkB,CAAC,OAAO,EAAE,MAAM;IAGzC,2BAA2B;IACpB,KAAK,IAAI,eAAe;IAG/B;;;OAGG;IACI,gBAAgB,CAAC,SAAS,EAAE,SAAS,GAAG,eAAe;IAK9D,sDAAsD;IAC/C,cAAc;IAGrB,mDAAmD;IAC5C,cAAc;IAGrB;;;;MAIE;IACK,cAAc,CAAC,CAAC,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAQ3D;;;;;;OAMG;IACI,kBAAkB,CAAC,MAAM,EAAE,eAAe,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,GAAG,SAAS;IAsGtG;;;;;;OAMG;IACH,IAAW,wBAAwB,IAAI,MAAM,CAE5C;IACD;;;;;;OAMG;WACW,MAAM,CAClB,WAAW,GAAE,OAAe,EAC5B,UAAU,GAAE,OAAe,EAC3B,UAAU,GAAE,OAAe,EAC3B,QAAQ,GAAE,OAAe,GACxB,eAAe;IAGlB;;;;;OAKG;IACI,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM;IAS5D;;;;;;OAMG;IACI,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM;IAI3D;;;;OAIG;IACI,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM;IAMvC;;;;;;;OAOG;IACI,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM;IAU3F;;;;;;OAMG;IACI,SAAS,CAAC,MAAM,EAAE,QAAQ,EAAE,WAAW,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM;IAoBtF;;;;;;OAMG;IACI,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM;IAM5D;;;;OAIG;IACI,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAMtC,mDAAmD;IAC5C,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,OAAc,GAAG,IAAI;IAIlE,0BAA0B;IACnB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAK1C,yBAAyB;IAClB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAKzC,yBAAyB;IAClB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAKzC;;;;OAIG;IACI,gBAAgB,IAAI,IAAI;IAI/B;;;;;OAKG;IACI,kBAAkB,CAAC,MAAM,GAAE,MAAU,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO;IAsBzE;;;;;;;OAOG;IACI,cAAc,CAAC,kBAAkB,GAAE,OAAc,GAAG,MAAM,EAAE,GAAG,SAAS;IAmB/E,6CAA6C;IAC7C,IAAoB,UAAU,IAAI,MAAM,CAEvC;IACD,4CAA4C;IAC5C,IAAW,SAAS,IAAI,MAAM,CAE7B;IACD,6CAA6C;IAC7C,IAAW,UAAU,IAAI,MAAM,CAE9B;IACD,6CAA6C;IAC7C,IAAW,UAAU,IAAI,MAAM,CAE9B;IACD,iDAAiD;IACjD,IAAW,UAAU,IAAI,MAAM,CAE9B;IACD,8CAA8C;IAC9C,IAAW,WAAW,IAAI,MAAM,CAE/B;IACD,8CAA8C;IACvC,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAGrD,wDAAwD;IACjD,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAKjD,qGAAqG;IAC9F,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAG9C,4GAA4G;IACrG,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAG9C,yCAAyC;IAClC,aAAa,CAAC,OAAO,GAAE,MAAU,GAAG,sBAAsB;IAGjE,wEAAwE;IACxD,KAAK,CAAC,SAAS,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO;IAGvE,sDAAsD;IAC/C,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,SAAS,GAAG,IAAI;IAG/D;;;OAGG;IACI,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,aAAa;IAGjE;;;;OAIG;IACI,cAAc,CAAC,aAAa,GAAE,MAAU,GAAG,OAAO;IA0BzD,kFAAkF;IAC3E,yBAAyB,CAAC,OAAO,EAAE,eAAe,GAAG,GAAG;CAGhE;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,eAAgB,SAAQ,YAAY;IACnD,gDAAgD;IAChD,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;IACxC,0DAA0D;IAC1D,gBAAgB,IAAI,MAAM,CAAC;IAC3B,oCAAoC;IACpC,eAAe,IAAI,OAAO,CAAC;IAC3B,uFAAuF;IACvF,KAAK,IAAI,IAAI,CAAC;IACd,4EAA4E;IAC5E,gBAAgB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACpC,4EAA4E;IAC5E,gBAAgB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACpC,6EAA6E;IAC7E,iBAAiB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACrC,4EAA4E;IAC5E,gBAAgB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACpC,+EAA+E;IAC/E,cAAc,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAClC,kCAAkC;IAClC,cAAc,IAAI,QAAQ,GAAG,SAAS,CAAC;IACvC;;;;;;;;OAQG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,mGAAmG;IACnG,WAAW,IAAI,IAAI,CAAC;IACpB,6FAA6F;IAC7F,YAAY,CAAC,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1D;;;OAGG;IACH,wBAAwB,CAAC,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACzG;;;OAGG;IACH,sBAAsB,CAAC,IAAI,MAAM,CAAC;CACnC"}
+{"version":3,"file":"Polyface.d.ts","sourceRoot":"","sources":["../../../src/polyface/Polyface.ts"],"names":[],"mappings":"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"}

package/lib/esm/polyface/Polyface.js

@@ -31,7 +31,9 @@ export class Polyface extends GeometryQuery {
         super();
         this.data = data;
     }
-    /** Flag indicating if the mesh display must assume both sides are visible. */
+    /**
+     * The [[PolyfaceData.twoSided]] flag.
+     */
     get twoSided() {
         return this.data.twoSided;
     }
@@ -118,43 +120,17 @@ export class IndexedPolyface extends Polyface {
         else
             this._facetToFaceData = [];
     }
-    /**
-     * Given an array of strictly increasing numbers, find the index of the largest number that is less than or equal
-     * to `value`.
-     * * Get an initial estimate by proportions of `value` and the first and last entries.
-     * * Linear search from there for final value.
-     * * For regularly spaced numbers (e.g., `data` is the `_facetStart` indices for a triangulated mesh or a quad mesh),
-     * the proportional estimate will be immediately correct.
-     */
-    static searchStrictlyIncreasingNumbers(data, value) {
-        const lastQ = data.length - 1;
-        if (lastQ <= 0 || value < 0 || value >= data[lastQ])
-            return undefined;
-        let q = Math.floor((value * lastQ) / data[lastQ]);
-        while (data[q] > value)
-            q--;
-        while (data[q + 1] <= value)
-            q++;
-        return q;
-    }
     /** Given an edgeIndex (index into `data.pointIndex`), return the index of the facet containing the edge. */
     edgeIndexToFacetIndex(k) {
         if (k === undefined)
             return undefined;
-        return IndexedPolyface.searchStrictlyIncreasingNumbers(this._facetStart, k);
+        return NumberArray.searchStrictlyIncreasingNumbers(this._facetStart, k);
     }
     /**
      * Given an edgeIndex (index into `data.pointIndex`), return the range of the edgeIndices of the containing facet.
-     * * A "face loop" is a contiguous block of edgeIndices in the polyface index arrays representing a facet.
      * * If an edge with edgeIndex `k` is found in the facet with facetIndex `f`, then the returned range `r` satisfies
      * `r.low = this.facetIndex0(f) <= k < this.facetIndex1(f) = r.high` and can be used to iterate the facet's face
-     * loop, e.g.:
-     * ````
-     * for (let k1 = r.low; k1 < r.high; k1++) {
-     *   const edgeIndex = myPolyface.data.pointIndex[k1];
-     *   // process this edge
-     * }
-     * ````
+     * loop. See [[facetIndex0]].
      */
     edgeIndexToFaceLoop(k) {
         const q = this.edgeIndexToFacetIndex(k);
@@ -352,9 +328,9 @@ export class IndexedPolyface extends Polyface {
      * @param needNormals `true` to allocate empty normal data and index arrays; `false` (default) to leave undefined.
      * @param needParams `true` to allocate empty uv parameter data and index arrays; `false` (default) to leave undefined.
      * @param needColors `true` to allocate empty color data and index arrays; `false` (default) to leave undefined.
-     * @param twoSided `true` if the facets are to be considered viewable from the back; `false` (default) if not.
+     * @param twoSided `true` (default) if the facets are to be considered viewable from the back; `false` if they are amenable to backface culling.
      */
-    static create(needNormals = false, needParams = false, needColors = false, twoSided = false) {
+    static create(needNormals = false, needParams = false, needColors = false, twoSided = true) {
         return new IndexedPolyface(new PolyfaceData(needNormals, needParams, needColors, twoSided));
     }
     /**
@@ -503,6 +479,14 @@ export class IndexedPolyface extends Polyface {
     validateAllIndices(index0 = 0, errors) {
         const numPointIndices = this.data.pointIndex.length;
         const messages = errors ?? [];
+        if (0 === numPointIndices) {
+            messages.push("empty pointIndex array");
+            return false;
+        }
+        if (index0 < 0 || index0 >= numPointIndices) {
+            messages.push("invalid input offset");
+            return false;
+        }
         if (this.data.normalIndex && this.data.normalIndex.length !== numPointIndices)
             messages.push("normalIndex count must match pointIndex count");
         if (this.data.paramIndex && this.data.paramIndex.length !== numPointIndices)
@@ -512,13 +496,19 @@ export class IndexedPolyface extends Polyface {
         if (this.data.edgeVisible.length !== numPointIndices)
             messages.push("visibleIndex count must equal pointIndex count");
         if (!Polyface.areIndicesValid(this.data.pointIndex, index0, numPointIndices, this.data.point, this.data.point ? this.data.point.length : 0))
-            messages.push("invalid point indices in the last facet");
+            messages.push("invalid point index encountered");
         if (!Polyface.areIndicesValid(this.data.normalIndex, index0, numPointIndices, this.data.normal, this.data.normal ? this.data.normal.length : 0))
-            messages.push("invalid normal indices in the last facet");
+            messages.push("invalid normal index encountered");
         if (!Polyface.areIndicesValid(this.data.paramIndex, index0, numPointIndices, this.data.param, this.data.param ? this.data.param.length : 0))
-            messages.push("invalid param indices in the last facet");
+            messages.push("invalid param index encountered");
         if (!Polyface.areIndicesValid(this.data.colorIndex, index0, numPointIndices, this.data.color, this.data.color ? this.data.color.length : 0))
-            messages.push("invalid color indices in the last facet");
+            messages.push("invalid color index encountered");
+        if (this.data.edgeMateIndex) {
+            if (this.data.edgeMateIndex.length !== numPointIndices)
+                messages.push("edgeMateIndex count must equal pointIndex count");
+            else if (!this.data.edgeMateIndex.every((i) => i === undefined || this.data.isValidEdgeIndex(i)))
+                messages.push("invalid edgeMate encountered");
+        }
         return 0 === messages.length;
     }
     /**
@@ -582,14 +572,34 @@ export class IndexedPolyface extends Polyface {
             return this._facetStart[facetIndex + 1] - this._facetStart[facetIndex];
         return 0;
     }
-    /** Given a valid facet index, return the index at which its face loop starts in the index arrays. */
+    /**
+     * Given a valid facet index, return the index at which its face loop starts in the index arrays.
+     * * A "face loop" is a contiguous block of indices into the parallel polyface index arrays.
+     * * Each of these indices represents an edge of a facet, thus it is sometimes called an "edgeIndex".
+     * * Together with [[facetIndex1]], this method can be used to iterate the face loop of the facet
+     * with index `iFacet` as follows:
+     * ````
+     * for (let iEdge = this.facetIndex0(iFacet); iEdge < this.facetIndex1(iFacet); iEdge++) {
+     *   const iPoint = this.data.pointIndex[iEdge];
+     *   const p = this.data.point[iPoint];
+     *   // ... process the edge of this facet starting at point p
+     * }
+     * ````
+     */
     facetIndex0(facetIndex) {
         return this._facetStart[facetIndex];
     }
-    /** Given a valid facet index, return one past the index at which its face loop ends in the index arrays. */
+    /**
+     * Given a valid facet index, return one past the index at which its face loop ends in the index arrays.
+     * * For details, see [[facetIndex0]].
+     */
     facetIndex1(facetIndex) {
         return this._facetStart[facetIndex + 1];
     }
+    /** Return a readonly reference to the facetStart array accessed by [[facetIndex0]] and [[facetIndex1]]. */
+    get facetStart() {
+        return this._facetStart;
+    }
     /** create a visitor for this polyface */
     createVisitor(numWrap = 0) {
         return IndexedPolyfaceVisitor.create(this, numWrap);