@cornerstonejs/core 2.0.0-beta.8 → 2.0.1

package/dist/esm/RenderingEngine/StackViewport.js

@@ -8,9 +8,19 @@ import vtkImageSlice from '@kitware/vtk.js/Rendering/Core/ImageSlice';
 import { mat4, vec2, vec3 } from 'gl-matrix';
 import eventTarget from '../eventTarget';
 import * as metaData from '../metaData';
-import { actorIsA, colormap as colormapUtils, createSigmoidRGBTransferFunction, imageIdToURI, imageRetrieveMetadataProvider, invertRgbTransferFunction, isEqual, isImageActor, triggerEvent, updateVTKImageDataWithCornerstoneImage, windowLevel as windowLevelUtil, } from '../utilities';
+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 { getColormap } from './helpers/cpuFallback/colors/index';
 import drawImageSync from './helpers/cpuFallback/drawImageSync';
 import { Events, InterpolationType, MetadataModules, RequestType, VOILUTFunctionType, ViewportStatus, } from '../enums';
 import { loadAndCacheImage } from '../loaders/imageLoader';
@@ -20,20 +30,21 @@ import canvasToPixel from './helpers/cpuFallback/rendering/canvasToPixel';
 import getDefaultViewport from './helpers/cpuFallback/rendering/getDefaultViewport';
 import pixelToCanvas from './helpers/cpuFallback/rendering/pixelToCanvas';
 import resize from './helpers/cpuFallback/rendering/resize';
-import cache from '../cache';
+import cache from '../cache/cache';
 import { getConfiguration, getShouldUseCPURendering } from '../init';
 import { createProgressive } from '../loaders/ProgressiveRetrieveImages';
-import createLinearRGBTransferFunction from '../utilities/createLinearRGBTransferFunction';
-import { getTransferFunctionNodes, setTransferFunctionNodes, } from '../utilities/transferFunctionUtils';
 import correctShift from './helpers/cpuFallback/rendering/correctShift';
 import resetCamera from './helpers/cpuFallback/rendering/resetCamera';
 import { Transform } from './helpers/cpuFallback/rendering/transform';
-import { findMatchingColormap } from '../utilities/colormap';
+import uuidv4 from '../utilities/uuidv4';
+import getSpacingInNormalDirection from '../utilities/getSpacingInNormalDirection';
+import getClosestImageId from '../utilities/getClosestImageId';
 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;
@@ -41,7 +52,6 @@ class StackViewport extends Viewport {
         this.initialTransferFunctionNodes = null;
         this.stackInvalidated = false;
         this._publishCalibratedEvent = false;
-        this.useNativeDataType = false;
         this.updateRenderingPipeline = () => {
             this._configureRenderingPipeline();
         };
@@ -66,7 +76,7 @@ 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;
@@ -84,28 +94,33 @@ class StackViewport extends Viewport {
             }
             return {
                 ...this.globalDefaultProperties,
-                rotation: this.getRotation(),
             };
         };
         this.getProperties = () => {
             const { colormap, voiRange, VOILUTFunction, interpolationType, invert, voiUpdatedWithSetProperties, } = this;
-            const rotation = this.getRotation();
             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;
@@ -118,9 +133,12 @@ class StackViewport extends Viewport {
         };
         this.setRotation = (rotation) => {
             const previousCamera = this.getCamera();
-            this.useCPURendering
-                ? this.setRotationCPU(rotation)
-                : this.setRotationGPU(rotation);
+            if (this.useCPURendering) {
+                this.setRotationCPU(rotation);
+            }
+            else {
+                this.setRotationGPU(rotation);
+            }
             if (this._suppressCameraModifiedEvents) {
                 return;
             }
@@ -131,7 +149,6 @@ class StackViewport extends Viewport {
                 element: this.element,
                 viewportId: this.id,
                 renderingEngineId: this.renderingEngineId,
-                rotation,
             };
             triggerEvent(this.element, Events.CAMERA_MODIFIED, eventDetail);
         };
@@ -163,11 +180,11 @@ class StackViewport extends Viewport {
             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) => {
@@ -312,12 +329,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;
                 },
             },
@@ -369,15 +388,13 @@ 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();
     }
@@ -389,12 +406,14 @@ class StackViewport extends Viewport {
         return getShouldUseCPURendering();
     }
     _configureRenderingPipeline(value) {
-        this.useNativeDataType = this._shouldUseNativeDataType();
         this.useCPURendering = value ?? getShouldUseCPURendering();
-        for (const [funcName, functions] of Object.entries(this.renderingPipelineFunctions)) {
-            this[funcName] = this.useCPURendering ? functions.cpu : functions.gpu;
+        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();
     }
@@ -434,31 +453,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.csImage.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,
@@ -480,10 +510,11 @@ class StackViewport extends Viewport {
             },
             scalarData: this.cpuImagePixelData,
             hasPixelSpacing: this.hasPixelSpacing,
-            calibration: { ...this.csImage.calibration, ...this.calibration },
+            calibration: { ...csImage?.calibration, ...this.calibration },
             preScale: {
-                ...this.csImage.preScale,
+                ...csImage?.preScale,
             },
+            voxelManager: csImage?.voxelManager,
         };
     }
     buildMetadata(image) {
@@ -558,20 +589,17 @@ class StackViewport extends Viewport {
             this.resetToDefaultProperties();
         }
     }
-    setProperties({ colormap, voiRange, VOILUTFunction, invert, interpolationType, rotation, } = {}, suppressEvents = false) {
+    setProperties({ colormap, voiRange, VOILUTFunction, invert, interpolationType, } = {}, suppressEvents = false) {
         this.viewportStatus = this.csImage
             ? ViewportStatus.PRE_RENDER
             : ViewportStatus.LOADING;
-        if (this.globalDefaultProperties == null) {
-            this.setDefaultProperties({
-                colormap,
-                voiRange,
-                VOILUTFunction,
-                invert,
-                interpolationType,
-                rotation,
-            });
-        }
+        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);
         }
@@ -588,11 +616,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;
@@ -616,9 +639,6 @@ class StackViewport extends Viewport {
         this.setVOI(voiRange);
         this.setInvertColor(this.initialInvert);
         this.setInterpolationType(InterpolationType.LINEAR);
-        if (this.getRotation() !== 0) {
-            this.setRotation(0);
-        }
         const transferFunction = this.getTransferFunction();
         setTransferFunctionNodes(transferFunction, this.initialTransferFunctionNodes);
         const nodes = getTransferFunctionNodes(transferFunction);
@@ -627,7 +647,7 @@ class StackViewport extends Viewport {
             return acc;
         }, []);
         const defaultActor = this.getDefaultActor();
-        const matchedColormap = findMatchingColormap(RGBPoints, defaultActor.actor);
+        const matchedColormap = colormapUtils.findMatchingColormap(RGBPoints, defaultActor.actor);
         this.setColormap(matchedColormap);
     }
     resetToDefaultProperties() {
@@ -651,15 +671,11 @@ class StackViewport extends Viewport {
             voiRange = properties.voiRange;
         }
         this.setVOI(voiRange);
-        if (this.getRotation() !== 0) {
-            this.setRotation(0);
-        }
         this.setInterpolationType(InterpolationType.LINEAR);
         this.setInvertColor(false);
         this.render();
     }
-    _setPropertiesFromCache() {
-        const { interpolationType, invert } = this;
+    _getVOIFromCache() {
         let voiRange;
         if (this.voiUpdatedWithSetProperties) {
             voiRange = this.voiRange;
@@ -670,6 +686,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);
@@ -744,7 +765,6 @@ class StackViewport extends Viewport {
             element: this.element,
             viewportId: this.id,
             renderingEngineId: this.renderingEngineId,
-            rotation: this.getRotation(),
         };
         triggerEvent(this.element, Events.CAMERA_MODIFIED, eventDetail);
     }
@@ -989,7 +1009,7 @@ class StackViewport extends Viewport {
     _getNumCompsFromPhotometricInterpretation(photometricInterpretation) {
         let numberOfComponents = 1;
         if (photometricInterpretation === 'RGB' ||
-            photometricInterpretation.indexOf('YBR') !== -1 ||
+            photometricInterpretation.includes('YBR') ||
             photometricInterpretation === 'PALETTE COLOR') {
             numberOfComponents = 3;
         }
@@ -1018,11 +1038,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],
@@ -1032,6 +1052,45 @@ 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) {
@@ -1045,7 +1104,7 @@ class StackViewport extends Viewport {
         let { rowCosines, columnCosines } = imagePlaneModule;
         rowCosines ||= [1, 0, 0];
         columnCosines ||= [0, 1, 0];
-        const viewPlaneNormal = (vec3.cross([0, 0, 0], columnCosines, rowCosines));
+        const viewPlaneNormal = vec3.cross([0, 0, 0], columnCosines, rowCosines);
         return {
             FrameOfReferenceUID,
             viewPlaneNormal,
@@ -1066,11 +1125,11 @@ 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,
         });
         const imageData = vtkImageData.newInstance();
@@ -1081,15 +1140,20 @@ class StackViewport extends Viewport {
         imageData.getPointData().setScalars(scalarArray);
         return imageData;
     }
-    _createVTKImageData({ origin, direction, dimensions, spacing, numComps, pixelArray, }) {
-        this._imageData = this.createVTKImageData({
-            origin,
-            direction,
-            dimensions,
-            spacing,
-            numComps,
-            pixelArray,
-        });
+    _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();
@@ -1119,7 +1183,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() {
@@ -1142,16 +1206,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);
@@ -1173,7 +1242,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) ||
@@ -1244,9 +1313,6 @@ class StackViewport extends Viewport {
             const requestType = RequestType.Interaction;
             const additionalDetails = { imageId, imageIdIndex };
             const options = {
-                preScale: {
-                    enabled: true,
-                },
                 useRGBA: true,
                 requestType,
             };
@@ -1301,20 +1367,12 @@ class StackViewport extends Viewport {
     getLoaderImageOptions(imageId) {
         const imageIdIndex = this.imageIds.indexOf(imageId);
         const { transferSyntaxUID } = metaData.get('transferSyntax', imageId) || {};
-        const additionalDetails = { imageId, imageIdIndex };
         const options = {
-            targetBuffer: {
-                type: this.useNativeDataType ? undefined : 'Float32Array',
-            },
-            preScale: {
-                enabled: true,
-            },
             useRGBA: false,
             transferSyntaxUID,
-            useNativeDataType: this.useNativeDataType,
             priority: 5,
             requestType: RequestType.Interaction,
-            additionalDetails,
+            additionalDetails: { imageId, imageIdIndex },
         };
         return options;
     }
@@ -1360,7 +1418,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
@@ -1369,59 +1427,57 @@ class StackViewport extends Viewport {
         this.cpuRenderingInvalidated = true;
         this._cpuFallbackEnabledElement.transform = calculateTransform(this._cpuFallbackEnabledElement);
     }
+    getSliceViewInfo() {
+        throw new Error('Method not implemented.');
+    }
     addImages(stackInputs) {
-        const actors = this.getActors();
+        const actors = [];
         stackInputs.forEach((stackInput) => {
-            const image = cache.getImage(stackInput.imageId);
-            const { origin, dimensions, direction, spacing, numComps } = this.getImageDataMetadata(image);
+            const { imageId, ...rest } = stackInput;
+            const image = cache.getImage(imageId);
+            const { origin, dimensions, direction, spacing, numberOfComponents } = this.getImageDataMetadata(image);
             const imagedata = this.createVTKImageData({
                 origin,
                 dimensions,
                 direction,
                 spacing,
-                numComps,
-                pixelArray: image.getPixelData(),
+                numberOfComponents,
+                pixelArray: image.voxelManager.getScalarData(),
             });
             const imageActor = this.createActorMapper(imagedata);
             if (imageActor) {
-                actors.push({ uid: stackInput.actorUID, actor: imageActor });
+                actors.push({
+                    uid: stackInput.actorUID ?? uuidv4(),
+                    actor: imageActor,
+                    referencedId: imageId,
+                    ...rest,
+                });
                 if (stackInput.callback) {
                     stackInput.callback({ imageActor, imageId: stackInput.imageId });
                 }
             }
         });
-        this.setActors(actors);
+        this.addActors(actors);
     }
     _updateActorToDisplayImageId(image) {
         const sameImageData = this._checkVTKImageDataMatchesCornerstoneImage(image, this._imageData);
-        const activeCamera = this.getRenderer().getActiveCamera();
-        const previousCameraProps = structuredClone(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 pixelArray = image.getPixelData();
+        const { origin, direction, dimensions, spacing, numberOfComponents, imagePixelModule, } = this.getImageDataMetadata(image);
+        const pixelArray = image.voxelManager.getScalarData();
         this._createVTKImageData({
             origin,
             direction,
             dimensions,
             spacing,
-            numComps,
+            numberOfComponents,
             pixelArray,
         });
         this._updateVTKImageDataFromCornerstoneImage(image);
@@ -1435,19 +1491,20 @@ class StackViewport extends Viewport {
         }
         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) {
@@ -1473,7 +1530,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;
@@ -1514,7 +1571,7 @@ class StackViewport extends Viewport {
         }
         return imageId;
     }
-    resetCameraCPU(resetPan, resetZoom) {
+    resetCameraCPU({ resetPan = true, resetZoom = true, }) {
         const { image } = this._cpuFallbackEnabledElement;
         if (!image) {
             return;
@@ -1529,14 +1586,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;
@@ -1584,24 +1641,6 @@ class StackViewport extends Viewport {
         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,
@@ -1630,38 +1669,84 @@ class StackViewport extends Viewport {
         }
         this._publishCalibratedEvent = false;
     }
+    jumpToWorld(worldPos) {
+        const imageIds = this.getImageIds();
+        const imageData = this.getImageData();
+        const { direction, spacing } = imageData;
+        const imageId = getClosestImageId({ direction: direction, spacing, imageIds }, worldPos, this.getCamera().viewPlaneNormal);
+        const index = imageIds.indexOf(imageId);
+        if (index === -1) {
+            return false;
+        }
+        this.setImageIdIndex(index);
+        this.render();
+        return true;
+    }
     _getVOIRangeForCurrentImage() {
         const { windowCenter, windowWidth } = this.csImage;
         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;
         }
-        let { imageURI } = options;
         const { referencedImageId, sliceIndex } = viewRef;
         if (viewRef.volumeId && !referencedImageId) {
-            return options.asVolume === true;
+            return options.asVolume;
         }
         let testIndex = this.getCurrentImageIdIndex();
+        let currentImageId = this.imageIds[testIndex];
         if (options.withNavigation && typeof sliceIndex === 'number') {
             testIndex = sliceIndex;
+            currentImageId = this.imageIds[testIndex];
         }
-        const imageId = this.imageIds[testIndex];
-        if (!imageId) {
+        if (!currentImageId) {
             return false;
         }
+        if (options.asOverlay && referencedImageId) {
+            const matchedImageId = this.matchImagesForOverlay(currentImageId, referencedImageId);
+            if (matchedImageId) {
+                return true;
+            }
+        }
+        let { imageURI } = options;
         if (!imageURI) {
-            const colonIndex = imageId.indexOf(':');
-            imageURI = imageId.substring(colonIndex + 1);
+            imageURI = imageIdToURI(currentImageId);
         }
-        return referencedImageId?.endsWith(imageURI);
+        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;
@@ -1684,23 +1769,23 @@ class StackViewport extends Viewport {
         if (!viewRef) {
             return;
         }
-        const { referencedImageId, sliceIndex, volumeId } = viewRef;
+        const { referencedImageId, sliceIndex } = viewRef;
         if (typeof sliceIndex === 'number' &&
             referencedImageId &&
             referencedImageId === this.imageIds[sliceIndex]) {
-            this.setImageIdIndex(sliceIndex);
+            this.scroll(sliceIndex - this.targetImageIdIndex);
         }
         else {
             const foundIndex = this.imageIds.indexOf(referencedImageId);
             if (foundIndex !== -1) {
-                this.setImageIdIndex(foundIndex);
+                this.scroll(foundIndex - this.targetImageIdIndex);
             }
             else {
                 throw new Error('Unsupported - referenced image id not found');
             }
         }
     }
-    getReferenceId(specifier = {}) {
+    getViewReferenceId(specifier = {}) {
         const { sliceIndex: sliceIndex = this.currentImageIdIndex } = specifier;
         if (Array.isArray(sliceIndex)) {
             throw new Error('Use of slice ranges for stacks not supported');
@@ -1725,7 +1810,7 @@ class StackViewport extends Viewport {
     }
     setColormapCPU(colormapData) {
         this.colormap = colormapData;
-        const colormap = getColormap(colormapData.name, colormapData);
+        const colormap = colormapUtils.getColormap(colormapData.name);
         this._cpuFallbackEnabledElement.viewport.colormap = colormap;
         this._cpuFallbackEnabledElement.renderingTools = {};
         this.fillWithBackgroundColor();
@@ -1768,17 +1853,17 @@ class StackViewport extends Viewport {
     }
     _getImagePlaneModule(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];
@@ -1798,4 +1883,3 @@ class StackViewport extends Viewport {
     }
 }
 export default StackViewport;
-//# sourceMappingURL=StackViewport.js.map