@kitware/vtk.js 28.6.0 → 28.8.0

package/Common/Core/DataArray.js

@@ -490,8 +490,19 @@ function vtkDataArray(publicAPI, model) {
   };
 
   publicAPI.deepCopy = function (other) {
-    publicAPI.shallowCopy(other);
-    publicAPI.setData(other.getData().slice());
+    // Retain current dataType and array reference before shallowCopy call.
+    var currentType = publicAPI.getDataType();
+    var currentArray = model.values;
+    publicAPI.shallowCopy(other); // Avoid array reallocation if size already sufficient
+    // and dataTypes match.
+
+    if ((currentArray === null || currentArray === void 0 ? void 0 : currentArray.length) >= other.getNumberOfValues() && currentType === other.getDataType()) {
+      currentArray.set(other.getData());
+      model.values = currentArray;
+      publicAPI.dataChange();
+    } else {
+      publicAPI.setData(other.getData().slice());
+    }
   };
 
   publicAPI.interpolateTuple = function (idx, source1, source1Idx, source2, source2Idx, t) {

package/Common/DataModel/PolyLine.d.ts

@@ -1,5 +1,5 @@
-import { quat } from 'gl-matrix';
-import { Vector2, Vector3 } from './../../types';
+import { quat, vec3 } from 'gl-matrix';
+import { Nullable, Vector2, Vector3 } from './../../types';
 import vtkCell, { ICellInitialValues } from './Cell';
 import { IIntersectWithLine } from './Line';
 
@@ -67,6 +67,31 @@ export interface vtkPolyLine extends vtkCell {
    * @param distance The distance from the first point of the polyline
    */
   findPointIdAtDistanceFromFirstPoint(distance: number): number;
+
+  /**
+   * An array of quaternions used to orient the polyline at each of its point
+   * The length of the array has to be the same size as the number of points
+   * Defaults to null.
+   */
+  getOrientations(): Nullable<quat[]>;
+
+  /**
+   * @see getOrientations
+   * @param orientations
+   */
+  setOrientations(orientations: Nullable<quat[]>): boolean;
+
+  /**
+   * The function used in getDistancesToFirstPoint and in findPointIdAtDistanceFromFirstPoint
+   * Defaults to vec3.dist of gl-matrix
+   */
+  getDistanceFunction(): (a: vec3, b: vec3) => number;
+
+  /**
+   * @see getDistanceFunction
+   * @param f
+   */
+  setDistanceFunction(f: (a: vec3, b: vec3) => number): boolean;
 }
 
 /**

package/Common/DataModel/PolyLine.js

@@ -58,7 +58,9 @@ function vtkPolyLine(publicAPI, model) {
   };
 
   publicAPI.getDistancesToFirstPoint = function () {
-    if (model.distancesTime.getMTime() < model.points.getMTime()) {
+    var dTime = model.distancesTime.getMTime();
+
+    if (dTime < model.points.getMTime() || dTime < publicAPI.getMTime()) {
       var numPoints = publicAPI.getNumberOfPoints();
 
       if (!model.distances) {
@@ -76,7 +78,7 @@ function vtkPolyLine(publicAPI, model) {
 
         for (var i = 1; i < numPoints; ++i) {
           model.points.getPoint(i, currentPoint);
-          totalDistance += vec3.dist(previousPoint, currentPoint);
+          totalDistance += model.distanceFunction(previousPoint, currentPoint);
           model.distances[i] = totalDistance;
           vec3.copy(previousPoint, currentPoint);
         }
@@ -121,15 +123,16 @@ function vtkPolyLine(publicAPI, model) {
 
 
 var DEFAULT_VALUES = {
-  orientations: null // an array of quat or null
-
+  orientations: null,
+  // an array of quat or null
+  distanceFunction: vec3.dist
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
   vtkCell.extend(publicAPI, model, initialValues);
-  macro.setGet(publicAPI, model, ['orientations']);
+  macro.setGet(publicAPI, model, ['orientations', 'distanceFunction']);
   model.distancesTime = {};
   macro.obj(model.distancesTime, {
     mtime: 0

package/Filters/General/ImageDataOutlineFilter.d.ts

@@ -0,0 +1,77 @@
+import { vtkAlgorithm, vtkObject } from './../../interfaces';
+import vtkImageData from './../../Common/DataModel/ImageData';
+import vtkPolyData from './../../Common/DataModel/PolyData';
+
+export const LINE_ARRAY: number[];
+
+export interface IImageDataOutlineFilterInitialValues {
+}
+
+type vtkImageDataOutlineFilterBase = vtkObject & vtkAlgorithm;
+
+export interface vtkImageDataOutlineFilter extends vtkImageDataOutlineFilterBase {
+    /**
+     *
+     * @param inData 
+     * @param outData 
+     */
+    requestData(inData: vtkImageData, outData: vtkPolyData): void;
+
+    /**
+     * Flag that indicates whether the output will generate faces of the outline.
+     * @returns {boolean}
+     */
+    getGenerateFaces(): boolean;
+
+    /**
+     * Flag that indicates whether the output will generate wireframe lines of the outline.
+     * @returns {boolean}
+     */
+    getGenerateLines(): boolean;
+
+    /**
+     * Flag to indicate that the output should generate wireframe of the outline.
+     * @param {boolean} generateLines
+     */
+    setGenerateLines(generateLines: boolean): boolean;
+
+    /**
+     * Flag to indicate that the output should generate triangulated faces of the outline.
+     * @param {boolean} generateFaces
+     */
+    setGenerateFaces(generateFaces: boolean): boolean;
+
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with
+ * vtkImageDataOutlineFilter characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IImageDataOutlineFilterInitialValues} [initialValues] (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues?: IImageDataOutlineFilterInitialValues): void;
+
+/**
+ * Method used to create a new instance of vtkImageDataOutlineFilter
+ * @param {IImageDataOutlineFilterInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(initialValues?: IImageDataOutlineFilterInitialValues): vtkImageDataOutlineFilter;
+
+
+/**
+ * vtkImageDataOutlineFilter - A filter that generates oriented outline for
+ * vtkImageData.
+ *
+ * vtkImageDataOutlineFilter is a filter that generates a wireframe or
+ * triangulated rectangular-cuboid as an outline of an input vtkImageData.
+ * It takes into account the orientation / DirectionMatrix of the image, so the
+ * output outline may not be axes aligned.
+ * 
+ */
+export declare const vtkImageDataOutlineFilter: {
+    newInstance: typeof newInstance;
+    extend: typeof extend;
+}
+export default vtkImageDataOutlineFilter;

package/Filters/General/ImageDataOutlineFilter.js

@@ -0,0 +1,82 @@
+import macro from '../../macros.js';
+import vtkCubeSource from '../Sources/CubeSource.js';
+
+var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
+// vtkImageDataOutlineFilter methods
+// ----------------------------------------------------------------------------
+
+function vtkImageDataOutlineFilter(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkImageDataOutlineFilter');
+
+  publicAPI.requestData = function (inData, outData) {
+    // implement requestData
+    var input = inData[0];
+
+    if (!input || !input.isA('vtkImageData')) {
+      vtkErrorMacro('Invalid or missing input');
+      return;
+    } // First create a cube polydata in the index-space of the image.
+    // The benefit of using `getSpatialExtent` call is that it automatically
+    // takes care of 0.5 voxel padding as required by an vtkImageData representation.
+
+
+    var spatialExt = input.getSpatialExtent();
+
+    if (!spatialExt) {
+      vtkErrorMacro('Unable to fetch spatial extents of input image.');
+      return;
+    }
+
+    model._cubeSource.setBounds(spatialExt); // Then apply index-to-world transform to the cube to create the outline.
+
+
+    model._cubeSource.setMatrix(input.getIndexToWorld());
+
+    outData[0] = model._cubeSource.getOutputData();
+  }; // Forward calls for [set/get]Generate[Faces/Lines] functions to cubeSource:
+
+
+  publicAPI.setGenerateFaces = function (generateFaces) {
+    if (model._cubeSource.setGenerateFaces(generateFaces)) {
+      publicAPI.modified();
+    }
+  };
+
+  publicAPI.setGenerateLines = function (generateLines) {
+    if (model._cubeSource.setGenerateLines(generateLines)) {
+      publicAPI.modified();
+    }
+  };
+
+  publicAPI.getGenerateFaces = model._cubeSource.getGenerateFaces;
+  publicAPI.getGenerateLines = model._cubeSource.getGenerateLines;
+} // ----------------------------------------------------------------------------
+// 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); // Make this a VTK object
+
+  macro.obj(publicAPI, model); // Also make it an algorithm with one input and one output
+
+  macro.algo(publicAPI, model, 1, 1); // Internal persistent objects
+
+  model._cubeSource = vtkCubeSource.newInstance();
+  macro.moveToProtected(publicAPI, model, ['cubeSource', 'tmpOut']); // Object specific methods
+
+  vtkImageDataOutlineFilter(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkImageDataOutlineFilter'); // ----------------------------------------------------------------------------
+
+var vtkImageDataOutlineFilter$1 = {
+  newInstance: newInstance,
+  extend: extend
+};
+
+export { vtkImageDataOutlineFilter$1 as default, extend, newInstance };

package/Filters/Sources/CubeSource.d.ts

@@ -1,3 +1,4 @@
+import { mat4 } from 'gl-matrix';
 import { vtkAlgorithm, vtkObject } from './../../interfaces';
 import { Bounds, Vector3 } from './../../types';
 
@@ -41,6 +42,24 @@ export interface vtkCubeSource extends vtkCubeSourceBase {
 	 */
 	getGenerate3DTextureCoordinates(): boolean;
 
+    /**
+     * Flag that indicates whether the output will generate faces of the outline.
+     * @returns {boolean}
+     */
+    getGenerateFaces(): boolean;
+
+    /**
+     * Flag that indicates whether the output will generate wireframe lines of the outline.
+     * @returns {boolean}
+     */
+    getGenerateLines(): boolean;
+
+    /**
+     * Get the 4x4 transformation set to apply as a final trasformation to the output.
+     * @param matrix
+     */
+    getMatrix(): mat4;
+
 	/**
 	 *
 	 * @default [0.0, 0.0, 0.0]
@@ -117,6 +136,24 @@ export interface vtkCubeSource extends vtkCubeSourceBase {
 	 */
 	setGenerate3DTextureCoordinates(generate3DTextureCoordinates: boolean): boolean;
 
+    /**
+     * Flag to indicate that the output should generate wireframe of the outline.
+     * @param {boolean} generateLines
+     */
+    setGenerateLines(generateLines: boolean): boolean;
+
+    /**
+     * Flag to indicate that the output should generate triangulated faces of the outline.
+     * @param {boolean} generateFaces
+     */
+    setGenerateFaces(generateFaces: boolean): boolean;
+
+    /**
+     * Set a 4x4 transformation that will be applied as a final trasformation to the output.
+     * @param matrix
+     */
+    setMatrix(matrix: mat4): boolean;
+
 	/**
 	 * Float array of size 3 representing the angles, in degrees, of rotation for the cube.
 	 * @param xAngle

package/Filters/Sources/CubeSource.js

@@ -1,9 +1,14 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
+import vtkCellArray from '../../Common/Core/CellArray.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
+import { IDENTITY } from '../../Common/Core/Math/Constants.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 
+var LINE_ARRAY = [2, 0, 1, 2, 2, 3, 2, 4, 5, 2, 6, 7, 2, 0, 2, 2, 1, 3, 2, 4, 6, 2, 5, 7, 2, 0, 4, 2, 1, 5, 2, 2, 6, 2, 3, 7]; // prettier-ignore
+
+var POLY_ARRAY = [4, 0, 1, 3, 2, 4, 4, 6, 7, 5, 4, 8, 10, 11, 9, 4, 12, 13, 15, 14, 4, 16, 18, 19, 17, 4, 20, 21, 23, 22]; // ----------------------------------------------------------------------------
 // vtkCubeSource methods
 // ----------------------------------------------------------------------------
 
@@ -20,7 +25,6 @@ function vtkCubeSource(publicAPI, model) {
 
     var polyData = vtkPolyData.newInstance();
     outData[0] = polyData;
-    var numberOfPolys = 6;
     var numberOfPoints = 24; // Define points
 
     var points = macro.newTypedArray(model.pointType, numberOfPoints * 3);
@@ -175,42 +179,29 @@ function vtkCubeSource(publicAPI, model) {
 
     vtkMatrixBuilder.buildFromDegree().rotateX(model.rotations[0]).rotateY(model.rotations[1]).rotateZ(model.rotations[2]).apply(points).apply(normals); // Apply transformation to the points coordinates
 
-    (_vtkMatrixBuilder$bui = vtkMatrixBuilder.buildFromRadian()).translate.apply(_vtkMatrixBuilder$bui, _toConsumableArray(model.center)).apply(points); // Define quads
-
-
-    var polys = new Uint16Array(numberOfPolys * 5);
-    polyData.getPolys().setData(polys, 1);
-    var polyIndex = 0;
-    polys[polyIndex++] = 4;
-    polys[polyIndex++] = 0;
-    polys[polyIndex++] = 1;
-    polys[polyIndex++] = 3;
-    polys[polyIndex++] = 2;
-    polys[polyIndex++] = 4;
-    polys[polyIndex++] = 4;
-    polys[polyIndex++] = 6;
-    polys[polyIndex++] = 7;
-    polys[polyIndex++] = 5;
-    polys[polyIndex++] = 4;
-    polys[polyIndex++] = 8;
-    polys[polyIndex++] = 10;
-    polys[polyIndex++] = 11;
-    polys[polyIndex++] = 9;
-    polys[polyIndex++] = 4;
-    polys[polyIndex++] = 12;
-    polys[polyIndex++] = 13;
-    polys[polyIndex++] = 15;
-    polys[polyIndex++] = 14;
-    polys[polyIndex++] = 4;
-    polys[polyIndex++] = 16;
-    polys[polyIndex++] = 18;
-    polys[polyIndex++] = 19;
-    polys[polyIndex++] = 17;
-    polys[polyIndex++] = 4;
-    polys[polyIndex++] = 20;
-    polys[polyIndex++] = 21;
-    polys[polyIndex++] = 23;
-    polys[polyIndex] = 22;
+    (_vtkMatrixBuilder$bui = vtkMatrixBuilder.buildFromRadian()).translate.apply(_vtkMatrixBuilder$bui, _toConsumableArray(model.center)).apply(points); // Apply optional additionally specified matrix transformation
+
+
+    vtkMatrixBuilder.buildFromRadian().setMatrix(model.matrix).apply(points); // prettier-ignore
+
+    var rotMatrix = [model.matrix[0], model.matrix[1], model.matrix[2], 0, model.matrix[4], model.matrix[5], model.matrix[6], 0, model.matrix[8], model.matrix[9], model.matrix[10], 0, 0, 0, 0, 1];
+    vtkMatrixBuilder.buildFromRadian().setMatrix(rotMatrix).apply(normals); // Lastly, generate the necessary cell arrays.
+
+    if (model.generateFaces) {
+      polyData.getPolys().deepCopy(model._polys);
+    } else {
+      polyData.getPolys().initialize();
+    }
+
+    if (model.generateLines) {
+      polyData.getLines().deepCopy(model._lineCells); // only set normals for faces, not for lines.
+
+      polyData.getPointData().setNormals(null);
+    } else {
+      polyData.getLines().initialize();
+    }
+
+    polyData.modified();
   }
 
   publicAPI.setBounds = function () {
@@ -228,10 +219,10 @@ function vtkCubeSource(publicAPI, model) {
       return;
     }
 
-    model.xLength = boundsArray[1] - boundsArray[0];
-    model.yLength = boundsArray[3] - boundsArray[2];
-    model.zLength = boundsArray[5] - boundsArray[4];
-    model.center = [(boundsArray[0] + boundsArray[1]) / 2.0, (boundsArray[2] + boundsArray[3]) / 2.0, (boundsArray[4] + boundsArray[5]) / 2.0];
+    publicAPI.setXLength(boundsArray[1] - boundsArray[0]);
+    publicAPI.setYLength(boundsArray[3] - boundsArray[2]);
+    publicAPI.setZLength(boundsArray[5] - boundsArray[4]);
+    publicAPI.setCenter([(boundsArray[0] + boundsArray[1]) / 2.0, (boundsArray[2] + boundsArray[3]) / 2.0, (boundsArray[4] + boundsArray[5]) / 2.0]);
   }; // Expose methods
 
 
@@ -247,8 +238,11 @@ var DEFAULT_VALUES = {
   zLength: 1.0,
   center: [0.0, 0.0, 0.0],
   rotations: [0.0, 0.0, 0.0],
+  matrix: _toConsumableArray(IDENTITY),
   pointType: 'Float64Array',
-  generate3DTextureCoordinates: false
+  generate3DTextureCoordinates: false,
+  generateFaces: true,
+  generateLines: false
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
@@ -256,8 +250,17 @@ function extend(publicAPI, model) {
   Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
 
   macro.obj(publicAPI, model);
-  macro.setGet(publicAPI, model, ['xLength', 'yLength', 'zLength', 'generate3DTextureCoordinates']);
+  macro.setGet(publicAPI, model, ['xLength', 'yLength', 'zLength', 'generate3DTextureCoordinates', 'generateFaces', 'generateLines']);
   macro.setGetArray(publicAPI, model, ['center', 'rotations'], 3);
+  macro.setGetArray(publicAPI, model, ['matrix'], 16); // Internal persistent/static objects
+
+  model._polys = vtkCellArray.newInstance({
+    values: Uint16Array.from(POLY_ARRAY)
+  });
+  model._lineCells = vtkCellArray.newInstance({
+    values: Uint16Array.from(LINE_ARRAY)
+  });
+  macro.moveToProtected(publicAPI, model, ['polys', 'lineCells']);
   macro.algo(publicAPI, model, 0, 1);
   vtkCubeSource(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Rendering/Core/ImageCPRMapper.d.ts

@@ -62,6 +62,21 @@ export interface vtkImageCPRMapper extends vtkAbstractMapper3D {
 	 */
 	setUseUniformOrientation(useUniformOrientation: boolean): boolean;
 
+	/**
+	 * A point used to offset each line of pixel in the rendering
+	 * The line of pixel is offseted such as the center of the line is as close as possible to the center point
+	 * This can be used in combination with @see getUseUniformOrientation and a custom distance function for @see getOrientedCenterline to visualize a CPR in projected mode or stretched mode
+	 * Defaults to null.
+	 * @returns the center point
+	 */
+	getCenterPoint(): Nullable<vec3>;
+	
+	/**
+	 * @see getCenterPoint
+	 * @param point
+	 */
+	setCenterPoint(point: Nullable<vec3>): boolean;
+
 	/**
 	 * This flag indicates wether the GPU should use half float or not
 	 * When true, will use half float
@@ -191,6 +206,17 @@ export interface vtkImageCPRMapper extends vtkAbstractMapper3D {
 	 */
 	preRenderCheck(): boolean;
 
+	/**
+	 * Configure the mapper and the centerline to be in straightened CPR mode
+	 */
+	useStraightenedMode(): void;
+
+	/**
+	 * Configure the mapper and the centerline to be in strectched CPR mode
+	 * @param centerPoint The center point, optional, default to the first point of the centerline or [0, 0, 0]
+	 */
+	useStretchedMode(centerPoint?: Nullable<vec3>): void;
+
 	/**
 	 * Set the polydata used as a centerline
 	 * You can also use `publicAPI.setInputData(centerlineData, 1);`
@@ -346,7 +372,10 @@ export function newInstance(initialValues?: IImageCPRMapperInitialValues): vtkIm
 
 /**
  * CPR in vtkImageCPRMapper stands for Curved Planar Reformation. This mapper
- * can be used to visualize tubular structures such as blood vessels.
+ * can be used to visualize tubular structures such as blood vessels. It can be
+ * used in projected mode, stretched mode or straightened mode depending on the
+ * settings @see getUseUniformOrientation , @see getCenterPoint and the distance
+ * function of @see getOrientedCenterline .
  * 
  * This specialised mapper takes as input a vtkImageData representing a volume
  * ( @see setImageData ) and a vtkPolyData representing a centerline

package/Rendering/Core/ImageCPRMapper.js

@@ -293,6 +293,36 @@ function vtkImageCPRMapper(publicAPI, model) {
     return true;
   };
 
+  publicAPI.useStraightenedMode = function () {
+    publicAPI.setCenterPoint(null);
+    publicAPI.setUseUniformOrientation(false);
+    publicAPI.getOrientedCenterline().setDistanceFunction(vec3.dist);
+  };
+
+  publicAPI.useStretchedMode = function (centerPoint) {
+    var centerline = publicAPI.getOrientedCenterline(); // Set center point
+
+    if (!centerPoint) {
+      // Get the first point of the centerline if there is one
+      var centerlinePoints = centerline.getPoints();
+      var newCenterPoint = centerlinePoints.getNumberOfTuples() > 0 ? centerlinePoints.getPoint(0) : [0, 0, 0];
+      publicAPI.setCenterPoint(newCenterPoint);
+    } else {
+      publicAPI.setCenterPoint(centerPoint);
+    } // Enable uniform orientation
+
+
+    publicAPI.setUseUniformOrientation(true); // Change distance function
+
+    centerline.setDistanceFunction(function (a, b) {
+      var direction = publicAPI.getUniformDirection();
+      var vec = vec3.subtract([], a, b);
+      var d2 = vec3.squaredLength(vec);
+      var x = vec3.dot(direction, vec);
+      return Math.sqrt(d2 - x * x);
+    });
+  };
+
   publicAPI.setCenterlineData = function (centerlineData) {
     return publicAPI.setInputData(centerlineData, 1);
   };
@@ -326,6 +356,7 @@ var DEFAULT_VALUES = {
   width: 10,
   uniformOrientation: [0, 0, 0, 1],
   useUniformOrientation: false,
+  centerPoint: null,
   preferSizeOverAccuracy: false,
   orientationArrayName: null,
   tangentDirection: [1, 0, 0],
@@ -345,7 +376,7 @@ function extend(publicAPI, model) {
     mtime: 0
   }); // Setters and getters
 
-  macro.setGet(publicAPI, model, ['width', 'uniformOrientation', 'useUniformOrientation', 'preferSizeOverAccuracy', 'orientationArrayName', 'tangentDirection', 'bitangentDirection', 'normalDirection']);
+  macro.setGet(publicAPI, model, ['width', 'uniformOrientation', 'useUniformOrientation', 'centerPoint', 'preferSizeOverAccuracy', 'orientationArrayName', 'tangentDirection', 'bitangentDirection', 'normalDirection']);
   CoincidentTopologyHelper.implementCoincidentTopologyMethods(publicAPI, model); // Object methods
 
   vtkImageCPRMapper(publicAPI, model);

package/Rendering/OpenGL/ImageCPRMapper.js

@@ -449,14 +449,20 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
   publicAPI.getNeedToRebuildShaders = function (cellBO, ren, actor) {
     // has something changed that would require us to recreate the shader?
     // candidates are
+    // presence of centerPoint
+    // value of useUniformOrientation
     // property modified (representation interpolation and lighting)
     // input modified
     // light complexity changed
     // render pass shader replacement changed
     var tNumComp = model.volumeTexture.getComponents();
     var iComp = actor.getProperty().getIndependentComponents();
+    var useCenterPoint = !!model.renderable.getCenterPoint();
+    var useUniformOrientation = model.renderable.getUseUniformOrientation();
 
-    if (model.lastHaveSeenDepthRequest !== model.haveSeenDepthRequest || cellBO.getProgram() === 0 || model.lastTextureComponents !== tNumComp || model.lastIndependentComponents !== iComp) {
+    if (cellBO.getProgram() === 0 || model.lastUseCenterPoint !== useCenterPoint || model.lastUseUniformOrientation !== useUniformOrientation || model.lastHaveSeenDepthRequest !== model.haveSeenDepthRequest || model.lastTextureComponents !== tNumComp || model.lastIndependentComponents !== iComp) {
+      model.lastUseCenterPoint = useCenterPoint;
+      model.lastUseUniformOrientation = useUniformOrientation;
       model.lastHaveSeenDepthRequest = model.haveSeenDepthRequest;
       model.lastTextureComponents = tNumComp;
       model.lastIndependentComponents = iComp;
@@ -521,6 +527,12 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
       tcoordFSDec.push('in vec3 centerlineTopDirVSOutput;', 'in vec3 centerlineBotDirVSOutput;', 'in float centerlineAngleVSOutput;');
     }
 
+    var centerPoint = model.renderable.getCenterPoint();
+
+    if (centerPoint) {
+      tcoordFSDec.push('uniform vec3 globalCenterPoint;');
+    }
+
     if (iComps) {
       for (var comp = 1; comp < tNumComp; comp++) {
         tcoordFSDec = tcoordFSDec.concat([// color shift and scale
@@ -566,7 +578,13 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
       tcoordFSImpl.push('vec3 interpolatedCenterlineDir;', 'if (centerlineAngleVSOutput < 0.0) {', '  // Lerp', '  interpolatedCenterlineDir = quadOffsetVSOutput.y * centerlineTopDirVSOutput + (1.0 - quadOffsetVSOutput.y) * centerlineBotDirVSOutput;', '} else {', '  // Slerp', '  float topInterpolationAngle = quadOffsetVSOutput.y * centerlineAngleVSOutput;', '  float botInterpolationAngle = centerlineAngleVSOutput - topInterpolationAngle;', '  interpolatedCenterlineDir = sin(topInterpolationAngle) * centerlineTopDirVSOutput + sin(botInterpolationAngle) * centerlineBotDirVSOutput;', '}', '// Slerp should give a normalized vector but when sin(angle) is small, rounding error occurs', '// Normalize for both lerp and slerp', 'interpolatedCenterlineDir = normalize(interpolatedCenterlineDir);');
     }
 
-    tcoordFSImpl.push('vec3 volumePosMC = centerlinePosVSOutput + quadOffsetVSOutput.x * interpolatedCenterlineDir;', 'vec3 volumePosTC = (MCTCMatrix * vec4(volumePosMC, 1.0)).xyz;', 'if (any(lessThan(volumePosTC, vec3(0.0))) || any(greaterThan(volumePosTC, vec3(1.0))))', '{', '  // set the background color and exit', '  gl_FragData[0] = backgroundColor;', '  return;', '}', 'vec4 tvalue = texture(volumeTexture, volumePosTC);');
+    if (centerPoint) {
+      tcoordFSImpl.push('float baseOffset = dot(interpolatedCenterlineDir, globalCenterPoint - centerlinePosVSOutput);', 'float horizontalOffset = quadOffsetVSOutput.x + baseOffset;');
+    } else {
+      tcoordFSImpl.push('float horizontalOffset = quadOffsetVSOutput.x;');
+    }
+
+    tcoordFSImpl.push('vec3 volumePosMC = centerlinePosVSOutput + horizontalOffset * interpolatedCenterlineDir;', 'vec3 volumePosTC = (MCTCMatrix * vec4(volumePosMC, 1.0)).xyz;', 'if (any(lessThan(volumePosTC, vec3(0.0))) || any(greaterThan(volumePosTC, vec3(1.0))))', '{', '  // set the background color and exit', '  gl_FragData[0] = backgroundColor;', '  return;', '}', 'vec4 tvalue = texture(volumeTexture, volumePosTC);');
 
     if (iComps) {
       var rgba = ['r', 'g', 'b', 'a'];
@@ -685,6 +703,11 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     if (cellBO.getProgram().isUniformUsed('centerlineDirection')) {
       var uniformDirection = model.renderable.getUniformDirection();
       cellBO.getProgram().setUniform3fArray('centerlineDirection', uniformDirection);
+    }
+
+    if (cellBO.getProgram().isUniformUsed('globalCenterPoint')) {
+      var centerPoint = model.renderable.getCenterPoint();
+      cellBO.getProgram().setUniform3fArray('globalCenterPoint', centerPoint);
     } // Model coordinates to image space
     // getWorldToIndex is badly named and is in fact modelToIndex
     // MCIC -> Model coordinates to index coordinates

package/Rendering/OpenGL/ImageResliceMapper.js

@@ -3,16 +3,17 @@ import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import { newInstance as newInstance$1, obj, get, vtkErrorMacro as vtkErrorMacro$1 } from '../../macros.js';
 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';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkHelper from './Helper.js';
+import vtkImageDataOutlineFilter from '../../Filters/General/ImageDataOutlineFilter.js';
 import { f as vtkMath } from '../../Common/Core/Math/index.js';
 import vtkOpenGLTexture from './Texture.js';
 import vtkPlane from '../../Common/DataModel/Plane.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkReplacementShaderMapper from './ReplacementShaderMapper.js';
 import vtkShaderProgram from './ShaderProgram.js';
+import vtkTransform from '../../Common/Transform/Transform.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { v as vtkImageResliceMapperVS } from './glsl/vtkImageResliceMapperVS.glsl.js';
 import { v as vtkImageResliceMapperFS } from './glsl/vtkImageResliceMapperFS.glsl.js';
@@ -789,49 +790,6 @@ 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;
@@ -900,8 +858,8 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
         model.resliceGeom.getPointData().setNormals(slicePD.getPointData().getNormals());
       } else if (slicePlane) {
         if (!orthoSlicing) {
-          imageToCubePolyData(image, model.cubePolyData);
-          model.cutter.setInputData(model.cubePolyData);
+          model.outlineFilter.setInputData(image);
+          model.cutter.setInputConnection(model.outlineFilter.getOutputPort());
           model.cutter.setCutFunction(slicePlane);
           model.lineToSurfaceFilter.setInputConnection(model.cutter.getOutputPort());
           model.lineToSurfaceFilter.update();
@@ -952,7 +910,8 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
             }
           }
 
-          transformPoints(ptsArray, image.getIndexToWorld());
+          model.transform.setMatrix(image.getIndexToWorld());
+          model.transform.transformPoints(ptsArray, ptsArray);
           var cellArray = new Uint16Array(8);
           cellArray[0] = 3;
           cellArray[1] = 0;
@@ -1047,10 +1006,13 @@ function extend(publicAPI, model) {
   obj(model.VBOBuildTime);
   model.tmpMat4 = mat4.identity(new Float64Array(16)); // Implicit plane to polydata related cache:
 
-  model.cubeSource = vtkCubeSource.newInstance();
+  model.outlineFilter = vtkImageDataOutlineFilter.newInstance();
+  model.outlineFilter.setGenerateFaces(true);
+  model.outlineFilter.setGenerateLines(false);
   model.cubePolyData = vtkPolyData.newInstance();
   model.cutter = vtkCutter.newInstance();
   model.lineToSurfaceFilter = vtkClosedPolyLineToSurfaceFilter.newInstance();
+  model.transform = vtkTransform.newInstance();
   get(publicAPI, model, ['openGLTexture']); // Object methods
 
   vtkOpenGLImageResliceMapper(publicAPI, model);

package/Widgets/Widgets3D/ResliceCursorWidget/behavior.js

@@ -365,6 +365,10 @@ function widgetBehavior(publicAPI, model) {
     var _manipulator$handleEv3 = manipulator.handleEvent(calldata, model._apiSpecificRenderWindow),
         worldCoords = _manipulator$handleEv3.worldCoords;
 
+    if (!worldCoords || !worldCoords.length) {
+      return;
+    }
+
     var center = model.widgetState.getCenter();
     var currentVectorToOrigin = [0, 0, 0];
     subtract(worldCoords, center, currentVectorToOrigin);

package/index.d.ts

@@ -57,6 +57,7 @@
 /// <reference path="./Filters/General/ClipClosedSurface.d.ts" />
 /// <reference path="./Filters/General/ContourTriangulator.d.ts" />
 /// <reference path="./Filters/General/ImageCropFilter.d.ts" />
+/// <reference path="./Filters/General/ImageDataOutlineFilter.d.ts" />
 /// <reference path="./Filters/General/ImageOutlineFilter.d.ts" />
 /// <reference path="./Filters/General/ImageSliceFilter.d.ts" />
 /// <reference path="./Filters/General/ImageStreamline.d.ts" />

package/package.json

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