@kitware/vtk.js 26.9.13 → 27.0.0

package/Interaction/Style/InteractorStyleImage.d.ts

@@ -0,0 +1,107 @@
+import { Vector2, Vector3 } from './../../types';
+import vtkRenderer from './../../Rendering/Core/Renderer';
+import vtkImageProperty from './../../Rendering/Core/ImageProperty';
+import vtkInteractorStyleTrackballCamera from './InteractorStyleTrackballCamera';
+
+export interface vtkInteractorStyleImage extends vtkInteractorStyleTrackballCamera {
+  /**
+   * Handles a mouse move.
+   * @param callData event data
+   */
+  handleMouseMove(callData: unknown): void;
+
+  /**
+   * Handles a left button press event.
+   * @param callData event data
+   */
+  handleLeftButtonPress(callData: unknown): void;
+
+  /**
+   * Handles a left button release event.
+   * @param callData event data
+   */
+  handleLeftButtonRelease(callData: unknown): void;
+
+  /**
+   * Handles the start of a wheel event.
+   * @param callData event data
+   */
+  handleStartMouseWheel(callData: unknown): void;
+
+  /**
+   * Handles the end of a wheel event.
+   * @param callData event data
+   */
+  handleEndMouseWheel(callData: unknown): void;
+
+  /**
+   * Handles a wheel event.
+   * @param callData event data
+   */
+  handleMouseWheel(callData: unknown): void;
+
+  /**
+   * Set window level from position.
+   * @param renderer the renderer
+   * @param position the display position
+   */
+  windowLevel(renderer: vtkRenderer, position: { x: number, y: number }): void;
+
+  /**
+   * Set slice from position.
+   * @param renderer the renderer
+   * @param position the display position
+   */
+  slice(renderer: vtkRenderer, position: { x: number, y: number }): void;
+
+  /**
+   * Sets the current image property.
+   * 
+   * This is a way of dealing with images as if they were layers.
+   * It looks through the renderer's list of props and sets the
+   * interactor ivars from the Nth image that it finds.  You can
+   * also use negative numbers, i.e. -1 will return the last image,
+   * -2 will return the second-to-last image, etc.
+   * @param i image number
+   */
+  setCurrentImageNumber(i: number): boolean;
+
+  /**
+   * Sets the current image property.
+   * @param imageProperty image property
+   */
+  setCurrentImageProperty(imageProperty: vtkImageProperty): boolean;
+}
+
+export interface IInteractorStyleImageInitialValues {
+  windowLevelStartPosition: Vector2;
+  windowLevelCurrentPosition: Vector2;
+  lastSlicePosition: number;
+  windowLevelInitial: Vector2;
+  // currentImageProperty: null;
+  currentImageNumber: number;
+  interactionMode: 'IMAGE2D' | 'IMAGE3D' | 'IMAGE_SLICING';
+  xViewRightVector: Vector3;
+  xViewUpVector: Vector3;
+  yViewRightVector: Vector3;
+  yViewUpVector: Vector3;
+  zViewRightVector: Vector3;
+  zViewUpVector: Vector3;
+}
+
+export function newInstance(
+  initialValues?: IInteractorStyleImageInitialValues
+): vtkInteractorStyleImage;
+
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IInteractorStyleImageInitialValues
+): void;
+
+export const vtkInteractorStyleImage: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+
+export default vtkInteractorStyleImage;

package/Interaction/Style/InteractorStyleImage.js

@@ -113,6 +113,20 @@ function vtkInteractorStyleImage(publicAPI, model) {
     }
 
     camera.setDistance(distance);
+    var props = callData.pokedRenderer.getViewProps().filter(function (prop) {
+      return prop.isA('vtkImageSlice');
+    });
+    props.forEach(function (prop) {
+      if (prop.getMapper().isA('vtkImageResliceMapper')) {
+        var p = prop.getMapper().getSlicePlane();
+
+        if (p) {
+          p.push(callData.spinY);
+          p.modified();
+          prop.getMapper().modified();
+        }
+      }
+    });
   }; //----------------------------------------------------------------------------
 
 

package/Interaction/Style/InteractorStyleTrackballCamera.d.ts

@@ -0,0 +1,170 @@
+import vtkInteractorStyle from './../../Rendering/Core/InteractorStyle';
+import vtkRenderer from './../../Rendering/Core/Renderer';
+
+export interface vtkInteractorStyleTrackballCamera extends vtkInteractorStyle {
+  /**
+   * Handles a mouse move.
+   * @param callData event data
+   */
+  handleMouseMove(callData: unknown): void;
+
+  /**
+   * Handles a 3D button event.
+   * @param callData event data
+   */
+  handleButton3D(ed: unknown): void;
+
+  /**
+   * Handles a 3D move event.
+   * @param ed event data
+   */
+  handleMove3D(ed: unknown): void;
+
+  /**
+   * Update camera pose
+   * @param ed event data
+   */
+  updateCameraPose(ed: unknown): void;
+
+  /**
+   * Handles a left button press event.
+   * @param callData event data
+   */
+  handleLeftButtonPress(callData: unknown): void;
+
+  /**
+   * Handles a left button release event.
+   * @param callData event data
+   */
+  handleLeftButtonRelease(callData: unknown): void;
+
+  /**
+   * Handles the start of a wheel event.
+   * @param callData event data
+   */
+  handleStartMouseWheel(callData: unknown): void;
+
+  /**
+   * Handles the end of a wheel event.
+   * @param callData event data
+   */
+  handleEndMouseWheel(callData: unknown): void;
+
+  /**
+   * Handles the start of a pinch gesture.
+   * @param callData event data
+   */
+  handleStartPinch(callData: unknown): void;
+
+  /**
+   * Handles the end of a pinch gesture.
+   * @param callData event data
+   */
+  handleEndPinch(callData: unknown): void;
+
+  /**
+   * Handles the start of a rotate gesture.
+   * @param callData event data
+   */
+  handleStartRotate(callData: unknown): void;
+
+  /**
+   * Handles the end of a rotate gesture.
+   * @param callData event data
+   */
+  handleEndRotate(callData: unknown): void;
+
+  /**
+   * Handles the start of a pan gesture.
+   * @param callData event data
+   */
+  handleStartPan(callData: unknown): void;
+
+  /**
+   * Handles the end of a pan gesture.
+   * @param callData event data
+   */
+  handleEndPan(callData: unknown): void;
+
+  /**
+   * Handles a pinch gesture.
+   * @param callData event data
+   */
+  handlePinch(callData: unknown): void;
+
+  /**
+   * Handles a pan gesture.
+   * @param callData event data
+   */
+  handlePan(callData: unknown): void;
+
+  /**
+   * Handles a rotate gesture.
+   * @param callData event data
+   */
+  handleRotate(callData: unknown): void;
+
+  /**
+   * Handles rotate with a mouse.
+   * @param renderer the renderer
+   * @param position the display position
+   */
+  handleMouseRotate(renderer: vtkRenderer, position: { x: number, y: number }): void;
+
+  /**
+   * Handles spin with a mouse.
+   * @param renderer the renderer
+   * @param position the display position
+   */
+  handleMouseSpin(renderer: vtkRenderer, position: { x: number, y: number }): void;
+
+  /**
+   * Handles pan with a mouse.
+   * @param renderer the renderer
+   * @param position the display position
+   */
+  handleMousePan(renderer: vtkRenderer, position: { x: number, y: number }): void;
+
+  /**
+   * Handles dolly with a mouse.
+   * @param renderer the renderer
+   * @param position the display position
+   */
+  handleMouseDolly(renderer: vtkRenderer, position: { x: number, y: number }): void;
+
+  /**
+   * Handles a wheel event.
+   * @param callData event data
+   */
+  handleMouseWheel(callData: unknown): void;
+
+  /**
+   * Dolly by factor.
+   * @param renderer the renderer
+   * @param factor factor
+   */
+  dollyByFactor(renderer: vtkRenderer, factor: number): void;
+}
+
+export interface IInteractorStyleTrackballCameraInitialValues {
+  motionFactor: number;
+  zoomFactor: number;
+}
+
+export function newInstance(
+  initialValues?: IInteractorStyleTrackballCameraInitialValues
+): vtkInteractorStyleTrackballCamera;
+
+
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IInteractorStyleTrackballCameraInitialValues
+): void;
+
+export const vtkInteractorStyleTrackballCamera: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+}
+
+export default vtkInteractorStyleTrackballCamera;

package/Rendering/Core/AbstractImageMapper.d.ts

@@ -1,15 +1,15 @@
-import vtkAbstractMapper, { IAbstractMapperInitialValues } from './AbstractMapper';
+import vtkAbstractMapper3D, { IAbstractMapper3DInitialValues } from './AbstractMapper3D';
 import vtkImageData from './../../Common/DataModel/ImageData';
 import { Nullable } from './../../types';
 
 
-export interface IAbstractImageMapperInitialValues extends IAbstractMapperInitialValues {
+export interface IAbstractImageMapperInitialValues extends IAbstractMapper3DInitialValues {
 	customDisplayExtent?: number[];
 	useCustomExtents?: boolean;
 	slice?: number;
 }
 
-export interface vtkAbstractImageMapper extends vtkAbstractMapper {
+export interface vtkAbstractImageMapper extends vtkAbstractMapper3D {
 
 	/**
 	 *

package/Rendering/Core/AbstractImageMapper.js

@@ -1,5 +1,5 @@
 import macro from '../../macros.js';
-import vtkAbstractMapper from './AbstractMapper.js';
+import vtkAbstractMapper3D from './AbstractMapper3D.js';
 
 // vtkAbstractImageMapper methods
 // ----------------------------------------------------------------------------
@@ -22,16 +22,18 @@ function vtkAbstractImageMapper(publicAPI, model) {
 var DEFAULT_VALUES = {
   slice: 0,
   customDisplayExtent: [0, 0, 0, 0, 0, 0],
-  useCustomExtents: false
+  useCustomExtents: false,
+  backgroundColor: [0, 0, 0, 1]
 }; // ----------------------------------------------------------------------------
 
 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);
+  vtkAbstractMapper3D.extend(publicAPI, model, initialValues);
   macro.setGet(publicAPI, model, ['slice', 'useCustomExtents']);
   macro.setGetArray(publicAPI, model, ['customDisplayExtent'], 6);
+  macro.setGetArray(publicAPI, model, ['backgroundColor'], 4);
   vtkAbstractImageMapper(publicAPI, model);
 } // ----------------------------------------------------------------------------
 

package/Rendering/Core/AbstractMapper3D.js

@@ -1,3 +1,4 @@
+import macro from '../../macros.js';
 import vtkAbstractMapper from './AbstractMapper.js';
 import { u as uninitializeBounds } from '../../Common/Core/Math/index.js';
 
@@ -46,7 +47,8 @@ function vtkAbstractMapper3D(publicAPI, model) {
 
 var DEFAULT_VALUES = {
   bounds: [1, -1, 1, -1, 1, -1],
-  center: [0, 0, 0]
+  center: [0, 0, 0],
+  viewSpecificProperties: null
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
@@ -63,6 +65,12 @@ function extend(publicAPI, model) {
     model.center = [0.0, 0.0, 0.0];
   }
 
+  macro.setGet(publicAPI, model, ['viewSpecificProperties']);
+
+  if (!model.viewSpecificProperties) {
+    model.viewSpecificProperties = {};
+  }
+
   vtkAbstractMapper3D(publicAPI, model);
 } // ----------------------------------------------------------------------------
 

package/Rendering/Core/ImageProperty/Constants.js

@@ -2,8 +2,8 @@ var InterpolationType = {
   NEAREST: 0,
   LINEAR: 1
 };
-var Constants = {
+var InterpolationType$1 = {
   InterpolationType: InterpolationType
 };
 
-export { InterpolationType, Constants as default };
+export { InterpolationType, InterpolationType$1 as default };

package/Rendering/Core/ImageProperty.js

@@ -1,7 +1,7 @@
 import macro from '../../macros.js';
-import Constants from './ImageProperty/Constants.js';
+import InterpolationType$1 from './ImageProperty/Constants.js';
 
-var InterpolationType = Constants.InterpolationType;
+var InterpolationType = InterpolationType$1.InterpolationType;
 var vtkErrorMacro = macro.vtkErrorMacro;
 var VTK_MAX_VRCOMP = 4; // ----------------------------------------------------------------------------
 // vtkImageProperty methods

package/Rendering/Core/ImageResliceMapper/Constants.d.ts

@@ -0,0 +1,11 @@
+export declare enum SlabTypes {
+	MIN = 0,
+	MAX = 1,
+	MEAN = 2,
+	SUM = 3,
+}
+
+declare const _default: {
+	SlabTypes: typeof SlabTypes;
+};
+export default _default;

package/Rendering/Core/ImageResliceMapper/Constants.js

@@ -0,0 +1,11 @@
+var SlabTypes = {
+  MIN: 0,
+  MAX: 1,
+  MEAN: 2,
+  SUM: 3
+};
+var Constants = {
+  SlabTypes: SlabTypes
+};
+
+export { SlabTypes, Constants as default };

package/Rendering/Core/ImageResliceMapper.d.ts

@@ -0,0 +1,245 @@
+import vtkAbstractImageMapper, { IAbstractImageMapperInitialValues } from './AbstractImageMapper';
+import vtkImageData from './../../Common/DataModel/ImageData';
+import vtkPlane from './../../Common/DataModel/Plane';
+import vtkPolyData from './../../Common/DataModel/PolyData';
+import { Bounds, Nullable, Vector3 } from './../../types';
+import { SlabTypes } from './ImageResliceMapper/Constants';
+
+
+interface ICoincidentTopology {
+	factor: number;
+	offset: number;
+}
+
+export interface IImageResliceMapperInitialValues extends IAbstractImageMapperInitialValues {
+	slabThickness?: number;
+	slabTrapezoidIntegration?: number;
+	slabType?: SlabTypes;
+	slicePlane?: vtkPlane;
+	slicePolyData?: vtkPolyData;
+}
+
+export interface vtkImageResliceMapper extends vtkAbstractImageMapper {
+
+	/**
+     * Get the bounds for this mapper as [xmin, xmax, ymin, ymax,zmin, zmax].
+	 * @return {Bounds} The bounds for the mapper.
+	 */
+	getBounds(): Bounds;
+
+	/**
+	 *
+	 */
+	getIsOpaque(): boolean;
+
+	/**
+	 *
+	 */
+	getResolveCoincidentTopology(): ICoincidentTopology
+
+	/**
+	 *
+	 */
+	getResolveCoincidentTopologyAsString(): ICoincidentTopology
+
+	/**
+	 *
+	 */
+	getResolveCoincidentTopologyLineOffsetParameters(): ICoincidentTopology
+
+	/**
+	 *
+	 */
+	getResolveCoincidentTopologyPointOffsetParameters(): ICoincidentTopology
+
+	/**
+	 *
+	 */
+	getResolveCoincidentTopologyPolygonOffsetFaces(): ICoincidentTopology
+
+	/**
+	 *
+	 */
+	getResolveCoincidentTopologyPolygonOffsetParameters(): ICoincidentTopology;
+
+	/**
+	 *
+	 * Get the slab thickness in world space (mm).
+	 */
+	getSlabThickness(): number;
+
+	/**
+	 *
+	 * Get whether slab trapezoid integration is enabled.
+	 */
+	getSlabTrapezoidIntegration(): number;
+
+	/**
+	 *
+	 * Get the slab composite function.
+	 */
+	getSlabType(): boolean;
+
+	/**
+	 *
+	 * Get the implicit plane used to slice the volume with.
+	 */
+	getSlicePlane(): vtkPlane;
+
+	/**
+	 *
+	 * Get the custom polydata used to slice the volume with.
+	 */
+	getSlicePolyData(): vtkPolyData;
+
+	/**
+	 *
+	 * @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;
+
+	/**
+	 *
+	 * 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. 
+	 */
+	setSlabThickness(slabThickness: number): number;
+
+	/**
+	 *
+	 * When a slab thickness larger than 0 is provided, the mapper will composite multile slices
+	 * together using different composite functions based on the slabType. When
+	 * slabTrapezoidIntegration is enabled, the first and the last slices in the slab are weighted at
+	 * half their original intensity for sum and mean slab types.
+	 * @param {Number} slabTrapezoidIntegration Enable/disable trapezoid integration for slab slicing.
+	 * Default: 0
+	 */
+	setSlabTrapezoidIntegration(slabTrapezoidIntegration: number): number;
+
+	/**
+	 *
+	 * When a slab thickness larger than 0 is provided, the mapper will composite multile slices
+	 * together using different composite functions based on the slabType. Available options are max,
+	 * min, mean and sum.
+	 * @param {SlabTypes} slabType The blend function used to composite slab slices.
+	 * Default: SlabTypes.MEAN
+	 */
+	setSlabType(slabType: SlabTypes): boolean;
+
+	/**
+	 *
+	 * The vtkImageResliceMapper provides flexibility in how the reslice source is provided. The user
+	 * can either provide an implicit vtkPlane (defined with its origin and normal), or a custom
+	 * vtkPolyData. When both sources are provided, the mapper chooses the custom polydata over the
+	 * implicit plane. When providing custom polydata as the source, it is required that the polydata
+	 * has point normals for slab slicing. When neither sources are provided, the mapper creates a
+	 * default implicit plane with normal (0, 0, 1) and origin at the mid-point of the volume's Z
+	 * bounds.
+	 * @param {vtkPlane} slicePlane The implicit plane to slice the volume with. Default: null
+	 */
+	setSlicePlane(slicePlane: vtkPlane): vtkPlane;
+
+	/**
+	 *
+	 * The vtkImageResliceMapper provides flexibility in how the reslice source is provided. The user
+	 * can either provide an implicit vtkPlane (defined with its origin and normal), or a custom
+	 * vtkPolyData. When both sources are provided, the mapper chooses the custom polydata over the
+	 * implicit plane. When providing custom polydata as the source, it is required that the polydata
+	 * has point normals for slab slicing. When neither sources are provided, the mapper creates a
+	 * default implicit plane with normal (0, 0, 1) and origin at the mid-point of the volume's Z
+	 * bounds.
+	 * @param {vtkPolyData} slicePolyData The polydata to slice the volume with. Default: null
+	 */
+	setSlicePolyData(slicePolyData: vtkPolyData): vtkPolyData;
+}
+
+/**
+ * Method use to decorate a given object (publicAPI+model) with vtkImageResliceMapper characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IImageResliceMapperInitialValues} [initialValues] (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues?: IImageResliceMapperInitialValues): void;
+
+/**
+ * Method use to create a new instance of vtkImageResliceMapper
+ * @param {IImageResliceMapperInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(initialValues?: IImageResliceMapperInitialValues): vtkImageResliceMapper;
+
+/**
+ * vtkImageResliceMapper provides hardware accelerated slicing of 3D image data / volumes.
+ * 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 vtkImageResliceMapper: {
+	newInstance: typeof newInstance;
+	extend: typeof extend;
+}
+export default vtkImageResliceMapper;