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

package/lib/cjs/polyface/IndexedPolyfaceWalker.d.ts

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

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

@@ -0,0 +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"}

package/lib/cjs/polyface/IndexedPolyfaceWalker.js

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

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

@@ -0,0 +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"]}