@kitware/vtk.js 25.4.0 → 25.7.0

package/Common/Core/CellArray.d.ts

@@ -1,13 +1,12 @@
 import { TypedArray } from './../../types';
-import vtkDataArray from './DataArray';
+import vtkDataArray, { IDataArrayInitialValues } from './DataArray';
 
 
 /**
- *
+ * The inital values of a vtkCellArray.
  */
-export interface ICellArrayInitialValues {
+export interface ICellArrayInitialValues extends IDataArrayInitialValues {
 	empty?: boolean;
-	numberOfComponents?: number;
 }
 
 export interface vtkCellArray extends vtkDataArray {
@@ -19,22 +18,35 @@ export interface vtkCellArray extends vtkDataArray {
 	getNumberOfCells(recompute?: boolean): number;
 
 	/**
-	 *
+	 * Get the sizes of the cells in this array.
 	 * @param {Boolean} [recompute] Recompute the cell sizes.
 	 */
 	getCellSizes(recompute?: boolean): any;
 
 	/**
-	 *
-	 * @param {TypedArray} typedArray The typedArray value.
+	 * Set the data of this array.
+	 * @param {TypedArray} typedArray The Array value.
 	 */
 	setData(typedArray: TypedArray): void;
 
 	/**
-	 * Returns the point indexes at the given location as a subarray.
+	 * Returns the point indices at the given location as a subarray.
 	 * @param loc
 	 */
 	getCell(loc: any): void;
+
+	/**
+	 * Reset the cell array by setting the number of cells to 0.
+	 * NOTE: This won't touch the actual memory of the underlying typedArray.
+	 */
+	initialize(): void;
+
+	/**
+	 * Insert a cell to this array in the next available slot.
+	 * @param {Number[]} cellPointIds The list of point ids (NOT prefixed with the number of points)
+	 * @returns {Number} Idx of where the cell was inserted
+	 */
+	insertNextCell(cellPointIds: number[]): number;
 }
 
 /**

package/Common/Core/CellArray.js

@@ -1,4 +1,5 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
 import vtkDataArray from './DataArray.js';
 import { VtkDataTypes } from './DataArray/Constants.js';
@@ -54,7 +55,7 @@ function vtkCellArray(publicAPI, model) {
     if (model.cellSizes) {
       model.numberOfCells = model.cellSizes.length;
     } else {
-      model.numberOfCells = getNumberOfCells(model.values);
+      model.numberOfCells = getNumberOfCells(publicAPI.getData());
     }
 
     return model.numberOfCells;
@@ -65,7 +66,7 @@ function vtkCellArray(publicAPI, model) {
       return model.cellSizes;
     }
 
-    model.cellSizes = extractCellSizes(model.values);
+    model.cellSizes = extractCellSizes(publicAPI.getData());
     return model.cellSizes;
   };
 
@@ -76,16 +77,34 @@ function vtkCellArray(publicAPI, model) {
     model.numberOfCells = undefined;
     model.cellSizes = undefined;
   };
-  /**
-   * Returns the point indexes at the given location as a subarray.
-   */
-
 
   publicAPI.getCell = function (loc) {
     var cellLoc = loc;
     var numberOfPoints = model.values[cellLoc++];
     return model.values.subarray(cellLoc, cellLoc + numberOfPoints);
   };
+
+  var superInitialize = publicAPI.initialize;
+
+  publicAPI.initialize = function () {
+    superInitialize(); // Set to undefined to ensure insertNextCell works correctly
+
+    model.numberOfCells = undefined;
+    model.cellSizes = undefined;
+  };
+
+  publicAPI.insertNextCell = function (cellPointIds) {
+    var cellId = publicAPI.getNumberOfCells();
+    publicAPI.insertNextTuples([cellPointIds.length].concat(_toConsumableArray(cellPointIds))); // By computing the number of cells earlier, we made sure that numberOfCells is defined
+
+    ++model.numberOfCells;
+
+    if (model.cellSizes != null) {
+      model.cellSizes.push(cellPointIds.length);
+    }
+
+    return cellId;
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------

package/Common/Core/DataArray.d.ts

@@ -1,5 +1,5 @@
 import { vtkObject, vtkRange } from './../../interfaces';
-import { TypedArray } from './../../types';
+import { float, int, Nullable, TypedArray } from './../../types';
 
 
 /**
@@ -22,6 +22,19 @@ interface vtkRangeHelper {
 	getRange(): vtkRange;
 }
 
+/**
+ * The inital values of a vtkDataArray.
+ */
+export interface IDataArrayInitialValues {
+	dataType?: string;
+	empty?: boolean;
+	name?: string;
+	numberOfComponents?: number;
+	rangeTuple?: [number, number];
+	size?: number;
+	values?: Array<number>|TypedArray;
+}
+
 export interface vtkDataArray extends vtkObject {
 
 	/**
@@ -64,56 +77,151 @@ export interface vtkDataArray extends vtkObject {
 	setRange(rangeValue: vtkRange, componentIndex: number): [number, number];
 
 	/**
+	 * Set the given tuple at the given index.
+	 * @param {Number} idx
+	 * @param {Array<Number>|TypedArray} tuple
+	 */
+	setTuple(idx: number, tuple: Array<number>|TypedArray): void;
+
+	/**
+	 * Set the given tuples starting at the given index.
+	 * @param {Number} idx
+	 * @param {Array<Number>|TypedArray} tuples
+	 */
+	setTuples(idx: number, tuples: Array<number>|TypedArray): void;
+
+	/**
+	 * Get the tuple at the given index.
+	 *
+	 * The recommended use is the following:
+	 * `const x = [];`
+	 * `dataArray.getTuple(idx, x);`
+	 * instead of:
+	 * `const x = dataArray.getTuple(idx);`
 	 *
 	 * @param {Number} idx
-	 * @param {Number[]} tuple
+	 * @param {Array<Number>} [tupleToFill] (default [])
+	 * @returns {Array<Number>}
+	 */
+	getTuple(idx: number, tupleToFill?: Array<number>): Array<number>;
+	
+	/**
+	 * Get the tuples between fromId (inclusive) and toId (exclusive).
+	 *
+	 * If fromId or toId is negative, it refers to a tuple index from the
+	 * end of the underlying typedArray.
+	 * If the range between fromId and toId is invalid, getTuples returns
+	 * null.
+	 *
+	 * NOTE: Any changes to the returned TypedArray will result in changes to
+	 * this DataArray's underlying TypedArray.
+	 *
+	 * @param {Number} [fromId] (default: 0)
+	 * @param {Number} [toId] (default: publicAPI.getNumberOfTuples())
+	 * @returns {Nullable<TypedArray>}
 	 */
-	setTuple(idx: number, tuple: number[]): void;
+	getTuples(fromId?: number, toId?: number): Nullable<TypedArray>;
 
 	/**
+	 * Insert the given tuple at the given index.
+	 * NOTE: May resize the data values array. "Safe" version of setTuple.
+	 *
+	 * A typical usage is when `vtkDataArray` is initialized with
+	 * `initialValues = { size: 0, values: new Uint8Array(1000) }`, where
+	 * an empty but pre-allocated array with 1'000 components is created.
+	 * The component values can then be inserted with `insertTuple()` or
+	 * `insertNextTuple()` without requiring new memory allocation until
+	 * the size of 1'000 is exceeded (e.g. after inserting the 250th
+	 * 4-component tuple).
+	 *
+	 * `insertTuple` increases the number of tuples (`getNumberOfTuples()`).
+	 *
+	 * @see insertNextTuple
+	 * @see getNumberOfTuples
 	 *
 	 * @param {Number} idx
-	 * @param {Number[]} [tupleToFill] (default [])
+	 * @param {Array<Number>|TypedArray} tuple
+	 * @returns {Number} Index of the inserted tuple
 	 */
-	getTuple(idx: number, tupleToFill?: number[]): number[];
+	insertTuple(idx: number, tuple: Array<number>|TypedArray): number;
+
+	/**
+	 * Insert tuples starting at the given idx.
+	 *
+	 * @param {Number} idx
+	 * @param {Array<Number>|TypedArray} tuples Flat array of tuples to insert
+	 * @returns The index of the last inserted tuple
+	 */
+	insertTuples(idx: number, tuples: Array<number>|TypedArray): number;
+
+	/**
+	 * Insert the given tuple at the next available slot and return the index of the insertion.
+	 * NOTE: May resize the data values array. "Safe" version of setTuple.
+	 *
+	 * @see insertTuple
+	 *
+	 * @param {Array<Number>|TypedArray} tuple
+	 * @returns {Number} Index of the inserted tuple.
+	 */
+	insertNextTuple(tuple: Array<number>|TypedArray): number;
+
+	/**
+	 * Convenience function to insert an array of tuples with insertNextTuple.
+	 * NOTE: tuples.length must be a multiple of `getNumberOfComponents`.
+	 * @param {Array<Number>|TypedArray} tuples
+	 * @returns The index of the last inserted tuple
+	 */
+	insertNextTuples(tuples: Array<number>|TypedArray): number;
 
 	/**
 	 *
 	 * @param {Number} [idx] (default: 1)
+	 * @returns {Number}
 	 */
 	getTupleLocation(idx?: number): number;
 
 	/**
 	 * Get the dimension (n) of the components.
+	 * @returns {Number}
 	 */
 	getNumberOfComponents(): number;
 
 	/**
-	 * Get the total number of values in the array.
+	 * Get the actual  number of values in the array, which is equal to `getNumberOfTuples() * getNumberOfComponents()`.
+	 * @returns {Number}
 	 */
 	getNumberOfValues(): number;
 
 	/**
-	 * Get the number of complete tuples (a component group) in the array.
+	 * Get the actual number of complete tuples (a component group) in the array.
+	 * @returns {Number}
 	 */
 	getNumberOfTuples(): number;
 
 	/**
-	 *
+	 * Get the data type of this array as a string.
+	 * @returns {String}
 	 */
 	getDataType(): string;
 
 	/**
-	 *
+	 * Return a clone of this array.
+	 * @returns {vtkDataArray}
 	 */
 	newClone(): vtkDataArray;
 
 	/**
-	 *
+	 * Get the name of the array.
+	 * @returns {String}
 	 */
 	getName(): string;
 
 	/**
+	 * Set the data of this array.
+	 * Optionally pass ´numberOfComponents´ to overwrite this dataArray's
+	 * numberOfComponents.
+	 * If this dataArray's numberOfComponents doesn't divide the given array's
+	 * length, this dataArray's numberOfComponents is set to 1.
 	 *
 	 * @param {TypedArray} typedArray
 	 * @param {Number} [numberOfComponents]
@@ -121,14 +229,50 @@ export interface vtkDataArray extends vtkObject {
 	setData(typedArray: TypedArray, numberOfComponents?: number): void;
 
 	/**
-	 *
+	 * Get the state of this array.
+	 * @returns {object}
 	 */
 	getState(): object;
 
+	/**
+	 * Deep copy of another vtkDataArray into this one.
+	 * @param {vtkDataArray} other
+	 */
+	deepCopy(other: vtkDataArray): void;
+	
+	/**
+	 * Interpolate between the tuples retrieved from source1 
+	 * and source2 with the resp. indices and set the 
+	 * resulting tuple to the idx of this DataArray.
+	 * 
+	 * @param {int} idx,
+	 * @param {vtkDataArray} source1,
+	 * @param {int} source1Idx,
+	 * @param {vtkDataArray} source2,
+	 * @param {int} source2Idx,
+	 * @param {float} t
+	 */
+	interpolateTuple(
+		idx: int,
+		source1: vtkDataArray,
+		source1Idx: int,
+		source2: vtkDataArray,
+		source2Idx: int,
+		t: float
+	): void;
+
+	/**
+	 * Reset this array.
+	 * NOTE: This won't touch the actual memory of the underlying typedArray. 
+	 */
+	initialize(): void;
+
 	// --- via macro --
 
 	/**
-	 *
+	 * Set the name of this array.
+	 * @param {String} name
+	 * @returns {Boolean}
 	 */
 	setName(name: string): boolean;
 
@@ -199,9 +343,9 @@ export function getMaxNorm(dataArray: vtkDataArray): number
  *
  * @param publicAPI object on which methods will be bounds (public)
  * @param model object on which data structure will be bounds (protected)
- * @param {object} [initialValues] (default: {})
+ * @param {object} [initialValues] (default: {}) Must pass a number > 0 for `size` except if `empty: true` is also passed or a non-empty typed array for `values`. 
  */
-export function extend(publicAPI: object, model: object, initialValues?: object): void;
+export function extend(publicAPI: object, model: object, initialValues?: IDataArrayInitialValues): void;
 
 // ----------------------------------------------------------------------------
 
@@ -252,7 +396,7 @@ export declare const vtkDataArray: {
 	// static
 	computeRange: typeof computeRange,
 	createRangeHelper: typeof createRangeHelper,
-  fastComputeRange: typeof fastComputeRange,
+	fastComputeRange: typeof fastComputeRange,
 	getDataType: typeof getDataType,
 	getMaxNorm: typeof getMaxNorm,
 	// constants

package/Common/Core/DataArray.js

@@ -1,11 +1,12 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import Constants from './DataArray/Constants.js';
-import { newInstance as newInstance$1, newTypedArray, newTypedArrayFrom, obj, set } from '../../macros.js';
+import { newInstance as newInstance$1, newTypedArray, newTypedArrayFrom, obj, set, vtkErrorMacro as vtkErrorMacro$1 } from '../../macros.js';
 import { n as norm } from './Math/index.js';
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var vtkErrorMacro = vtkErrorMacro$1;
 var DefaultDataType = Constants.DefaultDataType;
 var TUPLE_HOLDER = []; // ----------------------------------------------------------------------------
 // Global methods
@@ -164,6 +165,44 @@ function vtkDataArray(publicAPI, model) {
     model.ranges = null;
     publicAPI.modified();
   }
+  /**
+   * Resize model.values and copy the old values to the new array.
+   * @param {Number} requestedNumTuples Final expected number of tuples; must be >= 0
+   * @returns {Boolean} True if a resize occured, false otherwise
+   */
+
+
+  function resize(requestedNumTuples) {
+    if (requestedNumTuples < 0) {
+      return false;
+    }
+
+    var numComps = publicAPI.getNumberOfComponents();
+    var curNumTuples = model.values.length / (numComps > 0 ? numComps : 1);
+
+    if (requestedNumTuples === curNumTuples) {
+      return true;
+    }
+
+    if (requestedNumTuples > curNumTuples) {
+      // Requested size is bigger than current size.  Allocate enough
+      // memory to fit the requested size and be more than double the
+      // currently allocated memory.
+      var oldValues = model.values;
+      model.values = newTypedArray(model.dataType, (requestedNumTuples + curNumTuples) * numComps);
+      model.values.set(oldValues);
+      return true;
+    } // Requested size is smaller than current size
+
+
+    model.size = requestedNumTuples * numComps;
+    dataChange();
+    return true;
+  }
+
+  publicAPI.initialize = function () {
+    resize(0);
+  };
 
   publicAPI.getElementComponentSize = function () {
     return model.values.BYTES_PER_ELEMENT;
@@ -190,8 +229,20 @@ function vtkDataArray(publicAPI, model) {
     }
   };
 
+  publicAPI.getValue = function (valueIdx) {
+    var idx = valueIdx / model.numberOfComponents;
+    var comp = valueIdx % model.numberOfComponents;
+    return publicAPI.getComponent(idx, comp);
+  };
+
+  publicAPI.setValue = function (valueIdx, value) {
+    var idx = valueIdx / model.numberOfComponents;
+    var comp = valueIdx % model.numberOfComponents;
+    publicAPI.setComponent(idx, comp, value);
+  };
+
   publicAPI.getData = function () {
-    return model.values;
+    return model.size === model.values.length ? model.values : model.values.subarray(0, model.size);
   };
 
   publicAPI.getRange = function () {
@@ -212,7 +263,7 @@ function vtkDataArray(publicAPI, model) {
     } // Need to compute ranges...
 
 
-    range = computeRange(model.values, componentIndex, model.numberOfComponents);
+    range = computeRange(publicAPI.getData(), componentIndex, model.numberOfComponents);
     model.ranges[rangeIdx] = range;
     model.rangeTuple[0] = range.min;
     model.rangeTuple[1] = range.max;
@@ -242,6 +293,47 @@ function vtkDataArray(publicAPI, model) {
     }
   };
 
+  publicAPI.setTuples = function (idx, tuples) {
+    var i = idx * model.numberOfComponents;
+    var last = Math.min(tuples.length, model.size - i);
+
+    for (var j = 0; j < last;) {
+      model.values[i++] = tuples[j++];
+    }
+  };
+
+  publicAPI.insertTuple = function (idx, tuple) {
+    if (model.size <= idx * model.numberOfComponents) {
+      model.size = (idx + 1) * model.numberOfComponents;
+      resize(idx + 1);
+    }
+
+    publicAPI.setTuple(idx, tuple);
+    return idx;
+  };
+
+  publicAPI.insertTuples = function (idx, tuples) {
+    var end = idx + tuples.length / model.numberOfComponents;
+
+    if (model.size < end * model.numberOfComponents) {
+      model.size = end * model.numberOfComponents;
+      resize(end);
+    }
+
+    publicAPI.setTuples(idx, tuples);
+    return end;
+  };
+
+  publicAPI.insertNextTuple = function (tuple) {
+    var idx = model.size / model.numberOfComponents;
+    return publicAPI.insertTuple(idx, tuple);
+  };
+
+  publicAPI.insertNextTuples = function (tuples) {
+    var idx = model.size / model.numberOfComponents;
+    return publicAPI.insertTuples(idx, tuples);
+  };
+
   publicAPI.getTuple = function (idx) {
     var tupleToFill = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : TUPLE_HOLDER;
     var numberOfComponents = model.numberOfComponents || 1;
@@ -253,29 +345,40 @@ function vtkDataArray(publicAPI, model) {
     var offset = idx * numberOfComponents; // Check most common component sizes first
     // to avoid doing a for loop if possible
 
-    if (numberOfComponents === 1) {
-      tupleToFill[0] = model.values[offset];
-    } else if (numberOfComponents === 2) {
-      tupleToFill[0] = model.values[offset];
-      tupleToFill[1] = model.values[offset + 1];
-    } else if (numberOfComponents === 3) {
-      tupleToFill[0] = model.values[offset];
-      tupleToFill[1] = model.values[offset + 1];
-      tupleToFill[2] = model.values[offset + 2];
-    } else if (numberOfComponents === 4) {
-      tupleToFill[0] = model.values[offset];
-      tupleToFill[1] = model.values[offset + 1];
-      tupleToFill[2] = model.values[offset + 2];
-      tupleToFill[3] = model.values[offset + 3];
-    } else {
-      for (var i = 0; i < numberOfComponents; i++) {
-        tupleToFill[i] = model.values[offset + i];
-      }
+    switch (numberOfComponents) {
+      case 4:
+        tupleToFill[3] = model.values[offset + 3];
+      // eslint-disable-next-line no-fallthrough
+
+      case 3:
+        tupleToFill[2] = model.values[offset + 2];
+      // eslint-disable-next-line no-fallthrough
+
+      case 2:
+        tupleToFill[1] = model.values[offset + 1];
+      // eslint-disable-next-line no-fallthrough
+
+      case 1:
+        tupleToFill[0] = model.values[offset];
+        break;
+
+      default:
+        for (var i = 0; i < numberOfComponents; i++) {
+          tupleToFill[i] = model.values[offset + i];
+        }
+
     }
 
     return tupleToFill;
   };
 
+  publicAPI.getTuples = function (fromId, toId) {
+    var from = (fromId !== null && fromId !== void 0 ? fromId : 0) * model.numberOfComponents;
+    var to = (toId !== null && toId !== void 0 ? toId : publicAPI.getNumberOfTuples()) * model.numberOfComponents;
+    var arr = publicAPI.getData().subarray(from, to);
+    return arr.length > 0 ? arr : null;
+  };
+
   publicAPI.getTupleLocation = function () {
     var idx = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
     return idx * model.numberOfComponents;
@@ -286,11 +389,11 @@ function vtkDataArray(publicAPI, model) {
   };
 
   publicAPI.getNumberOfValues = function () {
-    return model.values.length;
+    return model.size;
   };
 
   publicAPI.getNumberOfTuples = function () {
-    return model.values.length / model.numberOfComponents;
+    return model.size / model.numberOfComponents;
   };
 
   publicAPI.getDataType = function () {
@@ -366,17 +469,66 @@ function vtkDataArray(publicAPI, model) {
 
     return sortedObj;
   };
+
+  publicAPI.deepCopy = function (other) {
+    publicAPI.shallowCopy(other);
+    publicAPI.setData(other.getData().slice());
+  };
+
+  publicAPI.interpolateTuple = function (idx, source1, source1Idx, source2, source2Idx, t) {
+    var numberOfComponents = model.numberOfComponents || 1;
+
+    if (numberOfComponents !== source1.getNumberOfComponents() || numberOfComponents !== source2.getNumberOfComponents()) {
+      vtkErrorMacro('numberOfComponents must match');
+    }
+
+    var tuple1 = [];
+    var tuple2 = [];
+    var out = [];
+    out.length = numberOfComponents;
+    source1.getTuple(source1Idx, tuple1);
+    source2.getTuple(source2Idx, tuple2); // Check most common component sizes first
+    // to avoid doing a for loop if possible
+
+    switch (numberOfComponents) {
+      case 4:
+        out[3] = tuple1[3] + (tuple2[3] - tuple1[3]) * t;
+      // eslint-disable-next-line no-fallthrough
+
+      case 3:
+        out[2] = tuple1[2] + (tuple2[2] - tuple1[2]) * t;
+      // eslint-disable-next-line no-fallthrough
+
+      case 2:
+        out[1] = tuple1[1] + (tuple2[1] - tuple1[1]) * t;
+      // eslint-disable-next-line no-fallthrough
+
+      case 1:
+        out[0] = tuple1[0] + (tuple2[0] - tuple1[0]) * t;
+        break;
+
+      default:
+        for (var i = 0; i < numberOfComponents; i++) {
+          out[i] = tuple1[i] + (tuple2[i] - tuple1[i]) * t;
+        }
+
+    }
+
+    return publicAPI.insertTuple(idx, out);
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
+// size: The current size of the dataArray.
+// NOTE: The underlying typed array may be larger than 'size'.
 
 
 var DEFAULT_VALUES = {
   name: '',
   numberOfComponents: 1,
-  size: 0,
   dataType: DefaultDataType,
-  rangeTuple: [0, 0] // values: null,
+  rangeTuple: [0, 0] // size: undefined,
+  // values: null,
   // ranges: null,
 
 }; // ----------------------------------------------------------------------------
@@ -396,7 +548,10 @@ function extend(publicAPI, model) {
   }
 
   if (model.values) {
-    model.size = model.values.length;
+    var _model$size;
+
+    // Takes the size if provided (can be lower than `model.values`) otherwise the actual length of `values`.
+    model.size = (_model$size = model.size) !== null && _model$size !== void 0 ? _model$size : model.values.length;
     model.dataType = getDataType(model.values);
   } // Object methods
 

package/Common/Core/Math/index.js

@@ -2347,4 +2347,4 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   'default': vtkMath
 });
 
-export { ceilLog2 as $, rowsToMat3 as A, degreesFromRadians as B, areEquals as C, clampValue as D, arrayRange as E, getMajorAxisIndex as F, isInf as G, rgb2hsv as H, rgb2lab as I, lab2rgb as J, floor as K, round as L, normalize2D as M, nearestPowerOfTwo as N, createUninitializedBounds as O, multiply3x3_vect3 as P, areBoundsInitialized as Q, isPowerOfTwo as R, angleBetweenVectors as S, signedAngleBetweenVectors as T, createArray as U, Pi as V, ceil as W, min as X, max as Y, arrayMin as Z, arrayMax as _, areMatricesEqual as a, factorial as a0, binomial as a1, beginCombination as a2, nextCombination as a3, randomSeed as a4, getSeed as a5, gaussian as a6, multiplyScalar2D as a7, multiplyAccumulate2D as a8, outer as a9, luFactorLinearSystem as aA, luSolveLinearSystem as aB, invertMatrix as aC, estimateMatrixCondition as aD, solveHomogeneousLeastSquares as aE, solveLeastSquares as aF, hex2float as aG, lab2xyz as aH, xyz2lab as aI, xyz2rgb as aJ, rgb2xyz as aK, clampAndNormalizeValue as aL, getScalarTypeFittingRange as aM, getAdjustedScalarRange as aN, extentIsWithinOtherExtent as aO, boundsIsWithinOtherBounds as aP, pointIsWithinBounds as aQ, solve3PointCircle as aR, inf as aS, negInf as aT, isFinite as aU, isNaN as aV, floatToHex2 as aW, floatRGB2HexCode as aX, float2CssRGBA as aY, projectVector as aa, dot2D as ab, projectVector2D as ac, gaussianAmplitude as ad, gaussianWeight as ae, outer2D as af, norm2D as ag, rowsToMat4 as ah, columnsToMat4 as ai, columnsToMat3 as aj, LUFactor3x3 as ak, LUSolve3x3 as al, linearSolve3x3 as am, multiply3x3_mat3 as an, multiplyMatrix as ao, transpose3x3 as ap, invert3x3 as aq, identity3x3 as ar, identity as as, quaternionToMatrix3x3 as at, roundNumber as au, matrix3x3ToQuaternion as av, multiplyQuaternion as aw, orthogonalize3x3 as ax, diagonalize3x3 as ay, singularValueDecomposition3x3 as az, roundVector as b, computeBoundsFromPoints as c, dot as d, clampVector as e, distance2BetweenPoints as f, solveLinearSystem as g, hsv2rgb as h, isNan as i, cross as j, add as k, normalize as l, multiplyAccumulate as m, norm as n, determinant2x2 as o, jacobiN as p, perpendiculars as q, radiansFromDegrees as r, subtract as s, vtkMath as t, uninitializeBounds as u, vtkMath$1 as v, jacobi as w, multiplyScalar as x, random as y, determinant3x3 as z };
+export { ceilLog2 as $, rowsToMat3 as A, degreesFromRadians as B, areEquals as C, clampValue as D, arrayRange as E, getMajorAxisIndex as F, isInf as G, rgb2hsv as H, rgb2lab as I, lab2rgb as J, floor as K, round as L, normalize2D as M, nearestPowerOfTwo as N, createUninitializedBounds as O, multiply3x3_vect3 as P, areBoundsInitialized as Q, isPowerOfTwo as R, angleBetweenVectors as S, signedAngleBetweenVectors as T, createArray as U, Pi as V, ceil as W, min as X, max as Y, arrayMin as Z, arrayMax as _, areMatricesEqual as a, factorial as a0, binomial as a1, beginCombination as a2, nextCombination as a3, randomSeed as a4, getSeed as a5, gaussian as a6, multiplyScalar2D as a7, multiplyAccumulate2D as a8, outer as a9, luFactorLinearSystem as aA, luSolveLinearSystem as aB, invertMatrix as aC, estimateMatrixCondition as aD, solveHomogeneousLeastSquares as aE, solveLeastSquares as aF, hex2float as aG, lab2xyz as aH, xyz2lab as aI, xyz2rgb as aJ, rgb2xyz as aK, clampAndNormalizeValue as aL, getScalarTypeFittingRange as aM, getAdjustedScalarRange as aN, extentIsWithinOtherExtent as aO, boundsIsWithinOtherBounds as aP, pointIsWithinBounds as aQ, solve3PointCircle as aR, inf as aS, negInf as aT, isFinite as aU, isNaN as aV, floatToHex2 as aW, floatRGB2HexCode as aX, float2CssRGBA as aY, projectVector as aa, dot2D as ab, projectVector2D as ac, gaussianAmplitude as ad, gaussianWeight as ae, outer2D as af, norm2D as ag, rowsToMat4 as ah, columnsToMat4 as ai, columnsToMat3 as aj, LUFactor3x3 as ak, LUSolve3x3 as al, linearSolve3x3 as am, multiply3x3_mat3 as an, multiplyMatrix as ao, transpose3x3 as ap, invert3x3 as aq, identity3x3 as ar, identity as as, quaternionToMatrix3x3 as at, roundNumber as au, matrix3x3ToQuaternion as av, multiplyQuaternion as aw, orthogonalize3x3 as ax, diagonalize3x3 as ay, singularValueDecomposition3x3 as az, roundVector as b, computeBoundsFromPoints as c, dot as d, clampVector as e, distance2BetweenPoints as f, vtkMath as g, hsv2rgb as h, isNan as i, solveLinearSystem as j, cross as k, add as l, normalize as m, norm as n, multiplyAccumulate as o, determinant2x2 as p, jacobiN as q, radiansFromDegrees as r, subtract as s, perpendiculars as t, uninitializeBounds as u, vtkMath$1 as v, jacobi as w, multiplyScalar as x, random as y, determinant3x3 as z };