@kitware/vtk.js 33.2.0 → 34.0.0-beta.1

package/BREAKING_CHANGES.md

@@ -1,3 +1,13 @@
+## From 33.x to 34
+
+- **vtkMapper**: many properties have moved to `vtkVolumeProperty`. The full list of changed methods is: `getAnisotropy`, `getComputeNormalFromOpacity`, `getFilterMode`, `getFilterModeAsString`, `getGlobalIlluminationReach`, `getIpScalarRange`, `getIpScalarRangeByReference`, `getLAOKernelRadius`, `getLAOKernelSize`, `getLocalAmbientOcclusion`, `getPreferSizeOverAccuracy`, `getVolumetricScatteringBlending`, `setAnisotropy`, `setAverageIPScalarRange`, `setComputeNormalFromOpacity`, `setFilterMode`, `setFilterModeToNormalized`, `setFilterModeToOff`, `setFilterModeToRaw`, `setGlobalIlluminationReach`, `setIpScalarRange`, `setIpScalarRangeFrom`, `setLAOKernelRadius`, `setLAOKernelSize`, `setLocalAmbientOcclusion`, `setPreferSizeOverAccuracy`, `setVolumetricScatteringBlending`.
+- **vtkRenderWindowInteractor**: KeyPress, KeyDown and KeyUp events are now observed on the container and no longer on the document. "tabIndex=0" is now automatically added on RWI containers to give focus on your render windows and catch key events. Check the KeyPressEvents example for usage.
+- **vtkOpenGLTexture**: The public `create2D*` and `create3D*` methods used to have positional parameters. These methods now use named parameters via passing in an object record.
+
+## From 32.x to 33
+
+- **vtkColorTransferFunction**, **vtkMapper**: Previous log scaling was disabled but functionality is now quite different from what it maybe was before it was disabled. ColorTransfer function now maps the model.nodes in logarithmic scales so there's an even spacing between powers of ten.
+
 ## From 31.x to 32
 
 - **vtkMapper**: remove `mapScalarsToTexture` from the public API. The function becomes protected and its API changes. This shouldn't cause any issue in most cases.

package/Interaction/Manipulators/KeyboardCameraManipulator.d.ts

@@ -0,0 +1,113 @@
+import { Vector3 } from './../../types';
+import { vtkObject } from './../../interfaces';
+import vtkCompositeKeyboardManipulator from './CompositeKeyboardManipulator';
+import vtkRenderWindowInteractor from './../../Rendering/Core/RenderWindowInteractor';
+import vtkCamera from './../../Rendering/Core/Camera';
+import vtkRenderer from './../../Rendering/Core/Renderer';
+
+export interface vtkKeyboardCameraManipulator
+  extends vtkObject,
+    vtkCompositeKeyboardManipulator {
+  /**
+   * Returns whether a movement is ongoing.
+   */
+  inMotion(): boolean;
+
+  /**
+   * Reset the movement speed to be proportional to the longest length of the renderer's bounds.
+   */
+  resetMovementSpeed(): void;
+
+  /**
+   * Initialize a movement of the current camera.
+   */
+  startMovement(): void;
+
+  /**
+   * Cancel any ongoing camera movement.
+   */
+  endMovement(): void;
+
+  /**
+   * Update active camera direction, depending on currently pressed keys.
+   */
+  calculateCurrentDirection(): void;
+
+  /**
+   * Returns the direction vector of the given camera for the given key.
+   * @param key the movedkey
+   * @param camera the camera
+   */
+  getDirectionFromKey(key: KeyboardEvent['key'], camera: vtkCamera): Vector3;
+
+  /**
+   * Moves the given camera, in the given direction, at the given speed.
+   * @param camera the moved camera
+   * @param direction the direction of the movemnt
+   * @param speed the speed
+   */
+  moveCamera(camera: vtkCamera, direction: Vector3, speed: number): void;
+
+  /**
+   * Handles a keypress event.
+   * @param interactor the interactor
+   * @param renderer the renderer
+   * @param key the key
+   */
+  onKeyPress(
+    interactor: vtkRenderWindowInteractor,
+    renderer: vtkRenderer,
+    key: KeyboardEvent['key']
+  ): void;
+
+  /**
+   * Handles a keydown event.
+   * @param interactor the interactor
+   * @param renderer the renderer
+   * @param key the key
+   */
+  onKeyDown(
+    interactor: vtkRenderWindowInteractor,
+    renderer: vtkRenderer,
+    key: KeyboardEvent['key']
+  ): void;
+
+  /**
+   * Handles a keyup event.
+   * @param interactor the interactor
+   * @param renderer the renderer
+   * @param key the key
+   */
+  onKeyUp(
+    interactor: vtkRenderWindowInteractor,
+    renderer: vtkRenderer,
+    key: KeyboardEvent['key']
+  ): void;
+}
+
+export interface IKeyboardCameraManipulatorInitialValues {
+  movementSpeed?: number;
+  moveForwardKeys?: KeyboardEvent['key'][];
+  moveLeftKeys?: KeyboardEvent['key'][];
+  moveBackwardKeys?: KeyboardEvent['key'][];
+  moveRightKeys?: KeyboardEvent['key'][];
+  moveUpKeys?: KeyboardEvent['key'][];
+  moveDownKeys?: KeyboardEvent['key'][];
+}
+
+export function newInstance(
+  initialValues?: IKeyboardCameraManipulatorInitialValues
+): vtkKeyboardCameraManipulator;
+
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IKeyboardCameraManipulatorInitialValues
+): void;
+
+export const vtkKeyboardCameraManipulator: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+
+export default vtkKeyboardCameraManipulator;

package/Rendering/Core/Actor.d.ts

@@ -36,12 +36,6 @@ export interface vtkActor extends vtkProp3D {
    */
   getBackfaceProperty(): vtkProperty;
 
-  /**
-   * Get the bounds for this mapper as [xmin, xmax, ymin, ymax,zmin, zmax].
-   * @return {Bounds} The bounds for the mapper.
-   */
-  getBounds(): Bounds;
-
   /**
    * Check whether the opaque is forced or not.
    */
@@ -63,16 +57,6 @@ export interface vtkActor extends vtkProp3D {
    */
   getMapper(): Nullable<vtkMapper>;
 
-  /**
-   * Get the property object that controls this actors surface
-   * properties. This should be an instance of a vtkProperty object. Every
-   * actor must have a property associated with it. If one isn’t specified,
-   * then one will be generated automatically. Multiple actors can share one
-   * property object.
-   * @return {vtkProperty} The property object
-   */
-  getProperty(): vtkProperty;
-
   /**
    * Check whether if the actor supports selection
    * @return {Boolean} true if the actor support selection.
@@ -111,11 +95,12 @@ export interface vtkActor extends vtkProp3D {
    */
   setMapper(mapper: vtkMapper): boolean;
 
-  /**
-   * Set the property object that controls this actors surface properties.
-   * @param {vtkProperty} property The vtkProperty instance.
-   */
+  // Inherited from vtkProp3D, but takes a vtkProperty instead of a generic vtkObject
+  getProperty(mapperInputPort?: number): vtkProperty;
+  getProperties(): vtkProperty[];
+  setProperty(mapperInputPort: number, property: vtkProperty): boolean;
   setProperty(property: vtkProperty): boolean;
+  setProperties(properties: vtkProperty[]): boolean;
 }
 
 /**

package/Rendering/Core/Actor.js

@@ -1,13 +1,7 @@
-import { mat4, vec3 } from 'gl-matrix';
 import { m as macro } from '../../macros2.js';
-import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkProp3D from './Prop3D.js';
 import vtkProperty from './Property.js';
 
-const {
-  vtkDebugMacro
-} = macro;
-
 // ----------------------------------------------------------------------------
 // vtkActor methods
 // ----------------------------------------------------------------------------
@@ -29,11 +23,11 @@ function vtkActor(publicAPI, model) {
       return false;
     }
     // make sure we have a property
-    if (!model.property) {
+    if (!model.properties[0]) {
       // force creation of a property
       publicAPI.getProperty();
     }
-    let isOpaque = model.property.getOpacity() >= 1.0;
+    let isOpaque = model.properties[0].getOpacity() >= 1.0;
 
     // are we using an opaque texture, if any?
     isOpaque = isOpaque && (!model.texture || !model.texture.isTranslucent());
@@ -47,71 +41,17 @@ function vtkActor(publicAPI, model) {
       return false;
     }
     // make sure we have a property
-    if (model.property === null) {
+    if (!model.properties[0]) {
       // force creation of a property
-      publicAPI.setProperty(publicAPI.makeProperty());
+      publicAPI.getProperty();
     }
 
     // is this actor opaque ?
     return !publicAPI.getIsOpaque();
   };
   publicAPI.makeProperty = vtkProperty.newInstance;
-  publicAPI.getProperty = () => {
-    if (model.property === null) {
-      model.property = publicAPI.makeProperty();
-    }
-    return model.property;
-  };
-  publicAPI.getBounds = () => {
-    if (model.mapper === null) {
-      return model.bounds;
-    }
-
-    // Check for the special case when the mapper's bounds are unknown
-    const bds = model.mapper.getBounds();
-    if (!bds || bds.length !== 6) {
-      return bds;
-    }
-
-    // Check for the special case when the actor is empty.
-    if (bds[0] > bds[1]) {
-      model.mapperBounds = bds.concat(); // copy the mapper's bounds
-      model.bounds = [1, -1, 1, -1, 1, -1];
-      model.boundsMTime.modified();
-      return bds;
-    }
-
-    // Check if we have cached values for these bounds - we cache the
-    // values returned by model.mapper.getBounds() and we store the time
-    // of caching. If the values returned this time are different, or
-    // the modified time of this class is newer than the cached time,
-    // then we need to rebuild.
-    if (!model.mapperBounds || bds[0] !== model.mapperBounds[0] || bds[1] !== model.mapperBounds[1] || bds[2] !== model.mapperBounds[2] || bds[3] !== model.mapperBounds[3] || bds[4] !== model.mapperBounds[4] || bds[5] !== model.mapperBounds[5] || publicAPI.getMTime() > model.boundsMTime.getMTime()) {
-      vtkDebugMacro('Recomputing bounds...');
-      model.mapperBounds = bds.concat(); // copy the mapper's bounds
-      const bbox = [];
-      vtkBoundingBox.getCorners(bds, bbox);
-      publicAPI.computeMatrix();
-      const tmp4 = new Float64Array(16);
-      mat4.transpose(tmp4, model.matrix);
-      bbox.forEach(pt => vec3.transformMat4(pt, pt, tmp4));
-
-      /* eslint-disable no-multi-assign */
-      model.bounds[0] = model.bounds[2] = model.bounds[4] = Number.MAX_VALUE;
-      model.bounds[1] = model.bounds[3] = model.bounds[5] = -Number.MAX_VALUE;
-      /* eslint-enable no-multi-assign */
-
-      model.bounds = model.bounds.map((d, i) => i % 2 === 0 ? bbox.reduce((a, b) => a > b[i / 2] ? b[i / 2] : a, d) : bbox.reduce((a, b) => a < b[(i - 1) / 2] ? b[(i - 1) / 2] : a, d));
-      model.boundsMTime.modified();
-    }
-    return model.bounds;
-  };
   publicAPI.getMTime = () => {
     let mt = superClass.getMTime();
-    if (model.property !== null) {
-      const time = model.property.getMTime();
-      mt = time > mt ? time : mt;
-    }
     if (model.backfaceProperty !== null) {
       const time = model.backfaceProperty.getMTime();
       mt = time > mt ? time : mt;
@@ -146,11 +86,9 @@ function vtkActor(publicAPI, model) {
 
 const DEFAULT_VALUES = {
   mapper: null,
-  property: null,
   backfaceProperty: null,
   forceOpaque: false,
-  forceTranslucent: false,
-  bounds: [1, -1, 1, -1, 1, -1]
+  forceTranslucent: false
 };
 
 // ----------------------------------------------------------------------------
@@ -167,7 +105,6 @@ function extend(publicAPI, model) {
   macro.obj(model.boundsMTime);
 
   // Build VTK API
-  macro.set(publicAPI, model, ['property']);
   macro.setGet(publicAPI, model, ['backfaceProperty', 'forceOpaque', 'forceTranslucent', 'mapper']);
 
   // Object methods

package/Rendering/Core/ImageCPRMapper.d.ts

@@ -1,5 +1,5 @@
 import { mat3, mat4, quat, vec3 } from 'gl-matrix';
-import { Extent, Nullable } from './../../types';
+import { Nullable } from './../../types';
 import { vtkOutputPort } from './../../interfaces';
 import {
   vtkAbstractMapper3D,
@@ -309,25 +309,6 @@ export interface vtkImageCPRMapper
    * @param imageData
    */
   setImageConnection(imageData: vtkOutputPort): void;
-
-  /**
-   * Tells the mapper to only update the specified extents.
-   *
-   * If there are zero extents, the mapper updates the entire volume texture.
-   * Otherwise, the mapper will only update the texture by the specified extents
-   * during the next render call.
-   *
-   * This array is cleared after a successful render.
-   * @param extents
-   */
-  setUpdatedExtents(extents: Extent[]): boolean;
-
-  /**
-   * Retrieves the updated extents.
-   *
-   * This array is cleared after every successful render.
-   */
-  getUpdatedExtents(): Extent[];
 }
 
 /**

package/Rendering/Core/ImageCPRMapper.js

@@ -283,7 +283,6 @@ const defaultValues = initialValues => ({
   projectionSlabThickness: 1,
   projectionSlabNumberOfSamples: 1,
   projectionMode: ProjectionMode.MAX,
-  updatedExtents: [],
   ...initialValues
 });
 
@@ -304,7 +303,7 @@ function extend(publicAPI, model) {
   });
 
   // Setters and getters
-  macro.setGet(publicAPI, model, ['width', 'uniformOrientation', 'useUniformOrientation', 'centerPoint', 'preferSizeOverAccuracy', 'orientationArrayName', 'tangentDirection', 'bitangentDirection', 'normalDirection', 'projectionSlabThickness', 'projectionSlabNumberOfSamples', 'projectionMode', 'updatedExtents']);
+  macro.setGet(publicAPI, model, ['width', 'uniformOrientation', 'useUniformOrientation', 'centerPoint', 'preferSizeOverAccuracy', 'orientationArrayName', 'tangentDirection', 'bitangentDirection', 'normalDirection', 'projectionSlabThickness', 'projectionSlabNumberOfSamples', 'projectionMode']);
   CoincidentTopologyHelper.implementCoincidentTopologyMethods(publicAPI, model);
 
   // Object methods

package/Rendering/Core/ImageProperty.d.ts

@@ -1,5 +1,5 @@
 import { vtkObject } from './../../interfaces';
-import { Nullable } from './../../types';
+import { Extent, Nullable } from './../../types';
 import vtkColorTransferFunction from './ColorTransferFunction';
 import vtkPiecewiseFunction from './../../Common/DataModel/PiecewiseFunction';
 import { InterpolationType } from './ImageProperty/Constants';
@@ -231,6 +231,25 @@ export interface vtkImageProperty extends vtkObject {
    * @param {Boolean} useLookupTableScalarRange
    */
   setUseLookupTableScalarRange(useLookupTableScalarRange: boolean): boolean;
+
+  /**
+   * Informs the mapper to only update the specified extents at the next render.
+   *
+   * If there are zero extents, the mapper updates the entire volume texture.
+   * Otherwise, the mapper will only update the texture by the specified extents
+   * during the next render call.
+   *
+   * This array is cleared after a successful render.
+   * @param extents
+   */
+  setUpdatedExtents(extents: Extent[]): boolean;
+
+  /**
+   * Retrieves the updated extents.
+   *
+   * This array is cleared after every successful render.
+   */
+  getUpdatedExtents(): Extent[];
 }
 
 /**

package/Rendering/Core/ImageProperty.js

@@ -136,7 +136,7 @@ function vtkImageProperty(publicAPI, model) {
 // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
-const DEFAULT_VALUES = {
+const defaultValues = initialValues => ({
   independentComponents: false,
   interpolationType: InterpolationType.LINEAR,
   colorWindow: 255,
@@ -147,14 +147,16 @@ const DEFAULT_VALUES = {
   useLookupTableScalarRange: false,
   useLabelOutline: false,
   labelOutlineThickness: [1],
-  labelOutlineOpacity: 1.0
-};
+  labelOutlineOpacity: 1.0,
+  updatedExtents: [],
+  ...initialValues
+});
 
 // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
   let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
+  Object.assign(model, defaultValues(initialValues));
 
   // Build VTK API
   macro.obj(publicAPI, model);
@@ -168,7 +170,7 @@ function extend(publicAPI, model) {
       });
     }
   }
-  macro.setGet(publicAPI, model, ['independentComponents', 'interpolationType', 'colorWindow', 'colorLevel', 'ambient', 'diffuse', 'opacity', 'useLookupTableScalarRange', 'useLabelOutline', 'labelOutlineOpacity']);
+  macro.setGet(publicAPI, model, ['independentComponents', 'interpolationType', 'colorWindow', 'colorLevel', 'ambient', 'diffuse', 'opacity', 'useLookupTableScalarRange', 'useLabelOutline', 'labelOutlineOpacity', 'updatedExtents']);
   macro.setGetArray(publicAPI, model, ['labelOutlineThickness']);
 
   // Object methods

package/Rendering/Core/ImageResliceMapper.d.ts

@@ -4,7 +4,7 @@ import {
 } from './AbstractImageMapper';
 import { vtkPlane } from './../../Common/DataModel/Plane';
 import { vtkPolyData } from './../../Common/DataModel/PolyData';
-import { Bounds, Extent } from './../../types';
+import { Bounds } from './../../types';
 import { SlabTypes } from './ImageResliceMapper/Constants';
 import {
   CoincidentTopologyHelper,
@@ -117,25 +117,6 @@ export interface vtkImageResliceMapper
    * @param {vtkPolyData} slicePolyData The polydata to slice the volume with. Default: null
    */
   setSlicePolyData(slicePolyData: vtkPolyData): boolean;
-
-  /**
-   * Tells the mapper to only update the specified extents.
-   *
-   * If there are zero extents, the mapper updates the entire volume texture.
-   * Otherwise, the mapper will only update the texture by the specified extents
-   * during the next render call.
-   *
-   * This array is cleared after a successful render.
-   * @param extents
-   */
-  setUpdatedExtents(extents: Extent[]): boolean;
-
-  /**
-   * Retrieves the updated extents.
-   *
-   * This array is cleared after every successful render.
-   */
-  getUpdatedExtents(): Extent[];
 }
 
 /**

package/Rendering/Core/ImageResliceMapper.js

@@ -44,7 +44,6 @@ const defaultValues = initialValues => ({
   slabType: SlabTypes.MEAN,
   slicePlane: null,
   slicePolyData: null,
-  updatedExtents: [],
   ...initialValues
 });
 
@@ -56,7 +55,7 @@ function extend(publicAPI, model) {
 
   // Build VTK API
   vtkAbstractImageMapper.extend(publicAPI, model, initialValues);
-  macro.setGet(publicAPI, model, ['slabThickness', 'slabTrapezoidIntegration', 'slabType', 'slicePlane', 'slicePolyData', 'updatedExtents']);
+  macro.setGet(publicAPI, model, ['slabThickness', 'slabTrapezoidIntegration', 'slabType', 'slicePlane', 'slicePolyData']);
   CoincidentTopologyHelper.implementCoincidentTopologyMethods(publicAPI, model);
 
   // Object methods

package/Rendering/Core/ImageSlice.d.ts

@@ -17,18 +17,6 @@ export interface vtkImageSlice extends vtkProp3D {
    */
   getActors(): any;
 
-  /**
-   * 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 this mapper as [xmin, xmax, ymin, ymax,zmin, zmax].
-   * @return {Bounds} The bounds for the mapper.
-   */
-  getBoundsByReference(): Bounds;
-
   /**
    * Get the bounds for a given slice as [xmin, xmax, ymin, ymax,zmin, zmax].
    * @param {Number} slice The slice index. If undefined, the current slice is considered.
@@ -47,11 +35,6 @@ export interface vtkImageSlice extends vtkProp3D {
    */
   getIsOpaque(): boolean;
 
-  /**
-   *
-   */
-  getProperty(): vtkImageProperty;
-
   /**
    *
    */
@@ -130,12 +113,6 @@ export interface vtkImageSlice extends vtkProp3D {
    */
   setMapper(mapper: vtkAbstractImageMapper): boolean;
 
-  /**
-   *
-   * @param {vtkImageProperty} property The vtkImageProperty instance.
-   */
-  setProperty(property: vtkImageProperty): boolean;
-
   /**
    *
    * @param {boolean} forceOpaque If true, render during opaque pass even if opacity value is below 1.0.
@@ -147,6 +124,13 @@ export interface vtkImageSlice extends vtkProp3D {
    * @param {boolean} forceTranslucent If true, render during translucent pass even if opacity value is 1.0.
    */
   setForceTranslucent(forceTranslucent: boolean): boolean;
+
+  // Inherited from vtkProp3D, but takes a vtkImageProperty instead of a generic vtkObject
+  getProperty(mapperInputPort?: number): vtkImageProperty;
+  getProperties(): vtkImageProperty[];
+  setProperty(mapperInputPort: number, property: vtkImageProperty): boolean;
+  setProperty(property: vtkImageProperty): boolean;
+  setProperties(properties: vtkImageProperty[]): boolean;
 }
 
 /**

package/Rendering/Core/ImageSlice.js

@@ -4,10 +4,6 @@ import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkProp3D from './Prop3D.js';
 import vtkImageProperty from './ImageProperty.js';
 
-const {
-  vtkDebugMacro
-} = macro;
-
 // ----------------------------------------------------------------------------
 // vtkImageSlice methods
 // ----------------------------------------------------------------------------
@@ -25,11 +21,11 @@ function vtkImageSlice(publicAPI, model) {
       return false;
     }
     // make sure we have a property
-    if (!model.property) {
+    if (!model.properties[0]) {
       // force creation of a property
       publicAPI.getProperty();
     }
-    let isOpaque = model.property.getOpacity() >= 1.0;
+    let isOpaque = model.properties[0].getOpacity() >= 1.0;
 
     // are we using an opaque scalar array, if any?
     isOpaque = isOpaque && (!model.mapper || model.mapper.getIsOpaque());
@@ -43,48 +39,6 @@ function vtkImageSlice(publicAPI, model) {
   // and the Renderer will do the images in their own pass.
   publicAPI.hasTranslucentPolygonalGeometry = () => false;
   publicAPI.makeProperty = vtkImageProperty.newInstance;
-  publicAPI.getProperty = () => {
-    if (model.property === null) {
-      model.property = publicAPI.makeProperty();
-    }
-    return model.property;
-  };
-  publicAPI.getBounds = () => {
-    if (model.mapper === null) {
-      return model.bounds;
-    }
-
-    // Check for the special case when the mapper's bounds are unknown
-    const bds = model.mapper.getBounds();
-    if (!bds || bds.length !== 6) {
-      return bds;
-    }
-
-    // Check for the special case when the actor is empty.
-    if (bds[0] > bds[1]) {
-      model.mapperBounds = bds.concat(); // copy the mapper's bounds
-      model.bounds = [1, -1, 1, -1, 1, -1];
-      model.boundsMTime.modified();
-      return bds;
-    }
-
-    // Check if we have cached values for these bounds - we cache the
-    // values returned by model.mapper.getBounds() and we store the time
-    // of caching. If the values returned this time are different, or
-    // the modified time of this class is newer than the cached time,
-    // then we need to rebuild.
-    const zip = rows => rows[0].map((_, c) => rows.map(row => row[c]));
-    if (!model.mapperBounds || !zip([bds, model.mapperBounds]).reduce((a, b) => a && b[0] === b[1], true) || publicAPI.getMTime() > model.boundsMTime.getMTime()) {
-      vtkDebugMacro('Recomputing bounds...');
-      model.mapperBounds = bds.map(x => x);
-      publicAPI.computeMatrix();
-      const tmp4 = new Float64Array(16);
-      mat4.transpose(tmp4, model.matrix);
-      vtkBoundingBox.transformBounds(bds, tmp4, model.bounds);
-      model.boundsMTime.modified();
-    }
-    return model.bounds;
-  };
   publicAPI.getBoundsForSlice = (slice, thickness) => {
     // Check for the special case when the mapper's bounds are unknown
     const bds = model.mapper.getBoundsForSlice(slice, thickness);
@@ -117,14 +71,6 @@ function vtkImageSlice(publicAPI, model) {
 
   // Get the maximum Z bound
   publicAPI.getMaxZBound = () => publicAPI.getBounds()[5];
-  publicAPI.getMTime = () => {
-    let mt = model.mtime;
-    if (model.property !== null) {
-      const time = model.property.getMTime();
-      mt = time > mt ? time : mt;
-    }
-    return mt;
-  };
   publicAPI.getRedrawMTime = () => {
     let mt = model.mtime;
     if (model.mapper !== null) {
@@ -137,14 +83,13 @@ function vtkImageSlice(publicAPI, model) {
         mt = time > mt ? time : mt;
       }
     }
-    if (model.property !== null) {
-      let time = model.property.getMTime();
-      mt = time > mt ? time : mt;
-      if (model.property.getRGBTransferFunction() !== null) {
-        time = model.property.getRGBTransferFunction().getMTime();
-        mt = time > mt ? time : mt;
+    model.properties.forEach(property => {
+      mt = Math.max(mt, property.getMTime());
+      const rgbFunc = property.getRGBTransferFunction();
+      if (rgbFunc !== null) {
+        mt = Math.max(mt, rgbFunc.getMTime());
       }
-    }
+    });
     return mt;
   };
   publicAPI.getSupportsSelection = () => model.mapper ? model.mapper.getSupportsSelection() : false;
@@ -156,10 +101,8 @@ function vtkImageSlice(publicAPI, model) {
 
 const DEFAULT_VALUES = {
   mapper: null,
-  property: null,
   forceOpaque: false,
-  forceTranslucent: false,
-  bounds: [...vtkBoundingBox.INIT_BOUNDS]
+  forceTranslucent: false
 };
 
 // ----------------------------------------------------------------------------
@@ -176,9 +119,7 @@ function extend(publicAPI, model) {
   macro.obj(model.boundsMTime);
 
   // Build VTK API
-  macro.set(publicAPI, model, ['property']);
   macro.setGet(publicAPI, model, ['mapper', 'forceOpaque', 'forceTranslucent']);
-  macro.getArray(publicAPI, model, ['bounds'], 6);
 
   // Object methods
   vtkImageSlice(publicAPI, model);