@kitware/vtk.js 32.11.0 → 32.12.1

package/Rendering/Core/AbstractPicker.d.ts

@@ -1,6 +1,6 @@
 import { vtkObject } from './../../interfaces';
 import { Vector3 } from './../../types';
-import vtkActor from './Actor';
+import vtkProp3D from './Prop3D';
 import vtkRenderer from './Renderer';
 
 /**
@@ -10,8 +10,8 @@ export interface IAbstractPickerInitialValues {
   renderer?: vtkRenderer;
   selectionPoint?: Vector3;
   pickPosition?: Vector3;
-  pickFromList?: number;
-  pickList?: vtkActor[];
+  pickFromList?: boolean;
+  pickList?: vtkProp3D[];
 }
 
 /**
@@ -20,15 +20,15 @@ export interface IAbstractPickerInitialValues {
 export interface vtkAbstractPicker extends vtkObject {
   /**
    *
-   * @param {vtkActor} actor
+   * @param {vtkProp3D} prop
    */
-  addPickList(actor: vtkActor): void;
+  addPickList(prop: vtkProp3D): void;
 
   /**
    *
-   * @param {vtkActor} actor
+   * @param {vtkProp3D} prop
    */
-  deletePickList(actor: vtkActor): void;
+  deletePickList(prop: vtkProp3D): void;
 
   /**
    *
@@ -38,7 +38,7 @@ export interface vtkAbstractPicker extends vtkObject {
   /**
    *
    */
-  getPickList(): boolean;
+  getPickList(): vtkProp3D[];
 
   /**
    * Get the picked position
@@ -82,17 +82,17 @@ export interface vtkAbstractPicker extends vtkObject {
 
   /**
    *
-   * @param {Number}  pickFromList
-   * @default 0
+   * @param {Boolean}  pickFromList
+   * @default false
    */
-  setPickFromList(pickFromList: number): boolean;
+  setPickFromList(pickFromList: boolean): boolean;
 
   /**
    *
-   * @param {vtkActor[]} pickList
+   * @param {vtkProp3D[]} pickList
    * @default []
    */
-  setPickList(pickList: vtkActor[]): boolean;
+  setPickList(pickList: vtkProp3D[]): boolean;
 }
 
 /**

package/Rendering/Core/AbstractPicker.js

@@ -38,7 +38,7 @@ const DEFAULT_VALUES = {
   renderer: null,
   selectionPoint: [0.0, 0.0, 0.0],
   pickPosition: [0.0, 0.0, 0.0],
-  pickFromList: 0,
+  pickFromList: false,
   pickList: []
 };
 

package/Rendering/Core/ImageCPRMapper.d.ts

@@ -1,5 +1,5 @@
 import { mat3, mat4, quat, vec3 } from 'gl-matrix';
-import { Nullable } from './../../types';
+import { Extent, Nullable } from './../../types';
 import { vtkOutputPort } from './../../interfaces';
 import vtkAbstractMapper3D, {
   IAbstractMapper3DInitialValues,
@@ -307,6 +307,25 @@ export interface vtkImageCPRMapper
    * @param imageData
    */
   setImageConnection(imageData: vtkOutputPort): void;
+
+  /**
+   * Tells the mapper to only update the specified extents.
+   *
+   * If there are zero extents, the mapper updates the entire volume texture.
+   * Otherwise, the mapper will only update the texture by the specified extents
+   * during the next render call.
+   *
+   * This array is cleared after a successful render.
+   * @param extents
+   */
+  setUpdatedExtents(extents: Extent[]): boolean;
+
+  /**
+   * Retrieves the updated extents.
+   *
+   * This array is cleared after every successful render.
+   */
+  getUpdatedExtents(): Extent[];
 }
 
 /**

package/Rendering/Core/ImageCPRMapper.js

@@ -270,7 +270,7 @@ function vtkImageCPRMapper(publicAPI, model) {
 // Object factory
 // ----------------------------------------------------------------------------
 
-const DEFAULT_VALUES = {
+const defaultValues = initialValues => ({
   width: 10,
   uniformOrientation: [0, 0, 0, 1],
   useUniformOrientation: false,
@@ -282,14 +282,16 @@ const DEFAULT_VALUES = {
   normalDirection: [0, 0, 1],
   projectionSlabThickness: 1,
   projectionSlabNumberOfSamples: 1,
-  projectionMode: ProjectionMode.MAX
-};
+  projectionMode: ProjectionMode.MAX,
+  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));
 
   // Inheritance
   vtkAbstractImageMapper.extend(publicAPI, model, initialValues);
@@ -302,7 +304,7 @@ function extend(publicAPI, model) {
   });
 
   // Setters and getters
-  macro.setGet(publicAPI, model, ['width', 'uniformOrientation', 'useUniformOrientation', 'centerPoint', 'preferSizeOverAccuracy', 'orientationArrayName', 'tangentDirection', 'bitangentDirection', 'normalDirection', 'projectionSlabThickness', 'projectionSlabNumberOfSamples', 'projectionMode']);
+  macro.setGet(publicAPI, model, ['width', 'uniformOrientation', 'useUniformOrientation', 'centerPoint', 'preferSizeOverAccuracy', 'orientationArrayName', 'tangentDirection', 'bitangentDirection', 'normalDirection', 'projectionSlabThickness', 'projectionSlabNumberOfSamples', 'projectionMode', 'updatedExtents']);
   CoincidentTopologyHelper.implementCoincidentTopologyMethods(publicAPI, model);
 
   // Object methods

package/Rendering/Core/ImageResliceMapper.d.ts

@@ -1,10 +1,9 @@
 import vtkAbstractImageMapper, {
   IAbstractImageMapperInitialValues,
 } from './AbstractImageMapper';
-import vtkImageData from './../../Common/DataModel/ImageData';
 import vtkPlane from './../../Common/DataModel/Plane';
 import vtkPolyData from './../../Common/DataModel/PolyData';
-import { Bounds, Nullable, Vector3 } from './../../types';
+import { Bounds, Extent } from './../../types';
 import { SlabTypes } from './ImageResliceMapper/Constants';
 import CoincidentTopologyHelper, {
   StaticCoincidentTopologyMethods,
@@ -116,6 +115,25 @@ export interface vtkImageResliceMapper
    * @param {vtkPolyData} slicePolyData The polydata to slice the volume with. Default: null
    */
   setSlicePolyData(slicePolyData: vtkPolyData): boolean;
+
+  /**
+   * Tells the mapper to only update the specified extents.
+   *
+   * If there are zero extents, the mapper updates the entire volume texture.
+   * Otherwise, the mapper will only update the texture by the specified extents
+   * during the next render call.
+   *
+   * This array is cleared after a successful render.
+   * @param extents
+   */
+  setUpdatedExtents(extents: Extent[]): boolean;
+
+  /**
+   * Retrieves the updated extents.
+   *
+   * This array is cleared after every successful render.
+   */
+  getUpdatedExtents(): Extent[];
 }
 
 /**

package/Rendering/Core/ImageResliceMapper.js

@@ -38,23 +38,25 @@ function vtkImageResliceMapper(publicAPI, model) {
 // Object factory
 // ----------------------------------------------------------------------------
 
-const DEFAULT_VALUES = {
+const defaultValues = initialValues => ({
   slabThickness: 0.0,
   slabTrapezoidIntegration: 0,
   slabType: SlabTypes.MEAN,
   slicePlane: null,
-  slicePolyData: null
-};
+  slicePolyData: null,
+  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
   vtkAbstractImageMapper.extend(publicAPI, model, initialValues);
-  macro.setGet(publicAPI, model, ['slabThickness', 'slabTrapezoidIntegration', 'slabType', 'slicePlane', 'slicePolyData']);
+  macro.setGet(publicAPI, model, ['slabThickness', 'slabTrapezoidIntegration', 'slabType', 'slicePlane', 'slicePolyData', 'updatedExtents']);
   CoincidentTopologyHelper.implementCoincidentTopologyMethods(publicAPI, model);
 
   // Object methods

package/Rendering/Core/VolumeMapper.d.ts

@@ -1,5 +1,5 @@
 import vtkPiecewiseFunction from './../../Common/DataModel/PiecewiseFunction';
-import { Bounds, Range } from './../../types';
+import { Bounds, Range, Extent } from './../../types';
 import vtkAbstractMapper3D, {
   IAbstractMapper3DInitialValues,
 } from './AbstractMapper3D';
@@ -281,6 +281,39 @@ export interface vtkVolumeMapper extends vtkAbstractMapper3D {
    */
   setLAOKernelRadius(LAOKernelRadius: number): 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;
+
+  /**
+   * Tells the mapper to only update the specified extents.
+   *
+   * If there are zero extents, the mapper updates the entire volume texture.
+   * Otherwise, the mapper will only update the texture by the specified extents
+   * during the next render call.
+   *
+   * This array is cleared after a successful render.
+   * @param extents
+   */
+  setUpdatedExtents(extents: Extent[]): boolean;
+
+  /**
+   * Retrieves the updated extents.
+   *
+   * This array is cleared after every successful render.
+   */
+  getUpdatedExtents(): Extent[];
+
   /**
    *
    */

package/Rendering/Core/VolumeMapper.js

@@ -101,7 +101,7 @@ function vtkVolumeMapper(publicAPI, model) {
 // ----------------------------------------------------------------------------
 
 // TODO: what values to use for averageIPScalarRange to get GLSL to use max / min values like [-Math.inf, Math.inf]?
-const DEFAULT_VALUES = {
+const defaultValues = initialValues => ({
   bounds: [1, -1, 1, -1, 1, -1],
   sampleDistance: 1.0,
   imageSampleDistance: 1.0,
@@ -124,16 +124,18 @@ const DEFAULT_VALUES = {
   // local ambient occlusion
   localAmbientOcclusion: false,
   LAOKernelSize: 15,
-  LAOKernelRadius: 7
-};
+  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));
   vtkAbstractMapper3D.extend(publicAPI, model, initialValues);
-  macro.setGet(publicAPI, model, ['sampleDistance', 'imageSampleDistance', 'maximumSamplesPerRay', 'autoAdjustSampleDistances', 'initialInteractionScale', 'interactionSampleDistanceFactor', 'blendMode', 'filterMode', 'preferSizeOverAccuracy', 'computeNormalFromOpacity', 'volumetricScatteringBlending', 'globalIlluminationReach', 'volumeShadowSamplingDistFactor', 'anisotropy', 'localAmbientOcclusion', 'LAOKernelSize', 'LAOKernelRadius']);
+  macro.setGet(publicAPI, model, ['sampleDistance', 'imageSampleDistance', 'maximumSamplesPerRay', 'autoAdjustSampleDistances', 'initialInteractionScale', 'interactionSampleDistanceFactor', 'blendMode', 'filterMode', 'preferSizeOverAccuracy', 'computeNormalFromOpacity', 'volumetricScatteringBlending', 'globalIlluminationReach', 'volumeShadowSamplingDistFactor', 'anisotropy', 'localAmbientOcclusion', 'LAOKernelSize', 'LAOKernelRadius', 'updatedExtents']);
   macro.setGetArray(publicAPI, model, ['ipScalarRange'], 2);
   macro.event(publicAPI, model, 'lightingActivated');
 

package/Rendering/OpenGL/ImageCPRMapper.js

@@ -156,6 +156,8 @@ 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 hasUpdatedExtents = !!updatedExtents.length;
     if (reBuildTex) {
       model.volumeTexture = vtkOpenGLTexture.newInstance();
       model.volumeTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
@@ -174,6 +176,13 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     } else {
       model.volumeTexture = cachedScalarsEntry.oglObject;
     }
+    if (hasUpdatedExtents) {
+      // If hasUpdatedExtents, then the texture is partially updated.
+      // clear the array to acknowledge the update.
+      model.renderable.setUpdatedExtents([]);
+      const dims = image.getDimensions();
+      model.volumeTexture.create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars, false, updatedExtents);
+    }
 
     // Rebuild the color texture if needed
     const numComp = scalars.getNumberOfComponents();

package/Rendering/OpenGL/ImageResliceMapper.js

@@ -185,15 +185,19 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     let toString = getImageDataHash(image, scalars);
     const tex = model._openGLRenderWindow.getGraphicsResourceForObject(scalars);
     const reBuildTex = !tex?.oglObject?.getHandle() || tex?.hash !== toString;
-    if (reBuildTex) {
+    const updatedExtents = model.renderable.getUpdatedExtents();
+    const hasUpdatedExtents = !!updatedExtents.length;
+    if (reBuildTex && !hasUpdatedExtents) {
       model.openGLTexture = vtkOpenGLTexture.newInstance();
       model.openGLTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
       // Build the image scalar texture
-      const dims = image.getDimensions();
       // Use norm16 for the 3D texture if the extension is available
       model.openGLTexture.setOglNorm16Ext(model.context.getExtension('EXT_texture_norm16'));
       model.openGLTexture.resetFormatAndType();
-      model.openGLTexture.create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars);
+
+      // Build the image scalar texture
+      const dims = image.getDimensions();
+      model.openGLTexture.create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars, false, updatedExtents);
       model._openGLRenderWindow.setGraphicsResourceForObject(scalars, model.openGLTexture, toString);
       if (scalars !== model._scalars) {
         model._openGLRenderWindow.registerGraphicsResourceUser(scalars, publicAPI);
@@ -203,6 +207,13 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     } else {
       model.openGLTexture = tex.oglObject;
     }
+    if (hasUpdatedExtents) {
+      // If hasUpdatedExtents, then the texture is partially updated.
+      // clear the array to acknowledge the update.
+      model.renderable.setUpdatedExtents([]);
+      const dims = image.getDimensions();
+      model.openGLTexture.create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars, false, updatedExtents);
+    }
     const ppty = actor.getProperty();
     const iComps = ppty.getIndependentComponents();
     const numIComps = iComps ? numComp : 1;

package/Rendering/OpenGL/Texture.d.ts

@@ -1,6 +1,6 @@
 import { Wrap, Filter } from './Texture/Constants';
 import vtkOpenGLRenderWindow from './RenderWindow';
-import { Nullable } from './../../types';
+import { Extent, Nullable } from './../../types';
 import { VtkDataTypes } from './../../Common/Core/DataArray';
 import { vtkViewNode } from './../SceneGraph/ViewNode';
 import { vtkObject, vtkRange } from './../../interfaces';
@@ -275,12 +275,16 @@ export interface vtkOpenGLTexture extends vtkViewNode {
 
   /**
    * Creates a 3D texture from raw data.
+   *
+   * updatedExtents is currently incompatible with webgl1, since there's no extent scaling.
+   *
    * @param width The width of the texture.
    * @param height The height of the texture.
    * @param depth The depth of the texture.
    * @param numComps The number of components in the texture.
    * @param dataType The data type of the texture.
    * @param data The raw data for the texture.
+   * @param updatedExtents Only update the specified extents (default: [])
    * @returns {boolean} True if the texture was successfully created, false otherwise.
    */
   create3DFromRaw(
@@ -289,11 +293,15 @@ export interface vtkOpenGLTexture extends vtkViewNode {
     depth: number,
     numComps: number,
     dataType: VtkDataTypes,
-    data: any
+    data: any,
+    updatedExtents?: Extent[]
   ): boolean;
 
   /**
    * Creates a 3D filterable texture from raw data, with a preference for size over accuracy if necessary.
+   *
+   * updatedExtents is currently incompatible with webgl1, since there's no extent scaling.
+   *
    * @param width The width of the texture.
    * @param height The height of the texture.
    * @param depth The depth of the texture.
@@ -302,6 +310,7 @@ export interface vtkOpenGLTexture extends vtkViewNode {
    * @param values The raw data for the texture.
    * @param preferSizeOverAccuracy Whether to prefer texture size over accuracy.
    * @param [ranges] The precomputed ranges of the data (optional). Provided to
+   * @param updatedExtents Only update the specified extents (default: [])
    * prevent computation of the data ranges.
    * @returns {boolean} True if the texture was successfully created, false
    * otherwise.
@@ -314,16 +323,21 @@ export interface vtkOpenGLTexture extends vtkViewNode {
     dataType: VtkDataTypes,
     values: any,
     preferSizeOverAccuracy: boolean,
-    ranges?: vtkRange[]
+    ranges?: vtkRange[],
+    updatedExtents?: Extent[]
   ): boolean;
 
   /**
    * Creates a 3D filterable texture from a data array, with a preference for size over accuracy if necessary.
+   *
+   * updatedExtents is currently incompatible with webgl1, since there's no extent scaling.
+   *
    * @param width The width of the texture.
    * @param height The height of the texture.
    * @param depth The depth of the texture.
    * @param dataArray The data array to use for the texture.
    * @param preferSizeOverAccuracy Whether to prefer texture size over accuracy.
+   * @param updatedExtents Only update the specified extents (default: [])
    * @returns {boolean} True if the texture was successfully created, false otherwise.
    */
   create3DFilterableFromDataArray(
@@ -331,7 +345,8 @@ export interface vtkOpenGLTexture extends vtkViewNode {
     height: number,
     depth: number,
     dataArray: any,
-    preferSizeOverAccuracy: boolean
+    preferSizeOverAccuracy: boolean,
+    updatedExtents?: Extent[]
   ): boolean;
 
   /**

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';
@@ -30,6 +31,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;
@@ -148,6 +159,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 +221,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 +366,7 @@ function vtkOpenGLTexture(publicAPI, model) {
 
   //----------------------------------------------------------------------------
   publicAPI.resetFormatAndType = () => {
+    model._prevTexParams = null;
     model.format = 0;
     model.internalFormat = 0;
     model._forceInternalFormat = false;
@@ -499,6 +513,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 +602,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 +637,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 +661,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 +677,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;
@@ -1056,7 +1162,8 @@ function vtkOpenGLTexture(publicAPI, model) {
   };
 
   //----------------------------------------------------------------------------
-  publicAPI.create3DFromRaw = (width, height, depth, numComps, dataType, data) => {
+  publicAPI.create3DFromRaw = function (width, height, depth, numComps, dataType, data) {
+    let updatedExtents = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : [];
     let dataTypeToUse = dataType;
     let dataToUse = data;
     if (!publicAPI.updateVolumeInfoForGL(dataTypeToUse, numComps) && dataToUse) {
@@ -1098,25 +1205,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);
@@ -1132,18 +1256,20 @@ function vtkOpenGLTexture(publicAPI, model) {
   publicAPI.create3DFilterableFromRaw = function (width, height, depth, numberOfComponents, dataType, values) {
     let preferSizeOverAccuracy = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : false;
     let ranges = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : undefined;
+    let updatedExtents = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : [];
     return publicAPI.create3DFilterableFromDataArray(width, height, depth, vtkDataArray.newInstance({
       numberOfComponents,
       dataType,
       values,
       ranges
-    }), preferSizeOverAccuracy);
+    }), 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;
+    let updatedExtents = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : [];
     const {
       numComps,
       dataType,
@@ -1178,7 +1304,7 @@ 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);
@@ -1347,6 +1473,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

@@ -1138,7 +1138,9 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
     // rebuild the scalarTexture if the data has changed
     toString = getImageDataHash(image, scalars);
     const reBuildTex = !tex?.oglObject?.getHandle() || tex?.hash !== toString;
-    if (reBuildTex) {
+    const updatedExtents = model.renderable.getUpdatedExtents();
+    const hasUpdatedExtents = !!updatedExtents.length;
+    if (reBuildTex && !hasUpdatedExtents) {
       model.scalarTexture = vtkOpenGLTexture.newInstance();
       model.scalarTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
       // Build the textures
@@ -1146,7 +1148,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       // Use norm16 for scalar texture if the extension is available
       model.scalarTexture.setOglNorm16Ext(model.context.getExtension('EXT_texture_norm16'));
       model.scalarTexture.resetFormatAndType();
-      model.scalarTexture.create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars, model.renderable.getPreferSizeOverAccuracy());
+      model.scalarTexture.create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars);
       if (scalars) {
         model._openGLRenderWindow.setGraphicsResourceForObject(scalars, model.scalarTexture, toString);
         if (scalars !== model._scalars) {
@@ -1158,6 +1160,13 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
     } else {
       model.scalarTexture = tex.oglObject;
     }
+    if (hasUpdatedExtents) {
+      // If hasUpdatedExtents, then the texture is partially updated.
+      // clear the array to acknowledge the update.
+      model.renderable.setUpdatedExtents([]);
+      const dims = image.getDimensions();
+      model.scalarTexture.create3DFilterableFromDataArray(dims[0], dims[1], dims[2], scalars, false, updatedExtents);
+    }
     if (!model.tris.getCABO().getElementCount()) {
       // build the CABO
       const ptsArray = new Float32Array(12);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "32.11.0",
+  "version": "32.12.1",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",
@@ -141,19 +141,20 @@
     "reformat-only": "prettier --single-quote --trailing-comma es5 --print-width 80 --arrow-parens always --write",
     "lint-fix": "eslint --fix Sources Examples",
     "lint": "eslint Sources Examples",
-    "doc": "kw-doc -c ./Documentation/config.js",
-    "doc:www": "npm t -- --single-run && kw-doc -c ./Documentation/config.js -s",
-    "doc:minified": "kw-doc -c ./Documentation/config.js -m",
-    "doc:generate-api": "node ./Documentation/generate-api-docs.js",
+    "doc": "npm run build:pre && kw-doc -c ./Documentation/config.js",
+    "doc:www": "npm t -- --single-run && npm run build:pre && kw-doc -c ./Documentation/config.js -s",
+    "doc:minified": "npm run build:pre && kw-doc -c ./Documentation/config.js -m",
+    "doc:generate-api": "npm run build:pre && node ./Documentation/generate-api-docs.js",
     "example": "node ./Utilities/ExampleRunner/example-runner-cli.js -c ./Documentation/config.js",
     "example:https": "node ./Utilities/ExampleRunner/example-runner-cli.js --server-type https -c ./Documentation/config.js",
     "example:webgpu": "cross-env WEBGPU=1 NO_WEBGL=1 node ./Utilities/ExampleRunner/example-runner-cli.js --server-type https -c ./Documentation/config.js",
+    "build:pre": "patch-package",
     "dev:esm": "npm run build:esm -- -w",
-    "dev:umd": "webpack --watch --config webpack.dev.js --progress",
+    "dev:umd": "npm run build:pre && webpack --watch --config webpack.dev.js --progress",
     "build": "npm run build:release",
-    "build:esm": "rollup -c rollup.config.js",
-    "build:umd": "webpack --config webpack.prod.js --progress",
-    "build:release": "npm run lint && concurrently \"cross-env NOLINT=1 npm run build:esm\" \"cross-env NOLINT=1 npm run build:umd\"",
+    "build:esm": "npm run build:pre && rollup -c rollup.config.js",
+    "build:umd": "npm run build:pre && webpack --config webpack.prod.js --progress",
+    "build:release": "npm run lint && npm run build:pre && concurrently \"cross-env NOLINT=1 npm run build:esm\" \"cross-env NOLINT=1 npm run build:umd\"",
     "release:create-packages": "node ./Utilities/ci/build-npm-package.js",
     "test": "karma start ./karma.conf.js",
     "test:headless": "karma start ./karma.conf.js --browsers ChromeHeadlessNoSandbox --single-run",
@@ -163,8 +164,7 @@
     "test:firefox-debug": "karma start ./karma.conf.js --browsers Firefox --no-single-run",
     "commit": "git cz",
     "semantic-release": "semantic-release",
-    "prepare": "node ./Utilities/prepare.js",
-    "postinstall": "patch-package"
+    "prepare": "node ./Utilities/prepare.js"
   },
   "config": {
     "commitizen": {