@cornerstonejs/core 5.0.0-beta.1 → 5.0.1

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

@@ -0,0 +1,420 @@
+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 { Representation } from '@kitware/vtk.js/Rendering/Core/Property/Constants';
+import vtkOpenGLImageResliceMapper from '@kitware/vtk.js/Rendering/OpenGL/ImageResliceMapper';
+import { getImageDataHash, getTransferFunctionsHash, } from '@kitware/vtk.js/Rendering/OpenGL/RenderWindow/resourceSharingHelper';
+import vtkOpenGLTexture from '@kitware/vtk.js/Rendering/OpenGL/Texture';
+import { getCanUseNorm16Texture } from '../../init';
+const { vtkErrorMacro } = macro;
+function findLabelOutlineProperties(actor, currentValidInputs) {
+    const labelmapProperties = [];
+    for (let i = 0; i < currentValidInputs.length; i++) {
+        const property = actor.getProperty(currentValidInputs[i].inputIndex);
+        if (property?.getUseLabelOutline()) {
+            labelmapProperties.push({
+                property,
+                arrayIndex: i,
+            });
+        }
+    }
+    return labelmapProperties;
+}
+function vtkStreamingOpenGLImageResliceMapper(publicAPI, model) {
+    model.classHierarchy.push('vtkStreamingOpenGLImageResliceMapper');
+    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;
+        }
+        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 });
+            }
+        }
+        const numberOfValidInputs = model.currentValidInputs.length;
+        if (numberOfValidInputs <= 0) {
+            vtkErrorMacro('No input!');
+            return;
+        }
+        model.labelOutlineProperties = findLabelOutlineProperties(actor, model.currentValidInputs);
+        const firstImageData = model.currentValidInputs[0].imageData;
+        const firstScalars = firstImageData.getPointData().getScalars();
+        const { numberOfComponents } = firstImageData.get('numberOfComponents') || {
+            numberOfComponents: undefined,
+        };
+        model.multiTexturePerVolumeEnabled = numberOfValidInputs > 1;
+        model.numberOfComponents = model.multiTexturePerVolumeEnabled
+            ? numberOfValidInputs
+            : typeof numberOfComponents === 'number'
+                ? numberOfComponents
+                : (firstScalars?.getNumberOfComponents?.() ?? 1);
+        publicAPI.updateResliceGeometry();
+        publicAPI.renderPieceStart(ren, actor);
+        publicAPI.renderPieceDraw(ren, actor);
+        publicAPI.renderPieceFinish(ren, actor);
+        publicAPI.invokeEvent({ type: 'EndEvent' });
+    };
+    publicAPI.getNeedToRebuildBufferObjects = (ren, actor) => {
+        const useLabelOutline = model.labelOutlineProperties.length > 0;
+        if (model.VBOBuildTime.getMTime() < publicAPI.getMTime() ||
+            model.VBOBuildTime.getMTime() < actor.getMTime() ||
+            model.VBOBuildTime.getMTime() < model.renderable.getMTime() ||
+            model.VBOBuildTime.getMTime() <
+                actor.getProperty(model.currentValidInputs[0].inputIndex)?.getMTime() ||
+            model.currentValidInputs.some(({ imageData }) => model.VBOBuildTime.getMTime() < imageData.getMTime()) ||
+            model.VBOBuildTime.getMTime() < model.resliceGeom.getMTime() ||
+            model.scalarTextures.length !== model.currentValidInputs.length ||
+            !model.colorTexture?.getHandle() ||
+            !model.pwfTexture?.getHandle() ||
+            (useLabelOutline &&
+                (!model.labelOutlineThicknessTexture?.getHandle() ||
+                    !model.labelOutlineOpacityTexture?.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;
+                }
+            }
+        }
+        return false;
+    };
+    publicAPI.buildBufferObjects = (ren, actor) => {
+        const actorProperties = actor.getProperties();
+        model.currentValidInputs.forEach(({ imageData }, component) => {
+            if (!model.scalarTextures) {
+                model.scalarTextures = [];
+            }
+            if (!model.scalarTextures[component]) {
+                model.scalarTextures[component] = vtkOpenGLTexture.newInstance();
+            }
+            const currentTexture = model.scalarTextures[component];
+            const actorProperty = actorProperties[component];
+            const updatedExtents = actorProperty.getUpdatedExtents();
+            const hasUpdatedExtents = !!updatedExtents.length;
+            const canStream = currentTexture && typeof currentTexture.hasUpdatedFrames === 'function';
+            if (canStream) {
+                const dims = imageData.getDimensions();
+                const { dataType } = imageData.get('dataType');
+                const numComps = model.numberOfComponents;
+                currentTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
+                currentTexture.enableUseHalfFloat?.(false);
+                const previousTextureParameters = currentTexture.getTextureParameters?.();
+                let shouldReset = true;
+                if (previousTextureParameters?.dataType === dataType) {
+                    if (previousTextureParameters?.width === dims[0] &&
+                        previousTextureParameters?.height === dims[1] &&
+                        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: numComps,
+                        dataType,
+                    });
+                    currentTexture.create3DFromRaw({
+                        width: dims[0],
+                        height: dims[1],
+                        depth: dims[2],
+                        numComps,
+                        dataType,
+                        data: null,
+                    });
+                    currentTexture.update3DFromRaw();
+                }
+                else {
+                    currentTexture.deactivate?.();
+                    currentTexture.update3DFromRaw();
+                }
+                if (hasUpdatedExtents) {
+                    actorProperty.setUpdatedExtents([]);
+                }
+                return;
+            }
+            const scalars = imageData.getPointData().getScalars();
+            if (!scalars) {
+                vtkErrorMacro('No scalars available for non-streaming reslice mapper');
+                return;
+            }
+            const tex = model._openGLRenderWindow.getGraphicsResourceForObject(scalars);
+            const scalarsHash = getImageDataHash(imageData, scalars);
+            const reBuildTex = !tex?.oglObject?.getHandle() || tex?.hash !== scalarsHash;
+            if (reBuildTex && !hasUpdatedExtents) {
+                const newScalarTexture = vtkOpenGLTexture.newInstance();
+                newScalarTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
+                const dims = imageData.getDimensions();
+                newScalarTexture.setOglNorm16Ext(model.context.getExtension('EXT_texture_norm16'));
+                newScalarTexture.resetFormatAndType();
+                newScalarTexture.create3DFilterableFromDataArray({
+                    width: dims[0],
+                    height: dims[1],
+                    depth: dims[2],
+                    dataArray: scalars,
+                });
+                model._openGLRenderWindow.setGraphicsResourceForObject(scalars, newScalarTexture, scalarsHash);
+                model.scalarTextures[component] = newScalarTexture;
+            }
+            else {
+                model.scalarTextures[component] = tex.oglObject;
+            }
+            if (hasUpdatedExtents) {
+                actorProperty.setUpdatedExtents([]);
+                const dims = imageData.getDimensions();
+                model.scalarTextures[component].create3DFilterableFromDataArray({
+                    width: dims[0],
+                    height: dims[1],
+                    depth: dims[2],
+                    dataArray: scalars,
+                    updatedExtents,
+                });
+            }
+            replaceGraphicsResource(model._openGLRenderWindow, model._scalarTexturesCore[component], scalars);
+            model._scalarTexturesCore[component] = scalars;
+        });
+        const firstValidInput = model.currentValidInputs[0];
+        const firstActorProperty = actorProperties[firstValidInput.inputIndex];
+        const iComps = firstActorProperty.getIndependentComponents();
+        const numIComps = iComps ? model.numberOfComponents : 1;
+        const textureHeight = iComps ? 2 * numIComps : 1;
+        const colorTransferFunctions = [];
+        for (let component = 0; component < numIComps; ++component) {
+            colorTransferFunctions.push(firstActorProperty.getRGBTransferFunction(component));
+        }
+        const colorFuncHash = getTransferFunctionsHash(colorTransferFunctions, iComps, numIComps);
+        const firstColorTransferFunc = firstActorProperty.getRGBTransferFunction();
+        const cTex = model._openGLRenderWindow.getGraphicsResourceForObject(firstColorTransferFunc);
+        const reBuildC = !cTex?.oglObject?.getHandle() || cTex?.hash !== colorFuncHash;
+        if (reBuildC) {
+            let cWidth = model.renderable.getColorTextureWidth();
+            if (cWidth <= 0) {
+                cWidth = model.context.getParameter(model.context.MAX_TEXTURE_SIZE);
+            }
+            const cSize = cWidth * textureHeight * 3;
+            const cTable = new Uint8ClampedArray(cSize);
+            const newColorTexture = vtkOpenGLTexture.newInstance();
+            newColorTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
+            if (firstColorTransferFunc) {
+                const tmpTable = new Float32Array(cWidth * 3);
+                for (let c = 0; c < numIComps; c++) {
+                    const cfun = firstActorProperty.getRGBTransferFunction(c);
+                    const cRange = cfun.getRange();
+                    cfun.getTable(cRange[0], cRange[1], cWidth, tmpTable, 1);
+                    if (iComps) {
+                        for (let i = 0; i < cWidth * 3; i++) {
+                            cTable[c * cWidth * 6 + i] = 255.0 * tmpTable[i];
+                            cTable[c * cWidth * 6 + i + cWidth * 3] = 255.0 * tmpTable[i];
+                        }
+                    }
+                    else {
+                        for (let i = 0; i < cWidth * 3; i++) {
+                            cTable[c * cWidth * 3 + i] = 255.0 * tmpTable[i];
+                        }
+                    }
+                }
+                newColorTexture.resetFormatAndType();
+                newColorTexture.create2DFromRaw({
+                    width: cWidth,
+                    height: textureHeight,
+                    numComps: 3,
+                    dataType: VtkDataTypes.UNSIGNED_CHAR,
+                    data: cTable,
+                });
+            }
+            else {
+                for (let column = 0; column < cWidth * 3; ++column) {
+                    const opacity = (255.0 * column) / ((cWidth - 1) * 3);
+                    for (let row = 0; row < textureHeight; ++row) {
+                        cTable[row * cWidth * 3 + column + 0] = opacity;
+                        cTable[row * cWidth * 3 + column + 1] = opacity;
+                        cTable[row * cWidth * 3 + column + 2] = opacity;
+                    }
+                }
+                newColorTexture.resetFormatAndType();
+                newColorTexture.create2DFromRaw({
+                    width: cWidth,
+                    height: 1,
+                    numComps: 3,
+                    dataType: VtkDataTypes.UNSIGNED_CHAR,
+                    data: cTable,
+                });
+            }
+            if (firstColorTransferFunc) {
+                model._openGLRenderWindow.setGraphicsResourceForObject(firstColorTransferFunc, newColorTexture, colorFuncHash);
+            }
+            model.colorTexture = newColorTexture;
+        }
+        else {
+            model.colorTexture = cTex.oglObject;
+        }
+        replaceGraphicsResource(model._openGLRenderWindow, model._colorTextureCore, firstColorTransferFunc);
+        model._colorTextureCore = firstColorTransferFunc;
+        const opacityFunctions = [];
+        for (let component = 0; component < numIComps; ++component) {
+            opacityFunctions.push(firstActorProperty.getPiecewiseFunction(component));
+        }
+        const opacityFuncHash = getTransferFunctionsHash(opacityFunctions, iComps, numIComps);
+        const firstPwFunc = firstActorProperty.getPiecewiseFunction();
+        const pwfTex = model._openGLRenderWindow.getGraphicsResourceForObject(firstPwFunc);
+        const reBuildPwf = !pwfTex?.oglObject?.getHandle() || pwfTex?.hash !== opacityFuncHash;
+        if (reBuildPwf) {
+            let pwfWidth = model.renderable.getOpacityTextureWidth();
+            if (pwfWidth <= 0) {
+                pwfWidth = model.context.getParameter(model.context.MAX_TEXTURE_SIZE);
+            }
+            const pwfSize = pwfWidth * textureHeight;
+            const pwfTable = new Uint8ClampedArray(pwfSize);
+            const newOpacityTexture = vtkOpenGLTexture.newInstance();
+            newOpacityTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
+            if (firstPwFunc) {
+                const pwfFloatTable = new Float32Array(pwfSize);
+                const tmpTable = new Float32Array(pwfWidth);
+                for (let c = 0; c < numIComps; ++c) {
+                    const pwfun = firstActorProperty.getPiecewiseFunction(c);
+                    if (pwfun === null) {
+                        pwfFloatTable.fill(1.0);
+                    }
+                    else {
+                        const pwfRange = pwfun.getRange();
+                        pwfun.getTable(pwfRange[0], pwfRange[1], pwfWidth, tmpTable, 1);
+                        if (iComps) {
+                            for (let i = 0; i < pwfWidth; i++) {
+                                pwfFloatTable[c * pwfWidth * 2 + i] = tmpTable[i];
+                                pwfFloatTable[c * pwfWidth * 2 + i + pwfWidth] = tmpTable[i];
+                            }
+                        }
+                        else {
+                            for (let i = 0; i < pwfWidth; i++) {
+                                pwfFloatTable[i] = tmpTable[i];
+                            }
+                        }
+                    }
+                }
+                newOpacityTexture.resetFormatAndType();
+                newOpacityTexture.create2DFromRaw({
+                    width: pwfWidth,
+                    height: textureHeight,
+                    numComps: 1,
+                    dataType: VtkDataTypes.FLOAT,
+                    data: pwfFloatTable,
+                });
+            }
+            else {
+                pwfTable.fill(255.0);
+                newOpacityTexture.resetFormatAndType();
+                newOpacityTexture.create2DFromRaw({
+                    width: pwfWidth,
+                    height: textureHeight,
+                    numComps: 1,
+                    dataType: VtkDataTypes.UNSIGNED_CHAR,
+                    data: pwfTable,
+                });
+            }
+            if (firstPwFunc) {
+                model._openGLRenderWindow.setGraphicsResourceForObject(firstPwFunc, newOpacityTexture, opacityFuncHash);
+            }
+            model.pwfTexture = newOpacityTexture;
+        }
+        else {
+            model.pwfTexture = pwfTex.oglObject;
+        }
+        replaceGraphicsResource(model._openGLRenderWindow, model._pwfTextureCore, firstPwFunc);
+        model._pwfTextureCore = firstPwFunc;
+        if (model.labelOutlineProperties.length > 0) {
+            publicAPI.updateLabelOutlineThicknessTexture(model.labelOutlineProperties);
+            publicAPI.updateLabelOutlineOpacityTexture(model.labelOutlineProperties);
+        }
+        const vboString = `${model.resliceGeom.getMTime()}A${model.renderable.getSlabThickness()}`;
+        if (!model.tris.getCABO().getElementCount() ||
+            model.VBOBuildString !== vboString) {
+            const points = vtkDataArray.newInstance({
+                numberOfComponents: 3,
+                values: model.resliceGeom.getPoints().getData(),
+            });
+            points.setName('points');
+            const cells = vtkDataArray.newInstance({
+                numberOfComponents: 1,
+                values: model.resliceGeom.getPolys().getData(),
+            });
+            const options = {
+                points,
+                cellOffset: 0,
+            };
+            if (model.renderable.getSlabThickness() > 0.0) {
+                const normals = model.resliceGeom.getPointData().getNormals();
+                if (!normals) {
+                    vtkErrorMacro('Slab mode requested without normals');
+                }
+                else {
+                    options.normals = normals;
+                }
+            }
+            model.tris
+                .getCABO()
+                .createVBO(cells, 'polys', Representation.SURFACE, options);
+        }
+        model.VBOBuildString = vboString;
+        model.VBOBuildTime.modified();
+    };
+}
+const DEFAULT_VALUES = {};
+export function extend(publicAPI, model, initialValues = {}) {
+    Object.assign(model, DEFAULT_VALUES, initialValues);
+    vtkOpenGLImageResliceMapper.extend(publicAPI, model, initialValues);
+    if (initialValues.scalarTexture) {
+        model.scalarTextures = [initialValues.scalarTexture];
+    }
+    else {
+        model.scalarTextures = [];
+    }
+    model.scalarTextureStrings = [];
+    model._scalarTexturesCore = [];
+    vtkStreamingOpenGLImageResliceMapper(publicAPI, model);
+}
+export const newInstance = macro.newInstance(extend, 'vtkStreamingOpenGLImageResliceMapper');
+export default { newInstance, extend };

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

@@ -6,6 +6,7 @@ import vtkOpenGLGlyph3DMapper from '@kitware/vtk.js/Rendering/OpenGL/Glyph3DMapp
 import vtkOpenGLImageMapper from '@kitware/vtk.js/Rendering/OpenGL/ImageMapper';
 import vtkOpenGLImageCPRMapper from '@kitware/vtk.js/Rendering/OpenGL/ImageCPRMapper';
 import vtkOpenGLImageSlice from '@kitware/vtk.js/Rendering/OpenGL/ImageSlice';
+import vtkOpenGLImageResliceMapper from '@kitware/vtk.js/Rendering/OpenGL/ImageResliceMapper';
 import vtkOpenGLPixelSpaceCallbackMapper from '@kitware/vtk.js/Rendering/OpenGL/PixelSpaceCallbackMapper';
 import vtkOpenGLPolyDataMapper from '@kitware/vtk.js/Rendering/OpenGL/PolyDataMapper';
 import vtkOpenGLRenderer from '@kitware/vtk.js/Rendering/OpenGL/Renderer';
@@ -16,6 +17,7 @@ import vtkOpenGLTexture from '@kitware/vtk.js/Rendering/OpenGL/Texture';
 import vtkOpenGLVolume from '@kitware/vtk.js/Rendering/OpenGL/Volume';
 import vtkOpenGLVolumeMapper from '@kitware/vtk.js/Rendering/OpenGL/VolumeMapper';
 import vtkViewNodeFactory from '@kitware/vtk.js/Rendering/SceneGraph/ViewNodeFactory';
+import vtkStreamingOpenGLImageResliceMapper from './vtkStreamingOpenGLImageResliceMapper';
 import vtkStreamingOpenGLVolumeMapper from './vtkStreamingOpenGLVolumeMapper';
 const CLASS_MAPPING = Object.create(null);
 export function registerOverride(className, fn) {
@@ -54,6 +56,9 @@ function vtkStreamingOpenGLViewNodeFactory(publicAPI, model) {
         if (className === 'vtkSharedVolumeMapper') {
             initialValues.scalarTexture = dataObject.getScalarTexture();
         }
+        if (className === 'vtkSharedImageResliceMapper') {
+            initialValues.scalarTexture = dataObject.getScalarTexture();
+        }
         return initialValues;
     };
 }
@@ -68,6 +73,7 @@ export function extend(publicAPI, model, initialValues = {}) {
     registerOverride('vtkGlyph3DMapper', vtkOpenGLGlyph3DMapper.newInstance);
     registerOverride('vtkImageMapper', vtkOpenGLImageMapper.newInstance);
     registerOverride('vtkImageCPRMapper', vtkOpenGLImageCPRMapper.newInstance);
+    registerOverride('vtkImageResliceMapper', vtkOpenGLImageResliceMapper.newInstance);
     registerOverride('vtkImageSlice', vtkOpenGLImageSlice.newInstance);
     registerOverride('vtkMapper', vtkOpenGLPolyDataMapper.newInstance);
     registerOverride('vtkPixelSpaceCallbackMapper', vtkOpenGLPixelSpaceCallbackMapper.newInstance);
@@ -79,6 +85,7 @@ export function extend(publicAPI, model, initialValues = {}) {
     registerOverride('vtkVolume', vtkOpenGLVolume.newInstance);
     registerOverride('vtkVolumeMapper', vtkOpenGLVolumeMapper.newInstance);
     registerOverride('vtkSharedVolumeMapper', vtkStreamingOpenGLVolumeMapper.newInstance);
+    registerOverride('vtkSharedImageResliceMapper', vtkStreamingOpenGLImageResliceMapper.newInstance);
 }
 export const newInstance = macro.newInstance(extend, 'vtkStreamingOpenGLViewNodeFactory');
 export default { newInstance, extend };

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

@@ -247,12 +247,18 @@ function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
                 currentTexture.enableUseHalfFloat(false);
                 const previousTextureParameters = currentTexture.getTextureParameters();
                 const dataType = imageData.get('dataType').dataType;
+                const textureNumberOfComponents = imageData.getPointData()?.getScalars()?.getNumberOfComponents?.() ??
+                    imageData.get('numberOfComponents').numberOfComponents ??
+                    1;
                 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 (previousTextureParameters?.numberOfComponents ===
+                                    textureNumberOfComponents) {
+                                    shouldReset = false;
+                                }
                             }
                         }
                     }
@@ -265,14 +271,14 @@ function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
                         width: dims[0],
                         height: dims[1],
                         depth: dims[2],
-                        numberOfComponents: numIComps,
+                        numberOfComponents: textureNumberOfComponents,
                         dataType,
                     });
                     currentTexture.create3DFromRaw({
                         width: dims[0],
                         height: dims[1],
                         depth: dims[2],
-                        numComps: numIComps,
+                        numComps: textureNumberOfComponents,
                         dataType,
                         data: null,
                     });

package/dist/esm/cache/cache.d.ts

@@ -45,7 +45,7 @@ declare class Cache {
     decrementGeometryCacheSize: (decrement: number) => void;
     getImageByReferencedImageId: (referencedImageId: string) => IImage | undefined;
     getImage: (imageId: string, minQuality?: ImageQualityStatus) => IImage | undefined;
-    setPartialImage(imageId: string, partialImage?: IImage): void;
+    setPartialImage(imageId: string, partialImage?: IImage, removeImageLoadObject?: boolean): void;
     getImageQuality(imageId: string): ImageQualityStatus;
     getVolume: (volumeId: string, allowPartialMatch?: boolean) => IImageVolume | IBaseStreamingImageVolume | undefined;
     getVolumes: () => IImageVolume[];

package/dist/esm/cache/cache.js

@@ -645,7 +645,7 @@ class Cache {
             throw error;
         }
     }
-    setPartialImage(imageId, partialImage) {
+    setPartialImage(imageId, partialImage, removeImageLoadObject = false) {
         const cachedImage = this._imageCache.get(imageId);
         if (!cachedImage) {
             if (partialImage) {
@@ -667,6 +667,9 @@ class Cache {
             cachedImage.image = partialImage || cachedImage.image;
         }
         else {
+            if (removeImageLoadObject) {
+                cachedImage.imageLoadObject = null;
+            }
             cachedImage.image = partialImage || cachedImage.image;
         }
     }

package/dist/esm/cache/classes/BaseStreamingImageVolume.js

@@ -1,5 +1,5 @@
 import * as metaData from '../../metaData';
-import { Events, ImageQualityStatus, RequestType } from '../../enums';
+import { Events, ImageQualityStatus, MetadataModules, RequestType, } from '../../enums';
 import eventTarget from '../../eventTarget';
 import imageLoadPoolManager from '../../requestPool/imageLoadPoolManager';
 import ProgressiveIterator from '../../utilities/ProgressiveIterator';
@@ -164,7 +164,7 @@ export class BaseStreamingImageVolume extends ImageVolume {
     }
     load(callback) {
         const { imageIds, loadStatus, numFrames } = this;
-        const { transferSyntaxUID } = metaData.get('transferSyntax', imageIds[0]) || {};
+        const { transferSyntaxUID } = metaData.get(MetadataModules.TRANSFER_SYNTAX, imageIds[0]) || {};
         const imageRetrieveConfiguration = metaData.get(imageRetrieveMetadataProvider.IMAGE_RETRIEVE_CONFIGURATION, this.volumeId, transferSyntaxUID, 'volume');
         this.imagesLoader = this.isDynamicVolume()
             ? this
@@ -195,12 +195,12 @@ export class BaseStreamingImageVolume extends ImageVolume {
         this._prefetchImageIds();
     }
     getLoaderImageOptions(imageId) {
-        const { transferSyntaxUID: transferSyntaxUID } = metaData.get('transferSyntax', imageId) || {};
+        const { transferSyntaxUID: transferSyntaxUID } = metaData.get(MetadataModules.TRANSFER_SYNTAX, imageId) || {};
         const targetRows = this.dimensions[1];
         const targetCols = this.dimensions[0];
         const imageIdIndex = this.getImageIdIndex(imageId);
-        const modalityLutModule = metaData.get('modalityLutModule', imageId) || {};
-        const generalSeriesModule = metaData.get('generalSeriesModule', imageId) || {};
+        const modalityLutModule = metaData.get(MetadataModules.MODALITY_LUT, imageId) || {};
+        const generalSeriesModule = metaData.get(MetadataModules.GENERAL_SERIES, imageId) || {};
         const scalingParameters = {
             rescaleSlope: modalityLutModule.rescaleSlope,
             rescaleIntercept: modalityLutModule.rescaleIntercept,
@@ -208,7 +208,7 @@ export class BaseStreamingImageVolume extends ImageVolume {
         };
         const modality = scalingParameters.modality;
         if (modality === 'PT' || modality === 'RTDOSE') {
-            const scalingFactor = metaData.get('scalingModule', imageId);
+            const scalingFactor = metaData.get(MetadataModules.SCALING, imageId);
             if (scalingFactor) {
                 this._addScalingToVolume(scalingFactor);
                 Object.assign(scalingParameters, scalingFactor);

package/dist/esm/cache/classes/ImageVolume.js

@@ -29,6 +29,11 @@ export class ImageVolume {
         this.origin = origin;
         this.direction = direction;
         this.dataType = dataType;
+        this.hasPixelSpacing =
+            Number.isFinite(spacing[0]) &&
+                spacing[0] > 0 &&
+                Number.isFinite(spacing[1]) &&
+                spacing[1] > 0;
         this.vtkOpenGLTexture = vtkStreamingOpenGLTexture.newInstance();
         this.vtkOpenGLTexture.setVolumeId(volumeId);
         this.voxelManager =

package/dist/esm/enums/CalibrationTypes.d.ts

@@ -1,12 +1,4 @@
-export declare enum CalibrationTypes {
-    NOT_APPLICABLE = "",
-    ERMF = "ERMF",
-    USER = "User",
-    PROJECTION = "Proj",
-    REGION = "Region",
-    ERROR = "Error",
-    UNCALIBRATED = "Uncalibrated",
-    CALIBRATED = "Calibrated",
-    UNKNOWN = "Unknown"
-}
-export default CalibrationTypes;
+import { Enums } from '@cornerstonejs/metadata';
+export declare const CalibrationTypes: typeof Enums.CalibrationTypes;
+declare const _default: typeof Enums.CalibrationTypes;
+export default _default;

package/dist/esm/enums/CalibrationTypes.js

@@ -1,13 +1,3 @@
-export var CalibrationTypes;
-(function (CalibrationTypes) {
-    CalibrationTypes["NOT_APPLICABLE"] = "";
-    CalibrationTypes["ERMF"] = "ERMF";
-    CalibrationTypes["USER"] = "User";
-    CalibrationTypes["PROJECTION"] = "Proj";
-    CalibrationTypes["REGION"] = "Region";
-    CalibrationTypes["ERROR"] = "Error";
-    CalibrationTypes["UNCALIBRATED"] = "Uncalibrated";
-    CalibrationTypes["CALIBRATED"] = "Calibrated";
-    CalibrationTypes["UNKNOWN"] = "Unknown";
-})(CalibrationTypes || (CalibrationTypes = {}));
-export default CalibrationTypes;
+import { Enums } from '@cornerstonejs/metadata';
+export const CalibrationTypes = Enums.CalibrationTypes;
+export default Enums.CalibrationTypes;

package/dist/esm/enums/MetadataModules.d.ts

@@ -1,38 +1,3 @@
-declare enum MetadataModules {
-    CALIBRATION = "calibrationModule",
-    CINE = "cineModule",
-    GENERAL_IMAGE = "generalImageModule",
-    GENERAL_SERIES = "generalSeriesModule",
-    GENERAL_STUDY = "generalStudyModule",
-    IMAGE_PIXEL = "imagePixelModule",
-    IMAGE_PLANE = "imagePlaneModule",
-    IMAGE_URL = "imageUrlModule",
-    MODALITY_LUT = "modalityLutModule",
-    MULTIFRAME = "multiframeModule",
-    NM_MULTIFRAME_GEOMETRY = "nmMultiframeGeometryModule",
-    OVERLAY_PLANE = "overlayPlaneModule",
-    PATIENT = "patientModule",
-    PATIENT_STUDY = "patientStudyModule",
-    PET_IMAGE = "petImageModule",
-    PET_ISOTOPE = "petIsotopeModule",
-    PET_SERIES = "petSeriesModule",
-    SOP_COMMON = "sopCommonModule",
-    ULTRASOUND_ENHANCED_REGION = "ultrasoundEnhancedRegionModule",
-    ECG = "ecgModule",
-    VOI_LUT = "voiLutModule",
-    FRAME_MODULE = "frameModule",
-    WADO_WEB_CLIENT = "wadoWebClient",
-    INSTANCE = "instance",
-    IMAGE_SOP_INSTANCE_REFERENCE = "ImageSopInstanceReference",
-    REFERENCED_SERIES_REFERENCE = "ReferencedSeriesReference",
-    PREDECESSOR_SEQUENCE = "PredecessorSequence",
-    STUDY_DATA = "StudyData",
-    SERIES_DATA = "SeriesData",
-    IMAGE_DATA = "ImageData",
-    RTSS_INSTANCE_DATA = "RtssInstanceData",
-    NEW_INSTANCE_DATA = "NewInstanceData",
-    RTSS_CONTOUR = "metaRTSSContour",
-    SEG_BIT = "metaSegBitmap",
-    SR_ANNOTATION = "metaSrAnnotation"
-}
-export default MetadataModules;
+import { Enums } from '@cornerstonejs/metadata';
+declare const _default: typeof Enums.MetadataModules;
+export default _default;