@kitware/vtk.js 33.3.2 → 34.0.0-beta.2

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,14 +203,33 @@ 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);
 }
 
 // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-const DEFAULT_VALUES = {
-  colorMixPreset: null,
+const defaultValues = initialValues => ({
+  colorMixPreset: ColorMixPreset.DEFAULT,
   independentComponents: true,
   interpolationType: InterpolationType.FAST_LINEAR,
   shade: false,
@@ -214,14 +239,31 @@ 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,
+  updatedExtents: [],
+  ...initialValues
+});
 
 // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
   let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
+  Object.assign(model, defaultValues(initialValues));
 
   // Build VTK API
   macro.obj(publicAPI, model);
@@ -245,7 +287,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', 'updatedExtents']);
+
+  // Property moved from volume mapper
+  macro.setGetArray(publicAPI, model, ['ipScalarRange'], 2);
   macro.setGetArray(publicAPI, model, ['labelOutlineThickness']);
 
   // Object methods

package/Rendering/OpenGL/Framebuffer.js

@@ -162,7 +162,13 @@ function vtkFramebuffer(publicAPI, model) {
     texture.setOpenGLRenderWindow(model._openGLRenderWindow);
     texture.setMinificationFilter(Filter.LINEAR);
     texture.setMagnificationFilter(Filter.LINEAR);
-    texture.create2DFromRaw(model.glFramebuffer.width, model.glFramebuffer.height, 4, VtkDataTypes.UNSIGNED_CHAR, null);
+    texture.create2DFromRaw({
+      width: model.glFramebuffer.width,
+      height: model.glFramebuffer.height,
+      numComps: 4,
+      dataType: VtkDataTypes.UNSIGNED_CHAR,
+      data: null
+    });
     publicAPI.setColorBuffer(texture);
 
     // for now do not count on having a depth buffer texture

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';
@@ -147,6 +147,7 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
   publicAPI.buildBufferObjects = (ren, actor) => {
     const image = model.currentImageDataInput;
     const centerline = model.currentCenterlineInput;
+    const property = actor.getProperty();
 
     // Rebuild the volumeTexture if the data has changed
     const scalars = image?.getPointData()?.getScalars();
@@ -156,7 +157,7 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     const cachedScalarsEntry = model._openGLRenderWindow.getGraphicsResourceForObject(scalars);
     const volumeTextureHash = getImageDataHash(image, scalars);
     const reBuildTex = !cachedScalarsEntry?.oglObject?.getHandle() || cachedScalarsEntry?.hash !== volumeTextureHash;
-    const updatedExtents = model.renderable.getUpdatedExtents();
+    const updatedExtents = property.getUpdatedExtents();
     const hasUpdatedExtents = !!updatedExtents.length;
     if (reBuildTex) {
       model.volumeTexture = vtkOpenGLTexture.newInstance();
@@ -166,7 +167,13 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
       // Use norm16 for scalar texture if the extension is available
       model.volumeTexture.setOglNorm16Ext(model.context.getExtension('EXT_texture_norm16'));
       model.volumeTexture.resetFormatAndType();
-      model.volumeTexture.create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars, model.renderable.getPreferSizeOverAccuracy());
+      model.volumeTexture.create3DFilterableFromDataArray({
+        width: dims[0],
+        height: dims[1],
+        depth: dims[2],
+        dataArray: scalars,
+        preferSizeOverAccuracy: model.renderable.getPreferSizeOverAccuracy()
+      });
       model._openGLRenderWindow.setGraphicsResourceForObject(scalars, model.volumeTexture, volumeTextureHash);
       if (scalars !== model._scalars) {
         model._openGLRenderWindow.registerGraphicsResourceUser(scalars, publicAPI);
@@ -179,9 +186,15 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     if (hasUpdatedExtents) {
       // If hasUpdatedExtents, then the texture is partially updated.
       // clear the array to acknowledge the update.
-      model.renderable.setUpdatedExtents([]);
+      property.setUpdatedExtents([]);
       const dims = image.getDimensions();
-      model.volumeTexture.create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars, false, updatedExtents);
+      model.volumeTexture.create3DFilterableFromDataArray({
+        width: dims[0],
+        height: dims[1],
+        depth: dims[2],
+        dataArray: scalars,
+        updatedExtents
+      });
     }
 
     // Rebuild the color texture if needed
@@ -190,9 +203,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) {
       let cWidth = model.renderable.getColorTextureWidth();
@@ -203,7 +220,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);
@@ -221,7 +238,13 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
           }
         }
         model.colorTexture.resetFormatAndType();
-        model.colorTexture.create2DFromRaw(cWidth, textureHeight, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
+        model.colorTexture.create2DFromRaw({
+          width: cWidth,
+          height: textureHeight,
+          numComps: 3,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: cTable
+        });
       } else {
         for (let i = 0; i < cWidth * 3; ++i) {
           cTable[i] = 255.0 * i / ((cWidth - 1) * 3);
@@ -229,15 +252,21 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
           cTable[i + 2] = 255.0 * i / ((cWidth - 1) * 3);
         }
         model.colorTexture.resetFormatAndType();
-        model.colorTexture.create2DFromRaw(cWidth, 1, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
+        model.colorTexture.create2DFromRaw({
+          width: cWidth,
+          height: 1,
+          numComps: 3,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: 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;
@@ -246,9 +275,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) {
       let pwfWidth = model.renderable.getOpacityTextureWidth();
@@ -259,7 +292,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) {
@@ -284,20 +317,32 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
           }
         }
         model.pwfTexture.resetFormatAndType();
-        model.pwfTexture.create2DFromRaw(pwfWidth, textureHeight, 1, VtkDataTypes.FLOAT, pwfFloatTable);
+        model.pwfTexture.create2DFromRaw({
+          width: pwfWidth,
+          height: textureHeight,
+          numComps: 1,
+          dataType: VtkDataTypes.FLOAT,
+          data: pwfFloatTable
+        });
       } else {
         // default is opaque
         pwfTable.fill(255.0);
         model.pwfTexture.resetFormatAndType();
-        model.pwfTexture.create2DFromRaw(pwfWidth, 1, 1, VtkDataTypes.UNSIGNED_CHAR, pwfTable);
+        model.pwfTexture.create2DFromRaw({
+          width: pwfWidth,
+          height: 1,
+          numComps: 1,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: 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';
@@ -555,13 +554,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 +577,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({
@@ -608,7 +604,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);
@@ -626,22 +622,34 @@ function vtkOpenGLImageMapper(publicAPI, model) {
           }
         }
         model.colorTexture.resetFormatAndType();
-        model.colorTexture.create2DFromRaw(cWidth, textureHeight, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
+        model.colorTexture.create2DFromRaw({
+          width: cWidth,
+          height: textureHeight,
+          numComps: 3,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: cTable
+        });
       } else {
         for (let i = 0; i < cWidth * 3; ++i) {
           cTable[i] = 255.0 * i / ((cWidth - 1) * 3);
           cTable[i + 1] = 255.0 * i / ((cWidth - 1) * 3);
           cTable[i + 2] = 255.0 * i / ((cWidth - 1) * 3);
         }
-        model.colorTexture.create2DFromRaw(cWidth, 1, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
+        model.colorTexture.create2DFromRaw({
+          width: cWidth,
+          height: 1,
+          numComps: 3,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: 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;
@@ -650,9 +658,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) {
@@ -674,7 +686,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,19 +711,31 @@ function vtkOpenGLImageMapper(publicAPI, model) {
           }
         }
         model.pwfTexture.resetFormatAndType();
-        model.pwfTexture.create2DFromRaw(pwfWidth, textureHeight, 1, VtkDataTypes.FLOAT, pwfFloatTable);
+        model.pwfTexture.create2DFromRaw({
+          width: pwfWidth,
+          height: textureHeight,
+          numComps: 1,
+          dataType: VtkDataTypes.FLOAT,
+          data: pwfFloatTable
+        });
       } else {
         // default is opaque
         pwfTable.fill(255.0);
-        model.pwfTexture.create2DFromRaw(pwfWidth, 1, 1, VtkDataTypes.UNSIGNED_CHAR, pwfTable);
+        model.pwfTexture.create2DFromRaw({
+          width: pwfWidth,
+          height: 1,
+          numComps: 1,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: 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;
@@ -887,7 +911,15 @@ function vtkOpenGLImageMapper(publicAPI, model) {
       // Don't share this resource as `scalars` is created in this function
       // so it is impossible to share
       model.openGLTexture.resetFormatAndType();
-      model.openGLTexture.create2DFilterableFromRaw(dims[0], dims[1], numComp, imgScalars.getDataType(), scalars, model.renderable.getPreferSizeOverAccuracy?.(), ranges);
+      model.openGLTexture.create2DFilterableFromRaw({
+        width: dims[0],
+        height: dims[1],
+        numComps: numComp,
+        dataType: imgScalars.getDataType(),
+        data: scalars,
+        preferSizeOverAccuracy: !!model.renderable.getPreferSizeOverAccuracy?.(),
+        ranges
+      });
       model.openGLTexture.activate();
       model.openGLTexture.sendParameters();
       model.openGLTexture.deactivate();
@@ -957,7 +989,13 @@ function vtkOpenGLImageMapper(publicAPI, model) {
       model.labelOutlineThicknessTexture.setMagnificationFilter(Filter.NEAREST);
 
       // Create a 2D texture (acting as 1D) from the raw data
-      model.labelOutlineThicknessTexture.create2DFromRaw(lWidth, lHeight, 1, VtkDataTypes.UNSIGNED_CHAR, lTable);
+      model.labelOutlineThicknessTexture.create2DFromRaw({
+        width: lWidth,
+        height: lHeight,
+        numComps: 1,
+        dataType: VtkDataTypes.UNSIGNED_CHAR,
+        data: lTable
+      });
       if (labelOutlineThicknessArray) {
         model._openGLRenderWindow.setGraphicsResourceForObject(labelOutlineThicknessArray, model.labelOutlineThicknessTexture, toString);
         if (labelOutlineThicknessArray !== model._labelOutlineThicknessArray) {