@kitware/vtk.js 25.6.0 → 25.7.2

package/Common/Core/Math.js

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

package/Common/Core/Points.d.ts

@@ -51,7 +51,7 @@ export interface vtkPoints extends vtkDataArray {
 	setNumberOfPoints(nbPoints: number, dimension?: number): void;
 
 	/**
-	 * Set the (x,y,z) coordinate of a point based on its index.
+	 * Set the (x,y,z) coordinates of a point based on its index.
 	 * @param {Number} idx The index of point.
 	 * @param {Number} x The x coordinate.
 	 * @param {Number} y The y coordinate.
@@ -60,11 +60,12 @@ export interface vtkPoints extends vtkDataArray {
 	setPoint(idx: number, x: number, y: number, z: number): void;
 
 	/**
-	 * Insert point into object.
-	 * @param {Number} idx The index of point.
-	 * @param {Number[]} coord The point's coordinates.
+	 * Insert the (x,y,z) coordinates of a point at the next available slot.
+	 * @param {Number} x The x coordinate.
+	 * @param {Number} y The y coordinate.
+	 * @param {Number} z The z coordinate.
 	 */
-	setPoint(idx: number, coord: number[]): void;
+	insertNextPoint(x: number, y: number, z: number): void;
 }
 
 /**

package/Common/Core/Points.js

@@ -25,15 +25,19 @@ function vtkPoints(publicAPI, model) {
   };
 
   publicAPI.setPoint = function (idx) {
-    var offset = idx * model.numberOfComponents;
-
-    for (var i = 0; i < model.numberOfComponents; i++) {
-      model.values[offset + i] = i + 1 < 1 || arguments.length <= i + 1 ? undefined : arguments[i + 1];
+    for (var _len = arguments.length, xyz = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      xyz[_key - 1] = arguments[_key];
     }
+
+    publicAPI.setTuple(idx, xyz);
   };
 
   publicAPI.getPoint = publicAPI.getTuple;
 
+  publicAPI.insertNextPoint = function (x, y, z) {
+    return publicAPI.insertNextTuple([x, y, z]);
+  };
+
   publicAPI.getBounds = function () {
     if (publicAPI.getNumberOfComponents() === 3) {
       var _xRange = publicAPI.getRange(0);

package/Common/DataModel/AbstractPointLocator.d.ts

@@ -0,0 +1,54 @@
+import { vtkObject } from './../../interfaces';
+import { Bounds } from './../../types';
+import { ILocatorInitialValues } from './Locator';
+
+/**
+ *
+ */
+export interface IAbstractPointLocatorInitialValues
+	extends ILocatorInitialValues {
+	bounds?: Bounds;
+	numberOfBuckets: number;
+}
+
+export interface vtkAbstractPointLocator extends vtkObject {
+	/**
+	 * Set the bounds of this object.
+	 * @param {Bounds} input
+	 */
+	setBounds(input: Bounds): void;
+
+	/**
+	 * Get the bounds of this object.
+	 * @returns {Bounds}
+	 */
+	getBounds(): Bounds;
+}
+
+// ----------------------------------------------------------------------------
+// Static API
+// ----------------------------------------------------------------------------
+
+/**
+ * Method use to decorate a given object (publicAPI+model) with vtkAbstractPointLocator characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IAbstractPointLocatorInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+	publicAPI: object,
+	model: object,
+	initialValues?: IAbstractPointLocatorInitialValues
+): void;
+
+// ----------------------------------------------------------------------------
+
+/**
+ * vtkAbstractPointLocator
+ */
+export declare const vtkAbstractPointLocator: {
+	extend: typeof extend;
+};
+
+export default vtkAbstractPointLocator;

package/Common/DataModel/AbstractPointLocator.js

@@ -0,0 +1,40 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import macro from '../../macros.js';
+import vtkLocator from './Locator.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; }
+
+function vtkAbstractPointLocator(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkAbstractPointLocator');
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+function defaultValues(initialValues) {
+  return _objectSpread({
+    bounds: null,
+    numberOfBuckets: 0
+  }, initialValues);
+} // ----------------------------------------------------------------------------
+
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  vtkLocator.extend(publicAPI, model, defaultValues(initialValues)); // Make this a VTK object
+
+  macro.obj(publicAPI, model);
+  macro.get(publicAPI, model, ['numberOfBuckets']);
+  macro.setGetArray(publicAPI, model, ['bounds'], 6); // Object specific methods
+
+  vtkAbstractPointLocator(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var vtkAbstractPointLocator$1 = {
+  extend: extend
+};
+
+export { vtkAbstractPointLocator$1 as default, extend };

package/Common/DataModel/DataSetAttributes/FieldData.d.ts

@@ -34,9 +34,9 @@ export interface vtkFieldData extends vtkObject {
 
 	/**
 	 * 
-	 * @param other 
+	 * @param {vtkFieldData} other
 	 */
-	copyStructure(other: any): void;
+	copyStructure(other: vtkFieldData): void;
 
 	/**
 	 * Get the number of arrays.
@@ -50,9 +50,10 @@ export interface vtkFieldData extends vtkObject {
 
 	/**
 	 * Add a new array.
-	 * @param arr 
+	 * If an array with the same name already exists, it is replaced instead.
+	 * @param {vtkDataArray} arr 
 	 */
-	addArray(arr: any): number;
+	addArray(arr: vtkDataArray): number;
 
 	/**
 	 * Remove all the arrays.
@@ -60,30 +61,30 @@ export interface vtkFieldData extends vtkObject {
 	removeAllArrays(): void;
 
 	/**
-	 * 
+	 * Remove an array.
 	 * @param {String} arrayName The name of the array.
 	 */
 	removeArray(arrayName: string): void;
 
 	/**
-	 * 
+	 * Remove an array by its index.
 	 * @param {Number} arrayIdx The index of the array to remove. 
 	 */
 	removeArrayByIndex(arrayIdx: number): void;
 
 	/**
-	 * 
+	 * Get all arrays.
 	 */
 	getArrays(): any;
 
 	/**
 	 * 
-	 * @param arraySpec 
+	 * @param {any} arraySpec 
 	 */
 	getArray(arraySpec: any): void;
 
 	/**
-	 * 
+	 * Get an array by its name.
 	 * @param {String} arrayName The name of the array.
 	 */
 	getArrayByName(arrayName: string): Nullable<vtkDataArray>;
@@ -95,19 +96,19 @@ export interface vtkFieldData extends vtkObject {
 	getArrayWithIndex(arrayName: string): IArrayWithIndex;
 
 	/**
-	 * 
+	 * Get an array by its index.
 	 * @param {Number} idx The index of the array.
 	 */
 	getArrayByIndex(idx: number): Nullable<any>;
 
 	/**
-	 * 
+	 * Return true if there exists an array with the given arraName. False otherwise.
 	 * @param {String} arrayName The name of the array.
 	 */
 	hasArray(arrayName: string): boolean;
 
 	/**
-	 * 
+	 * Get the name of an array at the given index.
 	 * @param {Number} idx The index of the array.
 	 */
 	getArrayName(idx: number): string;
@@ -118,18 +119,28 @@ export interface vtkFieldData extends vtkObject {
 	getCopyFieldFlags(): object;
 
 	/**
-	 * 
+	 * Get the flag of the array that has the given name.
 	 * @param {String} arrayName The name of the array.
 	 */
 	getFlag(arrayName: string): boolean;
 
 	/**
-	 * 
-	 * @param other 
-	 * @param fromId 
-	 * @param toId 
+	 * Pass data from one fieldData to another at the given index.
+	 * @param {vtkFieldData} other
+	 * @param {Number} [fromId] (default: -1)
+	 * @param {Number} [toId] (default: -1)
+	 */
+	passData(other: vtkFieldData, fromId?: number, toId?: number): void;
+
+	/**
+	 * Works like passData, but interpolates the values between the two given fromIds.
+	 * @param {vtkFieldData} other
+	 * @param {Number} [fromId1] (default: -1)
+	 * @param {Number} [fromId2] (default: -1)
+	 * @param {Number} [toId] (default: -1)
+	 * @param {Number} [t] (default: 0.5)
 	 */
-	passData(other: any, fromId?: number, toId?: number): void;
+	interpolateData(other: vtkFieldData, fromId1?: number, fromId2?: number, toId?: number, t?: number): void;
 
 	/**
 	 * 
@@ -160,15 +171,15 @@ export interface vtkFieldData extends vtkObject {
 
 	/**
 	 * 
-	 * @param other 
+	 * @param {vtkFieldData} other 
 	 */
-	deepCopy(other: any): void;
+	deepCopy(other: vtkFieldData): void;
 
 	/**
 	 * 
-	 * @param other 
+	 * @param {vtkFieldData} other 
 	 */
-	copyFlags(other: any): void;
+	copyFlags(other: vtkFieldData): void;
 
 	/**
 	 * TODO: publicAPI.squeeze = () => model.arrays.forEach(entry => entry.data.squeeze());

package/Common/DataModel/DataSetAttributes/FieldData.js

@@ -2,6 +2,8 @@ import vtk from '../../../vtk.js';
 import macro from '../../../macros.js';
 import vtkDataArray from '../../Core/DataArray.js';
 
+var vtkErrorMacro = macro.vtkErrorMacro,
+    vtkWarningMacro = macro.vtkWarningMacro; // ----------------------------------------------------------------------------
 // vtkFieldData methods
 // ----------------------------------------------------------------------------
 
@@ -52,6 +54,19 @@ function vtkFieldData(publicAPI, model) {
   };
 
   publicAPI.addArray = function (arr) {
+    var name = arr.getName();
+
+    var _publicAPI$getArrayWi = publicAPI.getArrayWithIndex(name),
+        array = _publicAPI$getArrayWi.array,
+        index = _publicAPI$getArrayWi.index;
+
+    if (array != null) {
+      model.arrays[index] = {
+        data: arr
+      };
+      return index;
+    }
+
     model.arrays = [].concat(model.arrays, {
       data: arr
     });
@@ -134,37 +149,104 @@ function vtkFieldData(publicAPI, model) {
 
         if (!destArr) {
           if (fromId < 0 || fromId > arr.getNumberOfTuples()) {
+            // TBD: should this be a deep or a shallow copy?
             publicAPI.addArray(arr);
+            other.getAttributes(arr).forEach(function (attrType) {
+              publicAPI.setAttribute(arr, attrType);
+            });
           } else {
             var ncomps = arr.getNumberOfComponents();
             var newSize = arr.getNumberOfValues();
             var tId = toId > -1 ? toId : fromId;
 
-            if (newSize < tId * ncomps) {
+            if (newSize <= tId * ncomps) {
               newSize = (tId + 1) * ncomps;
             }
 
             destArr = vtkDataArray.newInstance({
               name: arr.getName(),
               dataType: arr.getDataType(),
-              numberOfComponents: arr.getNumberOfComponents(),
-              size: newSize
+              numberOfComponents: ncomps,
+              values: macro.newTypedArray(arr.getDataType(), newSize),
+              size: 0
             });
-            destArr.setTuple(tId, arr.getTuple(fromId));
+            destArr.insertTuple(tId, arr.getTuple(fromId));
             publicAPI.addArray(destArr);
+            other.getAttributes(arr).forEach(function (attrType) {
+              publicAPI.setAttribute(destArr, attrType);
+            });
           }
         } else if (arr.getNumberOfComponents() === destArr.getNumberOfComponents()) {
           if (fromId > -1 && fromId < arr.getNumberOfTuples()) {
             var _tId = toId > -1 ? toId : fromId;
 
-            destArr.setTuple(_tId, arr.getTuple(fromId));
+            destArr.insertTuple(_tId, arr.getTuple(fromId));
+          } else {
+            // if `fromId` is not provided, just copy all (or as much possible)
+            // from `arr` to `destArr`.
+            destArr.insertTuples(0, arr.getTuples());
+          }
+        } else {
+          vtkErrorMacro('Unhandled case in passData');
+        }
+      }
+    });
+  };
+
+  publicAPI.interpolateData = function (other) {
+    var fromId1 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -1;
+    var fromId2 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
+    var toId = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : -1;
+    var t = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0.5;
+    other.getArrays().forEach(function (arr) {
+      var copyFlag = publicAPI.getFlag(arr.getName());
+
+      if (copyFlag !== false && !(model.doCopyAllOff && copyFlag !== true) && arr) {
+        var destArr = publicAPI.getArrayByName(arr.getName());
+
+        if (!destArr) {
+          if (fromId1 < 0 || fromId2 < 0 || fromId1 > arr.getNumberOfTuples()) {
+            // TBD: should this be a deep or a shallow copy?
+            publicAPI.addArray(arr);
+            other.getAttributes(arr).forEach(function (attrType) {
+              publicAPI.setAttribute(arr, attrType);
+            });
           } else {
-            // if fromId and not provided, just copy all (or as much possible)
-            // of arr to destArr.
-            for (var i = 0; i < arr.getNumberOfTuples(); ++i) {
-              destArr.setTuple(i, arr.getTuple(i));
+            var ncomps = arr.getNumberOfComponents();
+            var newSize = arr.getNumberOfValues(); // TODO: Is this supposed to happen?
+
+            var tId = toId > -1 ? toId : fromId1;
+
+            if (newSize <= tId * ncomps) {
+              newSize = (tId + 1) * ncomps;
             }
+
+            destArr = vtkDataArray.newInstance({
+              name: arr.getName(),
+              dataType: arr.getDataType(),
+              numberOfComponents: ncomps,
+              values: macro.newTypedArray(arr.getDataType(), newSize),
+              size: 0
+            });
+            destArr.interpolateTuple(tId, arr, fromId1, arr, fromId2, t);
+            publicAPI.addArray(destArr);
+            other.getAttributes(arr).forEach(function (attrType) {
+              publicAPI.setAttribute(destArr, attrType);
+            });
+          }
+        } else if (arr.getNumberOfComponents() === destArr.getNumberOfComponents()) {
+          if (fromId1 > -1 && fromId1 < arr.getNumberOfTuples()) {
+            var _tId2 = toId > -1 ? toId : fromId1;
+
+            destArr.interpolateTuple(_tId2, arr, fromId1, arr, fromId2, t);
+            vtkWarningMacro('Unexpected case in interpolateData');
+          } else {
+            // if `fromId` is not provided, just copy all (or as much possible)
+            // from `arr` to `destArr`.
+            destArr.insertTuples(arr.getTuples());
           }
+        } else {
+          vtkErrorMacro('Unhandled case in interpolateData');
         }
       }
     });

package/Common/DataModel/DataSetAttributes.d.ts

@@ -112,6 +112,14 @@ export interface vtkDataSetAttributes extends vtkFieldData {
 	 */
 	getActiveAttribute(attType: string): any;
 
+	/**
+	 * Get a list of attribute names that the given array 
+	 * is for this vtkDataSetAttributes.
+	 * @param {vtkDataArray} arr
+	 * @returns {String[]}
+	 */
+	getAttributes(arr: vtkDataArray): string[];
+
 	/**
 	 *
 	 */
@@ -360,6 +368,41 @@ export interface vtkDataSetAttributes extends vtkFieldData {
 	 */
 	setPedigreeIds(pedigreeIds: vtkDataArray): boolean;
 
+	/**
+	 *
+	 */
+	copyScalarsOn(): void;
+
+	/**
+	 *
+	 */
+	copyVectorsOn(): void;
+
+	/**
+	 *
+	 */
+	copyNormalsOn(): void;
+
+	/**
+	 *
+	 */
+	copyTCoordsOn(): void;
+
+	/**
+	 *
+	 */
+	copyTensorsOn(): void;
+
+	/**
+	 *
+	 */
+	copyGlobalIdsOn(): void;
+
+	/**
+	 *
+	 */
+	copyPedigreeIdsOn(): void;
+
 	/**
 	 *
 	 */
@@ -394,6 +437,7 @@ export interface vtkDataSetAttributes extends vtkFieldData {
 	 *
 	 */
 	copyPedigreeIdsOff(): void;
+
 }
 
 /**

package/Common/DataModel/DataSetAttributes.js

@@ -73,6 +73,12 @@ function vtkDataSetAttributes(publicAPI, model) {
     return model["active".concat(attType)];
   };
 
+  publicAPI.getAttributes = function (arr) {
+    return attrTypes.filter(function (attrType) {
+      return publicAPI["get".concat(attrType)]() === arr;
+    });
+  };
+
   publicAPI.setActiveAttributeByName = function (arrayName, attType) {
     return publicAPI.setActiveAttributeByIndex(publicAPI.getArrayWithIndex(arrayName).index, attType);
   };
@@ -171,6 +177,11 @@ function vtkDataSetAttributes(publicAPI, model) {
       var attType = value.toUpperCase();
       model.copyAttributeFlags[AttributeCopyOperations.PASSDATA][AttributeTypes[attType]] = false;
     };
+
+    publicAPI["copy".concat(value, "On")] = function () {
+      var attType = value.toUpperCase();
+      model.copyAttributeFlags[AttributeCopyOperations.PASSDATA][AttributeTypes[attType]] = true;
+    };
   });
 
   publicAPI.initializeAttributeCopyFlags = function () {