@kitware/vtk.js 33.0.0-beta.3 → 33.0.0-beta.5

package/Rendering/OpenGL/Texture.js

@@ -1,3 +1,4 @@
+import DeepEqual from 'fast-deep-equal';
 import Constants from './Texture/Constants.js';
 import HalfFloat from '../../Common/Core/HalfFloat.js';
 import { n as newInstance$1, o as obj, s as set, e as setGet, g as get, i as moveToProtected, a as newTypedArray, c as macro } from '../../macros2.js';
@@ -17,7 +18,8 @@ const {
 const {
   vtkDebugMacro,
   vtkErrorMacro,
-  vtkWarningMacro
+  vtkWarningMacro,
+  requiredParam
 } = macro;
 const {
   toHalf
@@ -30,6 +32,16 @@ const {
 function vtkOpenGLTexture(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkOpenGLTexture');
+  function getTexParams() {
+    return {
+      internalFormat: model.internalFormat,
+      format: model.format,
+      openGLDataType: model.openGLDataType,
+      width: model.width,
+      height: model.height
+    };
+  }
+
   // Renders myself
   publicAPI.render = function () {
     let renWin = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
@@ -84,7 +96,14 @@ function vtkOpenGLTexture(publicAPI, model) {
           publicAPI.setMinificationFilter(Filter.LINEAR_MIPMAP_LINEAR);
         }
         const canvas = model.renderable.getCanvas();
-        publicAPI.create2DFromRaw(canvas.width, canvas.height, 4, VtkDataTypes.UNSIGNED_CHAR, canvas, true);
+        publicAPI.create2DFromRaw({
+          width: canvas.width,
+          height: canvas.height,
+          numComps: 4,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: canvas,
+          flip: true
+        });
         publicAPI.activate();
         publicAPI.sendParameters();
         model.textureBuildTime.modified();
@@ -96,7 +115,14 @@ function vtkOpenGLTexture(publicAPI, model) {
           model.generateMipmap = true;
           publicAPI.setMinificationFilter(Filter.LINEAR_MIPMAP_LINEAR);
         }
-        publicAPI.create2DFromRaw(jsid.width, jsid.height, 4, VtkDataTypes.UNSIGNED_CHAR, jsid.data, true);
+        publicAPI.create2DFromRaw({
+          width: jsid.width,
+          height: jsid.height,
+          numComps: 4,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: jsid.data,
+          flip: true
+        });
         publicAPI.activate();
         publicAPI.sendParameters();
         model.textureBuildTime.modified();
@@ -121,9 +147,21 @@ function vtkOpenGLTexture(publicAPI, model) {
           publicAPI.setMinificationFilter(Filter.LINEAR_MIPMAP_LINEAR);
         }
         if (data.length % 6 === 0) {
-          publicAPI.createCubeFromRaw(ext[1] - ext[0] + 1, ext[3] - ext[2] + 1, inScalars.getNumberOfComponents(), inScalars.getDataType(), data);
+          publicAPI.createCubeFromRaw({
+            width: ext[1] - ext[0] + 1,
+            height: ext[3] - ext[2] + 1,
+            numComps: inScalars.getNumberOfComponents(),
+            dataType: inScalars.getDataType(),
+            data
+          });
         } else {
-          publicAPI.create2DFromRaw(ext[1] - ext[0] + 1, ext[3] - ext[2] + 1, inScalars.getNumberOfComponents(), inScalars.getDataType(), inScalars.getData());
+          publicAPI.create2DFromRaw({
+            width: ext[1] - ext[0] + 1,
+            height: ext[3] - ext[2] + 1,
+            numComps: inScalars.getNumberOfComponents(),
+            dataType: inScalars.getDataType(),
+            data: inScalars.getData()
+          });
         }
         publicAPI.activate();
         publicAPI.sendParameters();
@@ -148,6 +186,7 @@ function vtkOpenGLTexture(publicAPI, model) {
     if (model.context && model.handle) {
       model.context.deleteTexture(model.handle);
     }
+    model._prevTexParams = null;
     model.handle = 0;
     model.numberOfDimensions = 0;
     model.target = 0;
@@ -209,6 +248,7 @@ function vtkOpenGLTexture(publicAPI, model) {
       rwin.activateTexture(publicAPI);
       rwin.deactivateTexture(publicAPI);
       model.context.deleteTexture(model.handle);
+      model._prevTexParams = null;
       model.handle = 0;
       model.numberOfDimensions = 0;
       model.target = 0;
@@ -353,6 +393,7 @@ function vtkOpenGLTexture(publicAPI, model) {
 
   //----------------------------------------------------------------------------
   publicAPI.resetFormatAndType = () => {
+    model._prevTexParams = null;
     model.format = 0;
     model.internalFormat = 0;
     model._forceInternalFormat = false;
@@ -499,6 +540,86 @@ function vtkOpenGLTexture(publicAPI, model) {
     }
   };
 
+  //----------------------------------------------------------------------------
+
+  /**
+   * Gets the extent's size.
+   * @param {Extent} extent
+   */
+  function getExtentSize(extent) {
+    const [xmin, xmax, ymin, ymax, zmin, zmax] = extent;
+    return [xmax - xmin + 1, ymax - ymin + 1, zmax - zmin + 1];
+  }
+
+  //----------------------------------------------------------------------------
+
+  /**
+   * Gets the number of pixels in the extent.
+   * @param {Extent} extent
+   */
+  function getExtentPixelCount(extent) {
+    const [sx, sy, sz] = getExtentSize(extent);
+    return sx * sy * sz;
+  }
+
+  //----------------------------------------------------------------------------
+
+  /**
+   * Reads a flattened extent from the image data and writes to the given output array.
+   *
+   * Assumes X varies the fastest and Z varies the slowest.
+   *
+   * @param {*} data
+   * @param {*} dataDims
+   * @param {Extent} extent
+   * @param {TypedArray} outArray
+   * @param {number} outOffset
+   * @returns
+   */
+  function readExtentIntoArray(data, dataDims, extent, outArray, outOffset) {
+    const [xmin, xmax, ymin, ymax, zmin, zmax] = extent;
+    const [dx, dy] = dataDims;
+    const sxy = dx * dy;
+    let writeOffset = outOffset;
+    for (let zi = zmin; zi <= zmax; zi++) {
+      const zOffset = zi * sxy;
+      for (let yi = ymin; yi <= ymax; yi++) {
+        const zyOffset = zOffset + yi * dx;
+        // explicit alternative to data.subarray,
+        // due to potential perf issues on v8
+        for (let readOffset = zyOffset + xmin, end = zyOffset + xmax; readOffset <= end; readOffset++, writeOffset++) {
+          outArray[writeOffset] = data[readOffset];
+        }
+      }
+    }
+  }
+
+  //----------------------------------------------------------------------------
+
+  /**
+   * Reads several image extents into a contiguous pixel array.
+   *
+   * @param {*} data
+   * @param {Extent[]} extent
+   * @param {TypedArrayConstructor} typedArrayConstructor optional typed array constructor
+   * @returns
+   */
+  function readExtents(data, extents) {
+    let typedArrayConstructor = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+    const constructor = typedArrayConstructor || data.constructor;
+    const numPixels = extents.reduce((count, extent) => count + getExtentPixelCount(extent), 0);
+    const extentPixels = new constructor(numPixels);
+    const dataDims = [model.width, model.height, model.depth];
+    let writeOffset = 0;
+    extents.forEach(extent => {
+      readExtentIntoArray(data, dataDims, extent, extentPixels, writeOffset);
+      writeOffset += getExtentPixelCount(extent);
+    });
+    return extentPixels;
+  }
+
+  //----------------------------------------------------------------------------
+
   /**
    * Updates the data array to match the required data type for OpenGL.
    *
@@ -508,23 +629,30 @@ function vtkOpenGLTexture(publicAPI, model) {
    * @param {string} dataType - The original data type of the input data.
    * @param {Array} data - The input data array that needs to be updated.
    * @param {boolean} [depth=false] - Indicates whether the data is a 3D array.
+   * @param {Array<Extent>} imageExtents only consider these image extents (default: [])
    * @returns {Array} The updated data array that matches the OpenGL data type.
    */
   publicAPI.updateArrayDataTypeForGL = function (dataType, data) {
     let depth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    let imageExtents = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
     const pixData = [];
     let pixCount = model.width * model.height * model.components;
     if (depth) {
       pixCount *= model.depth;
     }
+    const onlyUpdateExtents = !!imageExtents.length;
 
     // if the opengl data type is float
     // then the data array must be float
     if (dataType !== VtkDataTypes.FLOAT && model.openGLDataType === model.context.FLOAT) {
       for (let idx = 0; idx < data.length; idx++) {
         if (data[idx]) {
-          const dataArrayToCopy = data[idx].length > pixCount ? data[idx].subarray(0, pixCount) : data[idx];
-          pixData.push(new Float32Array(dataArrayToCopy));
+          if (onlyUpdateExtents) {
+            pixData.push(readExtents(data[idx], imageExtents, Float32Array));
+          } else {
+            const dataArrayToCopy = data[idx].length > pixCount ? data[idx].subarray(0, pixCount) : data[idx];
+            pixData.push(new Float32Array(dataArrayToCopy));
+          }
         } else {
           pixData.push(null);
         }
@@ -536,8 +664,12 @@ function vtkOpenGLTexture(publicAPI, model) {
     if (dataType !== VtkDataTypes.UNSIGNED_CHAR && model.openGLDataType === model.context.UNSIGNED_BYTE) {
       for (let idx = 0; idx < data.length; idx++) {
         if (data[idx]) {
-          const dataArrayToCopy = data[idx].length > pixCount ? data[idx].subarray(0, pixCount) : data[idx];
-          pixData.push(new Uint8Array(dataArrayToCopy));
+          if (onlyUpdateExtents) {
+            pixData.push(readExtents(data[idx], imageExtents, Uint8Array));
+          } else {
+            const dataArrayToCopy = data[idx].length > pixCount ? data[idx].subarray(0, pixCount) : data[idx];
+            pixData.push(new Uint8Array(dataArrayToCopy));
+          }
         } else {
           pixData.push(null);
         }
@@ -556,9 +688,10 @@ function vtkOpenGLTexture(publicAPI, model) {
     if (halfFloat) {
       for (let idx = 0; idx < data.length; idx++) {
         if (data[idx]) {
-          const newArray = new Uint16Array(pixCount);
-          const src = data[idx];
-          for (let i = 0; i < pixCount; i++) {
+          const src = onlyUpdateExtents ? readExtents(data[idx], imageExtents) : data[idx];
+          const newArray = new Uint16Array(onlyUpdateExtents ? src.length : pixCount);
+          const newArrayLen = newArray.length;
+          for (let i = 0; i < newArrayLen; i++) {
             newArray[i] = toHalf(src[i]);
           }
           pixData.push(newArray);
@@ -571,7 +704,7 @@ function vtkOpenGLTexture(publicAPI, model) {
     // The output has to be filled
     if (pixData.length === 0) {
       for (let i = 0; i < data.length; i++) {
-        pixData.push(data[i]);
+        pixData.push(onlyUpdateExtents && data[i] ? readExtents(data[i], imageExtents) : data[i]);
       }
     }
     return pixData;
@@ -680,8 +813,16 @@ function vtkOpenGLTexture(publicAPI, model) {
   }
 
   //----------------------------------------------------------------------------
-  publicAPI.create2DFromRaw = function (width, height, numComps, dataType, data) {
-    let flip = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;
+
+  publicAPI.create2DFromRaw = function () {
+    let {
+      width = requiredParam('width'),
+      height = requiredParam('height'),
+      numComps = requiredParam('numComps'),
+      dataType = requiredParam('dataType'),
+      data = requiredParam('data'),
+      flip = false
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     // Now determine the texture parameters using the arguments.
     publicAPI.getOpenGLDataType(dataType, true);
     publicAPI.getInternalFormat(dataType, numComps);
@@ -730,7 +871,14 @@ function vtkOpenGLTexture(publicAPI, model) {
   };
 
   //----------------------------------------------------------------------------
-  publicAPI.createCubeFromRaw = (width, height, numComps, dataType, data) => {
+  publicAPI.createCubeFromRaw = function () {
+    let {
+      width = requiredParam('width'),
+      height = requiredParam('height'),
+      numComps = requiredParam('numComps'),
+      dataType = requiredParam('dataType'),
+      data = requiredParam('data')
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     // Now determine the texture parameters using the arguments.
     publicAPI.getOpenGLDataType(dataType);
     publicAPI.getInternalFormat(dataType, numComps);
@@ -811,7 +959,13 @@ function vtkOpenGLTexture(publicAPI, model) {
   };
 
   //----------------------------------------------------------------------------
-  publicAPI.createDepthFromRaw = (width, height, dataType, data) => {
+  publicAPI.createDepthFromRaw = function () {
+    let {
+      width = requiredParam('width'),
+      height = requiredParam('height'),
+      dataType = requiredParam('dataType'),
+      data = requiredParam('data')
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     // Now determine the texture parameters using the arguments.
     publicAPI.getOpenGLDataType(dataType);
     model.format = model.context.DEPTH_COMPONENT;
@@ -984,22 +1138,47 @@ function vtkOpenGLTexture(publicAPI, model) {
       scaleOffsets
     };
   }
-  publicAPI.create2DFilterableFromRaw = function (width, height, numberOfComponents, dataType, values) {
-    let preferSizeOverAccuracy = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;
-    return publicAPI.create2DFilterableFromDataArray(width, height, vtkDataArray.newInstance({
-      numberOfComponents,
-      dataType,
-      values
-    }), preferSizeOverAccuracy);
+  publicAPI.create2DFilterableFromRaw = function () {
+    let {
+      width = requiredParam('width'),
+      height = requiredParam('height'),
+      numComps = requiredParam('numComps'),
+      dataType = requiredParam('dataType'),
+      data = requiredParam('data'),
+      preferSizeOverAccuracy = false,
+      ranges = undefined
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return publicAPI.create2DFilterableFromDataArray({
+      width,
+      height,
+      dataArray: vtkDataArray.newInstance({
+        numComps,
+        dataType,
+        values: data,
+        ranges
+      }),
+      preferSizeOverAccuracy
+    });
   };
-  publicAPI.create2DFilterableFromDataArray = function (width, height, dataArray) {
-    let preferSizeOverAccuracy = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  publicAPI.create2DFilterableFromDataArray = function () {
+    let {
+      width = requiredParam('width'),
+      height = requiredParam('height'),
+      dataArray = requiredParam('dataArray'),
+      preferSizeOverAccuracy = false
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     const {
       numComps,
       dataType,
       data
     } = processDataArray(dataArray, preferSizeOverAccuracy);
-    publicAPI.create2DFromRaw(width, height, numComps, dataType, data);
+    publicAPI.create2DFromRaw({
+      width,
+      height,
+      numComps,
+      dataType,
+      data
+    });
   };
   publicAPI.updateVolumeInfoForGL = (dataType, numComps) => {
     let isScalingApplied = false;
@@ -1054,7 +1233,16 @@ function vtkOpenGLTexture(publicAPI, model) {
   };
 
   //----------------------------------------------------------------------------
-  publicAPI.create3DFromRaw = (width, height, depth, numComps, dataType, data) => {
+  publicAPI.create3DFromRaw = function () {
+    let {
+      width = requiredParam('width'),
+      height = requiredParam('height'),
+      depth = requiredParam('depth'),
+      numComps = requiredParam('numComps'),
+      dataType = requiredParam('dataType'),
+      data = requiredParam('data'),
+      updatedExtents = []
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     let dataTypeToUse = dataType;
     let dataToUse = data;
     if (!publicAPI.updateVolumeInfoForGL(dataTypeToUse, numComps) && dataToUse) {
@@ -1096,25 +1284,42 @@ function vtkOpenGLTexture(publicAPI, model) {
     model._openGLRenderWindow.activateTexture(publicAPI);
     publicAPI.createTexture();
     publicAPI.bind();
+    const hasUpdatedExtents = updatedExtents.length > 0;
+
+    // It's possible for the texture parameters to change while
+    // streaming, so check for such a change.
+    const rebuildEntireTexture = !hasUpdatedExtents || !DeepEqual(model._prevTexParams, getTexParams());
+
     // Create an array of texture with one texture
     const dataArray = [dataToUse];
     const is3DArray = true;
-    const pixData = publicAPI.updateArrayDataTypeForGL(dataTypeToUse, dataArray, is3DArray);
+    const pixData = publicAPI.updateArrayDataTypeForGL(dataTypeToUse, dataArray, is3DArray, rebuildEntireTexture ? [] : updatedExtents);
     const scaledData = scaleTextureToHighestPowerOfTwo(pixData);
 
     // Source texture data from the PBO.
     // model.context.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
     model.context.pixelStorei(model.context.UNPACK_ALIGNMENT, 1);
-
-    // openGLDataType
-
-    if (useTexStorage(dataTypeToUse)) {
-      model.context.texStorage3D(model.target, 1, model.internalFormat, model.width, model.height, model.depth);
-      if (scaledData[0] != null) {
-        model.context.texSubImage3D(model.target, 0, 0, 0, 0, model.width, model.height, model.depth, model.format, model.openGLDataType, scaledData[0]);
+    if (rebuildEntireTexture) {
+      if (useTexStorage(dataTypeToUse)) {
+        model.context.texStorage3D(model.target, 1, model.internalFormat, model.width, model.height, model.depth);
+        if (scaledData[0] != null) {
+          model.context.texSubImage3D(model.target, 0, 0, 0, 0, model.width, model.height, model.depth, model.format, model.openGLDataType, scaledData[0]);
+        }
+      } else {
+        model.context.texImage3D(model.target, 0, model.internalFormat, model.width, model.height, model.depth, 0, model.format, model.openGLDataType, scaledData[0]);
+      }
+      model._prevTexParams = getTexParams();
+    } else if (hasUpdatedExtents) {
+      const extentPixels = scaledData[0];
+      let readOffset = 0;
+      for (let i = 0; i < updatedExtents.length; i++) {
+        const extent = updatedExtents[i];
+        const extentSize = getExtentSize(extent);
+        const extentPixelCount = getExtentPixelCount(extent);
+        const textureData = new extentPixels.constructor(extentPixels.buffer, readOffset, extentPixelCount);
+        readOffset += textureData.byteLength;
+        model.context.texSubImage3D(model.target, 0, extent[0], extent[2], extent[4], extentSize[0], extentSize[1], extentSize[2], model.format, model.openGLDataType, textureData);
       }
-    } else {
-      model.context.texImage3D(model.target, 0, model.internalFormat, model.width, model.height, model.depth, 0, model.format, model.openGLDataType, scaledData[0]);
     }
     if (model.generateMipmap) {
       model.context.generateMipmap(model.target);
@@ -1127,19 +1332,44 @@ function vtkOpenGLTexture(publicAPI, model) {
   //----------------------------------------------------------------------------
   // This method simulates a 3D texture using 2D
   // Prefer create3DFilterableFromDataArray to enable caching of min and max values
-  publicAPI.create3DFilterableFromRaw = function (width, height, depth, numberOfComponents, dataType, values) {
-    let preferSizeOverAccuracy = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : false;
-    return publicAPI.create3DFilterableFromDataArray(width, height, depth, vtkDataArray.newInstance({
-      numberOfComponents,
-      dataType,
-      values
-    }), preferSizeOverAccuracy);
+  publicAPI.create3DFilterableFromRaw = function () {
+    let {
+      width = requiredParam('width'),
+      height = requiredParam('height'),
+      depth = requiredParam('depth'),
+      numComps = requiredParam('numComps'),
+      dataType = requiredParam('dataType'),
+      data = requiredParam('data'),
+      preferSizeOverAccuracy = false,
+      ranges = undefined,
+      updatedExtents = []
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return publicAPI.create3DFilterableFromDataArray({
+      width,
+      height,
+      depth,
+      dataArray: vtkDataArray.newInstance({
+        numComps,
+        dataType,
+        values: data,
+        ranges
+      }),
+      preferSizeOverAccuracy,
+      updatedExtents
+    });
   };
 
   //----------------------------------------------------------------------------
   // This method create a 3D texture from dimensions and a DataArray
-  publicAPI.create3DFilterableFromDataArray = function (width, height, depth, dataArray) {
-    let preferSizeOverAccuracy = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  publicAPI.create3DFilterableFromDataArray = function () {
+    let {
+      width = requiredParam('width'),
+      height = requiredParam('height'),
+      depth = requiredParam('depth'),
+      dataArray = requiredParam('dataArray'),
+      preferSizeOverAccuracy = false,
+      updatedExtents = []
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     const {
       numComps,
       dataType,
@@ -1174,7 +1404,15 @@ function vtkOpenGLTexture(publicAPI, model) {
 
     // WebGL2 path, we have 3d textures etc
     if (model._openGLRenderWindow.getWebgl2()) {
-      return publicAPI.create3DFromRaw(width, height, depth, numComps, dataType, data);
+      return publicAPI.create3DFromRaw({
+        width,
+        height,
+        depth,
+        numComps,
+        dataType,
+        data,
+        updatedExtents
+      });
     }
     const numPixelsIn = width * height * depth;
     const scaleOffsetsCopy = structuredClone(scaleOffsets);
@@ -1343,6 +1581,7 @@ function vtkOpenGLTexture(publicAPI, model) {
 const DEFAULT_VALUES = {
   _openGLRenderWindow: null,
   _forceInternalFormat: false,
+  _prevTexParams: null,
   context: null,
   handle: 0,
   sendParametersTime: null,

package/Rendering/OpenGL/VolumeMapper.js

@@ -1013,7 +1013,13 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       }
       model.jitterTexture.setMinificationFilter(Filter.NEAREST);
       model.jitterTexture.setMagnificationFilter(Filter.NEAREST);
-      model.jitterTexture.create2DFromRaw(32, 32, 1, VtkDataTypes.FLOAT, jitterArray);
+      model.jitterTexture.create2DFromRaw({
+        width: 32,
+        height: 32,
+        numComps: 1,
+        dataType: VtkDataTypes.FLOAT,
+        data: jitterArray
+      });
     }
     const volumeProperties = actor.getProperties();
     const firstValidInput = model.currentValidInputs[0];
@@ -1034,7 +1040,10 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
     if (reBuildOp) {
       const newOpacityTexture = vtkOpenGLTexture.newInstance();
       newOpacityTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-      const oWidth = 1024;
+      let oWidth = model.renderable.getOpacityTextureWidth();
+      if (oWidth <= 0) {
+        oWidth = model.context.getParameter(model.context.MAX_TEXTURE_SIZE);
+      }
       const oSize = oWidth * 2 * numIComps;
       const ofTable = new Float32Array(oSize);
       const tmpTable = new Float32Array(oWidth);
@@ -1058,13 +1067,25 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       // visible artifacts. High values of opacity quickly terminate without
       // artifacts.
       if (model._openGLRenderWindow.getWebgl2() || model.context.getExtension('OES_texture_float') && model.context.getExtension('OES_texture_float_linear')) {
-        newOpacityTexture.create2DFromRaw(oWidth, 2 * numIComps, 1, VtkDataTypes.FLOAT, ofTable);
+        newOpacityTexture.create2DFromRaw({
+          width: oWidth,
+          height: 2 * numIComps,
+          numComps: 1,
+          dataType: VtkDataTypes.FLOAT,
+          data: ofTable
+        });
       } else {
         const oTable = new Uint8ClampedArray(oSize);
         for (let i = 0; i < oSize; ++i) {
           oTable[i] = 255.0 * ofTable[i];
         }
-        newOpacityTexture.create2DFromRaw(oWidth, 2 * numIComps, 1, VtkDataTypes.UNSIGNED_CHAR, oTable);
+        newOpacityTexture.create2DFromRaw({
+          width: oWidth,
+          height: 2 * numIComps,
+          numComps: 1,
+          dataType: VtkDataTypes.UNSIGNED_CHAR,
+          data: oTable
+        });
       }
       if (firstScalarOpacityFunc) {
         model._openGLRenderWindow.setGraphicsResourceForObject(firstScalarOpacityFunc, newOpacityTexture, opacityFuncHash);
@@ -1088,7 +1109,10 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
     if (reBuildC) {
       const newColorTexture = vtkOpenGLTexture.newInstance();
       newColorTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-      const cWidth = 1024;
+      let cWidth = model.renderable.getColorTextureWidth();
+      if (cWidth <= 0) {
+        cWidth = model.context.getParameter(model.context.MAX_TEXTURE_SIZE);
+      }
       const cSize = cWidth * 2 * numIComps * 3;
       const cTable = new Uint8ClampedArray(cSize);
       const tmpTable = new Float32Array(cWidth * 3);
@@ -1104,7 +1128,13 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       newColorTexture.resetFormatAndType();
       newColorTexture.setMinificationFilter(Filter.LINEAR);
       newColorTexture.setMagnificationFilter(Filter.LINEAR);
-      newColorTexture.create2DFromRaw(cWidth, 2 * numIComps, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
+      newColorTexture.create2DFromRaw({
+        width: cWidth,
+        height: 2 * numIComps,
+        numComps: 3,
+        dataType: VtkDataTypes.UNSIGNED_CHAR,
+        data: cTable
+      });
       model._openGLRenderWindow.setGraphicsResourceForObject(firstColorTransferFunc, newColorTexture, colorFuncHash);
       model.colorTexture = newColorTexture;
     } else {
@@ -1125,7 +1155,9 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       const tex = model._openGLRenderWindow.getGraphicsResourceForObject(scalars);
       const scalarsHash = getImageDataHash(imageData, scalars);
       const reBuildTex = !tex?.oglObject?.getHandle() || tex?.hash !== scalarsHash;
-      if (reBuildTex) {
+      const updatedExtents = volumeProperty.getUpdatedExtents();
+      const hasUpdatedExtents = !!updatedExtents.length;
+      if (reBuildTex && !hasUpdatedExtents) {
         const newScalarTexture = vtkOpenGLTexture.newInstance();
         newScalarTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
         // Build the textures
@@ -1133,12 +1165,31 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
         // Use norm16 for scalar texture if the extension is available
         newScalarTexture.setOglNorm16Ext(model.context.getExtension('EXT_texture_norm16'));
         newScalarTexture.resetFormatAndType();
-        newScalarTexture.create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars, volumeProperty.getPreferSizeOverAccuracy());
+        newScalarTexture.create3DFilterableFromDataArray({
+          width: dims[0],
+          height: dims[1],
+          depth: dims[2],
+          dataArray: scalars,
+          preferSizeOverAccuracy: volumeProperty.getPreferSizeOverAccuracy()
+        });
         model._openGLRenderWindow.setGraphicsResourceForObject(scalars, newScalarTexture, scalarsHash);
         model.scalarTextures[component] = newScalarTexture;
       } else {
         model.scalarTextures[component] = tex.oglObject;
       }
+      if (hasUpdatedExtents) {
+        // If hasUpdatedExtents, then the texture is partially updated.
+        // clear the array to acknowledge the update.
+        volumeProperty.setUpdatedExtents([]);
+        const dims = imageData.getDimensions();
+        model.scalarTextures[component].create3DFilterableFromDataArray({
+          width: dims[0],
+          height: dims[1],
+          depth: dims[2],
+          dataArray: scalars,
+          updatedExtents
+        });
+      }
       replaceGraphicsResource(model._openGLRenderWindow, model._scalarTexturesCore[component], scalars);
       model._scalarTexturesCore[component] = scalars;
     });
@@ -1151,7 +1202,10 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
     if (reBuildL) {
       const newLabelOutlineThicknessTexture = vtkOpenGLTexture.newInstance();
       newLabelOutlineThicknessTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-      const lWidth = 1024;
+      let lWidth = model.renderable.getLabelOutlineTextureWidth();
+      if (lWidth <= 0) {
+        lWidth = model.context.getParameter(model.context.MAX_TEXTURE_SIZE);
+      }
       const lHeight = 1;
       const lSize = lWidth * lHeight;
       const lTable = new Uint8Array(lSize);
@@ -1168,7 +1222,13 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       newLabelOutlineThicknessTexture.setMagnificationFilter(Filter.NEAREST);
 
       // Create a 2D texture (acting as 1D) from the raw data
-      newLabelOutlineThicknessTexture.create2DFromRaw(lWidth, lHeight, 1, VtkDataTypes.UNSIGNED_CHAR, lTable);
+      newLabelOutlineThicknessTexture.create2DFromRaw({
+        width: lWidth,
+        height: lHeight,
+        numComps: 1,
+        dataType: VtkDataTypes.UNSIGNED_CHAR,
+        data: lTable
+      });
       if (labelOutlineThicknessArray) {
         model._openGLRenderWindow.setGraphicsResourceForObject(labelOutlineThicknessArray, newLabelOutlineThicknessTexture, labelOutlineThicknessHash);
       }