@kitware/vtk.js 28.3.2 → 28.4.0

package/Common/Core/DataArray.js

@@ -264,7 +264,14 @@ function vtkDataArray(publicAPI, model) {
 
   publicAPI.getRange = function () {
     var componentIndex = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : -1;
-    var rangeIdx = componentIndex < 0 ? model.numberOfComponents : componentIndex;
+    var rangeIdx = componentIndex;
+
+    if (rangeIdx < 0) {
+      // If scalar data, then store in slot 0 (same as componentIndex = 0).
+      // If vector data, then store in last slot.
+      rangeIdx = model.numberOfComponents === 1 ? 0 : model.numberOfComponents;
+    }
+
     var range = null;
 
     if (!model.ranges) {

package/Proxy/Core/View2DProxy.js

@@ -147,8 +147,9 @@ function vtkView2DProxy(publicAPI, model) {
 
     if (rep.setSlicingMode) {
       rep.setSlicingMode('XYZ'[model.axis]);
-      publicAPI.bindRepresentationToManipulator(rep);
     }
+
+    publicAPI.bindRepresentationToManipulator(rep);
   };
 
   var superRemoveRepresentation = publicAPI.removeRepresentation;

package/Proxy/Representations/ResliceRepresentationProxy.d.ts

@@ -0,0 +1,30 @@
+import type vtkPolyData from './../../Common/DataModel/PolyData';
+import type vtkPlane from './../../Common/DataModel/Plane';
+import vtkAbstractRepresentationProxy from './../Core/AbstractRepresentationProxy';
+
+export interface vtkResliceRepresentationProxy
+  extends vtkAbstractRepresentationProxy {
+
+  // proxy property mappings
+
+  setVisibility(visible: boolean): boolean;
+  getVisibility(): boolean;
+  setWindowWidth(width: number): boolean;
+  getWindowWidth(): number;
+  setWindowLevel(level: number): boolean;
+  getWindowLevel(): number;
+  setInterpolationType(type: number): boolean;
+  getInterpolationType(): number;
+  setSlabType(type: number): boolean;
+  getSlabtype(): number;
+  setSlicePlane(plane: vtkPlane): boolean;
+  getSlicePlane(): vtkPlane;
+  setSlicePolyData(polydata: vtkPolyData): boolean;
+  getSlicePolyData(): vtkPolyData;
+  setSlabThickness(thickness: number): boolean;
+  getSlabThickness(): number;
+  setSlabTrapezoidIntegration(slabTrapezoidIntegration: number): boolean;
+  getSlabTrapezoidIntegration(): number;
+}
+
+export default vtkResliceRepresentationProxy;

package/Proxy/Representations/ResliceRepresentationProxy.js

@@ -0,0 +1,157 @@
+import macro from '../../macros.js';
+import vtkImageSlice from '../../Rendering/Core/ImageSlice.js';
+import vtkImageResliceMapper from '../../Rendering/Core/ImageResliceMapper.js';
+import { SlabTypes } from '../../Rendering/Core/ImageResliceMapper/Constants.js';
+import vtkPlane from '../../Common/DataModel/Plane.js';
+import vtkAbstractRepresentationProxy from '../Core/AbstractRepresentationProxy.js';
+
+function sum(a, b) {
+  return a + b;
+} // ----------------------------------------------------------------------------
+
+
+function mean() {
+  for (var _len = arguments.length, array = new Array(_len), _key = 0; _key < _len; _key++) {
+    array[_key] = arguments[_key];
+  }
+
+  return array.reduce(sum, 0) / array.length;
+} // ----------------------------------------------------------------------------
+
+
+function updateDomains(dataset, dataArray, model, updateProp) {
+  var dataRange = dataArray.getRange();
+  var propToUpdate = {
+    windowWidth: {
+      domain: {
+        min: 0,
+        max: dataRange[1] - dataRange[0],
+        step: 'any'
+      }
+    },
+    windowLevel: {
+      domain: {
+        min: dataRange[0],
+        max: dataRange[1],
+        step: 'any'
+      }
+    }
+  };
+  updateProp('windowWidth', propToUpdate.windowWidth);
+  updateProp('windowLevel', propToUpdate.windowLevel);
+  return {
+    windowWidth: propToUpdate.windowWidth.domain.max,
+    windowLevel: Math.floor(mean(propToUpdate.windowLevel.domain.min, propToUpdate.windowLevel.domain.max))
+  };
+} // ----------------------------------------------------------------------------
+// vtkResliceRepresentationProxy methods
+// ----------------------------------------------------------------------------
+
+
+function vtkResliceRepresentationProxy(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkResliceRepresentationProxy');
+  model.mapper = vtkImageResliceMapper.newInstance();
+  model.actor = vtkImageSlice.newInstance();
+  model.property = model.actor.getProperty(); // set slicing plane
+
+  model.slicePlane = vtkPlane.newInstance();
+  model.slicePlane.setNormal(0, 1, 0);
+  model.mapper.setSlicePlane(model.slicePlane);
+  model.mapper.setSlabType(SlabTypes.MAX); // connect rendering pipeline
+
+  model.actor.setMapper(model.mapper);
+  model.actors.push(model.actor);
+
+  function setInputData(inputDataset) {
+    var state = updateDomains(inputDataset, publicAPI.getDataArray(), model, publicAPI.updateProxyProperty);
+    publicAPI.set(state);
+    model.slicePlane.setOrigin(inputDataset.getCenter());
+  } // Keep things updated
+
+
+  model.sourceDependencies.push(model.mapper);
+  model.sourceDependencies.push({
+    setInputData: setInputData
+  }); // API ----------------------------------------------------------------------
+
+  var parentSetColorBy = publicAPI.setColorBy;
+
+  publicAPI.setColorBy = function (arrayName, arrayLocation) {
+    var componentIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
+
+    if (arrayName === null) {
+      model.property.setRGBTransferFunction(null);
+      model.property.setPiecewiseFunction(null);
+    } else {
+      parentSetColorBy(arrayName, arrayLocation, componentIndex);
+      var lutProxy = publicAPI.getLookupTableProxy(arrayName);
+      var pwfProxy = publicAPI.getPiecewiseFunctionProxy(arrayName);
+      model.property.setRGBTransferFunction(lutProxy.getLookupTable());
+      model.property.setPiecewiseFunction(pwfProxy.getPiecewiseFunction());
+    }
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues); // Object methods
+
+  vtkAbstractRepresentationProxy.extend(publicAPI, model, initialValues);
+  macro.get(publicAPI, model, ['slicePlane']); // Object specific methods
+
+  vtkResliceRepresentationProxy(publicAPI, model); // Proxyfy
+
+  macro.proxyPropertyMapping(publicAPI, model, {
+    visibility: {
+      modelKey: 'actor',
+      property: 'visibility'
+    },
+    windowWidth: {
+      modelKey: 'property',
+      property: 'colorWindow'
+    },
+    windowLevel: {
+      modelKey: 'property',
+      property: 'colorLevel'
+    },
+    interpolationType: {
+      modelKey: 'property',
+      property: 'interpolationType'
+    },
+    slicePlane: {
+      modelKey: 'mapper',
+      property: 'slicePlane'
+    },
+    slicePolyData: {
+      modelKey: 'mapper',
+      property: 'slicePolyData'
+    },
+    slabType: {
+      modelKey: 'mapper',
+      property: 'slabType'
+    },
+    slabThickness: {
+      modelKey: 'mapper',
+      property: 'slabThickness'
+    },
+    slabTrapezoidIntegration: {
+      modelKey: 'mapper',
+      property: 'slabTrapezoidIntegration'
+    }
+  });
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkResliceRepresentationProxy'); // ----------------------------------------------------------------------------
+
+var index = {
+  newInstance: newInstance,
+  extend: extend
+};
+
+export { index as default, extend, newInstance };

package/Rendering/Core/ImageResliceMapper.d.ts

@@ -78,7 +78,7 @@ export interface vtkImageResliceMapper extends vtkAbstractImageMapper {
 	 *
 	 * Get the slab composite function.
 	 */
-	getSlabType(): boolean;
+	getSlabType(): SlabTypes;
 
 	/**
 	 *
@@ -165,9 +165,9 @@ export interface vtkImageResliceMapper extends vtkAbstractImageMapper {
 	/**
 	 *
 	 * Enable slab slicing mode and set the slab thickness in world space (mm).
-	 * @param {Boolean} slabThickness The slab thickness in world space (mm). Default: 0. 
+	 * @param {Number} slabThickness The slab thickness in world space (mm). Default: 0.
 	 */
-	setSlabThickness(slabThickness: number): number;
+	setSlabThickness(slabThickness: number): boolean;
 
 	/**
 	 *
@@ -178,7 +178,7 @@ export interface vtkImageResliceMapper extends vtkAbstractImageMapper {
 	 * @param {Number} slabTrapezoidIntegration Enable/disable trapezoid integration for slab slicing.
 	 * Default: 0
 	 */
-	setSlabTrapezoidIntegration(slabTrapezoidIntegration: number): number;
+	setSlabTrapezoidIntegration(slabTrapezoidIntegration: number): boolean;
 
 	/**
 	 *
@@ -201,7 +201,7 @@ export interface vtkImageResliceMapper extends vtkAbstractImageMapper {
 	 * bounds.
 	 * @param {vtkPlane} slicePlane The implicit plane to slice the volume with. Default: null
 	 */
-	setSlicePlane(slicePlane: vtkPlane): vtkPlane;
+	setSlicePlane(slicePlane: vtkPlane): boolean;
 
 	/**
 	 *
@@ -214,7 +214,7 @@ export interface vtkImageResliceMapper extends vtkAbstractImageMapper {
 	 * bounds.
 	 * @param {vtkPolyData} slicePolyData The polydata to slice the volume with. Default: null
 	 */
-	setSlicePolyData(slicePolyData: vtkPolyData): vtkPolyData;
+	setSlicePolyData(slicePolyData: vtkPolyData): boolean;
 }
 
 /**

package/Rendering/OpenGL/ImageMapper.js

@@ -743,7 +743,11 @@ function vtkOpenGLImageMapper(publicAPI, model) {
           for (var j = 0; j < dims[1]; j++) {
             var bsIdx = (sliceOffset + j * dims[0] + k * dims[0] * dims[1]) * numComp;
             id = (k * dims[1] + j) * numComp;
-            scalars.set(basicScalars.subarray(bsIdx, bsIdx + numComp), id);
+            var end = bsIdx + numComp;
+
+            while (bsIdx < end) {
+              scalars[id++] = basicScalars[bsIdx++];
+            }
           }
         }
 
@@ -770,7 +774,12 @@ function vtkOpenGLImageMapper(publicAPI, model) {
             var _bsIdx = (_i9 + sliceOffset * dims[0] + _k * dims[0] * dims[1]) * numComp;
 
             _id = (_k * dims[0] + _i9) * numComp;
-            scalars.set(basicScalars.subarray(_bsIdx, _bsIdx + numComp), _id);
+
+            var _end = _bsIdx + numComp;
+
+            while (_bsIdx < _end) {
+              scalars[_id++] = basicScalars[_bsIdx++];
+            }
           }
         }
 

package/Rendering/OpenGL/ImageResliceMapper.js

@@ -1,6 +1,7 @@
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import { newInstance as newInstance$1, obj, get, vtkErrorMacro as vtkErrorMacro$1 } from '../../macros.js';
-import { mat4, vec3 } from 'gl-matrix';
+import { mat4, mat3, vec3 } from 'gl-matrix';
 import vtkClosedPolyLineToSurfaceFilter from '../../Filters/General/ClosedPolyLineToSurfaceFilter.js';
 import vtkCubeSource from '../../Filters/Sources/CubeSource.js';
 import vtkCutter from '../../Filters/Core/Cutter.js';
@@ -440,12 +441,9 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
 
       if (program.isUniformUsed('WCTCMatrix')) {
         var image = model.currentInput;
-        mat4.identity(model.tmpMat4);
-        var bounds = image.getBounds();
-        var sc = [bounds[1] - bounds[0], bounds[3] - bounds[2], bounds[5] - bounds[4]];
-        var o = [bounds[0], bounds[2], bounds[4]];
-        var q = [0, 0, 0, 1];
-        mat4.fromRotationTranslationScale(model.tmpMat4, q, o, sc);
+        var dim = image.getDimensions();
+        mat4.copy(model.tmpMat4, image.getIndexToWorld());
+        mat4.scale(model.tmpMat4, model.tmpMat4, dim);
         mat4.invert(model.tmpMat4, model.tmpMat4);
 
         if (inverseShiftScaleMatrix) {
@@ -455,6 +453,10 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
         program.setUniformMatrix('WCTCMatrix', model.tmpMat4);
       }
 
+      if (program.isUniformUsed('vboScaling')) {
+        program.setUniform3fv('vboScaling', cellBO.getCABO().getCoordScale());
+      }
+
       cellBO.getAttributeUpdateTime().modified();
     } // Depth request
 
@@ -672,7 +674,7 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     }
 
     if (slabThickness > 0.0) {
-      tcoordFSDec = tcoordFSDec.concat(['uniform vec3 spacing;', 'uniform float slabThickness;', 'uniform int slabType;', 'uniform int slabTrapezoid;']);
+      tcoordFSDec = tcoordFSDec.concat(['uniform vec3 spacing;', 'uniform float slabThickness;', 'uniform int slabType;', 'uniform int slabTrapezoid;', 'uniform vec3 vboScaling;']);
       tcoordFSDec = tcoordFSDec.concat(['vec4 compositeValue(vec4 currVal, vec4 valToComp, int trapezoid)', '{', '  vec4 retVal = vec4(1.0);', '  if (slabType == 0) // min', '  {', '    retVal = min(currVal, valToComp);', '  }', '  else if (slabType == 1) // max', '  {', '    retVal = max(currVal, valToComp);', '  }', '  else if (slabType == 3) // sum', '  {', '    retVal = currVal + (trapezoid > 0 ? 0.5 * valToComp : valToComp); ', '  }', '  else // mean', '  {', '    retVal = currVal + (trapezoid > 0 ? 0.5 * valToComp : valToComp); ', '  }', '  return retVal;', '}']);
     }
 
@@ -680,7 +682,7 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     var tcoordFSImpl = ['if (any(greaterThan(fragTexCoord, vec3(1.0))) || any(lessThan(fragTexCoord, vec3(0.0))))', '{', '  // set the background color and exit', '  gl_FragData[0] = backgroundColor;', '  return;', '}', 'vec4 tvalue = texture(texture1, fragTexCoord);'];
 
     if (slabThickness > 0.0) {
-      tcoordFSImpl = tcoordFSImpl.concat(['// Get the first and last samples', 'int numSlices = 1;', 'vec3 normalxspacing = normalWCVSOutput * spacing * 0.5;', 'float distTraveled = length(normalxspacing);', 'int trapezoid = 0;', 'while (distTraveled < slabThickness * 0.5)', '{', '  distTraveled += length(normalxspacing);', '  float fnumSlices = float(numSlices);', '  if (distTraveled > slabThickness * 0.5)', '  {', '    // Before stepping outside the slab, sample at the boundaries', '    normalxspacing = normalWCVSOutput * slabThickness * 0.5 / fnumSlices;', '    trapezoid = slabTrapezoid;', '  }', '  vec3 fragTCoordNeg = (WCTCMatrix * vec4(vertexWCVSOutput.xyz - fnumSlices * normalxspacing, 1.0)).xyz;', '  if (!any(greaterThan(fragTCoordNeg, vec3(1.0))) && !any(lessThan(fragTCoordNeg, vec3(0.0))))', '  {', '    vec4 newVal = texture(texture1, fragTCoordNeg);', '    tvalue = compositeValue(tvalue, newVal, trapezoid);', '    numSlices += 1;', '  }', '  vec3 fragTCoordPos = (WCTCMatrix * vec4(vertexWCVSOutput.xyz + fnumSlices * normalxspacing, 1.0)).xyz;', '  if (!any(greaterThan(fragTCoordNeg, vec3(1.0))) && !any(lessThan(fragTCoordNeg, vec3(0.0))))', '  {', '    vec4 newVal = texture(texture1, fragTCoordPos);', '    tvalue = compositeValue(tvalue, newVal, trapezoid);', '    numSlices += 1;', '  }', '}', '// Finally, if slab type is *mean*, divide the sum by the numSlices', 'if (slabType == 2)', '{', '  tvalue = tvalue / float(numSlices);', '}']);
+      tcoordFSImpl = tcoordFSImpl.concat(['// Get the first and last samples', 'int numSlices = 1;', 'float scaling = min(min(spacing.x, spacing.y), spacing.z) * 0.5;', 'vec3 normalxspacing = scaling * normalWCVSOutput;', 'float distTraveled = length(normalxspacing);', 'int trapezoid = 0;', 'while (distTraveled < slabThickness * 0.5)', '{', '  distTraveled += length(normalxspacing);', '  float fnumSlices = float(numSlices);', '  if (distTraveled > slabThickness * 0.5)', '  {', '    // Before stepping outside the slab, sample at the boundaries', '    normalxspacing = normalWCVSOutput * slabThickness * 0.5 / fnumSlices;', '    trapezoid = slabTrapezoid;', '  }', '  vec3 fragTCoordNeg = (WCTCMatrix * vec4(vertexWCVSOutput.xyz - fnumSlices * normalxspacing * vboScaling, 1.0)).xyz;', '  if (!any(greaterThan(fragTCoordNeg, vec3(1.0))) && !any(lessThan(fragTCoordNeg, vec3(0.0))))', '  {', '    vec4 newVal = texture(texture1, fragTCoordNeg);', '    tvalue = compositeValue(tvalue, newVal, trapezoid);', '    numSlices += 1;', '  }', '  vec3 fragTCoordPos = (WCTCMatrix * vec4(vertexWCVSOutput.xyz + fnumSlices * normalxspacing * vboScaling, 1.0)).xyz;', '  if (!any(greaterThan(fragTCoordNeg, vec3(1.0))) && !any(lessThan(fragTCoordNeg, vec3(0.0))))', '  {', '    vec4 newVal = texture(texture1, fragTCoordPos);', '    tvalue = compositeValue(tvalue, newVal, trapezoid);', '    numSlices += 1;', '  }', '}', '// Finally, if slab type is *mean*, divide the sum by the numSlices', 'if (slabType == 2)', '{', '  tvalue = tvalue / float(numSlices);', '}']);
     }
 
     if (iComps) {
@@ -787,6 +789,49 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     return [false, 2];
   }
 
+  function transformPoints(points, transform) {
+    var tmp = [0, 0, 0];
+
+    for (var i = 0; i < points.length; i += 3) {
+      var p = points.subarray(i, i + 3);
+
+      if (transform.length === 9) {
+        vec3.transformMat3(tmp, p, transform);
+      } else {
+        vec3.transformMat4(tmp, p, transform);
+      }
+
+      p[0] = tmp[0];
+      p[1] = tmp[1];
+      p[2] = tmp[2];
+    }
+  }
+
+  function imageToCubePolyData(image, outPD) {
+    // First create a cube polydata in the index-space of the image.
+    var sext = image === null || image === void 0 ? void 0 : image.getSpatialExtent();
+
+    if (sext) {
+      model.cubeSource.setXLength(sext[1] - sext[0]);
+      model.cubeSource.setYLength(sext[3] - sext[2]);
+      model.cubeSource.setZLength(sext[5] - sext[4]);
+    } else {
+      model.cubeSource.setXLength(1);
+      model.cubeSource.setYLength(1);
+      model.cubeSource.setZLength(1);
+    }
+
+    model.cubeSource.setCenter(model.cubeSource.getXLength() / 2.0, model.cubeSource.getYLength() / 2.0, model.cubeSource.getZLength() / 2.0);
+    model.cubeSource.update();
+    var out = model.cubeSource.getOutputData();
+    outPD.getPoints().setData(Float32Array.from(out.getPoints().getData()), 3);
+    outPD.getPolys().setData(Uint32Array.from(out.getPolys().getData()), 1); // Now, transform the cube polydata points in-place
+    // using the image's indexToWorld transformation.
+
+    var points = outPD.getPoints().getData();
+    transformPoints(points, image.getIndexToWorld());
+  }
+
   publicAPI.updateResliceGeometry = function () {
     var resGeomString = '';
     var image = model.currentInput;
@@ -805,9 +850,19 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
       if (image) {
         resGeomString = resGeomString.concat("Image".concat(image.getMTime()));
       } // Check to see if we can bypass oblique slicing related bounds computation
+      // Compute a world-to-image-orientation matrix.
+      // Ignore the translation component since we are
+      // using it on vectors rather than positions.
+
+
+      var w2io = mat3.fromValues(image === null || image === void 0 ? void 0 : image.getDirection());
+      mat3.invert(w2io, w2io); // transform the cutting plane normal to image local coords
 
+      var imageLocalNormal = _toConsumableArray(slicePlane.getNormal());
 
-      var _isVectorAxisAligned = isVectorAxisAligned(slicePlane.getNormal());
+      vec3.transformMat3(imageLocalNormal, imageLocalNormal, w2io);
+
+      var _isVectorAxisAligned = isVectorAxisAligned(imageLocalNormal);
 
       var _isVectorAxisAligned2 = _slicedToArray(_isVectorAxisAligned, 2);
 
@@ -844,26 +899,18 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
         model.resliceGeom.getPolys().setData(slicePD.getPolys().getData(), 1);
         model.resliceGeom.getPointData().setNormals(slicePD.getPointData().getNormals());
       } else if (slicePlane) {
-        var bounds = image ? imageBounds : [0, 1, 0, 1, 0, 1];
-
         if (!orthoSlicing) {
-          var cube = vtkCubeSource.newInstance();
-          cube.setCenter(0.5 * (bounds[0] + bounds[1]), 0.5 * (bounds[2] + bounds[3]), 0.5 * (bounds[4] + bounds[5]));
-          cube.setXLength(bounds[1] - bounds[0]);
-          cube.setYLength(bounds[3] - bounds[2]);
-          cube.setZLength(bounds[5] - bounds[4]);
-          var cutter = vtkCutter.newInstance();
-          cutter.setInputConnection(cube.getOutputPort());
-          cutter.setCutFunction(slicePlane);
-          var pds = vtkClosedPolyLineToSurfaceFilter.newInstance();
-          pds.setInputConnection(cutter.getOutputPort());
-          pds.update();
+          imageToCubePolyData(image, model.cubePolyData);
+          model.cutter.setInputData(model.cubePolyData);
+          model.cutter.setCutFunction(slicePlane);
+          model.lineToSurfaceFilter.setInputConnection(model.cutter.getOutputPort());
+          model.lineToSurfaceFilter.update();
 
           if (!model.resliceGeom) {
             model.resliceGeom = vtkPolyData.newInstance();
           }
 
-          var planePD = pds.getOutputData();
+          var planePD = model.lineToSurfaceFilter.getOutputData();
           model.resliceGeom.getPoints().setData(planePD.getPoints().getData(), 3);
           model.resliceGeom.getPolys().setData(planePD.getPolys().getData(), 1);
           model.resliceGeom.getPointData().setNormals(planePD.getPointData().getNormals()); // The above method does not generate point normals
@@ -887,20 +934,25 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
           });
           model.resliceGeom.getPointData().setNormals(normals);
         } else {
+          // Since the image-local normal is axis-aligned, we
+          // can quickly construct the cutting plane using indexToWorld transforms.
           var ptsArray = new Float32Array(12);
-          var o = slicePlane.getOrigin();
+          var indexSpacePlaneOrigin = image.worldToIndex(slicePlane.getOrigin(), [0, 0, 0]);
           var otherAxes = [(orthoAxis + 1) % 3, (orthoAxis + 2) % 3].sort();
+          var dim = image.getDimensions();
+          var ext = [0, dim[0] - 1, 0, dim[1] - 1, 0, dim[2] - 1];
           var ptIdx = 0;
 
           for (var _i7 = 0; _i7 < 2; ++_i7) {
             for (var j = 0; j < 2; ++j) {
-              ptsArray[ptIdx + orthoAxis] = o[orthoAxis];
-              ptsArray[ptIdx + otherAxes[0]] = bounds[2 * otherAxes[0] + j];
-              ptsArray[ptIdx + otherAxes[1]] = bounds[2 * otherAxes[1] + _i7];
+              ptsArray[ptIdx + orthoAxis] = indexSpacePlaneOrigin[orthoAxis];
+              ptsArray[ptIdx + otherAxes[0]] = ext[2 * otherAxes[0] + j];
+              ptsArray[ptIdx + otherAxes[1]] = ext[2 * otherAxes[1] + _i7];
               ptIdx += 3;
             }
           }
 
+          transformPoints(ptsArray, image.getIndexToWorld());
           var cellArray = new Uint16Array(8);
           cellArray[0] = 3;
           cellArray[1] = 0;
@@ -992,9 +1044,13 @@ function extend(publicAPI, model) {
   model.colorTexture = vtkOpenGLTexture.newInstance();
   model.pwfTexture = vtkOpenGLTexture.newInstance();
   model.VBOBuildTime = {};
-  obj(model.VBOBuildTime); // model.modelToView = mat4.identity(new Float64Array(16));
+  obj(model.VBOBuildTime);
+  model.tmpMat4 = mat4.identity(new Float64Array(16)); // Implicit plane to polydata related cache:
 
-  model.tmpMat4 = mat4.identity(new Float64Array(16));
+  model.cubeSource = vtkCubeSource.newInstance();
+  model.cubePolyData = vtkPolyData.newInstance();
+  model.cutter = vtkCutter.newInstance();
+  model.lineToSurfaceFilter = vtkClosedPolyLineToSurfaceFilter.newInstance();
   get(publicAPI, model, ['openGLTexture']); // Object methods
 
   vtkOpenGLImageResliceMapper(publicAPI, model);

package/Widgets/Widgets3D/ResliceCursorWidget.d.ts

@@ -0,0 +1,103 @@
+import { mat4 } from 'gl-matrix';
+import vtkAbstractWidgetFactory from './../Core/AbstractWidgetFactory';
+import vtkImageData from './../../Common/DataModel/ImageData';
+import vtkImageReslice from './../../Imaging/Core/ImageReslice';
+import vtkPlaneSource from './../../Filters/Sources/PlaneSource';
+import vtkRenderer from './../../Rendering/Core/Renderer';
+import vtkPlaneManipulator from './../Manipulators/PlaneManipulator';
+import { ViewTypes } from './../Core/WidgetManager/Constants';
+import { Vector2, Vector3 } from './../../types';
+
+export interface IDisplayScaleParams {
+  dispHeightFactor: number,
+  cameraPosition: Vector3,
+  cameraDir: Vector3,
+  isParallel: false,
+  rendererPixelDims: Vector2
+}
+
+export interface vtkResliceCursorWidget extends vtkAbstractWidgetFactory {
+
+  /**
+   * @param {ViewTypes} viewType
+   */
+  getRepresentationsForViewType(viewType: ViewTypes): unknown;
+
+  setImage(image: vtkImageData): void;
+
+  setCenter(center: Vector3): void;
+
+  updateCameraPoints(
+    renderer: vtkRenderer,
+    viewType: ViewTypes,
+    resetFocalPoint: boolean,
+    keepCenterFocalDistance: boolean,
+    computeFocalPointOffset: boolean
+  ): void;
+
+  resetCamera(
+    renderer: vtkRenderer,
+    viewType: ViewTypes,
+    resetFocalPoint: boolean,
+    keepCenterFocalDistance: boolean
+  ): void;
+
+
+  getPlaneSource(viewType: ViewTypes): vtkPlaneSource;
+
+  getResliceAxes(viewType: ViewTypes): mat4;
+
+  updateReslicePlane(imageReslice: vtkImageReslice, viewType: ViewTypes): boolean;
+
+  getPlaneSourceFromViewType(type: ViewTypes): vtkPlaneSource;
+
+  getPlaneNormalFromViewType(viewType: ViewTypes): Vector3;
+
+  getOtherPlaneNormals(viewType: ViewTypes): Array<Vector3>;
+
+  getResliceMatrix(): mat4;
+
+  getDisplayScaleParams(): IDisplayScaleParams;
+
+  setScaleInPixels(scale: boolean): boolean;
+
+  getScaleInPixels(): boolean;
+
+  setRotationHandlePosition(position: number): boolean;
+
+  getRotationHandlePosition(): number;
+
+  setManipulator(manipulator: vtkPlaneManipulator): boolean;
+
+  getManipulator(): vtkPlaneManipulator;
+
+}
+
+export interface IResliceCursorWidgetInitialValues {}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkResliceCursorWidget characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param initialValues (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IResliceCursorWidgetInitialValues
+): vtkResliceCursorWidget;
+
+/**
+ * Method used to create a new instance of vtkResliceCursorWidget
+ * 
+ * @param initialValues for pre-setting some of its content
+ */
+export function newInstance(initialValues?: IResliceCursorWidgetInitialValues): vtkResliceCursorWidget;
+
+export declare const vtkResliceCursorWidget: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+
+export default vtkResliceCursorWidget;

package/index.d.ts

@@ -130,6 +130,7 @@
 /// <reference path="./Proxy/Core/SourceProxy.d.ts" />
 /// <reference path="./Proxy/Core/View2DProxy.d.ts" />
 /// <reference path="./Proxy/Core/ViewProxy.d.ts" />
+/// <reference path="./Proxy/Representations/ResliceRepresentationProxy.d.ts" />
 /// <reference path="./Proxy/Representations/SliceRepresentationProxy.d.ts" />
 /// <reference path="./Proxy/Representations/VolumeRepresentationProxy.d.ts" />
 /// <reference path="./Rendering/Core/AbstractImageMapper.d.ts" />
@@ -219,6 +220,7 @@
 /// <reference path="./Widgets/Manipulators/TrackballManipulator.d.ts" />
 /// <reference path="./Widgets/Representations/WidgetRepresentation.d.ts" />
 /// <reference path="./Widgets/Widgets3D/InteractiveOrientationWidget.d.ts" />
+/// <reference path="./Widgets/Widgets3D/ResliceCursorWidget.d.ts" />
 /// <reference path="./Widgets/Widgets3D/SphereWidget.d.ts" />
 /// <reference path="./macros.d.ts" />
 /// <reference path="./vtk.d.ts" />

package/package.json

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