@cornerstonejs/core 2.0.0-beta.20 → 2.0.0-beta.22

package/dist/esm/RenderingEngine/helpers/setDefaultVolumeVOI.js

@@ -1,19 +1,20 @@
 import { loadAndCacheImage } from '../../loaders/imageLoader';
 import * as metaData from '../../metaData';
-import { getMinMax, windowLevel } from '../../utilities';
+import getMinMax from '../../utilities/getMinMax';
+import * as windowLevel from '../../utilities/windowLevel';
 import { RequestType } from '../../enums';
-import cache from '../../cache';
+import cache from '../../cache/cache';
 const PRIORITY = 0;
 const REQUEST_TYPE = RequestType.Prefetch;
-async function setDefaultVolumeVOI(volumeActor, imageVolume, useNativeDataType) {
+async function setDefaultVolumeVOI(volumeActor, imageVolume) {
     let voi = getVOIFromMetadata(imageVolume);
-    if (!voi && imageVolume?.imageIds?.length) {
-        voi = await getVOIFromMinMax(imageVolume, useNativeDataType);
+    if (!voi && imageVolume.imageIds.length) {
+        voi = await getVOIFromMiddleSliceMinMax(imageVolume);
         voi = handlePreScaledVolume(imageVolume, voi);
     }
-    if ((voi?.lower === 0 && voi?.upper === 0) ||
-        voi?.lower === undefined ||
-        voi?.upper === undefined) {
+    if ((voi.lower === 0 && voi.upper === 0) ||
+        voi.lower === undefined ||
+        voi.upper === undefined) {
         return;
     }
     volumeActor
@@ -41,7 +42,7 @@ function getVOIFromMetadata(imageVolume) {
         const imageIdIndex = Math.floor(imageIds.length / 2);
         const imageId = imageIds[imageIdIndex];
         const voiLutModule = metaData.get('voiLutModule', imageId);
-        if (voiLutModule && voiLutModule.windowWidth && voiLutModule.windowCenter) {
+        if (voiLutModule?.windowWidth && voiLutModule.windowCenter) {
             const { windowWidth, windowCenter } = voiLutModule;
             voi = {
                 windowWidth: Array.isArray(windowWidth) ? windowWidth[0] : windowWidth,
@@ -52,7 +53,7 @@ function getVOIFromMetadata(imageVolume) {
         }
     }
     else {
-        voi = metadata?.voiLut?.[0];
+        voi = metadata.voiLut[0];
     }
     if (voi) {
         const { lower, upper } = windowLevel.toLowHighRange(Number(voi.windowWidth), Number(voi.windowCenter));
@@ -62,18 +63,13 @@ function getVOIFromMetadata(imageVolume) {
         };
     }
 }
-async function getVOIFromMinMax(imageVolume, useNativeDataType) {
+async function getVOIFromMiddleSliceMinMax(imageVolume) {
     const { imageIds } = imageVolume;
-    const scalarData = imageVolume.getScalarData();
     const imageIdIndex = Math.floor(imageIds.length / 2);
     const imageId = imageVolume.imageIds[imageIdIndex];
     const generalSeriesModule = metaData.get('generalSeriesModule', imageId) || {};
     const { modality } = generalSeriesModule;
     const modalityLutModule = metaData.get('modalityLutModule', imageId) || {};
-    const numImages = imageIds.length;
-    const bytesPerImage = scalarData.byteLength / numImages;
-    const voxelsPerImage = scalarData.length / numImages;
-    const bytePerPixel = scalarData.BYTES_PER_ELEMENT;
     const scalingParameters = {
         rescaleSlope: modalityLutModule.rescaleSlope,
         rescaleIntercept: modalityLutModule.rescaleIntercept,
@@ -89,16 +85,10 @@ async function getVOIFromMinMax(imageVolume, useNativeDataType) {
             };
         }
     }
-    const byteOffset = imageIdIndex * bytesPerImage;
     const options = {
-        targetBuffer: {
-            type: useNativeDataType ? undefined : 'Float32Array',
-        },
         priority: PRIORITY,
         requestType: REQUEST_TYPE,
-        useNativeDataType,
         preScale: {
-            enabled: true,
             scalingParameters: scalingParametersToUse,
         },
     };
@@ -106,27 +96,13 @@ async function getVOIFromMinMax(imageVolume, useNativeDataType) {
     if (!imageVolume.referencedImageIds?.length) {
         image = await loadAndCacheImage(imageId, { ...options, ignoreCache: true });
     }
-    const imageScalarData = image
-        ? image.getPixelData()
-        : _getImageScalarDataFromImageVolume(imageVolume, byteOffset, bytePerPixel, voxelsPerImage);
+    const imageScalarData = image.getPixelData();
     const { min, max } = getMinMax(imageScalarData);
     return {
         lower: min,
         upper: max,
     };
 }
-function _getImageScalarDataFromImageVolume(imageVolume, byteOffset, bytePerPixel, voxelsPerImage) {
-    const { scalarData } = imageVolume;
-    const { buffer } = scalarData;
-    if (scalarData.BYTES_PER_ELEMENT !== bytePerPixel) {
-        byteOffset *= scalarData.BYTES_PER_ELEMENT / bytePerPixel;
-    }
-    const TypedArray = scalarData.constructor;
-    const imageScalarData = new TypedArray(voxelsPerImage);
-    const volumeBufferView = new TypedArray(buffer, byteOffset, voxelsPerImage);
-    imageScalarData.set(volumeBufferView);
-    return imageScalarData;
-}
 function _isCurrentImagePTPrescaled(modality, imageVolume) {
     if (modality !== 'PT' || !imageVolume.isPreScaled) {
         return false;

package/dist/esm/RenderingEngine/helpers/setVolumesForViewports.d.ts

@@ -1,3 +1,3 @@
 import type { IVolumeInput, IRenderingEngine } from '../../types';
-declare function setVolumesForViewports(renderingEngine: IRenderingEngine, volumeInputs: Array<IVolumeInput>, viewportIds: Array<string>, immediateRender?: boolean, suppressEvents?: boolean): Promise<void>;
+declare function setVolumesForViewports(renderingEngine: IRenderingEngine, volumeInputs: IVolumeInput[], viewportIds: string[], immediateRender?: boolean, suppressEvents?: boolean): Promise<void>;
 export default setVolumesForViewports;

package/dist/esm/RenderingEngine/helpers/viewportTypeToViewportClass.d.ts

@@ -2,11 +2,13 @@ import StackViewport from '../StackViewport';
 import VolumeViewport from '../VolumeViewport';
 import VolumeViewport3D from '../VolumeViewport3D';
 import VideoViewport from '../VideoViewport';
+import WSIViewport from '../WSIViewport';
 declare const viewportTypeToViewportClass: {
     orthographic: typeof VolumeViewport;
     perspective: typeof VolumeViewport;
     stack: typeof StackViewport;
     volume3d: typeof VolumeViewport3D;
     video: typeof VideoViewport;
+    wholeSlide: typeof WSIViewport;
 };
 export default viewportTypeToViewportClass;

package/dist/esm/RenderingEngine/helpers/viewportTypeToViewportClass.js

@@ -3,11 +3,13 @@ import VolumeViewport from '../VolumeViewport';
 import ViewportType from '../../enums/ViewportType';
 import VolumeViewport3D from '../VolumeViewport3D';
 import VideoViewport from '../VideoViewport';
+import WSIViewport from '../WSIViewport';
 const viewportTypeToViewportClass = {
     [ViewportType.ORTHOGRAPHIC]: VolumeViewport,
     [ViewportType.PERSPECTIVE]: VolumeViewport,
     [ViewportType.STACK]: StackViewport,
     [ViewportType.VOLUME_3D]: VolumeViewport3D,
     [ViewportType.VIDEO]: VideoViewport,
+    [ViewportType.WholeSlide]: WSIViewport,
 };
 export default viewportTypeToViewportClass;

package/dist/esm/RenderingEngine/helpers/volumeNewImageEventDispatcher.d.ts

@@ -1,4 +1,4 @@
-import { EventTypes } from '../../types';
+import type { EventTypes } from '../../types';
 export declare function resetVolumeNewImageState(viewportId: string): void;
 declare function volumeNewImageEventDispatcher(cameraEvent: EventTypes.CameraModifiedEvent): void;
 export default volumeNewImageEventDispatcher;

package/dist/esm/RenderingEngine/helpers/volumeNewImageEventDispatcher.js

@@ -1,7 +1,7 @@
-import { getImageSliceDataForVolumeViewport, triggerEvent, } from '../../utilities';
+import getImageSliceDataForVolumeViewport from '../../utilities/getImageSliceDataForVolumeViewport';
+import triggerEvent from '../../utilities/triggerEvent';
 import { Events } from '../../enums';
 import { getRenderingEngine } from '../getRenderingEngine';
-import BaseVolumeViewport from '../BaseVolumeViewport';
 const state = {};
 export function resetVolumeNewImageState(viewportId) {
     if (state[viewportId] !== undefined) {
@@ -12,8 +12,8 @@ function volumeNewImageEventDispatcher(cameraEvent) {
     const { renderingEngineId, viewportId } = cameraEvent.detail;
     const renderingEngine = getRenderingEngine(renderingEngineId);
     const viewport = renderingEngine.getViewport(viewportId);
-    if (!(viewport instanceof BaseVolumeViewport)) {
-        throw new Error(`volumeNewImageEventDispatcher: viewport is not a BaseVolumeViewport`);
+    if (!('setVolumes' in viewport)) {
+        throw new Error(`volumeNewImageEventDispatcher: viewport does not have setVolumes method`);
     }
     if (state[viewport.id] === undefined) {
         state[viewport.id] = 0;

package/dist/esm/RenderingEngine/renderingEngineCache.d.ts

@@ -3,6 +3,6 @@ declare const renderingEngineCache: {
     get: (id: string) => IRenderingEngine;
     set: (re: IRenderingEngine) => void;
     delete: (id: string) => boolean;
-    getAll: () => Array<IRenderingEngine>;
+    getAll: () => IRenderingEngine[];
 };
 export default renderingEngineCache;

package/dist/esm/RenderingEngine/vtkClasses/vtkSlabCamera.d.ts

@@ -1,5 +1,6 @@
 import { mat4 } from 'gl-matrix';
 import type { vtkObject } from '@kitware/vtk.js/interfaces';
+import type { Range } from '@kitware/vtk.js/types';
 interface ICameraInitialValues {
     position?: number[];
     focalPoint?: number[];
@@ -25,7 +26,7 @@ interface ICameraInitialValues {
 export interface vtkSlabCamera extends vtkObject {
     applyTransform(transformMat4: mat4): void;
     azimuth(angle: number): void;
-    computeClippingRange(bounds: number[]): number[];
+    computeClippingRange(bounds: number[]): Range;
     computeDistance(): void;
     computeViewParametersFromPhysicalMatrix(mat: mat4): void;
     computeViewParametersFromViewMatrix(vmat: mat4): void;
@@ -80,7 +81,7 @@ export interface vtkSlabCamera extends vtkObject {
     getWorldToPhysicalMatrix(result: mat4): void;
     getIsPerformingCoordinateTransformation(status: boolean): void;
     orthogonalizeViewUp(): void;
-    physicalOrientationToWorldDirection(ori: number[]): any;
+    physicalOrientationToWorldDirection(ori: number[]): number[];
     pitch(angle: number): void;
     roll(angle: number): void;
     setClippingRange(near: number, far: number): boolean;
@@ -129,6 +130,7 @@ export interface vtkSlabCamera extends vtkObject {
     yaw(angle: number): void;
     zoom(factor: number): void;
     setIsPerformingCoordinateTransformation(status: boolean): void;
+    computeCameraLightTransform(): void;
 }
 declare function extend(publicAPI: any, model: any, initialValues?: ICameraInitialValues): void;
 declare const newInstance: (initialValues?: ICameraInitialValues) => vtkSlabCamera;

package/dist/esm/RenderingEngine/vtkClasses/vtkStreamingOpenGLTexture.js

@@ -1,108 +1,117 @@
 import macro from '@kitware/vtk.js/macros';
 import vtkOpenGLTexture from '@kitware/vtk.js/Rendering/OpenGL/Texture';
-import HalfFloat from '@kitware/vtk.js/Common/Core/HalfFloat';
-import { getConfiguration } from '../../init';
+import cache from '../../cache/cache';
 function vtkStreamingOpenGLTexture(publicAPI, model) {
     model.classHierarchy.push('vtkStreamingOpenGLTexture');
+    model.updatedFrames = [];
+    model.volumeId = null;
     const superCreate3DFilterableFromRaw = publicAPI.create3DFilterableFromRaw;
-    publicAPI.create3DFilterableFromRaw = (width, height, depth, numComps, dataType, data, preferSizeOverAccuracy) => {
+    publicAPI.create3DFilterableFromRaw = (width, height, depth, numberOfComponents, dataType, data, preferSizeOverAccuracy) => {
         model.inputDataType = dataType;
-        model.inputNumComps = numComps;
-        superCreate3DFilterableFromRaw(width, height, depth, numComps, dataType, data, preferSizeOverAccuracy);
+        model.inputNumComps = numberOfComponents;
+        superCreate3DFilterableFromRaw(width, height, depth, numberOfComponents, dataType, data, preferSizeOverAccuracy);
     };
-    publicAPI.update3DFromRaw = (data) => {
-        const { updatedFrames } = model;
-        if (!updatedFrames.length) {
+    publicAPI.update3DFromRaw = () => {
+        const { volumeId } = model;
+        if (!volumeId) {
             return;
         }
+        const volume = cache.getVolume(volumeId);
         model._openGLRenderWindow.activateTexture(publicAPI);
         publicAPI.createTexture();
         publicAPI.bind();
-        let bytesPerVoxel;
-        let TypedArrayConstructor;
-        if (data instanceof Uint8Array) {
-            bytesPerVoxel = 1;
-            TypedArrayConstructor = Uint8Array;
-        }
-        else if (data instanceof Int16Array) {
-            bytesPerVoxel = 2;
-            TypedArrayConstructor = Int16Array;
-        }
-        else if (data instanceof Uint16Array) {
-            bytesPerVoxel = 2;
-            TypedArrayConstructor = Uint16Array;
+        if (volume.isDynamicVolume()) {
+            updateDynamicVolumeTexture();
+            return;
         }
-        else if (data instanceof Float32Array) {
-            bytesPerVoxel = 4;
-            TypedArrayConstructor = Float32Array;
+        return (publicAPI.hasUpdatedFrames() && updateTextureImagesUsingVoxelManager());
+    };
+    const superModified = publicAPI.modified;
+    publicAPI.setUpdatedFrame = (frameIndex) => {
+        model.updatedFrames[frameIndex] = true;
+        superModified();
+    };
+    publicAPI.modified = () => {
+        superModified();
+        const volume = cache.getVolume(model.volumeId);
+        if (!volume) {
+            return;
         }
-        else {
-            throw new Error(`No support for given TypedArray.`);
+        const imageIds = volume.imageIds;
+        for (let i = 0; i < imageIds.length; i++) {
+            model.updatedFrames[i] = true;
         }
-        for (let i = 0; i < updatedFrames.length; i++) {
-            if (updatedFrames[i]) {
-                model.fillSubImage3D(data, i, bytesPerVoxel, TypedArrayConstructor);
+    };
+    function updateTextureImagesUsingVoxelManager() {
+        const volume = cache.getVolume(model.volumeId);
+        const imageIds = volume.imageIds;
+        for (let i = 0; i < model.updatedFrames.length; i++) {
+            if (model.updatedFrames[i]) {
+                const image = cache.getImage(imageIds[i]);
+                if (!image) {
+                    continue;
+                }
+                const data = image.voxelManager.getScalarData();
+                const gl = model.context;
+                const dataType = data.constructor.name;
+                const [pixData] = publicAPI.updateArrayDataTypeForGL(dataType, [data]);
+                publicAPI.bind();
+                const zOffset = i;
+                gl.texSubImage3D(model.target, 0, 0, 0, zOffset, model.width, model.height, 1, model.format, model.openGLDataType, pixData);
+                publicAPI.deactivate();
+                model.updatedFrames[i] = null;
             }
         }
-        model.updatedFrames = [];
         if (model.generateMipmap) {
             model.context.generateMipmap(model.target);
         }
         publicAPI.deactivate();
         return true;
-    };
-    model.fillSubImage3D = (data, frameIndex, bytesPerVoxel, TypedArrayConstructor) => {
-        const buffer = data.buffer;
-        const frameLength = model.width * model.height;
-        const frameLengthInBytes = frameLength * model.components * bytesPerVoxel;
-        const zOffset = frameIndex * frameLengthInBytes;
-        const rowLength = model.width * model.components;
-        const gl = model.context;
-        const MAX_TEXTURE_SIZE = gl.getParameter(gl.MAX_TEXTURE_SIZE);
-        let blockHeight = Math.floor((bytesPerVoxel * MAX_TEXTURE_SIZE) / model.width);
-        blockHeight = Math.min(blockHeight, model.height);
-        const { useNorm16Texture, preferSizeOverAccuracy } = getConfiguration().rendering;
-        if (useNorm16Texture && !preferSizeOverAccuracy) {
-            blockHeight = 1;
-        }
-        const multiRowBlockLength = rowLength * blockHeight;
-        const multiRowBlockLengthInBytes = multiRowBlockLength * bytesPerVoxel;
-        const normalBlocks = Math.floor(model.height / blockHeight);
-        const lastBlockHeight = model.height % blockHeight;
-        const multiRowLastBlockLength = rowLength * lastBlockHeight;
-        for (let block = 0; block < normalBlocks; block++) {
-            const yOffset = block * blockHeight;
-            let dataView = new TypedArrayConstructor(buffer, zOffset + block * multiRowBlockLengthInBytes, multiRowBlockLength);
-            if (model.useHalfFloat &&
-                (TypedArrayConstructor === Uint16Array ||
-                    TypedArrayConstructor === Int16Array)) {
-                for (let idx = 0; idx < dataView.length; idx++) {
-                    dataView[idx] = HalfFloat.toHalf(dataView[idx]);
-                }
-                if (TypedArrayConstructor === Int16Array) {
-                    dataView = new Uint16Array(dataView);
-                }
+    }
+    function updateDynamicVolumeTexture() {
+        const volume = cache.getVolume(model.volumeId);
+        const imageIds = volume.getCurrentTimePointImageIds();
+        for (let i = 0; i < imageIds.length; i++) {
+            const imageId = imageIds[i];
+            const image = cache.getImage(imageId);
+            if (!image) {
+                continue;
             }
-            gl.texSubImage3D(model.target, 0, 0, yOffset, frameIndex, model.width, blockHeight, 1, model.format, model.openGLDataType, dataView);
+            const data = image.voxelManager.getScalarData();
+            const gl = model.context;
+            const dataType = data.constructor.name;
+            const [pixData] = publicAPI.updateArrayDataTypeForGL(dataType, [data]);
+            publicAPI.bind();
+            let zOffset = i;
+            gl.texSubImage3D(model.target, 0, 0, 0, zOffset, model.width, model.height, 1, model.format, model.openGLDataType, pixData);
+            publicAPI.deactivate();
         }
-        if (lastBlockHeight !== 0) {
-            const yOffset = normalBlocks * blockHeight;
-            const dataView = new TypedArrayConstructor(buffer, zOffset + normalBlocks * multiRowBlockLengthInBytes, multiRowLastBlockLength);
-            gl.texSubImage3D(model.target, 0, 0, yOffset, frameIndex, model.width, lastBlockHeight, 1, model.format, model.openGLDataType, dataView);
+        if (model.generateMipmap) {
+            model.context.generateMipmap(model.target);
         }
+        publicAPI.deactivate();
+        return true;
+    }
+    publicAPI.hasUpdatedFrames = () => !model.updatedFrames.length || model.updatedFrames.some((frame) => frame);
+    publicAPI.getUpdatedFrames = () => model.updatedFrames;
+    publicAPI.setVolumeId = (volumeId) => {
+        model.volumeId = volumeId;
     };
-    publicAPI.getTextureParameters = () => {
-        return {
-            width: model.width,
-            height: model.height,
-            depth: model.depth,
-            numComps: model.inputNumComps,
-            dataType: model.inputDataType,
-        };
-    };
-    publicAPI.setUpdatedFrame = (frameIndex) => {
-        model.updatedFrames[frameIndex] = true;
+    publicAPI.getVolumeId = () => model.volumeId;
+    publicAPI.setTextureParameters = ({ width, height, depth, numberOfComponents, dataType, }) => {
+        model.width ??= width;
+        model.height ??= height;
+        model.depth ??= depth;
+        model.inputNumComps ??= numberOfComponents;
+        model.inputDataType ??= dataType;
     };
+    publicAPI.getTextureParameters = () => ({
+        width: model.width,
+        height: model.height,
+        depth: model.depth,
+        numberOfComponents: model.inputNumComps,
+        dataType: model.inputDataType,
+    });
 }
 const DEFAULT_VALUES = {
     updatedFrames: [],

package/dist/esm/RenderingEngine/vtkClasses/vtkStreamingOpenGLViewNodeFactory.js

@@ -31,7 +31,7 @@ function vtkStreamingOpenGLViewNodeFactory(publicAPI, model) {
         let isObject = false;
         const keys = Object.keys(model.overrides);
         while (className && !isObject) {
-            if (keys.indexOf(className) !== -1) {
+            if (keys.includes(className)) {
                 isObject = true;
             }
             else {

package/dist/esm/RenderingEngine/vtkClasses/vtkStreamingOpenGLVolumeMapper.js

@@ -2,8 +2,10 @@ import macro from '@kitware/vtk.js/macros';
 import vtkOpenGLVolumeMapper from '@kitware/vtk.js/Rendering/OpenGL/VolumeMapper';
 import { Filter } from '@kitware/vtk.js/Rendering/OpenGL/Texture/Constants';
 import { VtkDataTypes } from '@kitware/vtk.js/Common/Core/DataArray/Constants';
+import { getTransferFunctionHash } from '@kitware/vtk.js/Rendering/OpenGL/RenderWindow/resourceSharingHelper';
 import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
 import { Representation } from '@kitware/vtk.js/Rendering/Core/Property/Constants';
+import vtkOpenGLTexture from '@kitware/vtk.js/Rendering/OpenGL/Texture';
 function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
     model.classHierarchy.push('vtkStreamingOpenGLVolumeMapper');
     publicAPI.buildBufferObjects = (ren, actor) => {
@@ -11,10 +13,6 @@ function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
         if (!image) {
             return;
         }
-        const scalars = image.getPointData() && image.getPointData().getScalars();
-        if (!scalars) {
-            return;
-        }
         const vprop = actor.getProperty();
         if (!model.jitterTexture.getHandle()) {
             const oTable = new Uint8Array(32 * 32);
@@ -25,18 +23,22 @@ function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
             model.jitterTexture.setMagnificationFilter(Filter.LINEAR);
             model.jitterTexture.create2DFromRaw(32, 32, 1, VtkDataTypes.UNSIGNED_CHAR, oTable);
         }
-        const numComp = scalars.getNumberOfComponents();
-        const iComps = vprop.getIndependentComponents();
-        const numIComps = iComps ? numComp : 1;
-        let toString = `${vprop.getMTime()}`;
-        if (model.opacityTextureString !== toString) {
+        const { numberOfComponents: numIComps } = image.get('numberOfComponents');
+        const useIndependentComps = publicAPI.useIndependentComponents(vprop);
+        const scalarOpacityFunc = vprop.getScalarOpacity();
+        const opTex = model._openGLRenderWindow.getGraphicsResourceForObject(scalarOpacityFunc);
+        let toString = getTransferFunctionHash(scalarOpacityFunc, useIndependentComps, numIComps);
+        const reBuildOp = !opTex?.oglObject || opTex.hash !== toString;
+        if (reBuildOp) {
+            model.opacityTexture = vtkOpenGLTexture.newInstance();
+            model.opacityTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
             const oWidth = 1024;
             const oSize = oWidth * 2 * numIComps;
             const ofTable = new Float32Array(oSize);
             const tmpTable = new Float32Array(oWidth);
             for (let c = 0; c < numIComps; ++c) {
                 const ofun = vprop.getScalarOpacity(c);
-                const opacityFactor = model.renderable.getSampleDistance() /
+                const opacityFactor = publicAPI.getCurrentSampleDistance(ren) /
                     vprop.getScalarOpacityUnitDistance(c);
                 const oRange = ofun.getRange();
                 ofun.getTable(oRange[0], oRange[1], oWidth, tmpTable, 1);
@@ -46,7 +48,7 @@ function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
                     ofTable[c * oWidth * 2 + i + oWidth] = ofTable[c * oWidth * 2 + i];
                 }
             }
-            model.opacityTexture.releaseGraphicsResources(model._openGLRenderWindow);
+            model.opacityTexture.resetFormatAndType();
             model.opacityTexture.setMinificationFilter(Filter.LINEAR);
             model.opacityTexture.setMagnificationFilter(Filter.LINEAR);
             if (model._openGLRenderWindow.getWebgl2() ||
@@ -55,19 +57,34 @@ function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
                 model.opacityTexture.create2DFromRaw(oWidth, 2 * numIComps, 1, VtkDataTypes.FLOAT, ofTable);
             }
             else {
-                const oTable = new Uint8Array(oSize);
+                const oTable = new Uint8ClampedArray(oSize);
                 for (let i = 0; i < oSize; ++i) {
                     oTable[i] = 255.0 * ofTable[i];
                 }
                 model.opacityTexture.create2DFromRaw(oWidth, 2 * numIComps, 1, VtkDataTypes.UNSIGNED_CHAR, oTable);
             }
-            model.opacityTextureString = toString;
+            if (scalarOpacityFunc) {
+                model._openGLRenderWindow.setGraphicsResourceForObject(scalarOpacityFunc, model.opacityTexture, toString);
+                if (scalarOpacityFunc !== model._scalarOpacityFunc) {
+                    model._openGLRenderWindow.registerGraphicsResourceUser(scalarOpacityFunc, publicAPI);
+                    model._openGLRenderWindow.unregisterGraphicsResourceUser(model._scalarOpacityFunc, publicAPI);
+                }
+                model._scalarOpacityFunc = scalarOpacityFunc;
+            }
+        }
+        else {
+            model.opacityTexture = opTex.oglObject;
         }
-        toString = `${vprop.getMTime()}`;
-        if (model.colorTextureString !== toString) {
+        const colorTransferFunc = vprop.getRGBTransferFunction();
+        toString = getTransferFunctionHash(colorTransferFunc, useIndependentComps, numIComps);
+        const cTex = model._openGLRenderWindow.getGraphicsResourceForObject(colorTransferFunc);
+        const reBuildC = !cTex?.oglObject?.getHandle() || cTex?.hash !== toString;
+        if (reBuildC) {
+            model.colorTexture = vtkOpenGLTexture.newInstance();
+            model.colorTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
             const cWidth = 1024;
             const cSize = cWidth * 2 * numIComps * 3;
-            const cTable = new Uint8Array(cSize);
+            const cTable = new Uint8ClampedArray(cSize);
             const tmpTable = new Float32Array(cWidth * 3);
             for (let c = 0; c < numIComps; ++c) {
                 const cfun = vprop.getRGBTransferFunction(c);
@@ -78,39 +95,57 @@ function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
                     cTable[c * cWidth * 6 + i + cWidth * 3] = 255.0 * tmpTable[i];
                 }
             }
-            model.colorTexture.releaseGraphicsResources(model._openGLRenderWindow);
+            model.colorTexture.resetFormatAndType();
             model.colorTexture.setMinificationFilter(Filter.LINEAR);
             model.colorTexture.setMagnificationFilter(Filter.LINEAR);
             model.colorTexture.create2DFromRaw(cWidth, 2 * numIComps, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
-            model.colorTextureString = toString;
+            if (colorTransferFunc) {
+                model._openGLRenderWindow.setGraphicsResourceForObject(colorTransferFunc, model.colorTexture, toString);
+                if (colorTransferFunc !== model._colorTransferFunc) {
+                    model._openGLRenderWindow.registerGraphicsResourceUser(colorTransferFunc, publicAPI);
+                    model._openGLRenderWindow.unregisterGraphicsResourceUser(model._colorTransferFunc, publicAPI);
+                }
+                model._colorTransferFunc = colorTransferFunc;
+            }
+        }
+        else {
+            model.colorTexture = cTex.oglObject;
         }
         publicAPI.updateLabelOutlineThicknessTexture(actor);
-        toString = `${image.getMTime()}`;
+        toString = `${image.getMTime()}-${model.scalarTexture.getMTime()}`;
         if (model.scalarTextureString !== toString) {
             const dims = image.getDimensions();
+            model.scalarTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
+            model.scalarTexture.enableUseHalfFloat(false);
             const previousTextureParameters = model.scalarTexture.getTextureParameters();
-            const dataType = image.getPointData().getScalars().getDataType();
-            const data = image.getPointData().getScalars().getData();
+            const dataType = image.get('dataType').dataType;
             let shouldReset = true;
-            if (previousTextureParameters.dataType &&
-                previousTextureParameters.dataType === dataType) {
-                const previousTextureSize = previousTextureParameters.width *
-                    previousTextureParameters.height *
-                    previousTextureParameters.depth *
-                    previousTextureParameters.numComps;
-                if (data.length === previousTextureSize) {
-                    shouldReset = false;
+            if (previousTextureParameters?.dataType === dataType) {
+                if (previousTextureParameters?.width === dims[0]) {
+                    if (previousTextureParameters?.height === dims[1]) {
+                        if (previousTextureParameters?.depth === dims[2]) {
+                            shouldReset = false;
+                        }
+                    }
                 }
             }
             if (shouldReset) {
-                model.scalarTexture.setOglNorm16Ext(model.context.getExtension('EXT_texture_norm16'));
-                model.scalarTexture.releaseGraphicsResources(model._openGLRenderWindow);
+                const norm16Ext = model.context.getExtension('EXT_texture_norm16');
+                model.scalarTexture.setOglNorm16Ext(norm16Ext);
                 model.scalarTexture.resetFormatAndType();
-                model.scalarTexture.create3DFilterableFromRaw(dims[0], dims[1], dims[2], numComp, scalars.getDataType(), scalars.getData(), model.renderable.getPreferSizeOverAccuracy());
+                model.scalarTexture.setTextureParameters({
+                    width: dims[0],
+                    height: dims[1],
+                    depth: dims[2],
+                    numberOfComponents: numIComps,
+                    dataType,
+                });
+                model.scalarTexture.create3DFromRaw(dims[0], dims[1], dims[2], numIComps, dataType, null);
+                model.scalarTexture.update3DFromRaw();
             }
             else {
                 model.scalarTexture.deactivate();
-                model.scalarTexture.update3DFromRaw(data);
+                model.scalarTexture.update3DFromRaw();
             }
             model.scalarTextureString = toString;
         }
@@ -146,16 +181,22 @@ function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
         }
         model.VBOBuildTime.modified();
     };
-    publicAPI.getRenderTargetSize = () => {
-        if (model._useSmallViewport) {
-            return [model._smallViewportWidth, model._smallViewportHeight];
+    publicAPI.getNeedToRebuildBufferObjects = (ren, actor) => {
+        if (model.VBOBuildTime.getMTime() < publicAPI.getMTime() ||
+            model.VBOBuildTime.getMTime() < actor.getMTime() ||
+            model.VBOBuildTime.getMTime() < model.renderable.getMTime() ||
+            model.VBOBuildTime.getMTime() < actor.getProperty().getMTime() ||
+            model.VBOBuildTime.getMTime() < model.currentInput.getMTime() ||
+            model.VBOBuildTime.getMTime() < model.scalarTexture?.getMTime() ||
+            model.VBOBuildTime.getMTime() < model.colorTexture?.getMTime() ||
+            model.VBOBuildTime.getMTime() <
+                model.labelOutlineThicknessTexture?.getMTime() ||
+            !model.scalarTexture?.getHandle() ||
+            !model.colorTexture?.getHandle() ||
+            !model.labelOutlineThicknessTexture?.getHandle()) {
+            return true;
         }
-        const { usize, vsize } = model._openGLRenderer.getTiledSizeAndOrigin();
-        return [usize, vsize];
-    };
-    publicAPI.getRenderTargetOffset = () => {
-        const { lowerLeftU, lowerLeftV } = model._openGLRenderer.getTiledSizeAndOrigin();
-        return [lowerLeftU, lowerLeftV];
+        return false;
     };
 }
 const DEFAULT_VALUES = {};

package/dist/esm/Settings.d.ts

@@ -8,7 +8,7 @@ export default class Settings {
     import(root: Record<string, unknown>): void;
     dump(): Record<string, unknown>;
     static assert(subject: Settings): Settings;
-    static getDefaultSettings(subfield?: any): Settings | any;
+    static getDefaultSettings(subfield?: any): Settings | unknown;
     static getRuntimeSettings(): Settings;
     static getObjectSettings(subject: unknown, from?: unknown): Settings;
     static extendRuntimeSettings(): Settings;