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

package/lib/esm/geometry3d/GrowableFloat64Array.js

@@ -0,0 +1,249 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/**
+ * A `GrowableFloat64Array` is Float64Array accompanied by a count of how many of the array's entries are considered in use.
+ * * In C++ terms, this is like an std::vector
+ * * As entries are added to the array, the buffer is reallocated as needed to accommodate.
+ * * The reallocations leave unused space to accept further additional entries without reallocation.
+ * * The `length` property returns the number of entries in use.
+ * * the `capacity` property returns the (usually larger) length of the (over-allocated) Float64Array.
+ * @public
+ */
+export class GrowableFloat64Array {
+    constructor(initialCapacity = 8) {
+        this._data = new Float64Array(initialCapacity);
+        this._inUse = 0;
+    }
+    /**
+     * Create a GrowableFloat64Array with given contents.
+     * @param contents data to copy into the array
+     */
+    static create(contents) {
+        const result = new GrowableFloat64Array(contents.length);
+        for (const a of contents) {
+            result.push(a);
+        }
+        return result;
+    }
+    /** sort-compatible comparison.
+     * * Returns `(a-b)` which is
+     *   * negative if `a<b`
+     *   * zero if `a === b` (with exact equality)
+     *   * positive if `a>b`
+     */
+    static compare(a, b) {
+        return a - b;
+    }
+    /** Return a new array with
+     * * All active entries copied from this instance
+     * * optionally trimmed capacity to the active length or replicate the capacity and unused space.
+     */
+    clone(maintainExcessCapacity = false) {
+        const n = this._inUse;
+        const data = this._data;
+        const out = new GrowableFloat64Array(maintainExcessCapacity ? this.capacity() : n);
+        for (let i = 0; i < n; i++)
+            out.push(data[i]);
+        return out;
+    }
+    /**
+     * Returns the number of entries in use.
+     * * Note that this is typically smaller than the length of the length of the supporting `Float64Array`
+     */
+    get length() {
+        return this._inUse;
+    }
+    /**
+     * Set the value at specified index.
+     * @param index index of entry to set
+     * @param value value to set
+     */
+    setAtUncheckedIndex(index, value) {
+        this._data[index] = value;
+    }
+    /**
+     * Move the value at index i to index j.
+     * @param i source index
+     * @param j destination index.
+     */
+    move(i, j) {
+        this._data[j] = this._data[i];
+    }
+    /**
+     * swap the values at indices i and j
+     * @param i first index
+     * @param j second index
+     */
+    swap(i, j) {
+        const a = this._data[i];
+        this._data[i] = this._data[j];
+        this._data[j] = a;
+    }
+    /**
+     * append a single value to the array.
+     * @param toPush value to append to the active array.
+     */
+    push(toPush) {
+        if (this._inUse + 1 <= this._data.length) {
+            this._data[this._inUse] = toPush;
+            this._inUse++;
+        }
+        else {
+            // Make new array (double size), copy values, then push toPush
+            const newData = new Float64Array(4 + this._inUse * 2);
+            for (let i = 0; i < this._inUse; i++) {
+                newData[i] = this._data[i];
+            }
+            this._data = newData;
+            this._data[this._inUse] = toPush;
+            this._inUse++;
+        }
+    }
+    /**
+     * Push each value from an array.
+     * @param data array of values to push
+     */
+    pushArray(data) {
+        for (const a of data)
+            this.push(a);
+    }
+    /** Push a `numToCopy` consecutive values starting at `copyFromIndex` to the end of the array. */
+    pushBlockCopy(copyFromIndex, numToCopy) {
+        const newLength = this._inUse + numToCopy;
+        this.ensureCapacity(newLength);
+        const limit = copyFromIndex + numToCopy;
+        for (let i = copyFromIndex; i < limit; i++)
+            this._data[this._inUse++] = this._data[i];
+    }
+    /** Clear the array to 0 length.  The underlying memory remains allocated for reuse. */
+    clear() {
+        while (this._inUse > 0)
+            this.pop();
+    }
+    /**
+     * Returns the number of entries in the supporting Float64Array buffer.
+     * * This number can be larger than the `length` property.
+     */
+    capacity() {
+        return this._data.length;
+    }
+    /**
+     * * If the capacity (Float64Array length) is less than or equal to the requested newCapacity, do nothing
+     * * If the requested newCapacity is larger than the existing capacity, reallocate (and copy existing values) with the larger capacity.
+     * @param newCapacity
+     */
+    ensureCapacity(newCapacity) {
+        if (newCapacity > this.capacity()) {
+            const oldInUse = this._inUse;
+            const newData = new Float64Array(newCapacity);
+            for (let i = 0; i < oldInUse; i++)
+                newData[i] = this._data[i];
+            this._data = newData;
+        }
+    }
+    /**
+     * * If newLength is less than current (active) length, just set (active) length.
+     * * If newLength is greater, ensureCapacity (newSize) and pad with padValue up to newSize;
+     * @param newLength new data count
+     * @param padValue value to use for padding if the length increases.
+     */
+    resize(newLength, padValue = 0) {
+        // quick out for easy case ...
+        if (newLength <= this._inUse) {
+            this._inUse = newLength;
+            return;
+        }
+        const oldLength = this._inUse;
+        this.ensureCapacity(newLength);
+        for (let i = oldLength; i < newLength; i++)
+            this._data[i] = padValue;
+        this._inUse = newLength;
+    }
+    /**
+     * * Reduce the length by one.
+     * * Note that there is no method return value -- use `back` to get that value before `pop()`
+     * * (As with std::vector, separating the `pop` from the value access eliminates error testing from `pop` call)
+     */
+    pop() {
+        // Could technically access outside of array, if filled and then reduced using pop (similar to C
+        // and accessing out of bounds), but with adjusted inUse counter, that data will eventually be overwritten
+        if (this._inUse > 0) {
+            this._inUse--;
+        }
+    }
+    /** Access by index, without bounds check */
+    atUncheckedIndex(index) {
+        return this._data[index];
+    }
+    /** Access the 0-index member, without bounds check */
+    front() {
+        return this._data[0];
+    }
+    /** Access the final member, without bounds check */
+    back() {
+        return this._data[this._inUse - 1];
+    }
+    /** set a value by index */
+    reassign(index, value) {
+        this._data[index] = value;
+    }
+    /**
+     * * Sort the array entries.
+     * * Uses insertion sort -- fine for small arrays (less than 30), slow for larger arrays
+     * @param compareMethod comparison method
+     */
+    sort(compareMethod = GrowableFloat64Array.compare) {
+        for (let i = 0; i < this._inUse; i++) {
+            for (let j = i + 1; j < this._inUse; j++) {
+                const tempI = this._data[i];
+                const tempJ = this._data[j];
+                if (compareMethod(tempI, tempJ) > 0) {
+                    this._data[i] = tempJ;
+                    this._data[j] = tempI;
+                }
+            }
+        }
+    }
+    /**
+     * * compress out values not within the [a,b] interval.
+     * * Note that if a is greater than b all values are rejected.
+     * @param a low value for accepted interval
+     * @param b high value for accepted interval
+     */
+    restrictToInterval(a, b) {
+        const data = this._data;
+        const n = data.length;
+        let numAccept = 0;
+        let q = 0;
+        for (let i = 0; i < n; i++) {
+            q = data[i];
+            if (q >= a && q <= b)
+                data[numAccept++] = q;
+        }
+        this._inUse = numAccept;
+    }
+    /**
+     * * compress out multiple copies of values.
+     * * this is done in the current order of the array.
+     */
+    compressAdjacentDuplicates(tolerance = 0.0) {
+        const data = this._data;
+        const n = this._inUse;
+        if (n === 0)
+            return;
+        let numAccepted = 1;
+        let a = data[0];
+        let b;
+        for (let i = 1; i < n; i++) {
+            b = data[i];
+            if (Math.abs(b - a) > tolerance) {
+                data[numAccepted++] = b;
+                a = b;
+            }
+        }
+        this._inUse = numAccepted;
+    }
+}
+//# sourceMappingURL=GrowableFloat64Array.js.map

package/lib/esm/geometry3d/GrowableFloat64Array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GrowableFloat64Array.js","sourceRoot":"","sources":["../../../src/geometry3d/GrowableFloat64Array.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n\r\n/** @packageDocumentation\r\n * @module ArraysAndInterfaces\r\n */\r\n\r\n/**\r\n * Type for a OptionalGrowableFloat64Array or undefined.\r\n * @public\r\n */\r\nexport type OptionalGrowableFloat64Array = GrowableFloat64Array | undefined;\r\n/**\r\n * Signature for a function which does lexical comparison of `blockSize` consecutive values as 2 starting indices.\r\n * @public\r\n */\r\nexport type BlockComparisonFunction = (data: Float64Array, blockSize: number, index0: number, index1: number) => number;\r\n/**\r\n * A `GrowableFloat64Array` is Float64Array accompanied by a count of how many of the array's entries are considered in use.\r\n * * In C++ terms, this is like an std::vector\r\n * * As entries are added to the array, the buffer is reallocated as needed to accommodate.\r\n * * The reallocations leave unused space to accept further additional entries without reallocation.\r\n * * The `length` property returns the number of entries in use.\r\n * * the `capacity` property returns the (usually larger) length of the (over-allocated) Float64Array.\r\n * @public\r\n */\r\nexport class GrowableFloat64Array {\r\n  private _data: Float64Array;\r\n  private _inUse: number;\r\n  constructor(initialCapacity: number = 8) {\r\n    this._data = new Float64Array(initialCapacity);\r\n    this._inUse = 0;\r\n  }\r\n  /**\r\n   * Create a GrowableFloat64Array with given contents.\r\n   * @param contents data to copy into the array\r\n   */\r\n  public static create(contents: Float64Array | number[]): GrowableFloat64Array {\r\n    const result = new GrowableFloat64Array(contents.length);\r\n    for (const a of contents) {\r\n      result.push(a);\r\n    }\r\n    return result;\r\n  }\r\n  /** sort-compatible comparison.\r\n   * * Returns `(a-b)` which is\r\n   *   * negative if `a<b`\r\n   *   * zero if `a === b` (with exact equality)\r\n   *   * positive if `a>b`\r\n   */\r\n  public static compare(a: any, b: any): number {\r\n    return a - b;\r\n  }\r\n  /** Return a new array with\r\n   * * All active entries copied from this instance\r\n   * * optionally trimmed capacity to the active length or replicate the capacity and unused space.\r\n   */\r\n  public clone(maintainExcessCapacity: boolean = false): GrowableFloat64Array {\r\n    const n = this._inUse;\r\n    const data = this._data;\r\n    const out = new GrowableFloat64Array(maintainExcessCapacity ? this.capacity() : n);\r\n    for (let i = 0; i < n; i++)\r\n      out.push(data[i]);\r\n    return out;\r\n  }\r\n  /**\r\n   * Returns the number of entries in use.\r\n   * * Note that this is typically smaller than the length of the length of the supporting `Float64Array`\r\n   */\r\n  public get length() {\r\n    return this._inUse;\r\n  }\r\n  /**\r\n   * Set the value at specified index.\r\n   * @param index index of entry to set\r\n   * @param value value to set\r\n   */\r\n  public setAtUncheckedIndex(index: number, value: number) {\r\n    this._data[index] = value;\r\n  }\r\n\r\n  /**\r\n   * Move the value at index i to index j.\r\n   * @param i source index\r\n   * @param j destination index.\r\n   */\r\n  public move(i: number, j: number) {\r\n    this._data[j] = this._data[i];\r\n  }\r\n  /**\r\n   * swap the values at indices i and j\r\n   * @param i first index\r\n   * @param j second index\r\n   */\r\n  public swap(i: number, j: number) {\r\n    const a = this._data[i];\r\n    this._data[i] = this._data[j];\r\n    this._data[j] = a;\r\n  }\r\n\r\n  /**\r\n   * append a single value to the array.\r\n   * @param toPush value to append to the active array.\r\n   */\r\n  public push(toPush: number) {\r\n    if (this._inUse + 1 <= this._data.length) {\r\n      this._data[this._inUse] = toPush;\r\n      this._inUse++;\r\n    } else {\r\n      // Make new array (double size), copy values, then push toPush\r\n      const newData = new Float64Array(4 + this._inUse * 2);\r\n      for (let i = 0; i < this._inUse; i++) {\r\n        newData[i] = this._data[i];\r\n      }\r\n      this._data = newData;\r\n      this._data[this._inUse] = toPush;\r\n      this._inUse++;\r\n    }\r\n  }\r\n  /**\r\n   * Push each value from an array.\r\n   * @param data array of values to push\r\n   */\r\n  public pushArray(data: Float64Array | number[]) {\r\n    for (const a of data) this.push(a);\r\n  }\r\n  /** Push a `numToCopy` consecutive values starting at `copyFromIndex` to the end of the array. */\r\n  public pushBlockCopy(copyFromIndex: number, numToCopy: number) {\r\n    const newLength = this._inUse + numToCopy;\r\n    this.ensureCapacity(newLength);\r\n    const limit = copyFromIndex + numToCopy;\r\n    for (let i = copyFromIndex; i < limit; i++)\r\n      this._data[this._inUse++] = this._data[i];\r\n  }\r\n  /** Clear the array to 0 length.  The underlying memory remains allocated for reuse. */\r\n  public clear() {\r\n    while (this._inUse > 0)\r\n      this.pop();\r\n  }\r\n  /**\r\n   * Returns the number of entries in the supporting Float64Array buffer.\r\n   * * This number can be larger than the `length` property.\r\n   */\r\n  public capacity() {\r\n    return this._data.length;\r\n  }\r\n  /**\r\n   * * If the capacity (Float64Array length) is less than or equal to the requested newCapacity, do nothing\r\n   * * If the requested newCapacity is larger than the existing capacity, reallocate (and copy existing values) with the larger capacity.\r\n   * @param newCapacity\r\n   */\r\n  public ensureCapacity(newCapacity: number) {\r\n    if (newCapacity > this.capacity()) {\r\n      const oldInUse = this._inUse;\r\n      const newData = new Float64Array(newCapacity);\r\n      for (let i = 0; i < oldInUse; i++)\r\n        newData[i] = this._data[i];\r\n      this._data = newData;\r\n    }\r\n  }\r\n  /**\r\n   * * If newLength is less than current (active) length, just set (active) length.\r\n   * * If newLength is greater, ensureCapacity (newSize) and pad with padValue up to newSize;\r\n   * @param newLength new data count\r\n   * @param padValue value to use for padding if the length increases.\r\n   */\r\n  public resize(newLength: number, padValue: number = 0) {\r\n    // quick out for easy case ...\r\n    if (newLength <= this._inUse) {\r\n      this._inUse = newLength;\r\n      return;\r\n    }\r\n    const oldLength = this._inUse;\r\n    this.ensureCapacity(newLength);\r\n    for (let i = oldLength; i < newLength; i++)\r\n      this._data[i] = padValue;\r\n    this._inUse = newLength;\r\n  }\r\n  /**\r\n   * * Reduce the length by one.\r\n   * * Note that there is no method return value -- use `back` to get that value before `pop()`\r\n   * * (As with std::vector, separating the `pop` from the value access eliminates error testing from `pop` call)\r\n   */\r\n  public pop() {\r\n    // Could technically access outside of array, if filled and then reduced using pop (similar to C\r\n    // and accessing out of bounds), but with adjusted inUse counter, that data will eventually be overwritten\r\n    if (this._inUse > 0) {\r\n      this._inUse--;\r\n    }\r\n  }\r\n  /** Access by index, without bounds check */\r\n  public atUncheckedIndex(index: number): number {\r\n    return this._data[index];\r\n  }\r\n  /** Access the 0-index member, without bounds check */\r\n  public front() {\r\n    return this._data[0];\r\n  }\r\n  /** Access the final member, without bounds check */\r\n  public back() {\r\n    return this._data[this._inUse - 1];\r\n  }\r\n  /** set a value by index */\r\n  public reassign(index: number, value: number) {\r\n    this._data[index] = value;\r\n  }\r\n\r\n  /**\r\n   * * Sort the array entries.\r\n   * * Uses insertion sort -- fine for small arrays (less than 30), slow for larger arrays\r\n   * @param compareMethod comparison method\r\n   */\r\n  public sort(compareMethod: (a: any, b: any) => number = GrowableFloat64Array.compare) {\r\n    for (let i = 0; i < this._inUse; i++) {\r\n      for (let j = i + 1; j < this._inUse; j++) {\r\n        const tempI = this._data[i];\r\n        const tempJ = this._data[j];\r\n        if (compareMethod(tempI, tempJ) > 0) {\r\n          this._data[i] = tempJ;\r\n          this._data[j] = tempI;\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * * compress out values not within the [a,b] interval.\r\n   * * Note that if a is greater than b all values are rejected.\r\n   * @param a low value for accepted interval\r\n   * @param b high value for accepted interval\r\n   */\r\n  public restrictToInterval(a: number, b: number) {\r\n    const data = this._data;\r\n    const n = data.length;\r\n    let numAccept = 0;\r\n    let q = 0;\r\n    for (let i = 0; i < n; i++) {\r\n      q = data[i];\r\n      if (q >= a && q <= b)\r\n        data[numAccept++] = q;\r\n    }\r\n    this._inUse = numAccept;\r\n  }\r\n\r\n  /**\r\n   * * compress out multiple copies of values.\r\n   * * this is done in the current order of the array.\r\n   */\r\n  public compressAdjacentDuplicates(tolerance: number = 0.0) {\r\n    const data = this._data;\r\n    const n = this._inUse;\r\n    if (n === 0)\r\n      return;\r\n\r\n    let numAccepted = 1;\r\n    let a = data[0];\r\n    let b;\r\n    for (let i = 1; i < n; i++) {\r\n      b = data[i];\r\n      if (Math.abs(b - a) > tolerance) {\r\n        data[numAccepted++] = b;\r\n        a = b;\r\n      }\r\n    }\r\n    this._inUse = numAccepted;\r\n  }\r\n\r\n}\r\n"]}

package/lib/esm/geometry3d/GrowableXYArray.d.ts

@@ -0,0 +1,204 @@
+import { MultiLineStringDataVariant } from "../topology/Triangulation";
+import { GrowableXYZArray } from "./GrowableXYZArray";
+import { IndexedXYCollection } from "./IndexedXYCollection";
+import { Matrix3d } from "./Matrix3d";
+import { Point2d, Vector2d } from "./Point2dVector2d";
+import { Point3d } from "./Point3dVector3d";
+import { Range2d } from "./Range";
+import { Transform } from "./Transform";
+import { XAndY, XYAndZ } from "./XYZProps";
+/** `GrowableXYArray` manages a (possibly growing) Float64Array to pack xy coordinates.
+ * @public
+ */
+export declare class GrowableXYArray extends IndexedXYCollection {
+    /**
+     * array of packed xyz xyz xyz components
+     */
+    private _data;
+    /**
+     * Number of xyz triples (not floats) in the array
+     */
+    private _xyInUse;
+    /**
+     * capacity in xyz triples. (not floats)
+     */
+    private _xyzCapacity;
+    /** Construct a new GrowablePoint2d array.
+     * @param numPoints [in] initial capacity.
+     */
+    constructor(numPoints?: number);
+    /** The number of points in use. When the length is increased, the array is padded with zeroes. */
+    get length(): number;
+    set length(newLength: number);
+    /** Return the number of float64 in use. */
+    get float64Length(): number;
+    /** Return the raw packed data.
+     * * Note that the length of the returned Float64Array is a count of doubles, and includes the excess capacity
+     */
+    float64Data(): Float64Array;
+    /** If necessary, increase the capacity to a new pointCount.  Current coordinates and point count (length) are unchanged. */
+    ensureCapacity(pointCapacity: number): void;
+    /** Resize the actual point count, preserving excess capacity. */
+    resize(pointCount: number): void;
+    /**
+     * Make a copy of the (active) points in this array.
+     * (The clone does NOT get excess capacity)
+     */
+    clone(): GrowableXYArray;
+    /** Create an array populated from
+     * * An array of Point2d
+     * * An array of Point3d (hidden as XAndY)
+     * * An array of objects with keyed values, et `{x:1, y:1}`
+     * * A `GrowableXYZArray`
+     */
+    static create(data: XAndY[] | GrowableXYZArray): GrowableXYArray;
+    /** Restructure MultiLineStringDataVariant as array of GrowableXYZArray */
+    static createArrayOfGrowableXYZArray(data: MultiLineStringDataVariant): GrowableXYZArray[] | undefined;
+    /** push a point to the end of the array */
+    push(toPush: XAndY): void;
+    /** push all points of an array */
+    pushAll(points: XAndY[]): void;
+    /** push all points of an array */
+    pushAllXYAndZ(points: XYAndZ[] | GrowableXYZArray): void;
+    /**
+     * Replicate numWrap xyz values from the front of the array as new values at the end.
+     * @param numWrap number of xyz values to replicate
+     */
+    pushWrap(numWrap: number): void;
+    /** push a point given by x,y coordinates */
+    pushXY(x: number, y: number): void;
+    /** Remove one point from the back.
+     * * NOTE that (in the manner of std::vector native) this is "just" removing the point -- no point is NOT returned.
+     * * Use `back ()` to get the last x,y,z assembled into a `Point3d `
+     */
+    pop(): void;
+    /**
+     * Test if index is valid for an xyz (point or vector) within this array
+     * @param index xyz index to test.
+     */
+    isIndexValid(index: number): boolean;
+    /**
+     * Clear all xyz data, but leave capacity unchanged.
+     */
+    clear(): void;
+    /**
+     * Get a point by index, strongly typed as a Point2d.  This is unchecked.  Use atPoint2dIndex to have validity test.
+     * @param pointIndex index to access
+     * @param result optional result
+     */
+    getPoint2dAtUncheckedPointIndex(pointIndex: number, result?: Point2d): Point2d;
+    /**
+     * Get x coordinate by point index, with no index checking
+     * @param pointIndex index to access
+     */
+    getXAtUncheckedPointIndex(pointIndex: number): number;
+    /**
+     * Get y coordinate by index, with no index checking
+     * @param pointIndex index to access
+     */
+    getYAtUncheckedPointIndex(pointIndex: number): number;
+    /**
+     * Gather all points as a Point2d[]
+     */
+    getPoint2dArray(): Point2d[];
+    /** copy xyz into strongly typed Point2d */
+    getPoint2dAtCheckedPointIndex(pointIndex: number, result?: Point2d): Point2d | undefined;
+    /** copy xyz into strongly typed Vector2d */
+    getVector2dAtCheckedVectorIndex(vectorIndex: number, result?: Vector2d): Vector2d | undefined;
+    /**
+     * Read coordinates from source array, place them at index within this array.
+     * @param destIndex point index where coordinates are to be placed in this array
+     * @param source source array
+     * @param sourceIndex point index in source array
+     * @returns true if destIndex and sourceIndex are both valid.
+     */
+    transferFromGrowableXYArray(destIndex: number, source: GrowableXYArray, sourceIndex: number): boolean;
+    /**
+     * push coordinates from the source array to the end of this array.
+     * @param source source array
+     * @param sourceIndex xyz index within the source.  If undefined, push entire contents of source
+     * @returns true if sourceIndex is valid.
+     */
+    pushFromGrowableXYArray(source: GrowableXYArray, sourceIndex?: number): number;
+    /**
+     * * Compute a point at fractional coordinate between points i and j of source
+     * * push onto this array.
+     */
+    pushInterpolatedFromGrowableXYArray(source: GrowableXYArray, i: number, fraction: number, j: number): void;
+    /**
+     * push coordinates from the source array to the end of this array.
+     * @param source source array
+     * @param transform optional transform to apply to points.
+     * @param dest optional result.
+     */
+    static createFromGrowableXYZArray(source: GrowableXYZArray, transform?: Transform, dest?: GrowableXYArray): GrowableXYArray;
+    /**
+     * Return the first point, or undefined if the array is empty.
+     */
+    front(result?: Point2d): Point2d | undefined;
+    /**
+     * Return the last point, or undefined if the array is empty.
+     */
+    back(result?: Point2d): Point2d | undefined;
+    /**
+     * Set the coordinates of a single point.
+     * @param pointIndex index of point to set
+     * @param value coordinates to set
+     */
+    setAtCheckedPointIndex(pointIndex: number, value: XAndY): boolean;
+    /**
+     * Set the coordinates of a single point given as coordinates.
+     * @param pointIndex index of point to set
+     * @param x x coordinate
+     * @param y y coordinate
+     */
+    setXYZAtCheckedPointIndex(pointIndex: number, x: number, y: number): boolean;
+    /**
+     * Copy all points into a simple array of Point3D with given z.
+     */
+    getPoint3dArray(z?: number): Point3d[];
+    /** reverse the order of points. */
+    reverseInPlace(): void;
+    /** multiply each point by the transform, replace values. */
+    multiplyTransformInPlace(transform: Transform): void;
+    /** multiply each xyz (as a vector) by matrix, replace values. */
+    multiplyMatrix3dInPlace(matrix: Matrix3d): void;
+    /** multiply each point by the transform, replace values. */
+    tryTransformInverseInPlace(transform: Transform): boolean;
+    /** Extend a `Range2d`, optionally transforming the points. */
+    extendRange(rangeToExtend: Range2d, transform?: Transform): void;
+    /** sum the lengths of segments between points. */
+    sumLengths(): number;
+    /**
+     * Multiply each x,y,z by the scale factor.
+     * @param factor
+     */
+    scaleInPlace(factor: number): void;
+    /** Compute a point at fractional coordinate between points i and j */
+    interpolate(i: number, fraction: number, j: number, result?: Point2d): Point2d | undefined;
+    /** Sum the signed areas of the projection to xy plane */
+    areaXY(): number;
+    /** Compute a vector from index origin i to indexed target j  */
+    vectorIndexIndex(i: number, j: number, result?: Vector2d): Vector2d | undefined;
+    /** Compute a vector from origin to indexed target j */
+    vectorXAndYIndex(origin: XAndY, j: number, result?: Vector2d): Vector2d | undefined;
+    /** Compute the cross product of vectors from from indexed origin to indexed targets i and j */
+    crossProductIndexIndexIndex(originIndex: number, targetAIndex: number, targetBIndex: number): number | undefined;
+    /** Compute the cross product of vectors from from origin to indexed targets i and j */
+    crossProductXAndYIndexIndex(origin: XAndY, targetAIndex: number, targetBIndex: number): number | undefined;
+    /** Return the distance between two points in the array. */
+    distance(i: number, j: number): number | undefined;
+    /** Return the distance between an array point and the input point. */
+    distanceIndexToPoint(i: number, spacePoint: Point2d): number | undefined;
+    /** Test for nearly equal arrays. */
+    static isAlmostEqual(dataA: GrowableXYArray | undefined, dataB: GrowableXYArray | undefined): boolean;
+    /** Return an array of block indices sorted per compareLexicalBlock function */
+    sortIndicesLexical(): Uint32Array;
+    /** compare two blocks in simple lexical order. */
+    compareLexicalBlock(ia: number, ib: number): number;
+    /** Access a single double at offset within a block.  This has no index checking. */
+    component(pointIndex: number, componentIndex: number): number;
+    /** Toleranced equality test */
+    isAlmostEqual(other: GrowableXYArray, tolerance?: number): boolean;
+}
+//# sourceMappingURL=GrowableXYArray.d.ts.map

package/lib/esm/geometry3d/GrowableXYArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GrowableXYArray.d.ts","sourceRoot":"","sources":["../../../src/geometry3d/GrowableXYArray.ts"],"names":[],"mappings":"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"}