@kitware/vtk.js 28.12.4 → 28.13.0

package/Imaging/Core/ImageReslice.js

@@ -29,7 +29,7 @@ function vtkImageReslice(publicAPI, model) {
   const superClass = {
     ...publicAPI
   };
-  let indexMatrix = null;
+  const indexMatrix = mat4.identity(new Float64Array(16));
   let optimizedTransform = null;
   function getImageResliceSlabTrap(tmpPtr, inComponents, sampleCount, f) {
     const n = sampleCount - 1;
@@ -218,7 +218,7 @@ function vtkImageReslice(publicAPI, model) {
     let interpolationMode = model.interpolationMode;
     model.usePermuteExecute = false;
     if (model.optimization) {
-      if (model.slabSliceSpacingFraction === 1.0 && model.interpolator.isSeparable() && publicAPI.isPermutationMatrix(indexMatrix)) {
+      if (optimizedTransform == null && model.slabSliceSpacingFraction === 1.0 && model.interpolator.isSeparable() && publicAPI.isPermutationMatrix(indexMatrix)) {
         model.usePermuteExecute = true;
         if (publicAPI.canUseNearestNeighbor(indexMatrix, outWholeExt)) {
           interpolationMode = InterpolationMode.NEAREST;
@@ -286,7 +286,7 @@ function vtkImageReslice(publicAPI, model) {
     const rescaleScalars = model.scalarShift !== 0.0 || model.scalarScale !== 1.0;
 
     // is nearest neighbor optimization possible?
-    const optimizeNearest = interpolationMode === InterpolationMode.NEAREST && borderMode === ImageBorderMode.CLAMP && !(perspective || convertScalars != null || rescaleScalars) && inputScalarType === outScalars.getDataType() && fullSize === inScalars.getNumberOfTuples() && model.border === true && nsamples <= 1;
+    const optimizeNearest = interpolationMode === InterpolationMode.NEAREST && borderMode === ImageBorderMode.CLAMP && !(optimizedTransform != null || perspective || convertScalars != null || rescaleScalars) && inputScalarType === outScalars.getDataType() && fullSize === inScalars.getNumberOfTuples() && model.border === true && nsamples <= 1;
 
     // get pixel information
     const scalarType = outScalars.getDataType();
@@ -306,11 +306,6 @@ function vtkImageReslice(publicAPI, model) {
       origin[i] = newmat[4 * 3 + i];
     }
 
-    // get the input origin and spacing for conversion purposes
-    model.interpolator.getOrigin();
-    const inSpacing = model.interpolator.getSpacing();
-    [1.0 / inSpacing[0], 1.0 / inSpacing[1], 1.0 / inSpacing[2]];
-
     // allocate an output row of type double
     let floatPtr = null;
     if (!optimizeNearest) {
@@ -409,6 +404,16 @@ function vtkImageReslice(publicAPI, model) {
                   inPoint[1] *= f;
                   inPoint[2] *= f;
                 }
+                if (optimizedTransform !== null) {
+                  // get the input origin and spacing for conversion purposes
+                  const inOrigin = model.interpolator.getOrigin();
+                  const inSpacing = model.interpolator.getSpacing();
+                  const inInvSpacing = [1.0 / inSpacing[0], 1.0 / inSpacing[1], 1.0 / inSpacing[2]];
+
+                  // apply the AbstractTransform if there is one
+                  // TBD: handle inDirection
+                  publicAPI.applyTransform(optimizedTransform, inPoint, inOrigin, inInvSpacing);
+                }
                 if (model.interpolator.checkBoundsIJK(inPoint)) {
                   // do the interpolation
                   isInBounds = 1;
@@ -541,63 +546,29 @@ function vtkImageReslice(publicAPI, model) {
    * @returns
    */
   publicAPI.getIndexMatrix = (input, output) => {
-    // first verify that we have to update the matrix
-    if (indexMatrix === null) {
-      indexMatrix = mat4.identity(new Float64Array(16));
-    }
-    const inOrigin = input.getOrigin();
-    const inSpacing = input.getSpacing();
-    const inDirection = input.getDirection();
-    const outOrigin = output.getOrigin();
-    const outSpacing = output.getSpacing();
     const transform = mat4.identity(new Float64Array(16));
-    const inMatrix = mat4.identity(new Float64Array(16));
-    const outMatrix = mat4.identity(new Float64Array(16));
+    optimizedTransform = null;
     if (model.resliceAxes) {
       mat4.copy(transform, model.resliceAxes);
     }
     if (model.resliceTransform) {
       if (model.resliceTransform.isA('vtkHomogeneousTransform')) {
-        // transform->PostMultiply();
-        // transform->Concatenate(
-        // mat4.multiply(transform, transform, model.resliceTransform.getMatrix());
         mat4.multiply(transform, model.resliceTransform.getMatrix(), transform);
       } else {
         // TODO
         vtkWarningMacro('Non homogeneous transform have not yet been ported');
       }
     }
-    if (!vtkMath.isIdentity3x3(inDirection)) {
-      const imageTransform = vtkMatrixBuilder.buildFromRadian().translate(inOrigin[0], inOrigin[1], inOrigin[2]).multiply3x3(inDirection).translate(-inOrigin[0], -inOrigin[1], -inOrigin[2]);
-      mat4.multiply(transform, imageTransform.getMatrix(), transform);
-    }
-
-    // check to see if we have an identity matrix
-    let isIdentity = vtkMath.isIdentity(transform);
 
     // the outMatrix takes OutputData indices to OutputData coordinates,
+    const outMatrix = output.getIndexToWorld();
+    mat4.multiply(transform, transform, outMatrix);
+
     // the inMatrix takes InputData coordinates to InputData indices
-    for (let i = 0; i < 3; i++) {
-      if ((inSpacing[i] !== outSpacing[i] || inOrigin[i] !== outOrigin[i]) || optimizedTransform != null ) {
-        isIdentity = false;
-      }
-      inMatrix[4 * i + i] = 1.0 / inSpacing[i];
-      inMatrix[4 * 3 + i] = -inOrigin[i] / inSpacing[i];
-      outMatrix[4 * i + i] = outSpacing[i];
-      outMatrix[4 * 3 + i] = outOrigin[i];
-    }
-    if (!isIdentity) {
-      // transform.PreMultiply();
-      // transform.Concatenate(outMatrix);
-      mat4.multiply(transform, transform, outMatrix);
-
-      // the optimizedTransform requires data coords, not
-      // index coords, as its input
-      {
-        // transform->PostMultiply();
-        // transform->Concatenate(inMatrix);
-        mat4.multiply(transform, inMatrix, transform);
-      }
+    // the optimizedTransform requires data coords, not index coords, as its input
+    if (optimizedTransform == null) {
+      const inMatrix = input.getWorldToIndex();
+      mat4.multiply(transform, inMatrix, transform);
     }
     mat4.copy(indexMatrix, transform);
     return indexMatrix;

package/Interaction/UI/FPSMonitor.js

@@ -123,6 +123,7 @@ function vtkFPSMonitor(publicAPI, model) {
       model.fpsSum -= model.buffer.shift();
     }
     renderTitle();
+    renderInfo();
     renderCanvas();
   }
 

package/Proxy/Core/View2DProxy.js

@@ -257,6 +257,9 @@ function vtkView2DProxy(publicAPI, model) {
   }
   publicAPI.bindRepresentationToManipulator = representation => {
     let nbListeners = 0;
+    if (!representation.getProxyId) {
+      return nbListeners;
+    }
     model.rangeManipulator.removeAllListeners();
     model.sliceRepresentation = representation;
     while (model.sliceRepresentationSubscriptions.length) {

package/Rendering/Core/ImageProperty.js

@@ -38,7 +38,9 @@ function vtkImageProperty(publicAPI, model) {
   };
 
   // Set the color of a volume to an RGB transfer function
-  publicAPI.setRGBTransferFunction = (index, func) => {
+  publicAPI.setRGBTransferFunction = function () {
+    let index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    let func = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
     // backwards compatible call without the component index
     let idx = index;
     let transferFunc = func;
@@ -61,7 +63,9 @@ function vtkImageProperty(publicAPI, model) {
   };
 
   // Set the piecewise function
-  publicAPI.setPiecewiseFunction = (index, func) => {
+  publicAPI.setPiecewiseFunction = function () {
+    let index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    let func = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
     let idx = index;
     let transferFunc = func;
     if (!Number.isInteger(index)) {
@@ -83,7 +87,9 @@ function vtkImageProperty(publicAPI, model) {
   };
 
   // Alias to set the piecewise function
-  publicAPI.setScalarOpacity = (index, func) => {
+  publicAPI.setScalarOpacity = function () {
+    let index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    let func = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
     // backwards compatible call without the component index
     let idx = index;
     let transferFunc = func;
@@ -99,7 +105,9 @@ function vtkImageProperty(publicAPI, model) {
     let idx = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
     return publicAPI.getPiecewiseFunction(idx);
   };
-  publicAPI.setComponentWeight = (index, value) => {
+  publicAPI.setComponentWeight = function () {
+    let index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    let value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
     if (index < 0 || index >= VTK_MAX_VRCOMP) {
       vtkErrorMacro('Invalid index');
       return false;
@@ -112,7 +120,8 @@ function vtkImageProperty(publicAPI, model) {
     }
     return false;
   };
-  publicAPI.getComponentWeight = index => {
+  publicAPI.getComponentWeight = function () {
+    let index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
     if (index < 0 || index >= VTK_MAX_VRCOMP) {
       vtkErrorMacro('Invalid index');
       return 0.0;

package/Rendering/Core/Mapper2D.js

@@ -116,6 +116,16 @@ function vtkMapper2D(publicAPI, model) {
     }
     model.colorBuildString = `${publicAPI.getMTime()}${scalars.getMTime()}${alpha}`;
   };
+  publicAPI.getPrimitiveCount = () => {
+    const input = publicAPI.getInputData();
+    const pcount = {
+      points: input.getPoints().getNumberOfValues() / 3,
+      verts: input.getVerts().getNumberOfValues() - input.getVerts().getNumberOfCells(),
+      lines: input.getLines().getNumberOfValues() - 2 * input.getLines().getNumberOfCells(),
+      triangles: input.getPolys().getNumberOfValues() - 3 * input.getPolys().getNumberOfCells()
+    };
+    return pcount;
+  };
 }
 
 // ----------------------------------------------------------------------------

package/Rendering/Core/RenderWindow.js

@@ -94,22 +94,31 @@ function vtkRenderWindow(publicAPI, model) {
   publicAPI.getStatistics = () => {
     const results = {
       propCount: 0,
-      invisiblePropCount: 0
+      invisiblePropCount: 0,
+      gpuMemoryMB: 0
     };
+    model._views.forEach(v => {
+      results.gpuMemoryMB += v.getGraphicsMemoryInfo() / 1e6;
+    });
     model.renderers.forEach(ren => {
       const props = ren.getViewProps();
+      const gren = model._views[0].getViewNodeFor(ren);
       props.forEach(prop => {
         if (prop.getVisibility()) {
           results.propCount += 1;
           const mpr = prop.getMapper && prop.getMapper();
           if (mpr && mpr.getPrimitiveCount) {
-            const pcount = mpr.getPrimitiveCount();
-            Object.keys(pcount).forEach(keyName => {
-              if (!results[keyName]) {
-                results[keyName] = 0;
-              }
-              results[keyName] += pcount[keyName];
-            });
+            const gmpr = gren.getViewNodeFor(mpr);
+            if (gmpr) {
+              results.gpuMemoryMB += gmpr.getAllocatedGPUMemoryInBytes() / 1e6;
+              const pcount = mpr.getPrimitiveCount();
+              Object.keys(pcount).forEach(keyName => {
+                if (!results[keyName]) {
+                  results[keyName] = 0;
+                }
+                results[keyName] += pcount[keyName];
+              });
+            }
           }
         } else {
           results.invisiblePropCount += 1;

package/Rendering/Core/VolumeProperty.js

@@ -63,7 +63,9 @@ function vtkVolumeProperty(publicAPI, model) {
   };
 
   // Set the color of a volume to a gray transfer function
-  publicAPI.setGrayTransferFunction = (index, func) => {
+  publicAPI.setGrayTransferFunction = function () {
+    let index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    let func = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
     let modified = false;
     if (model.componentData[index].grayTransferFunction !== func) {
       model.componentData[index].grayTransferFunction = func;
@@ -80,7 +82,8 @@ function vtkVolumeProperty(publicAPI, model) {
   };
 
   // Get the currently set gray transfer function. Create one if none set.
-  publicAPI.getGrayTransferFunction = index => {
+  publicAPI.getGrayTransferFunction = function () {
+    let index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
     if (model.componentData[index].grayTransferFunction === null) {
       model.componentData[index].grayTransferFunction = vtkPiecewiseFunction.newInstance();
       model.componentData[index].grayTransferFunction.addPoint(0, 0.0);
@@ -94,7 +97,9 @@ function vtkVolumeProperty(publicAPI, model) {
   };
 
   // Set the color of a volume to an RGB transfer function
-  publicAPI.setRGBTransferFunction = (index, func) => {
+  publicAPI.setRGBTransferFunction = function () {
+    let index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    let func = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
     let modified = false;
     if (model.componentData[index].rGBTransferFunction !== func) {
       model.componentData[index].rGBTransferFunction = func;
@@ -111,7 +116,8 @@ function vtkVolumeProperty(publicAPI, model) {
   };
 
   // Get the currently set RGB transfer function. Create one if none set.
-  publicAPI.getRGBTransferFunction = index => {
+  publicAPI.getRGBTransferFunction = function () {
+    let index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
     if (model.componentData[index].rGBTransferFunction === null) {
       model.componentData[index].rGBTransferFunction = vtkColorTransferFunction.newInstance();
       model.componentData[index].rGBTransferFunction.addRGBPoint(0, 0.0, 0.0, 0.0);
@@ -125,7 +131,9 @@ function vtkVolumeProperty(publicAPI, model) {
   };
 
   // Set the scalar opacity of a volume to a transfer function
-  publicAPI.setScalarOpacity = (index, func) => {
+  publicAPI.setScalarOpacity = function () {
+    let index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    let func = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
     if (model.componentData[index].scalarOpacity !== func) {
       model.componentData[index].scalarOpacity = func;
       publicAPI.modified();
@@ -135,7 +143,8 @@ function vtkVolumeProperty(publicAPI, model) {
   };
 
   // Get the scalar opacity transfer function. Create one if none set.
-  publicAPI.getScalarOpacity = index => {
+  publicAPI.getScalarOpacity = function () {
+    let index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
     if (model.componentData[index].scalarOpacity === null) {
       model.componentData[index].scalarOpacity = vtkPiecewiseFunction.newInstance();
       model.componentData[index].scalarOpacity.addPoint(0, 1.0);
@@ -144,7 +153,9 @@ function vtkVolumeProperty(publicAPI, model) {
     }
     return model.componentData[index].scalarOpacity;
   };
-  publicAPI.setComponentWeight = (index, value) => {
+  publicAPI.setComponentWeight = function () {
+    let index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    let value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
     if (index < 0 || index >= VTK_MAX_VRCOMP) {
       vtkErrorMacro('Invalid index');
       return false;
@@ -157,7 +168,8 @@ function vtkVolumeProperty(publicAPI, model) {
     }
     return false;
   };
-  publicAPI.getComponentWeight = index => {
+  publicAPI.getComponentWeight = function () {
+    let index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
     if (index < 0 || index >= VTK_MAX_VRCOMP) {
       vtkErrorMacro('Invalid index');
       return 0.0;

package/Rendering/OpenGL/BufferObject.js

@@ -70,6 +70,7 @@ function vtkOpenGLBufferObject(publicAPI, model) {
     }
     model.context.bindBuffer(convertType(internalType), internalHandle);
     model.context.bufferData(convertType(internalType), data, model.context.STATIC_DRAW);
+    model.allocatedGPUMemoryInBytes = data.length * data.BYTES_PER_ELEMENT;
     dirty = false;
     return true;
   };
@@ -92,6 +93,7 @@ function vtkOpenGLBufferObject(publicAPI, model) {
       model.context.bindBuffer(convertType(internalType), null);
       model.context.deleteBuffer(internalHandle);
       internalHandle = null;
+      model.allocatedGPUMemoryInBytes = 0;
     }
   };
   publicAPI.setOpenGLRenderWindow = rw => {
@@ -115,7 +117,8 @@ function vtkOpenGLBufferObject(publicAPI, model) {
 const DEFAULT_VALUES = {
   objectType: ObjectType.ARRAY_BUFFER,
   // _openGLRenderWindow: null,
-  context: null
+  context: null,
+  allocatedGPUMemoryInBytes: 0
 };
 
 // ----------------------------------------------------------------------------
@@ -126,7 +129,7 @@ function extend(publicAPI, model) {
 
   // Object methods
   macro.obj(publicAPI, model);
-  macro.get(publicAPI, model, ['_openGLRenderWindow']);
+  macro.get(publicAPI, model, ['_openGLRenderWindow', 'allocatedGPUMemoryInBytes']);
   macro.moveToProtected(publicAPI, model, ['openGLRenderWindow']);
   vtkOpenGLBufferObject(publicAPI, model);
 }

package/Rendering/OpenGL/Helper.js

@@ -168,6 +168,7 @@ function vtkOpenGLHelper(publicAPI, model) {
     }
     return 6;
   };
+  publicAPI.getAllocatedGPUMemoryInBytes = () => publicAPI.getCABO().getAllocatedGPUMemoryInBytes();
 }
 
 // ----------------------------------------------------------------------------

package/Rendering/OpenGL/ImageMapper.js

@@ -27,11 +27,10 @@ const {
 // helper methods
 // ----------------------------------------------------------------------------
 
-function computeFnToString(property, fn, numberOfComponents) {
-  const pwfun = fn.apply(property);
+function computeFnToString(property, pwfun, numberOfComponents) {
   if (pwfun) {
     const iComps = property.getIndependentComponents();
-    return `${property.getMTime()}-${iComps}-${numberOfComponents}`;
+    return `${pwfun.getMTime()}-${iComps}-${numberOfComponents}`;
   }
   return '0';
 }
@@ -51,9 +50,6 @@ function vtkOpenGLImageMapper(publicAPI, model) {
       model._openGLRenderWindow = model._openGLRenderer.getParent();
       model.context = model._openGLRenderWindow.getContext();
       model.tris.setOpenGLRenderWindow(model._openGLRenderWindow);
-      model.openGLTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-      model.colorTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-      model.pwfTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
       const ren = model._openGLRenderer.getRenderable();
       model.openGLCamera = model._openGLRenderer.getViewNodeFor(ren.getActiveCamera());
       // is slice set by the camera
@@ -226,7 +222,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     if (!model.currentRenderPass && model.lastRenderPassShaderReplacement || model.currentRenderPass && model.currentRenderPass.getShaderReplacement() !== model.lastRenderPassShaderReplacement) {
       needRebuild = true;
     }
-    if (needRebuild || model.lastHaveSeenDepthRequest !== model.haveSeenDepthRequest || cellBO.getProgram() === 0 || model.lastTextureComponents !== tNumComp || model.lastIndependentComponents !== iComp) {
+    if (needRebuild || model.lastHaveSeenDepthRequest !== model.haveSeenDepthRequest || cellBO.getProgram()?.getHandle() === 0 || model.lastTextureComponents !== tNumComp || model.lastIndependentComponents !== iComp) {
       model.lastHaveSeenDepthRequest = model.haveSeenDepthRequest;
       model.lastTextureComponents = tNumComp;
       model.lastIndependentComponents = iComp;
@@ -474,33 +470,34 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     const dataType = imgScalars.getDataType();
     const numComp = imgScalars.getNumberOfComponents();
     const actorProperty = actor.getProperty();
-
-    // set interpolation on the texture based on property setting
     const iType = actorProperty.getInterpolationType();
-    if (iType === InterpolationType.NEAREST) {
-      model.colorTexture.setMinificationFilter(Filter.NEAREST);
-      model.colorTexture.setMagnificationFilter(Filter.NEAREST);
-      model.pwfTexture.setMinificationFilter(Filter.NEAREST);
-      model.pwfTexture.setMagnificationFilter(Filter.NEAREST);
-    } else {
-      model.colorTexture.setMinificationFilter(Filter.LINEAR);
-      model.colorTexture.setMagnificationFilter(Filter.LINEAR);
-      model.pwfTexture.setMinificationFilter(Filter.LINEAR);
-      model.pwfTexture.setMagnificationFilter(Filter.LINEAR);
-    }
     const iComps = actorProperty.getIndependentComponents();
     const numIComps = iComps ? numComp : 1;
     const textureHeight = iComps ? 2 * numIComps : 1;
-    const cfunToString = computeFnToString(actorProperty, actorProperty.getRGBTransferFunction, numIComps);
-    if (model.colorTextureString !== cfunToString) {
+    const colorTransferFunc = actorProperty.getRGBTransferFunction();
+    const cfunToString = computeFnToString(actorProperty, colorTransferFunc, numIComps);
+    const cTex = model._openGLRenderWindow.getGraphicsResourceForObject(colorTransferFunc);
+    const reBuildC = !cTex?.vtkObj || cTex?.hash !== cfunToString || model.colorTextureString !== cfunToString;
+    if (reBuildC) {
       const cWidth = 1024;
       const cSize = cWidth * textureHeight * 3;
       const cTable = new Uint8Array(cSize);
-      let cfun = actorProperty.getRGBTransferFunction();
-      if (cfun) {
+      if (!model.colorTexture) {
+        model.colorTexture = vtkOpenGLTexture.newInstance();
+        model.colorTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
+      }
+      // set interpolation on the texture based on property setting
+      if (iType === InterpolationType.NEAREST) {
+        model.colorTexture.setMinificationFilter(Filter.NEAREST);
+        model.colorTexture.setMagnificationFilter(Filter.NEAREST);
+      } else {
+        model.colorTexture.setMinificationFilter(Filter.LINEAR);
+        model.colorTexture.setMagnificationFilter(Filter.LINEAR);
+      }
+      if (colorTransferFunc) {
         const tmpTable = new Float32Array(cWidth * 3);
         for (let c = 0; c < numIComps; c++) {
-          cfun = actorProperty.getRGBTransferFunction(c);
+          const cfun = actorProperty.getRGBTransferFunction(c);
           const cRange = cfun.getRange();
           cfun.getTable(cRange[0], cRange[1], cWidth, tmpTable, 1);
           if (iComps) {
@@ -514,6 +511,8 @@ function vtkOpenGLImageMapper(publicAPI, model) {
             }
           }
         }
+        model.colorTexture.releaseGraphicsResources(model._openGLRenderWindow);
+        model.colorTexture.resetFormatAndType();
         model.colorTexture.create2DFromRaw(cWidth, textureHeight, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
       } else {
         for (let i = 0; i < cWidth * 3; ++i) {
@@ -524,24 +523,43 @@ function vtkOpenGLImageMapper(publicAPI, model) {
         model.colorTexture.create2DFromRaw(cWidth, 1, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
       }
       model.colorTextureString = cfunToString;
+      if (colorTransferFunc) {
+        model._openGLRenderWindow.setGraphicsResourceForObject(colorTransferFunc, model.colorTexture, model.colorTextureString);
+      }
+    } else {
+      model.colorTexture = cTex.vtkObj;
+      model.colorTextureString = cTex.hash;
     }
 
     // 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 pwfunToString = computeFnToString(actorProperty, actorProperty.getPiecewiseFunction, numIComps);
-    if (model.pwfTextureString !== pwfunToString) {
+    const pwFunc = actorProperty.getPiecewiseFunction();
+    const pwfunToString = computeFnToString(actorProperty, pwFunc, numIComps);
+    const pwfTex = model._openGLRenderWindow.getGraphicsResourceForObject(pwFunc);
+    // rebuild opacity tfun?
+    const reBuildPwf = !pwfTex?.vtkObj || pwfTex?.hash !== pwfunToString || model.pwfTextureString !== pwfunToString;
+    if (reBuildPwf) {
       const pwfWidth = 1024;
       const pwfSize = pwfWidth * textureHeight;
       const pwfTable = new Uint8Array(pwfSize);
-      let pwfun = actorProperty.getPiecewiseFunction();
-      // support case where pwfun is added/removed
-      model.pwfTexture.resetFormatAndType();
-      if (pwfun) {
+      if (!model.pwfTexture) {
+        model.pwfTexture = vtkOpenGLTexture.newInstance();
+        model.pwfTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
+      }
+      // set interpolation on the texture based on property setting
+      if (iType === InterpolationType.NEAREST) {
+        model.pwfTexture.setMinificationFilter(Filter.NEAREST);
+        model.pwfTexture.setMagnificationFilter(Filter.NEAREST);
+      } else {
+        model.pwfTexture.setMinificationFilter(Filter.LINEAR);
+        model.pwfTexture.setMagnificationFilter(Filter.LINEAR);
+      }
+      if (pwFunc) {
         const pwfFloatTable = new Float32Array(pwfSize);
         const tmpTable = new Float32Array(pwfWidth);
         for (let c = 0; c < numIComps; ++c) {
-          pwfun = actorProperty.getPiecewiseFunction(c);
+          const pwfun = actorProperty.getPiecewiseFunction(c);
           if (pwfun === null) {
             // Piecewise constant max if no function supplied for this component
             pwfFloatTable.fill(1.0);
@@ -561,6 +579,8 @@ function vtkOpenGLImageMapper(publicAPI, model) {
             }
           }
         }
+        model.pwfTexture.releaseGraphicsResources(model._openGLRenderWindow);
+        model.pwfTexture.resetFormatAndType();
         model.pwfTexture.create2DFromRaw(pwfWidth, textureHeight, 1, VtkDataTypes.FLOAT, pwfFloatTable);
       } else {
         // default is opaque
@@ -568,6 +588,12 @@ function vtkOpenGLImageMapper(publicAPI, model) {
         model.pwfTexture.create2DFromRaw(pwfWidth, 1, 1, VtkDataTypes.UNSIGNED_CHAR, pwfTable);
       }
       model.pwfTextureString = pwfunToString;
+      if (pwFunc) {
+        model._openGLRenderWindow.setGraphicsResourceForObject(pwFunc, model.pwfTexture, model.pwfTextureString);
+      }
+    } else {
+      model.pwfTexture = pwfTex.vtkObj;
+      model.pwfTextureString = pwfTex.hash;
     }
 
     // Find what IJK axis and what direction to slice along
@@ -605,6 +631,10 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     if (model.VBOBuildString !== toString) {
       // Build the VBOs
       const dims = image.getDimensions();
+      if (!model.openGLTexture) {
+        model.openGLTexture = vtkOpenGLTexture.newInstance();
+        model.openGLTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
+      }
       if (iType === InterpolationType.NEAREST) {
         if (new Set([1, 3, 4]).has(numComp) && dataType === VtkDataTypes.UNSIGNED_CHAR && !iComps) {
           model.openGLTexture.setGenerateMipmap(true);
@@ -710,7 +740,19 @@ function vtkOpenGLImageMapper(publicAPI, model) {
       } else {
         vtkErrorMacro('Reformat slicing not yet supported.');
       }
-      model.openGLTexture.create2DFilterableFromRaw(dims[0], dims[1], numComp, imgScalars.getDataType(), scalars, model.renderable.getPreferSizeOverAccuracy?.());
+      const tex = model._openGLRenderWindow.getGraphicsResourceForObject(scalars);
+      if (!tex?.vtkObj) {
+        if (model._scalars !== scalars) {
+          model._openGLRenderWindow.releaseGraphicsResourcesForObject(model._scalars);
+          model._scalars = scalars;
+        }
+        model.openGLTexture.resetFormatAndType();
+        model.openGLTexture.create2DFilterableFromRaw(dims[0], dims[1], numComp, imgScalars.getDataType(), scalars, model.renderable.getPreferSizeOverAccuracy?.());
+        model._openGLRenderWindow.setGraphicsResourceForObject(scalars, model.openGLTexture, model.VBOBuildString);
+      } else {
+        model.openGLTexture = tex.vtkObj;
+        model.VBOBuildString = tex.hash;
+      }
       model.openGLTexture.activate();
       model.openGLTexture.sendParameters();
       model.openGLTexture.deactivate();
@@ -763,7 +805,8 @@ const DEFAULT_VALUES = {
   pwfTexture: null,
   lastHaveSeenDepthRequest: false,
   haveSeenDepthRequest: false,
-  lastTextureComponents: 0
+  lastTextureComponents: 0,
+  _scalars: null
 };
 
 // ----------------------------------------------------------------------------
@@ -777,15 +820,6 @@ function extend(publicAPI, model) {
   vtkReplacementShaderMapper.implementReplaceShaderCoincidentOffset(publicAPI, model, initialValues);
   vtkReplacementShaderMapper.implementBuildShadersWithReplacements(publicAPI, model, initialValues);
   model.tris = vtkHelper.newInstance();
-  model.openGLTexture = vtkOpenGLTexture.newInstance({
-    resizable: true
-  });
-  model.colorTexture = vtkOpenGLTexture.newInstance({
-    resizable: true
-  });
-  model.pwfTexture = vtkOpenGLTexture.newInstance({
-    resizable: true
-  });
   model.imagemat = mat4.identity(new Float64Array(16));
   model.imagematinv = mat4.identity(new Float64Array(16));