@kitware/vtk.js 26.9.14 → 27.1.0

package/Interaction/Style/InteractorStyleImage.js

@@ -55,8 +55,13 @@ function vtkInteractorStyleImage(publicAPI, model) {
 
       publicAPI.startWindowLevel();
     } else if (model.interactionMode === 'IMAGE3D' && callData.shiftKey) {
-      // If shift is held down, do a rotation
-      publicAPI.startRotate();
+      // If ctrl+shift or alt+shift is held down, dolly the camera
+      if (callData.controlKey || callData.altKey) {
+        publicAPI.startDolly();
+      } else {
+        // If shift is held down, rotate
+        publicAPI.startRotate();
+      }
     } else if (model.interactionMode === 'IMAGE_SLICING' && callData.controlKey) {
       // If ctrl is held down in slicing mode, slice the image
       model.lastSlicePosition = pos.y;
@@ -113,6 +118,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/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;

package/Rendering/Core/ImageResliceMapper.js

@@ -0,0 +1,70 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.js';
+import Constants from './ImageResliceMapper/Constants.js';
+import macro from '../../macros.js';
+import vtkAbstractImageMapper from './AbstractImageMapper.js';
+import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var SlabTypes = Constants.SlabTypes;
+var staticOffsetAPI = CoincidentTopologyHelper.staticOffsetAPI,
+    otherStaticMethods = CoincidentTopologyHelper.otherStaticMethods; // ----------------------------------------------------------------------------
+// vtkImageResliceMapper methods
+// ----------------------------------------------------------------------------
+
+function vtkImageResliceMapper(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkImageResliceMapper');
+
+  publicAPI.getBounds = function () {
+    var bds = _toConsumableArray(vtkBoundingBox.INIT_BOUNDS);
+
+    var image = publicAPI.getInputData();
+
+    if (publicAPI.getSlicePolyData()) {
+      bds = publicAPI.getSlicePolyData().getBounds();
+    } else if (image) {
+      bds = image.getBounds();
+
+      if (publicAPI.getSlicePlane()) {
+        vtkBoundingBox.cutWithPlane(bds, publicAPI.getSlicePlane().getOrigin(), publicAPI.getSlicePlane().getNormal());
+      }
+    }
+
+    return bds;
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {
+  slabThickness: 0.0,
+  slabTrapezoidIntegration: 0,
+  slabType: SlabTypes.MEAN,
+  slicePlane: null,
+  slicePolyData: null
+}; // ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+
+  vtkAbstractImageMapper.extend(publicAPI, model, initialValues);
+  macro.setGet(publicAPI, model, ['slabThickness', 'slabTrapezoidIntegration', 'slabType', 'slicePlane', 'slicePolyData']);
+  CoincidentTopologyHelper.implementCoincidentTopologyMethods(publicAPI, model); // Object methods
+
+  vtkImageResliceMapper(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkImageResliceMapper'); // ----------------------------------------------------------------------------
+
+var vtkImageResliceMapper$1 = _objectSpread(_objectSpread({
+  newInstance: newInstance,
+  extend: extend
+}, staticOffsetAPI), otherStaticMethods);
+
+export { vtkImageResliceMapper$1 as default, extend, newInstance };

package/Rendering/Core/Mapper.js

@@ -553,7 +553,6 @@ var DEFAULT_VALUES = {
   forceCompileOnly: 0,
   useInvertibleColors: false,
   invertibleScalars: null,
-  viewSpecificProperties: null,
   customShaderAttributes: []
 }; // ----------------------------------------------------------------------------
 
@@ -563,14 +562,9 @@ function extend(publicAPI, model) {
 
   vtkAbstractMapper3D.extend(publicAPI, model, initialValues);
   macro.get(publicAPI, model, ['colorCoordinates', 'colorMapColors', 'colorTextureMap']);
-  macro.setGet(publicAPI, model, ['colorByArrayName', 'arrayAccessMode', 'colorMode', 'fieldDataTupleId', 'interpolateScalarsBeforeMapping', 'lookupTable', 'populateSelectionSettings', 'renderTime', 'scalarMode', 'scalarVisibility', 'selectionWebGLIdsToVTKIds', 'static', 'useLookupTableScalarRange', 'viewSpecificProperties', 'customShaderAttributes' // point data array names that will be transferred to the VBO
+  macro.setGet(publicAPI, model, ['colorByArrayName', 'arrayAccessMode', 'colorMode', 'fieldDataTupleId', 'interpolateScalarsBeforeMapping', 'lookupTable', 'populateSelectionSettings', 'renderTime', 'scalarMode', 'scalarVisibility', 'selectionWebGLIdsToVTKIds', 'static', 'useLookupTableScalarRange', 'customShaderAttributes' // point data array names that will be transferred to the VBO
   ]);
   macro.setGetArray(publicAPI, model, ['scalarRange'], 2);
-
-  if (!model.viewSpecificProperties) {
-    model.viewSpecificProperties = {};
-  }
-
   CoincidentTopologyHelper.implementCoincidentTopologyMethods(publicAPI, model); // Object methods
 
   vtkMapper(publicAPI, model);

package/Rendering/Core.js

@@ -17,6 +17,7 @@ import vtkGlyph3DMapper from './Core/Glyph3DMapper.js';
 import vtkHardwareSelector from './Core/HardwareSelector.js';
 import vtkImageMapper from './Core/ImageMapper.js';
 import vtkImageProperty from './Core/ImageProperty.js';
+import vtkImageResliceMapper from './Core/ImageResliceMapper.js';
 import vtkImageSlice from './Core/ImageSlice.js';
 import vtkInteractorObserver from './Core/InteractorObserver.js';
 import vtkInteractorStyle from './Core/InteractorStyle.js';
@@ -66,6 +67,7 @@ var Core = {
   vtkHardwareSelector: vtkHardwareSelector,
   vtkImageMapper: vtkImageMapper,
   vtkImageProperty: vtkImageProperty,
+  vtkImageResliceMapper: vtkImageResliceMapper,
   vtkImageSlice: vtkImageSlice,
   vtkInteractorObserver: vtkInteractorObserver,
   vtkInteractorStyle: vtkInteractorStyle,

package/Rendering/OpenGL/ImageMapper.js

@@ -104,17 +104,6 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     publicAPI.renderPiece(ren, actor);
   };
 
-  publicAPI.buildShaders = function (shaders, ren, actor) {
-    publicAPI.getShaderTemplate(shaders, ren, actor);
-    model.lastRenderPassShaderReplacement = model.currentRenderPass ? model.currentRenderPass.getShaderReplacement() : null; // apply any renderPassReplacements
-
-    if (model.lastRenderPassShaderReplacement) {
-      model.lastRenderPassShaderReplacement(shaders);
-    }
-
-    publicAPI.replaceShaderValues(shaders, ren, actor);
-  };
-
   publicAPI.getShaderTemplate = function (shaders, ren, actor) {
     shaders.Vertex = vtkPolyDataVS;
     shaders.Fragment = vtkPolyDataFS;
@@ -875,6 +864,7 @@ function extend(publicAPI, model) {
 
   vtkViewNode.extend(publicAPI, model, initialValues);
   vtkReplacementShaderMapper.implementReplaceShaderCoincidentOffset(publicAPI, model, initialValues);
+  vtkReplacementShaderMapper.implementBuildShadersWithReplacements(publicAPI, model, initialValues);
   model.tris = vtkHelper.newInstance();
   model.openGLTexture = vtkOpenGLTexture.newInstance({
     resizable: true