@kitware/vtk.js 25.7.3 → 25.7.4

package/Common/Core/CellArray.d.ts

@@ -25,9 +25,9 @@ export interface vtkCellArray extends vtkDataArray {
 
 	/**
 	 * Set the data of this array.
-	 * @param {TypedArray} typedArray The Array value.
+	 * @param {Number[]|TypedArray} typedArray The Array value.
 	 */
-	setData(typedArray: TypedArray): void;
+	setData(typedArray: number[]|TypedArray): void;
 
 	/**
 	 * Returns the point indices at the given location as a subarray.

package/Common/Core/DataArray.d.ts

@@ -1,5 +1,5 @@
 import { vtkObject, vtkRange } from './../../interfaces';
-import { float, int, Nullable, TypedArray } from './../../types';
+import { float, int, Nullable, Range, TypedArray } from './../../types';
 
 
 /**
@@ -30,7 +30,7 @@ export interface IDataArrayInitialValues {
 	empty?: boolean;
 	name?: string;
 	numberOfComponents?: number;
-	rangeTuple?: [number, number];
+	rangeTuple?: Range;
 	size?: number;
 	values?: Array<number>|TypedArray;
 }
@@ -60,21 +60,21 @@ export interface vtkDataArray extends vtkObject {
 	/**
 	 *
 	 */
-	getData(): TypedArray;
+	getData(): number[]|TypedArray;
 
 	/**
 	 * Get the range of the given component.
 	 *
 	 * @param {Number} componentIndex (default: -1)
 	 */
-	getRange(componentIndex?: number): [number, number];
+	getRange(componentIndex?: number): Range;
 
 	/**
 	 *
 	 * @param {vtkRange} rangeValue
 	 * @param {Number} componentIndex
 	 */
-	setRange(rangeValue: vtkRange, componentIndex: number): [number, number];
+	setRange(rangeValue: vtkRange, componentIndex: number): Range;
 
 	/**
 	 * Set the given tuple at the given index.
@@ -93,17 +93,20 @@ export interface vtkDataArray extends vtkObject {
 	/**
 	 * Get the tuple at the given index.
 	 *
-	 * The recommended use is the following:
+	 * For performance reasons, it is advised to pass a 'tupleToFill':
 	 * `const x = [];`
-	 * `dataArray.getTuple(idx, x);`
+	 * `for (int i = 0; i < N; ++i) {
+	 * `  dataArray.getTuple(idx, x);`
+	 * `  ...`
 	 * instead of:
-	 * `const x = dataArray.getTuple(idx);`
-	 *
+	 * `for (int i = 0; i < N; ++i) {
+	 * `  const x = dataArray.getTuple(idx);`
+	 * `...`
 	 * @param {Number} idx
-	 * @param {Array<Number>} [tupleToFill] (default [])
-	 * @returns {Array<Number>}
+	 * @param {Number[]|TypedArray} [tupleToFill] (default [])
+	 * @returns {Number[]|TypedArray}
 	 */
-	getTuple(idx: number, tupleToFill?: Array<number>): Array<number>;
+	getTuple(idx: number, tupleToFill?: number[]|TypedArray): number[]|TypedArray;
 	
 	/**
 	 * Get the tuples between fromId (inclusive) and toId (exclusive).
@@ -223,10 +226,10 @@ export interface vtkDataArray extends vtkObject {
 	 * 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]
+	 * @param {Number[]|TypedArray} typedArray The Array value.
+	 * @param {Number} [numberOfComponents] 
 	 */
-	setData(typedArray: TypedArray, numberOfComponents?: number): void;
+	setData(typedArray: number[]|TypedArray, numberOfComponents?: number): void;
 
 	/**
 	 * Get the state of this array.

package/Common/Core/DataArray.js

@@ -7,8 +7,7 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 
 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 = []; // ----------------------------------------------------------------------------
+var DefaultDataType = Constants.DefaultDataType; // ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
 // Original source from https://www.npmjs.com/package/compute-range
@@ -132,9 +131,11 @@ function getDataType(typedArray) {
 function getMaxNorm(normArray) {
   var numComps = normArray.getNumberOfComponents();
   var maxNorm = 0.0;
+  var tuple = new Array(numComps);
 
   for (var i = 0; i < normArray.getNumberOfTuples(); ++i) {
-    var norm$1 = norm(normArray.getTuple(i), numComps);
+    normArray.getTuple(i, tuple);
+    var norm$1 = norm(tuple, numComps);
 
     if (norm$1 > maxNorm) {
       maxNorm = norm$1;
@@ -335,13 +336,8 @@ function vtkDataArray(publicAPI, model) {
   };
 
   publicAPI.getTuple = function (idx) {
-    var tupleToFill = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : TUPLE_HOLDER;
+    var tupleToFill = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
     var numberOfComponents = model.numberOfComponents || 1;
-
-    if (tupleToFill.length !== numberOfComponents) {
-      tupleToFill.length = numberOfComponents;
-    }
-
     var offset = idx * numberOfComponents; // Check most common component sizes first
     // to avoid doing a for loop if possible
 
@@ -363,7 +359,7 @@ function vtkDataArray(publicAPI, model) {
         break;
 
       default:
-        for (var i = 0; i < numberOfComponents; i++) {
+        for (var i = numberOfComponents - 1; i >= 0; --i) {
           tupleToFill[i] = model.values[offset + i];
         }
 
@@ -482,12 +478,10 @@ function vtkDataArray(publicAPI, model) {
       vtkErrorMacro('numberOfComponents must match');
     }
 
-    var tuple1 = [];
-    var tuple2 = [];
+    var tuple1 = source1.getTuple(source1Idx);
+    var tuple2 = source2.getTuple(source2Idx);
     var out = [];
-    out.length = numberOfComponents;
-    source1.getTuple(source1Idx, tuple1);
-    source2.getTuple(source2Idx, tuple2); // Check most common component sizes first
+    out.length = numberOfComponents; // Check most common component sizes first
     // to avoid doing a for loop if possible
 
     switch (numberOfComponents) {

package/Common/Core/MatrixBuilder.d.ts

@@ -78,11 +78,11 @@ declare interface Transform {
 	 * iterations (sets of 3) to loop through. Assumes the `typedArray` is an
 	 * array of multiples of 3, unless specifically handling with offset and
 	 * iterations. Returns the instance for chaining.
-	 * @param {TypedArray} typedArray 
+	 * @param {Number[]|TypedArray} typedArray The Array value.
 	 * @param {Number} [offset] 
 	 * @param {Number} [nbIterations] 
 	 */
-	apply(typedArray: TypedArray, offset?: number, nbIterations?: number): Transform
+	apply(typedArray: number[]|TypedArray, offset?: number, nbIterations?: number): Transform
 
 	/**
 	 * Returns the internal `mat4` matrix.

package/Common/Core/Points.d.ts

@@ -1,5 +1,5 @@
 import vtkDataArray from './DataArray';
-import { Bounds } from './../../types';
+import { Bounds, TypedArray } from './../../types';
 
 /**
  *
@@ -26,10 +26,10 @@ export interface vtkPoints extends vtkDataArray {
 	/**
 	 * Get the coordinate of a point.
 	 * @param {Number} idx The index of point.
-	 * @param {Number[]} [tupleToFill] 
-	 * @default []
+	 * @param {Number[]|TypedArray} [tupleToFill] (default [])
+	 * @returns {Number[]|TypedArray}
 	 */
-	getPoint(idx: number, tupleToFill?: number[]): number[];
+	getPoint(idx: number, tupleToFill?: number[]|TypedArray): number[]|TypedArray;
 
 	/**
 	 * Get the number of points for this object can hold.

package/Common/Core/StringArray.js

@@ -1,7 +1,6 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
 
-var TUPLE_HOLDER = []; // ----------------------------------------------------------------------------
 // vtkStringArray methods
 // ----------------------------------------------------------------------------
 
@@ -34,7 +33,7 @@ function vtkStringArray(publicAPI, model) {
   };
 
   publicAPI.getTuple = function (idx) {
-    var tupleToFill = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : TUPLE_HOLDER;
+    var tupleToFill = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
     var numberOfComponents = model.numberOfComponents || 1;
 
     if (tupleToFill.length) {

package/Common/Core/VariantArray.js

@@ -1,7 +1,6 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
 
-var TUPLE_HOLDER = []; // ----------------------------------------------------------------------------
 // vtkVariantArray methods
 // ----------------------------------------------------------------------------
 
@@ -34,7 +33,7 @@ function vtkVariantArray(publicAPI, model) {
   };
 
   publicAPI.getTuple = function (idx) {
-    var tupleToFill = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : TUPLE_HOLDER;
+    var tupleToFill = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
     var numberOfComponents = model.numberOfComponents || 1;
 
     if (tupleToFill.length) {

package/Common/DataModel/BoundingBox.js

@@ -56,6 +56,24 @@ function _addPoint(bounds) {
   return bounds;
 }
 
+function _addPoints(bounds, points) {
+  if (points.length === 0) {
+    return bounds;
+  }
+
+  if (Array.isArray(points[0])) {
+    for (var i = 0; i < points.length; ++i) {
+      _addPoint(bounds, points[i]);
+    }
+  } else {
+    for (var _i = 0; _i < points.length; _i += 3) {
+      _addPoint(bounds, points.slice(_i, _i + 3));
+    }
+  }
+
+  return bounds;
+}
+
 function _addBounds(bounds, xMin, xMax, yMin, yMax, zMin, zMax) {
   var _bounds2 = _slicedToArray(bounds, 6),
       _xMin = _bounds2[0],
@@ -337,18 +355,18 @@ function _intersectBox(bounds, origin, dir, coord, tolerance) {
   } // Calculate parametric distance to plane
 
 
-  for (var _i = 0; _i < 3; _i++) {
-    if (quadrant[_i] !== MIDDLE && dir[_i] !== 0.0) {
-      maxT[_i] = (candidatePlane[_i] - origin[_i]) / dir[_i];
+  for (var _i2 = 0; _i2 < 3; _i2++) {
+    if (quadrant[_i2] !== MIDDLE && dir[_i2] !== 0.0) {
+      maxT[_i2] = (candidatePlane[_i2] - origin[_i2]) / dir[_i2];
     } else {
-      maxT[_i] = -1.0;
+      maxT[_i2] = -1.0;
     }
   } // Find the largest parametric value of intersection
 
 
-  for (var _i2 = 0; _i2 < 3; _i2++) {
-    if (maxT[whichPlane] < maxT[_i2]) {
-      whichPlane = _i2;
+  for (var _i3 = 0; _i3 < 3; _i3++) {
+    if (maxT[whichPlane] < maxT[_i3]) {
+      whichPlane = _i3;
     }
   } // Check for valie intersection along line
 
@@ -359,15 +377,15 @@ function _intersectBox(bounds, origin, dir, coord, tolerance) {
 
   tolerance[0] = maxT[whichPlane]; // Intersection point along line is okay. Check bbox.
 
-  for (var _i3 = 0; _i3 < 3; _i3++) {
-    if (whichPlane !== _i3) {
-      coord[_i3] = origin[_i3] + maxT[whichPlane] * dir[_i3];
+  for (var _i4 = 0; _i4 < 3; _i4++) {
+    if (whichPlane !== _i4) {
+      coord[_i4] = origin[_i4] + maxT[whichPlane] * dir[_i4];
 
-      if (coord[_i3] < bounds[2 * _i3] || coord[_i3] > bounds[2 * _i3 + 1]) {
+      if (coord[_i4] < bounds[2 * _i4] || coord[_i4] > bounds[2 * _i4 + 1]) {
         return 0;
       }
     } else {
-      coord[_i3] = candidatePlane[_i3];
+      coord[_i4] = candidatePlane[_i4];
     }
   }
 
@@ -623,6 +641,11 @@ var BoundingBox = /*#__PURE__*/function () {
 
       return _addPoint(this.bounds, xyz);
     }
+  }, {
+    key: "addPoints",
+    value: function addPoints(points) {
+      return _addPoints(this.bounds, points);
+    }
   }, {
     key: "addBounds",
     value: function addBounds(xMin, xMax, yMin, yMax, zMin, zMax) {
@@ -772,6 +795,7 @@ var STATIC = {
   setBounds: _setBounds,
   reset: _reset,
   addPoint: _addPoint,
+  addPoints: _addPoints,
   addBounds: _addBounds,
   setMinPoint: _setMinPoint,
   setMaxPoint: _setMaxPoint,
@@ -805,4 +829,4 @@ var vtkBoundingBox = _objectSpread({
   newInstance: newInstance
 }, STATIC);
 
-export { STATIC, _addBounds as addBounds, _addPoint as addPoint, _computeCornerPoints as computeCornerPoints, _computeLocalBounds as computeLocalBounds, _computeScale as computeScale3, contains, _containsPoint as containsPoint, _cutWithPlane as cutWithPlane, vtkBoundingBox as default, _equals as equals, _getCenter as getCenter, _getCorners as getCorners, _getDiagonalLength as getDiagonalLength, _getLength as getLength, _getLengths as getLengths, _getMaxLength as getMaxLength, _getMaxPoint as getMaxPoint, _getMinPoint as getMinPoint, _getXRange as getXRange, _getYRange as getYRange, _getZRange as getZRange, _inflate as inflate, _intersect as intersect, _intersectBox as intersectBox, _intersectPlane as intersectPlane, _intersects as intersects, _isValid as isValid, _reset as reset, _scale as scale, scaleAboutCenter, _setBounds as setBounds, _setMaxPoint as setMaxPoint, _setMinPoint as setMinPoint };
+export { STATIC, _addBounds as addBounds, _addPoint as addPoint, _addPoints as addPoints, _computeCornerPoints as computeCornerPoints, _computeLocalBounds as computeLocalBounds, _computeScale as computeScale3, contains, _containsPoint as containsPoint, _cutWithPlane as cutWithPlane, vtkBoundingBox as default, _equals as equals, _getCenter as getCenter, _getCorners as getCorners, _getDiagonalLength as getDiagonalLength, _getLength as getLength, _getLengths as getLengths, _getMaxLength as getMaxLength, _getMaxPoint as getMaxPoint, _getMinPoint as getMinPoint, _getXRange as getXRange, _getYRange as getYRange, _getZRange as getZRange, _inflate as inflate, _intersect as intersect, _intersectBox as intersectBox, _intersectPlane as intersectPlane, _intersects as intersects, _isValid as isValid, _reset as reset, _scale as scale, scaleAboutCenter, _setBounds as setBounds, _setMaxPoint as setMaxPoint, _setMinPoint as setMinPoint };

package/Common/DataModel/ImageData.js

@@ -1,11 +1,12 @@
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
 import { c as computeBoundsFromPoints, b as roundVector, e as clampVector } from '../Core/Math/index.js';
 import vtkBoundingBox from './BoundingBox.js';
 import vtkDataSet from './DataSet.js';
 import vtkStructuredData from './StructuredData.js';
 import { StructuredType } from './StructuredData/Constants.js';
-import { mat3, vec3, mat4 } from 'gl-matrix';
+import { mat3, mat4, vec3 } from 'gl-matrix';
 
 var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
 // vtkImageData methods
@@ -31,15 +32,8 @@ function vtkImageData(publicAPI, model) {
       return false;
     }
 
-    var changeDetected = false;
-    model.extent.forEach(function (item, index) {
-      if (item !== extentArray[index]) {
-        if (changeDetected) {
-          return;
-        }
-
-        changeDetected = true;
-      }
+    var changeDetected = model.extent.some(function (item, index) {
+      return item !== extentArray[index];
     });
 
     if (changeDetected) {
@@ -196,49 +190,22 @@ function vtkImageData(publicAPI, model) {
 
   publicAPI.extentToBounds = function (ex) {
     // prettier-ignore
-    var corners = [ex[0], ex[2], ex[4], ex[1], ex[2], ex[4], ex[0], ex[3], ex[4], ex[1], ex[3], ex[4], ex[0], ex[2], ex[5], ex[1], ex[2], ex[5], ex[0], ex[3], ex[5], ex[1], ex[3], ex[5]];
-    var idx = new Float64Array([corners[0], corners[1], corners[2]]);
-    var vout = new Float64Array(3);
-    publicAPI.indexToWorld(idx, vout);
-    var bounds = [vout[0], vout[0], vout[1], vout[1], vout[2], vout[2]];
-
-    for (var i = 3; i < 24; i += 3) {
-      vec3.set(idx, corners[i], corners[i + 1], corners[i + 2]);
-      publicAPI.indexToWorld(idx, vout);
-
-      if (vout[0] < bounds[0]) {
-        bounds[0] = vout[0];
-      }
+    var corners = [[ex[0], ex[2], ex[4]], [ex[1], ex[2], ex[4]], [ex[0], ex[3], ex[4]], [ex[1], ex[3], ex[4]], [ex[0], ex[2], ex[5]], [ex[1], ex[2], ex[5]], [ex[0], ex[3], ex[5]], [ex[1], ex[3], ex[5]]];
 
-      if (vout[1] < bounds[2]) {
-        bounds[2] = vout[1];
-      }
+    var bounds = _toConsumableArray(vtkBoundingBox.INIT_BOUNDS);
 
-      if (vout[2] < bounds[4]) {
-        bounds[4] = vout[2];
-      }
+    var vout = [];
 
-      if (vout[0] > bounds[1]) {
-        bounds[1] = vout[0];
-      }
-
-      if (vout[1] > bounds[3]) {
-        bounds[3] = vout[1];
-      }
-
-      if (vout[2] > bounds[5]) {
-        bounds[5] = vout[2];
-      }
+    for (var i = 0; i < 8; ++i) {
+      publicAPI.indexToWorld(corners[i], vout);
+      vtkBoundingBox.addPoint.apply(vtkBoundingBox, [bounds].concat(vout));
     }
 
     return bounds;
   };
 
   publicAPI.getSpatialExtent = function () {
-    var boundingBox = vtkBoundingBox.newInstance();
-    boundingBox.setBounds(model.extent);
-    boundingBox.inflate(0.5);
-    return boundingBox.getBounds();
+    return vtkBoundingBox.inflate(_toConsumableArray(model.extent), 0.5);
   }; // Internal, shouldn't need to call this manually.
 
 
@@ -351,14 +318,7 @@ function vtkImageData(publicAPI, model) {
   publicAPI.computeTransforms();
 
   publicAPI.getCenter = function () {
-    var bounds = publicAPI.getBounds();
-    var center = [];
-
-    for (var i = 0; i < 3; i++) {
-      center[i] = (bounds[2 * i + 1] + bounds[2 * i]) / 2;
-    }
-
-    return center;
+    return vtkBoundingBox.getCenter(publicAPI.getBounds());
   };
 
   publicAPI.computeHistogram = function (worldBounds) {

package/Filters/General/ClipClosedSurface.js

@@ -91,10 +91,8 @@ function vtkClipClosedSurface(publicAPI, model) {
     } // Get the edge and interpolate the new point
 
 
-    var p0 = [];
-    var p1 = [];
-    points.getPoint(i0, p0);
-    points.getPoint(i1, p1);
+    var p0 = points.getPoint(i0);
+    var p1 = points.getPoint(i1);
     var f = v0 / (v0 - v1);
     var s = 1.0 - f;
     var t = 1.0 - s;

package/Filters/General/ImageStreamline.js

@@ -114,9 +114,10 @@ function vtkImageStreamline(publicAPI, model) {
     velAtArg[0] = 0.0;
     velAtArg[1] = 0.0;
     velAtArg[2] = 0.0;
+    var vel = new Array(3);
 
     for (var i = 0; i < 8; i++) {
-      var vel = velArray.getTuple(voxelIndices[i]);
+      velArray.getTuple(voxelIndices[i], vel);
 
       for (var j = 0; j < 3; j++) {
         velAtArg[j] += weights[i] * vel[j];
@@ -212,9 +213,11 @@ function vtkImageStreamline(publicAPI, model) {
     var offset = 0;
     var datas = [];
     var vectors = input.getPointData().getVectors();
+    var point = [];
 
     for (var i = 0; i < nSeeds; i++) {
-      var retVal = publicAPI.streamIntegrate(vectors, input, seedPts.getTuple(i), offset);
+      seedPts.getTuple(i, point);
+      var retVal = publicAPI.streamIntegrate(vectors, input, point, offset);
       offset += retVal[0].length / 3;
       datas.push(retVal);
     }

package/Filters/General/PaintFilter.js

@@ -89,10 +89,11 @@ function vtkPaintFilter(publicAPI, model) {
 
     if (model.voxelFunc) {
       var bgScalars = model.backgroundImage.getPointData().getScalars();
+      var voxel = [];
 
       for (var _i = 0; _i < maskLabelMap.length; _i++) {
         if (maskLabelMap[_i]) {
-          var voxel = bgScalars.getTuple(_i); // might not fill up snapshot
+          bgScalars.getTuple(_i, voxel); // might not fill up snapshot
 
           if (model.voxelFunc(voxel, _i, label)) {
             snapshot[diffIdx++] = [_i, data[_i]];

package/Filters/General/TubeFilter.js

@@ -236,6 +236,7 @@ function vtkTubeFilter(publicAPI, model) {
     var normal = [0.0, 0.0, 0.0];
     var sFactor = 1.0;
     var ptId = offset;
+    var vector = [];
 
     for (var j = 0; j < npts; ++j) {
       // First point
@@ -307,7 +308,7 @@ function vtkTubeFilter(publicAPI, model) {
       if (inScalars && model.varyRadius === VaryRadius.VARY_RADIUS_BY_SCALAR) {
         sFactor = 1.0 + (model.radiusFactor - 1.0) * (inScalars.getComponent(pts[j], 0) - range[0]) / (range[1] - range[0]);
       } else if (inVectors && model.varyRadius === VaryRadius.VARY_RADIUS_BY_VECTOR) {
-        sFactor = Math.sqrt(maxSpeed / norm(inVectors.getTuple(pts[j])));
+        sFactor = Math.sqrt(maxSpeed / norm(inVectors.getTuple(pts[j], vector)));
 
         if (sFactor > model.radiusFactor) {
           sFactor = model.radiusFactor;
@@ -667,16 +668,10 @@ function vtkTubeFilter(publicAPI, model) {
     var numStrips = 0;
     var inLinesData = inLines.getData();
     var npts = inLinesData[0];
-    var sidesShareVerticesMultiplier = model.sidesShareVertices ? 1 : 2;
 
     for (var i = 0; i < inLinesData.length; i += npts + 1) {
-      numNewPts += sidesShareVerticesMultiplier * npts * model.numberOfSides;
-
-      if (model.capping) {
-        numNewPts += 2 * model.numberOfSides;
-      }
-
       npts = inLinesData[i];
+      numNewPts = computeOffset(numNewPts, npts);
       numStrips += (2 * npts + 1) * Math.ceil(model.numberOfSides / model.onRatio);
 
       if (model.capping) {

package/Filters/General/WindowedSincPolyDataFilter.js

@@ -1,4 +1,3 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
@@ -177,13 +176,13 @@ function vtkWindowedSincPolyDataFilter(publicAPI, model) {
             if (model.featureEdgeSmoothing) {
               // TODO: support polygons
               // vtkPolygon::ComputeNormal(inPts,npts,pts,normal);
-              vtkTriangle.computeNormal(_toConsumableArray(inPts.getPoint(_pts2[0])), _toConsumableArray(inPts.getPoint(_pts2[1])), _toConsumableArray(inPts.getPoint(_pts2[2])), normal);
+              vtkTriangle.computeNormal(inPts.getPoint(_pts2[0]), inPts.getPoint(_pts2[1]), inPts.getPoint(_pts2[2]), normal);
 
               var _mesh$getCellPoints = mesh.getCellPoints(nei),
                   cellPointIds = _mesh$getCellPoints.cellPointIds; // vtkPolygon::ComputeNormal(inPts,numNeiPts,neiPts,neiNormal);
 
 
-              vtkTriangle.computeNormal(_toConsumableArray(inPts.getPoint(cellPointIds[0])), _toConsumableArray(inPts.getPoint(cellPointIds[1])), _toConsumableArray(inPts.getPoint(cellPointIds[2])), neiNormal);
+              vtkTriangle.computeNormal(inPts.getPoint(cellPointIds[0]), inPts.getPoint(cellPointIds[1]), inPts.getPoint(cellPointIds[2]), neiNormal);
 
               if (vtkMath.dot(normal, neiNormal) <= cosFeatureAngle) {
                 edge = VertexType.VTK_FEATURE_EDGE_VERTEX;
@@ -230,12 +229,11 @@ function vtkWindowedSincPolyDataFilter(publicAPI, model) {
           verts[_i4].type = VertexType.VTK_FIXED_VERTEX;
         } // check angle between edges
         else {
-          var _x = [0, 0, 0];
-          inPts.getPoint(verts[_i4].edges[0], _x);
-          var _x2 = [0, 0, 0];
-          inPts.getPoint(_i4, _x2);
-          var x3 = [0, 0, 0];
-          inPts.getPoint(verts[_i4].edges[1], x3);
+          var _x = inPts.getPoint(verts[_i4].edges[0]);
+
+          var _x2 = inPts.getPoint(_i4);
+
+          var x3 = inPts.getPoint(verts[_i4].edges[1]);
           var l1 = [0, 0, 0];
           var l2 = [0, 0, 0];
 

package/Rendering/OpenGL/PolyDataMapper2D.js

@@ -209,9 +209,11 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
         var p = vtkPoints.newInstance();
         var numPts = points.getNumberOfPoints();
         p.setNumberOfPoints(numPts);
+        var point = [];
 
         for (var i = 0; i < numPts; ++i) {
-          transformCoordinate.setValue(points.getPoint(i));
+          points.getPoint(i, point);
+          transformCoordinate.setValue(point);
           var v = transformCoordinate.getComputedDoubleViewportValue(ren);
           p.setPoint(i, v[0], v[1], 0.0);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "25.7.3",
+  "version": "25.7.4",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",

package/types.d.ts

@@ -22,7 +22,6 @@ declare type double = number;
 declare type int = number;
 
 declare type TypedArray =
-  | number[]
   | Uint32Array
   | Uint16Array
   | Uint8Array