@kitware/vtk.js 33.0.0-beta.4 → 33.0.1

package/BREAKING_CHANGES.md

@@ -1,6 +1,3 @@
-## From 32.x to 33
-
-- **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`.
 ## 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/Common/Core/ScalarsToColors/Constants.js

@@ -9,9 +9,14 @@ const ScalarMappingTarget = {
   RGB: 3,
   RGBA: 4
 };
+const Scale = {
+  LINEAR: 0,
+  LOG10: 1
+};
 var vtkScalarsToColors = {
   VectorMode,
-  ScalarMappingTarget
+  ScalarMappingTarget,
+  Scale
 };
 
-export { ScalarMappingTarget, VectorMode, vtkScalarsToColors as default };
+export { ScalarMappingTarget, Scale, VectorMode, vtkScalarsToColors as default };

package/Common/Core/ScalarsToColors.js

@@ -5,6 +5,7 @@ import Constants from '../../Rendering/Core/Mapper/Constants.js';
 
 const {
   ScalarMappingTarget,
+  Scale,
   VectorMode
 } = vtkScalarsToColors$2;
 const {
@@ -469,7 +470,8 @@ const DEFAULT_VALUES = {
   mappingRange: null,
   annotationArray: null,
   annotatedValueMap: null,
-  indexedLookup: false
+  indexedLookup: false,
+  scale: Scale.LINEAR
 };
 
 // ----------------------------------------------------------------------------

package/Rendering/Core/Actor.d.ts

@@ -36,6 +36,12 @@ 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.
    */
@@ -57,6 +63,16 @@ 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.
@@ -95,12 +111,11 @@ export interface vtkActor extends vtkProp3D {
    */
   setMapper(mapper: vtkMapper): boolean;
 
-  // Inherited from vtkProp3D, but takes a vtkProperty instead of a generic vtkObject
-  getProperty(mapperInputPort?: number): vtkProperty;
-  getProperties(): vtkProperty[];
-  setProperty(mapperInputPort: number, property: vtkProperty): boolean;
+  /**
+   * Set the property object that controls this actors surface properties.
+   * @param {vtkProperty} property The vtkProperty instance.
+   */
   setProperty(property: vtkProperty): boolean;
-  setProperties(properties: vtkProperty[]): boolean;
 }
 
 /**

package/Rendering/Core/Actor.js

@@ -1,7 +1,13 @@
+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
 // ----------------------------------------------------------------------------
@@ -23,11 +29,11 @@ function vtkActor(publicAPI, model) {
       return false;
     }
     // make sure we have a property
-    if (!model.properties[0]) {
+    if (!model.property) {
       // force creation of a property
       publicAPI.getProperty();
     }
-    let isOpaque = model.properties[0].getOpacity() >= 1.0;
+    let isOpaque = model.property.getOpacity() >= 1.0;
 
     // are we using an opaque texture, if any?
     isOpaque = isOpaque && (!model.texture || !model.texture.isTranslucent());
@@ -41,17 +47,71 @@ function vtkActor(publicAPI, model) {
       return false;
     }
     // make sure we have a property
-    if (!model.properties[0]) {
+    if (model.property === null) {
       // force creation of a property
-      publicAPI.getProperty();
+      publicAPI.setProperty(publicAPI.makeProperty());
     }
 
     // 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;
@@ -86,9 +146,11 @@ function vtkActor(publicAPI, model) {
 
 const DEFAULT_VALUES = {
   mapper: null,
+  property: null,
   backfaceProperty: null,
   forceOpaque: false,
-  forceTranslucent: false
+  forceTranslucent: false,
+  bounds: [1, -1, 1, -1, 1, -1]
 };
 
 // ----------------------------------------------------------------------------
@@ -105,6 +167,7 @@ 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/ColorTransferFunction.js

@@ -400,13 +400,18 @@ function vtkColorTransferFunction(publicAPI, model) {
     publicAPI.getColor(x, rgb);
     return rgb[2];
   };
+  publicAPI.logScaleEnabled = () => model.scale === Scale.LOG10;
+  publicAPI.usingLogScale = () => publicAPI.logScaleEnabled() && model.mappingRange[0] > 0.0;
 
   //----------------------------------------------------------------------------
   // Returns a table of RGB colors at regular intervals along the function
   publicAPI.getTable = (xStart_, xEnd_, size, table) => {
+    // Note: This requires range[0] <= range[1].
+    const usingLogScale = publicAPI.usingLogScale();
+
     // To handle BigInt limitation
-    const xStart = Number(xStart_);
-    const xEnd = Number(xEnd_);
+    const xStart = usingLogScale ? Math.log10(Number(xStart_)) : Number(xStart_);
+    const xEnd = usingLogScale ? Math.log10(Number(xEnd_)) : Number(xEnd_);
 
     // Special case: If either the start or end is a NaN, then all any
     // interpolation done on them is also a NaN.  Therefore, fill the table with
@@ -443,17 +448,9 @@ function vtkColorTransferFunction(publicAPI, model) {
     const tmpVec = [];
 
     // If the scale is logarithmic, make sure the range is valid.
-    let usingLogScale = model.scale === Scale.LOG10;
-    if (usingLogScale) {
-      // Note: This requires range[0] <= range[1].
-      usingLogScale = model.mappingRange[0] > 0.0;
-    }
-    let logStart = 0.0;
-    let logEnd = 0.0;
-    let logX = 0.0;
+    let scaledMappingRange = model.mappingRange;
     if (usingLogScale) {
-      logStart = Math.log10(xStart);
-      logEnd = Math.log10(xEnd);
+      scaledMappingRange = [Math.log10(model.mappingRange[0]), Math.log10(model.mappingRange[1])];
     }
 
     // For each table entry
@@ -465,15 +462,7 @@ function vtkColorTransferFunction(publicAPI, model) {
       // it halfway between start and end (usually start and end will
       // be the same in this case)
       if (size > 1) {
-        if (usingLogScale) {
-          logX = logStart + i / (size - 1.0) * (logEnd - logStart);
-          x = 10.0 ** logX;
-        } else {
-          x = xStart + i / (size - 1.0) * (xEnd - xStart);
-        }
-      } else if (usingLogScale) {
-        logX = 0.5 * (logStart + logEnd);
-        x = 10.0 ** logX;
+        x = xStart + i / (size - 1.0) * (xEnd - xStart);
       } else {
         x = 0.5 * (xStart + xEnd);
       }
@@ -482,7 +471,7 @@ function vtkColorTransferFunction(publicAPI, model) {
       // discretize (round down to the closest integer),
       // then map back to mappingRange
       if (model.discretize) {
-        const range = model.mappingRange;
+        const range = scaledMappingRange;
         if (x >= range[0] && x <= range[1]) {
           const numberOfValues = model.numberOfValues;
           const deltaRange = range[1] - range[0];
@@ -509,10 +498,6 @@ function vtkColorTransferFunction(publicAPI, model) {
         if (idx < numNodes) {
           x1 = model.nodes[idx - 1].x;
           x2 = model.nodes[idx].x;
-          if (usingLogScale) {
-            x1 = Math.log10(x1);
-            x2 = Math.log10(x2);
-          }
           rgb1[0] = model.nodes[idx - 1].r;
           rgb2[0] = model.nodes[idx].r;
           rgb1[1] = model.nodes[idx - 1].g;
@@ -537,7 +522,7 @@ function vtkColorTransferFunction(publicAPI, model) {
       }
 
       // Are we at or past the end? If so, just use the last value
-      if (x > model.mappingRange[1]) {
+      if (x > scaledMappingRange[1]) {
         table[tidx] = 0.0;
         table[tidx + 1] = 0.0;
         table[tidx + 2] = 0.0;
@@ -552,7 +537,7 @@ function vtkColorTransferFunction(publicAPI, model) {
             table[tidx + 2] = lastB;
           }
         }
-      } else if (x < model.mappingRange[0] || isInf(x) && x < 0) {
+      } else if (x < scaledMappingRange[0] || isInf(x) && x < 0) {
         // we are before the first node? If so, duplicate this node's values.
         // We have to deal with -inf here
         table[tidx] = 0.0;
@@ -586,11 +571,7 @@ function vtkColorTransferFunction(publicAPI, model) {
         // sharpness to get the curve shape we want and to have
         // it pass through (y1+y2)/2 at the midpoint.
         let s = 0.0;
-        if (usingLogScale) {
-          s = (logX - x1) / (x2 - x1);
-        } else {
-          s = (x - x1) / (x2 - x1);
-        }
+        s = (x - x1) / (x2 - x1);
 
         // Readjust based on the midpoint - linear adjustment
         if (s < midpoint) {
@@ -975,7 +956,9 @@ function vtkColorTransferFunction(publicAPI, model) {
   //----------------------------------------------------------------------------
   publicAPI.setMappingRange = (min, max) => {
     const range = [min, max];
+    const scaledRange = [min, max];
     const originalRange = publicAPI.getRange();
+    const logScaleEnabled = publicAPI.logScaleEnabled();
     if (originalRange[1] === range[1] && originalRange[0] === range[0]) {
       return;
     }
@@ -983,8 +966,16 @@ function vtkColorTransferFunction(publicAPI, model) {
       vtkErrorMacro('attempt to set zero width color range');
       return;
     }
-    const scale = (range[1] - range[0]) / (originalRange[1] - originalRange[0]);
-    const shift = range[0] - originalRange[0] * scale;
+    if (logScaleEnabled) {
+      if (range[0] <= 0.0) {
+        console.warn('attempt to set log scale color range with non-positive minimum');
+      } else {
+        scaledRange[0] = Math.log10(range[0]);
+        scaledRange[1] = Math.log10(range[1]);
+      }
+    }
+    const scale = (scaledRange[1] - scaledRange[0]) / (originalRange[1] - originalRange[0]);
+    const shift = scaledRange[0] - originalRange[0] * scale;
     for (let i = 0; i < model.nodes.length; ++i) {
       model.nodes[i].x = model.nodes[i].x * scale + shift;
     }

package/Rendering/Core/ImageCPRMapper.d.ts

@@ -1,5 +1,5 @@
 import { mat3, mat4, quat, vec3 } from 'gl-matrix';
-import { Nullable } from './../../types';
+import { Extent, Nullable } from './../../types';
 import { vtkOutputPort } from './../../interfaces';
 import vtkAbstractMapper3D, {
   IAbstractMapper3DInitialValues,
@@ -307,6 +307,25 @@ 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,6 +283,7 @@ const defaultValues = initialValues => ({
   projectionSlabThickness: 1,
   projectionSlabNumberOfSamples: 1,
   projectionMode: ProjectionMode.MAX,
+  updatedExtents: [],
   ...initialValues
 });
 
@@ -303,7 +304,7 @@ function extend(publicAPI, model) {
   });
 
   // Setters and getters
-  macro.setGet(publicAPI, model, ['width', 'uniformOrientation', 'useUniformOrientation', 'centerPoint', 'preferSizeOverAccuracy', 'orientationArrayName', 'tangentDirection', 'bitangentDirection', 'normalDirection', 'projectionSlabThickness', 'projectionSlabNumberOfSamples', 'projectionMode']);
+  macro.setGet(publicAPI, model, ['width', 'uniformOrientation', 'useUniformOrientation', 'centerPoint', 'preferSizeOverAccuracy', 'orientationArrayName', 'tangentDirection', 'bitangentDirection', 'normalDirection', 'projectionSlabThickness', 'projectionSlabNumberOfSamples', 'projectionMode', 'updatedExtents']);
   CoincidentTopologyHelper.implementCoincidentTopologyMethods(publicAPI, model);
 
   // Object methods

package/Rendering/Core/ImageProperty.d.ts

@@ -1,5 +1,5 @@
 import { vtkObject } from './../../interfaces';
-import { Extent, Nullable } from './../../types';
+import { Nullable } from './../../types';
 import vtkColorTransferFunction from './ColorTransferFunction';
 import vtkPiecewiseFunction from './../../Common/DataModel/PiecewiseFunction';
 import { InterpolationType } from './ImageProperty/Constants';
@@ -231,25 +231,6 @@ 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 defaultValues = initialValues => ({
+const DEFAULT_VALUES = {
   independentComponents: false,
   interpolationType: InterpolationType.LINEAR,
   colorWindow: 255,
@@ -147,16 +147,14 @@ const defaultValues = initialValues => ({
   useLookupTableScalarRange: false,
   useLabelOutline: false,
   labelOutlineThickness: [1],
-  labelOutlineOpacity: 1.0,
-  updatedExtents: [],
-  ...initialValues
-});
+  labelOutlineOpacity: 1.0
+};
 
 // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
   let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, defaultValues(initialValues));
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Build VTK API
   macro.obj(publicAPI, model);
@@ -170,7 +168,7 @@ function extend(publicAPI, model) {
       });
     }
   }
-  macro.setGet(publicAPI, model, ['independentComponents', 'interpolationType', 'colorWindow', 'colorLevel', 'ambient', 'diffuse', 'opacity', 'useLookupTableScalarRange', 'useLabelOutline', 'labelOutlineOpacity', 'updatedExtents']);
+  macro.setGet(publicAPI, model, ['independentComponents', 'interpolationType', 'colorWindow', 'colorLevel', 'ambient', 'diffuse', 'opacity', 'useLookupTableScalarRange', 'useLabelOutline', 'labelOutlineOpacity']);
   macro.setGetArray(publicAPI, model, ['labelOutlineThickness']);
 
   // Object methods

package/Rendering/Core/ImageResliceMapper.d.ts

@@ -3,7 +3,7 @@ import vtkAbstractImageMapper, {
 } from './AbstractImageMapper';
 import vtkPlane from './../../Common/DataModel/Plane';
 import vtkPolyData from './../../Common/DataModel/PolyData';
-import { Bounds } from './../../types';
+import { Bounds, Extent } from './../../types';
 import { SlabTypes } from './ImageResliceMapper/Constants';
 import CoincidentTopologyHelper, {
   StaticCoincidentTopologyMethods,
@@ -115,6 +115,25 @@ 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,6 +44,7 @@ const defaultValues = initialValues => ({
   slabType: SlabTypes.MEAN,
   slicePlane: null,
   slicePolyData: null,
+  updatedExtents: [],
   ...initialValues
 });
 
@@ -55,7 +56,7 @@ function extend(publicAPI, model) {
 
   // Build VTK API
   vtkAbstractImageMapper.extend(publicAPI, model, initialValues);
-  macro.setGet(publicAPI, model, ['slabThickness', 'slabTrapezoidIntegration', 'slabType', 'slicePlane', 'slicePolyData']);
+  macro.setGet(publicAPI, model, ['slabThickness', 'slabTrapezoidIntegration', 'slabType', 'slicePlane', 'slicePolyData', 'updatedExtents']);
   CoincidentTopologyHelper.implementCoincidentTopologyMethods(publicAPI, model);
 
   // Object methods

package/Rendering/Core/ImageSlice.d.ts

@@ -17,6 +17,18 @@ 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.
@@ -35,6 +47,11 @@ export interface vtkImageSlice extends vtkProp3D {
    */
   getIsOpaque(): boolean;
 
+  /**
+   *
+   */
+  getProperty(): vtkImageProperty;
+
   /**
    *
    */
@@ -113,6 +130,12 @@ 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.
@@ -124,13 +147,6 @@ 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;
 }
 
 /**