@cornerstonejs/core 4.11.5 → 4.12.1

package/dist/esm/RenderingEngine/StackViewport.js

@@ -111,10 +111,6 @@ class StackViewport extends Viewport {
             mapper.setInputData(imageData);
             const actor = vtkImageSlice.newInstance();
             actor.setMapper(mapper);
-            const { preferSizeOverAccuracy } = getConfiguration().rendering;
-            if (preferSizeOverAccuracy) {
-                mapper.setPreferSizeOverAccuracy(true);
-            }
             if (imageData.getPointData().getScalars().getNumberOfComponents() > 1) {
                 actor.getProperty().setIndependentComponents(false);
             }

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

@@ -4,6 +4,7 @@ import createVolumeMapper from './createVolumeMapper';
 import triggerEvent from '../../utilities/triggerEvent';
 import { Events } from '../../enums';
 import setDefaultVolumeVOI from './setDefaultVolumeVOI';
+import { getConfiguration } from '../../init';
 async function createVolumeActor(props, element, viewportId, suppressEvents = false) {
     const { volumeId, callback, blendMode } = props;
     const imageVolume = await loadVolume(volumeId);
@@ -20,6 +21,9 @@ async function createVolumeActor(props, element, viewportId, suppressEvents = fa
     const { numberOfComponents } = imageData.get('numberOfComponents');
     const volumeProperty = volumeActor.getProperty();
     volumeProperty.set({ viewportId: viewportId }, true);
+    if (getConfiguration().rendering.preferSizeOverAccuracy) {
+        volumeProperty.setPreferSizeOverAccuracy(true);
+    }
     if (numberOfComponents === 3) {
         volumeActor.getProperty().setIndependentComponents(false);
     }

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

@@ -4,9 +4,6 @@ import vtkVolumeMapper from '@kitware/vtk.js/Rendering/Core/VolumeMapper';
 import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
 export default function createVolumeMapper(imageData, vtkOpenGLTexture) {
     const volumeMapper = vtkSharedVolumeMapper.newInstance();
-    if (getConfiguration().rendering.preferSizeOverAccuracy) {
-        volumeMapper.setPreferSizeOverAccuracy(true);
-    }
     volumeMapper.setInputData(imageData);
     const spacing = imageData.getSpacing();
     const sampleDistanceMultiplier = getConfiguration().rendering?.volumeRendering?.sampleDistanceMultiplier ||

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

@@ -13,10 +13,18 @@ function vtkStreamingOpenGLTexture(publicAPI, model) {
     model.updatedFrames = [];
     model.volumeId = null;
     const superCreate3DFilterableFromRaw = publicAPI.create3DFilterableFromRaw;
-    publicAPI.create3DFilterableFromRaw = (width, height, depth, numberOfComponents, dataType, data, preferSizeOverAccuracy) => {
+    publicAPI.create3DFilterableFromRaw = ({ width, height, depth, numberOfComponents, dataType, data, preferSizeOverAccuracy, }) => {
         model.inputDataType = dataType;
         model.inputNumComps = numberOfComponents;
-        superCreate3DFilterableFromRaw(width, height, depth, numberOfComponents, dataType, data, preferSizeOverAccuracy);
+        superCreate3DFilterableFromRaw({
+            width,
+            height,
+            depth,
+            numberOfComponents,
+            dataType,
+            data,
+            preferSizeOverAccuracy,
+        });
     };
     const superUpdate = publicAPI.updateVolumeInfoForGL;
     publicAPI.updateVolumeInfoForGL = (dataType, numComps) => {

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

@@ -1,47 +1,143 @@
 import macro from '@kitware/vtk.js/macros';
+import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
+import { VtkDataTypes } from '@kitware/vtk.js/Common/Core/DataArray/Constants';
 import vtkOpenGLVolumeMapper from '@kitware/vtk.js/Rendering/OpenGL/VolumeMapper';
+import vtkOpenGLTexture from '@kitware/vtk.js/Rendering/OpenGL/Texture';
 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 { getTransferFunctionsHash } from '@kitware/vtk.js/Rendering/OpenGL/RenderWindow/resourceSharingHelper';
 import { Representation } from '@kitware/vtk.js/Rendering/Core/Property/Constants';
-import vtkOpenGLTexture from '@kitware/vtk.js/Rendering/OpenGL/Texture';
-import { getConstructorFromType } from '../../utilities/getBufferConfiguration';
+import { BlendMode } from '@kitware/vtk.js/Rendering/Core/VolumeMapper/Constants';
 import { getCanUseNorm16Texture } from '../../init';
 function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
     model.classHierarchy.push('vtkStreamingOpenGLVolumeMapper');
-    publicAPI.buildBufferObjects = (ren, actor) => {
-        const image = model.currentInput;
-        if (!image) {
+    const graphicsResourceReferenceCount = new Map();
+    function decreaseGraphicsResourceCount(openGLRenderWindow, coreObject) {
+        if (!coreObject) {
+            return;
+        }
+        const oldCount = graphicsResourceReferenceCount.get(coreObject) ?? 0;
+        const newCount = oldCount - 1;
+        if (newCount <= 0) {
+            openGLRenderWindow.unregisterGraphicsResourceUser(coreObject, publicAPI);
+            graphicsResourceReferenceCount.delete(coreObject);
+        }
+        else {
+            graphicsResourceReferenceCount.set(coreObject, newCount);
+        }
+    }
+    function increaseGraphicsResourceCount(openGLRenderWindow, coreObject) {
+        if (!coreObject) {
+            return;
+        }
+        const oldCount = graphicsResourceReferenceCount.get(coreObject) ?? 0;
+        const newCount = oldCount + 1;
+        graphicsResourceReferenceCount.set(coreObject, newCount);
+        if (oldCount <= 0) {
+            openGLRenderWindow.registerGraphicsResourceUser(coreObject, publicAPI);
+        }
+    }
+    function replaceGraphicsResource(openGLRenderWindow, oldResourceCoreObject, newResourceCoreObject) {
+        if (oldResourceCoreObject === newResourceCoreObject) {
             return;
         }
-        const vprop = actor.getProperty();
+        decreaseGraphicsResourceCount(openGLRenderWindow, oldResourceCoreObject);
+        increaseGraphicsResourceCount(openGLRenderWindow, newResourceCoreObject);
+    }
+    publicAPI.renderPiece = (ren, actor) => {
+        publicAPI.invokeEvent({ type: 'StartEvent' });
+        model.renderable.update();
+        const numberOfInputs = model.renderable.getNumberOfInputPorts();
+        model.currentValidInputs = [];
+        for (let inputIndex = 0; inputIndex < numberOfInputs; ++inputIndex) {
+            const imageData = model.renderable.getInputData(inputIndex);
+            if (imageData && !imageData.isDeleted()) {
+                model.currentValidInputs.push({ imageData, inputIndex });
+            }
+        }
+        let newNumberOfLights = 0;
+        if (model.currentValidInputs.length > 0) {
+            const volumeProperties = actor.getProperties();
+            const firstValidInput = model.currentValidInputs[0];
+            const firstImageData = firstValidInput.imageData;
+            const firstVolumeProperty = volumeProperties[firstValidInput.inputIndex];
+            if (firstVolumeProperty.getShade() &&
+                model.renderable.getBlendMode() === BlendMode.COMPOSITE_BLEND) {
+                ren.getLights().forEach((light) => {
+                    if (light.getSwitch() > 0) {
+                        newNumberOfLights++;
+                    }
+                });
+            }
+            const numberOfValidInputs = model.currentValidInputs.length;
+            const multiTexturePerVolumeEnabled = numberOfValidInputs > 1;
+            const { numberOfComponents } = firstImageData.get('numberOfComponents');
+            model.numberOfComponents = multiTexturePerVolumeEnabled
+                ? numberOfValidInputs
+                : numberOfComponents;
+            if (model.numberOfComponents > 1) {
+                model.useIndependentComponents =
+                    firstVolumeProperty.getIndependentComponents();
+            }
+            else {
+                model.useIndependentComponents = false;
+            }
+        }
+        if (newNumberOfLights !== model.numberOfLights) {
+            model.numberOfLights = newNumberOfLights;
+            publicAPI.modified();
+        }
+        publicAPI.invokeEvent({ type: 'EndEvent' });
+        if (model.currentValidInputs.length === 0) {
+            return;
+        }
+        publicAPI.renderPieceStart(ren, actor);
+        publicAPI.renderPieceDraw(ren, actor);
+        publicAPI.renderPieceFinish(ren, actor);
+    };
+    publicAPI.buildBufferObjects = (ren, actor) => {
         if (!model.jitterTexture.getHandle()) {
-            const oTable = new Uint8Array(32 * 32);
+            const jitterArray = new Float32Array(32 * 32);
             for (let i = 0; i < 32 * 32; ++i) {
-                oTable[i] = 255.0 * Math.random();
-            }
-            model.jitterTexture.setMinificationFilter(Filter.LINEAR);
-            model.jitterTexture.setMagnificationFilter(Filter.LINEAR);
-            model.jitterTexture.create2DFromRaw(32, 32, 1, VtkDataTypes.UNSIGNED_CHAR, oTable);
-        }
-        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;
+                jitterArray[i] = Math.random();
+            }
+            model.jitterTexture.setMinificationFilter(Filter.NEAREST);
+            model.jitterTexture.setMagnificationFilter(Filter.NEAREST);
+            model.jitterTexture.create2DFromRaw({
+                width: 32,
+                height: 32,
+                numComps: 1,
+                dataType: VtkDataTypes.FLOAT,
+                data: jitterArray,
+            });
+        }
+        const volumeProperties = actor.getProperties();
+        const firstValidInput = model.currentValidInputs[0];
+        const firstVolumeProperty = volumeProperties[firstValidInput.inputIndex];
+        const numberOfComponents = model.numberOfComponents;
+        const useIndependentComps = model.useIndependentComponents;
+        const numIComps = useIndependentComps ? numberOfComponents : 1;
+        const opacityFunctions = [];
+        for (let component = 0; component < numIComps; ++component) {
+            opacityFunctions.push(firstVolumeProperty.getScalarOpacity(component));
+        }
+        const opacityFuncHash = getTransferFunctionsHash(opacityFunctions, useIndependentComps, numIComps);
+        const firstScalarOpacityFunc = firstVolumeProperty.getScalarOpacity();
+        const opTex = model._openGLRenderWindow.getGraphicsResourceForObject(firstScalarOpacityFunc);
+        const reBuildOp = !opTex?.oglObject?.getHandle() || opTex.hash !== opacityFuncHash;
         if (reBuildOp) {
-            model.opacityTexture = vtkOpenGLTexture.newInstance();
-            model.opacityTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-            const oWidth = 1024;
+            const newOpacityTexture = vtkOpenGLTexture.newInstance();
+            newOpacityTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
+            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);
             for (let c = 0; c < numIComps; ++c) {
-                const ofun = vprop.getScalarOpacity(c);
+                const ofun = firstVolumeProperty.getScalarOpacity(c);
                 const opacityFactor = publicAPI.getCurrentSampleDistance(ren) /
-                    vprop.getScalarOpacityUnitDistance(c);
+                    firstVolumeProperty.getScalarOpacityUnitDistance(c);
                 const oRange = ofun.getRange();
                 ofun.getTable(oRange[0], oRange[1], oWidth, tmpTable, 1);
                 for (let i = 0; i < oWidth; ++i) {
@@ -50,46 +146,63 @@ function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
                     ofTable[c * oWidth * 2 + i + oWidth] = ofTable[c * oWidth * 2 + i];
                 }
             }
-            model.opacityTexture.resetFormatAndType();
-            model.opacityTexture.setMinificationFilter(Filter.LINEAR);
-            model.opacityTexture.setMagnificationFilter(Filter.LINEAR);
-            if (model._openGLRenderWindow.getWebgl2() &&
-                model.context.getExtension('OES_texture_float') &&
-                model.context.getExtension('OES_texture_float_linear')) {
-                model.opacityTexture.create2DFromRaw(oWidth, 2 * numIComps, 1, VtkDataTypes.FLOAT, ofTable);
+            newOpacityTexture.resetFormatAndType();
+            newOpacityTexture.setMinificationFilter(Filter.LINEAR);
+            newOpacityTexture.setMagnificationFilter(Filter.LINEAR);
+            if (model._openGLRenderWindow.getWebgl2() ||
+                (model.context.getExtension('OES_texture_float') &&
+                    model.context.getExtension('OES_texture_float_linear'))) {
+                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];
                 }
-                model.opacityTexture.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 (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;
+            if (firstScalarOpacityFunc) {
+                model._openGLRenderWindow.setGraphicsResourceForObject(firstScalarOpacityFunc, newOpacityTexture, opacityFuncHash);
             }
+            model.opacityTexture = newOpacityTexture;
         }
         else {
             model.opacityTexture = opTex.oglObject;
         }
-        const colorTransferFunc = vprop.getRGBTransferFunction();
-        toString = getTransferFunctionHash(colorTransferFunc, useIndependentComps, numIComps);
-        const cTex = model._openGLRenderWindow.getGraphicsResourceForObject(colorTransferFunc);
-        const reBuildC = !cTex?.oglObject?.getHandle() || cTex?.hash !== toString;
+        replaceGraphicsResource(model._openGLRenderWindow, model._opacityTextureCore, firstScalarOpacityFunc);
+        model._opacityTextureCore = firstScalarOpacityFunc;
+        const colorTransferFunctions = [];
+        for (let component = 0; component < numIComps; ++component) {
+            colorTransferFunctions.push(firstVolumeProperty.getRGBTransferFunction(component));
+        }
+        const colorFuncHash = getTransferFunctionsHash(colorTransferFunctions, useIndependentComps, numIComps);
+        const firstColorTransferFunc = firstVolumeProperty.getRGBTransferFunction();
+        const cTex = model._openGLRenderWindow.getGraphicsResourceForObject(firstColorTransferFunc);
+        const reBuildC = !cTex?.oglObject?.getHandle() || cTex?.hash !== colorFuncHash;
         if (reBuildC) {
-            model.colorTexture = vtkOpenGLTexture.newInstance();
-            model.colorTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
-            const cWidth = 1024;
+            const newColorTexture = vtkOpenGLTexture.newInstance();
+            newColorTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
+            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);
             for (let c = 0; c < numIComps; ++c) {
-                const cfun = vprop.getRGBTransferFunction(c);
+                const cfun = firstVolumeProperty.getRGBTransferFunction(c);
                 const cRange = cfun.getRange();
                 cfun.getTable(cRange[0], cRange[1], cWidth, tmpTable, 1);
                 for (let i = 0; i < cWidth * 3; ++i) {
@@ -97,60 +210,124 @@ function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
                     cTable[c * cWidth * 6 + i + cWidth * 3] = 255.0 * tmpTable[i];
                 }
             }
-            model.colorTexture.resetFormatAndType();
-            model.colorTexture.setMinificationFilter(Filter.LINEAR);
-            model.colorTexture.setMagnificationFilter(Filter.LINEAR);
-            model.colorTexture.create2DFromRaw(cWidth, 2 * numIComps, 3, VtkDataTypes.UNSIGNED_CHAR, cTable);
-            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;
-            }
+            newColorTexture.resetFormatAndType();
+            newColorTexture.setMinificationFilter(Filter.LINEAR);
+            newColorTexture.setMagnificationFilter(Filter.LINEAR);
+            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 {
             model.colorTexture = cTex.oglObject;
         }
-        publicAPI.updateLabelOutlineThicknessTexture(actor);
-        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.get('dataType').dataType;
-            let shouldReset = true;
-            if (previousTextureParameters?.dataType === dataType) {
-                if (previousTextureParameters?.width === dims[0]) {
-                    if (previousTextureParameters?.height === dims[1]) {
-                        if (previousTextureParameters?.depth === dims[2]) {
-                            shouldReset = false;
+        replaceGraphicsResource(model._openGLRenderWindow, model._colorTextureCore, firstColorTransferFunc);
+        model._colorTextureCore = firstColorTransferFunc;
+        model.currentValidInputs.forEach(({ imageData, inputIndex: _inputIndex }, component) => {
+            if (!model.scalarTextures) {
+                model.scalarTextures = [];
+            }
+            if (!model.scalarTextures[component]) {
+                console.warn(`ScalarTexture for component ${component} not initialized, skipping.`);
+                return;
+            }
+            const currentTexture = model.scalarTextures[component];
+            const toString = `${imageData.getMTime()}-${currentTexture.getMTime()}`;
+            if (!model.scalarTextureStrings) {
+                model.scalarTextureStrings = [];
+            }
+            if (model.scalarTextureStrings[component] !== toString) {
+                const dims = imageData.getDimensions();
+                currentTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
+                currentTexture.enableUseHalfFloat(false);
+                const previousTextureParameters = currentTexture.getTextureParameters();
+                const dataType = imageData.get('dataType').dataType;
+                let shouldReset = true;
+                if (previousTextureParameters?.dataType === dataType) {
+                    if (previousTextureParameters?.width === dims[0]) {
+                        if (previousTextureParameters?.height === dims[1]) {
+                            if (previousTextureParameters?.depth === dims[2]) {
+                                shouldReset = false;
+                            }
                         }
                     }
                 }
+                if (shouldReset) {
+                    const norm16Ext = model.context.getExtension('EXT_texture_norm16');
+                    currentTexture.setOglNorm16Ext(getCanUseNorm16Texture() ? norm16Ext : null);
+                    currentTexture.resetFormatAndType();
+                    currentTexture.setTextureParameters({
+                        width: dims[0],
+                        height: dims[1],
+                        depth: dims[2],
+                        numberOfComponents: numIComps,
+                        dataType,
+                    });
+                    currentTexture.create3DFromRaw({
+                        width: dims[0],
+                        height: dims[1],
+                        depth: dims[2],
+                        numComps: numIComps,
+                        dataType,
+                        data: null,
+                    });
+                    currentTexture.update3DFromRaw();
+                }
+                else {
+                    currentTexture.deactivate();
+                    currentTexture.update3DFromRaw();
+                }
+                model.scalarTextureStrings[component] = toString;
             }
-            if (shouldReset) {
-                const norm16Ext = model.context.getExtension('EXT_texture_norm16');
-                model.scalarTexture.setOglNorm16Ext(getCanUseNorm16Texture() ? norm16Ext : null);
-                model.scalarTexture.resetFormatAndType();
-                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();
+            if (!model._scalarTexturesCore) {
+                model._scalarTexturesCore = [];
             }
-            else {
-                model.scalarTexture.deactivate();
-                model.scalarTexture.update3DFromRaw();
+        });
+        const labelOutlineThicknessArray = firstVolumeProperty.getLabelOutlineThickness();
+        const lTex = model._openGLRenderWindow.getGraphicsResourceForObject(labelOutlineThicknessArray);
+        const labelOutlineThicknessHash = labelOutlineThicknessArray.join('-');
+        const reBuildL = !lTex?.oglObject?.getHandle() || lTex?.hash !== labelOutlineThicknessHash;
+        if (reBuildL) {
+            const newLabelOutlineThicknessTexture = vtkOpenGLTexture.newInstance();
+            newLabelOutlineThicknessTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
+            let lWidth = model.renderable.getLabelOutlineTextureWidth();
+            if (lWidth <= 0) {
+                lWidth = model.context.getParameter(model.context.MAX_TEXTURE_SIZE);
             }
-            model.scalarTextureString = toString;
+            const lHeight = 1;
+            const lSize = lWidth * lHeight;
+            const lTable = new Uint8Array(lSize);
+            for (let i = 0; i < lWidth; ++i) {
+                const thickness = typeof labelOutlineThicknessArray[i] !== 'undefined'
+                    ? labelOutlineThicknessArray[i]
+                    : labelOutlineThicknessArray[0];
+                lTable[i] = thickness;
+            }
+            newLabelOutlineThicknessTexture.resetFormatAndType();
+            newLabelOutlineThicknessTexture.setMinificationFilter(Filter.NEAREST);
+            newLabelOutlineThicknessTexture.setMagnificationFilter(Filter.NEAREST);
+            newLabelOutlineThicknessTexture.create2DFromRaw({
+                width: lWidth,
+                height: lHeight,
+                numComps: 1,
+                dataType: VtkDataTypes.UNSIGNED_CHAR,
+                data: lTable,
+            });
+            if (labelOutlineThicknessArray) {
+                model._openGLRenderWindow.setGraphicsResourceForObject(labelOutlineThicknessArray, newLabelOutlineThicknessTexture, labelOutlineThicknessHash);
+            }
+            model.labelOutlineThicknessTexture = newLabelOutlineThicknessTexture;
         }
+        else {
+            model.labelOutlineThicknessTexture = lTex.oglObject;
+        }
+        replaceGraphicsResource(model._openGLRenderWindow, model._labelOutlineThicknessTextureCore, labelOutlineThicknessArray);
+        model._labelOutlineThicknessTextureCore = labelOutlineThicknessArray;
         if (!model.tris.getCABO().getElementCount()) {
             const ptsArray = new Float32Array(12);
             for (let i = 0; i < 4; i++) {
@@ -188,16 +365,33 @@ function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
             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;
         }
+        if (model.scalarTextures && model.scalarTextures.length > 0) {
+            for (let i = 0; i < model.scalarTextures.length; i++) {
+                const texture = model.scalarTextures[i];
+                if (texture &&
+                    (model.VBOBuildTime.getMTime() < texture.getMTime() ||
+                        !texture.getHandle())) {
+                    return true;
+                }
+            }
+        }
+        if (model.currentValidInputs && model.currentValidInputs.length > 0) {
+            for (let i = 0; i < model.currentValidInputs.length; i++) {
+                const input = model.currentValidInputs[i];
+                if (input &&
+                    input.imageData &&
+                    model.VBOBuildTime.getMTime() < input.imageData.getMTime()) {
+                    return true;
+                }
+            }
+        }
         return false;
     };
 }
@@ -205,7 +399,14 @@ const DEFAULT_VALUES = {};
 export function extend(publicAPI, model, initialValues = {}) {
     Object.assign(model, DEFAULT_VALUES, initialValues);
     vtkOpenGLVolumeMapper.extend(publicAPI, model, initialValues);
-    model.scalarTexture = initialValues.scalarTexture;
+    if (initialValues.scalarTexture) {
+        model.scalarTextures = [initialValues.scalarTexture];
+    }
+    else {
+        model.scalarTextures = [];
+    }
+    model.scalarTextureStrings = [];
+    model._scalarTexturesCore = [];
     model.previousState = {};
     vtkStreamingOpenGLVolumeMapper(publicAPI, model);
 }

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "4.11.5";
+export declare const version = "4.12.1";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '4.11.5';
+export const version = '4.12.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "4.11.5",
+  "version": "4.12.1",
   "description": "Cornerstone3D Core",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
@@ -81,7 +81,7 @@
     "prepublishOnly": "yarn run build"
   },
   "dependencies": {
-    "@kitware/vtk.js": "32.12.1",
+    "@kitware/vtk.js": "34.15.1",
     "comlink": "4.4.2",
     "gl-matrix": "3.4.3",
     "loglevel": "1.9.2"
@@ -97,5 +97,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "9dc8d3389f395190f13c42d583b09586053f50ee"
+  "gitHead": "ba9c1f6316761f852a6278a70b012d89241b9e54"
 }