@cornerstonejs/core 5.1.0 → 5.1.1

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/GenericViewport/GenericViewport.d.ts

@@ -1,6 +1,7 @@
 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 { 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';
@@ -39,11 +40,13 @@ declare abstract class GenericViewport<TViewState extends object, TDataPresentat
     setDisplaySetPresentation(props: Partial<TDataPresentation>): void;
     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;
@@ -66,6 +69,7 @@ declare abstract class GenericViewport<TViewState extends object, TDataPresentat
     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;
@@ -75,6 +79,7 @@ declare abstract class GenericViewport<TViewState extends object, TDataPresentat
     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) {
@@ -67,6 +68,9 @@ class GenericViewport {
     getDisplaySetPresentation(displaySetId) {
         return this.getDataPresentationState(displaySetId);
     }
+    getCurrentMode() {
+        return this.getSourceBinding() ? 'unknown' : 'empty';
+    }
     getViewReference(_specifier = {}) {
         return {
             FrameOfReferenceUID: this.getFrameOfReferenceUID(),
@@ -85,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) {
@@ -261,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;
     }
@@ -313,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

@@ -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,

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;