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

package/Rendering/Core/VolumeProperty.d.ts

@@ -13,6 +13,7 @@ export interface IVolumePropertyInitialValues {
   specularPower?: number;
   useLabelOutline?: boolean;
   labelOutlineThickness?: number | number[];
+  colorMixPreset?: ColorMixPreset;
 }
 
 export interface vtkVolumeProperty extends vtkObject {
@@ -71,7 +72,7 @@ export interface vtkVolumeProperty extends vtkObject {
   /**
    *
    */
-  getColorMixPreset(): Nullable<ColorMixPreset>;
+  getColorMixPreset(): ColorMixPreset;
 
   /**
    *
@@ -194,7 +195,7 @@ export interface vtkVolumeProperty extends vtkObject {
 
   /**
    * Set the color mix code to a preset value
-   * Set to null to use no preset
+   * Defaults to ColorMixPreset.DEFAULT
    * See the test `testColorMix` for an example on how to use this preset.
    *
    * If set to `CUSTOM`, a tag `//VTK::CustomColorMix` is made available to the
@@ -202,9 +203,9 @@ export interface vtkVolumeProperty extends vtkObject {
    * will be used to mix the colors from each component.
    * Each component is available as a rgba vec4: `comp0`, `comp1`...
    * There are other useful functions or variable available. To find them,
-   * see `//VTK::CustomComponentsColorMix::Impl` tag in `vtkVolumeFS.glsl`.
+   * see `//VTK::CustomColorMix` tag in `vtkVolumeFS.glsl`.
    */
-  setColorMixPreset(preset: Nullable<ColorMixPreset>): boolean;
+  setColorMixPreset(preset: ColorMixPreset): boolean;
 
   /**
    * Does the data have independent components, or do some define color only?
@@ -370,6 +371,121 @@ export interface vtkVolumeProperty extends vtkObject {
    * Get the interpolation type for sampling a volume as a string.
    */
   getInterpolationTypeAsString(): string;
+
+  /**
+   *
+   */
+  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 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 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 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;
 }
 
 /**

package/Rendering/Core/VolumeProperty.js

@@ -1,11 +1,14 @@
 import { m as macro } from '../../macros2.js';
+import { E as clampValue, K as floor } from '../../Common/Core/Math/index.js';
 import vtkColorTransferFunction from './ColorTransferFunction.js';
 import vtkPiecewiseFunction from '../../Common/DataModel/PiecewiseFunction.js';
 import Constants from './VolumeProperty/Constants.js';
 
 const {
   InterpolationType,
-  OpacityMode
+  OpacityMode,
+  FilterMode,
+  ColorMixPreset
 } = Constants;
 const {
   vtkErrorMacro
@@ -19,6 +22,9 @@ const VTK_MAX_VRCOMP = 4;
 function vtkVolumeProperty(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkVolumeProperty');
+  const superClass = {
+    ...publicAPI
+  };
   publicAPI.getMTime = () => {
     let mTime = model.mtime;
     let time;
@@ -197,6 +203,25 @@ function vtkVolumeProperty(publicAPI, model) {
     const cap = macro.capitalize(val);
     publicAPI[`get${cap}`] = index => model.componentData[index][`${val}`];
   });
+  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.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);
 }
 
 // ----------------------------------------------------------------------------
@@ -204,7 +229,7 @@ function vtkVolumeProperty(publicAPI, model) {
 // ----------------------------------------------------------------------------
 
 const DEFAULT_VALUES = {
-  colorMixPreset: null,
+  colorMixPreset: ColorMixPreset.DEFAULT,
   independentComponents: true,
   interpolationType: InterpolationType.FAST_LINEAR,
   shade: false,
@@ -214,7 +239,22 @@ const DEFAULT_VALUES = {
   specularPower: 10.0,
   useLabelOutline: false,
   labelOutlineThickness: [1],
-  labelOutlineOpacity: 1.0
+  labelOutlineOpacity: 1.0,
+  // Properties moved from volume mapper
+  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,
+  anisotropy: 0.0,
+  // local ambient occlusion
+  localAmbientOcclusion: false,
+  LAOKernelSize: 15,
+  LAOKernelRadius: 7
 };
 
 // ----------------------------------------------------------------------------
@@ -245,7 +285,12 @@ function extend(publicAPI, model) {
       });
     }
   }
-  macro.setGet(publicAPI, model, ['colorMixPreset', 'independentComponents', 'interpolationType', 'shade', 'ambient', 'diffuse', 'specular', 'specularPower', 'useLabelOutline', 'labelOutlineOpacity']);
+  macro.setGet(publicAPI, model, ['colorMixPreset', 'independentComponents', 'interpolationType', 'shade', 'ambient', 'diffuse', 'specular', 'specularPower', 'useLabelOutline', 'labelOutlineOpacity',
+  // Properties moved from volume mapper
+  'filterMode', 'preferSizeOverAccuracy', 'computeNormalFromOpacity', 'volumetricScatteringBlending', 'globalIlluminationReach', 'anisotropy', 'localAmbientOcclusion', 'LAOKernelSize', 'LAOKernelRadius']);
+
+  // Property moved from volume mapper
+  macro.setGetArray(publicAPI, model, ['ipScalarRange'], 2);
   macro.setGetArray(publicAPI, model, ['labelOutlineThickness']);
 
   // Object methods

package/Rendering/OpenGL/ImageCPRMapper.js

@@ -11,7 +11,7 @@ import vtkOpenGLTexture from './Texture.js';
 import vtkReplacementShaderMapper from './ReplacementShaderMapper.js';
 import vtkShaderProgram from './ShaderProgram.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
-import { getImageDataHash, getTransferFunctionHash } from './RenderWindow/resourceSharingHelper.js';
+import { getImageDataHash, getTransferFunctionsHash } from './RenderWindow/resourceSharingHelper.js';
 import { v as vtkPolyDataVS } from './glsl/vtkPolyDataVS.glsl.js';
 import { v as vtkPolyDataFS } from './glsl/vtkPolyDataFS.glsl.js';
 import { registerOverride } from './ViewNodeFactory.js';
@@ -181,9 +181,13 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     const iComps = ppty.getIndependentComponents();
     const numIComps = iComps ? numComp : 1;
     const textureHeight = iComps ? 2 * numIComps : 1;
-    const colorTransferFunc = ppty.getRGBTransferFunction();
-    const colorTextureHash = getTransferFunctionHash(colorTransferFunc, iComps, numIComps);
-    const cachedColorEntry = model._openGLRenderWindow.getGraphicsResourceForObject(colorTransferFunc);
+    const colorTransferFunctions = [];
+    for (let component = 0; component < numIComps; ++component) {
+      colorTransferFunctions.push(ppty.getRGBTransferFunction(component));
+    }
+    const colorTextureHash = getTransferFunctionsHash(colorTransferFunctions, iComps, numIComps);
+    const firstColorTransferFunc = ppty.getRGBTransferFunction();
+    const cachedColorEntry = model._openGLRenderWindow.getGraphicsResourceForObject(firstColorTransferFunc);
     const reBuildColorTexture = !cachedColorEntry?.oglObject?.getHandle() || cachedColorEntry?.hash !== colorTextureHash;
     if (reBuildColorTexture) {
       const cWidth = 1024;
@@ -191,7 +195,7 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
       const cTable = new Uint8ClampedArray(cSize);
       model.colorTexture = vtkOpenGLTexture.newInstance();
       model.colorTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-      if (colorTransferFunc) {
+      if (firstColorTransferFunc) {
         const tmpTable = new Float32Array(cWidth * 3);
         for (let c = 0; c < numIComps; c++) {
           const cfun = ppty.getRGBTransferFunction(c);
@@ -219,13 +223,13 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
         model.colorTexture.resetFormatAndType();
         model.colorTexture.create2DFromRaw(cWidth, 1, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
       }
-      if (colorTransferFunc) {
-        model._openGLRenderWindow.setGraphicsResourceForObject(colorTransferFunc, model.colorTexture, colorTextureHash);
-        if (colorTransferFunc !== model._colorTransferFunc) {
-          model._openGLRenderWindow.registerGraphicsResourceUser(colorTransferFunc, publicAPI);
+      if (firstColorTransferFunc) {
+        model._openGLRenderWindow.setGraphicsResourceForObject(firstColorTransferFunc, model.colorTexture, colorTextureHash);
+        if (firstColorTransferFunc !== model._colorTransferFunc) {
+          model._openGLRenderWindow.registerGraphicsResourceUser(firstColorTransferFunc, publicAPI);
           model._openGLRenderWindow.unregisterGraphicsResourceUser(model._colorTransferFunc, publicAPI);
         }
-        model._colorTransferFunc = colorTransferFunc;
+        model._colorTransferFunc = firstColorTransferFunc;
       }
     } else {
       model.colorTexture = cachedColorEntry.oglObject;
@@ -234,9 +238,13 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     // Build piecewise function buffer.  This buffer is used either
     // for component weighting or opacity, depending on whether we're
     // rendering components independently or not.
-    const pwFunc = ppty.getPiecewiseFunction();
-    const pwfTextureHash = getTransferFunctionHash(pwFunc, iComps, numIComps);
-    const cachedPwfEntry = model._openGLRenderWindow.getGraphicsResourceForObject(pwFunc);
+    const opacityFunctions = [];
+    for (let component = 0; component < numIComps; ++component) {
+      opacityFunctions.push(ppty.getPiecewiseFunction(component));
+    }
+    const pwfTextureHash = getTransferFunctionsHash(opacityFunctions, iComps, numIComps);
+    const firstPwFunc = ppty.getPiecewiseFunction();
+    const cachedPwfEntry = model._openGLRenderWindow.getGraphicsResourceForObject(firstPwFunc);
     const reBuildPwf = !cachedPwfEntry?.oglObject?.getHandle() || cachedPwfEntry?.hash !== pwfTextureHash;
     if (reBuildPwf) {
       const pwfWidth = 1024;
@@ -244,7 +252,7 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
       const pwfTable = new Uint8ClampedArray(pwfSize);
       model.pwfTexture = vtkOpenGLTexture.newInstance();
       model.pwfTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-      if (pwFunc) {
+      if (firstPwFunc) {
         const pwfFloatTable = new Float32Array(pwfSize);
         const tmpTable = new Float32Array(pwfWidth);
         for (let c = 0; c < numIComps; ++c) {
@@ -276,13 +284,13 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
         model.pwfTexture.resetFormatAndType();
         model.pwfTexture.create2DFromRaw(pwfWidth, 1, 1, VtkDataTypes.UNSIGNED_CHAR, pwfTable);
       }
-      if (pwFunc) {
-        model._openGLRenderWindow.setGraphicsResourceForObject(pwFunc, model.pwfTexture, pwfTextureHash);
-        if (pwFunc !== model._pwFunc) {
-          model._openGLRenderWindow.registerGraphicsResourceUser(pwFunc, publicAPI);
+      if (firstPwFunc) {
+        model._openGLRenderWindow.setGraphicsResourceForObject(firstPwFunc, model.pwfTexture, pwfTextureHash);
+        if (firstPwFunc !== model._pwFunc) {
+          model._openGLRenderWindow.registerGraphicsResourceUser(firstPwFunc, publicAPI);
           model._openGLRenderWindow.unregisterGraphicsResourceUser(model._pwFunc, publicAPI);
         }
-        model._pwFunc = pwFunc;
+        model._pwFunc = firstPwFunc;
       }
     } else {
       model.pwfTexture = cachedPwfEntry.oglObject;

package/Rendering/OpenGL/ImageMapper.js

@@ -4,14 +4,13 @@ import { n as newInstance$1, e as setGet, o as obj, r as vtkErrorMacro$1, h as c
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import { VtkDataTypes } from '../../Common/Core/DataArray/Constants.js';
 import vtkHelper from './Helper.js';
-import { u as uninitializeBounds } from '../../Common/Core/Math/index.js';
 import vtkOpenGLTexture from './Texture.js';
 import vtkShaderProgram from './ShaderProgram.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { Representation } from '../Core/Property/Constants.js';
 import { Filter, Wrap } from './Texture/Constants.js';
 import { InterpolationType } from '../Core/ImageProperty/Constants.js';
-import { getTransferFunctionHash } from './RenderWindow/resourceSharingHelper.js';
+import { getTransferFunctionsHash } from './RenderWindow/resourceSharingHelper.js';
 import { v as vtkPolyDataVS } from './glsl/vtkPolyDataVS.glsl.js';
 import { v as vtkPolyDataFS } from './glsl/vtkPolyDataFS.glsl.js';
 import vtkReplacementShaderMapper from './ReplacementShaderMapper.js';
@@ -168,9 +167,9 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     // check for the outline thickness and opacity
     const vtkImageLabelOutline = actor.getProperty().getUseLabelOutline();
     if (vtkImageLabelOutline === true) {
-      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::LabelOutline::Dec', ['uniform int outlineThickness;', 'uniform float vpWidth;', 'uniform float vpHeight;', 'uniform float vpOffsetX;', 'uniform float vpOffsetY;', 'uniform mat4 PCWCMatrix;', 'uniform mat4 vWCtoIDX;', 'uniform ivec3 imageDimensions;', 'uniform int sliceAxis;']).result;
+      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::LabelOutline::Dec', ['uniform int outlineThickness;', 'uniform float vpWidth;', 'uniform float vpHeight;', 'uniform float vpOffsetX;', 'uniform float vpOffsetY;', 'uniform mat4 PCWCMatrix;', 'uniform mat4 vWCtoIDX;', 'uniform ivec3 imageDimensions;']).result;
       FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::ImageLabelOutlineOn', '#define vtkImageLabelOutlineOn').result;
-      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::LabelOutlineHelperFunction', ['#ifdef vtkImageLabelOutlineOn', 'vec3 fragCoordToIndexSpace(vec4 fragCoord) {', '  vec4 pcPos = vec4(', '    (fragCoord.x / vpWidth - vpOffsetX - 0.5) * 2.0,', '    (fragCoord.y / vpHeight - vpOffsetY - 0.5) * 2.0,', '    (fragCoord.z - 0.5) * 2.0,', '    1.0);', '', '  vec4 worldCoord = PCWCMatrix * pcPos;', '  vec4 vertex = (worldCoord/worldCoord.w);', '', '  vec3 index = (vWCtoIDX * vertex).xyz;', '', '  // half voxel fix for labelmapOutline', '  return (index + vec3(0.5)) / vec3(imageDimensions);', '}', 'vec2 getSliceCoords(vec3 coord, int axis) {', '  if (axis == 0) return coord.yz;', '  if (axis == 1) return coord.xz;', '  if (axis == 2) return coord.xy;', '}', '#endif']).result;
+      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::LabelOutlineHelperFunction', ['#ifdef vtkImageLabelOutlineOn', 'vec3 fragCoordToIndexSpace(vec4 fragCoord) {', '  vec4 pcPos = vec4(', '    (fragCoord.x / vpWidth - vpOffsetX - 0.5) * 2.0,', '    (fragCoord.y / vpHeight - vpOffsetY - 0.5) * 2.0,', '    (fragCoord.z - 0.5) * 2.0,', '    1.0);', '', '  vec4 worldCoord = PCWCMatrix * pcPos;', '  vec4 vertex = (worldCoord/worldCoord.w);', '', '  vec3 index = (vWCtoIDX * vertex).xyz;', '', '  // half voxel fix for labelmapOutline', '  return (index + vec3(0.5)) / vec3(imageDimensions);', '}', '#endif']).result;
     }
     if (iComps) {
       const rgba = ['r', 'g', 'b', 'a'];
@@ -202,7 +201,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
           FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TCoord::Impl', [...splitStringOnEnter(`
                 #ifdef vtkImageLabelOutlineOn
                   vec3 centerPosIS = fragCoordToIndexSpace(gl_FragCoord);
-                  float centerValue = texture2D(texture1, getSliceCoords(centerPosIS, sliceAxis)).r;
+                  float centerValue = texture2D(texture1, centerPosIS.xy).r;
                   bool pixelOnBorder = false;
                   vec3 tColor = texture2D(colorTexture1, vec2(centerValue * cscale0 + cshift0, 0.5)).rgb;
                   float scalarOpacity = texture2D(pwfTexture1, vec2(centerValue * pwfscale0 + pwfshift0, 0.5)).r;
@@ -213,7 +212,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
                   int actualThickness = int(textureValue * 255.0);
 
                   if (segmentIndex == 0){
-                    gl_FragData[0] = vec4(0.0, 0.0, 0.0, 0.0);
+                    gl_FragData[0] = vec4(0.0, 1.0, 1.0, 0.0);
                     return;
                   }
 
@@ -226,7 +225,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
                         gl_FragCoord.y + float(j),
                         gl_FragCoord.z, gl_FragCoord.w);
                       vec3 neighborPosIS = fragCoordToIndexSpace(neighborPixelCoord);
-                      float value = texture2D(texture1, getSliceCoords(neighborPosIS, sliceAxis)).r;
+                      float value = texture2D(texture1, neighborPosIS.xy).r;
                       if (value != centerValue) {
                         pixelOnBorder = true;
                         break;
@@ -475,14 +474,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     if (vtkImageLabelOutline === true) {
       const worldToIndex = image.getWorldToIndex();
       const imageDimensions = image.getDimensions();
-      let sliceAxis = model.renderable.getClosestIJKAxis().ijkMode;
-
-      // SlicingMode.NONE equates to SlicingMode.K
-      if (sliceAxis === SlicingMode.NONE) {
-        sliceAxis = SlicingMode.K;
-      }
-      program.setUniform3i('imageDimensions', imageDimensions[0], imageDimensions[1], imageDimensions[2]);
-      program.setUniformi('sliceAxis', sliceAxis);
+      program.setUniform3i('imageDimensions', imageDimensions[0], imageDimensions[1], 1);
       program.setUniformMatrix('vWCtoIDX', worldToIndex);
       const labelOutlineKeyMats = model.openGLCamera.getKeyMatrices(ren);
 
@@ -555,13 +547,6 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     publicAPI.renderPieceDraw(ren, actor);
     publicAPI.renderPieceFinish(ren, actor);
   };
-  publicAPI.computeBounds = (ren, actor) => {
-    if (!publicAPI.getInput()) {
-      uninitializeBounds(model.bounds);
-      return;
-    }
-    model.bounds = publicAPI.getInput().getBounds();
-  };
   publicAPI.updateBufferObjects = (ren, actor) => {
     // Rebuild buffers if needed
     if (publicAPI.getNeedToRebuildBufferObjects(ren, actor)) {
@@ -585,9 +570,13 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     const iComps = actorProperty.getIndependentComponents();
     const numIComps = iComps ? numComp : 1;
     const textureHeight = iComps ? 2 * numIComps : 1;
-    const colorTransferFunc = actorProperty.getRGBTransferFunction();
-    const cfunToString = getTransferFunctionHash(colorTransferFunc, iComps, numIComps);
-    const cTex = model._openGLRenderWindow.getGraphicsResourceForObject(colorTransferFunc);
+    const colorTransferFunctions = [];
+    for (let component = 0; component < numIComps; ++component) {
+      colorTransferFunctions.push(actorProperty.getRGBTransferFunction(component));
+    }
+    const cfunToString = getTransferFunctionsHash(colorTransferFunctions, iComps, numIComps);
+    const firstColorTransferFunc = actorProperty.getRGBTransferFunction();
+    const cTex = model._openGLRenderWindow.getGraphicsResourceForObject(firstColorTransferFunc);
     const reBuildC = !cTex?.oglObject?.getHandle() || cTex?.hash !== cfunToString;
     if (reBuildC) {
       model.colorTexture = vtkOpenGLTexture.newInstance({
@@ -605,7 +594,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
         model.colorTexture.setMinificationFilter(Filter.LINEAR);
         model.colorTexture.setMagnificationFilter(Filter.LINEAR);
       }
-      if (colorTransferFunc) {
+      if (firstColorTransferFunc) {
         const tmpTable = new Float32Array(cWidth * 3);
         for (let c = 0; c < numIComps; c++) {
           const cfun = actorProperty.getRGBTransferFunction(c);
@@ -632,13 +621,13 @@ function vtkOpenGLImageMapper(publicAPI, model) {
         }
         model.colorTexture.create2DFromRaw(cWidth, 1, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
       }
-      if (colorTransferFunc) {
-        model._openGLRenderWindow.setGraphicsResourceForObject(colorTransferFunc, model.colorTexture, cfunToString);
-        if (colorTransferFunc !== model._colorTransferFunc) {
-          model._openGLRenderWindow.registerGraphicsResourceUser(colorTransferFunc, publicAPI);
+      if (firstColorTransferFunc) {
+        model._openGLRenderWindow.setGraphicsResourceForObject(firstColorTransferFunc, model.colorTexture, cfunToString);
+        if (firstColorTransferFunc !== model._colorTransferFunc) {
+          model._openGLRenderWindow.registerGraphicsResourceUser(firstColorTransferFunc, publicAPI);
           model._openGLRenderWindow.unregisterGraphicsResourceUser(model._colorTransferFunc, publicAPI);
         }
-        model._colorTransferFunc = colorTransferFunc;
+        model._colorTransferFunc = firstColorTransferFunc;
       }
     } else {
       model.colorTexture = cTex.oglObject;
@@ -647,9 +636,13 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     // Build piecewise function buffer.  This buffer is used either
     // for component weighting or opacity, depending on whether we're
     // rendering components independently or not.
-    const pwFunc = actorProperty.getPiecewiseFunction();
-    const pwfunToString = getTransferFunctionHash(pwFunc, iComps, numIComps);
-    const pwfTex = model._openGLRenderWindow.getGraphicsResourceForObject(pwFunc);
+    const opacityFunctions = [];
+    for (let component = 0; component < numIComps; ++component) {
+      opacityFunctions.push(actorProperty.getPiecewiseFunction(component));
+    }
+    const pwfunToString = getTransferFunctionsHash(opacityFunctions, iComps, numIComps);
+    const firstPwFunc = actorProperty.getPiecewiseFunction();
+    const pwfTex = model._openGLRenderWindow.getGraphicsResourceForObject(firstPwFunc);
     // rebuild opacity tfun?
     const reBuildPwf = !pwfTex?.oglObject?.getHandle() || pwfTex?.hash !== pwfunToString;
     if (reBuildPwf) {
@@ -668,7 +661,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
         model.pwfTexture.setMinificationFilter(Filter.LINEAR);
         model.pwfTexture.setMagnificationFilter(Filter.LINEAR);
       }
-      if (pwFunc) {
+      if (firstPwFunc) {
         const pwfFloatTable = new Float32Array(pwfSize);
         const tmpTable = new Float32Array(pwfWidth);
         for (let c = 0; c < numIComps; ++c) {
@@ -699,13 +692,13 @@ function vtkOpenGLImageMapper(publicAPI, model) {
         pwfTable.fill(255.0);
         model.pwfTexture.create2DFromRaw(pwfWidth, 1, 1, VtkDataTypes.UNSIGNED_CHAR, pwfTable);
       }
-      if (pwFunc) {
-        model._openGLRenderWindow.setGraphicsResourceForObject(pwFunc, model.pwfTexture, pwfunToString);
-        if (pwFunc !== model._pwFunc) {
-          model._openGLRenderWindow.registerGraphicsResourceUser(pwFunc, publicAPI);
+      if (firstPwFunc) {
+        model._openGLRenderWindow.setGraphicsResourceForObject(firstPwFunc, model.pwfTexture, pwfunToString);
+        if (firstPwFunc !== model._pwFunc) {
+          model._openGLRenderWindow.registerGraphicsResourceUser(firstPwFunc, publicAPI);
           model._openGLRenderWindow.unregisterGraphicsResourceUser(model._pwFunc, publicAPI);
         }
-        model._pwFunc = pwFunc;
+        model._pwFunc = firstPwFunc;
       }
     } else {
       model.pwfTexture = pwfTex.oglObject;
@@ -903,7 +896,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     }
   };
   publicAPI.updatelabelOutlineThicknessTexture = image => {
-    const labelOutlineThicknessArray = image.getProperty().getLabelOutlineThicknessByReference();
+    const labelOutlineThicknessArray = image.getProperty().getLabelOutlineThickness();
     const lTex = model._openGLRenderWindow.getGraphicsResourceForObject(labelOutlineThicknessArray);
 
     // compute the join of the labelOutlineThicknessArray so that