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

package/Rendering/Core/Prop3D.d.ts

@@ -1,6 +1,7 @@
 import { mat4, quat } from 'gl-matrix';
 import { Bounds, Vector3, Range } from './../../types';
 import vtkProp, { IPropInitialValues } from './Prop';
+import { vtkObject } from './../../interfaces';
 
 export interface IProp3DInitialValues extends IPropInitialValues {
   origin?: number[];
@@ -19,11 +20,17 @@ export interface vtkProp3D extends vtkProp {
   addPosition(deltaXYZ: number[]): void;
 
   /**
-   * Get the bounds as [xmin, xmax, ymin, ymax, zmin, zmax].
-   * @return {Bounds} The bounds for the mapper.
+   * Get the bounds of this actor as [xmin, xmax, ymin, ymax, zmin, zmax].
+   * They are the bounds of the underlying mapper, transformed using the actor's matrix.
+   * @return {Bounds} The bounds for the actor.
    */
   getBounds(): Bounds;
 
+  /**
+   * Same as getBounds() but the returned array is not copied, so it should not be written to.
+   */
+  getBoundsByReference(): Bounds;
+
   /**
    * Check if there was a modification or transformation.
    * @default null
@@ -131,6 +138,21 @@ export interface vtkProp3D extends vtkProp {
    */
   getUserMatrix(): mat4;
 
+  /**
+   * Get the actor property for the specified mapper input port, which defaults to 0
+   * It controls this actors rendering properties. If one isn’t specified,
+   * then one will be generated automatically. Multiple actors can share one
+   * property object.
+   * @param {number} mapperInputPort Defaults to 0
+   */
+  getProperty(mapperInputPort?: number): vtkObject;
+
+  /**
+   * Get the actor properties array
+   * Each element of the array corresponds to a mapper input port
+   */
+  getProperties(): vtkObject[];
+
   /**
    * Rotate the Prop3D in degrees about the X axis using the right hand
    * rule. The axis is the Prop3D’s X axis, which can change as other
@@ -256,6 +278,21 @@ export interface vtkProp3D extends vtkProp {
    * Generate the matrix based on internal model.
    */
   computeMatrix(): void;
+
+  /**
+   * Set the actor property for the specified mapper input port, which defaults to 0
+   * @param {vtkObject} property
+   * @param {number} mapperInputPort Is 0 when not given
+   */
+  setProperty(mapperInputPort: number, property: vtkObject): boolean;
+  setProperty(property: vtkObject): boolean;
+
+  /**
+   * Set the actor properties array
+   * Each element of the array corresponds to a mapper input port
+   * @param {vtkObject[]} properties
+   */
+  setProperties(properties: vtkObject[]): boolean;
 }
 
 /**

package/Rendering/Core/Prop3D.js

@@ -121,6 +121,54 @@ function vtkProp3D(publicAPI, model) {
       model.matrixMTime.modified();
     }
   };
+  publicAPI.getBoundsByReference = () => {
+    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]) {
+      // No need to copy bds, a new array is created when calling getBounds()
+      model.mapperBounds = bds;
+      model.bounds = [...vtkBoundingBox.INIT_BOUNDS];
+      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.every((_, i) => bds[i] === model.mapperBounds[i]) || publicAPI.getMTime() > model.boundsMTime.getMTime()) {
+      macro.vtkDebugMacro('Recomputing bounds...');
+      // No need to copy bds, a new array is created when calling getBounds()
+      model.mapperBounds = bds;
+
+      // Compute actor bounds from matrix and mapper bounds
+      publicAPI.computeMatrix();
+      const transposedMatrix = new Float64Array(16);
+      mat4.transpose(transposedMatrix, model.matrix);
+      vtkBoundingBox.transformBounds(bds, transposedMatrix, model.bounds);
+      model.boundsMTime.modified();
+    }
+    return model.bounds;
+  };
+  publicAPI.getBounds = () => {
+    const bounds = publicAPI.getBoundsByReference();
+    // Handle case when bounds are not iterable (for example null or undefined)
+    try {
+      return [...bounds];
+    } catch {
+      return bounds;
+    }
+  };
   publicAPI.getCenter = () => vtkBoundingBox.getCenter(model.bounds);
   publicAPI.getLength = () => vtkBoundingBox.getLength(model.bounds);
   publicAPI.getXRange = () => vtkBoundingBox.getXRange(model.bounds);
@@ -131,6 +179,35 @@ function vtkProp3D(publicAPI, model) {
     publicAPI.computeMatrix();
   }
   publicAPI.onModified(updateIdentityFlag);
+  publicAPI.getProperty = function () {
+    let mapperInputPort = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    if (model.properties[mapperInputPort] == null) {
+      model.properties[mapperInputPort] = publicAPI.makeProperty?.();
+    }
+    return model.properties[mapperInputPort];
+  };
+  publicAPI.setProperty = (firstArg, secondArg) => {
+    // Two options for argument layout:
+    // - (mapperInputPort, property)
+    // - (property)
+    const useInputPortArgument = Number.isInteger(firstArg);
+    const [mapperInputPort, property] = useInputPortArgument ? [firstArg, secondArg] : [0, firstArg];
+    if (model.properties[mapperInputPort] === property) {
+      return false;
+    }
+    model.properties[mapperInputPort] = property;
+    return true;
+  };
+  publicAPI.getMTime = () => {
+    let mt = model.mtime;
+    model.properties.forEach(property => {
+      if (property !== null) {
+        const time = property.getMTime();
+        mt = time > mt ? time : mt;
+      }
+    });
+    return mt;
+  };
 }
 
 // ----------------------------------------------------------------------------
@@ -143,7 +220,8 @@ const DEFAULT_VALUES = {
   orientation: [0, 0, 0],
   rotation: null,
   scale: [1, 1, 1],
-  bounds: [1, -1, 1, -1, 1, -1],
+  bounds: [...vtkBoundingBox.INIT_BOUNDS],
+  properties: [],
   userMatrix: null,
   userMatrixMTime: null,
   cachedProp3D: null,
@@ -163,9 +241,10 @@ function extend(publicAPI, model) {
   macro.obj(model.matrixMTime);
 
   // Build VTK API
-  macro.get(publicAPI, model, ['bounds', 'isIdentity']);
+  macro.get(publicAPI, model, ['isIdentity']);
   macro.getArray(publicAPI, model, ['orientation']);
   macro.setGetArray(publicAPI, model, ['origin', 'position', 'scale'], 3);
+  macro.setGet(publicAPI, model, ['properties']);
 
   // Object internal instance
   model.matrix = mat4.identity(new Float64Array(16));

package/Rendering/Core/RenderWindowInteractor.d.ts

@@ -974,6 +974,12 @@ export interface vtkRenderWindowInteractor extends vtkObject {
   /**
    * Add an HTMLElement as the new container for the interactor.
    * All events will be bound to this new container.
+   *
+   * container will gain the tabIndex=0 attribute to catch keyboard events.
+   * container must have focus (manually via click or tab, or programmatically
+   * via `.focus()`) to receive keypress events
+   * Outline on focus can be customized with CSS :focus pseudo-class.
+   *
    * Any old container will be removed along with its listeners.
    */
   setContainer(container: Nullable<HTMLElement>): boolean;

package/Rendering/Core/RenderWindowInteractor.js

@@ -188,11 +188,13 @@ function vtkRenderWindowInteractor(publicAPI, model) {
     });
     container.addEventListener('pointerup', publicAPI.handlePointerUp);
     container.addEventListener('pointercancel', publicAPI.handlePointerCancel);
-    document.addEventListener('keypress', publicAPI.handleKeyPress);
-    document.addEventListener('keydown', publicAPI.handleKeyDown);
+    container.addEventListener('keypress', publicAPI.handleKeyPress);
+    container.addEventListener('keydown', publicAPI.handleKeyDown);
+    // Observe keyup on document in case the focus changes
+    // between keydown and keyup.
     document.addEventListener('keyup', publicAPI.handleKeyUp);
     document.addEventListener('pointerlockchange', publicAPI.handlePointerLockChange);
-
+    container.tabIndex = 0; // to receive key events
     // using touchAction is more performant than preventDefault
     // in a touchstart handler.
     container.style.touchAction = 'none';
@@ -237,8 +239,8 @@ function vtkRenderWindowInteractor(publicAPI, model) {
       container.removeEventListener('pointerup', publicAPI.handlePointerUp);
       container.removeEventListener('pointercancel', publicAPI.handlePointerCancel);
     }
-    document.removeEventListener('keypress', publicAPI.handleKeyPress);
-    document.removeEventListener('keydown', publicAPI.handleKeyDown);
+    container.removeEventListener('keypress', publicAPI.handleKeyPress);
+    container.removeEventListener('keydown', publicAPI.handleKeyDown);
     document.removeEventListener('keyup', publicAPI.handleKeyUp);
     document.removeEventListener('pointerlockchange', publicAPI.handlePointerLockChange);
     pointerCache.clear();

package/Rendering/Core/Volume.d.ts

@@ -29,22 +29,6 @@ export interface vtkVolume extends vtkProp3D {
    */
   getVolumes(): vtkVolume[];
 
-  /**
-   * Get the volume property
-   */
-  getProperty(): vtkVolumeProperty;
-
-  /**
-   * 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 as [xmin, xmax, ymin, ymax, zmin, zmax].
-   */
-  getBoundsByReference(): Bounds;
-
   /**
    * Get the `Modified Time` which is a monotonic increasing integer
    * global for all vtkObjects.
@@ -75,11 +59,12 @@ export interface vtkVolume extends vtkProp3D {
    */
   setMapper(mapper: vtkVolumeMapper): boolean;
 
-  /**
-   * Set the volume property
-   * @param {vtkVolumeProperty} property
-   */
+  // Inherited from vtkProp3D, but takes a vtkVolumeProperty instead of a generic vtkObject
+  getProperty(mapperInputPort?: number): vtkVolumeProperty;
+  getProperties(): vtkVolumeProperty[];
+  setProperty(mapperInputPort: number, property: vtkVolumeProperty): boolean;
   setProperty(property: vtkVolumeProperty): boolean;
+  setProperties(properties: vtkVolumeProperty[]): boolean;
 }
 
 /**

package/Rendering/Core/Volume.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 vtkVolumeProperty from './VolumeProperty.js';
 
-const {
-  vtkDebugMacro
-} = macro;
-
 // ----------------------------------------------------------------------------
 // vtkVolume methods
 // ----------------------------------------------------------------------------
@@ -15,66 +9,8 @@ const {
 function vtkVolume(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkVolume');
-  publicAPI.getVolumes = () => publicAPI;
+  publicAPI.getVolumes = () => [publicAPI];
   publicAPI.makeProperty = vtkVolumeProperty.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);
-      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 = 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) {
@@ -96,9 +32,7 @@ function vtkVolume(publicAPI, model) {
 // ----------------------------------------------------------------------------
 
 const DEFAULT_VALUES = {
-  mapper: null,
-  property: null,
-  bounds: [1, -1, 1, -1, 1, -1]
+  mapper: null
 };
 
 // ----------------------------------------------------------------------------
@@ -115,9 +49,7 @@ function extend(publicAPI, model) {
   macro.obj(model.boundsMTime);
 
   // Build VTK API
-  macro.set(publicAPI, model, ['property']);
   macro.setGet(publicAPI, model, ['mapper']);
-  macro.getArray(publicAPI, model, ['bounds'], 6);
 
   // Object methods
   vtkVolume(publicAPI, model);

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

@@ -8,14 +8,7 @@ export declare enum BlendMode {
   LABELMAP_EDGE_PROJECTION_BLEND = 6,
 }
 
-export declare enum FilterMode {
-  OFF = 0,
-  NORMALIZED = 1,
-  RAW = 2,
-}
-
 declare const _default: {
   BlendMode: typeof BlendMode;
-  FilterMode: typeof FilterMode;
 };
 export default _default;

package/Rendering/Core/VolumeMapper/Constants.js

@@ -7,14 +7,8 @@ const BlendMode = {
   RADON_TRANSFORM_BLEND: 5,
   LABELMAP_EDGE_PROJECTION_BLEND: 6
 };
-const FilterMode = {
-  OFF: 0,
-  NORMALIZED: 1,
-  RAW: 2
-};
 var Constants = {
-  BlendMode,
-  FilterMode
+  BlendMode
 };
 
-export { BlendMode, FilterMode, Constants as default };
+export { BlendMode, Constants as default };

package/Rendering/Core/VolumeMapper.d.ts

@@ -1,30 +1,22 @@
 import { vtkPiecewiseFunction } from './../../Common/DataModel/PiecewiseFunction';
-import { Bounds, Range, Extent } from './../../types';
+import { Bounds } from './../../types';
 import {
   vtkAbstractMapper3D,
   IAbstractMapper3DInitialValues,
 } from './AbstractMapper3D';
-import { BlendMode, FilterMode } from './VolumeMapper/Constants';
+import { BlendMode } from './VolumeMapper/Constants';
 
 /**
  *
  */
 export interface IVolumeMapperInitialValues
   extends IAbstractMapper3DInitialValues {
-  anisotropy?: number;
   autoAdjustSampleDistances?: boolean;
-  averageIPScalarRange?: Range;
   blendMode?: BlendMode;
   bounds?: Bounds;
-  computeNormalFromOpacity?: boolean;
-  getVolumeShadowSamplingDistFactor?: number;
-  globalIlluminationReach?: number;
-  imageSampleDistance?: number;
-  localAmbientOcclusion?: boolean;
   maximumSamplesPerRay?: number;
   sampleDistance?: number;
-  LAOKernelRadius?: number;
-  LAOKernelSize?: number;
+  volumeShadowSamplingDistFactor?: number;
 }
 
 export interface vtkVolumeMapper extends vtkAbstractMapper3D {
@@ -50,6 +42,12 @@ export interface vtkVolumeMapper extends vtkAbstractMapper3D {
    */
   getSampleDistance(): number;
 
+  /**
+   * Get the multipler for volume shadow sampling distance
+   * @default 5.0
+   */
+  getVolumeShadowSamplingDistFactor(): number;
+
   /**
    * Sampling distance in the XY image dimensions.
    * Default value of 1 meaning 1 ray cast per pixel. If set to 0.5, 4 rays will be cast per pixel.
@@ -85,71 +83,6 @@ export interface vtkVolumeMapper extends vtkAbstractMapper3D {
    */
   getInteractionSampleDistanceFactor(): number;
 
-  /**
-   *
-   */
-  getAverageIPScalarRange(): Range;
-
-  /**
-   *
-   */
-  getAverageIPScalarRangeByReference(): Range;
-
-  /**
-   * Get the blending coefficient that interpolates between surface and volume rendering
-   * @default 0.0
-   */
-  getVolumetricScatteringBlending(): number;
-
-  /**
-   * Get the global illumination reach of volume shadow
-   * @default 0.0
-   */
-  getGlobalIlluminationReach(): number;
-
-  /**
-   * Get the multipler for volume shadow sampling distance
-   * @default 5.0
-   */
-  getVolumeShadowSamplingDistFactor(): number;
-
-  /**
-   * Get anisotropy of volume shadow scatter
-   * @default 0.0
-   */
-  getAnisotropy(): number;
-
-  /**
-   * Get local ambient occlusion flag
-   * @default false
-   */
-  getLocalAmbientOcclusion(): boolean;
-
-  /**
-   * Get kernel size for local ambient occlusion
-   * @default 15
-   */
-  getLAOKernelSize(): number;
-
-  /**
-   * Get kernel radius for local ambient occlusion
-   * @default 7
-   */
-  getLAOKernelRadius(): number;
-
-  /**
-   *
-   * @param x
-   * @param y
-   */
-  setAverageIPScalarRange(x: number, y: number): boolean;
-
-  /**
-   *
-   * @param {Range} averageIPScalarRange
-   */
-  setAverageIPScalarRangeFrom(averageIPScalarRange: Range): boolean;
-
   /**
    * Set blend mode to COMPOSITE_BLEND
    * @param {BlendMode} blendMode
@@ -187,6 +120,13 @@ export interface vtkVolumeMapper extends vtkAbstractMapper3D {
    */
   setSampleDistance(sampleDistance: number): boolean;
 
+  /**
+   * Set the multipler for volume shadow sampling distance. This function is only effective when volumeScatterBlendCoef is greater than 0.
+   * For VSSampleDistanceFactor >= 1.0, volume shadow sampling distance = VSSampleDistanceFactor * SampleDistance.
+   * @param VSSampleDistanceFactor
+   */
+  setVolumeShadowSamplingDistFactor(VSSampleDistanceFactor: number): void;
+
   /**
    *
    * @param imageSampleDistance
@@ -219,102 +159,6 @@ export interface vtkVolumeMapper extends vtkAbstractMapper3D {
     interactionSampleDistanceFactor: number
   ): boolean;
 
-  /**
-   * Set the normal computation to be dependent on the transfer function.
-   * By default, the mapper relies on the scalar gradient for computing normals at sample locations
-   * for lighting calculations. This is an approximation and can lead to inaccurate results.
-   * When enabled, this property makes the mapper compute normals based on the accumulated opacity
-   * at sample locations. This can generate a more accurate representation of edge structures in the
-   * data but adds an overhead and drops frame rate.
-   * @param computeNormalFromOpacity
-   */
-  setComputeNormalFromOpacity(computeNormalFromOpacity: boolean): boolean;
-
-  /**
-   * Set the blending coefficient that determines the interpolation between surface and volume rendering.
-   * Default value of 0.0 means shadow effect is computed with phong model.
-   * Value of 1.0 means shadow is created by volume occlusion.
-   * @param volumeScatterBlendCoef
-   */
-  setVolumetricScatteringBlending(volumeScatterBlendCoef: number): void;
-
-  /**
-   * Set the global illumination reach of volume shadow. This function is only effective when volumeScatterBlendCoef is greater than 0.
-   * Default value of 0.0 means only the neighboring voxel is considered when creating global shadow.
-   * Value of 1.0 means the shadow ray traverses through the entire volume.
-   * @param globalIlluminationReach
-   */
-  setGlobalIlluminationReach(globalIlluminationReach: number): void;
-
-  /**
-   * Set the multipler for volume shadow sampling distance. This function is only effective when volumeScatterBlendCoef is greater than 0.
-   * For VSSampleDistanceFactor >= 1.0, volume shadow sampling distance = VSSampleDistanceFactor * SampleDistance.
-   * @param VSSampleDistanceFactor
-   */
-  setVolumeShadowSamplingDistFactor(VSSampleDistanceFactor: number): void;
-
-  /**
-   * Set anisotropy of volume shadow scatter. This function is only effective when volumeScatterBlendCoef is greater than 0.
-   * Default value of 0.0 means light scatters uniformly in all directions.
-   * Value of -1.0 means light scatters backward, value of 1.0 means light scatters forward.
-   * @param anisotropy
-   */
-  setAnisotropy(anisotropy: number): void;
-
-  /**
-   * Set whether to turn on local ambient occlusion (LAO). LAO is only effective if shading is on and volumeScatterBlendCoef is set to 0.
-   * LAO effect is added to ambient lighting, so the ambient component of the actor needs to be great than 0.
-   * @param localAmbientOcclusion
-   */
-  setLocalAmbientOcclusion(localAmbientOcclusion: boolean): void;
-
-  /**
-   * Set kernel size for local ambient occlusion. It specifies the number of rays that are randomly sampled in the hemisphere.
-   * Value is clipped between 1 and 32.
-   * @param LAOKernelSize
-   */
-  setLAOKernelSize(LAOKernelSize: number): void;
-
-  /**
-   * Set kernel radius for local ambient occlusion. It specifies the number of samples that are considered on each random ray.
-   * Value must be greater than or equal to 1.
-   * @param LAOKernelRadius
-   */
-  setLAOKernelRadius(LAOKernelRadius: number): void;
-
-  /**
-   * Set kernel size for local ambient occlusion. It specifies the number of rays that are randomly sampled in the hemisphere.
-   * Value is clipped between 1 and 32.
-   * @param LAOKernelSize
-   */
-  setLAOKernelSize(LAOKernelSize: number): void;
-
-  /**
-   * Set kernel radius for local ambient occlusion. It specifies the number of samples that are considered on each random ray.
-   * Value must be greater than or equal to 1.
-   * @param LAOKernelRadius
-   */
-  setLAOKernelRadius(LAOKernelRadius: number): 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[];
-
   /**
    *
    */
@@ -450,6 +294,5 @@ export declare const vtkVolumeMapper: {
   newInstance: typeof newInstance;
   extend: typeof extend;
   BlendMode: typeof BlendMode;
-  FilterMode: typeof FilterMode;
 };
 export default vtkVolumeMapper;