@cornerstonejs/core 5.0.16 → 5.1.1

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

@@ -65,6 +65,10 @@ declare abstract class BaseVolumeViewport extends Viewport {
     getProperties: (volumeId?: string) => VolumeViewportProperties | undefined | null;
     private getColormap;
     setVolumes(volumeInputArray: IVolumeInput[], immediate?: boolean, suppressEvents?: boolean): Promise<void>;
+    setDisplaySets(...entries: Array<{
+        displaySetId: string;
+        options?: unknown;
+    }>): Promise<void>;
     addVolumes(volumeInputArray: IVolumeInput[], immediate?: boolean, suppressEvents?: boolean): Promise<void>;
     removeVolumeActors(actorUIDs: string[], immediate?: boolean): void;
     setOrientation(_orientation: OrientationAxis | OrientationVectors, _immediate?: boolean, _suppressEvents?: boolean): void;

package/dist/esm/RenderingEngine/BaseVolumeViewport.js

@@ -14,6 +14,9 @@ import transformWorldToIndex from '../utilities/transformWorldToIndex';
 import { findMatchingColormap, updateOpacity as colormapUpdateOpacity, updateThreshold as colormapUpdateThreshold, updateOpacityMapping as colormapUpdateOpacityMapping, getOpacityState, } from '../utilities/colormap';
 import getAcquisitionPlaneOrientation from '../utilities/getAcquisitionPlaneOrientation';
 import { getTransferFunctionNodes, setTransferFunctionNodes, } from '../utilities/transferFunctionUtils';
+import { createAndCacheVolume } from '../loaders/volumeLoader';
+import resolveViewportVolumeId from './helpers/resolveViewportVolumeId';
+import { getGenericViewportImageDisplaySet } from './GenericViewport/genericViewportDisplaySetAccess';
 import createVolumeActor from './helpers/createVolumeActor';
 import volumeNewImageEventDispatcher, { resetVolumeNewImageState, } from './helpers/volumeNewImageEventDispatcher';
 import Viewport from './Viewport';
@@ -912,6 +915,7 @@ class BaseVolumeViewport extends Viewport {
     }
     setSampleDistanceMultiplier(multiplier) { }
     async setVolumes(volumeInputArray, immediate = false, suppressEvents = false) {
+        this.clearDisplaySets();
         const volumeId = volumeInputArray[0].volumeId;
         const firstImageVolume = cache.getVolume(volumeId);
         if (!firstImageVolume) {
@@ -947,6 +951,26 @@ class BaseVolumeViewport extends Viewport {
             this.render();
         }
     }
+    async setDisplaySets(...entries) {
+        await this.mountDisplaySets(entries, async (entry) => {
+            const dataSet = getGenericViewportImageDisplaySet(entry.displaySetId);
+            if (!dataSet?.imageIds?.length) {
+                throw new Error(`[VolumeViewport] No registered imageIds for display set ${entry.displaySetId}`);
+            }
+            const volumeId = resolveViewportVolumeId(dataSet.volumeId ?? entry.displaySetId);
+            if (!cache.getVolume(volumeId)) {
+                const volume = await createAndCacheVolume(volumeId, {
+                    imageIds: dataSet.imageIds,
+                });
+                volume.load();
+            }
+            const volumeInput = {
+                volumeId,
+                ...(entry.options ?? {}),
+            };
+            await this.setVolumes([volumeInput]);
+        });
+    }
     async addVolumes(volumeInputArray, immediate = false, suppressEvents = false) {
         const firstImageVolume = cache.getVolume(volumeInputArray[0].volumeId);
         if (!firstImageVolume) {

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

@@ -10,6 +10,7 @@ declare class ContextPoolRenderingEngine extends BaseRenderingEngine {
     protected enableVTKjsDrivenViewport(viewportInputEntry: NormalizedViewportInput): void;
     protected addVtkjsDrivenViewport(viewportInputEntry: InternalViewportInput): void;
     protected setVtkjsDrivenViewports(viewportInputEntries: NormalizedViewportInput[]): void;
+    private _getDisplayedSize;
     protected _resizeVTKViewports(vtkDrivenViewports: IViewport[], keepCamera?: boolean, immediate?: boolean): void;
     protected _renderFlaggedViewports: () => void;
     private renderViewportUsingCustomOrVtkPipeline;

package/dist/esm/RenderingEngine/ContextPoolRenderingEngine.js

@@ -8,6 +8,7 @@ import ViewportType from '../enums/ViewportType';
 import viewportTypeUsesCustomRenderingPipeline, { viewportUsesCustomRenderingPipeline, } from './helpers/viewportTypeUsesCustomRenderingPipeline';
 import getOrCreateCanvas, { updateCanvasSizeAndAspectRatio, } from './helpers/getOrCreateCanvas';
 import { getViewportClassForInput } from './helpers/viewportTypeToViewportClass';
+import { isGenericViewport } from '../utilities/viewportCapabilities';
 class ContextPoolRenderingEngine extends BaseRenderingEngine {
     constructor(id) {
         super(id);
@@ -124,13 +125,21 @@ class ContextPoolRenderingEngine extends BaseRenderingEngine {
             }
         }
     }
-    _resizeVTKViewports(vtkDrivenViewports, keepCamera = true, immediate = true) {
+    _getDisplayedSize(vp) {
         const devicePixelRatio = window.devicePixelRatio || 1;
+        const sizeSource = isGenericViewport(vp)
+            ? vp.element
+            : getOrCreateCanvas(vp.element);
+        return {
+            displayedWidth: Math.round(sizeSource.clientWidth * devicePixelRatio),
+            displayedHeight: Math.round(sizeSource.clientHeight * devicePixelRatio),
+        };
+    }
+    _resizeVTKViewports(vtkDrivenViewports, keepCamera = true, immediate = true) {
         const viewportsNeedingResize = [];
         for (const vp of vtkDrivenViewports) {
             const canvas = getOrCreateCanvas(vp.element);
-            const displayedWidth = Math.round(canvas.clientWidth * devicePixelRatio);
-            const displayedHeight = Math.round(canvas.clientHeight * devicePixelRatio);
+            const { displayedWidth, displayedHeight } = this._getDisplayedSize(vp);
             if (displayedWidth === 0 || displayedHeight === 0) {
                 continue;
             }
@@ -146,9 +155,7 @@ class ContextPoolRenderingEngine extends BaseRenderingEngine {
             return;
         }
         for (const vp of viewportsNeedingResize) {
-            const canvas = getOrCreateCanvas(vp.element);
-            const displayedWidth = Math.round(canvas.clientWidth * devicePixelRatio);
-            const displayedHeight = Math.round(canvas.clientHeight * devicePixelRatio);
+            const { displayedWidth, displayedHeight } = this._getDisplayedSize(vp);
             const targetWidth = Math.max(VIEWPORT_MIN_SIZE, displayedWidth);
             const targetHeight = Math.max(VIEWPORT_MIN_SIZE, displayedHeight);
             vp.sWidth = targetWidth;
@@ -162,6 +169,9 @@ class ContextPoolRenderingEngine extends BaseRenderingEngine {
         }
         vtkDrivenViewports.forEach((vp) => {
             vp.resize?.();
+            if (isGenericViewport(vp)) {
+                return;
+            }
             const prevCamera = vp.getCamera();
             const rotation = vp.getRotation?.() ?? 0;
             const { flipHorizontal } = prevCamera;

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

@@ -19,6 +19,10 @@ declare class ECGViewport extends Viewport {
     private removeEventListeners;
     private elementDisabledHandler;
     setEcg(imageId: string): Promise<void>;
+    setDisplaySets(...entries: Array<{
+        displaySetId: string;
+        options?: unknown;
+    }>): Promise<void>;
     setChannelVisibility(index: number, visible: boolean): void;
     getVisibleChannels(): {
         name: string;

package/dist/esm/RenderingEngine/ECGViewport.js

@@ -3,6 +3,7 @@ import { Transform } from './helpers/cpuFallback/rendering/transform';
 import triggerEvent from '../utilities/triggerEvent';
 import Viewport from './Viewport';
 import { getOrCreateCanvas } from './helpers';
+import { getGenericViewportSourceDataId } from './GenericViewport/genericViewportDisplaySetAccess';
 import { ECG_CHANNEL_SPACING, computeECGChannelLayouts, computeECGHeight, drawECGGrid, drawECGLabels, drawECGTraces, ECG_RENDERING_COLORS, ECG_SECONDS_WIDTH, getVisibleECGChannelsByFlag, loadECGWaveform, } from '../utilities/ECGUtilities';
 const ECG_AMPLITUDE_INDEX_SIZE = 65536;
 class ECGViewport extends Viewport {
@@ -173,6 +174,7 @@ class ECGViewport extends Viewport {
         this.removeEventListeners();
     }
     async setEcg(imageId) {
+        this.clearDisplaySets();
         this.imageId = imageId;
         const { waveform, calibration } = await loadECGWaveform(imageId);
         this.channels = waveform.channels.map((channel) => ({
@@ -192,6 +194,12 @@ class ECGViewport extends Viewport {
         this.refreshRenderValues();
         this.renderFrame();
     }
+    async setDisplaySets(...entries) {
+        await this.mountDisplaySets(entries, async (entry) => {
+            const sourceDataId = getGenericViewportSourceDataId(entry.displaySetId);
+            await this.setEcg(sourceDataId);
+        });
+    }
     setChannelVisibility(index, visible) {
         if (index >= 0 && index < this.channels.length) {
             this.channels[index].visible = visible;

package/dist/esm/RenderingEngine/GenericViewport/ECG/DefaultECGDataProvider.js

@@ -1,5 +1,5 @@
 import { loadECGWaveform } from '../../../utilities/ECGUtilities';
-import { getGenericViewportSourceDataId } from '../genericViewportDataSetAccess';
+import { getGenericViewportSourceDataId } from '../genericViewportDisplaySetAccess';
 export class DefaultECGDataProvider {
     async load(dataId) {
         const sourceDataId = getGenericViewportSourceDataId(dataId);

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

@@ -1,7 +1,8 @@
 import type ICamera from '../../types/ICamera';
-import type { Point2, Point3 } from '../../types';
+import type { Point2, Point3, ViewportContentMode } from '../../types';
 import ViewportStatus from '../../enums/ViewportStatus';
-import type { BaseViewportRenderContext, BindingRole, DataAddOptions, DataId, DataProvider, LoadedData, ViewportDataBinding, RenderPathResolver, ViewportController, ViewportId } from './ViewportArchitectureTypes';
+import type { IRenderingEngine } from '../../types';
+import type { BaseViewportRenderContext, BindingRole, DataAddOptions, DisplaySetId, DataProvider, LoadedData, ViewportDataBinding, RenderPathResolver, ViewportController, ViewportId } from './ViewportArchitectureTypes';
 import type ViewportType from '../../enums/ViewportType';
 import type ResolvedViewportView from './ResolvedViewportView';
 import type { ReferenceCompatibleOptions, ViewReference, ViewReferenceSpecifier, RenderingEngineResizeOptions } from '../../types/IViewport';
@@ -27,19 +28,25 @@ declare abstract class GenericViewport<TViewState extends object, TDataPresentat
         element: HTMLDivElement;
     });
     setDisplaySets(...entries: Array<{
-        displaySetId: DataId;
+        displaySetId: DisplaySetId;
         options?: unknown;
     }>): Promise<void>;
-    addDisplaySet(displaySetId: DataId, options: DataAddOptions): Promise<void>;
-    removeData(displaySetId: DataId): void;
+    addDisplaySet(displaySetId: DisplaySetId, options: DataAddOptions): Promise<void>;
+    getDisplaySets(): Array<{
+        displaySetId: DisplaySetId;
+        options?: unknown;
+    }>;
+    removeData(displaySetId: DisplaySetId): void;
     setDisplaySetPresentation(props: Partial<TDataPresentation>): void;
-    setDisplaySetPresentation(displaySetId: DataId, props: Partial<TDataPresentation>): void;
-    getDisplaySetPresentation(displaySetId: DataId): TDataPresentation | undefined;
+    setDisplaySetPresentation(displaySetId: DisplaySetId, props: Partial<TDataPresentation>): void;
+    getDisplaySetPresentation(displaySetId: DisplaySetId): TDataPresentation | undefined;
+    getCurrentMode(): ViewportContentMode;
     getViewReference(_specifier?: ViewReferenceSpecifier): ViewReference;
     getViewReferenceId(_specifier?: ViewReferenceSpecifier): string;
     setViewReference(_viewReference: ViewReference): void;
     isReferenceViewable(viewReference: ViewReference, options?: ReferenceCompatibleOptions): boolean;
     getFrameOfReferenceUID(): string;
+    getRenderingEngine(): IRenderingEngine;
     abstract getResolvedView(): ResolvedViewportView<unknown, ICamera<unknown>> | undefined;
     canvasToWorld(canvasPos: Point2): Point3;
     worldToCanvas(worldPos: Point3): Point2;
@@ -56,21 +63,23 @@ declare abstract class GenericViewport<TViewState extends object, TDataPresentat
     resize(): void;
     resetViewState(_options?: unknown): boolean;
     resizeForRenderingEngine({ keepCamera, }?: RenderingEngineResizeOptions): void;
-    protected addLoadedData(displaySetId: DataId, data: LoadedData, options: DataAddOptions, shouldIgnore?: () => boolean): Promise<boolean>;
+    protected addLoadedData(displaySetId: DisplaySetId, data: LoadedData, options: DataAddOptions, shouldIgnore?: () => boolean): Promise<boolean>;
     protected removeAllData(): void;
-    protected setDataPresentationState(displaySetId: DataId, props: TDataPresentation): void;
-    protected getDataPresentationState(displaySetId: DataId): TDataPresentation | undefined;
-    protected setDefaultDataPresentation(displaySetId: DataId, defaults: TDataPresentation): TDataPresentation;
-    protected mergeDataPresentation(displaySetId: DataId, props: Partial<TDataPresentation>): TDataPresentation;
+    protected setDataPresentationState(displaySetId: DisplaySetId, props: TDataPresentation): void;
+    protected getDataPresentationState(displaySetId: DisplaySetId): TDataPresentation | undefined;
+    protected setDefaultDataPresentation(displaySetId: DisplaySetId, defaults: TDataPresentation): TDataPresentation;
+    protected mergeDataPresentation(displaySetId: DisplaySetId, props: Partial<TDataPresentation>): TDataPresentation;
+    protected notifyDataPresentationModified(_displaySetId: DisplaySetId, _props: Partial<TDataPresentation>): void;
     protected normalizeViewState(viewState: TViewState): TViewState;
     protected modified(previousCamera?: ICamera): void;
     protected getCameraForEvent(): ICamera;
     protected triggerCameraModifiedEvent(previousCamera: ICamera): void;
     protected triggerCameraResetEvent(): void;
-    protected getBinding(displaySetId: DataId): ViewportDataBinding<TDataPresentation> | undefined;
-    protected getDisplaySetRenderMode(displaySetId: DataId): string | undefined;
-    protected getDisplaySetRole(displaySetId: DataId): BindingRole | undefined;
+    protected getBinding(displaySetId: DisplaySetId): ViewportDataBinding<TDataPresentation> | undefined;
+    protected getDisplaySetRenderMode(displaySetId: DisplaySetId): string | undefined;
+    protected getDisplaySetRole(displaySetId: DisplaySetId): BindingRole | undefined;
     protected getFirstBinding(): ViewportDataBinding<TDataPresentation> | undefined;
+    protected getSourceBinding(): ViewportDataBinding<TDataPresentation> | undefined;
     protected getCurrentBinding(): ViewportDataBinding<TDataPresentation> | undefined;
     protected forEachBinding(visitor: (binding: ViewportDataBinding<TDataPresentation>) => void): void;
     protected getReferenceViewContexts(_viewReference?: ViewReference): GenericViewportReferenceContext[];

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

@@ -1,6 +1,7 @@
 import Events from '../../enums/Events';
 import ViewportStatus from '../../enums/ViewportStatus';
 import triggerEvent from '../../utilities/triggerEvent';
+import renderingEngineCache from '../renderingEngineCache';
 import { isGenericViewportReferenceViewable, } from './genericViewportReferenceCompatibility';
 class GenericViewport {
     constructor(args) {
@@ -34,6 +35,12 @@ class GenericViewport {
         const data = await this.dataProvider.load(displaySetId, options);
         await this.addLoadedData(displaySetId, data, options);
     }
+    getDisplaySets() {
+        return Array.from(this.bindings.entries()).map(([displaySetId, binding]) => ({
+            displaySetId,
+            options: { role: binding.role },
+        }));
+    }
     removeData(displaySetId) {
         const binding = this.bindings.get(displaySetId);
         if (!binding) {
@@ -61,6 +68,9 @@ class GenericViewport {
     getDisplaySetPresentation(displaySetId) {
         return this.getDataPresentationState(displaySetId);
     }
+    getCurrentMode() {
+        return this.getSourceBinding() ? 'unknown' : 'empty';
+    }
     getViewReference(_specifier = {}) {
         return {
             FrameOfReferenceUID: this.getFrameOfReferenceUID(),
@@ -79,6 +89,9 @@ class GenericViewport {
         return (this.getResolvedView()?.getFrameOfReferenceUID() ??
             `${this.type}-viewport-${this.id}`);
     }
+    getRenderingEngine() {
+        return renderingEngineCache.get(this.renderingEngineId);
+    }
     canvasToWorld(canvasPos) {
         const cc = this.getResolvedView();
         if (!cc) {
@@ -255,8 +268,13 @@ class GenericViewport {
             ...props,
         };
         this.setDataPresentationState(displaySetId, nextPresentation);
+        if (this.bindings.has(displaySetId)) {
+            this.notifyDataPresentationModified(displaySetId, props);
+        }
         return nextPresentation;
     }
+    notifyDataPresentationModified(_displaySetId, _props) {
+    }
     normalizeViewState(viewState) {
         return viewState;
     }
@@ -307,6 +325,14 @@ class GenericViewport {
     getFirstBinding() {
         return this.bindings.values().next().value;
     }
+    getSourceBinding() {
+        for (const binding of this.bindings.values()) {
+            if (binding.role === 'source') {
+                return binding;
+            }
+        }
+        return this.getFirstBinding();
+    }
     getCurrentBinding() {
         return this.getFirstBinding();
     }

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

@@ -28,6 +28,7 @@ export class CpuImageSliceRenderPath {
         }
         ctx.display.activateRenderMode(ActorRenderMode.CPU_IMAGE);
         let rendering;
+        markCpuImagePreScaled(payload.image);
         const compatibilityActor = new CanvasActor({
             getImageData: () => this.getImageData(rendering),
         }, payload.image);
@@ -47,7 +48,7 @@ export class CpuImageSliceRenderPath {
             actorEntryUID: uuidv4(),
             enabledElement,
             compatibilityActor,
-            currentImageIdIndex: payload.initialImageIdIndex,
+            currentImageIdIndex: payload.initialImageIdIndex ?? 0,
             defaultVOIRange: getDefaultImageVOIRange(payload.image),
             dataPresentation: undefined,
             fitScale: getCPUFallbackScalarScale(enabledElement.viewport.scale),
@@ -56,7 +57,7 @@ export class CpuImageSliceRenderPath {
         };
         triggerPlanarNewImage(ctx, {
             image: payload.image,
-            imageIdIndex: payload.initialImageIdIndex,
+            imageIdIndex: payload.initialImageIdIndex ?? 0,
         });
         return {
             rendering,
@@ -355,9 +356,16 @@ function worldToCPUImageDrawPoint(enabledElement, worldPos) {
             sourceY,
     ];
 }
+function markCpuImagePreScaled(image) {
+    image.isPreScaled = image.preScale?.scaled;
+}
 export function buildPlanarImageData(image, frameOfReferenceUID) {
     const metadata = getImageDataMetadata(image);
-    const { calibration, dimensions, direction, modality, origin, spacing } = metadata;
+    const { dimensions, direction, modality, origin, spacing } = metadata;
+    const userCalibration = metaData.get('calibratedPixelSpacing', image.imageId);
+    const calibration = userCalibration
+        ? { ...metadata.calibration, ...userCalibration }
+        : metadata.calibration;
     const rowVector = direction.slice(0, 3);
     const columnVector = direction.slice(3, 6);
     const scalarData = image.voxelManager?.getScalarData() || image.getPixelData?.();
@@ -418,6 +426,7 @@ function renderCompatibilityOverlayActors(ctx) {
 async function updateRenderedImage(args) {
     const { ctx, dataId, image, imageIdIndex, props, rendering } = args;
     const enabledElement = rendering.enabledElement;
+    markCpuImagePreScaled(image);
     const camera = ctx.viewport.getViewState();
     const defaultViewport = getDefaultViewport(ctx.cpu.canvas, image);
     const previousViewport = enabledElement.viewport;

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

@@ -40,7 +40,7 @@ export class CpuVolumeSliceRenderPath {
             imageIds: payload.imageIds,
             acquisitionOrientation: payload.acquisitionOrientation,
             layerCanvas: createCanvas(null, ctx.cpu.canvas.width, ctx.cpu.canvas.height),
-            currentImageIdIndex: payload.initialImageIdIndex,
+            currentImageIdIndex: payload.initialImageIdIndex ?? 0,
             maxImageIdIndex: payload.imageIds.length - 1,
             defaultVOIRange,
             renderingInvalidated: true,
@@ -145,6 +145,7 @@ export class CpuVolumeSliceRenderPath {
             acquisitionOrientation: rendering.acquisitionOrientation,
             imageIds: rendering.imageIds,
             imageIdIndex: rendering.currentImageIdIndex,
+            maxImageIdIndex: rendering.maxImageIdIndex,
         });
         return {
             rendering,
@@ -361,6 +362,7 @@ export class CpuVolumeSliceRenderPath {
                 acquisitionOrientation: rendering.acquisitionOrientation,
                 imageIds: rendering.imageIds,
                 imageIdIndex: rendering.currentImageIdIndex,
+                maxImageIdIndex: rendering.maxImageIdIndex,
             });
         }
     }

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

@@ -2,7 +2,7 @@ import { loadAndCacheImage } from '../../../loaders/imageLoader';
 import { createAndCacheVolume } from '../../../loaders/volumeLoader';
 import { ActorRenderMode } from '../../../types';
 import resolveViewportVolumeId from '../../helpers/resolveViewportVolumeId';
-import { getGenericViewportPlanarDataSet } from '../genericViewportDataSetAccess';
+import { getGenericViewportPlanarDisplaySet } from '../genericViewportDisplaySetAccess';
 export class DefaultPlanarDataProvider {
     async load(dataId, options) {
         const dataSet = this.getDataSet(dataId);
@@ -16,6 +16,9 @@ export class DefaultPlanarDataProvider {
             throw new Error('[PlanarViewport] Cannot load an empty planar dataset');
         }
         const clampedImageIdIndex = Math.min(Math.max(0, dataSet.initialImageIdIndex ?? 0), dataSet.imageIds.length - 1);
+        const initialImageIdIndex = dataSet.initialImageIdIndex === undefined
+            ? undefined
+            : clampedImageIdIndex;
         if (options.renderMode === ActorRenderMode.VTK_VOLUME_SLICE ||
             options.renderMode === ActorRenderMode.CPU_VOLUME) {
             const volumeId = resolveViewportVolumeId(options.volumeId);
@@ -30,7 +33,7 @@ export class DefaultPlanarDataProvider {
                 id: dataId,
                 type: 'image',
                 imageIds,
-                initialImageIdIndex: clampedImageIdIndex,
+                initialImageIdIndex,
                 acquisitionOrientation: options.acquisitionOrientation,
                 imageData: dataSet.imageData,
                 imageVolume,
@@ -50,7 +53,7 @@ export class DefaultPlanarDataProvider {
             imageIds: dataSet.imageIds,
             image,
             imageData: dataSet.imageData,
-            initialImageIdIndex: clampedImageIdIndex,
+            initialImageIdIndex,
             acquisitionOrientation: options.acquisitionOrientation,
             reference: dataSet.reference,
             renderMode: options.renderMode,
@@ -59,7 +62,7 @@ export class DefaultPlanarDataProvider {
         };
     }
     getDataSet(dataId) {
-        const dataSet = getGenericViewportPlanarDataSet(dataId);
+        const dataSet = getGenericViewportPlanarDisplaySet(dataId);
         if (!isPlanarRegisteredDataSet(dataSet)) {
             return;
         }

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

@@ -4,7 +4,7 @@ import { ActorRenderMode } from '../../../types';
 import triggerEvent from '../../../utilities/triggerEvent';
 import { findMatchingColormap, getMaxOpacity, getThresholdValue, } from '../../../utilities/colormap';
 import { getTransferFunctionNodes } from '../../../utilities/transferFunctionUtils';
-import genericViewportDataSetMetadataProvider from '../../../utilities/genericViewportDataSetMetadataProvider';
+import genericViewportDisplaySetMetadataProvider from '../../../utilities/genericViewportDisplaySetMetadataProvider';
 import { clonePlanarLegacyProperties, mergePlanarLegacyProperties, clonePlanarOrientation, toPlanarDataPresentation, } from './planarLegacyCompatibility';
 import { mapSlabTypeToBlendMode } from './planarVolumeSliceBlendMode';
 export const PLANAR_LEGACY_PER_IMAGE_DEFAULT_PROPERTIES_LIMIT = 2048;
@@ -255,7 +255,7 @@ class PlanarLegacyCompatibilityController {
         return `__planar_v2__:${this.host.getViewportId()}:volume:${volumeId}`;
     }
     registerDataSet(dataId, dataSet) {
-        genericViewportDataSetMetadataProvider.add(dataId, dataSet);
+        genericViewportDisplaySetMetadataProvider.add(dataId, dataSet);
         this.managedDataIds.add(dataId);
     }
     async mountVolumes(volumeInputArray, replaceExisting, suppressEvents) {
@@ -507,7 +507,7 @@ class PlanarLegacyCompatibilityController {
     }
     unregisterDataId(dataId) {
         try {
-            genericViewportDataSetMetadataProvider.remove(dataId);
+            genericViewportDisplaySetMetadataProvider.remove(dataId);
         }
         finally {
             this.properties.delete(dataId);

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

@@ -17,6 +17,7 @@ export interface PlanarRenderPathDecisionOptions {
 }
 export declare class PlanarRenderPathDecisionService {
     select(dataSet: PlanarRegisteredDataSet, options?: PlanarRenderPathDecisionOptions): SelectedPlanarRenderPath;
+    canRender(dataSet: PlanarRegisteredDataSet, options?: PlanarRenderPathDecisionOptions): boolean;
     private selectImageRenderMode;
     private selectVolumeRenderMode;
     private shouldUseCPUForImage;

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

@@ -7,7 +7,7 @@ import { ActorRenderMode } from '../../../types';
 import { isValidVolume } from '../../../utilities/isValidVolume';
 import { getOrientationFromScanAxisNormal } from '../../helpers/getCameraVectors';
 export const DEFAULT_PLANAR_CPU_IMAGE_THRESHOLD = 64 * 1024 * 1024;
-export const DEFAULT_PLANAR_CPU_VOLUME_THRESHOLD = 64 * 1024 * 1024;
+export const DEFAULT_PLANAR_CPU_VOLUME_THRESHOLD = Number.POSITIVE_INFINITY;
 export class PlanarRenderPathDecisionService {
     select(dataSet, options = {}) {
         if (!dataSet.imageIds.length) {
@@ -32,12 +32,32 @@ export class PlanarRenderPathDecisionService {
             acquisitionOrientation,
             renderMode: useVolumePath
                 ? this.selectVolumeRenderMode(dataSet, options)
-                : this.selectImageRenderMode(dataSet, options),
+                : this.selectImageRenderMode(options),
             volumeId,
         };
     }
-    selectImageRenderMode(dataSet, options) {
-        return this.shouldUseCPUForImage(dataSet, options)
+    canRender(dataSet, options = {}) {
+        if (!dataSet.imageIds.length) {
+            return false;
+        }
+        const orientation = options.orientation || OrientationAxis.ACQUISITION;
+        const acquisitionOrientation = getPlanarAcquisitionOrientation(dataSet.imageIds);
+        const isAcquisitionPath = orientation === OrientationAxis.ACQUISITION ||
+            (acquisitionOrientation !== undefined &&
+                orientation === acquisitionOrientation);
+        const useVolumePath = isVolumeBackedDataSet(dataSet, isAcquisitionPath);
+        if (!isAcquisitionPath &&
+            !useVolumePath &&
+            !dataSet.useWorldCoordinateImageData) {
+            return false;
+        }
+        if (useVolumePath && !supportsVolumeRendering(dataSet)) {
+            return false;
+        }
+        return true;
+    }
+    selectImageRenderMode(options) {
+        return this.shouldUseCPUForImage(options)
             ? ActorRenderMode.CPU_IMAGE
             : ActorRenderMode.VTK_IMAGE;
     }
@@ -46,14 +66,11 @@ export class PlanarRenderPathDecisionService {
             ? ActorRenderMode.CPU_VOLUME
             : ActorRenderMode.VTK_VOLUME_SLICE;
     }
-    shouldUseCPUForImage(dataSet, options) {
+    shouldUseCPUForImage(options) {
         if (options.webGLAvailable === false) {
             return true;
         }
-        const configuredCpuThresholds = getConfiguredPlanarCpuThresholds();
-        return shouldUseCPU(dataSet.imageIds, options.cpuThresholds?.image ??
-            configuredCpuThresholds?.image ??
-            DEFAULT_PLANAR_CPU_IMAGE_THRESHOLD);
+        return getShouldUseCPURendering();
     }
     shouldUseCPUForVolume(dataSet, options) {
         if (options.webGLAvailable === false) {

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

@@ -1,5 +1,5 @@
 import { OrientationAxis, ViewportType, VOILUTFunctionType } from '../../../enums';
-import type { ActorEntry, ICamera, IImage, IStackInput, OrientationVectors, Point2, Point3, ReferenceCompatibleOptions, VOIRange, ViewReference, ViewReferenceSpecifier } from '../../../types';
+import type { ActorEntry, ICamera, IImage, IStackInput, ImageActor, OrientationVectors, Point2, Point3, ReferenceCompatibleOptions, VOIRange, ViewReference, ViewReferenceSpecifier, ViewportContentMode } from '../../../types';
 import type { PlaneRestriction } from '../../../types/IViewport';
 import type ViewportInputOptions from '../../../types/ViewportInputOptions';
 import GenericViewport from '../GenericViewport';
@@ -33,6 +33,7 @@ declare class PlanarViewport extends GenericViewport<PlanarViewState, PlanarData
     private renderImageObjectDataId?;
     private resolvedViewCache?;
     private resolvedViewCacheRevision;
+    private cachedCanvasDimensions?;
     private setDataRequestId;
     static get useCustomRenderingPipeline(): boolean;
     constructor(args: PlanarViewportInput);
@@ -45,6 +46,8 @@ declare class PlanarViewport extends GenericViewport<PlanarViewState, PlanarData
     removeData(dataId: string): void;
     getActors(): ActorEntry[];
     getDefaultActor(): ActorEntry | undefined;
+    getImageActor(volumeId?: string): ImageActor | null;
+    getDefaultImageData(): any;
     renderImageObject(image: IImage): Promise<void>;
     getCanvas(): HTMLCanvasElement;
     addImages(stackInputs: IStackInput[]): Promise<void>;
@@ -67,10 +70,14 @@ declare class PlanarViewport extends GenericViewport<PlanarViewState, PlanarData
     getImageIds(): string[];
     getVolumeId(viewRefSpecifier?: ViewReferenceSpecifier): string | undefined;
     getSourceDataId(): string | undefined;
+    getCurrentMode(): ViewportContentMode;
+    protected notifyDataPresentationModified(displaySetId: string, props: Partial<PlanarDataPresentation>): void;
     getDefaultVOIRange(dataId?: string): VOIRange | undefined;
     getCurrentImageIdIndex(): number;
     getCurrentImageId(viewRefSpecifier?: ViewReferenceSpecifier): string | undefined;
     getSliceIndex(): number;
+    getNumberOfSlices(): number;
+    calibrateSpacing(imageId: string): void;
     protected normalizeViewState(viewState: PlanarViewState): PlanarViewState;
     setViewState(viewStatePatch: Partial<PlanarViewState>): void;
     setDisplaySetPresentation(props: Partial<PlanarDataPresentation>): void;
@@ -112,8 +119,10 @@ declare class PlanarViewport extends GenericViewport<PlanarViewState, PlanarData
     setImageIdIndex(imageIdIndex: number): Promise<string>;
     scroll(delta: number): Promise<string>;
     setOrientation(orientation: PlanarSetOrientationInput): void;
+    canRenderOrientation(orientation: PlanarSetOrientationInput, dataId?: string): boolean;
     resetViewState(options?: PlanarResetViewStateOptions): boolean;
     resetViewStateForResize(): boolean;
+    resetDisplaySetPresentation(dataId?: string): void;
     getUseCustomRenderingPipeline(): boolean;
     setRendered(): void;
     resize(): void;
@@ -154,6 +163,9 @@ declare class PlanarViewport extends GenericViewport<PlanarViewState, PlanarData
     private getVolumeSliceWorldPointForImageIdIndex;
     private getPlanarData;
     protected getCurrentBinding(): import("./PlanarMountedData").PlanarDataBinding;
+    private removeReplaceableData;
+    private resolveNextSourceId;
+    private isSegmentationOverlayBinding;
     private getDataSet;
     private loadPlanarData;
     private applyLoadedPlanarViewState;
@@ -165,10 +177,11 @@ declare class PlanarViewport extends GenericViewport<PlanarViewState, PlanarData
     private resolveOverlayReference;
     private resolveOverlayDataId;
     protected findBindingDataIdByActorEntryUID(actorEntryUID: string): string | undefined;
-    protected findDataIdByVolumeId(volumeId: string): string | undefined;
+    findDataIdByVolumeId(volumeId: string): string | undefined;
     protected getCurrentPlanarRendering(): PlanarRendering | undefined;
     private resolveViewState;
     private getProjectionSnapshot;
+    private getCachedPlanarCanvasDimensions;
     private resolveCachedViewState;
     private clearResolvedViewCache;
     private resolveFrameOfReferenceUID;