@kitware/vtk.js 32.6.2 → 33.0.0-beta.2

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

@@ -63,7 +63,7 @@ export interface IRenderWindowInteractorInitialValues {
   mouseScrollDebounceByPass?: boolean;
 }
 
-export interface IPosition {
+interface IPosition {
   type: string;
 }
 

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,29 +1,21 @@
 import vtkPiecewiseFunction from './../../Common/DataModel/PiecewiseFunction';
-import { Bounds, Range } 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 {
@@ -49,6 +41,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.
@@ -84,71 +82,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
@@ -186,6 +119,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
@@ -218,69 +158,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;
-
   /**
    *
    */
@@ -346,6 +223,5 @@ export declare const vtkVolumeMapper: {
   newInstance: typeof newInstance;
   extend: typeof extend;
   BlendMode: typeof BlendMode;
-  FilterMode: typeof FilterMode;
 };
 export default vtkVolumeMapper;

package/Rendering/Core/VolumeMapper.js

@@ -1,12 +1,11 @@
 import { m as macro } from '../../macros2.js';
-import { H as createUninitializedBounds, E as clampValue, K as floor } from '../../Common/Core/Math/index.js';
 import Constants from './VolumeMapper/Constants.js';
 import vtkAbstractMapper3D from './AbstractMapper3D.js';
+import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkPiecewiseFunction from '../../Common/DataModel/PiecewiseFunction.js';
 
 const {
-  BlendMode,
-  FilterMode
+  BlendMode
 } = Constants;
 function createRadonTransferFunction(firstAbsorbentMaterialHounsfieldValue, firstAbsorbentMaterialAbsorption, maxAbsorbentMaterialHounsfieldValue, maxAbsorbentMaterialAbsorption, outputTransferFunction) {
   let ofun = null;
@@ -21,6 +20,7 @@ function createRadonTransferFunction(firstAbsorbentMaterialHounsfieldValue, firs
   ofun.addPoint(maxAbsorbentMaterialHounsfieldValue, maxAbsorbentMaterialAbsorption);
   return ofun;
 }
+const methodNamesMovedToVolumeProperties = ['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'];
 
 // ----------------------------------------------------------------------------
 // Static API
@@ -41,20 +41,12 @@ function vtkVolumeMapper(publicAPI, model) {
     ...publicAPI
   };
   publicAPI.getBounds = () => {
-    const input = publicAPI.getInputData();
-    if (!input) {
-      model.bounds = createUninitializedBounds();
-    } else {
-      if (!model.static) {
-        publicAPI.update();
-      }
-      model.bounds = input.getBounds();
+    if (!model.static) {
+      publicAPI.update();
     }
+    model.bounds = [...publicAPI.getInputData().getBounds()];
     return model.bounds;
   };
-  publicAPI.update = () => {
-    publicAPI.getInputData();
-  };
   publicAPI.setBlendModeToComposite = () => {
     publicAPI.setBlendMode(BlendMode.COMPOSITE_BLEND);
   };
@@ -74,35 +66,23 @@ function vtkVolumeMapper(publicAPI, model) {
     publicAPI.setBlendMode(BlendMode.RADON_TRANSFORM_BLEND);
   };
   publicAPI.getBlendModeAsString = () => macro.enumToString(BlendMode, model.blendMode);
-  publicAPI.setAverageIPScalarRange = (min, max) => {
-    console.warn('setAverageIPScalarRange is deprecated use setIpScalarRange');
-    publicAPI.setIpScalarRange(min, max);
-  };
-  publicAPI.getFilterModeAsString = () => macro.enumToString(FilterMode, model.filterMode);
-  publicAPI.setFilterModeToOff = () => {
-    publicAPI.setFilterMode(FilterMode.OFF);
-  };
-  publicAPI.setFilterModeToNormalized = () => {
-    publicAPI.setFilterMode(FilterMode.NORMALIZED);
-  };
-  publicAPI.setFilterModeToRaw = () => {
-    publicAPI.setFilterMode(FilterMode.RAW);
-  };
-  publicAPI.setGlobalIlluminationReach = gl => superClass.setGlobalIlluminationReach(clampValue(gl, 0.0, 1.0));
-  publicAPI.setVolumetricScatteringBlending = vsb => superClass.setVolumetricScatteringBlending(clampValue(vsb, 0.0, 1.0));
   publicAPI.setVolumeShadowSamplingDistFactor = vsdf => superClass.setVolumeShadowSamplingDistFactor(vsdf >= 1.0 ? vsdf : 1.0);
-  publicAPI.setAnisotropy = at => superClass.setAnisotropy(clampValue(at, -0.99, 0.99));
-  publicAPI.setLAOKernelSize = ks => superClass.setLAOKernelSize(floor(clampValue(ks, 1, 32)));
-  publicAPI.setLAOKernelRadius = kr => superClass.setLAOKernelRadius(kr >= 1 ? kr : 1);
+
+  // Instead of a "undefined is not a function" error, give more context and advice for these widely used methods
+  methodNamesMovedToVolumeProperties.forEach(removedMethodName => {
+    const removedMethod = () => {
+      throw new Error(`The method "volumeMapper.${removedMethodName}()" doesn't exist anymore. ` + `It is a rendering property that has been moved to the volume property. ` + `Replace your code with:\n` + `volumeActor.getProperty().${removedMethodName}()\n`);
+    };
+    publicAPI[removedMethodName] = removedMethod;
+  });
 }
 
 // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-// TODO: what values to use for averageIPScalarRange to get GLSL to use max / min values like [-Math.inf, Math.inf]?
 const DEFAULT_VALUES = {
-  bounds: [1, -1, 1, -1, 1, -1],
+  bounds: [...vtkBoundingBox.INIT_BOUNDS],
   sampleDistance: 1.0,
   imageSampleDistance: 1.0,
   maximumSamplesPerRay: 1000,
@@ -110,21 +90,7 @@ const DEFAULT_VALUES = {
   initialInteractionScale: 1.0,
   interactionSampleDistanceFactor: 1.0,
   blendMode: BlendMode.COMPOSITE_BLEND,
-  ipScalarRange: [-1000000.0, 1000000.0],
-  filterMode: FilterMode.OFF,
-  // ignored by WebGL so no behavior change
-  preferSizeOverAccuracy: false,
-  // Whether to use halfFloat representation of float, when it is inaccurate
-  computeNormalFromOpacity: false,
-  // volume shadow parameters
-  volumetricScatteringBlending: 0.0,
-  globalIlluminationReach: 0.0,
-  volumeShadowSamplingDistFactor: 5.0,
-  anisotropy: 0.0,
-  // local ambient occlusion
-  localAmbientOcclusion: false,
-  LAOKernelSize: 15,
-  LAOKernelRadius: 7
+  volumeShadowSamplingDistFactor: 5.0
 };
 
 // ----------------------------------------------------------------------------
@@ -133,8 +99,7 @@ function extend(publicAPI, model) {
   let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
   vtkAbstractMapper3D.extend(publicAPI, model, initialValues);
-  macro.setGet(publicAPI, model, ['sampleDistance', 'imageSampleDistance', 'maximumSamplesPerRay', 'autoAdjustSampleDistances', 'initialInteractionScale', 'interactionSampleDistanceFactor', 'blendMode', 'filterMode', 'preferSizeOverAccuracy', 'computeNormalFromOpacity', 'volumetricScatteringBlending', 'globalIlluminationReach', 'volumeShadowSamplingDistFactor', 'anisotropy', 'localAmbientOcclusion', 'LAOKernelSize', 'LAOKernelRadius']);
-  macro.setGetArray(publicAPI, model, ['ipScalarRange'], 2);
+  macro.setGet(publicAPI, model, ['sampleDistance', 'imageSampleDistance', 'maximumSamplesPerRay', 'autoAdjustSampleDistances', 'initialInteractionScale', 'interactionSampleDistanceFactor', 'blendMode', 'volumeShadowSamplingDistFactor']);
   macro.event(publicAPI, model, 'lightingActivated');
 
   // Object methods

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

@@ -10,9 +10,7 @@ export declare enum OpacityMode {
 }
 
 export declare enum ColorMixPreset {
-  // Add a `//VTK::CustomColorMix` tag to the Fragment shader
-  // See usage in file `testColorMix` and in function `setColorMixPreset`
-  CUSTOM = 0,
+  DEFAULT = 0,
 
   // Two components preset
   // Out color: sum of colors weighted by opacity
@@ -23,11 +21,22 @@ export declare enum ColorMixPreset {
   // Out color: color of the first component, colorized by second component with an intensity that is the second component's opacity
   // Out opacity: opacity of the first component
   COLORIZE = 2,
+
+  // Add a `//VTK::CustomColorMix` tag to the Fragment shader
+  // See usage in file `testColorMix` and in function `setColorMixPreset`
+  CUSTOM = 3,
+}
+
+export declare enum FilterMode {
+  OFF = 0,
+  NORMALIZED = 1,
+  RAW = 2,
 }
 
 declare const _default: {
   InterpolationType: typeof InterpolationType;
   OpacityMode: typeof OpacityMode;
   ColorMixPreset: typeof ColorMixPreset;
+  FilterMode: typeof FilterMode;
 };
 export default _default;

package/Rendering/Core/VolumeProperty/Constants.js

@@ -8,14 +8,21 @@ const OpacityMode = {
   PROPORTIONAL: 1
 };
 const ColorMixPreset = {
-  CUSTOM: 0,
+  DEFAULT: 0,
   ADDITIVE: 1,
-  COLORIZE: 2
+  COLORIZE: 2,
+  CUSTOM: 3
+};
+const FilterMode = {
+  OFF: 0,
+  NORMALIZED: 1,
+  RAW: 2
 };
 var Constants = {
   InterpolationType,
   OpacityMode,
-  ColorMixPreset
+  ColorMixPreset,
+  FilterMode
 };
 
-export { ColorMixPreset, InterpolationType, OpacityMode, Constants as default };
+export { ColorMixPreset, FilterMode, InterpolationType, OpacityMode, Constants as default };