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

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

@@ -0,0 +1,61 @@
+import { Angle } from "../geometry3d/Angle";
+import { BarycentricTriangle } from "../geometry3d/BarycentricTriangle";
+import { IndexedXYZCollection } from "../geometry3d/IndexedXYZCollection";
+/** @packageDocumentation
+ * @module Polyface
+ */
+/**
+ * * Context for constructing triangulations between linestrings with dis-similar point counts and distribution.
+ * @internal
+ */
+export declare class GreedyTriangulationBetweenLineStrings {
+    private _vector1;
+    private constructor();
+    private _turnRadians;
+    private isForwardVector;
+    private isPlanarBase;
+    /**
+     * Starting at start in source, examine points to see how long they are close to being "in plane"
+     * * child interval begins at parent.begin
+     * * child interval end initializes at trialEnd and grows.
+     * * child must be predefined by caller
+     * * Return the accepted interval
+     */
+    private advanceToPlanarLimit;
+    private _triangleA1?;
+    private _triangleB1?;
+    private _triangleA2?;
+    private _triangleB2?;
+    private _triangleA3?;
+    private _triangleB3?;
+    private _bestTriangle?;
+    private _workTriangle?;
+    /** evaluate aspect ratios to select heuristically best triangles with given index intervals.
+     * (ASSUME NO DUPLICATES, as in caller.)
+     */
+    private addGreedy;
+    private _xyzA;
+    private _xyzB;
+    private _forwardA;
+    private _forwardB;
+    private _crossA;
+    private _crossB;
+    /**
+     * Working from start to finish, emit triangles with heuristic lookahead to get pleasing matching between the linestrings.
+     * @param pointsA
+     * @param pointsB
+     * @param handler
+     */
+    emitTriangles(pointsA: IndexedXYZCollection, pointsB: IndexedXYZCollection, handler: (triangle: BarycentricTriangle) => void): void;
+    /**
+     * Run triangle logic on inputs with no duplicates.
+     * @param pointsA
+     * @param pointsB
+     * @param handler
+     */
+    private emitTrianglesGo;
+    /** Default angle for considering two vectors to be colinear */
+    static defaultNearColinearAngle: Angle;
+    static createContext(planarTurnAngle?: Angle): GreedyTriangulationBetweenLineStrings;
+}
+//# sourceMappingURL=GreedyTriangulationBetweenLineStrings.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GreedyTriangulationBetweenLineStrings.d.ts","sourceRoot":"","sources":["../../../src/polyface/GreedyTriangulationBetweenLineStrings.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AAGxE,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAI1E;;GAEG;AACH;;;GAGG;AACH,qBAAa,qCAAqC;IAEhD,OAAO,CAAC,QAAQ,CAAW;IAC3B,OAAO;IAWP,OAAO,CAAC,YAAY,CAAS;IAE7B,OAAO,CAAC,eAAe;IAWvB,OAAO,CAAC,YAAY;IAyBpB;;;;;;OAMG;IACH,OAAO,CAAC,oBAAoB;IAyB5B,OAAO,CAAC,WAAW,CAAC,CAAoB;IACxC,OAAO,CAAC,WAAW,CAAC,CAAoB;IAExC,OAAO,CAAC,WAAW,CAAC,CAAoB;IACxC,OAAO,CAAC,WAAW,CAAC,CAAoB;IAExC,OAAO,CAAC,WAAW,CAAC,CAAoB;IACxC,OAAO,CAAC,WAAW,CAAC,CAAoB;IACxC,OAAO,CAAC,aAAa,CAAC,CAAoB;IAC1C,OAAO,CAAC,aAAa,CAAC,CAAoB;IAC1C;;OAEG;IACH,OAAO,CAAC,SAAS;IA8DjB,OAAO,CAAC,KAAK,CAAU;IACvB,OAAO,CAAC,KAAK,CAAU;IACvB,OAAO,CAAC,SAAS,CAAW;IAC5B,OAAO,CAAC,SAAS,CAAW;IAC5B,OAAO,CAAC,OAAO,CAAW;IAC1B,OAAO,CAAC,OAAO,CAAW;IAC1B;;;;;OAKG;IACI,aAAa,CAClB,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,CAAC,QAAQ,EAAE,mBAAmB,KAAK,IAAI;IAIlD;;;;;OAKG;IACH,OAAO,CAAC,eAAe;IA0DvB,+DAA+D;IAC/D,OAAc,wBAAwB,QAA2B;WACnD,aAAa,CAAC,eAAe,GAAE,KAAqC;CAGnF"}

package/lib/esm/polyface/GreedyTriangulationBetweenLineStrings.js

@@ -0,0 +1,245 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+import { Geometry } from "../Geometry";
+import { Angle } from "../geometry3d/Angle";
+import { GrowableXYZArray } from "../geometry3d/GrowableXYZArray";
+import { IndexedXYZCollectionInterval } from "../geometry3d/IndexedCollectionInterval";
+import { Point3d, Vector3d } from "../geometry3d/Point3dVector3d";
+import { TriangleCandidate } from "./TriangleCandidate";
+/** @packageDocumentation
+ * @module Polyface
+ */
+/**
+ * * Context for constructing triangulations between linestrings with dis-similar point counts and distribution.
+ * @internal
+ */
+export class GreedyTriangulationBetweenLineStrings {
+    constructor(turnRadians) {
+        this._turnRadians = turnRadians;
+        this._xyzA = Point3d.create();
+        this._xyzB = Point3d.create();
+        this._forwardA = Vector3d.create();
+        this._forwardB = Vector3d.create();
+        this._vector1 = Vector3d.create();
+        this._crossA = Vector3d.create();
+        this._crossB = Vector3d.create();
+    }
+    isForwardVector(candidate, forward, perp) {
+        if (candidate.dotProduct(forward) <= 0.0)
+            return false;
+        const theta = candidate.angleFromPerpendicular(perp);
+        if (Math.abs(theta.radians) > this._turnRadians)
+            return false;
+        return true;
+    }
+    isPlanarBase(pointsA, baseA, pointsB, baseB, xyzA, crossA, forwardA, xyzB, crossB, forwardB) {
+        if (baseA + 1 < pointsA.length && baseB + 1 < pointsB.length) {
+            pointsA.getPoint3dAtUncheckedPointIndex(baseA, xyzA);
+            pointsB.getPoint3dAtUncheckedPointIndex(baseB, xyzB);
+            pointsA.vectorXYAndZIndex(xyzA, baseA + 1, forwardA);
+            pointsB.vectorXYAndZIndex(xyzB, baseB + 1, forwardB);
+            Vector3d.createStartEnd(xyzA, xyzB, this._vector1);
+            this._vector1.crossProduct(forwardA, crossA);
+            this._vector1.crossProduct(forwardB, crossB);
+            if (!xyzA.isAlmostEqual(xyzB) && crossA.angleTo(crossB).radians < this._turnRadians)
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Starting at start in source, examine points to see how long they are close to being "in plane"
+     * * child interval begins at parent.begin
+     * * child interval end initializes at trialEnd and grows.
+     * * child must be predefined by caller
+     * * Return the accepted interval
+     */
+    advanceToPlanarLimit(parent, child, trialEnd, xyzA, perpA, forwardA, perpB, forwardB) {
+        child.setFrom(parent, parent.begin, trialEnd); // initialize as empty interval.
+        while (child.end < parent.end) {
+            child.points.vectorXYAndZIndex(xyzA, child.end, this._vector1);
+            if (!this.isForwardVector(this._vector1, forwardA, perpA))
+                break;
+            if (!this.isForwardVector(this._vector1, forwardB, perpB))
+                break;
+            if (child.end > 0) {
+                child.points.vectorIndexIndex(child.end - 1, child.end, this._vector1);
+                if (!this.isForwardVector(this._vector1, forwardA, perpA))
+                    break;
+            }
+            child.end++;
+        }
+    }
+    /** evaluate aspect ratios to select heuristically best triangles with given index intervals.
+     * (ASSUME NO DUPLICATES, as in caller.)
+     */
+    addGreedy(intervalA, intervalB, handler, addOnly1 = false) {
+        intervalA.restrictEnd();
+        intervalB.restrictEnd();
+        while (intervalA.length > 1 && intervalB.length > 1) {
+            // triangles A1 and B1 are always valid.
+            this._triangleA1 = TriangleCandidate.createFromIndexedXYZ(intervalA.points, intervalA.begin, intervalA.points, intervalA.begin + 1, intervalB.points, intervalB.begin, 1, this._triangleA1);
+            this._triangleA2 = TriangleCandidate.createFromIndexedXYZ(intervalA.points, intervalA.begin + 1, intervalA.points, intervalA.begin + 2, intervalB.points, intervalB.begin, 2, this._triangleA2);
+            this._triangleA3 = TriangleCandidate.createFromIndexedXYZ(intervalA.points, intervalA.begin, intervalA.points, intervalA.begin + 1, intervalB.points, intervalB.begin + 1, 3, this._triangleA3);
+            this._triangleB1 = TriangleCandidate.createFromIndexedXYZ(intervalB.points, intervalB.begin + 1, intervalB.points, intervalB.begin, intervalA.points, intervalA.begin, -1, this._triangleB1);
+            this._triangleB2 = TriangleCandidate.createFromIndexedXYZ(intervalB.points, intervalB.begin + 2, intervalB.points, intervalB.begin + 1, intervalA.points, intervalA.begin, -2, this._triangleB2);
+            this._triangleB3 = TriangleCandidate.createFromIndexedXYZ(intervalB.points, intervalB.begin + 1, intervalB.points, intervalB.begin, intervalA.points, intervalA.begin + 1, -3, this._triangleB3);
+            // Look at pairs of 2 triangles.
+            // (each pair begins with 1 or -1)
+            // For each pair find the smallest aspect ratio of its two triangles.  (Small is bad)
+            // Choose the pair where that (smaller aspect ratio of two) is largest.
+            // Advance in that direction.
+            this._bestTriangle = TriangleCandidate.copyWithLowerQuality(this._triangleA1, this._triangleB3, this._bestTriangle);
+            this._workTriangle = TriangleCandidate.copyWithLowerQuality(this._triangleB1, this._triangleA3, this._workTriangle);
+            TriangleCandidate.updateIfOtherHasHigherQuality(this._bestTriangle, this._workTriangle);
+            // TestTriangle::UpdateIfOtherHasLargerAspectRatio (bestTriangle, TestTriangle::MergeAspectRatio (triangleB1, triangleB2));
+            // TestTriangle::UpdateIfOtherHasLargerAspectRatio (bestTriangle, TestTriangle::MergeAspectRatio (triangleA1, triangleA2));
+            if (this._bestTriangle.id > 0) {
+                intervalA.advanceBegin();
+                handler(this._bestTriangle);
+                if (addOnly1)
+                    return;
+            }
+            else {
+                intervalB.advanceBegin();
+                handler(this._bestTriangle);
+                if (addOnly1)
+                    return;
+            }
+        }
+        // sweep in trailing points from either side.  At least one of intervalA.begin, intervalB.begin is at its limit, so only one of these will execute any bodies.
+        if (intervalA.isSingleton) {
+            while (intervalB.length >= 2) {
+                this._workTriangle = TriangleCandidate.createFromIndexedXYZ(intervalB.points, intervalB.begin + 1, intervalB.points, intervalB.begin, intervalA.points, intervalA.begin, 0, this._workTriangle);
+                //  this._workTriangle.scaleFromPointInPlace(this._workTriangle.points[2], 0.95); // crude visualization aid for tracking logic.
+                handler(this._workTriangle);
+                intervalB.advanceBegin();
+            }
+        }
+        // sweep in trailing points from either side.  At least one of baseA, baseB is at its limit, so only one of these will execute any bodies.
+        if (intervalB.isSingleton) {
+            while (intervalA.length >= 2) {
+                this._workTriangle = TriangleCandidate.createFromIndexedXYZ(intervalA.points, intervalA.begin, intervalA.points, intervalA.begin + 1, intervalB.points, intervalB.begin, 0, this._workTriangle);
+                // this._workTriangle.scaleFromPointInPlace(this._workTriangle.points[2], 0.95); // crude visualization aid for tracking logic.
+                handler(this._workTriangle);
+                intervalA.advanceBegin();
+            }
+        }
+    }
+    /**
+     * Working from start to finish, emit triangles with heuristic lookahead to get pleasing matching between the linestrings.
+     * @param pointsA
+     * @param pointsB
+     * @param handler
+     */
+    emitTriangles(pointsA, pointsB, handler) {
+        /** Clean up duplicates for the real logic . . . */
+        this.emitTrianglesGo(resolveToNoDuplicates(pointsA), resolveToNoDuplicates(pointsB), handler);
+    }
+    /**
+     * Run triangle logic on inputs with no duplicates.
+     * @param pointsA
+     * @param pointsB
+     * @param handler
+     */
+    emitTrianglesGo(pointsA, pointsB, handler) {
+        const intervalA = IndexedXYZCollectionInterval.createComplete(pointsA);
+        const intervalB = IndexedXYZCollectionInterval.createComplete(pointsB);
+        const childA = IndexedXYZCollectionInterval.createComplete(pointsA);
+        const childB = IndexedXYZCollectionInterval.createComplete(pointsB);
+        while (intervalA.length > 0 && intervalB.length > 0 && (intervalA.length > 1 || intervalB.length > 1)) {
+            // const lA = intervalA.length;
+            // const lB = intervalB.length;
+            if (this.isPlanarBase(pointsA, intervalA.begin, pointsB, intervalB.begin, this._xyzA, this._crossA, this._forwardA, this._xyzB, this._crossB, this._forwardB)) {
+                this.advanceToPlanarLimit(intervalA, childA, intervalA.begin + 1, this._xyzA, this._crossA, this._forwardA, this._crossB, this._forwardB);
+                this.advanceToPlanarLimit(intervalB, childB, intervalB.begin + 1, this._xyzB, this._crossB, this._forwardB, this._crossA, this._forwardA);
+                this.addGreedy(childA, childB, handler);
+                intervalA.advanceToTail(childA);
+                intervalB.advanceToTail(childB);
+            }
+            else if (this.isPlanarBase(pointsA, intervalA.begin + 1, pointsB, intervalB.begin, this._xyzA, this._crossA, this._forwardA, this._xyzB, this._crossB, this._forwardB)) {
+                childA.setFrom(intervalA, intervalA.begin, intervalA.begin + 2);
+                childB.setFrom(intervalB, intervalB.begin, intervalB.begin + 1);
+                this.addGreedy(childA, childB, handler);
+                intervalA.advanceToTail(childA);
+                intervalB.advanceToTail(childB);
+            }
+            else if (this.isPlanarBase(pointsA, intervalA.begin, pointsB, intervalB.begin + 1, this._xyzA, this._crossA, this._forwardA, this._xyzB, this._crossB, this._forwardB)) {
+                childA.setFrom(intervalA, intervalA.begin, intervalA.begin + 1);
+                childB.setFrom(intervalB, intervalB.begin, intervalB.begin + 2);
+                this.addGreedy(childA, childB, handler);
+                intervalA.advanceToTail(childA);
+                intervalB.advanceToTail(childB);
+            }
+            else if (intervalA.length > 1 && intervalB.length > 1) {
+                childA.setFrom(intervalA, intervalA.begin, intervalA.begin + 2);
+                childB.setFrom(intervalB, intervalB.begin, intervalB.begin + 2);
+                this.addGreedy(childA, childB, handler, true);
+                intervalA.advanceToHead(childA);
+                intervalB.advanceToHead(childB);
+            }
+            else if (intervalA.length > 1) {
+                childA.setFrom(intervalA, intervalA.begin, intervalA.begin + 2);
+                childB.setFrom(intervalB);
+                this.addGreedy(childA, childB, handler);
+                intervalA.advanceToTail(childA);
+                intervalB.advanceToTail(childB);
+            }
+            else if (intervalB.length > 1) {
+                childA.setFrom(intervalA);
+                childB.setFrom(intervalB, intervalB.begin, intervalB.begin + 2);
+                this.addGreedy(childA, childB, handler);
+                intervalA.advanceToTail(childA);
+                intervalB.advanceToTail(childB);
+            }
+            /*      if (intervalA.length >= lA && intervalB.length >= lB) {
+                    // This should not happen == neither one advanced.   Just move ahead in the longer one ..
+                    if (intervalA.length > intervalB.length)
+                      intervalA.advanceBegin();
+                    else intervalB.advanceBegin();
+                  } */
+        }
+        // catch everything else blindly
+        this.addGreedy(intervalA, intervalB, handler);
+    }
+    static createContext(planarTurnAngle = this.defaultNearColinearAngle) {
+        return new GreedyTriangulationBetweenLineStrings(planarTurnAngle.radians);
+    }
+}
+/** Default angle for considering two vectors to be colinear */
+GreedyTriangulationBetweenLineStrings.defaultNearColinearAngle = Angle.createDegrees(15);
+/**
+ * * If there are no contiguous duplicated points in `data` return `data` unchanged.
+ * * If there are duplicates, compress to a new array.
+ * @param data
+ * @param tolerance
+ */
+function resolveToNoDuplicates(data, tolerance = Geometry.smallMetricDistance) {
+    let hasDuplicates = false;
+    const n = data.length;
+    for (let i = 0; i + 1 < n; i++) {
+        if (data.distanceIndexIndex(i, i + 1) <= tolerance) {
+            hasDuplicates = true;
+            break;
+        }
+    }
+    if (!hasDuplicates)
+        return data;
+    const result = new GrowableXYZArray(n);
+    result.pushXYZ(data.getXAtUncheckedPointIndex(0), data.getYAtUncheckedPointIndex(0), data.getZAtUncheckedPointIndex(0));
+    let i0 = 0;
+    for (let i = 1; i < n; i++) {
+        if (data.distanceIndexIndex(i0, i) > tolerance) {
+            result.pushXYZ(data.getXAtUncheckedPointIndex(i), data.getYAtUncheckedPointIndex(i), data.getZAtUncheckedPointIndex(i));
+            i0 = i;
+        }
+    }
+    /** enforce exact closure if original was closed. */
+    if (data.distanceIndexIndex(0, n - 1) <= tolerance) {
+        result.pop();
+        result.pushFromGrowableXYZArray(result, 0);
+    }
+    return result;
+}
+//# sourceMappingURL=GreedyTriangulationBetweenLineStrings.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GreedyTriangulationBetweenLineStrings.js","sourceRoot":"","sources":["../../../src/polyface/GreedyTriangulationBetweenLineStrings.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\nimport { Geometry } from \"../Geometry\";\r\nimport { Angle } from \"../geometry3d/Angle\";\r\nimport { BarycentricTriangle } from \"../geometry3d/BarycentricTriangle\";\r\nimport { GrowableXYZArray } from \"../geometry3d/GrowableXYZArray\";\r\nimport { IndexedXYZCollectionInterval } from \"../geometry3d/IndexedCollectionInterval\";\r\nimport { IndexedXYZCollection } from \"../geometry3d/IndexedXYZCollection\";\r\nimport { Point3d, Vector3d } from \"../geometry3d/Point3dVector3d\";\r\nimport { TriangleCandidate } from \"./TriangleCandidate\";\r\n\r\n/** @packageDocumentation\r\n * @module Polyface\r\n */\r\n/**\r\n * * Context for constructing triangulations between linestrings with dis-similar point counts and distribution.\r\n * @internal\r\n */\r\nexport class GreedyTriangulationBetweenLineStrings {\r\n\r\n  private _vector1: Vector3d;\r\n  private constructor(turnRadians: number) {\r\n    this._turnRadians = turnRadians;\r\n    this._xyzA = Point3d.create();\r\n    this._xyzB = Point3d.create();\r\n    this._forwardA = Vector3d.create();\r\n    this._forwardB = Vector3d.create();\r\n    this._vector1 = Vector3d.create();\r\n    this._crossA = Vector3d.create();\r\n    this._crossB = Vector3d.create();\r\n  }\r\n\r\n  private _turnRadians: number;\r\n\r\n  private isForwardVector(\r\n    candidate: Vector3d,\r\n    forward: Vector3d,\r\n    perp: Vector3d): boolean {\r\n    if (candidate.dotProduct(forward) <= 0.0)\r\n      return false;\r\n    const theta = candidate.angleFromPerpendicular(perp);\r\n    if (Math.abs(theta.radians) > this._turnRadians)\r\n      return false;\r\n    return true;\r\n  }\r\n  private isPlanarBase(\r\n    pointsA: IndexedXYZCollection,\r\n    baseA: number,\r\n    pointsB: IndexedXYZCollection,\r\n    baseB: number,\r\n    xyzA: Point3d,\r\n    crossA: Vector3d,\r\n    forwardA: Vector3d,\r\n    xyzB: Point3d,\r\n    crossB: Vector3d,\r\n    forwardB: Vector3d): boolean {\r\n    if (baseA + 1 < pointsA.length && baseB + 1 < pointsB.length) {\r\n      pointsA.getPoint3dAtUncheckedPointIndex(baseA, xyzA);\r\n      pointsB.getPoint3dAtUncheckedPointIndex(baseB, xyzB);\r\n      pointsA.vectorXYAndZIndex(xyzA, baseA + 1, forwardA);\r\n      pointsB.vectorXYAndZIndex(xyzB, baseB + 1, forwardB);\r\n      Vector3d.createStartEnd(xyzA, xyzB, this._vector1);\r\n      this._vector1.crossProduct(forwardA, crossA);\r\n      this._vector1.crossProduct(forwardB, crossB);\r\n      if (!xyzA.isAlmostEqual(xyzB) && crossA.angleTo(crossB).radians < this._turnRadians)\r\n        return true;\r\n    }\r\n    return false;\r\n\r\n  }\r\n  /**\r\n   * Starting at start in source, examine points to see how long they are close to being \"in plane\"\r\n   * * child interval begins at parent.begin\r\n   * * child interval end initializes at trialEnd and grows.\r\n   * * child must be predefined by caller\r\n   * * Return the accepted interval\r\n   */\r\n  private advanceToPlanarLimit(\r\n    parent: IndexedXYZCollectionInterval,\r\n    child: IndexedXYZCollectionInterval,\r\n    trialEnd: number,\r\n    xyzA: Point3d,\r\n    perpA: Vector3d,\r\n    forwardA: Vector3d,\r\n    perpB: Vector3d,\r\n    forwardB: Vector3d) {\r\n    child.setFrom(parent, parent.begin, trialEnd);  // initialize as empty interval.\r\n    while (child.end < parent.end) {\r\n      child.points.vectorXYAndZIndex(xyzA, child.end, this._vector1);\r\n      if (!this.isForwardVector(this._vector1, forwardA, perpA))\r\n        break;\r\n      if (!this.isForwardVector(this._vector1, forwardB, perpB))\r\n        break;\r\n      if (child.end > 0) {\r\n        child.points.vectorIndexIndex(child.end - 1, child.end, this._vector1);\r\n        if (!this.isForwardVector(this._vector1, forwardA, perpA))\r\n          break;\r\n      }\r\n      child.end++;\r\n    }\r\n  }\r\n\r\n  private _triangleA1?: TriangleCandidate;\r\n  private _triangleB1?: TriangleCandidate;\r\n\r\n  private _triangleA2?: TriangleCandidate;\r\n  private _triangleB2?: TriangleCandidate;\r\n\r\n  private _triangleA3?: TriangleCandidate;\r\n  private _triangleB3?: TriangleCandidate;\r\n  private _bestTriangle?: TriangleCandidate;\r\n  private _workTriangle?: TriangleCandidate;\r\n  /** evaluate aspect ratios to select heuristically best triangles with given index intervals.\r\n   * (ASSUME NO DUPLICATES, as in caller.)\r\n   */\r\n  private addGreedy(\r\n    intervalA: IndexedXYZCollectionInterval,\r\n    intervalB: IndexedXYZCollectionInterval,\r\n    handler: (triangle: BarycentricTriangle) => void,\r\n    addOnly1: boolean = false) {\r\n    intervalA.restrictEnd();\r\n    intervalB.restrictEnd();\r\n\r\n    while (intervalA.length > 1 && intervalB.length > 1) {\r\n\r\n      // triangles A1 and B1 are always valid.\r\n      this._triangleA1 = TriangleCandidate.createFromIndexedXYZ(intervalA.points, intervalA.begin, intervalA.points, intervalA.begin + 1, intervalB.points, intervalB.begin, 1, this._triangleA1);\r\n      this._triangleA2 = TriangleCandidate.createFromIndexedXYZ(intervalA.points, intervalA.begin + 1, intervalA.points, intervalA.begin + 2, intervalB.points, intervalB.begin, 2, this._triangleA2);\r\n      this._triangleA3 = TriangleCandidate.createFromIndexedXYZ(intervalA.points, intervalA.begin, intervalA.points, intervalA.begin + 1, intervalB.points, intervalB.begin + 1, 3, this._triangleA3);\r\n\r\n      this._triangleB1 = TriangleCandidate.createFromIndexedXYZ(intervalB.points, intervalB.begin + 1, intervalB.points, intervalB.begin, intervalA.points, intervalA.begin, -1, this._triangleB1);\r\n      this._triangleB2 = TriangleCandidate.createFromIndexedXYZ(intervalB.points, intervalB.begin + 2, intervalB.points, intervalB.begin + 1, intervalA.points, intervalA.begin, -2, this._triangleB2);\r\n      this._triangleB3 = TriangleCandidate.createFromIndexedXYZ(intervalB.points, intervalB.begin + 1, intervalB.points, intervalB.begin, intervalA.points, intervalA.begin + 1, -3, this._triangleB3);\r\n      // Look at pairs of 2 triangles.\r\n      // (each pair begins with 1 or -1)\r\n      // For each pair find the smallest aspect ratio of its two triangles.  (Small is bad)\r\n      // Choose the pair where that (smaller aspect ratio of two) is largest.\r\n      // Advance in that direction.\r\n      this._bestTriangle = TriangleCandidate.copyWithLowerQuality(this._triangleA1, this._triangleB3, this._bestTriangle);\r\n      this._workTriangle = TriangleCandidate.copyWithLowerQuality(this._triangleB1, this._triangleA3, this._workTriangle);\r\n      TriangleCandidate.updateIfOtherHasHigherQuality(this._bestTriangle, this._workTriangle);\r\n      // TestTriangle::UpdateIfOtherHasLargerAspectRatio (bestTriangle, TestTriangle::MergeAspectRatio (triangleB1, triangleB2));\r\n      // TestTriangle::UpdateIfOtherHasLargerAspectRatio (bestTriangle, TestTriangle::MergeAspectRatio (triangleA1, triangleA2));\r\n\r\n      if (this._bestTriangle.id > 0) {\r\n        intervalA.advanceBegin();\r\n        handler(this._bestTriangle);\r\n        if (addOnly1)\r\n          return;\r\n      } else {\r\n        intervalB.advanceBegin();\r\n        handler(this._bestTriangle);\r\n        if (addOnly1)\r\n          return;\r\n      }\r\n    }\r\n    // sweep in trailing points from either side.  At least one of intervalA.begin, intervalB.begin is at its limit, so only one of these will execute any bodies.\r\n    if (intervalA.isSingleton) {\r\n      while (intervalB.length >= 2) {\r\n        this._workTriangle = TriangleCandidate.createFromIndexedXYZ(intervalB.points, intervalB.begin + 1, intervalB.points, intervalB.begin, intervalA.points, intervalA.begin, 0, this._workTriangle);\r\n        //  this._workTriangle.scaleFromPointInPlace(this._workTriangle.points[2], 0.95); // crude visualization aid for tracking logic.\r\n        handler(this._workTriangle);\r\n        intervalB.advanceBegin();\r\n      }\r\n    }\r\n\r\n    // sweep in trailing points from either side.  At least one of baseA, baseB is at its limit, so only one of these will execute any bodies.\r\n    if (intervalB.isSingleton) {\r\n      while (intervalA.length >= 2) {\r\n        this._workTriangle = TriangleCandidate.createFromIndexedXYZ(intervalA.points, intervalA.begin, intervalA.points, intervalA.begin + 1, intervalB.points, intervalB.begin, 0, this._workTriangle);\r\n        // this._workTriangle.scaleFromPointInPlace(this._workTriangle.points[2], 0.95); // crude visualization aid for tracking logic.\r\n        handler(this._workTriangle);\r\n        intervalA.advanceBegin();\r\n      }\r\n    }\r\n  }\r\n\r\n  private _xyzA: Point3d;\r\n  private _xyzB: Point3d;\r\n  private _forwardA: Vector3d;\r\n  private _forwardB: Vector3d;\r\n  private _crossA: Vector3d;\r\n  private _crossB: Vector3d;\r\n  /**\r\n   * Working from start to finish, emit triangles with heuristic lookahead to get pleasing matching between the linestrings.\r\n   * @param pointsA\r\n   * @param pointsB\r\n   * @param handler\r\n   */\r\n  public emitTriangles(\r\n    pointsA: IndexedXYZCollection,\r\n    pointsB: IndexedXYZCollection,\r\n    handler: (triangle: BarycentricTriangle) => void) {\r\n    /** Clean up duplicates for the real logic . . . */\r\n    this.emitTrianglesGo(resolveToNoDuplicates(pointsA), resolveToNoDuplicates(pointsB), handler);\r\n  }\r\n  /**\r\n   * Run triangle logic on inputs with no duplicates.\r\n   * @param pointsA\r\n   * @param pointsB\r\n   * @param handler\r\n   */\r\n  private emitTrianglesGo(\r\n    pointsA: IndexedXYZCollection,\r\n    pointsB: IndexedXYZCollection,\r\n    handler: (triangle: BarycentricTriangle) => void) {\r\n    const intervalA = IndexedXYZCollectionInterval.createComplete(pointsA);\r\n    const intervalB = IndexedXYZCollectionInterval.createComplete(pointsB);\r\n    const childA = IndexedXYZCollectionInterval.createComplete(pointsA);\r\n    const childB = IndexedXYZCollectionInterval.createComplete(pointsB);\r\n    while (intervalA.length > 0 && intervalB.length > 0 && (intervalA.length > 1 || intervalB.length > 1)) {\r\n      // const lA = intervalA.length;\r\n      // const lB = intervalB.length;\r\n      if (this.isPlanarBase(pointsA, intervalA.begin, pointsB, intervalB.begin, this._xyzA, this._crossA, this._forwardA, this._xyzB, this._crossB, this._forwardB)) {\r\n        this.advanceToPlanarLimit(intervalA, childA, intervalA.begin + 1, this._xyzA, this._crossA, this._forwardA, this._crossB, this._forwardB);\r\n        this.advanceToPlanarLimit(intervalB, childB, intervalB.begin + 1, this._xyzB, this._crossB, this._forwardB, this._crossA, this._forwardA);\r\n        this.addGreedy(childA, childB, handler);\r\n        intervalA.advanceToTail(childA);\r\n        intervalB.advanceToTail(childB);\r\n      } else if (this.isPlanarBase(pointsA, intervalA.begin + 1, pointsB, intervalB.begin, this._xyzA, this._crossA, this._forwardA, this._xyzB, this._crossB, this._forwardB)) {\r\n        childA.setFrom(intervalA, intervalA.begin, intervalA.begin + 2);\r\n        childB.setFrom(intervalB, intervalB.begin, intervalB.begin + 1);\r\n        this.addGreedy(childA, childB, handler);\r\n        intervalA.advanceToTail(childA);\r\n        intervalB.advanceToTail(childB);\r\n      } else if (this.isPlanarBase(pointsA, intervalA.begin, pointsB, intervalB.begin + 1, this._xyzA, this._crossA, this._forwardA, this._xyzB, this._crossB, this._forwardB)) {\r\n        childA.setFrom(intervalA, intervalA.begin, intervalA.begin + 1);\r\n        childB.setFrom(intervalB, intervalB.begin, intervalB.begin + 2);\r\n        this.addGreedy(childA, childB, handler);\r\n        intervalA.advanceToTail(childA);\r\n        intervalB.advanceToTail(childB);\r\n      } else if (intervalA.length > 1 && intervalB.length > 1) {\r\n        childA.setFrom(intervalA, intervalA.begin, intervalA.begin + 2);\r\n        childB.setFrom(intervalB, intervalB.begin, intervalB.begin + 2);\r\n        this.addGreedy(childA, childB, handler, true);\r\n        intervalA.advanceToHead(childA);\r\n        intervalB.advanceToHead(childB);\r\n      } else if (intervalA.length > 1) {\r\n        childA.setFrom(intervalA, intervalA.begin, intervalA.begin + 2);\r\n        childB.setFrom(intervalB);\r\n        this.addGreedy(childA, childB, handler);\r\n        intervalA.advanceToTail(childA);\r\n        intervalB.advanceToTail(childB);\r\n      } else if (intervalB.length > 1) {\r\n        childA.setFrom(intervalA);\r\n        childB.setFrom(intervalB, intervalB.begin, intervalB.begin + 2);\r\n        this.addGreedy(childA, childB, handler);\r\n        intervalA.advanceToTail(childA);\r\n        intervalB.advanceToTail(childB);\r\n      }\r\n      /*      if (intervalA.length >= lA && intervalB.length >= lB) {\r\n              // This should not happen == neither one advanced.   Just move ahead in the longer one ..\r\n              if (intervalA.length > intervalB.length)\r\n                intervalA.advanceBegin();\r\n              else intervalB.advanceBegin();\r\n            } */\r\n    }\r\n    // catch everything else blindly\r\n    this.addGreedy(intervalA, intervalB, handler);\r\n  }\r\n  /** Default angle for considering two vectors to be colinear */\r\n  public static defaultNearColinearAngle = Angle.createDegrees(15);\r\n  public static createContext(planarTurnAngle: Angle = this.defaultNearColinearAngle) {\r\n    return new GreedyTriangulationBetweenLineStrings(planarTurnAngle.radians);\r\n  }\r\n}\r\n\r\n/**\r\n * * If there are no contiguous duplicated points in `data` return `data` unchanged.\r\n * * If there are duplicates, compress to a new array.\r\n * @param data\r\n * @param tolerance\r\n */\r\nfunction resolveToNoDuplicates(data: IndexedXYZCollection, tolerance = Geometry.smallMetricDistance): IndexedXYZCollection {\r\n  let hasDuplicates = false;\r\n  const n = data.length;\r\n  for (let i = 0; i + 1 < n; i++) {\r\n    if (data.distanceIndexIndex(i, i + 1)! <= tolerance) {\r\n      hasDuplicates = true;\r\n      break;\r\n    }\r\n  }\r\n  if (!hasDuplicates)\r\n    return data;\r\n  const result = new GrowableXYZArray(n);\r\n  result.pushXYZ(data.getXAtUncheckedPointIndex(0), data.getYAtUncheckedPointIndex(0), data.getZAtUncheckedPointIndex(0));\r\n  let i0 = 0;\r\n  for (let i = 1; i < n; i++) {\r\n    if (data.distanceIndexIndex(i0, i)! > tolerance) {\r\n      result.pushXYZ(data.getXAtUncheckedPointIndex(i), data.getYAtUncheckedPointIndex(i), data.getZAtUncheckedPointIndex(i));\r\n      i0 = i;\r\n    }\r\n  }\r\n  /** enforce exact closure if original was closed. */\r\n  if (data.distanceIndexIndex(0, n - 1)! <= tolerance) {\r\n    result.pop();\r\n    result.pushFromGrowableXYZArray(result, 0);\r\n  }\r\n  return result;\r\n}\r\n"]}

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

@@ -0,0 +1,87 @@
+/** @packageDocumentation
+ * @module Polyface
+ */
+/**
+ * * For boundary sorting, an edge is a (packed!) Float64Array.
+ * * Fixed entry positions are:
+ *   * [0] is start vertex index (in CCW order around its facet)
+ *   * [1] is end vertex index (in CCW order around its facet)
+ *   * [2] is facet index.
+ */
+export declare class SortableEdge extends Float64Array {
+    /** Return the vertex index that appears first in the order stored.  */
+    get vertexIndexA(): number;
+    /** Return the vertex index that appears second in the order stored.  */
+    get vertexIndexB(): number;
+    /** Return the facet index.  */
+    get facetIndex(): number;
+    /** return true if vertexIndexA is less than vertexIndexB */
+    get isLowHigh(): boolean;
+    /** Return the vertex index with lower numeric value */
+    get lowVertexIndex(): number;
+    /** Return the vertex index with higher numeric value */
+    get highVertexIndex(): number;
+    /** Return true if the vertices edgeA and edgeB are the same vertex indices in opposite order */
+    static areDirectedPartners(edgeA: SortableEdge, edgeB: SortableEdge): boolean;
+    /** Return true if the vertices edgeA and edgeB are the same vertex indices with no consideration of order */
+    static areUndirectedPartners(edgeA: SortableEdge, edgeB: SortableEdge): boolean;
+    /** Return numeric relationship of edgeA and edgeB:
+     * * 1 if they share start and end in the same order
+     * * -1 if they share start and end in reversed order
+     * * 0 otherwise.
+     */
+    static relativeOrientation(edgeA: SortableEdge, edgeB: SortableEdge): number;
+    get isNullEdge(): boolean;
+    /**
+     * lexical comparison of two edges.
+     * * If the edges have the same vertex pair (in same or opposite order) they will end up adjacent in a sort
+     * * If the edges have 0 or 1 shared vertex indices, the one with lowest low comes first.
+     * @param edgeA first edge
+     * @param edgeB second edge
+     */
+    static lessThan(edgeA: SortableEdge, edgeB: SortableEdge): number;
+    constructor(vertexA: number, vertexB: number, facetIndex: number);
+    toJSON(): any;
+    static clusterToJSON(data: SortableEdgeCluster): any;
+    static clusterArrayToJSON(data: SortableEdgeCluster[]): any[];
+}
+export declare type SortableEdgeCluster = SortableEdge | SortableEdge[];
+/**
+ * An IndexedEdgeMatcher carries an array (`edges`) of edges start & end indices for sorting and subsequent analyses (such as testing for closed mesh)
+ */
+export declare class IndexedEdgeMatcher {
+    edges: SortableEdge[];
+    constructor();
+    /**
+     * push a new edge.
+     * @returns the edge (as emplaced at the back of the sortableEdge array)
+     * @param vertexA start vertex
+     * @param vertexB end vertex
+     * @param facetIndex facet index
+     */
+    addEdge(vertexA: number, vertexB: number, facetIndex: number): SortableEdge;
+    /**
+     * Push edges all around a facet, returning to vertexArray[0]
+     * @param vertexArray array of vertex indices around facet
+     * @param facetIndex
+     */
+    addPath(vertexArray: number[], facetIndex: number, closeLoop?: boolean): void;
+    /** Sort the edge index array. */
+    sort(): void;
+    /** Create a single or compound SortableEdgeCluster in dest. */
+    private collectSortableEdgeCluster;
+    /**
+     * sort the edges, and look for three categories of paired edges:
+     * * caller must allocate all result arrays of interest.
+     * * Any combination of the result arrays may be `undefined`, indicating that category is to be ignored.
+     * * Any combination of the result arrays may be aliased as the same target, in which case those to categories are merged into the target.
+     * * For instance, to ignore manifold pairs and collect all others (singleton and other) as a single array `allOther`, create `const allOther = []` as an empty array and call
+     * `sortAndCollectClusters (undefined, allOther, allOther);`
+     * @param manifoldPairs optional array to receive pairs of properly mated SortableEdgePairs, i.e. simple interior edges adjacent to two facets in opposing directions.
+     * @param singletons optional array to receive edges that are simple boundary edges.
+     * @param nullEdges clusters with null edges (same start and end vertex)
+     * @param allOtherClusters optional array to receive arrays in which all the edges are partners in an undirected sense but not a simple directed pair.
+     */
+    sortAndCollectClusters(manifoldPairs: SortableEdgeCluster[] | undefined, singletons: SortableEdgeCluster[] | undefined, nullEdges: SortableEdgeCluster[] | undefined, allOtherClusters: SortableEdgeCluster[] | undefined): void;
+}
+//# sourceMappingURL=IndexedEdgeMatcher.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IndexedEdgeMatcher.d.ts","sourceRoot":"","sources":["../../../src/polyface/IndexedEdgeMatcher.ts"],"names":[],"mappings":"AAKA;;GAEG;AAKH;;;;;;GAMG;AACH,qBAAa,YAAa,SAAQ,YAAY;IAC5C,uEAAuE;IACvE,IAAW,YAAY,IAAI,MAAM,CAAoB;IACrD,wEAAwE;IACxE,IAAW,YAAY,IAAI,MAAM,CAAoB;IACrD,+BAA+B;IAC/B,IAAW,UAAU,IAAI,MAAM,CAAoB;IACnD,4DAA4D;IAC5D,IAAW,SAAS,IAAI,OAAO,CAA8B;IAC7D,uDAAuD;IACvD,IAAW,cAAc,IAAI,MAAM,CAAkD;IACrF,wDAAwD;IACxD,IAAW,eAAe,IAAI,MAAM,CAAkD;IACtF,gGAAgG;WAClF,mBAAmB,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO;IACpF,6GAA6G;WAC/F,qBAAqB,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO;IAGtF;;;;OAIG;WACW,mBAAmB,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,GAAG,MAAM;IAMnF,IAAW,UAAU,IAAI,OAAO,CAAgC;IAChE;;;;;;OAMG;WACW,QAAQ,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,GAAG,MAAM;gBAiBrD,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;IAMhE,MAAM,IAAI,GAAG;WACN,aAAa,CAAC,IAAI,EAAE,mBAAmB,GAAG,GAAG;WAO7C,kBAAkB,CAAC,IAAI,EAAE,mBAAmB,EAAE;CAM7D;AAED,oBAAY,mBAAmB,GAAG,YAAY,GAAG,YAAY,EAAE,CAAC;AAChE;;GAEG;AACH,qBAAa,kBAAkB;IACtB,KAAK,EAAE,YAAY,EAAE,CAAC;;IAK7B;;;;;;OAMG;IACI,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,YAAY;IAKlF;;;;OAIG;IACI,OAAO,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS,GAAE,OAAc;IASnF,iCAAiC;IAC1B,IAAI;IAGX,+DAA+D;IAC/D,OAAO,CAAC,0BAA0B;IAalC;;;;;;;;;;;OAWG;IACI,sBAAsB,CAAC,aAAa,EAAE,mBAAmB,EAAE,GAAG,SAAS,EAAE,UAAU,EAAE,mBAAmB,EAAE,GAAG,SAAS,EAAE,SAAS,EAAE,mBAAmB,EAAE,GAAG,SAAS,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,GAAG,SAAS;CAyBjO"}

package/lib/esm/polyface/IndexedEdgeMatcher.js

@@ -0,0 +1,192 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Polyface
+ */
+// For boundary sorting, an edge exists as a (packed!) Float64Array.
+// Fixed entries are:
+// 0:
+/**
+ * * For boundary sorting, an edge is a (packed!) Float64Array.
+ * * Fixed entry positions are:
+ *   * [0] is start vertex index (in CCW order around its facet)
+ *   * [1] is end vertex index (in CCW order around its facet)
+ *   * [2] is facet index.
+ */
+export class SortableEdge extends Float64Array {
+    /** Return the vertex index that appears first in the order stored.  */
+    get vertexIndexA() { return this[0]; }
+    /** Return the vertex index that appears second in the order stored.  */
+    get vertexIndexB() { return this[1]; }
+    /** Return the facet index.  */
+    get facetIndex() { return this[2]; }
+    /** return true if vertexIndexA is less than vertexIndexB */
+    get isLowHigh() { return this[0] < this[1]; }
+    /** Return the vertex index with lower numeric value */
+    get lowVertexIndex() { return this[0] < this[1] ? this[0] : this[1]; }
+    /** Return the vertex index with higher numeric value */
+    get highVertexIndex() { return this[0] > this[1] ? this[0] : this[1]; }
+    /** Return true if the vertices edgeA and edgeB are the same vertex indices in opposite order */
+    static areDirectedPartners(edgeA, edgeB) { return edgeA[0] === edgeB[1] && edgeA[1] === edgeB[0]; }
+    /** Return true if the vertices edgeA and edgeB are the same vertex indices with no consideration of order */
+    static areUndirectedPartners(edgeA, edgeB) {
+        return (edgeA[0] === edgeB[0] && edgeA[1] === edgeB[1]) || ((edgeA[0] === edgeB[1] && edgeA[1] === edgeB[0]));
+    }
+    /** Return numeric relationship of edgeA and edgeB:
+     * * 1 if they share start and end in the same order
+     * * -1 if they share start and end in reversed order
+     * * 0 otherwise.
+     */
+    static relativeOrientation(edgeA, edgeB) {
+        if (edgeA[0] === edgeB[0] && edgeA[1] === edgeB[1])
+            return 1;
+        if (edgeA[0] === edgeB[1] && edgeA[1] === edgeB[0])
+            return -1;
+        return 0;
+    }
+    get isNullEdge() { return this[0] === this[1]; }
+    /**
+     * lexical comparison of two edges.
+     * * If the edges have the same vertex pair (in same or opposite order) they will end up adjacent in a sort
+     * * If the edges have 0 or 1 shared vertex indices, the one with lowest low comes first.
+     * @param edgeA first edge
+     * @param edgeB second edge
+     */
+    static lessThan(edgeA, edgeB) {
+        // primary compare is based on indirect indices
+        const lowA = edgeA.lowVertexIndex;
+        const lowB = edgeB.lowVertexIndex;
+        if (lowA < lowB)
+            return -1;
+        if (lowB < lowA)
+            return 1;
+        const highA = edgeA.highVertexIndex;
+        const highB = edgeB.highVertexIndex;
+        if (highA < highB)
+            return -1;
+        if (highB < highA)
+            return 1;
+        // undirected indices match ... use directed vertexIndexA
+        return edgeA.vertexIndexA - edgeB.vertexIndexA;
+    }
+    constructor(vertexA, vertexB, facetIndex) {
+        super(3);
+        this[0] = vertexA;
+        this[1] = vertexB;
+        this[2] = facetIndex;
+    }
+    toJSON() { return [this[0], this[1], this[2]]; }
+    static clusterToJSON(data) {
+        if (data instanceof SortableEdge)
+            return data.toJSON();
+        const result = [];
+        for (const edge of data)
+            result.push(edge.toJSON());
+    }
+    static clusterArrayToJSON(data) {
+        const result = [];
+        for (const cluster of data)
+            result.push(SortableEdge.clusterToJSON(cluster));
+        return result;
+    }
+}
+/**
+ * An IndexedEdgeMatcher carries an array (`edges`) of edges start & end indices for sorting and subsequent analyses (such as testing for closed mesh)
+ */
+export class IndexedEdgeMatcher {
+    constructor() {
+        this.edges = [];
+    }
+    /**
+     * push a new edge.
+     * @returns the edge (as emplaced at the back of the sortableEdge array)
+     * @param vertexA start vertex
+     * @param vertexB end vertex
+     * @param facetIndex facet index
+     */
+    addEdge(vertexA, vertexB, facetIndex) {
+        const edge = new SortableEdge(vertexA, vertexB, facetIndex);
+        this.edges.push(edge);
+        return edge;
+    }
+    /**
+     * Push edges all around a facet, returning to vertexArray[0]
+     * @param vertexArray array of vertex indices around facet
+     * @param facetIndex
+     */
+    addPath(vertexArray, facetIndex, closeLoop = true) {
+        if (vertexArray.length === 0)
+            return;
+        const m = vertexArray.length - 1;
+        for (let i = 0; i < m; i++) {
+            this.addEdge(vertexArray[i], vertexArray[i + 1], facetIndex);
+        }
+        if (closeLoop)
+            this.addEdge(vertexArray[m], vertexArray[0], facetIndex);
+    }
+    /** Sort the edge index array. */
+    sort() {
+        this.edges.sort(SortableEdge.lessThan);
+    }
+    /** Create a single or compound SortableEdgeCluster in dest. */
+    collectSortableEdgeCluster(index0, index1, dest) {
+        if (dest !== undefined && index1 > index0) {
+            if (index1 === index0 + 1) {
+                dest.push(this.edges[index0]);
+            }
+            else {
+                const cluster = [];
+                for (let i = index0; i < index1; i++)
+                    cluster.push(this.edges[i]);
+                dest.push(cluster);
+            }
+        }
+    }
+    /**
+     * sort the edges, and look for three categories of paired edges:
+     * * caller must allocate all result arrays of interest.
+     * * Any combination of the result arrays may be `undefined`, indicating that category is to be ignored.
+     * * Any combination of the result arrays may be aliased as the same target, in which case those to categories are merged into the target.
+     * * For instance, to ignore manifold pairs and collect all others (singleton and other) as a single array `allOther`, create `const allOther = []` as an empty array and call
+     * `sortAndCollectClusters (undefined, allOther, allOther);`
+     * @param manifoldPairs optional array to receive pairs of properly mated SortableEdgePairs, i.e. simple interior edges adjacent to two facets in opposing directions.
+     * @param singletons optional array to receive edges that are simple boundary edges.
+     * @param nullEdges clusters with null edges (same start and end vertex)
+     * @param allOtherClusters optional array to receive arrays in which all the edges are partners in an undirected sense but not a simple directed pair.
+     */
+    sortAndCollectClusters(manifoldPairs, singletons, nullEdges, allOtherClusters) {
+        this.sort();
+        if (manifoldPairs)
+            manifoldPairs.length = 0;
+        if (singletons)
+            singletons.length = 0;
+        if (nullEdges)
+            nullEdges.length = 0;
+        if (allOtherClusters)
+            allOtherClusters.length = 0;
+        const n = this.edges.length;
+        let clusterLength;
+        for (let index0 = 0; index0 < n; index0 += clusterLength) {
+            const baseEdge = this.edges[index0];
+            clusterLength = 1;
+            for (let index1 = index0 + 1; index1 < n && SortableEdge.areUndirectedPartners(baseEdge, this.edges[index1]); index1++) {
+                clusterLength++;
+            }
+            if (this.edges[index0].isNullEdge) {
+                this.collectSortableEdgeCluster(index0, index0 + clusterLength, nullEdges);
+            }
+            else if (clusterLength === 2 && SortableEdge.areDirectedPartners(baseEdge, this.edges[index0 + 1])) {
+                this.collectSortableEdgeCluster(index0, index0 + clusterLength, manifoldPairs);
+            }
+            else if (clusterLength === 1) {
+                this.collectSortableEdgeCluster(index0, index0 + 1, singletons);
+            }
+            else {
+                this.collectSortableEdgeCluster(index0, index0 + clusterLength, allOtherClusters);
+            }
+        }
+    }
+}
+//# sourceMappingURL=IndexedEdgeMatcher.js.map