@cornerstonejs/core 5.1.0 → 5.1.2

package/dist/esm/RenderingEngine/GenericViewport/Planar/PlanarViewport.js

@@ -1,5 +1,6 @@
 import { Events, OrientationAxis, ViewportStatus, ViewportType, VOILUTFunctionType, } from '../../../enums';
 import { ActorRenderMode } from '../../../types';
+import { isImageActor } from '../../../utilities/actorCheck';
 import cache from '../../../cache/cache';
 import { deepClone } from '../../../utilities/deepClone';
 import imageIdToURI from '../../../utilities/imageIdToURI';
@@ -13,6 +14,7 @@ import GenericViewport from '../GenericViewport';
 import { getGenericViewportImageDisplaySet, isGenericViewportImageDisplaySet, } from '../genericViewportDisplaySetAccess';
 import { DefaultPlanarDataProvider } from './DefaultPlanarDataProvider';
 import { createPlanarRenderPathResolver } from './PlanarRenderPathResolver';
+import { defaultPlanarRenderPathDecisionService } from './PlanarRenderPathDecisionService';
 import { normalizePlanarOrientation, selectPlanarRenderPath, } from './planarRenderPathSelector';
 import { clonePlanarOrientation } from './planarLegacyCompatibility';
 import { normalizePlanarRotation } from './planarViewPresentation';
@@ -78,6 +80,7 @@ class PlanarViewport extends GenericViewport {
         this.element.style.position = this.element.style.position || 'relative';
         this.element.style.overflow = 'hidden';
         this.element.style.background = this.element.style.background || '#000';
+        this.element.style.isolation = 'isolate';
         const vtkCanvas = args.canvas;
         const viewportElement = this.element.querySelector('.viewport-element');
         const cpuCanvas = document.createElement('canvas');
@@ -160,7 +163,7 @@ class PlanarViewport extends GenericViewport {
         const requestId = ++this.setDataRequestId;
         const isStale = () => requestId !== this.setDataRequestId;
         this.clearResolvedViewCache();
-        this.removeAllData();
+        this.removeReplaceableData(entries);
         for (const [index, { displaySetId, options = {} }] of entries.entries()) {
             if (isStale()) {
                 return;
@@ -201,6 +204,14 @@ class PlanarViewport extends GenericViewport {
         this.setDefaultDataPresentation(dataId, {
             visible: true,
         });
+        const mountedPresentation = this.getDisplaySetPresentation(dataId);
+        const voiRange = mountedPresentation?.voiRange ?? this.getDefaultVOIRange(dataId);
+        if (voiRange) {
+            this.notifyDataPresentationModified(dataId, { voiRange });
+        }
+        if (role === 'source') {
+            this.triggerCameraModifiedEvent(this.getCameraForEvent());
+        }
     }
     removeData(dataId) {
         this.clearResolvedViewCache();
@@ -216,6 +227,22 @@ class PlanarViewport extends GenericViewport {
     getDefaultActor() {
         return this.mountedData.getDefaultActor();
     }
+    getImageActor(volumeId) {
+        const actorEntries = this.getActors();
+        let actorEntry = actorEntries[0];
+        if (volumeId) {
+            actorEntry =
+                actorEntries.find((a) => a.referencedId === volumeId) ??
+                    this.mountedData.getActorForDataId(volumeId);
+        }
+        if (!actorEntry || !isImageActor(actorEntry)) {
+            return null;
+        }
+        return actorEntry.actor;
+    }
+    getDefaultImageData() {
+        return this.getImageActor()?.getMapper().getInputData();
+    }
     renderImageObject(image) {
         const dataId = `image-object:${this.id}:${imageIdToURI(image.imageId)}`;
         if (this.renderImageObjectDataId &&
@@ -297,6 +324,58 @@ class PlanarViewport extends GenericViewport {
     getSourceDataId() {
         return this.mountedData.getActiveDataId();
     }
+    getCurrentMode() {
+        const binding = this.getSourceBinding();
+        if (!binding) {
+            return 'empty';
+        }
+        const renderMode = binding.rendering.renderMode;
+        if (renderMode === ActorRenderMode.VTK_VOLUME ||
+            renderMode === ActorRenderMode.VTK_VOLUME_SLICE ||
+            renderMode === ActorRenderMode.CPU_VOLUME) {
+            return 'volume';
+        }
+        if (renderMode === ActorRenderMode.VTK_IMAGE ||
+            renderMode === ActorRenderMode.CPU_IMAGE) {
+            return 'stack';
+        }
+        return this.getVolumeId() ? 'volume' : 'stack';
+    }
+    notifyDataPresentationModified(displaySetId, props) {
+        if (this.suppressEvents) {
+            return;
+        }
+        const voiTouched = 'voiRange' in props || 'invert' in props || 'voiLUTFunction' in props;
+        const colormapTouched = 'colormap' in props;
+        if (!voiTouched && !colormapTouched) {
+            return;
+        }
+        const presentation = this.getDisplaySetPresentation(displaySetId);
+        const volumeId = this.getDataSet(displaySetId)?.volumeId ??
+            (displaySetId === this.getSourceDataId()
+                ? this.getVolumeId()
+                : undefined);
+        if (voiTouched) {
+            const range = props.voiRange ?? presentation?.voiRange;
+            if (range) {
+                triggerEvent(this.element, Events.VOI_MODIFIED, {
+                    viewportId: this.id,
+                    range,
+                    volumeId,
+                    VOILUTFunction: props.voiLUTFunction ?? presentation?.voiLUTFunction,
+                    invert: props.invert ?? presentation?.invert,
+                    colormap: presentation?.colormap,
+                });
+            }
+        }
+        if (colormapTouched && props.colormap) {
+            triggerEvent(this.element, Events.COLORMAP_MODIFIED, {
+                viewportId: this.id,
+                colormap: props.colormap,
+                volumeId,
+            });
+        }
+    }
     getDefaultVOIRange(dataId) {
         return this.mountedData.getDefaultVOIRange(dataId);
     }
@@ -309,6 +388,25 @@ class PlanarViewport extends GenericViewport {
     getSliceIndex() {
         return this.getCurrentImageIdIndex();
     }
+    getNumberOfSlices() {
+        const imageCount = this.getImageIds().length;
+        if (!imageCount) {
+            return 0;
+        }
+        return this.getMaxImageIdIndex() + 1;
+    }
+    calibrateSpacing(imageId) {
+        this.render();
+        const cpuImageData = this.getImageData();
+        triggerEvent(this.element, Events.IMAGE_SPACING_CALIBRATED, {
+            element: this.element,
+            viewportId: this.id,
+            renderingEngineId: this.renderingEngineId,
+            imageId,
+            calibration: cpuImageData?.calibration,
+            imageData: cpuImageData?.imageData,
+        });
+    }
     normalizeViewState(viewState) {
         return normalizePlanarViewState(viewState);
     }
@@ -546,6 +644,19 @@ class PlanarViewport extends GenericViewport {
     setOrientation(orientation) {
         this.setViewState({ orientation: this.resolveSetOrientation(orientation) });
     }
+    canRenderOrientation(orientation, dataId) {
+        const targetDataId = dataId ?? this.getSourceDataId();
+        if (!targetDataId) {
+            return false;
+        }
+        const dataSet = this.getDataSet(targetDataId);
+        if (!dataSet) {
+            return false;
+        }
+        return defaultPlanarRenderPathDecisionService.canRender(dataSet, {
+            orientation: this.resolveSetOrientation(orientation),
+        });
+    }
     resetViewState(options) {
         const { resetPan = true, resetZoom = true, resetOrientation = true, resetFlip = true, } = options || {};
         const nextCamera = {
@@ -573,6 +684,22 @@ class PlanarViewport extends GenericViewport {
     resetViewStateForResize() {
         return this.resetViewState();
     }
+    resetDisplaySetPresentation(dataId) {
+        if (this.isDestroyed) {
+            return;
+        }
+        const targetDataId = dataId ?? this.getSourceDataId();
+        if (!targetDataId) {
+            return;
+        }
+        this.setDataPresentationState(targetDataId, {});
+        const defaultVOIRange = this.getDefaultVOIRange(targetDataId);
+        if (defaultVOIRange) {
+            this.notifyDataPresentationModified(targetDataId, {
+                voiRange: defaultVOIRange,
+            });
+        }
+    }
     getUseCustomRenderingPipeline() {
         return false;
     }
@@ -584,6 +711,7 @@ class PlanarViewport extends GenericViewport {
             return;
         }
         this.clearResolvedViewCache();
+        this.cachedCanvasDimensions = undefined;
         const { clientHeight, clientWidth } = this.element;
         const { canvas } = this.renderContext.cpu;
         const devicePixelRatio = window.devicePixelRatio || 1;
@@ -728,6 +856,12 @@ class PlanarViewport extends GenericViewport {
     }
     getActiveImageIdIndex() {
         const binding = this.getCurrentBinding();
+        if (this.getCurrentMode() === 'volume') {
+            const resolvedImageIdIndex = this.getResolvedView()?.state?.currentImageIdIndex;
+            if (typeof resolvedImageIdIndex === 'number') {
+                return resolvedImageIdIndex;
+            }
+        }
         const currentImageIdIndex = binding?.rendering?.currentImageIdIndex;
         if (typeof currentImageIdIndex === 'number') {
             return currentImageIdIndex;
@@ -757,6 +891,27 @@ class PlanarViewport extends GenericViewport {
     getCurrentBinding() {
         return this.mountedData.getCurrentBinding();
     }
+    removeReplaceableData(entries) {
+        const nextSourceId = this.resolveNextSourceId(entries);
+        const preserveSegmentationOverlays = nextSourceId !== undefined && nextSourceId === this.getSourceDataId();
+        for (const dataId of Array.from(this.bindings.keys())) {
+            if (preserveSegmentationOverlays &&
+                this.isSegmentationOverlayBinding(dataId)) {
+                continue;
+            }
+            this.removeData(dataId);
+        }
+    }
+    resolveNextSourceId(entries) {
+        const explicitSource = entries.find((entry) => entry.options?.role === 'source');
+        return explicitSource?.displaySetId ?? entries[0]?.displaySetId;
+    }
+    isSegmentationOverlayBinding(dataId) {
+        if (this.getDisplaySetRole(dataId) !== 'overlay') {
+            return false;
+        }
+        return this.getDataSet(dataId)?.reference?.kind === 'segmentation';
+    }
     getDataSet(dataId) {
         const dataSet = getGenericViewportImageDisplaySet(dataId);
         if (!isPlanarRegisteredDataSet(dataSet)) {
@@ -773,6 +928,7 @@ class PlanarViewport extends GenericViewport {
         const selectedPath = selectPlanarRenderPath(dataSet, {
             orientation: resolvedOrientation,
             cpuThresholds: options.cpuThresholds,
+            webGLAvailable: options.forceCPU ? false : undefined,
         });
         const data = await this.dataProvider.load(dataId, {
             acquisitionOrientation: selectedPath.acquisitionOrientation,
@@ -794,7 +950,7 @@ class PlanarViewport extends GenericViewport {
             ? this.createInitialVolumeSliceState(planarData, selectedPath.renderMode, orientation)
             : {
                 kind: 'stackIndex',
-                imageIdIndex: planarData.initialImageIdIndex,
+                imageIdIndex: planarData.initialImageIdIndex ?? 0,
             };
         this.clearResolvedViewCache();
         this.viewState = this.normalizeViewState({
@@ -934,6 +1090,20 @@ class PlanarViewport extends GenericViewport {
         }
         return snapshot;
     }
+    getCachedPlanarCanvasDimensions(rendering) {
+        const cached = this.cachedCanvasDimensions;
+        if (cached) {
+            return cached;
+        }
+        const dimensions = getPlanarViewStateCanvasDimensions({
+            renderContext: this.renderContext,
+            rendering,
+        });
+        if (dimensions.canvasHeight > 0 && dimensions.canvasWidth > 0) {
+            this.cachedCanvasDimensions = dimensions;
+        }
+        return dimensions;
+    }
     resolveCachedViewState(viewState, args = {}) {
         if (args.frameOfReferenceUID || typeof args.sliceIndex === 'number') {
             return this.resolveViewState(viewState, args);
@@ -946,10 +1116,7 @@ class PlanarViewport extends GenericViewport {
         if (!rendering) {
             return this.resolveViewState(viewState, args);
         }
-        const { canvasHeight, canvasWidth } = getPlanarViewStateCanvasDimensions({
-            renderContext: this.renderContext,
-            rendering,
-        });
+        const { canvasHeight, canvasWidth } = this.getCachedPlanarCanvasDimensions(rendering);
         if (cache &&
             cache.activeDataId === activeDataId &&
             cache.viewState === viewState &&
@@ -1073,10 +1240,7 @@ class PlanarViewport extends GenericViewport {
     getCurrentCanvasDimensions() {
         const rendering = this.getCurrentPlanarRendering();
         if (rendering) {
-            const { canvasHeight, canvasWidth } = getPlanarViewStateCanvasDimensions({
-                renderContext: this.renderContext,
-                rendering,
-            });
+            const { canvasHeight, canvasWidth } = this.getCachedPlanarCanvasDimensions(rendering);
             return {
                 width: canvasWidth || this.element.clientWidth,
                 height: canvasHeight || this.element.clientHeight,

package/dist/esm/RenderingEngine/GenericViewport/Planar/PlanarViewportTypes.d.ts

@@ -1,6 +1,6 @@
 import type vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
 import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
-import type { BlendModes, InterpolationType, OrientationAxis } from '../../../enums';
+import type { BlendModes, InterpolationType, OrientationAxis, VOILUTFunctionType } from '../../../enums';
 import type { ActorEntry, ActorRenderMode, ColormapPublic, IImage, IImageVolume, OrientationVectors, Point2, Point3, VOIRange } from '../../../types';
 import type { ViewportInput } from '../../../types/IViewport';
 import type ViewportInputOptions from '../../../types/ViewportInputOptions';
@@ -28,6 +28,7 @@ export interface PlanarSetDataOptions {
         image?: number;
         volume?: number;
     };
+    forceCPU?: boolean;
     role?: BindingRole;
 }
 export interface PlanarDataLoadOptions {
@@ -38,7 +39,7 @@ export interface PlanarDataLoadOptions {
 }
 export interface PlanarPayload {
     imageIds: string[];
-    initialImageIdIndex: number;
+    initialImageIdIndex?: number;
     volumeId: string;
     renderMode: PlanarEffectiveRenderMode;
     acquisitionOrientation?: PlanarViewState['orientation'];
@@ -51,6 +52,7 @@ export interface PlanarPayload {
 export interface PlanarPresentationProps extends BasePresentationProps {
     colormap?: ColormapPublic;
     voiRange?: VOIRange;
+    voiLUTFunction?: VOILUTFunctionType;
     invert?: boolean;
 }
 export type PlanarDisplayArea = Omit<DisplayArea, 'scale'> & {

package/dist/esm/RenderingEngine/GenericViewport/Planar/VtkImageMapperRenderPath.js

@@ -4,9 +4,10 @@ import { buildPlanarActorEntry } from './buildPlanarActorEntry';
 import uuidv4 from '../../../utilities/uuidv4';
 import { InterpolationType, MetadataModules, ViewportType, } from '../../../enums';
 import { loadAndCacheImage } from '../../../loaders/imageLoader';
+import { updateVTKImageDataWithCornerstoneImage } from '../../../utilities/updateVTKImageDataWithCornerstoneImage';
 import * as metaData from '../../../metaData';
 import { ActorRenderMode } from '../../../types';
-import { applyPlanarImagePresentation, createVTKImageDataFromImage, getDefaultImageVOIRange, } from '../../helpers/planarImageRendering';
+import { applyPlanarImagePresentation, createVTKImageDataFromImage, getDefaultImageVOIRange, updateVTKImageDataGeometryFromImage, } from '../../helpers/planarImageRendering';
 import { canvasToWorldContextPool, worldToCanvasContextPool, } from './planarAdapterCoordinateTransforms';
 import { buildPlanarImageData } from './CpuImageSliceRenderPath';
 import { triggerPlanarNewImage } from './planarImageEvents';
@@ -24,6 +25,9 @@ export class VtkImageMapperRenderPath {
         ctx.display.activateRenderMode(ActorRenderMode.VTK_IMAGE);
         mapper.setInputData(imageData);
         actor.setMapper(mapper);
+        if (imageData.getPointData().getScalars().getNumberOfComponents() > 1) {
+            actor.getProperty().setIndependentComponents(false);
+        }
         ctx.vtk.renderer.addActor(actor);
         const rendering = {
             renderMode: ActorRenderMode.VTK_IMAGE,
@@ -33,15 +37,17 @@ export class VtkImageMapperRenderPath {
             mapper,
             imageData,
             useWorldCoordinateImageData: payload.useWorldCoordinateImageData,
-            currentImageIdIndex: payload.initialImageIdIndex,
+            currentImageIdIndex: payload.initialImageIdIndex ?? 0,
             defaultVOIRange: getDefaultImageVOIRange(payload.image),
             dataPresentation: undefined,
             loadRequestId: 0,
         };
-        triggerPlanarNewImage(ctx, {
-            image: payload.image,
-            imageIdIndex: payload.initialImageIdIndex,
-        });
+        if (options.role !== 'overlay') {
+            triggerPlanarNewImage(ctx, {
+                image: payload.image,
+                imageIdIndex: payload.initialImageIdIndex ?? 0,
+            });
+        }
         return {
             rendering,
             updateDataPresentation: (props) => {
@@ -79,6 +85,7 @@ export class VtkImageMapperRenderPath {
         applyPlanarImagePresentation({
             actor: rendering.actor,
             defaultVOIRange: rendering.defaultVOIRange,
+            defaultVOILUTFunction: rendering.currentImage?.voiLUTFunction,
             props: {
                 interpolationType: InterpolationType.LINEAR,
                 ...dataPresentation,
@@ -215,8 +222,15 @@ async function updateRenderedImage(args) {
     const { ctx, dataId, image, rendering, imageIdIndex, dataPresentation } = args;
     const camera = ctx.viewport.getViewState();
     const { actor, mapper } = rendering;
-    const imageData = createVTKImageDataFromImage(image);
-    mapper.setInputData(imageData);
+    let imageData = rendering.imageData;
+    if (imageData && canReuseImageDataForImage(imageData, image)) {
+        updateVTKImageDataWithCornerstoneImage(imageData, image);
+        updateVTKImageDataGeometryFromImage(imageData, image);
+    }
+    else {
+        imageData = createVTKImageDataFromImage(image);
+        mapper.setInputData(imageData);
+    }
     rendering.currentImage = image;
     rendering.imageData = imageData;
     rendering.currentImageIdIndex = imageIdIndex;
@@ -228,6 +242,7 @@ async function updateRenderedImage(args) {
     applyPlanarImagePresentation({
         actor,
         defaultVOIRange: rendering.defaultVOIRange,
+        defaultVOILUTFunction: image.voiLUTFunction,
         props: {
             interpolationType: dataPresentation?.interpolationType ?? InterpolationType.LINEAR,
             ...dataPresentation,
@@ -248,9 +263,27 @@ async function updateRenderedImage(args) {
             });
         }
     }
-    triggerPlanarNewImage(ctx, { image, imageIdIndex });
+    if (projection?.isSourceBinding) {
+        triggerPlanarNewImage(ctx, { image, imageIdIndex });
+    }
     ctx.display.requestRender();
 }
+function canReuseImageDataForImage(imageData, image) {
+    const scalars = imageData.getPointData?.()?.getScalars?.();
+    if (!scalars) {
+        return false;
+    }
+    const [xVoxels, yVoxels] = imageData.getDimensions();
+    if (xVoxels !== image.columns || yVoxels !== image.rows) {
+        return false;
+    }
+    if (scalars.getDataType() !==
+        image.voxelManager.getScalarData().constructor.name) {
+        return false;
+    }
+    const incomingComponents = image.color ? 3 : 1;
+    return scalars.getNumberOfComponents() === incomingComponents;
+}
 function applyPlanarImageActorTransforms(ctx, rendering, activeSourceICamera) {
     applyPlanarICameraToActor({
         actor: rendering.actor,

package/dist/esm/RenderingEngine/GenericViewport/Planar/VtkVolumeSliceRenderPath.js

@@ -36,7 +36,7 @@ export class VtkVolumeSliceRenderPath {
             imageIds: payload.imageIds,
             acquisitionOrientation: payload.acquisitionOrientation,
             mapper,
-            currentImageIdIndex: payload.initialImageIdIndex,
+            currentImageIdIndex: payload.initialImageIdIndex ?? 0,
             maxImageIdIndex: payload.imageIds.length - 1,
             defaultVOIRange: defaultRange
                 ? { lower: defaultRange[0], upper: defaultRange[1] }
@@ -60,6 +60,7 @@ export class VtkVolumeSliceRenderPath {
             acquisitionOrientation: rendering.acquisitionOrientation,
             imageIds: rendering.imageIds,
             imageIdIndex: rendering.currentImageIdIndex,
+            maxImageIdIndex: rendering.maxImageIdIndex,
         });
         return {
             rendering,
@@ -154,6 +155,7 @@ export class VtkVolumeSliceRenderPath {
                 acquisitionOrientation: rendering.acquisitionOrientation,
                 imageIds: rendering.imageIds,
                 imageIdIndex: rendering.currentImageIdIndex,
+                maxImageIdIndex: rendering.maxImageIdIndex,
             });
         }
     }

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarImageEvents.d.ts

@@ -18,5 +18,6 @@ export declare function triggerPlanarVolumeNewImage(ctx: PlanarImageEventContext
     acquisitionOrientation?: PlanarViewState['orientation'];
     imageIds: string[];
     imageIdIndex: number | undefined;
+    maxImageIdIndex: number;
 }): void;
 export {};

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarImageEvents.js

@@ -22,7 +22,16 @@ export function triggerPlanarVolumeNewImage(ctx, params) {
             imageId: params.imageIds[params.imageIdIndex],
             imageIdIndex: params.imageIdIndex,
         });
-        return;
     }
-    triggerPlanarNewImage(ctx);
+    else {
+        triggerPlanarNewImage(ctx);
+    }
+    if (typeof params.imageIdIndex === 'number') {
+        triggerEvent(ctx.viewport.element, Events.VOLUME_NEW_IMAGE, {
+            imageIndex: params.imageIdIndex,
+            numberOfSlices: params.maxImageIdIndex + 1,
+            viewportId: ctx.viewportId,
+            renderingEngineId: ctx.renderingEngineId,
+        });
+    }
 }

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarVolumePresentation.js

@@ -61,7 +61,10 @@ function applyColormapOpacity(args) {
     if (colormap.opacity === undefined && colormap.threshold === undefined) {
         return;
     }
-    const range = resolveVolumeOpacityRange(actor, voiRange);
+    const range = colormap.threshold !== undefined
+        ? (getActorScalarRange(actor) ??
+            resolveVolumeOpacityRange(actor, voiRange))
+        : resolveVolumeOpacityRange(actor, voiRange);
     const opacityFunction = vtkPiecewiseFunction.newInstance();
     const points = buildColormapOpacityPoints({
         colormap,
@@ -75,7 +78,9 @@ function applyColormapOpacity(args) {
 }
 function buildColormapOpacityPoints(args) {
     const { colormap, range, fallbackOpacity } = args;
-    const delta = Math.max(Math.abs(range.upper - range.lower) * 0.001, 1e-3);
+    const span = range.upper - range.lower;
+    const delta = Math.max(Math.abs(span) * 0.001, 1e-3);
+    const toScalar = (normalized) => range.lower + normalized * span;
     const threshold = colormap.threshold !== undefined
         ? Math.max(range.lower, Math.min(range.upper, colormap.threshold))
         : undefined;
@@ -83,7 +88,7 @@ function buildColormapOpacityPoints(args) {
         const sortedPoints = colormap.opacity
             .map(({ opacity, value }) => ({
             opacity: clampToUnit(opacity),
-            value,
+            value: toScalar(value),
         }))
             .sort((a, b) => a.value - b.value);
         if (threshold === undefined) {
@@ -185,6 +190,28 @@ function getVolumeNumberOfComponents(actor) {
         imageDataMetadata?.numberOfComponents ??
         1);
 }
+function getActorScalarRange(actor) {
+    const mapperInputData = actor.getMapper()?.getInputData?.();
+    const voxelManager = mapperInputData?.get?.('voxelManager')?.voxelManager;
+    const voxelRange = voxelManager?.getRange?.();
+    if (voxelRange &&
+        Number.isFinite(voxelRange[0]) &&
+        Number.isFinite(voxelRange[1]) &&
+        voxelRange[1] > voxelRange[0]) {
+        return { lower: voxelRange[0], upper: voxelRange[1] };
+    }
+    const scalarRange = mapperInputData
+        ?.getPointData?.()
+        ?.getScalars?.()
+        ?.getRange?.();
+    if (scalarRange &&
+        Number.isFinite(scalarRange[0]) &&
+        Number.isFinite(scalarRange[1]) &&
+        scalarRange[1] > scalarRange[0]) {
+        return { lower: scalarRange[0], upper: scalarRange[1] };
+    }
+    return undefined;
+}
 function resolveVolumeOpacityRange(actor, voiRange) {
     if (voiRange &&
         Number.isFinite(voiRange.lower) &&

package/dist/esm/RenderingEngine/GenericViewport/Video/VideoViewport.d.ts

@@ -41,6 +41,7 @@ declare class VideoViewport extends GenericViewport<VideoViewState, VideoDataPre
     getCurrentImageIdIndex(): number;
     getImageIds(): string[];
     render(): void;
+    customRenderViewportToCanvas(): void;
     resetViewState(): boolean;
     dispose(): void;
     getUseCustomRenderingPipeline(): boolean;

package/dist/esm/RenderingEngine/GenericViewport/Video/VideoViewport.js

@@ -288,6 +288,9 @@ class VideoViewport extends GenericViewport {
             return;
         }
     }
+    customRenderViewportToCanvas() {
+        this.render();
+    }
     resetViewState() {
         if (this.isDestroyed) {
             return false;

package/dist/esm/RenderingEngine/GenericViewport/Volume3D/viewport3D.d.ts

@@ -41,7 +41,11 @@ declare class VolumeViewport3D extends GenericViewport<Volume3DCamera, Volume3DD
     getImageData(): IImageData | undefined;
     getActors(): ActorEntry[];
     getDefaultActor(): ActorEntry | undefined;
-    resetViewState(): boolean;
+    resetViewState(options?: {
+        resetPan?: boolean;
+        resetZoom?: boolean;
+        resetToCenter?: boolean;
+    }): boolean;
     resetViewStateForResize(): boolean;
     resize(): void;
     render(): void;

package/dist/esm/RenderingEngine/GenericViewport/Volume3D/viewport3D.js

@@ -25,6 +25,7 @@ class VolumeViewport3D extends GenericViewport {
         this.suppressEvents = false;
         this.renderingEngineId = args.renderingEngineId;
         this.canvas = args.canvas;
+        this.canvas.style.display = '';
         this.sWidth = args.sWidth;
         this.sHeight = args.sHeight;
         this.defaultOptions = args.defaultOptions || {};
@@ -230,11 +231,24 @@ class VolumeViewport3D extends GenericViewport {
         }
         return this.getActorEntriesForRendering(this.getVolume3DRendering(binding), data)[0];
     }
-    resetViewState() {
+    resetViewState(options) {
+        const { resetPan = true, resetZoom = true, resetToCenter = true, } = options || {};
         const previousCamera = this.getCameraForEvent();
         const renderer = this.getRenderer();
+        const camera = renderer.getActiveCamera();
+        const previousParallelScale = camera.getParallelScale();
+        const previousPosition = camera.getPosition();
+        const previousFocalPoint = camera.getFocalPoint();
         renderer.resetCamera();
         renderer.resetCameraClippingRange();
+        if (!resetZoom) {
+            camera.setParallelScale(previousParallelScale);
+        }
+        if (!resetPan || !resetToCenter) {
+            camera.setFocalPoint(...previousFocalPoint);
+            camera.setPosition(...previousPosition);
+            renderer.resetCameraClippingRange();
+        }
         this.viewState = this.getViewState();
         this.render();
         this.triggerCameraModifiedEvent(previousCamera);

package/dist/esm/RenderingEngine/GenericViewport/genericViewportReferenceCompatibility.js

@@ -189,15 +189,32 @@ function getReferencedImageRangeEndIndex(imageURIEntries, viewRef) {
     const rangeEndSliceIndex = imageURIEntries.findIndex((imageURIEntry) => imageURIEntryMatches(imageURIEntry, rangeEndImageURI));
     return rangeEndSliceIndex === -1 ? undefined : rangeEndSliceIndex;
 }
+const imageIdCompatibleURIsCache = new Map();
+const imageIdsURIEntriesCache = new WeakMap();
+function getImageIdsURIEntries(imageIds) {
+    let entries = imageIdsURIEntriesCache.get(imageIds);
+    if (!entries) {
+        entries = imageIds.map((imageId) => getImageIdCompatibleURIs(imageId));
+        imageIdsURIEntriesCache.set(imageIds, entries);
+    }
+    return entries;
+}
 function getContextImageURIEntries(context) {
-    const imageURIEntries = (context.imageIds || []).map((imageId) => getImageIdCompatibleURIs(imageId));
+    const baseEntries = context.imageIds?.length
+        ? getImageIdsURIEntries(context.imageIds)
+        : [];
+    const extraImageURIs = context.imageURIs;
+    if (!extraImageURIs?.length) {
+        return baseEntries;
+    }
+    const imageURIEntries = baseEntries.slice();
     const knownImageURIs = new Set();
-    for (const imageURIEntry of imageURIEntries) {
+    for (const imageURIEntry of baseEntries) {
         for (const imageURI of imageURIEntry) {
             knownImageURIs.add(imageURI);
         }
     }
-    for (const imageURI of context.imageURIs || []) {
+    for (const imageURI of extraImageURIs) {
         if (!knownImageURIs.has(imageURI)) {
             imageURIEntries.push([imageURI]);
             knownImageURIs.add(imageURI);
@@ -206,7 +223,12 @@ function getContextImageURIEntries(context) {
     return imageURIEntries;
 }
 function getImageIdCompatibleURIs(imageId) {
-    return uniqueStrings([imageIdToURI(imageId), getLegacyImageIdURI(imageId)]);
+    let uris = imageIdCompatibleURIsCache.get(imageId);
+    if (!uris) {
+        uris = uniqueStrings([imageIdToURI(imageId), getLegacyImageIdURI(imageId)]);
+        imageIdCompatibleURIsCache.set(imageId, uris);
+    }
+    return uris;
 }
 function getLegacyImageIdURI(imageId) {
     const colonIndex = imageId.indexOf(':');