@kitware/vtk.js 26.3.1 → 26.4.0

package/Proxy/Representations/VolumeRepresentationProxy.d.ts

@@ -0,0 +1,44 @@
+import vtkAbstractRepresentationProxy from './../Core/AbstractRepresentationProxy';
+import vtkImageCropFilter from './../../Filters/General/ImageCropFilter';
+
+export interface vtkVolumeRepresentationProxy
+  extends vtkAbstractRepresentationProxy {
+  setIs2DVolume(is2D: boolean): void;
+  getIs2DVolume(): boolean;
+  isVisible(): boolean;
+  setVisibility(visible: boolean): void;
+  getVisibility(): boolean;
+  setSliceVisibility(isVisible: boolean): void;
+  getSliceVisibility(): boolean;
+  setSampleDistance(samp: number): void;
+  getSampleDistance(): number;
+  setEdgeGradient(grad: number): void;
+  getEdgeGradient(): number;
+  getCropFilter(): vtkImageCropFilter;
+
+  // proxy property mappings
+  getXSlice(): number;
+  setXSlice(slice: number): boolean;
+  getYSlice(): number;
+  setYSlice(slice: number): boolean;
+  getZSlice(): number;
+  setZSlice(slice: number): boolean;
+  getVolumeVisibility(): boolean;
+  setVolumeVisibility(visible: boolean): boolean;
+  getXSliceVisibility(): boolean;
+  setXSliceVisibility(visible: boolean): boolean;
+  getYSliceVisibility(): boolean;
+  setYSliceVisibility(visible: boolean): boolean;
+  getZSliceVisibility(): boolean;
+  setZSliceVisibility(visible: boolean): boolean;
+  getWindowWidth(): number;
+  setWindowWidth(width: number): boolean;
+  getWindowLevel(): number;
+  setWindowLevel(level: number): boolean;
+  getUseShadow(): boolean;
+  setUseShadow(useShadow: boolean): boolean;
+  getCroppingPlanes(): number[];
+  setCroppingPlanes(planes: number[]): boolean;
+}
+
+export default vtkVolumeRepresentationProxy;

package/Rendering/Core/AbstractImageMapper/helper.js

@@ -0,0 +1,127 @@
+import { vec3 } from 'gl-matrix';
+import vtkPlane from '../../../Common/DataModel/Plane.js';
+
+/**
+ * Perform plane-line intersection, where the line is defined by two points (p1, p2),
+ * and the plane is defined by the imageData and slice number.
+ *
+ * @param {Vector3} p1
+ * @param {Vector3} p2
+ * @param {vtkImageMapper|vtkImageArrayMapper} mapper
+ */
+
+function doPicking(p1, p2, mapper) {
+  var imageData = mapper.getCurrentImage();
+  var extent = imageData.getExtent(); // Slice origin
+
+  var ijk = [extent[0], extent[2], extent[4]];
+
+  var _mapper$getClosestIJK = mapper.getClosestIJKAxis(),
+      ijkMode = _mapper$getClosestIJK.ijkMode;
+
+  var nSlice = mapper.isA('vtkImageArrayMapper') ? mapper.getSubSlice() : mapper.getSlice();
+
+  if (ijkMode !== mapper.getSlicingMode()) {
+    // If not IJK slicing, get the IJK slice from the XYZ position/slice
+    nSlice = mapper.getSliceAtPosition(nSlice);
+  }
+
+  ijk[ijkMode] += nSlice;
+  var worldOrigin = [0, 0, 0];
+  imageData.indexToWorld(ijk, worldOrigin); // Normal computation
+
+  ijk[ijkMode] += 1;
+  var worldNormal = [0, 0, 0];
+  imageData.indexToWorld(ijk, worldNormal);
+  worldNormal[0] -= worldOrigin[0];
+  worldNormal[1] -= worldOrigin[1];
+  worldNormal[2] -= worldOrigin[2];
+  vec3.normalize(worldNormal, worldNormal);
+  var intersect = vtkPlane.intersectWithLine(p1, p2, worldOrigin, worldNormal);
+
+  if (intersect.intersection) {
+    var point = intersect.x;
+    var absoluteIJK = [0, 0, 0];
+    imageData.worldToIndex(point, absoluteIJK); // `t` is the parametric position along the line
+    // defined in Plane.intersectWithLine
+
+    return {
+      t: intersect.t,
+      absoluteIJK: absoluteIJK
+    };
+  }
+
+  return null;
+}
+/**
+ * Implement point picking for image plane.
+ * The plane is defined by the imageData and current slice number,
+ * set in the input mapper.
+ *
+ * @param {Vector3} p1
+ * @param {Vector3} p2
+ * @param {vtkImageMapper|vtkImageArrayMapper} mapper
+ */
+
+
+function intersectWithLineForPointPicking(p1, p2, mapper) {
+  var pickingData = doPicking(p1, p2, mapper);
+
+  if (pickingData) {
+    var imageData = mapper.getCurrentImage();
+    var extent = imageData.getExtent(); // Get closer integer ijk
+    // NB: point picking means closest slice, means rounding
+
+    var ijk = [Math.round(pickingData.absoluteIJK[0]), Math.round(pickingData.absoluteIJK[1]), Math.round(pickingData.absoluteIJK[2])]; // Are we outside our actual extent
+
+    if (ijk[0] < extent[0] || ijk[0] > extent[1] || ijk[1] < extent[2] || ijk[1] > extent[3] || ijk[2] < extent[4] || ijk[2] > extent[5]) {
+      return null;
+    }
+
+    return {
+      t: pickingData.t,
+      ijk: ijk
+    };
+  }
+
+  return null;
+}
+/**
+ * Implement cell picking for image plane.
+ * The plane is defined by the imageData and current slice number,
+ * set in the input mapper.
+ *
+ * @param {Vector3} p1
+ * @param {Vector3} p2
+ * @param {vtkImageMapper|vtkImageArrayMapper} mapper
+ */
+
+function intersectWithLineForCellPicking(p1, p2, mapper) {
+  var pickingData = doPicking(p1, p2, mapper);
+
+  if (pickingData) {
+    var imageData = mapper.getCurrentImage();
+    var extent = imageData.getExtent();
+    var absIJK = pickingData.absoluteIJK; // Get closer integer ijk
+    // NB: cell picking means closest voxel, means flooring
+
+    var ijk = [Math.floor(absIJK[0]), Math.floor(absIJK[1]), Math.floor(absIJK[2])]; // Are we outside our actual extent
+
+    if (ijk[0] < extent[0] || ijk[0] > extent[1] - 1 || ijk[1] < extent[2] || ijk[1] > extent[3] - 1 || ijk[2] < extent[4] || // handle single-slice images
+    ijk[2] > (extent[5] ? extent[5] - 1 : extent[5])) {
+      return null;
+    } // Parametric coordinates within cell
+
+
+    var pCoords = [absIJK[0] - ijk[0], absIJK[1] - ijk[1], absIJK[2] - ijk[2]];
+    return {
+      t: pickingData.t,
+      ijk: ijk,
+      pCoords: pCoords
+    };
+  }
+
+  return null;
+}
+
+export { intersectWithLineForCellPicking, intersectWithLineForPointPicking };

package/Rendering/Core/AbstractImageMapper.d.ts

@@ -0,0 +1,82 @@
+import vtkAbstractMapper, { IAbstractMapperInitialValues } from './AbstractMapper';
+import vtkImageData from './../../Common/DataModel/ImageData';
+import { Nullable } from './../../types';
+
+
+export interface IAbstractImageMapperInitialValues extends IAbstractMapperInitialValues {
+	customDisplayExtent?: number[];
+	useCustomExtents?: boolean;
+	slice?: number;
+}
+
+export interface vtkAbstractImageMapper extends vtkAbstractMapper {
+
+	/**
+	 *
+	 */
+	getIsOpaque(): boolean;
+
+	/**
+  	 * Return currently active image for the mapper. Overridden by deriving classes.
+	 */
+	getCurrentImage(): Nullable<vtkImageData>;
+
+	/**
+	 * Get the slice index.
+	 */
+	getSlice(): number;
+
+	/**
+	 *
+	 * @param {Number} slice The slice index.
+	 */
+	setSlice(slice: number): boolean;
+
+	/**
+	 *
+	 */
+	getUseCustomExtents(): boolean;
+
+	/**
+	 *
+	 * @param {Boolean} useCustomExtents
+	 */
+	setUseCustomExtents(useCustomExtents: boolean): boolean;
+
+	/**
+	 *
+	 * @param {Number} x1 The x coordinate of the first point.
+	 * @param {Number} x2 The x coordinate of the second point.
+	 * @param {Number} y1 The y coordinate of the first point.
+	 * @param {Number} y2 The y coordinate of the second point.
+	 * @param {Number} z1 The z coordinate of the first point.
+	 * @param {Number} z2 The z coordinate of the second point.
+	 */
+	setCustomDisplayExtent(x1: number, x2: number, y1: number, y2: number, z1: number, z2: number): boolean;
+
+	/**
+	 *
+	 * @param customDisplayExtent
+	 */
+	setCustomDisplayExtentFrom(customDisplayExtent: number[]): boolean;
+}
+
+/**
+ * Method use to decorate a given object (publicAPI+model) with vtkAbstractImageMapper characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IAbstractImageMapperInitialValues} [initialValues] (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues?: IAbstractImageMapperInitialValues): void;
+
+/**
+ * vtkImageMapper provides 2D image display support for vtk.
+ * It can be associated with a vtkImageSlice prop and placed within a Renderer.
+ *
+ * This class resolves coincident topology with the same methods as vtkMapper.
+ */
+export declare const vtkAbstractImageMapper: {
+	extend: typeof extend;
+}
+export default vtkAbstractImageMapper;

package/Rendering/Core/AbstractImageMapper.js

@@ -0,0 +1,42 @@
+import macro from '../../macros.js';
+import vtkAbstractMapper from './AbstractMapper.js';
+
+// vtkAbstractImageMapper methods
+// ----------------------------------------------------------------------------
+
+function vtkAbstractImageMapper(publicAPI, model) {
+  model.classHierarchy.push('vtkAbstractImageMapper');
+
+  publicAPI.getIsOpaque = function () {
+    return true;
+  };
+
+  publicAPI.getCurrentImage = function () {
+    return null;
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {
+  slice: 0,
+  customDisplayExtent: [0, 0, 0, 0, 0, 0],
+  useCustomExtents: false
+}; // ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+
+  vtkAbstractMapper.extend(publicAPI, model, initialValues);
+  macro.setGet(publicAPI, model, ['slice', 'useCustomExtents']);
+  macro.setGetArray(publicAPI, model, ['customDisplayExtent'], 6);
+  vtkAbstractImageMapper(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var vtkAbstractImageMapper$1 = {
+  extend: extend
+};
+
+export { vtkAbstractImageMapper$1 as default, extend };

package/Rendering/Core/CellPicker.js

@@ -180,7 +180,7 @@ function vtkCellPicker(publicAPI, model) {
       return Number.MAX_VALUE;
     }
 
-    if (mapper.isA('vtkImageMapper')) {
+    if (mapper.isA('vtkImageMapper') || mapper.isA('vtkImageArrayMapper')) {
       var pickData = mapper.intersectWithLineForCellPicking(p1, p2);
 
       if (pickData) {

package/Rendering/Core/ImageArrayMapper.d.ts

@@ -0,0 +1,252 @@
+import vtkAbstractImageMapper, { IAbstractImageMapperInitialValues } from './AbstractImageMapper';
+import IClosestIJKAxis from './ImageMapper';
+import { Bounds, Nullable } from './../../types';
+import { SlicingMode } from './ImageMapper/Constants';
+import vtkImageData from './../../Common/DataModel/ImageData';
+import vtkCollection from './../../Common/DataModel/Collection';
+
+
+interface ICoincidentTopology {
+	factor: number;
+	offset: number;
+}
+
+interface ISliceToSubSlice {
+	imageIndex: number;
+	subSlice: number;
+}
+
+export interface IImageArrayMapperInitialValues extends IAbstractImageMapperInitialValues {
+  	slicingMode: SlicingMode.K,
+  	sliceToSubSliceMap: ISliceToSubSlice[],
+}
+
+export interface vtkImageArrayMapper extends vtkAbstractImageMapper {
+
+	/**
+	 * 
+	 * @param inputData set input as a vtkCollection of vtkImageData objects.
+	 */
+	setInputData(inputData: vtkCollection): void;
+
+	/**
+	 *  Get vtkImageData corresponding to the provided (global) slice number.
+	 * @param slice (global) slice number. If a slice number is not provided,
+	 * the function uses the current slice number (i.e. the output of getSlice()).
+	 */
+	getImage(slice?: number): Nullable<vtkImageData>;
+
+	/**
+  	 * Return currently active image. This depends on the currently active slice number.
+	 */
+	getCurrentImage(): Nullable<vtkImageData>;
+
+	/**
+     * Get the bounds for this mapper as [xmin, xmax, ymin, ymax,zmin, zmax].
+	 * @return {Bounds} The bounds for the mapper.
+	 */
+	getBounds(): Bounds;
+
+	/**
+	 * Get the bounds for a given slice as [xmin, xmax, ymin, ymax,zmin, zmax].
+	 * @param {Number} [slice] The slice index.
+	 * @param {Number} [halfThickness] Half the slice thickness in index space (unit voxel spacing).
+	 * @return {Number[]} The bounds for a given slice.
+	 */
+	getBoundsForSlice(slice?: number, halfThickness?: number): number[];
+
+	/**
+	 * Get the closest IJK axis
+	 * @return {IClosestIJKAxis} The axis object.
+	 */
+	getClosestIJKAxis(): IClosestIJKAxis;
+
+	/**
+	 * Calculate the total number of slices in the input collection.
+	 */
+	computeTotalSlices(): number;
+
+	/**
+	 * Fetch the pre-calculated total number of slices in the input collection.
+	 */
+	getTotalSlices(): number;
+
+	/**
+	 *
+	 * @param {Number} slice The slice index.
+	 */
+	setSlice(slice: number): boolean;
+
+	/**
+	 * Calculate the global slice number that corresponds to the provided image and subSlice number.
+	 * The global slice number corresponds to the total number of 2D image frames that a collection has.
+	 * @param imageIndex The image number is the index of the vtkImageData object in the input collection.
+	 * @param subSlice The subSlice number is the k-index of a slice within a vtkImageData object in the input collection.
+	 */
+	computeSlice(imageIndex: number, subSlice: number): number;
+
+	/**
+	 * Get the vtkImageData index corresponding to the provided global slice number.
+	 * @param slice global slice number. If a slice number is not provided,
+	 * the function uses the current slice number (i.e. the output of getSlice()).
+	 */
+	getImageIndex(slice?: number): number;
+
+	/**
+	 * Given a global slice number, identify the subSlice number (slice k-index within a vtkImageData).
+	 * @param slice global slice number. If a slice number is not provided,
+	 * the function uses the current slice number (i.e. the output of getSlice()).
+	 */
+	getSubSlice(slice?: number): number;
+
+
+	/**
+	 *
+	 */
+	getResolveCoincidentTopology(): ICoincidentTopology
+
+	/**
+	 *
+	 */
+	getResolveCoincidentTopologyAsString(): ICoincidentTopology
+
+	/**
+	 *
+	 */
+	getResolveCoincidentTopologyLineOffsetParameters(): ICoincidentTopology
+
+	/**
+	 *
+	 */
+	getResolveCoincidentTopologyPointOffsetParameters(): ICoincidentTopology
+
+	/**
+	 *
+	 */
+	getResolveCoincidentTopologyPolygonOffsetFaces(): ICoincidentTopology
+
+	/**
+	 *
+	 */
+	getResolveCoincidentTopologyPolygonOffsetParameters(): ICoincidentTopology;
+
+	/**
+	 *
+	 * @param {Number} factor 
+	 * @param {Number} offset 
+	 */
+	setRelativeCoincidentTopologyLineOffsetParameters(factor: number, offset: number): boolean;
+
+	/**
+	 *
+	 * @param {Number} factor 
+	 * @param {Number} offset 
+	 */
+	setRelativeCoincidentTopologyPointOffsetParameters(factor: number, offset: number): boolean;
+
+	/**
+	 *
+	 * @param {Number} factor 
+	 * @param {Number} offset 
+	 */
+	setRelativeCoincidentTopologyPolygonOffsetParameters(factor: number, offset: number): boolean;
+
+	/**
+	 *
+	 * @param resolveCoincidentTopology
+	 * @default false
+	 */
+	setResolveCoincidentTopology(resolveCoincidentTopology: boolean): boolean;
+
+	/**
+	 *
+	 * @param {Number} factor 
+	 * @param {Number} offset 
+	 */
+	setResolveCoincidentTopologyLineOffsetParameters(factor: number, offset: number): boolean;
+
+	/**
+	 *
+	 * @param {Number} factor 
+	 * @param {Number} offset 
+	 */
+	setResolveCoincidentTopologyPointOffsetParameters(factor: number, offset: number): boolean;
+
+	/**
+	 *
+	 * @param value
+	 */
+	setResolveCoincidentTopologyPolygonOffsetFaces(value: number): boolean;
+
+	/**
+	 *
+	 * @param {Number} factor 
+	 * @param {Number} offset 
+	 */
+	setResolveCoincidentTopologyPolygonOffsetParameters(factor: number, offset: number): boolean;
+
+	/**
+	 *
+	 */
+	setResolveCoincidentTopologyToDefault(): boolean;
+
+	/**
+	 *
+	 */
+	setResolveCoincidentTopologyToOff(): boolean;
+
+	/**
+	 *
+	 */
+	setResolveCoincidentTopologyToPolygonOffset(): boolean;
+
+	/**
+	 * Set the slicing mode. 
+	 * @param {Number} mode The slicing mode.
+	 */
+	setSlicingMode(mode: number): boolean;
+
+	/**
+	 *
+	 * @param {Number[]} p1 The coordinates of the first point.
+	 * @param {Number[]} p2 The coordinates of the second point.
+	 */
+	intersectWithLineForPointPicking(p1: number[], p2: number[]): any;
+
+	/**
+	 *
+	 * @param {Number[]} p1 The coordinates of the first point.
+	 * @param {Number[]} p2 The coordinates of the second point.
+	 */
+	intersectWithLineForCellPicking(p1: number[], p2: number[]): any;
+}
+
+/**
+ * Method use to decorate a given object (publicAPI+model) with vtkImageArrayMapper characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IImageArrayMapperInitialValues} [initialValues] (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues?: IImageArrayMapperInitialValues): void;
+
+/**
+ * Method use to create a new instance of vtkImageArrayMapper
+ * @param {IImageArrayMapperInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(initialValues?: IImageArrayMapperInitialValues): vtkImageArrayMapper;
+
+/**
+ * vtkImageArrayMapper provides display support for a collection of single/multi-frame images.
+ * Images can have variable dimensions (width, height, depth in pixels), can be mixture of
+ * color (RGB) and grayscale images, origin point and direction cosines.
+ * It can be associated with a vtkImageSlice prop and placed within a Renderer.
+ *
+ * This class resolves coincident topology with the same methods as vtkMapper.
+ */
+export declare const vtkImageArrayMapper: {
+	newInstance: typeof newInstance;
+	extend: typeof extend;
+	SlicingMode: typeof SlicingMode;
+}
+export default vtkImageArrayMapper;