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

package/dist/esm/RenderingEngine/VideoViewport.js

@@ -7,6 +7,8 @@ import Viewport from './Viewport';
 import { getOrCreateCanvas } from './helpers';
 import CanvasActor from './CanvasActor';
 import cache from '../cache/cache';
+import uuidv4 from '../utilities/uuidv4';
+import { pointInShapeCallback } from '../utilities/pointInShapeCallback';
 class VideoViewport extends Viewport {
     static { this.frameRangeExtractor = /(\/frames\/|[&?]frameNumber=)([^/&?]*)/i; }
     constructor(props) {
@@ -110,12 +112,14 @@ class VideoViewport extends Viewport {
             this.renderFrame();
         };
         this.renderFrame = () => {
+            const dpr = window.devicePixelRatio || 1;
             const transform = this.getTransform();
             const transformationMatrix = transform.getMatrix();
             const ctx = this.canvasContext;
             ctx.resetTransform();
-            ctx.transform(transformationMatrix[0], transformationMatrix[1], transformationMatrix[2], transformationMatrix[3], transformationMatrix[4], transformationMatrix[5]);
-            ctx.drawImage(this.videoElement, 0, 0, this.videoWidth || 1024, this.videoHeight || 1024);
+            ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+            ctx.transform(transformationMatrix[0] / dpr, transformationMatrix[1] / dpr, transformationMatrix[2] / dpr, transformationMatrix[3] / dpr, transformationMatrix[4] / dpr, transformationMatrix[5] / dpr);
+            ctx.drawImage(this.videoElement, 0, 0, this.videoWidth, this.videoHeight);
             for (const actor of this.getActors()) {
                 actor.actor.render(this, this.canvasContext);
             }
@@ -138,7 +142,7 @@ class VideoViewport extends Viewport {
                 time: this.videoElement.currentTime,
                 duration: this.videoElement.duration,
             });
-            this.initialRender();
+            this.initialRender?.();
             const frame = this.getFrameNumber();
             if (this.isPlaying) {
                 if (frame < this.frameRange[0]) {
@@ -225,7 +229,7 @@ class VideoViewport extends Viewport {
         };
     }
     setDataIds(imageIds, options) {
-        this.setVideo(imageIds[0], (options.viewReference.sliceIndex || 0) + 1);
+        this.setVideo(imageIds[0], (options.viewReference?.sliceIndex || 0) + 1);
     }
     setVideo(imageId, frameNumber) {
         this.imageId = Array.isArray(imageId) ? imageId[0] : imageId;
@@ -423,15 +427,24 @@ class VideoViewport extends Viewport {
         });
     }
     getScalarData() {
-        if (this.scalarData.frameNumber === this.getFrameNumber()) {
+        if (this.scalarData?.frameNumber === this.getFrameNumber()) {
             return this.scalarData;
         }
+        if (!this.videoElement ||
+            !this.videoElement.videoWidth ||
+            !this.videoElement.videoHeight) {
+            console.debug('Video not ready yet, returning empty scalar data');
+            const emptyData = new Uint8ClampedArray();
+            emptyData.getRange = () => [0, 255];
+            emptyData.frameNumber = -1;
+            return emptyData;
+        }
         const canvas = document.createElement('canvas');
-        canvas.width = this.videoWidth;
-        canvas.height = this.videoHeight;
+        canvas.width = this.videoElement.videoWidth;
+        canvas.height = this.videoElement.videoHeight;
         const context = canvas.getContext('2d');
         context.drawImage(this.videoElement, 0, 0);
-        const canvasData = context.getImageData(0, 0, this.videoWidth, this.videoHeight);
+        const canvasData = context.getImageData(0, 0, canvas.width, canvas.height);
         const scalarData = canvasData.data;
         scalarData.getRange = () => [0, 255];
         scalarData.frameNumber = this.getFrameNumber();
@@ -442,6 +455,22 @@ class VideoViewport extends Viewport {
         const { metadata } = this;
         const spacing = metadata.spacing;
         const imageData = {
+            getDirection: () => metadata.direction,
+            getDimensions: () => metadata.dimensions,
+            getRange: () => [0, 255],
+            getScalarData: () => this.getScalarData(),
+            getSpacing: () => metadata.spacing,
+            worldToIndex: (point) => {
+                const canvasPoint = this.worldToCanvas(point);
+                const pixelCoord = this.canvasToIndex(canvasPoint);
+                return [pixelCoord[0], pixelCoord[1], 0];
+            },
+            indexToWorld: (point, destPoint) => {
+                const canvasPoint = this.indexToCanvas([point[0], point[1]]);
+                return this.canvasToWorld(canvasPoint, destPoint);
+            },
+        };
+        const imageDataForReturn = {
             dimensions: metadata.dimensions,
             spacing,
             origin: metadata.origin,
@@ -452,20 +481,15 @@ class VideoViewport extends Viewport {
             },
             getScalarData: () => this.getScalarData(),
             scalarData: this.getScalarData(),
-            imageData: {
-                getDirection: () => metadata.direction,
-                getDimensions: () => metadata.dimensions,
-                getRange: () => [0, 255],
-                getScalarData: () => this.getScalarData(),
-                getSpacing: () => metadata.spacing,
-                worldToIndex: (point) => {
-                    const canvasPoint = this.worldToCanvas(point);
-                    const pixelCoord = this.canvasToIndex(canvasPoint);
-                    return [pixelCoord[0], pixelCoord[1], 0];
-                },
-                indexToWorld: (point, destPoint) => {
-                    const canvasPoint = this.indexToCanvas([point[0], point[1]]);
-                    return this.canvasToWorld(canvasPoint, destPoint);
+            imageData,
+            voxelManager: {
+                forEach: (callback, options) => {
+                    return pointInShapeCallback(options.imageData, {
+                        pointInShapeFn: options.isInObject ?? (() => true),
+                        callback: callback,
+                        boundsIJK: options.boundsIJK,
+                        returnPoints: options.returnPoints ?? false,
+                    });
                 },
             },
             hasPixelSpacing: this.hasPixelSpacing,
@@ -478,7 +502,7 @@ class VideoViewport extends Viewport {
             get: () => this.getScalarData(),
             enumerable: true,
         });
-        return imageData;
+        return imageDataForReturn;
     }
     hasImageURI(imageURI) {
         const framesMatch = imageURI.match(VideoViewport.frameRangeExtractor);
@@ -612,7 +636,7 @@ class VideoViewport extends Viewport {
         }
     }
     getViewReference(viewRefSpecifier) {
-        let sliceIndex = viewRefSpecifier.sliceIndex;
+        let sliceIndex = viewRefSpecifier?.sliceIndex ?? this.getSliceIndex();
         if (!sliceIndex) {
             sliceIndex = this.isPlaying
                 ? [this.frameRange[0] - 1, this.frameRange[1] - 1]
@@ -704,8 +728,9 @@ class VideoViewport extends Viewport {
         stackInputs.forEach((stackInput) => {
             const image = cache.getImage(stackInput.imageId);
             const imageActor = this.createActorMapper(image);
+            const uid = stackInput.actorUID ?? uuidv4();
             if (imageActor) {
-                actors.push({ uid: stackInput.actorUID, actor: imageActor });
+                actors.push({ uid, actor: imageActor });
                 if (stackInput.callback) {
                     stackInput.callback({
                         imageActor: imageActor,

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

@@ -77,7 +77,9 @@ declare class Viewport {
     setActors(actors: ActorEntry[]): void;
     _removeActor(actorUID: string): void;
     removeActors(actorUIDs: string[]): void;
-    addActors(actors: ActorEntry[], resetCameraPanAndZoom?: boolean): void;
+    addActors(actors: ActorEntry[], options?: {
+        resetCamera?: boolean;
+    }): void;
     addActor(actorEntry: ActorEntry): void;
     removeAllActors(): void;
     protected resetCameraNoEvent(): void;

package/dist/esm/RenderingEngine/Viewport.js

@@ -199,8 +199,7 @@ class Viewport {
     }
     setActors(actors) {
         this.removeAllActors();
-        const resetCameraPanAndZoom = true;
-        this.addActors(actors, resetCameraPanAndZoom);
+        this.addActors(actors, { resetCamera: true });
     }
     _removeActor(actorUID) {
         const actorEntry = this.getActor(actorUID);
@@ -217,7 +216,8 @@ class Viewport {
             this._removeActor(actorUID);
         });
     }
-    addActors(actors, resetCameraPanAndZoom = false) {
+    addActors(actors, options = {}) {
+        const { resetCamera = false } = options;
         const renderingEngine = this.getRenderingEngine();
         if (!renderingEngine || renderingEngine.hasBeenDestroyed) {
             console.warn('Viewport::addActors::Rendering engine has not been initialized or has been destroyed');
@@ -226,10 +226,13 @@ class Viewport {
         actors.forEach((actor) => {
             this.addActor(actor);
         });
-        this.resetCamera({
-            resetPan: resetCameraPanAndZoom,
-            resetZoom: resetCameraPanAndZoom,
-        });
+        const prevViewPresentation = this.getViewPresentation();
+        const prevViewRef = this.getViewReference();
+        this.resetCamera();
+        if (!resetCamera) {
+            this.setViewReference(prevViewRef);
+            this.setViewPresentation(prevViewPresentation);
+        }
     }
     addActor(actorEntry) {
         const { uid: actorUID, actor } = actorEntry;
@@ -498,6 +501,9 @@ class Viewport {
         this.fitToCanvasCamera = camera;
     }
     getPan(initialCamera = this.initialCamera) {
+        if (!initialCamera) {
+            return [0, 0];
+        }
         const activeCamera = this.getVtkActiveCamera();
         const focalPoint = activeCamera.getFocalPoint();
         const zero3 = this.canvasToWorld([0, 0]);
@@ -664,7 +670,7 @@ class Viewport {
             }
             if (cameraModifiedOutOfPlane || viewUpHasChanged) {
                 const actorEntry = this.getDefaultActor();
-                if (!actorEntry.actor) {
+                if (!actorEntry?.actor) {
                     return;
                 }
                 if (!actorIsA(actorEntry, 'vtkActor')) {

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

@@ -11,6 +11,7 @@ declare class VolumeViewport extends BaseVolumeViewport {
     getNumberOfSlices: () => number;
     addVolumes(volumeInputArray: IVolumeInput[], immediate?: boolean, suppressEvents?: boolean): Promise<void>;
     setOrientation(orientation: OrientationAxis | OrientationVectors, immediate?: boolean): void;
+    protected setCameraClippingRange(): void;
     private _getAcquisitionPlaneOrientation;
     private _setViewPlaneToAcquisitionPlane;
     setBlendMode(blendMode: BlendModes, filterActorUIDs?: any[], immediate?: boolean): void;
@@ -33,7 +34,6 @@ declare class VolumeViewport extends BaseVolumeViewport {
     getViewReference(viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
     resetProperties(volumeId?: string): void;
     private _resetProperties;
-    private setCameraClippingRange;
     getSlicesClippingPlanes(): {
         sliceIndex: number;
         planes: {

package/dist/esm/RenderingEngine/VolumeViewport.js

@@ -54,8 +54,7 @@ class VolumeViewport extends BaseVolumeViewport {
             if (!actorEntry || !actorIsA(actorEntry, 'vtkVolume')) {
                 return;
             }
-            const { uid } = actorEntry;
-            const volume = cache.getVolume(uid);
+            const volume = cache.getVolume(this.getVolumeId());
             if (!volume) {
                 return;
             }
@@ -68,7 +67,7 @@ class VolumeViewport extends BaseVolumeViewport {
                 console.warn('No image data found for calculating vtkPlanes.');
                 return [];
             }
-            const volumeId = actorEntry.uid;
+            const volumeId = this.getVolumeId();
             const imageVolume = cache.getVolume(volumeId);
             const camera = this.getCamera();
             const { focalPoint, position, viewPlaneNormal } = camera;
@@ -140,12 +139,21 @@ class VolumeViewport extends BaseVolumeViewport {
             this.render();
         }
     }
+    setCameraClippingRange() {
+        const activeCamera = this.getVtkActiveCamera();
+        if (activeCamera.getParallelProjection()) {
+            activeCamera.setClippingRange(activeCamera.getDistance(), activeCamera.getDistance() + this.getSlabThickness());
+        }
+        else {
+            activeCamera.setClippingRange(RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS, RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE);
+        }
+    }
     _getAcquisitionPlaneOrientation() {
         const actorEntry = this.getDefaultActor();
         if (!actorEntry) {
             return;
         }
-        const volumeId = actorEntry.uid;
+        const volumeId = this.getVolumeId();
         const imageVolume = cache.getVolume(volumeId);
         if (!imageVolume) {
             throw new Error(`imageVolume with id: ${volumeId} does not exist in cache`);
@@ -199,7 +207,6 @@ class VolumeViewport extends BaseVolumeViewport {
         }
         super.resetCamera({ resetPan, resetZoom, resetToCenter });
         const activeCamera = this.getVtkActiveCamera();
-        this.setCameraClippingRange();
         const viewPlaneNormal = activeCamera.getViewPlaneNormal();
         const focalPoint = activeCamera.getFocalPoint();
         const actorEntries = this.getActors();
@@ -258,7 +265,6 @@ class VolumeViewport extends BaseVolumeViewport {
         });
         const currentCamera = this.getCamera();
         this.updateClippingPlanesForActors(currentCamera);
-        this.setCameraClippingRange();
         this.triggerCameraModifiedEventIfNecessary(currentCamera, currentCamera);
         this.viewportProperties.slabThickness = slabThickness;
     }
@@ -366,9 +372,10 @@ class VolumeViewport extends BaseVolumeViewport {
             this.viewportProperties.slabThickness = undefined;
             this.updateClippingPlanesForActors(this.getCamera());
         }
-        const imageVolume = cache.getVolume(volumeActor.uid);
+        volumeId ||= this.getVolumeId();
+        const imageVolume = cache.getVolume(volumeId);
         if (!imageVolume) {
-            throw new Error(`imageVolume with id: ${volumeActor.uid} does not exist in cache`);
+            throw new Error(`imageVolume with id: ${volumeId} does not exist in cache`);
         }
         setDefaultVolumeVOI(volumeActor.actor, imageVolume);
         if (isImageActor(volumeActor)) {
@@ -392,15 +399,6 @@ class VolumeViewport extends BaseVolumeViewport {
         });
         triggerEvent(this.element, Events.VOI_MODIFIED, eventDetails);
     }
-    setCameraClippingRange() {
-        const activeCamera = this.getVtkActiveCamera();
-        if (activeCamera.getParallelProjection()) {
-            activeCamera.setClippingRange(activeCamera.getDistance(), activeCamera.getDistance() + this.getSlabThickness());
-        }
-        else {
-            activeCamera.setClippingRange(RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS, RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE);
-        }
-    }
     getSlicesClippingPlanes() {
         const focalPoints = this.getSlicePlaneCoordinates();
         const { viewPlaneNormal } = this.getCamera();

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

@@ -3,7 +3,7 @@ import type { ViewportInput } from '../types/IViewport';
 import BaseVolumeViewport from './BaseVolumeViewport';
 declare class VolumeViewport3D extends BaseVolumeViewport {
     constructor(props: ViewportInput);
-    resetCamera({ resetPan, resetZoom, resetToCenter, }: {
+    resetCamera({ resetPan, resetZoom, resetToCenter, }?: {
         resetPan?: boolean;
         resetZoom?: boolean;
         resetToCenter?: boolean;
@@ -14,6 +14,9 @@ declare class VolumeViewport3D extends BaseVolumeViewport {
     setSlabThickness(slabThickness: number, filterActorUIDs?: string[]): void;
     setBlendMode(blendMode: BlendModes, filterActorUIDs?: string[], immediate?: boolean): void;
     resetProperties(volumeId?: string): void;
+    resetCameraForResize: () => boolean;
+    getSliceIndex(): number;
+    protected setCameraClippingRange(): void;
     resetSlabThickness(): void;
 }
 export default VolumeViewport3D;

package/dist/esm/RenderingEngine/VolumeViewport3D.js

@@ -16,6 +16,13 @@ class VolumeViewport3D extends BaseVolumeViewport {
         this.getCurrentImageId = () => {
             return null;
         };
+        this.resetCameraForResize = () => {
+            return this.resetCamera({
+                resetPan: true,
+                resetZoom: true,
+                resetToCenter: true,
+            });
+        };
         const { parallelProjection, orientation } = this.options;
         const activeCamera = this.getVtkActiveCamera();
         if (parallelProjection != null) {
@@ -25,7 +32,7 @@ class VolumeViewport3D extends BaseVolumeViewport {
             this.applyViewOrientation(orientation);
         }
     }
-    resetCamera({ resetPan = true, resetZoom = true, resetToCenter = true, }) {
+    resetCamera({ resetPan = true, resetZoom = true, resetToCenter = true, } = {}) {
         super.resetCamera({ resetPan, resetZoom, resetToCenter });
         const activeCamera = this.getVtkActiveCamera();
         if (activeCamera.getParallelProjection()) {
@@ -54,9 +61,10 @@ class VolumeViewport3D extends BaseVolumeViewport {
             this.viewportProperties.slabThickness = undefined;
             this.updateClippingPlanesForActors(this.getCamera());
         }
-        const imageVolume = cache.getVolume(volumeActor.uid);
+        volumeId ||= this.getVolumeId();
+        const imageVolume = cache.getVolume(volumeId);
         if (!imageVolume) {
-            throw new Error(`imageVolume with id: ${volumeActor.uid} does not exist in cache`);
+            throw new Error(`imageVolume with id: ${volumeId} does not exist in cache`);
         }
         setDefaultVolumeVOI(volumeActor.actor, imageVolume);
         if (isImageActor(volumeActor)) {
@@ -68,6 +76,18 @@ class VolumeViewport3D extends BaseVolumeViewport {
         this.setCamera(this.initialCamera);
         triggerEvent(this.element, Events.VOI_MODIFIED, super.getVOIModifiedEventDetail(volumeId));
     }
+    getSliceIndex() {
+        return null;
+    }
+    setCameraClippingRange() {
+        const activeCamera = this.getVtkActiveCamera();
+        if (activeCamera.getParallelProjection()) {
+            activeCamera.setClippingRange(-RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE, RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE);
+        }
+        else {
+            activeCamera.setClippingRange(RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS, RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE);
+        }
+    }
     resetSlabThickness() {
         return null;
     }

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

@@ -52,7 +52,7 @@ declare class WSIViewport extends Viewport {
     getZoom(): any;
     setZoom(zoom: number): void;
     protected getTransform(): Transform;
-    getReferenceId(): string;
+    getViewReferenceId(): string;
     getCurrentImageIdIndex(): number;
 }
 export default WSIViewport;

package/dist/esm/RenderingEngine/WSIViewport.js

@@ -8,6 +8,7 @@ import { getOrCreateCanvas } from './helpers';
 import { EPSILON } from '../constants';
 import triggerEvent from '../utilities/triggerEvent';
 import { peerImport } from '../init';
+import { pointInShapeCallback } from '../utilities/pointInShapeCallback';
 const _map = Symbol.for('map');
 const EVENT_POSTRENDER = 'postrender';
 class WSIViewport extends Viewport {
@@ -186,7 +187,23 @@ class WSIViewport extends Viewport {
             return null;
         }
         const { spacing } = metadata;
-        return {
+        const imageData = {
+            getDirection: () => metadata.direction,
+            getDimensions: () => metadata.dimensions,
+            getRange: () => [0, 255],
+            getScalarData: () => this.getScalarData(),
+            getSpacing: () => metadata.spacing,
+            worldToIndex: (point) => {
+                const canvasPoint = this.worldToCanvas(point);
+                const pixelCoord = this.canvasToIndex(canvasPoint);
+                return [pixelCoord[0], pixelCoord[1], 0];
+            },
+            indexToWorld: (point) => {
+                const canvasPoint = this.indexToCanvas([point[0], point[1]]);
+                return this.canvasToWorld(canvasPoint);
+            },
+        };
+        const imageDataReturn = {
             dimensions: metadata.dimensions,
             spacing,
             numberOfComponents: 3,
@@ -196,29 +213,25 @@ class WSIViewport extends Viewport {
                 Modality: this.modality,
                 FrameOfReferenceUID: this.frameOfReferenceUID,
             },
-            imageData: {
-                getDirection: () => metadata.direction,
-                getDimensions: () => metadata.dimensions,
-                getRange: () => [0, 255],
-                getScalarData: () => this.getScalarData(),
-                getSpacing: () => metadata.spacing,
-                worldToIndex: (point) => {
-                    const canvasPoint = this.worldToCanvas(point);
-                    const pixelCoord = this.canvasToIndex(canvasPoint);
-                    return [pixelCoord[0], pixelCoord[1], 0];
-                },
-                indexToWorld: (point) => {
-                    const canvasPoint = this.indexToCanvas([point[0], point[1]]);
-                    return this.canvasToWorld(canvasPoint);
-                },
-            },
             hasPixelSpacing: this.hasPixelSpacing,
             calibration: this.calibration,
             preScale: {
                 scaled: false,
             },
             scalarData: this.getScalarData(),
+            imageData,
+            voxelManager: {
+                forEach: (callback, options) => {
+                    return pointInShapeCallback(options.imageData, {
+                        pointInShapeFn: options.isInObject ?? (() => true),
+                        callback: callback,
+                        boundsIJK: options.boundsIJK,
+                        returnPoints: options.returnPoints ?? false,
+                    });
+                },
+            },
         };
+        return imageDataReturn;
     }
     hasImageURI(imageURI) {
         return true;
@@ -404,7 +417,7 @@ class WSIViewport extends Viewport {
         transform.translate(-center[0], -center[1]);
         return transform;
     }
-    getReferenceId() {
+    getViewReferenceId() {
         return `imageId:${this.getCurrentImageId()}`;
     }
     getCurrentImageIdIndex() {

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

@@ -18,6 +18,8 @@ async function createVolumeActor(props, element, viewportId, suppressEvents = fa
     const volumeActor = vtkVolume.newInstance();
     volumeActor.setMapper(volumeMapper);
     const { numberOfComponents } = imageData.get('numberOfComponents');
+    const volumeProperty = volumeActor.getProperty();
+    volumeProperty.set({ viewportId: viewportId });
     if (numberOfComponents === 3) {
         volumeActor.getProperty().setIndependentComponents(false);
     }

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

@@ -44,24 +44,23 @@ function getVOIFromMetadata(imageVolume) {
         const voiLutModule = metaData.get('voiLutModule', imageId);
         if (voiLutModule?.windowWidth && voiLutModule.windowCenter) {
             const { windowWidth, windowCenter } = voiLutModule;
-            voi = {
-                windowWidth: Array.isArray(windowWidth) ? windowWidth[0] : windowWidth,
-                windowCenter: Array.isArray(windowCenter)
-                    ? windowCenter[0]
-                    : windowCenter,
-            };
+            const width = Array.isArray(windowWidth) ? windowWidth[0] : windowWidth;
+            const center = Array.isArray(windowCenter)
+                ? windowCenter[0]
+                : windowCenter;
+            if (width !== 0) {
+                voi = { windowWidth: width, windowCenter: center };
+            }
         }
     }
     else {
         voi = metadata.voiLut[0];
     }
-    if (voi) {
+    if (voi && (voi.windowWidth !== 0 || voi.windowCenter !== 0)) {
         const { lower, upper } = windowLevel.toLowHighRange(Number(voi.windowWidth), Number(voi.windowCenter));
-        return {
-            lower,
-            upper,
-        };
+        return { lower, upper };
     }
+    return undefined;
 }
 async function getVOIFromMiddleSliceMinMax(imageVolume) {
     const { imageIds } = imageVolume;

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

@@ -31,7 +31,7 @@ declare class Cache {
     getVolumeLoadObject: (volumeId: string) => IVolumeLoadObject | undefined;
     getGeometry: (geometryId: string) => IGeometry | undefined;
     getImage: (imageId: string) => IImage | undefined;
-    getVolume: (volumeId: string) => IImageVolume | undefined;
+    getVolume: (volumeId: string, allowPartialMatch?: boolean) => IImageVolume | undefined;
     getVolumes: () => IImageVolume[];
     filterVolumesByReferenceId: (volumeId: string) => IImageVolume[];
     removeImageLoadObject: (imageId: string) => void;

package/dist/esm/cache/cache.js

@@ -133,13 +133,15 @@ class Cache {
             cachedImage.timeStamp = Date.now();
             return cachedImage.image;
         };
-        this.getVolume = (volumeId) => {
+        this.getVolume = (volumeId, allowPartialMatch = false) => {
             if (volumeId === undefined) {
                 throw new Error('getVolume: volumeId must not be undefined');
             }
             const cachedVolume = this._volumeCache.get(volumeId);
             if (!cachedVolume) {
-                return;
+                return allowPartialMatch
+                    ? [...this._volumeCache.values()].find((cv) => cv.volumeId.includes(volumeId))?.volume
+                    : undefined;
             }
             cachedVolume.timeStamp = Date.now();
             return cachedVolume.volume;
@@ -277,6 +279,10 @@ class Cache {
             console.warn('The image was purged from the cache before it completed loading.');
             return;
         }
+        if (!image) {
+            console.warn('Image is undefined');
+            return;
+        }
         if (image.sizeInBytes === undefined || Number.isNaN(image.sizeInBytes)) {
             throw new Error('_putImageCommon: image.sizeInBytes must not be undefined');
         }

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

@@ -49,6 +49,8 @@ export default class StreamingDynamicImageVolume extends BaseStreamingImageVolum
         this.invalidateVolume(true);
         triggerEvent(eventTarget, Events.DYNAMIC_VOLUME_TIME_POINT_INDEX_CHANGED, {
             volumeId: this.volumeId,
+            timePointIndex: index,
+            numTimePoints: this.numTimePoints,
             imageIdGroupIndex: index,
             numImageIdGroups: this.numTimePoints,
             splittingTag: this.splittingTag,

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

@@ -26,7 +26,7 @@ declare enum Events {
     VOLUME_NEW_IMAGE = "CORNERSTONE_VOLUME_NEW_IMAGE",
     PRE_STACK_NEW_IMAGE = "CORNERSTONE_PRE_STACK_NEW_IMAGE",
     IMAGE_SPACING_CALIBRATED = "CORNERSTONE_IMAGE_SPACING_CALIBRATED",
-    VIEWPORT_NEW_IMAGE_SET = "CORNERSTONE_STACK_VIEWPORT_NEW_STACK",
+    VIEWPORT_NEW_IMAGE_SET = "CORNERSTONE_VIEWPORT_NEW_IMAGE_SET",
     STACK_VIEWPORT_SCROLL = "CORNERSTONE_STACK_VIEWPORT_SCROLL",
     GEOMETRY_CACHE_GEOMETRY_ADDED = "CORNERSTONE_GEOMETRY_CACHE_GEOMETRY_ADDED",
     VOLUME_VIEWPORT_SCROLL_OUT_OF_BOUNDS = "VOLUME_VIEWPORT_SCROLL_OUT_OF_BOUNDS",

package/dist/esm/enums/Events.js

@@ -27,7 +27,7 @@ var Events;
     Events["VOLUME_NEW_IMAGE"] = "CORNERSTONE_VOLUME_NEW_IMAGE";
     Events["PRE_STACK_NEW_IMAGE"] = "CORNERSTONE_PRE_STACK_NEW_IMAGE";
     Events["IMAGE_SPACING_CALIBRATED"] = "CORNERSTONE_IMAGE_SPACING_CALIBRATED";
-    Events["VIEWPORT_NEW_IMAGE_SET"] = "CORNERSTONE_STACK_VIEWPORT_NEW_STACK";
+    Events["VIEWPORT_NEW_IMAGE_SET"] = "CORNERSTONE_VIEWPORT_NEW_IMAGE_SET";
     Events["STACK_VIEWPORT_SCROLL"] = "CORNERSTONE_STACK_VIEWPORT_SCROLL";
     Events["GEOMETRY_CACHE_GEOMETRY_ADDED"] = "CORNERSTONE_GEOMETRY_CACHE_GEOMETRY_ADDED";
     Events["VOLUME_VIEWPORT_SCROLL_OUT_OF_BOUNDS"] = "VOLUME_VIEWPORT_SCROLL_OUT_OF_BOUNDS";

package/dist/esm/loaders/configuration/interleavedRetrieve.js

@@ -69,8 +69,5 @@ const interleavedRetrieveConfiguration = [
         requestType: RequestType.Thumbnail,
         retrieveType: 'multipleFinal',
     },
-    {
-        id: 'errorRetrieve',
-    },
 ];
 export default interleavedRetrieveConfiguration;

package/dist/esm/loaders/configuration/singleRetrieve.js

@@ -3,8 +3,5 @@ const singleRetrieveStages = [
         id: 'initialImages',
         retrieveType: 'single',
     },
-    {
-        id: 'errorRetrieve',
-    },
 ];
 export default singleRetrieveStages;