@kitware/vtk.js 25.10.1 → 25.11.1

package/Imaging/Core/ImageReslice.js

@@ -1,7 +1,9 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { mat4, vec4 } from 'gl-matrix';
-import macro from '../../macros.js';
+import macro, { vtkWarningMacro } from '../../macros.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
+import { g as vtkMath } from '../../Common/Core/Math/index.js';
+import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 import { VtkDataTypes } from '../../Common/Core/DataArray/Constants.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkImageData from '../../Common/DataModel/ImageData.js';
@@ -15,14 +17,16 @@ 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 SlabMode = Constants.SlabMode;
-var capitalize = macro.capitalize,
-    vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
+var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
 // vtkImageReslice methods
 // ----------------------------------------------------------------------------
 
 function vtkImageReslice(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkImageReslice');
+
+  var superClass = _objectSpread({}, publicAPI);
+
   var indexMatrix = null;
   var optimizedTransform = null;
 
@@ -97,6 +101,16 @@ function vtkImageReslice(publicAPI, model) {
     getImageResliceSlabTrap(tmpPtr, inComponents, sampleCount, f);
   }
 
+  publicAPI.getMTime = function () {
+    var mTime = superClass.getMTime();
+
+    if (model.resliceTransform) {
+      mTime = Math.max(mTime, model.resliceTransform.getMTime());
+    }
+
+    return mTime;
+  };
+
   publicAPI.setResliceAxes = function (resliceAxes) {
     if (!model.resliceAxes) {
       model.resliceAxes = mat4.identity(new Float64Array(16));
@@ -131,12 +145,10 @@ function vtkImageReslice(publicAPI, model) {
     var outSpacing = [1, 1, 1];
     var outWholeExt = [0, 0, 0, 0, 0, 0];
     var outDims = [0, 0, 0];
-    var matrix = null;
+    var matrix = mat4.identity(new Float64Array(16));
 
     if (model.resliceAxes) {
-      matrix = model.resliceAxes;
-    } else {
-      matrix = mat4.identity(new Float64Array(16));
+      mat4.multiply(matrix, matrix, model.resliceAxes);
     }
 
     var imatrix = new Float64Array(16);
@@ -236,6 +248,11 @@ function vtkImageReslice(publicAPI, model) {
     output.setDimensions(outDims);
     output.setOrigin(outOrigin);
     output.setSpacing(outSpacing);
+
+    if (model.outputDirection) {
+      output.setDirection(model.outputDirection);
+    }
+
     output.getPointData().setScalars(outScalars);
     publicAPI.getIndexMatrix(input, output);
     var interpolationMode = model.interpolationMode;
@@ -340,7 +357,7 @@ function vtkImageReslice(publicAPI, model) {
     var floatPtr = null;
 
     if (!optimizeNearest) {
-      floatPtr = new Float64Array(inComponents * (outExt[1] - outExt[0]));
+      floatPtr = new Float64Array(inComponents * (outExt[1] - outExt[0] + nsamples));
     }
 
     var background = macro.newTypedArray(inputScalarType, model.backgroundColor); // set color for area outside of input volume extent
@@ -577,6 +594,20 @@ function vtkImageReslice(publicAPI, model) {
       }
     }
   };
+  /**
+   * The transform matrix supplied by the user converts output coordinates
+   * to input coordinates.
+   * To speed up the pixel lookup, the following function provides a
+   * matrix which converts output pixel indices to input pixel indices.
+   * This will also concatenate the ResliceAxes and the ResliceTransform
+   * if possible (if the ResliceTransform is a 4x4 matrix transform).
+   * If it does, this->OptimizedTransform will be set to nullptr, otherwise
+   * this->OptimizedTransform will be equal to this->ResliceTransform.
+   * @param {vtkPolyData} input
+   * @param {vtkPolyData} output
+   * @returns
+   */
+
 
   publicAPI.getIndexMatrix = function (input, output) {
     // first verify that we have to update the matrix
@@ -586,6 +617,7 @@ function vtkImageReslice(publicAPI, model) {
 
     var inOrigin = input.getOrigin();
     var inSpacing = input.getSpacing();
+    var inDirection = input.getDirection();
     var outOrigin = output.getOrigin();
     var outSpacing = output.getSpacing();
     var transform = mat4.identity(new Float64Array(16));
@@ -596,14 +628,29 @@ function vtkImageReslice(publicAPI, model) {
       mat4.copy(transform, model.resliceAxes);
     }
 
-    if (model.resliceTransform) ; // check to see if we have an identity matrix
+    if (model.resliceTransform) {
+      if (model.resliceTransform.isA('vtkHomogeneousTransform')) {
+        // transform->PostMultiply();
+        // transform->Concatenate(
+        // mat4.multiply(transform, transform, model.resliceTransform.getMatrix());
+        mat4.multiply(transform, model.resliceTransform.getMatrix(), transform);
+      } else {
+        // TODO
+        vtkWarningMacro('Non homogeneous transform have not yet been ported');
+      }
+    }
+
+    if (!vtkMath.isIdentity3x3(inDirection)) {
+      var imageTransform = vtkMatrixBuilder.buildFromRadian().translate(inOrigin[0], inOrigin[1], inOrigin[2]).multiply3x3(inDirection).translate(-inOrigin[0], -inOrigin[1], -inOrigin[2]);
+      mat4.multiply(transform, imageTransform.getMatrix(), transform);
+    } // check to see if we have an identity matrix
 
 
-    var isIdentity = publicAPI.isIdentityMatrix(transform); // the outMatrix takes OutputData indices to OutputData coordinates,
+    var isIdentity = vtkMath.isIdentity(transform); // the outMatrix takes OutputData indices to OutputData coordinates,
     // the inMatrix takes InputData coordinates to InputData indices
 
     for (var i = 0; i < 3; i++) {
-      if ((inSpacing[i] !== outSpacing[i] || inOrigin[i] !== outOrigin[i]) || optimizedTransform !== null ) {
+      if ((inSpacing[i] !== outSpacing[i] || inOrigin[i] !== outOrigin[i]) || optimizedTransform != null ) {
         isIdentity = false;
       }
 
@@ -633,6 +680,7 @@ function vtkImageReslice(publicAPI, model) {
   publicAPI.getAutoCroppedOutputBounds = function (input) {
     var inOrigin = input.getOrigin();
     var inSpacing = input.getSpacing();
+    var inDirection = input.getDirection();
     var dims = input.getDimensions();
     var inWholeExt = [0, dims[0] - 1, 0, dims[1] - 1, 0, dims[2] - 1];
     var matrix = new Float64Array(16);
@@ -643,6 +691,18 @@ function vtkImageReslice(publicAPI, model) {
       mat4.identity(matrix);
     }
 
+    var transform = null;
+
+    if (model.resliceTransform) {
+      transform = model.resliceTransform.getInverse();
+    }
+
+    var imageTransform = null;
+
+    if (!vtkMath.isIdentity3x3(inDirection)) {
+      imageTransform = vtkMatrixBuilder.buildFromRadian().translate(inOrigin[0], inOrigin[1], inOrigin[2]).multiply3x3(inDirection).translate(-inOrigin[0], -inOrigin[1], -inOrigin[2]).invert().getMatrix();
+    }
+
     var bounds = [Number.MAX_VALUE, -Number.MAX_VALUE, Number.MAX_VALUE, -Number.MAX_VALUE, Number.MAX_VALUE, -Number.MAX_VALUE];
     var point = [0, 0, 0, 0];
 
@@ -652,7 +712,13 @@ function vtkImageReslice(publicAPI, model) {
       point[2] = inOrigin[2] + inWholeExt[4 + Math.floor(i / 4) % 2] * inSpacing[2];
       point[3] = 1.0;
 
-      if (model.resliceTransform) ;
+      if (imageTransform) {
+        vec4.transformMat4(point, point, imageTransform);
+      }
+
+      if (model.resliceTransform) {
+        transform.transformPoint(point, point);
+      }
 
       vec4.transformMat4(point, point, matrix);
       var f = 1.0 / point[3];
@@ -931,27 +997,6 @@ function vtkImageReslice(publicAPI, model) {
 
     return 1;
   };
-}
-
-function setNullArray(publicAPI, model, fieldNames) {
-  fieldNames.forEach(function (field) {
-    var setterName = "set".concat(capitalize(field));
-    var superSet = publicAPI[setterName];
-
-    publicAPI[setterName] = function () {
-      if (arguments.length === 1 && (arguments.length <= 0 ? undefined : arguments[0]) == null || model[field] == null) {
-        if ((arguments.length <= 0 ? undefined : arguments[0]) !== model[field]) {
-          model[field] = arguments.length <= 0 ? undefined : arguments[0];
-          publicAPI.modified();
-          return true;
-        }
-
-        return null;
-      }
-
-      return superSet.apply(void 0, arguments);
-    };
-  });
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
@@ -965,6 +1010,8 @@ var DEFAULT_VALUES = {
   // automatically computed if null
   outputOrigin: null,
   // automatically computed if null
+  outputDirection: null,
+  // identity if null
   outputExtent: null,
   // automatically computed if null
   outputScalarType: null,
@@ -987,7 +1034,7 @@ var DEFAULT_VALUES = {
   scalarScale: 1,
   backgroundColor: [0, 0, 0, 0],
   resliceAxes: null,
-  resliceTransform: null,
+  // resliceTransform: null,
   interpolator: vtkImageInterpolator.newInstance(),
   usePermuteExecute: false // no supported yet
 
@@ -1000,10 +1047,11 @@ function extend(publicAPI, model) {
   macro.obj(publicAPI, model); // Also make it an algorithm with one input and one output
 
   macro.algo(publicAPI, model, 1, 1);
-  macro.setGet(publicAPI, model, ['outputDimensionality', 'outputScalarType', 'scalarShift', 'scalarScale', 'transformInputSampling', 'autoCropOutput', 'wrap', 'mirror', 'border', 'backgroundColor', 'interpolationMode', 'slabMode', 'slabTrapezoidIntegration', 'slabNumberOfSlices', 'slabSliceSpacingFraction']);
+  macro.setGet(publicAPI, model, ['outputDimensionality', 'outputScalarType', 'scalarShift', 'scalarScale', 'transformInputSampling', 'autoCropOutput', 'wrap', 'mirror', 'border', 'interpolationMode', 'resliceTransform', 'slabMode', 'slabTrapezoidIntegration', 'slabNumberOfSlices', 'slabSliceSpacingFraction']);
   macro.setGetArray(publicAPI, model, ['outputOrigin', 'outputSpacing'], 3);
   macro.setGetArray(publicAPI, model, ['outputExtent'], 6);
-  setNullArray(publicAPI, model, ['outputOrigin', 'outputSpacing', 'outputExtent']);
+  macro.setGetArray(publicAPI, model, ['outputDirection'], 9);
+  macro.setGetArray(publicAPI, model, ['backgroundColor'], 4);
   macro.get(publicAPI, model, ['resliceAxes']); // Object specific methods
 
   macro.algo(publicAPI, model, 1, 1);

package/Rendering/OpenGL/Texture.js

@@ -298,7 +298,7 @@ function vtkOpenGLTexture(publicAPI, model) {
 
 
   publicAPI.getInternalFormat = function (vtktype, numComps) {
-    if (!model.internalFormat) {
+    if (!model._forceInternalFormat) {
       model.internalFormat = publicAPI.getDefaultInternalFormat(vtktype, numComps);
     }
 
@@ -332,6 +332,8 @@ function vtkOpenGLTexture(publicAPI, model) {
 
 
   publicAPI.setInternalFormat = function (iFormat) {
+    model._forceInternalFormat = true;
+
     if (iFormat !== model.internalFormat) {
       model.internalFormat = iFormat;
       publicAPI.modified();
@@ -388,6 +390,7 @@ function vtkOpenGLTexture(publicAPI, model) {
   publicAPI.resetFormatAndType = function () {
     model.format = 0;
     model.internalFormat = 0;
+    model._forceInternalFormat = false;
     model.openGLDataType = 0;
   }; //----------------------------------------------------------------------------
 
@@ -1288,6 +1291,7 @@ function vtkOpenGLTexture(publicAPI, model) {
 
 var DEFAULT_VALUES = {
   _openGLRenderWindow: null,
+  _forceInternalFormat: false,
   context: null,
   handle: 0,
   sendParametersTime: null,

package/Rendering/OpenGL/VolumeMapper.js

@@ -459,7 +459,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
     var i2wmat4 = model.currentInput.getIndexToWorld();
     mat4.multiply(model.idxToView, model.modelToView, i2wmat4);
     mat3.multiply(model.idxNormalMatrix, keyMats.normalMatrix, actMats.normalMatrix);
-    mat3.multiply(model.idxNormalMatrix, model.idxNormalMatrix, model.currentInput.getDirection());
+    mat3.multiply(model.idxNormalMatrix, model.idxNormalMatrix, model.currentInput.getDirectionByReference());
     var maxSamples = vec3.length(vsize) / model.renderable.getSampleDistance();
 
     if (maxSamples > model.renderable.getMaximumSamplesPerRay()) {

package/Rendering/SceneGraph/ViewNode.js

@@ -181,6 +181,7 @@ function vtkViewNode(publicAPI, model) {
         }
 
         deleted.push(child);
+        child.delete();
       } else {
         child.setVisited(false);
       }
@@ -208,6 +209,16 @@ function vtkViewNode(publicAPI, model) {
 
     return ret;
   };
+
+  var parentDelete = publicAPI.delete;
+
+  publicAPI.delete = function () {
+    for (var i = 0; i < model.children.length; i++) {
+      model.children[i].delete();
+    }
+
+    parentDelete();
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------

package/index.d.ts

@@ -26,6 +26,7 @@
 /// <reference path="./Common/DataModel/DataSet.d.ts" />
 /// <reference path="./Common/DataModel/DataSetAttributes/FieldData.d.ts" />
 /// <reference path="./Common/DataModel/DataSetAttributes.d.ts" />
+/// <reference path="./Common/DataModel/EdgeLocator.d.ts" />
 /// <reference path="./Common/DataModel/ITKHelper.d.ts" />
 /// <reference path="./Common/DataModel/ImageData.d.ts" />
 /// <reference path="./Common/DataModel/IncrementalOctreeNode.d.ts" />

package/macros.js

@@ -580,7 +580,7 @@ function setGet(publicAPI, model, fieldNames) {
 function getArray(publicAPI, model, fieldNames) {
   fieldNames.forEach(function (field) {
     publicAPI["get".concat(_capitalize(field))] = function () {
-      return model[field] ? [].concat(model[field]) : model[field];
+      return model[field] ? Array.from(model[field]) : model[field];
     };
 
     publicAPI["get".concat(_capitalize(field), "ByReference")] = function () {
@@ -638,9 +638,11 @@ function setArray(publicAPI, model, fieldNames, size) {
           }
         }
 
-        changeDetected = model[field] == null || model[field].some(function (item, index) {
-          return item !== array[index];
-        }) || model[field].length !== array.length;
+        changeDetected = model[field] == null || model[field].length !== array.length;
+
+        for (var i = 0; !changeDetected && i < array.length; ++i) {
+          changeDetected = model[field][i] !== array[i];
+        }
 
         if (changeDetected && needCopy) {
           array = Array.from(array);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "25.10.1",
+  "version": "25.11.1",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",
@@ -140,6 +140,7 @@
     "doc:publish": "kw-doc -c ./Documentation/config.js -mp",
     "doc:generate-api": "node ./Documentation/generate-api-docs.js",
     "example": "node ./Utilities/ExampleRunner/example-runner-cli.js -c ./Documentation/config.js",
+    "example:webgpu": "cross-env WEBGPU=1 NO_WEBGL=1 node ./Utilities/ExampleRunner/example-runner-cli.js -c ./Documentation/config.js",
     "dev:esm": "npm run build:esm -- -w",
     "dev:umd": "webpack --watch --config webpack.dev.js --progress",
     "build": "npm run build:release",

package/Filters/General/ClipClosedSurface/ccsEdgeLocator.js

@@ -1,40 +0,0 @@
-import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
-import _createClass from '@babel/runtime/helpers/createClass';
-
-var CCSEdgeLocator = /*#__PURE__*/function () {
-  function CCSEdgeLocator() {
-    _classCallCheck(this, CCSEdgeLocator);
-
-    this._edgeMap = new Map();
-  }
-
-  _createClass(CCSEdgeLocator, [{
-    key: "initialize",
-    value: function initialize() {
-      this._edgeMap.clear();
-    }
-  }, {
-    key: "insertUniqueEdge",
-    value: function insertUniqueEdge(i0, i1) {
-      // Generate key, which is unique, since we order the edges
-      var key = i1 < i0 ? "".concat(i1, "-").concat(i0) : "".concat(i0, "-").concat(i1);
-
-      var node = this._edgeMap.get(key);
-
-      if (!node) {
-        // Didn't find key, so add a new edge entry
-        node = {
-          edgeId: -1
-        };
-
-        this._edgeMap.set(key, node);
-      }
-
-      return node;
-    }
-  }]);
-
-  return CCSEdgeLocator;
-}();
-
-export { CCSEdgeLocator as default };