@cornerstonejs/core 2.0.0-beta.27 → 2.0.0-beta.28

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

@@ -1,6 +1,6 @@
 import type { mat4 } from 'gl-matrix';
 import type { BlendModes, InterpolationType, OrientationAxis } from '../enums';
-import type { FlipDirection, IImageData, IVolumeInput, OrientationVectors, Point2, Point3, VolumeViewportProperties, ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewReference } from '../types';
+import type { FlipDirection, IImageData, IVolumeInput, OrientationVectors, Point2, Point3, VolumeViewportProperties, ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewReference, ICamera } from '../types';
 import type { VoiModifiedEventDetail } from '../types/EventTypes';
 import type { ViewportInput } from '../types/IViewport';
 import type { TransferFunctionNodes } from '../types/ITransferFunctionNode';
@@ -60,7 +60,11 @@ declare abstract class BaseVolumeViewport extends Viewport {
     flip(flipDirection: FlipDirection): void;
     getFrameOfReferenceUID: () => string;
     hasVolumeId(volumeId: string): boolean;
+    hasVolumeURI(volumeURI: string): boolean;
     getImageData(volumeId?: string): IImageData | undefined;
+    protected setCameraClippingRange(): void;
+    getSliceIndex(): number;
+    setCamera(cameraInterface: ICamera, storeAsInitialCamera?: boolean): void;
     private _setVolumeActors;
     canvasToWorld: (canvasPos: Point2) => Point3;
     worldToCanvas: (worldPos: Point3) => Point2;

package/dist/esm/RenderingEngine/BaseVolumeViewport.js

@@ -20,12 +20,13 @@ import volumeNewImageEventDispatcher, { resetVolumeNewImageState, } from './help
 import Viewport from './Viewport';
 import vtkSlabCamera from './vtkClasses/vtkSlabCamera';
 import getVolumeViewportScrollInfo from '../utilities/getVolumeViewportScrollInfo';
-import { actorIsA } from '../utilities/actorCheck';
+import { actorIsA, isImageActor } from '../utilities/actorCheck';
 import snapFocalPointToSlice from '../utilities/snapFocalPointToSlice';
 import getVoiFromSigmoidRGBTransferFunction from '../utilities/getVoiFromSigmoidRGBTransferFunction';
 import isEqual, { isEqualNegative } from '../utilities/isEqual';
 import applyPreset from '../utilities/applyPreset';
 import imageIdToURI from '../utilities/imageIdToURI';
+import uuidv4 from '../utilities/uuidv4';
 class BaseVolumeViewport extends Viewport {
     constructor(props) {
         super(props);
@@ -83,12 +84,14 @@ class BaseVolumeViewport extends Viewport {
                 return;
             }
             const { colormap: latestColormap, VOILUTFunction, interpolationType, invert, slabThickness, preset, } = this.viewportProperties;
+            const volume = cache.getVolume(this.getVolumeId());
+            if (!volume) {
+                return null;
+            }
             const voiRanges = this.getActors()
                 .map((actorEntry) => {
                 const volumeActor = actorEntry.actor;
-                const volumeId = actorEntry.uid;
-                const volume = cache.getVolume(volumeId);
-                if (!volume) {
+                if (!actorIsA(actorEntry, 'vtkVolume')) {
                     return null;
                 }
                 const cfun = volumeActor.getProperty().getRGBTransferFunction(0);
@@ -119,7 +122,7 @@ class BaseVolumeViewport extends Viewport {
                 return;
             }
             const { volumeActor } = applicableVolumeActorInfo;
-            const cfun = volumeActor.getProperty().getRGBTransferFunction(0);
+            const cfun = this._getOrCreateColorTransferFunction(volumeId);
             const { nodes } = cfun.getState();
             const RGBPoints = nodes.reduce((acc, node) => {
                 acc.push(node.x, node.r, node.g, node.b);
@@ -191,8 +194,8 @@ class BaseVolumeViewport extends Viewport {
         };
         this.hasImageURI = (imageURI) => {
             const volumeActors = this.getActors().filter((actorEntry) => actorIsA(actorEntry, 'vtkVolume'));
-            return volumeActors.some(({ uid }) => {
-                const volume = cache.getVolume(uid);
+            return volumeActors.some(({ uid, referencedId }) => {
+                const volume = cache.getVolume(referencedId || uid);
                 if (!volume?.imageIds) {
                     return false;
                 }
@@ -571,6 +574,9 @@ class BaseVolumeViewport extends Viewport {
                 slabThickness,
             });
         }
+        if (invert !== undefined && this.viewportProperties.invert !== invert) {
+            this.setInvert(invert, volumeId, suppressEvents);
+        }
         if (colormap?.name) {
             this.setColormap(colormap, volumeId, suppressEvents);
         }
@@ -586,9 +592,6 @@ class BaseVolumeViewport extends Viewport {
         if (VOILUTFunction !== undefined) {
             this.setVOILUTFunction(VOILUTFunction, volumeId, suppressEvents);
         }
-        if (invert !== undefined && this.viewportProperties.invert !== invert) {
-            this.setInvert(invert, volumeId, suppressEvents);
-        }
         if (preset !== undefined) {
             this.setPreset(preset, volumeId, suppressEvents);
         }
@@ -668,7 +671,7 @@ class BaseVolumeViewport extends Viewport {
         for (let i = 0; i < volumeInputArray.length; i++) {
             const { volumeId, actorUID, slabThickness } = volumeInputArray[i];
             const actor = await createVolumeActor(volumeInputArray[i], this.element, this.id, suppressEvents);
-            const uid = actorUID || volumeId;
+            const uid = actorUID || uuidv4();
             volumeActors.push({
                 uid,
                 actor,
@@ -703,7 +706,7 @@ class BaseVolumeViewport extends Viewport {
             if (!visibility) {
                 actor.setVisibility(false);
             }
-            const uid = actorUID || volumeId;
+            const uid = actorUID || uuidv4();
             volumeActors.push({
                 uid,
                 actor,
@@ -734,22 +737,24 @@ class BaseVolumeViewport extends Viewport {
         }
     }
     _getApplicableVolumeActor(volumeId) {
-        if (volumeId !== undefined && !this.getActor(volumeId)) {
-            return;
-        }
         const actorEntries = this.getActors();
-        if (!actorEntries.length) {
+        if (!actorEntries?.length) {
             return;
         }
-        let volumeActor;
         if (volumeId) {
-            volumeActor = this.getActor(volumeId).actor;
-        }
-        if (!volumeActor) {
-            volumeActor = actorEntries[0].actor;
-            volumeId = actorEntries[0].uid;
+            const actorEntry = actorEntries.find((actor) => actor.referencedId === volumeId);
+            return {
+                volumeActor: actorEntry.actor,
+                volumeId,
+                actorUID: actorEntry.uid,
+            };
         }
-        return { volumeActor, volumeId };
+        const defaultActorEntry = actorEntries[0];
+        return {
+            volumeActor: defaultActorEntry.actor,
+            volumeId: defaultActorEntry.referencedId,
+            actorUID: defaultActorEntry.uid,
+        };
     }
     async _isValidVolumeInputArray(volumeInputArray, FrameOfReferenceUID) {
         const numVolumes = volumeInputArray.length;
@@ -772,14 +777,21 @@ class BaseVolumeViewport extends Viewport {
     hasVolumeId(volumeId) {
         return this.volumeIds.has(volumeId);
     }
+    hasVolumeURI(volumeURI) {
+        for (const volumeId of this.volumeIds) {
+            if (volumeId.includes(volumeURI)) {
+                return true;
+            }
+        }
+        return false;
+    }
     getImageData(volumeId) {
         const defaultActor = this.getDefaultActor();
         if (!defaultActor) {
             return;
         }
-        const { uid: defaultActorUID } = defaultActor;
-        volumeId = volumeId ?? defaultActorUID;
-        const actorEntry = this.getActor(volumeId);
+        volumeId ||= this.getVolumeId();
+        const actorEntry = this.getActors()?.find((actor) => actor.referencedId === volumeId);
         if (!actorIsA(actorEntry, 'vtkVolume')) {
             return;
         }
@@ -804,6 +816,16 @@ class BaseVolumeViewport extends Viewport {
             voxelManager: volume?.voxelManager,
         };
     }
+    setCameraClippingRange() {
+        throw new Error('Method not implemented.');
+    }
+    getSliceIndex() {
+        throw new Error('Method not implemented.');
+    }
+    setCamera(cameraInterface, storeAsInitialCamera) {
+        super.setCamera(cameraInterface, storeAsInitialCamera);
+        this.setCameraClippingRange();
+    }
     _setVolumeActors(volumeActorEntries) {
         for (let i = 0; i < volumeActorEntries.length; i++) {
             this.viewportProperties.invert = false;
@@ -843,9 +865,9 @@ class BaseVolumeViewport extends Viewport {
         if (!actorIsA(actorEntry, 'vtkVolume')) {
             return;
         }
-        const { actor, uid } = actorEntry;
+        const { actor } = actorEntry;
         const imageData = actor.getMapper().getInputData();
-        const volume = cache.getVolume(uid);
+        const volume = cache.getVolume(this.getVolumeId());
         const index = transformWorldToIndex(imageData, point);
         return volume.voxelManager.getAtIJKPoint(index);
     }
@@ -855,10 +877,12 @@ class BaseVolumeViewport extends Viewport {
             return;
         }
         if (!specifier?.volumeId) {
-            return actorEntries.find((actorEntry) => actorEntry.actor.getClassName() === 'vtkVolume')?.uid;
+            const found = actorEntries.find((actorEntry) => actorEntry.actor.getClassName() === 'vtkVolume');
+            return found?.referencedId || found?.uid;
         }
-        return actorEntries.find((actorEntry) => actorEntry.actor.getClassName() === 'vtkVolume' &&
-            actorEntry.uid === specifier?.volumeId)?.uid;
+        const found = actorEntries.find((actorEntry) => actorEntry.actor.getClassName() === 'vtkVolume' &&
+            actorEntry.referencedId === specifier?.volumeId);
+        return found?.referencedId || found?.uid;
     }
     getViewReferenceId(specifier = {}) {
         let { volumeId, sliceIndex: sliceIndex } = specifier;
@@ -867,7 +891,7 @@ class BaseVolumeViewport extends Viewport {
             if (!actorEntries) {
                 return;
             }
-            volumeId = actorEntries.find((actorEntry) => actorEntry.actor.getClassName() === 'vtkVolume')?.uid;
+            volumeId = actorEntries.find((actorEntry) => actorEntry.actor.getClassName() === 'vtkVolume')?.referencedId;
         }
         const currentIndex = this.getSliceIndex();
         sliceIndex ??= currentIndex;
@@ -880,4 +904,3 @@ class BaseVolumeViewport extends Viewport {
     }
 }
 export default BaseVolumeViewport;
-//# sourceMappingURL=BaseVolumeViewport.js.map

package/dist/esm/RenderingEngine/CanvasActor/CanvasMapper.js

@@ -6,4 +6,3 @@ export default class CanvasMapper {
         return this.actor.getImage();
     }
 }
-//# sourceMappingURL=CanvasMapper.js.map

package/dist/esm/RenderingEngine/CanvasActor/CanvasProperties.js

@@ -27,4 +27,3 @@ export default class CanvasProperties {
         return [r, g, b, this.opacity];
     }
 }
-//# sourceMappingURL=CanvasProperties.js.map

package/dist/esm/RenderingEngine/CanvasActor/index.js

@@ -155,4 +155,3 @@ export default class CanvasActor {
         return this.image;
     }
 }
-//# sourceMappingURL=index.js.map

package/dist/esm/RenderingEngine/RenderingEngine.js

@@ -275,10 +275,14 @@ class RenderingEngine {
         }
     }
     _resizeVTKViewports(vtkDrivenViewports, keepCamera = true, immediate = true) {
-        vtkDrivenViewports.forEach((vp) => {
-            getOrCreateCanvas(vp.element);
+        const canvasesDrivenByVtkJs = vtkDrivenViewports.map((vp) => {
+            return getOrCreateCanvas(vp.element);
+        });
+        canvasesDrivenByVtkJs.forEach((canvas) => {
+            const devicePixelRatio = window.devicePixelRatio || 1;
+            canvas.width = canvas.clientWidth * devicePixelRatio;
+            canvas.height = canvas.clientHeight * devicePixelRatio;
         });
-        const canvasesDrivenByVtkJs = vtkDrivenViewports.map((vp) => vp.canvas);
         if (canvasesDrivenByVtkJs.length) {
             const { offScreenCanvasWidth, offScreenCanvasHeight } = this._resizeOffScreenCanvas(canvasesDrivenByVtkJs);
             this._resize(vtkDrivenViewports, offScreenCanvasWidth, offScreenCanvasHeight);
@@ -639,4 +643,3 @@ function _TEMPDownloadURI(uri) {
     link.click();
     document.body.removeChild(link);
 }
-//# sourceMappingURL=RenderingEngine.js.map

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

@@ -32,7 +32,6 @@ declare class StackViewport extends Viewport {
     private initialTransferFunctionNodes;
     private interpolationType;
     private _imageData;
-    private cameraFocalPointOnRender;
     private stackInvalidated;
     private _publishCalibratedEvent;
     private _calibrationEvent;
@@ -97,6 +96,7 @@ declare class StackViewport extends Viewport {
     resetProperties(): void;
     private _resetProperties;
     resetToDefaultProperties(): void;
+    private _getVOIFromCache;
     private _setPropertiesFromCache;
     private getCameraCPU;
     private setCameraCPU;
@@ -177,7 +177,6 @@ declare class StackViewport extends Viewport {
     scroll(delta: number, debounce?: boolean, loop?: boolean): void;
     setImageIdIndex(imageIdIndex: number): Promise<string>;
     calibrateSpacing(imageId: string): void;
-    private _restoreCameraProps;
     private triggerCameraEvent;
     private triggerCalibrationEvent;
     private canvasToWorldCPU;

package/dist/esm/RenderingEngine/StackViewport.js

@@ -36,11 +36,13 @@ import { createProgressive } from '../loaders/ProgressiveRetrieveImages';
 import correctShift from './helpers/cpuFallback/rendering/correctShift';
 import resetCamera from './helpers/cpuFallback/rendering/resetCamera';
 import { Transform } from './helpers/cpuFallback/rendering/transform';
+import uuidv4 from '../utilities/uuidv4';
 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;
@@ -391,7 +393,6 @@ class StackViewport extends Viewport {
         this.imageIds = [];
         this.currentImageIdIndex = 0;
         this.targetImageIdIndex = 0;
-        this.cameraFocalPointOnRender = [0, 0, 0];
         this.resetCamera();
         this.initializeElementDisabledHandler();
     }
@@ -450,13 +451,14 @@ 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(),
             get scalarData() {
-                return this.csImage.voxelManager.getScalarData();
+                return csImage?.voxelManager.getScalarData();
             },
             imageData: actor.getMapper().getInputData(),
             metadata: {
@@ -465,16 +467,17 @@ class StackViewport extends Viewport {
             },
             scaling: this.scaling,
             hasPixelSpacing: this.hasPixelSpacing,
-            calibration: { ...this.csImage.calibration, ...this.calibration },
+            calibration: { ...csImage?.calibration, ...this.calibration },
             preScale: {
-                ...this.csImage.preScale,
+                ...csImage?.preScale,
             },
-            voxelManager: this.csImage.voxelManager,
+            voxelManager: csImage?.voxelManager,
         };
     }
     getImageDataCPU() {
         const { metadata } = this._cpuFallbackEnabledElement;
         const spacing = metadata.spacing;
+        const csImage = this.csImage;
         return {
             dimensions: metadata.dimensions,
             spacing,
@@ -505,11 +508,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: this.csImage.voxelManager,
+            voxelManager: csImage?.voxelManager,
         };
     }
     buildMetadata(image) {
@@ -588,15 +591,13 @@ class StackViewport extends Viewport {
         this.viewportStatus = this.csImage
             ? ViewportStatus.PRE_RENDER
             : ViewportStatus.LOADING;
-        if (this.globalDefaultProperties == null) {
-            this.setDefaultProperties({
-                colormap,
-                voiRange,
-                VOILUTFunction,
-                invert,
-                interpolationType,
-            });
-        }
+        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);
         }
@@ -672,8 +673,7 @@ class StackViewport extends Viewport {
         this.setInvertColor(false);
         this.render();
     }
-    _setPropertiesFromCache() {
-        const { interpolationType, invert } = this;
+    _getVOIFromCache() {
         let voiRange;
         if (this.voiUpdatedWithSetProperties) {
             voiRange = this.voiRange;
@@ -684,6 +684,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);
@@ -1045,33 +1050,35 @@ class StackViewport extends Viewport {
             imagePixelModule,
         };
     }
-    matchImagesForOverlay(currentImageId, referencedImageId) {
+    matchImagesForOverlay(currentImageId, targetOverlayImageId) {
         const matchImagesForOverlay = (targetImageId) => {
-            const referenceImagePlaneModule = metaData.get(MetadataModules.IMAGE_PLANE, referencedImageId);
+            const overlayImagePlaneModule = metaData.get(MetadataModules.IMAGE_PLANE, targetOverlayImageId);
             const currentImagePlaneModule = metaData.get(MetadataModules.IMAGE_PLANE, targetImageId);
-            const referenceOrientation = referenceImagePlaneModule.imageOrientationPatient;
+            const overlayOrientation = overlayImagePlaneModule.imageOrientationPatient;
             const currentOrientation = currentImagePlaneModule.imageOrientationPatient;
-            if (referenceOrientation && currentOrientation) {
-                const closeEnough = isEqual(referenceImagePlaneModule.imageOrientationPatient, currentImagePlaneModule.imageOrientationPatient);
+            if (overlayOrientation && currentOrientation) {
+                const closeEnough = isEqual(overlayImagePlaneModule.imageOrientationPatient, currentImagePlaneModule.imageOrientationPatient);
                 if (closeEnough) {
-                    const referencePosition = referenceImagePlaneModule.imagePositionPatient;
+                    const referencePosition = overlayImagePlaneModule.imagePositionPatient;
                     const currentPosition = currentImagePlaneModule.imagePositionPatient;
                     if (referencePosition && currentPosition) {
-                        const vector = vec3.create();
-                        vec3.subtract(vector, currentPosition, referencePosition);
-                        const viewPlaneNormal = vec3.create();
-                        vec3.cross(viewPlaneNormal, currentOrientation.slice(0, 3), currentOrientation.slice(3, 6));
-                        const dotProduct = vec3.dot(vector, viewPlaneNormal);
-                        const isOrthogonal = Math.abs(dotProduct) < EPSILON;
-                        if (isOrthogonal) {
-                            return targetImageId;
+                        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 = referenceImagePlaneModule.rows;
-                const referenceColumns = referenceImagePlaneModule.columns;
+                const referenceRows = overlayImagePlaneModule.rows;
+                const referenceColumns = overlayImagePlaneModule.columns;
                 const currentRows = currentImagePlaneModule.rows;
                 const currentColumns = currentImagePlaneModule.columns;
                 if (referenceRows === currentRows &&
@@ -1197,15 +1204,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) &&
-            dataType === image.voxelManager.getScalarData().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);
@@ -1416,7 +1429,7 @@ class StackViewport extends Viewport {
         throw new Error('Method not implemented.');
     }
     addImages(stackInputs) {
-        const actors = this.getActors();
+        const actors = [];
         stackInputs.forEach((stackInput) => {
             const { imageId } = stackInput;
             const image = cache.getImage(imageId);
@@ -1432,7 +1445,7 @@ class StackViewport extends Viewport {
             const imageActor = this.createActorMapper(imagedata);
             if (imageActor) {
                 actors.push({
-                    uid: stackInput.actorUID,
+                    uid: stackInput.actorUID ?? uuidv4(),
                     actor: imageActor,
                     referencedId: imageId,
                 });
@@ -1441,26 +1454,15 @@ class StackViewport extends Viewport {
                 }
             }
         });
-        this.setActors(actors);
+        this.addActors(actors);
     }
     _updateActorToDisplayImageId(image) {
         const sameImageData = this._checkVTKImageDataMatchesCornerstoneImage(image, this._imageData);
-        const activeCamera = this.getRenderer().getActiveCamera();
-        const previousCameraProps = 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;
@@ -1486,19 +1488,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) {
@@ -1635,24 +1638,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,
@@ -1726,10 +1711,10 @@ class StackViewport extends Viewport {
         }
         let { imageURI } = options;
         if (!imageURI) {
-            const colonIndex = currentImageId.indexOf(':');
-            imageURI = currentImageId.substring(colonIndex + 1);
+            imageURI = imageIdToURI(currentImageId);
         }
-        return referencedImageId?.endsWith(imageURI);
+        const referencedImageURI = imageIdToURI(referencedImageId);
+        return referencedImageURI === imageURI;
     }
     getViewReference(viewRefSpecifier = {}) {
         const { sliceIndex = this.getCurrentImageIdIndex() } = viewRefSpecifier;
@@ -1866,4 +1851,3 @@ class StackViewport extends Viewport {
     }
 }
 export default StackViewport;
-//# sourceMappingURL=StackViewport.js.map