@cornerstonejs/core 2.0.0-beta.3 → 2.0.0-beta.30

package/dist/esm/RenderingEngine/StackViewport.js

@@ -1,42 +1,56 @@
 import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
 import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
-import _cloneDeep from 'lodash.clonedeep';
 import vtkCamera from '@kitware/vtk.js/Rendering/Core/Camera';
-import { vec2, vec3, mat4 } from 'gl-matrix';
+import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
+import vtkColorMaps from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps';
 import vtkImageMapper from '@kitware/vtk.js/Rendering/Core/ImageMapper';
 import vtkImageSlice from '@kitware/vtk.js/Rendering/Core/ImageSlice';
-import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
+import { mat4, vec2, vec3 } from 'gl-matrix';
+import eventTarget from '../eventTarget';
 import * as metaData from '../metaData';
+import { actorIsA, isImageActor } from '../utilities/actorCheck';
+import * as colormapUtils from '../utilities/colormap';
+import { getTransferFunctionNodes, setTransferFunctionNodes, } from '../utilities/transferFunctionUtils';
+import * as windowLevelUtil from '../utilities/windowLevel';
+import createLinearRGBTransferFunction from '../utilities/createLinearRGBTransferFunction';
+import createSigmoidRGBTransferFunction from '../utilities/createSigmoidRGBTransferFunction';
+import { updateVTKImageDataWithCornerstoneImage } from '../utilities/updateVTKImageDataWithCornerstoneImage';
+import triggerEvent from '../utilities/triggerEvent';
+import { isEqual } from '../utilities/isEqual';
+import invertRgbTransferFunction from '../utilities/invertRgbTransferFunction';
+import imageRetrieveMetadataProvider from '../utilities/imageRetrieveMetadataProvider';
+import imageIdToURI from '../utilities/imageIdToURI';
 import Viewport from './Viewport';
-import eventTarget from '../eventTarget';
-import { triggerEvent, isEqual, invertRgbTransferFunction, createSigmoidRGBTransferFunction, windowLevel as windowLevelUtil, imageIdToURI, isImageActor, actorIsA, } from '../utilities';
 import drawImageSync from './helpers/cpuFallback/drawImageSync';
-import { getColormap } from './helpers/cpuFallback/colors/index';
+import { Events, InterpolationType, MetadataModules, RequestType, VOILUTFunctionType, ViewportStatus, } from '../enums';
 import { loadAndCacheImage } from '../loaders/imageLoader';
 import imageLoadPoolManager from '../requestPool/imageLoadPoolManager';
-import { InterpolationType, RequestType, Events, VOILUTFunctionType, } from '../enums';
+import calculateTransform from './helpers/cpuFallback/rendering/calculateTransform';
 import canvasToPixel from './helpers/cpuFallback/rendering/canvasToPixel';
-import pixelToCanvas from './helpers/cpuFallback/rendering/pixelToCanvas';
 import getDefaultViewport from './helpers/cpuFallback/rendering/getDefaultViewport';
-import calculateTransform from './helpers/cpuFallback/rendering/calculateTransform';
+import pixelToCanvas from './helpers/cpuFallback/rendering/pixelToCanvas';
 import resize from './helpers/cpuFallback/rendering/resize';
-import resetCamera from './helpers/cpuFallback/rendering/resetCamera';
-import { Transform } from './helpers/cpuFallback/rendering/transform';
+import cache from '../cache/cache';
 import { getConfiguration, getShouldUseCPURendering } from '../init';
-import cache from '../cache';
+import { createProgressive } from '../loaders/ProgressiveRetrieveImages';
 import correctShift from './helpers/cpuFallback/rendering/correctShift';
-import createLinearRGBTransferFunction from '../utilities/createLinearRGBTransferFunction';
-import ViewportStatus from '../enums/ViewportStatus';
+import resetCamera from './helpers/cpuFallback/rendering/resetCamera';
+import { Transform } from './helpers/cpuFallback/rendering/transform';
+import uuidv4 from '../utilities/uuidv4';
+import getSpacingInNormalDirection from '../utilities/getSpacingInNormalDirection';
 const EPSILON = 1;
 class StackViewport extends Viewport {
     constructor(props) {
         super(props);
+        this.imagesLoader = this;
+        this.globalDefaultProperties = {};
+        this.perImageIdDefaultProperties = new Map();
         this.voiUpdatedWithSetProperties = false;
         this.invert = false;
         this.initialInvert = false;
+        this.initialTransferFunctionNodes = null;
         this.stackInvalidated = false;
         this._publishCalibratedEvent = false;
-        this.useNativeDataType = false;
         this.updateRenderingPipeline = () => {
             this._configureRenderingPipeline();
         };
@@ -50,20 +64,8 @@ class StackViewport extends Viewport {
                 resize(this._cpuFallbackEnabledElement);
             }
         };
-        this.getFrameOfReferenceUID = () => {
-            const imageId = this.getCurrentImageId();
-            if (!imageId) {
-                return;
-            }
-            const imagePlaneModule = metaData.get('imagePlaneModule', imageId);
-            if (!imagePlaneModule) {
-                return;
-            }
-            return imagePlaneModule.frameOfReferenceUID;
-        };
-        this.getCornerstoneImage = () => {
-            return this.csImage;
-        };
+        this.getFrameOfReferenceUID = (sliceIndex) => this.getImagePlaneReferenceData(sliceIndex)?.FrameOfReferenceUID;
+        this.getCornerstoneImage = () => this.csImage;
         this.createActorMapper = (imageData) => {
             const mapper = vtkImageMapper.newInstance();
             mapper.setInputData(imageData);
@@ -73,29 +75,51 @@ class StackViewport extends Viewport {
             if (preferSizeOverAccuracy) {
                 mapper.setPreferSizeOverAccuracy(true);
             }
-            if (imageData.getPointData().getNumberOfComponents() > 1) {
+            if (imageData.getPointData().getScalars().getNumberOfComponents() > 1) {
                 actor.getProperty().setIndependentComponents(false);
             }
             return actor;
         };
+        this.getNumberOfSlices = () => {
+            return this.imageIds.length;
+        };
+        this.getDefaultProperties = (imageId) => {
+            let imageProperties;
+            if (imageId !== undefined) {
+                imageProperties = this.perImageIdDefaultProperties.get(imageId);
+            }
+            if (imageProperties !== undefined) {
+                return imageProperties;
+            }
+            return {
+                ...this.globalDefaultProperties,
+            };
+        };
         this.getProperties = () => {
-            const { voiRange, VOILUTFunction, interpolationType, invert, voiUpdatedWithSetProperties, } = this;
-            const rotation = this.getRotation();
+            const { colormap, voiRange, VOILUTFunction, interpolationType, invert, voiUpdatedWithSetProperties, } = this;
             return {
+                colormap,
                 voiRange,
                 VOILUTFunction,
                 interpolationType,
                 invert,
-                rotation,
                 isComputedVOI: !voiUpdatedWithSetProperties,
             };
         };
+        this.resetCameraForResize = () => {
+            return this.resetCamera({
+                resetPan: true,
+                resetZoom: true,
+                resetToCenter: true,
+                suppressEvents: true,
+            });
+        };
         this.getRotationCPU = () => {
             const { viewport } = this._cpuFallbackEnabledElement;
             return viewport.rotation;
         };
         this.getRotationGPU = () => {
-            const { viewUp: currentViewUp, viewPlaneNormal, flipVertical, } = this.getCamera();
+            const { viewUp: currentViewUp, viewPlaneNormal, flipVertical, } = this.getCameraNoRotation();
             const initialViewUp = flipVertical
                 ? vec3.negate(vec3.create(), this.initialViewUp)
                 : this.initialViewUp;
@@ -106,6 +130,27 @@ class StackViewport extends Viewport {
                 ? initialToCurrentViewUpAngle
                 : (360 - initialToCurrentViewUpAngle) % 360;
         };
+        this.setRotation = (rotation) => {
+            const previousCamera = this.getCamera();
+            if (this.useCPURendering) {
+                this.setRotationCPU(rotation);
+            }
+            else {
+                this.setRotationGPU(rotation);
+            }
+            if (this._suppressCameraModifiedEvents) {
+                return;
+            }
+            const camera = this.getCamera();
+            const eventDetail = {
+                previousCamera,
+                camera,
+                element: this.element,
+                viewportId: this.id,
+                renderingEngineId: this.renderingEngineId,
+            };
+            triggerEvent(this.element, Events.CAMERA_MODIFIED, eventDetail);
+        };
         this.renderImageObject = (image) => {
             this._setCSImage(image);
             const renderFn = this.useCPURendering
@@ -117,29 +162,28 @@ class StackViewport extends Viewport {
             image.isPreScaled = image.preScale?.scaled;
             this.csImage = image;
         };
-        this.canvasToWorldCPU = (canvasPos) => {
+        this.canvasToWorldCPU = (canvasPos, worldPos = [0, 0, 0]) => {
             if (!this._cpuFallbackEnabledElement.image) {
                 return;
             }
             const [px, py] = canvasToPixel(this._cpuFallbackEnabledElement, canvasPos);
             const { origin, spacing, direction } = this.getImageData();
-            const worldPos = vec3.fromValues(0, 0, 0);
             const iVector = direction.slice(0, 3);
             const jVector = direction.slice(3, 6);
             vec3.scaleAndAdd(worldPos, origin, iVector, px * spacing[0]);
             vec3.scaleAndAdd(worldPos, worldPos, jVector, py * spacing[1]);
-            return [worldPos[0], worldPos[1], worldPos[2]];
+            return worldPos;
         };
         this.worldToCanvasCPU = (worldPos) => {
             const { spacing, direction, origin } = this.getImageData();
             const iVector = direction.slice(0, 3);
             const jVector = direction.slice(3, 6);
             const diff = vec3.subtract(vec3.create(), worldPos, origin);
-            const worldPoint = [
+            const indexPoint = [
                 vec3.dot(diff, iVector) / spacing[0],
                 vec3.dot(diff, jVector) / spacing[1],
             ];
-            const canvasPoint = pixelToCanvas(this._cpuFallbackEnabledElement, worldPoint);
+            const canvasPoint = pixelToCanvas(this._cpuFallbackEnabledElement, indexPoint);
             return canvasPoint;
         };
         this.canvasToWorldGPU = (canvasPos) => {
@@ -191,6 +235,9 @@ class StackViewport extends Viewport {
         this.getCurrentImageIdIndex = () => {
             return this.currentImageIdIndex;
         };
+        this.getSliceIndex = () => {
+            return this.currentImageIdIndex;
+        };
         this.getTargetImageIdIndex = () => {
             return this.targetImageIdIndex;
         };
@@ -248,6 +295,22 @@ class StackViewport extends Viewport {
                 cpu: this.setCameraCPU,
                 gpu: super.setCamera,
             },
+            getPan: {
+                cpu: this.getPanCPU,
+                gpu: super.getPan,
+            },
+            setPan: {
+                cpu: this.setPanCPU,
+                gpu: super.setPan,
+            },
+            getZoom: {
+                cpu: this.getZoomCPU,
+                gpu: super.getZoom,
+            },
+            setZoom: {
+                cpu: this.setZoomCPU,
+                gpu: super.setZoom,
+            },
             setVOI: {
                 cpu: this.setVOICPU,
                 gpu: this.setVOIGPU,
@@ -265,12 +328,14 @@ class StackViewport extends Viewport {
                 gpu: this.setInvertColorGPU,
             },
             resetCamera: {
-                cpu: (resetPan = true, resetZoom = true) => {
-                    this.resetCameraCPU(resetPan, resetZoom);
+                cpu: (options = {}) => {
+                    const { resetPan = true, resetZoom = true } = options;
+                    this.resetCameraCPU({ resetPan, resetZoom });
                     return true;
                 },
-                gpu: (resetPan = true, resetZoom = true) => {
-                    this.resetCameraGPU(resetPan, resetZoom);
+                gpu: (options = {}) => {
+                    const { resetPan = true, resetZoom = true } = options;
+                    this.resetCameraGPU({ resetPan, resetZoom });
                     return true;
                 },
             },
@@ -322,32 +387,32 @@ class StackViewport extends Viewport {
         this.scaling = {};
         this.modality = null;
         this.useCPURendering = getShouldUseCPURendering();
-        this.useNativeDataType = this._shouldUseNativeDataType();
         this._configureRenderingPipeline();
-        this.useCPURendering
+        const result = this.useCPURendering
             ? this._resetCPUFallbackElement()
             : this._resetGPUViewport();
         this.imageIds = [];
         this.currentImageIdIndex = 0;
         this.targetImageIdIndex = 0;
-        this.cameraFocalPointOnRender = [0, 0, 0];
         this.resetCamera();
         this.initializeElementDisabledHandler();
     }
     setUseCPURendering(value) {
         this.useCPURendering = value;
-        this._configureRenderingPipeline();
+        this._configureRenderingPipeline(value);
     }
     static get useCustomRenderingPipeline() {
         return getShouldUseCPURendering();
     }
-    _configureRenderingPipeline() {
-        this.useNativeDataType = this._shouldUseNativeDataType();
-        this.useCPURendering = getShouldUseCPURendering();
-        for (const [funcName, functions] of Object.entries(this.renderingPipelineFunctions)) {
-            this[funcName] = this.useCPURendering ? functions.cpu : functions.gpu;
+    _configureRenderingPipeline(value) {
+        this.useCPURendering = value ?? getShouldUseCPURendering();
+        for (const key in this.renderingPipelineFunctions) {
+            if (Object.prototype.hasOwnProperty.call(this.renderingPipelineFunctions, key)) {
+                const functions = this.renderingPipelineFunctions[key];
+                this[key] = this.useCPURendering ? functions.cpu : functions.gpu;
+            }
         }
-        this.useCPURendering
+        const result = this.useCPURendering
             ? this._resetCPUFallbackElement()
             : this._resetGPUViewport();
     }
@@ -387,31 +452,42 @@ class StackViewport extends Viewport {
         }
         const { actor } = defaultActor;
         const vtkImageData = actor.getMapper().getInputData();
+        const csImage = this.csImage;
         return {
             dimensions: vtkImageData.getDimensions(),
             spacing: vtkImageData.getSpacing(),
             origin: vtkImageData.getOrigin(),
             direction: vtkImageData.getDirection(),
-            scalarData: vtkImageData.getPointData().getScalars().getData(),
+            get scalarData() {
+                return csImage?.voxelManager.getScalarData();
+            },
             imageData: actor.getMapper().getInputData(),
-            metadata: { Modality: this.modality },
+            metadata: {
+                Modality: this.modality,
+                FrameOfReferenceUID: this.getFrameOfReferenceUID(),
+            },
             scaling: this.scaling,
             hasPixelSpacing: this.hasPixelSpacing,
-            calibration: this.calibration,
+            calibration: { ...csImage?.calibration, ...this.calibration },
             preScale: {
-                ...this.csImage.preScale,
+                ...csImage?.preScale,
             },
+            voxelManager: csImage?.voxelManager,
         };
     }
     getImageDataCPU() {
         const { metadata } = this._cpuFallbackEnabledElement;
         const spacing = metadata.spacing;
+        const csImage = this.csImage;
         return {
             dimensions: metadata.dimensions,
             spacing,
             origin: metadata.origin,
             direction: metadata.direction,
-            metadata: { Modality: this.modality },
+            metadata: {
+                Modality: this.modality,
+                FrameOfReferenceUID: this.getFrameOfReferenceUID(),
+            },
             scaling: this.scaling,
             imageData: {
                 getDirection: () => metadata.direction,
@@ -423,20 +499,21 @@ class StackViewport extends Viewport {
                     const pixelCoord = canvasToPixel(this._cpuFallbackEnabledElement, canvasPoint);
                     return [pixelCoord[0], pixelCoord[1], 0];
                 },
-                indexToWorld: (point) => {
+                indexToWorld: (point, destPoint) => {
                     const canvasPoint = pixelToCanvas(this._cpuFallbackEnabledElement, [
                         point[0],
                         point[1],
                     ]);
-                    return this.canvasToWorldCPU(canvasPoint);
+                    return this.canvasToWorldCPU(canvasPoint, destPoint);
                 },
             },
             scalarData: this.cpuImagePixelData,
             hasPixelSpacing: this.hasPixelSpacing,
-            calibration: this.calibration,
+            calibration: { ...csImage?.calibration, ...this.calibration },
             preScale: {
-                ...this.csImage.preScale,
+                ...csImage?.preScale,
             },
+            voxelManager: csImage?.voxelManager,
         };
     }
     buildMetadata(image) {
@@ -445,13 +522,14 @@ class StackViewport extends Viewport {
         const { windowWidth, windowCenter, voiLUTFunction } = image;
         const { modality } = metaData.get('generalSeriesModule', imageId);
         const imageIdScalingFactor = metaData.get('scalingModule', imageId);
+        const calibration = metaData.get(MetadataModules.CALIBRATION, imageId);
         if (modality === 'PT' && imageIdScalingFactor) {
             this._addScalingToViewport(imageIdScalingFactor);
         }
         this.modality = modality;
         const voiLUTFunctionEnum = this._getValidVOILUTFunction(voiLUTFunction);
         this.VOILUTFunction = voiLUTFunctionEnum;
-        this.calibration = null;
+        this.calibration = calibration;
         let imagePlaneModule = this._getImagePlaneModule(imageId);
         if (!this.useCPURendering) {
             imagePlaneModule = this.calibrateIfNecessary(imageId, imagePlaneModule);
@@ -489,10 +567,41 @@ class StackViewport extends Viewport {
         };
         return imagePlaneModule;
     }
-    setProperties({ voiRange, VOILUTFunction, invert, interpolationType, rotation, } = {}, suppressEvents = false) {
+    setDefaultProperties(ViewportProperties, imageId) {
+        if (imageId == null) {
+            this.globalDefaultProperties = ViewportProperties;
+        }
+        else {
+            this.perImageIdDefaultProperties.set(imageId, ViewportProperties);
+            if (this.getCurrentImageId() === imageId) {
+                this.setProperties(ViewportProperties);
+            }
+        }
+    }
+    clearDefaultProperties(imageId) {
+        if (imageId == null) {
+            this.globalDefaultProperties = {};
+            this.resetProperties();
+        }
+        else {
+            this.perImageIdDefaultProperties.delete(imageId);
+            this.resetToDefaultProperties();
+        }
+    }
+    setProperties({ colormap, voiRange, VOILUTFunction, invert, interpolationType, } = {}, suppressEvents = false) {
         this.viewportStatus = this.csImage
             ? ViewportStatus.PRE_RENDER
             : ViewportStatus.LOADING;
+        this.globalDefaultProperties = {
+            colormap: this.globalDefaultProperties.colormap ?? colormap,
+            voiRange: this.globalDefaultProperties.voiRange ?? voiRange,
+            VOILUTFunction: this.globalDefaultProperties.VOILUTFunction ?? VOILUTFunction,
+            invert: this.globalDefaultProperties.invert ?? invert,
+            interpolationType: this.globalDefaultProperties.interpolationType ?? interpolationType,
+        };
+        if (typeof colormap !== 'undefined') {
+            this.setColormap(colormap);
+        }
         if (typeof voiRange !== 'undefined') {
             const voiUpdatedWithSetProperties = true;
             this.setVOI(voiRange, { suppressEvents, voiUpdatedWithSetProperties });
@@ -506,11 +615,6 @@ class StackViewport extends Viewport {
         if (typeof interpolationType !== 'undefined') {
             this.setInterpolationType(interpolationType);
         }
-        if (typeof rotation !== 'undefined') {
-            if (this.getRotation() !== rotation) {
-                this.setRotation(rotation);
-            }
-        }
     }
     resetProperties() {
         this.cpuRenderingInvalidated = true;
@@ -532,14 +636,45 @@ class StackViewport extends Viewport {
             voiRange = this._getVOIRangeForCurrentImage();
         }
         this.setVOI(voiRange);
-        if (this.getRotation() !== 0) {
-            this.setRotation(0);
+        this.setInvertColor(this.initialInvert);
+        this.setInterpolationType(InterpolationType.LINEAR);
+        const transferFunction = this.getTransferFunction();
+        setTransferFunctionNodes(transferFunction, this.initialTransferFunctionNodes);
+        const nodes = getTransferFunctionNodes(transferFunction);
+        const RGBPoints = nodes.reduce((acc, node) => {
+            acc.push(node[0], node[1], node[2], node[3]);
+            return acc;
+        }, []);
+        const defaultActor = this.getDefaultActor();
+        const matchedColormap = colormapUtils.findMatchingColormap(RGBPoints, defaultActor.actor);
+        this.setColormap(matchedColormap);
+    }
+    resetToDefaultProperties() {
+        this.cpuRenderingInvalidated = true;
+        this.viewportStatus = ViewportStatus.PRE_RENDER;
+        this.fillWithBackgroundColor();
+        if (this.useCPURendering) {
+            this._cpuFallbackEnabledElement.renderingTools = {};
+        }
+        const currentImageId = this.getCurrentImageId();
+        const properties = this.perImageIdDefaultProperties.get(currentImageId) ||
+            this.globalDefaultProperties;
+        if (properties.colormap?.name) {
+            this.setColormap(properties.colormap);
+        }
+        let voiRange;
+        if (properties.voiRange == undefined) {
+            voiRange = this._getVOIRangeForCurrentImage();
         }
+        else {
+            voiRange = properties.voiRange;
+        }
+        this.setVOI(voiRange);
         this.setInterpolationType(InterpolationType.LINEAR);
-        this.setInvertColor(this.initialInvert);
+        this.setInvertColor(false);
+        this.render();
     }
-    _setPropertiesFromCache() {
-        const { interpolationType, invert } = this;
+    _getVOIFromCache() {
         let voiRange;
         if (this.voiUpdatedWithSetProperties) {
             voiRange = this.voiRange;
@@ -550,6 +685,11 @@ class StackViewport extends Viewport {
         else {
             voiRange = this._getVOIRangeForCurrentImage() ?? this.voiRange;
         }
+        return voiRange;
+    }
+    _setPropertiesFromCache() {
+        const voiRange = this._getVOIFromCache();
+        const { interpolationType, invert } = this;
         this.setVOI(voiRange);
         this.setInterpolationType(interpolationType);
         this.setInvertColor(invert);
@@ -624,10 +764,28 @@ class StackViewport extends Viewport {
             element: this.element,
             viewportId: this.id,
             renderingEngineId: this.renderingEngineId,
-            rotation: this.getRotation(),
         };
         triggerEvent(this.element, Events.CAMERA_MODIFIED, eventDetail);
     }
+    getPanCPU() {
+        const { viewport } = this._cpuFallbackEnabledElement;
+        return [viewport.translation.x, viewport.translation.y];
+    }
+    setPanCPU(pan) {
+        const camera = this.getCameraCPU();
+        this.setCameraCPU({
+            ...camera,
+            focalPoint: [...pan.map((p) => -p), 0],
+        });
+    }
+    getZoomCPU() {
+        const { viewport } = this._cpuFallbackEnabledElement;
+        return viewport.scale;
+    }
+    setZoomCPU(zoom) {
+        const camera = this.getCameraCPU();
+        this.setCameraCPU({ ...camera, scale: zoom });
+    }
     setFlipCPU({ flipHorizontal, flipVertical }) {
         const { viewport } = this._cpuFallbackEnabledElement;
         if (flipHorizontal !== undefined) {
@@ -639,30 +797,13 @@ class StackViewport extends Viewport {
             this.flipVertical = viewport.vflip;
         }
     }
-    setRotation(rotation) {
-        const previousCamera = this.getCamera();
-        this.useCPURendering
-            ? this.setRotationCPU(rotation)
-            : this.setRotationGPU(rotation);
-        const camera = this.getCamera();
-        const eventDetail = {
-            previousCamera,
-            camera,
-            element: this.element,
-            viewportId: this.id,
-            renderingEngineId: this.renderingEngineId,
-            rotation,
-        };
-        triggerEvent(this.element, Events.CAMERA_MODIFIED, eventDetail);
-    }
     setVOILUTFunction(voiLUTFunction, suppressEvents) {
         if (this.useCPURendering) {
             throw new Error('VOI LUT function is not supported in CPU rendering');
         }
         const newVOILUTFunction = this._getValidVOILUTFunction(voiLUTFunction);
         let forceRecreateLUTFunction = false;
-        if (this.VOILUTFunction !== VOILUTFunctionType.LINEAR &&
-            newVOILUTFunction === VOILUTFunctionType.LINEAR) {
+        if (this.VOILUTFunction !== newVOILUTFunction) {
             forceRecreateLUTFunction = true;
         }
         this.VOILUTFunction = newVOILUTFunction;
@@ -674,6 +815,10 @@ class StackViewport extends Viewport {
         viewport.rotation = rotation;
     }
     setRotationGPU(rotation) {
+        const panFit = this.getPan(this.fitToCanvasCamera);
+        const pan = this.getPan();
+        const panSub = vec2.sub([0, 0], panFit, pan);
+        this.setPan(panSub, false);
         const { flipVertical } = this.getCamera();
         const initialViewUp = flipVertical
             ? vec3.negate(vec3.create(), this.initialViewUp)
@@ -682,6 +827,11 @@ class StackViewport extends Viewport {
             viewUp: initialViewUp,
         });
         this.getVtkActiveCamera().roll(-rotation);
+        const afterPan = this.getPan();
+        const afterPanFit = this.getPan(this.fitToCanvasCamera);
+        const newCenter = vec2.sub([0, 0], afterPan, afterPanFit);
+        const newOffset = vec2.add([0, 0], panFit, newCenter);
+        this.setPan(newOffset, false);
     }
     setInterpolationTypeGPU(interpolationType) {
         const defaultActor = this.getDefaultActor();
@@ -773,6 +923,17 @@ class StackViewport extends Viewport {
             triggerEvent(this.element, Events.VOI_MODIFIED, eventDetail);
         }
     }
+    getTransferFunction() {
+        const defaultActor = this.getDefaultActor();
+        if (!defaultActor) {
+            return;
+        }
+        if (!isImageActor(defaultActor)) {
+            return;
+        }
+        const imageActor = defaultActor.actor;
+        return imageActor.getProperty().getRGBTransferFunction(0);
+    }
     setVOIGPU(voiRange, options = {}) {
         const { suppressEvents = false, forceRecreateLUTFunction = false, voiUpdatedWithSetProperties = false, } = options;
         if (voiRange &&
@@ -810,6 +971,8 @@ class StackViewport extends Viewport {
                 invertRgbTransferFunction(transferFunction);
             }
             imageActor.getProperty().setRGBTransferFunction(0, transferFunction);
+            this.initialTransferFunctionNodes =
+                getTransferFunctionNodes(transferFunction);
         }
         if (!isSigmoidTFun) {
             transferFunction.setRange(voiRangeToUse.lower, voiRangeToUse.upper);
@@ -845,13 +1008,13 @@ class StackViewport extends Viewport {
     _getNumCompsFromPhotometricInterpretation(photometricInterpretation) {
         let numberOfComponents = 1;
         if (photometricInterpretation === 'RGB' ||
-            photometricInterpretation.indexOf('YBR') !== -1 ||
+            photometricInterpretation.includes('YBR') ||
             photometricInterpretation === 'PALETTE COLOR') {
             numberOfComponents = 3;
         }
         return numberOfComponents;
     }
-    _getImageDataMetadata(image) {
+    getImageDataMetadata(image) {
         const { imagePlaneModule, imagePixelModule } = this.buildMetadata(image);
         let rowCosines, columnCosines;
         rowCosines = imagePlaneModule.rowCosines;
@@ -874,11 +1037,11 @@ class StackViewport extends Viewport {
         const yVoxels = image.rows;
         const zSpacing = EPSILON;
         const zVoxels = 1;
-        const numComps = image.numComps ||
+        const numberOfComponents = image.numberOfComponents ||
             this._getNumCompsFromPhotometricInterpretation(imagePixelModule.photometricInterpretation);
         return {
             bitsAllocated: imagePixelModule.bitsAllocated,
-            numComps,
+            numberOfComponents,
             origin,
             direction: [...rowCosineVec, ...colCosineVec, ...scanAxisNormal],
             dimensions: [xVoxels, yVoxels, zVoxels],
@@ -888,6 +1051,67 @@ class StackViewport extends Viewport {
             imagePixelModule,
         };
     }
+    matchImagesForOverlay(currentImageId, targetOverlayImageId) {
+        const matchImagesForOverlay = (targetImageId) => {
+            const overlayImagePlaneModule = metaData.get(MetadataModules.IMAGE_PLANE, targetOverlayImageId);
+            const currentImagePlaneModule = metaData.get(MetadataModules.IMAGE_PLANE, targetImageId);
+            const overlayOrientation = overlayImagePlaneModule.imageOrientationPatient;
+            const currentOrientation = currentImagePlaneModule.imageOrientationPatient;
+            if (overlayOrientation && currentOrientation) {
+                const closeEnough = isEqual(overlayImagePlaneModule.imageOrientationPatient, currentImagePlaneModule.imageOrientationPatient);
+                if (closeEnough) {
+                    const referencePosition = overlayImagePlaneModule.imagePositionPatient;
+                    const currentPosition = currentImagePlaneModule.imagePositionPatient;
+                    if (referencePosition && currentPosition) {
+                        const closeEnough = isEqual(referencePosition, currentPosition);
+                        if (closeEnough) {
+                            const referenceRows = overlayImagePlaneModule.rows;
+                            const referenceColumns = overlayImagePlaneModule.columns;
+                            const currentRows = currentImagePlaneModule.rows;
+                            const currentColumns = currentImagePlaneModule.columns;
+                            if (referenceRows === currentRows &&
+                                referenceColumns === currentColumns) {
+                                return targetImageId;
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                const referenceRows = overlayImagePlaneModule.rows;
+                const referenceColumns = overlayImagePlaneModule.columns;
+                const currentRows = currentImagePlaneModule.rows;
+                const currentColumns = currentImagePlaneModule.columns;
+                if (referenceRows === currentRows &&
+                    referenceColumns === currentColumns) {
+                    return targetImageId;
+                }
+            }
+        };
+        return matchImagesForOverlay(currentImageId);
+    }
+    getImagePlaneReferenceData(sliceIndex = this.getCurrentImageIdIndex()) {
+        const imageId = this.imageIds[sliceIndex];
+        if (!imageId) {
+            return;
+        }
+        const imagePlaneModule = metaData.get(MetadataModules.IMAGE_PLANE, imageId);
+        if (!imagePlaneModule) {
+            return;
+        }
+        const { imagePositionPatient, frameOfReferenceUID: FrameOfReferenceUID } = imagePlaneModule;
+        let { rowCosines, columnCosines } = imagePlaneModule;
+        rowCosines ||= [1, 0, 0];
+        columnCosines ||= [0, 1, 0];
+        const viewPlaneNormal = vec3.cross([0, 0, 0], columnCosines, rowCosines);
+        return {
+            FrameOfReferenceUID,
+            viewPlaneNormal,
+            cameraFocalPoint: imagePositionPatient,
+            referencedImageId: imageId,
+            sliceIndex,
+        };
+    }
     _getCameraOrientation(imageDataDirection) {
         const viewPlaneNormal = imageDataDirection.slice(6, 9).map((x) => -x);
         const viewUp = imageDataDirection.slice(3, 6).map((x) => -x);
@@ -900,25 +1124,45 @@ class StackViewport extends Viewport {
             viewUp: [viewUp[0], viewUp[1], viewUp[2]],
         };
     }
-    _createVTKImageData({ origin, direction, dimensions, spacing, numComps, pixelArray, }) {
+    createVTKImageData({ origin, direction, dimensions, spacing, numberOfComponents, pixelArray, }) {
         const values = new pixelArray.constructor(pixelArray.length);
         const scalarArray = vtkDataArray.newInstance({
             name: 'Pixels',
-            numberOfComponents: numComps,
+            numberOfComponents: numberOfComponents,
             values: values,
         });
-        this._imageData = vtkImageData.newInstance();
-        this._imageData.setDimensions(dimensions);
-        this._imageData.setSpacing(spacing);
-        this._imageData.setDirection(direction);
-        this._imageData.setOrigin(origin);
-        this._imageData.getPointData().setScalars(scalarArray);
+        const imageData = vtkImageData.newInstance();
+        imageData.setDimensions(dimensions);
+        imageData.setSpacing(spacing);
+        imageData.setDirection(direction);
+        imageData.setOrigin(origin);
+        imageData.getPointData().setScalars(scalarArray);
+        return imageData;
+    }
+    _createVTKImageData({ origin, direction, dimensions, spacing, numberOfComponents, pixelArray, }) {
+        try {
+            this._imageData = this.createVTKImageData({
+                origin,
+                direction,
+                dimensions,
+                spacing,
+                numberOfComponents,
+                pixelArray,
+            });
+        }
+        catch (e) {
+            console.error(e);
+        }
     }
     async setStack(imageIds, currentImageIdIndex = 0) {
         this._throwIfDestroyed();
         this.imageIds = imageIds;
         this.currentImageIdIndex = currentImageIdIndex;
         this.targetImageIdIndex = currentImageIdIndex;
+        const imageRetrieveConfiguration = metaData.get(imageRetrieveMetadataProvider.IMAGE_RETRIEVE_CONFIGURATION, imageIds[currentImageIdIndex], 'stack');
+        this.imagesLoader = imageRetrieveConfiguration
+            ? (imageRetrieveConfiguration.create || createProgressive)(imageRetrieveConfiguration)
+            : this;
         this.stackInvalidated = true;
         this.flipVertical = false;
         this.flipHorizontal = false;
@@ -938,7 +1182,7 @@ class StackViewport extends Viewport {
             element: this.element,
             currentImageIdIndex: currentImageIdIndex,
         };
-        triggerEvent(eventTarget, Events.STACK_VIEWPORT_NEW_STACK, eventDetail);
+        triggerEvent(this.element, Events.VIEWPORT_NEW_IMAGE_SET, eventDetail);
         return imageId;
     }
     _throwIfDestroyed() {
@@ -961,16 +1205,21 @@ class StackViewport extends Viewport {
         const dataType = imageData.getPointData().getScalars().getDataType();
         const isSameXSpacing = isEqual(xSpacing, image.columnPixelSpacing);
         const isSameYSpacing = isEqual(ySpacing, image.rowPixelSpacing);
-        return ((isSameXSpacing ||
-            (image.columnPixelSpacing === null && xSpacing === 1.0)) &&
-            (isSameYSpacing ||
-                (image.rowPixelSpacing === null && ySpacing === 1.0)) &&
-            xVoxels === image.columns &&
-            yVoxels === image.rows &&
-            isEqual(imagePlaneModule.rowCosines, rowCosines) &&
-            isEqual(imagePlaneModule.columnCosines, columnCosines) &&
-            (!this.useNativeDataType ||
-                dataType === image.getPixelData().constructor.name));
+        const isXSpacingValid = isSameXSpacing || (image.columnPixelSpacing === null && xSpacing === 1.0);
+        const isYSpacingValid = isSameYSpacing || (image.rowPixelSpacing === null && ySpacing === 1.0);
+        const isXVoxelsMatching = xVoxels === image.columns;
+        const isYVoxelsMatching = yVoxels === image.rows;
+        const isRowCosinesMatching = isEqual(imagePlaneModule.rowCosines, rowCosines);
+        const isColumnCosinesMatching = isEqual(imagePlaneModule.columnCosines, columnCosines);
+        const isDataTypeMatching = dataType === image.voxelManager.getScalarData().constructor.name;
+        const result = isXSpacingValid &&
+            isYSpacingValid &&
+            isXVoxelsMatching &&
+            isYVoxelsMatching &&
+            isRowCosinesMatching &&
+            isColumnCosinesMatching &&
+            isDataTypeMatching;
+        return result;
     }
     _updateVTKImageDataFromCornerstoneImage(image) {
         const imagePlaneModule = this._getImagePlaneModule(image.imageId);
@@ -979,33 +1228,12 @@ class StackViewport extends Viewport {
             origin = [0, 0, 0];
         }
         this._imageData.setOrigin(origin);
-        this._updatePixelData(image);
-    }
-    _updatePixelData(image) {
-        const pixelData = image.getPixelData();
-        const scalars = this._imageData.getPointData().getScalars();
-        const scalarData = scalars.getData();
-        if (image.color && image.rgba) {
-            const newPixelData = new Uint8Array(image.columns * image.rows * 3);
-            for (let i = 0; i < image.columns * image.rows; i++) {
-                newPixelData[i * 3] = pixelData[i * 4];
-                newPixelData[i * 3 + 1] = pixelData[i * 4 + 1];
-                newPixelData[i * 3 + 2] = pixelData[i * 4 + 2];
-            }
-            image.rgba = false;
-            image.getPixelData = () => newPixelData;
-            scalarData.set(newPixelData);
-        }
-        else {
-            scalarData.set(pixelData);
-        }
-        this._imageData.modified();
+        updateVTKImageDataWithCornerstoneImage(this._imageData, image);
     }
-    async _loadAndDisplayImage(imageId, imageIdIndex) {
-        await (this.useCPURendering
+    _loadAndDisplayImage(imageId, imageIdIndex) {
+        return this.useCPURendering
             ? this._loadAndDisplayImageCPU(imageId, imageIdIndex)
-            : this._loadAndDisplayImageGPU(imageId, imageIdIndex));
-        return imageId;
+            : this._loadAndDisplayImageGPU(imageId, imageIdIndex);
     }
     _loadAndDisplayImageCPU(imageId, imageIdIndex) {
         return new Promise((resolve, reject) => {
@@ -1013,7 +1241,7 @@ class StackViewport extends Viewport {
                 if (this.currentImageIdIndex !== imageIdIndex) {
                     return;
                 }
-                const pixelData = image.getPixelData();
+                const pixelData = image.voxelManager.getScalarData();
                 const preScale = image.preScale;
                 const scalingParams = preScale?.scalingParameters;
                 const scaledWithNonIntegers = (preScale?.scaled && scalingParams?.rescaleIntercept % 1 !== 0) ||
@@ -1081,13 +1309,11 @@ class StackViewport extends Viewport {
                 });
             }
             const priority = -5;
-            const requestType = RequestType.Interaction;
-            const additionalDetails = { imageId };
+            const requestType = RequestType.INTERACTION;
+            const additionalDetails = { imageId, imageIdIndex };
             const options = {
-                preScale: {
-                    enabled: true,
-                },
                 useRGBA: true,
+                requestType,
             };
             const eventDetail = {
                 imageId,
@@ -1099,74 +1325,91 @@ class StackViewport extends Viewport {
             imageLoadPoolManager.addRequest(sendRequest.bind(this, imageId, imageIdIndex, options), requestType, additionalDetails, priority);
         });
     }
+    successCallback(imageId, image) {
+        const imageIdIndex = this.imageIds.indexOf(imageId);
+        if (this.currentImageIdIndex !== imageIdIndex) {
+            return;
+        }
+        const csImgFrame = this.csImage?.imageFrame;
+        const imgFrame = image?.imageFrame;
+        const photometricInterpretation = csImgFrame?.photometricInterpretation ||
+            this.csImage?.photometricInterpretation;
+        const newPhotometricInterpretation = imgFrame?.photometricInterpretation || image?.photometricInterpretation;
+        if (photometricInterpretation !== newPhotometricInterpretation) {
+            this.stackInvalidated = true;
+        }
+        this._setCSImage(image);
+        const eventDetail = {
+            image,
+            imageId,
+            imageIdIndex,
+            viewportId: this.id,
+            renderingEngineId: this.renderingEngineId,
+        };
+        this._updateActorToDisplayImageId(image);
+        triggerEvent(this.element, Events.STACK_NEW_IMAGE, eventDetail);
+        this.render();
+        this.currentImageIdIndex = imageIdIndex;
+    }
+    errorCallback(imageId, permanent, error) {
+        if (!permanent) {
+            return;
+        }
+        const imageIdIndex = this.imageIds.indexOf(imageId);
+        const eventDetail = {
+            error,
+            imageIdIndex,
+            imageId,
+        };
+        triggerEvent(eventTarget, Events.IMAGE_LOAD_ERROR, eventDetail);
+    }
+    getLoaderImageOptions(imageId) {
+        const imageIdIndex = this.imageIds.indexOf(imageId);
+        const { transferSyntaxUID } = metaData.get('transferSyntax', imageId) || {};
+        const options = {
+            useRGBA: false,
+            transferSyntaxUID,
+            priority: 5,
+            requestType: RequestType.INTERACTION,
+            additionalDetails: { imageId, imageIdIndex },
+        };
+        return options;
+    }
+    async loadImages(imageIds, listener) {
+        const resultList = await Promise.allSettled(imageIds.map((imageId) => {
+            const options = this.getLoaderImageOptions(imageId);
+            return loadAndCacheImage(imageId, options).then((image) => {
+                listener.successCallback(imageId, image);
+                return imageId;
+            }, (error) => {
+                listener.errorCallback(imageId, true, error);
+                return imageId;
+            });
+        }));
+        const errorList = resultList.filter((item) => item.status === 'rejected');
+        if (errorList && errorList.length) {
+            const event = new CustomEvent(Events.IMAGE_LOAD_ERROR, {
+                detail: errorList,
+                cancelable: true,
+            });
+            eventTarget.dispatchEvent(event);
+        }
+        return resultList;
+    }
     _loadAndDisplayImageGPU(imageId, imageIdIndex) {
-        return new Promise((resolve, reject) => {
-            function successCallback(image, imageIdIndex, imageId) {
-                if (this.currentImageIdIndex !== imageIdIndex) {
-                    return;
-                }
-                const csImgFrame = this.csImage?.imageFrame;
-                const imgFrame = image?.imageFrame;
-                if (csImgFrame?.photometricInterpretation !==
-                    imgFrame?.photometricInterpretation ||
-                    this.csImage?.photometricInterpretation !==
-                        image?.photometricInterpretation) {
-                    this.stackInvalidated = true;
-                }
-                this._setCSImage(image);
-                const eventDetail = {
-                    image,
-                    imageId,
-                    imageIdIndex,
-                    viewportId: this.id,
-                    renderingEngineId: this.renderingEngineId,
-                };
-                triggerEvent(this.element, Events.STACK_NEW_IMAGE, eventDetail);
-                this._updateActorToDisplayImageId(image);
-                this.render();
-                this.currentImageIdIndex = imageIdIndex;
-                resolve(imageId);
-            }
-            function errorCallback(error, imageIdIndex, imageId) {
-                const eventDetail = {
-                    error,
-                    imageIdIndex,
-                    imageId,
-                };
-                triggerEvent(eventTarget, Events.IMAGE_LOAD_ERROR, eventDetail);
-                reject(error);
-            }
-            function sendRequest(imageId, imageIdIndex, options) {
-                return loadAndCacheImage(imageId, options).then((image) => {
-                    successCallback.call(this, image, imageIdIndex, imageId);
-                }, (error) => {
-                    errorCallback.call(this, error, imageIdIndex, imageId);
-                });
-            }
-            const priority = -5;
-            const requestType = RequestType.Interaction;
-            const additionalDetails = { imageId };
-            const options = {
-                targetBuffer: {
-                    type: this.useNativeDataType ? undefined : 'Float32Array',
-                },
-                preScale: {
-                    enabled: true,
-                },
-                useRGBA: false,
-            };
-            const eventDetail = {
-                imageId,
-                imageIdIndex,
-                viewportId: this.id,
-                renderingEngineId: this.renderingEngineId,
-            };
-            triggerEvent(this.element, Events.PRE_STACK_NEW_IMAGE, eventDetail);
-            imageLoadPoolManager.addRequest(sendRequest.bind(this, imageId, imageIdIndex, options), requestType, additionalDetails, priority);
+        const eventDetail = {
+            imageId,
+            imageIdIndex,
+            viewportId: this.id,
+            renderingEngineId: this.renderingEngineId,
+        };
+        triggerEvent(this.element, Events.PRE_STACK_NEW_IMAGE, eventDetail);
+        return this.imagesLoader.loadImages([imageId], this).then((v) => {
+            return imageId;
         });
     }
     _updateToDisplayImageCPU(image) {
-        const metadata = this._getImageDataMetadata(image);
+        const metadata = this.getImageDataMetadata(image);
         const viewport = getDefaultViewport(this.canvas, image, this.modality, this._cpuFallbackEnabledElement.viewport.colormap);
         const { windowCenter, windowWidth } = viewport.voi;
         this.voiRange = windowLevelUtil.toLowHighRange(windowWidth, windowCenter);
@@ -1174,7 +1417,7 @@ class StackViewport extends Viewport {
         this._cpuFallbackEnabledElement.metadata = {
             ...metadata,
         };
-        this.cpuImagePixelData = image.getPixelData();
+        this.cpuImagePixelData = image.voxelManager.getScalarData();
         const viewportSettingToUse = Object.assign({}, viewport, this._cpuFallbackEnabledElement.viewport);
         this._cpuFallbackEnabledElement.viewport = this.stackInvalidated
             ? viewport
@@ -1183,63 +1426,92 @@ class StackViewport extends Viewport {
         this.cpuRenderingInvalidated = true;
         this._cpuFallbackEnabledElement.transform = calculateTransform(this._cpuFallbackEnabledElement);
     }
+    getSliceViewInfo() {
+        throw new Error('Method not implemented.');
+    }
+    addImages(stackInputs) {
+        const actors = [];
+        stackInputs.forEach((stackInput) => {
+            const { imageId } = stackInput;
+            const image = cache.getImage(imageId);
+            const { origin, dimensions, direction, spacing, numberOfComponents } = this.getImageDataMetadata(image);
+            const imagedata = this.createVTKImageData({
+                origin,
+                dimensions,
+                direction,
+                spacing,
+                numberOfComponents,
+                pixelArray: image.voxelManager.getScalarData(),
+            });
+            const imageActor = this.createActorMapper(imagedata);
+            if (imageActor) {
+                actors.push({
+                    uid: stackInput.actorUID ?? uuidv4(),
+                    actor: imageActor,
+                    referencedId: imageId,
+                });
+                if (stackInput.callback) {
+                    stackInput.callback({ imageActor, imageId: stackInput.imageId });
+                }
+            }
+        });
+        this.addActors(actors);
+    }
     _updateActorToDisplayImageId(image) {
         const sameImageData = this._checkVTKImageDataMatchesCornerstoneImage(image, this._imageData);
-        const activeCamera = this.getRenderer().getActiveCamera();
-        const previousCameraProps = _cloneDeep(this.getCamera());
+        const viewPresentation = this.getViewPresentation();
         if (sameImageData && !this.stackInvalidated) {
             this._updateVTKImageDataFromCornerstoneImage(image);
-            const cameraProps = this.getCamera();
-            const panCache = vec3.subtract(vec3.create(), this.cameraFocalPointOnRender, cameraProps.focalPoint);
             this.resetCameraNoEvent();
-            this.setCameraNoEvent({
-                flipHorizontal: previousCameraProps.flipHorizontal,
-                flipVertical: previousCameraProps.flipVertical,
-                viewUp: previousCameraProps.viewUp,
-            });
-            const { focalPoint } = this.getCamera();
-            this.cameraFocalPointOnRender = focalPoint;
-            activeCamera.setFreezeFocalPoint(true);
-            this._restoreCameraProps(cameraProps, previousCameraProps, panCache);
+            this.setViewPresentation(viewPresentation);
             this._setPropertiesFromCache();
+            this.stackActorReInitialized = false;
             return;
         }
-        const { origin, direction, dimensions, spacing, numComps, imagePixelModule, } = this._getImageDataMetadata(image);
+        const { origin, direction, dimensions, spacing, numberOfComponents, imagePixelModule, } = this.getImageDataMetadata(image);
+        const pixelArray = image.voxelManager.getScalarData();
         this._createVTKImageData({
             origin,
             direction,
             dimensions,
             spacing,
-            numComps,
-            pixelArray: image.getPixelData(),
+            numberOfComponents,
+            pixelArray,
         });
         this._updateVTKImageDataFromCornerstoneImage(image);
         const actor = this.createActorMapper(this._imageData);
-        const actors = [];
-        actors.push({ uid: this.id, actor });
-        this.setActors(actors);
+        const oldActors = this.getActors();
+        if (oldActors.length && oldActors[0].uid === this.id) {
+            oldActors[0].actor = actor;
+        }
+        else {
+            oldActors.unshift({ uid: this.id, actor });
+        }
+        this.setActors(oldActors);
         const { viewPlaneNormal, viewUp } = this._getCameraOrientation(direction);
+        const previousCamera = this.getCamera();
         this.setCameraNoEvent({ viewUp, viewPlaneNormal });
         this.initialViewUp = viewUp;
         this.resetCameraNoEvent();
-        this.triggerCameraEvent(this.getCamera(), previousCameraProps);
-        activeCamera.setFreezeFocalPoint(true);
+        this.setViewPresentation(viewPresentation);
+        this.triggerCameraEvent(this.getCamera(), previousCamera);
         const monochrome1 = imagePixelModule.photometricInterpretation === 'MONOCHROME1';
         this.stackInvalidated = true;
-        this.setVOI(this._getInitialVOIRange(image), {
+        const voiRange = this._getInitialVOIRange(image);
+        this.setVOI(voiRange, {
             forceRecreateLUTFunction: !!monochrome1,
         });
         this.initialInvert = !!monochrome1;
         this.setInvertColor(this.invert || this.initialInvert);
-        this.cameraFocalPointOnRender = this.getCamera().focalPoint;
         this.stackInvalidated = false;
+        this.stackActorReInitialized = true;
         if (this._publishCalibratedEvent) {
             this.triggerCalibrationEvent();
         }
     }
     _getInitialVOIRange(image) {
         if (this.voiRange && this.voiUpdatedWithSetProperties) {
-            return this.voiRange;
+            return this.globalDefaultProperties.voiRange;
         }
         const { windowCenter, windowWidth } = image;
         let voiRange = this._getVOIRangeFromWindowLevel(windowWidth, windowCenter);
@@ -1256,7 +1528,7 @@ class StackViewport extends Viewport {
         if (this.modality !== 'PT' || !this.csImage.isPreScaled) {
             return false;
         }
-        if (!this.csImage.preScale?.scalingParameters?.suvbw) {
+        if (!this.csImage.preScale?.scalingParameters.suvbw) {
             return false;
         }
         return true;
@@ -1286,9 +1558,18 @@ class StackViewport extends Viewport {
         this.hasPixelSpacing = true;
         this.viewportStatus = ViewportStatus.PRE_RENDER;
         const imageId = await this._loadAndDisplayImage(this.imageIds[imageIdIndex], imageIdIndex);
+        if (this.perImageIdDefaultProperties.size >= 1) {
+            const defaultProperties = this.perImageIdDefaultProperties.get(imageId);
+            if (defaultProperties !== undefined) {
+                this.setProperties(defaultProperties);
+            }
+            else if (this.globalDefaultProperties !== undefined) {
+                this.setProperties(this.globalDefaultProperties);
+            }
+        }
         return imageId;
     }
-    resetCameraCPU(resetPan, resetZoom) {
+    resetCameraCPU({ resetPan = true, resetZoom = true, }) {
         const { image } = this._cpuFallbackEnabledElement;
         if (!image) {
             return;
@@ -1303,14 +1584,14 @@ class StackViewport extends Viewport {
             scale,
         });
     }
-    resetCameraGPU(resetPan, resetZoom) {
+    resetCameraGPU({ resetPan, resetZoom }) {
         this.setCamera({
             flipHorizontal: false,
             flipVertical: false,
             viewUp: this.initialViewUp,
         });
         const resetToCenter = true;
-        return super.resetCamera(resetPan, resetZoom, resetToCenter);
+        return super.resetCamera({ resetPan, resetZoom, resetToCenter });
     }
     scroll(delta, debounce = true, loop = false) {
         const imageIds = this.imageIds;
@@ -1345,37 +1626,19 @@ class StackViewport extends Viewport {
             triggerEvent(this.element, Events.STACK_VIEWPORT_SCROLL, eventData);
         }
     }
-    async setImageIdIndex(imageIdIndex) {
+    setImageIdIndex(imageIdIndex) {
         this._throwIfDestroyed();
         if (this.currentImageIdIndex === imageIdIndex) {
-            return this.getCurrentImageId();
+            return Promise.resolve(this.getCurrentImageId());
         }
-        const imageId = this._setImageIdIndex(imageIdIndex);
-        return imageId;
+        const imageIdPromise = this._setImageIdIndex(imageIdIndex);
+        return imageIdPromise;
     }
     calibrateSpacing(imageId) {
         const imageIdIndex = this.getImageIds().indexOf(imageId);
         this.stackInvalidated = true;
         this._loadAndDisplayImage(imageId, imageIdIndex);
     }
-    _restoreCameraProps({ parallelScale: prevScale }, previousCamera, panCache) {
-        const renderer = this.getRenderer();
-        const { position, focalPoint } = this.getCamera();
-        const newPosition = vec3.subtract(vec3.create(), position, panCache);
-        const newFocal = vec3.subtract(vec3.create(), focalPoint, panCache);
-        this.setCameraNoEvent({
-            parallelScale: prevScale,
-            position: newPosition,
-            focalPoint: newFocal,
-        });
-        const camera = this.getCamera();
-        this.triggerCameraEvent(camera, previousCamera);
-        const RESET_CAMERA_EVENT = {
-            type: 'ResetCameraEvent',
-            renderer,
-        };
-        renderer.invokeEvent(RESET_CAMERA_EVENT);
-    }
     triggerCameraEvent(camera, previousCamera) {
         const eventDetail = {
             previousCamera,
@@ -1409,11 +1672,111 @@ class StackViewport extends Viewport {
         return this._getVOIRangeFromWindowLevel(windowWidth, windowCenter);
     }
     _getValidVOILUTFunction(voiLUTFunction) {
-        if (Object.values(VOILUTFunctionType).indexOf(voiLUTFunction) === -1) {
-            voiLUTFunction = VOILUTFunctionType.LINEAR;
+        if (!Object.values(VOILUTFunctionType).includes(voiLUTFunction)) {
+            return VOILUTFunctionType.LINEAR;
         }
         return voiLUTFunction;
     }
+    getSliceInfo() {
+        const sliceIndex = this.getSliceIndex();
+        const { dimensions } = this.getImageData();
+        return {
+            width: dimensions[0],
+            height: dimensions[1],
+            sliceIndex,
+            slicePlane: 2,
+        };
+    }
+    isReferenceViewable(viewRef, options = {}) {
+        if (!super.isReferenceViewable(viewRef, options)) {
+            return false;
+        }
+        const { referencedImageId, sliceIndex } = viewRef;
+        if (viewRef.volumeId && !referencedImageId) {
+            return options.asVolume;
+        }
+        let testIndex = this.getCurrentImageIdIndex();
+        let currentImageId = this.imageIds[testIndex];
+        if (options.withNavigation && typeof sliceIndex === 'number') {
+            testIndex = sliceIndex;
+            currentImageId = this.imageIds[testIndex];
+        }
+        if (!currentImageId) {
+            return false;
+        }
+        if (options.asOverlay && referencedImageId) {
+            const matchedImageId = this.matchImagesForOverlay(currentImageId, referencedImageId);
+            if (matchedImageId) {
+                return true;
+            }
+        }
+        let { imageURI } = options;
+        if (!imageURI) {
+            imageURI = imageIdToURI(currentImageId);
+        }
+        const referencedImageURI = imageIdToURI(referencedImageId);
+        const endsWith = referencedImageId?.endsWith(imageURI);
+        if (endsWith) {
+            return endsWith;
+        }
+        const { cameraFocalPoint } = viewRef;
+        if (options.asNearbyProjection && cameraFocalPoint) {
+            const { spacing, direction, origin } = this.getImageData();
+            const viewPlaneNormal = direction.slice(6, 9);
+            const sliceThickness = getSpacingInNormalDirection({ direction, spacing }, viewPlaneNormal);
+            const diff = vec3.subtract(vec3.create(), cameraFocalPoint, origin);
+            const distanceToPlane = vec3.dot(diff, viewPlaneNormal);
+            const threshold = sliceThickness / 2;
+            if (Math.abs(distanceToPlane) <= threshold) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getViewReference(viewRefSpecifier = {}) {
+        const { sliceIndex = this.getCurrentImageIdIndex() } = viewRefSpecifier;
+        const reference = super.getViewReference(viewRefSpecifier);
+        const referencedImageId = this.imageIds[sliceIndex];
+        if (!referencedImageId) {
+            return;
+        }
+        reference.referencedImageId = referencedImageId;
+        if (this.getCurrentImageIdIndex() !== sliceIndex) {
+            const referenceData = this.getImagePlaneReferenceData(sliceIndex);
+            if (!referenceData) {
+                return;
+            }
+            Object.assign(reference, referenceData);
+        }
+        return reference;
+    }
+    setViewReference(viewRef) {
+        if (!viewRef) {
+            return;
+        }
+        const { referencedImageId, sliceIndex } = viewRef;
+        if (typeof sliceIndex === 'number' &&
+            referencedImageId &&
+            referencedImageId === this.imageIds[sliceIndex]) {
+            this.scroll(sliceIndex - this.targetImageIdIndex);
+        }
+        else {
+            const foundIndex = this.imageIds.indexOf(referencedImageId);
+            if (foundIndex !== -1) {
+                this.scroll(foundIndex - this.targetImageIdIndex);
+            }
+            else {
+                throw new Error('Unsupported - referenced image id not found');
+            }
+        }
+    }
+    getViewReferenceId(specifier = {}) {
+        const { sliceIndex: sliceIndex = this.currentImageIdIndex } = specifier;
+        if (Array.isArray(sliceIndex)) {
+            throw new Error('Use of slice ranges for stacks not supported');
+        }
+        return `imageId:${this.imageIds[sliceIndex]}`;
+    }
     getCPUFallbackError(method) {
         return new Error(`method ${method} cannot be used during CPU Fallback mode`);
     }
@@ -1431,48 +1794,61 @@ class StackViewport extends Viewport {
         this.render();
     }
     setColormapCPU(colormapData) {
-        const colormap = getColormap(colormapData.name, colormapData);
+        this.colormap = colormapData;
+        const colormap = colormapUtils.getColormap(colormapData.name);
         this._cpuFallbackEnabledElement.viewport.colormap = colormap;
         this._cpuFallbackEnabledElement.renderingTools = {};
         this.fillWithBackgroundColor();
         this.cpuRenderingInvalidated = true;
         this.render();
+        const eventDetail = {
+            viewportId: this.id,
+            colormap: colormapData,
+        };
+        triggerEvent(this.element, Events.COLORMAP_MODIFIED, eventDetail);
     }
     setColormapGPU(colormap) {
         const ActorEntry = this.getDefaultActor();
         const actor = ActorEntry.actor;
         const actorProp = actor.getProperty();
         const rgbTransferFunction = actorProp.getRGBTransferFunction();
+        const colormapObj = colormapUtils.getColormap(colormap.name) ||
+            vtkColorMaps.getPresetByName(colormap.name);
         if (!rgbTransferFunction) {
             const cfun = vtkColorTransferFunction.newInstance();
-            const voiRange = this._getVOIRangeForCurrentImage();
-            cfun.applyColorMap(colormap);
-            cfun.setMappingRange(voiRange.lower, voiRange.upper);
+            cfun.applyColorMap(colormapObj);
+            cfun.setMappingRange(this.voiRange.lower, this.voiRange.upper);
             actorProp.setRGBTransferFunction(0, cfun);
         }
         else {
-            rgbTransferFunction.applyColorMap(colormap);
+            rgbTransferFunction.applyColorMap(colormapObj);
+            rgbTransferFunction.setMappingRange(this.voiRange.lower, this.voiRange.upper);
             actorProp.setRGBTransferFunction(0, rgbTransferFunction);
         }
+        this.colormap = colormap;
         this.render();
+        const eventDetail = {
+            viewportId: this.id,
+            colormap,
+        };
+        triggerEvent(this.element, Events.COLORMAP_MODIFIED, eventDetail);
     }
     unsetColormapGPU() {
         throw new Error('unsetColormapGPU not implemented.');
     }
     _getImagePlaneModule(imageId) {
-        const imagePlaneModule = metaData.get('imagePlaneModule', imageId);
-        const calibratedPixelSpacing = metaData.get('calibratedPixelSpacing', imageId);
+        const imagePlaneModule = metaData.get(MetadataModules.IMAGE_PLANE, imageId);
+        this.hasPixelSpacing =
+            !imagePlaneModule.usingDefaultValues || this.calibration?.scale > 0;
         this.calibration ||= imagePlaneModule.calibration;
         const newImagePlaneModule = {
             ...imagePlaneModule,
         };
         if (!newImagePlaneModule.columnPixelSpacing) {
             newImagePlaneModule.columnPixelSpacing = 1;
-            this.hasPixelSpacing = this.calibration?.scale > 0;
         }
         if (!newImagePlaneModule.rowPixelSpacing) {
             newImagePlaneModule.rowPixelSpacing = 1;
-            this.hasPixelSpacing = this.calibration?.scale > 0;
         }
         if (!newImagePlaneModule.columnCosines) {
             newImagePlaneModule.columnCosines = [0, 1, 0];
@@ -1492,4 +1868,3 @@ class StackViewport extends Viewport {
     }
 }
 export default StackViewport;
-//# sourceMappingURL=StackViewport.js.map