@cornerstonejs/core 5.1.0 → 5.1.1

package/dist/esm/RenderingEngine/helpers/planarImageRendering.d.ts

@@ -2,7 +2,7 @@ import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 import type vtkImageSlice from '@kitware/vtk.js/Rendering/Core/ImageSlice';
 import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
 import type vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
-import { InterpolationType } from '../../enums';
+import { InterpolationType, VOILUTFunctionType } from '../../enums';
 import type { ColormapPublic, IImage, Point3, VOIRange } from '../../types';
 export interface PlanarCameraState {
     focalPoint: Point3;
@@ -17,6 +17,7 @@ export interface PlanarImagePresentation {
     interpolationType?: InterpolationType;
     colormap?: ColormapPublic;
     voiRange?: VOIRange;
+    voiLUTFunction?: VOILUTFunctionType;
     invert?: boolean;
 }
 export interface PlanarImageViewState {
@@ -32,17 +33,20 @@ export declare function createEmptyVTKImageData(args: {
     spacing: Point3;
 }): vtkImageData;
 export declare function createVTKImageDataFromImage(image: IImage): vtkImageData;
+export declare function updateVTKImageDataGeometryFromImage(imageData: vtkImageData, image: IImage): void;
 export declare function getDefaultImageVOIRange(image: IImage): VOIRange | undefined;
 export declare function getPlanarCameraState(renderer: vtkRenderer): PlanarCameraState;
 export declare function applyPlanarImagePresentation(args: {
     actor: vtkImageSlice;
     defaultVOIRange?: VOIRange;
+    defaultVOILUTFunction?: VOILUTFunctionType;
     props?: PlanarImagePresentation;
 }): void;
 export declare function createPlanarRGBTransferFunction(args: {
     colormap?: ColormapPublic;
     invert?: boolean;
     voiRange: VOIRange;
+    voiLUTFunction?: VOILUTFunctionType;
 }): vtkColorTransferFunction;
 export declare function applyPlanarCameraViewState(args: {
     initialCamera: PlanarCameraState;

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

@@ -1,9 +1,11 @@
 import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
 import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
-import { InterpolationType } from '../../enums';
+import { InterpolationType, VOILUTFunctionType } from '../../enums';
 import createLinearRGBTransferFunction from '../../utilities/createLinearRGBTransferFunction';
+import createSigmoidRGBTransferFunction from '../../utilities/createSigmoidRGBTransferFunction';
 import getVOIRangeFromWindowLevel from '../../utilities/getVOIRangeFromWindowLevel';
+import isPTPrescaledWithSUV from '../../utilities/isPTPrescaledWithSUV';
 import { getImageDataMetadata } from '../../utilities/getImageDataMetadata';
 import invertRgbTransferFunction from '../../utilities/invertRgbTransferFunction';
 import { resolveColormap } from '../../utilities/colormap';
@@ -32,7 +34,7 @@ export function createEmptyVTKImageData(args) {
 }
 export function createVTKImageDataFromImage(image) {
     const { dimensions, direction, numberOfComponents, origin, spacing } = getImageDataMetadata(image);
-    const pixelArray = image.voxelManager.getScalarData();
+    const pixelArray = image.voxelManager.getScalarData().slice();
     const imageData = createEmptyVTKImageData({
         dimensions,
         direction: Array.from(direction),
@@ -44,7 +46,16 @@ export function createVTKImageDataFromImage(image) {
     updateVTKImageDataWithCornerstoneImage(imageData, image);
     return imageData;
 }
+export function updateVTKImageDataGeometryFromImage(imageData, image) {
+    const { direction, origin, spacing } = getImageDataMetadata(image);
+    imageData.setOrigin(origin);
+    imageData.setDirection(new Float32Array(Array.from(direction)));
+    imageData.setSpacing(spacing);
+}
 export function getDefaultImageVOIRange(image) {
+    if (isPTPrescaledWithSUV(image)) {
+        return { lower: 0, upper: 5 };
+    }
     return getVOIRangeFromWindowLevel(image.windowWidth, image.windowCenter, image.voiLUTFunction);
 }
 export function getPlanarCameraState(renderer) {
@@ -58,7 +69,7 @@ export function getPlanarCameraState(renderer) {
     };
 }
 export function applyPlanarImagePresentation(args) {
-    const { actor, defaultVOIRange, props } = args;
+    const { actor, defaultVOIRange, defaultVOILUTFunction, props } = args;
     const property = actor.getProperty();
     const voiRange = props?.voiRange ?? defaultVOIRange;
     if (props?.visible !== undefined) {
@@ -77,15 +88,18 @@ export function applyPlanarImagePresentation(args) {
         colormap: props?.colormap,
         invert: props?.invert,
         voiRange,
+        voiLUTFunction: props?.voiLUTFunction ?? defaultVOILUTFunction,
     });
     property.setUseLookupTableScalarRange(true);
     property.setRGBTransferFunction(0, transferFunction);
 }
 export function createPlanarRGBTransferFunction(args) {
-    const { colormap, invert, voiRange } = args;
+    const { colormap, invert, voiRange, voiLUTFunction } = args;
     const transferFunction = colormap?.name !== undefined
         ? createColormapTransferFunction(colormap, voiRange)
-        : createLinearRGBTransferFunction(voiRange);
+        : voiLUTFunction === VOILUTFunctionType.SAMPLED_SIGMOID
+            ? createSigmoidRGBTransferFunction(voiRange)
+            : createLinearRGBTransferFunction(voiRange);
     if (invert) {
         invertRgbTransferFunction(transferFunction);
     }

package/dist/esm/RenderingEngine/helpers/stats/RenderModesPanel.d.ts

@@ -7,6 +7,7 @@ export declare class RenderModesPanel implements Panel {
     setContent(entries: Array<{
         renderingEngineId: string;
         viewportId: string;
+        viewportType: string;
         bindings: RenderModePanelBinding[];
     }>): void;
 }
@@ -16,4 +17,7 @@ export type RenderModePanelBinding = {
     referencedId?: string;
     renderMode: string;
     role: 'source' | 'overlay' | 'data';
+    scalarType?: string;
+    scalarRange?: [number, number];
+    numberOfComponents?: number;
 };

package/dist/esm/RenderingEngine/helpers/stats/RenderModesPanel.js

@@ -61,11 +61,19 @@ export class RenderModesPanel {
             heading.title = viewportId;
             heading.style.cssText = `
         display:flex;
+        align-items:center;
         justify-content:space-between;
         gap:8px;
         margin-bottom:6px;
         color:#ffd84d;
         font-weight:700;
+      `;
+            const left = document.createElement('div');
+            left.style.cssText = `
+        display:flex;
+        align-items:center;
+        gap:6px;
+        min-width:0;
       `;
             const name = document.createElement('span');
             name.textContent = truncate(viewportId, 72);
@@ -75,7 +83,25 @@ export class RenderModesPanel {
         text-overflow:ellipsis;
         white-space:nowrap;
       `;
-            heading.appendChild(name);
+            left.appendChild(name);
+            if (entry.viewportType) {
+                const type = document.createElement('span');
+                type.textContent = entry.viewportType;
+                type.title = entry.viewportType;
+                type.style.cssText = `
+          flex:0 0 auto;
+          padding:2px 6px;
+          background:rgba(255, 204, 0, 0.14);
+          border:1px solid rgba(255, 204, 0, 0.4);
+          border-radius:3px;
+          color:#ffe08a;
+          font-size:${PANEL_CONFIG.FONT_SIZE}px;
+          font-weight:700;
+          letter-spacing:0.03em;
+        `;
+                left.appendChild(type);
+            }
+            heading.appendChild(left);
             const count = document.createElement('span');
             count.textContent = `${bindings.length} binding${bindings.length === 1 ? '' : 's'}`;
             count.style.cssText = `
@@ -184,9 +210,30 @@ function createBindingRow(binding) {
         binding.referencedId !== binding.actorUID) {
         appendField(fields, 'ref', binding.referencedId, 76);
     }
+    if (binding.scalarType) {
+        appendField(fields, 'type', formatScalarType(binding.scalarType, binding.numberOfComponents), 40);
+    }
+    if (binding.scalarRange) {
+        appendField(fields, 'range', formatScalarRange(binding.scalarRange), 56);
+    }
     row.appendChild(fields);
     return row;
 }
+function formatScalarType(scalarType, numberOfComponents) {
+    const friendly = scalarType.replace(/Array$/, '');
+    return numberOfComponents && numberOfComponents > 1
+        ? `${friendly} x${numberOfComponents}`
+        : friendly;
+}
+function formatScalarRange([min, max]) {
+    return `${formatScalarValue(min)} .. ${formatScalarValue(max)}`;
+}
+function formatScalarValue(value) {
+    if (Number.isInteger(value)) {
+        return String(value);
+    }
+    return Number(value.toFixed(2)).toString();
+}
 function appendField(parent, label, value, maxLength) {
     const field = document.createElement('div');
     field.style.cssText = `

package/dist/esm/RenderingEngine/helpers/stats/StatsOverlay.js

@@ -161,6 +161,7 @@ export class StatsOverlay {
                 entries.push({
                     renderingEngineId: renderingEngine.id,
                     viewportId: viewport.id,
+                    viewportType: viewport.type,
                     bindings: this.getViewportBindingDebugEntries(debugViewport, renderModes ?? {}),
                 });
             }
@@ -170,17 +171,32 @@ export class StatsOverlay {
     getViewportBindingDebugEntries(viewport, renderModes) {
         const actors = viewport.getActors?.() ?? [];
         const sourceDataId = viewport.getSourceDataId?.();
-        return Object.entries(renderModes).map(([dataId, renderMode]) => {
-            const role = resolveBindingRole(viewport, dataId, sourceDataId);
-            const actor = role === 'source'
-                ? viewport.getDefaultActor?.()
-                : findActorForDataId(actors, dataId);
+        const renderModeEntries = Object.entries(renderModes);
+        if (renderModeEntries.length) {
+            return renderModeEntries.map(([dataId, renderMode]) => {
+                const role = resolveBindingRole(viewport, dataId, sourceDataId);
+                const actor = role === 'source'
+                    ? viewport.getDefaultActor?.()
+                    : findActorForDataId(actors, dataId);
+                return {
+                    actorUID: actor?.uid,
+                    dataId,
+                    referencedId: actor?.referencedId,
+                    renderMode,
+                    role,
+                    ...getActorScalarInfo(actor),
+                };
+            });
+        }
+        return actors.map((actor) => {
+            const dataId = actor.representationUID ?? actor.uid ?? '';
             return {
-                actorUID: actor?.uid,
+                actorUID: actor.uid,
                 dataId,
-                referencedId: actor?.referencedId,
-                renderMode,
-                role,
+                referencedId: actor.referencedId,
+                renderMode: '-',
+                role: resolveBindingRole(viewport, dataId, sourceDataId),
+                ...getActorScalarInfo(actor),
             };
         });
     }
@@ -309,3 +325,44 @@ function findActorForDataId(actors, dataId) {
         actor.representationUID === dataId ||
         actor.referencedId === dataId);
 }
+function getActorScalarInfo(entry) {
+    const inputData = entry?.actor?.getMapper?.()?.getInputData?.();
+    if (!inputData) {
+        return {};
+    }
+    try {
+        const scalars = inputData.getPointData?.()?.getScalars?.();
+        if (scalars?.getDataType) {
+            const numberOfComponents = scalars.getNumberOfComponents?.() ?? 1;
+            const range = numberOfComponents > 1 ? scalars.getRange?.(0) : scalars.getRange?.();
+            return {
+                scalarType: scalars.getDataType(),
+                scalarRange: normalizeRange(range),
+                numberOfComponents,
+            };
+        }
+        const scalarData = inputData.getScalarData?.();
+        if (scalarData?.constructor?.name) {
+            const range = Number.isFinite(inputData.minPixelValue) &&
+                Number.isFinite(inputData.maxPixelValue)
+                ? [inputData.minPixelValue, inputData.maxPixelValue]
+                : undefined;
+            return {
+                scalarType: scalarData.constructor.name,
+                scalarRange: normalizeRange(range),
+            };
+        }
+    }
+    catch {
+    }
+    return {};
+}
+function normalizeRange(range) {
+    if (!range ||
+        range.length < 2 ||
+        !Number.isFinite(range[0]) ||
+        !Number.isFinite(range[1])) {
+        return undefined;
+    }
+    return [range[0], range[1]];
+}

package/dist/esm/init.js

@@ -17,7 +17,7 @@ const defaultConfig = {
         planar: {
             cpuThresholds: {
                 image: 64 * 1024 * 1024,
-                volume: 64 * 1024 * 1024,
+                volume: Infinity,
             },
             cpuVolume: {
                 useViewportSamplingForLinear: true,

package/dist/esm/types/IGenericViewport.d.ts

@@ -0,0 +1,24 @@
+import type { IViewport, ViewReference } from './IViewport';
+import type ICamera from './ICamera';
+import type ResolvedViewportView from '../RenderingEngine/GenericViewport/ResolvedViewportView';
+export type ViewportContentMode = 'stack' | 'volume' | 'volume3d' | 'video' | 'wholeSlide' | 'ecg' | 'empty' | 'unknown';
+export interface IGenericViewport extends IViewport {
+    setDisplaySets(...entries: Array<{
+        displaySetId: string;
+        options?: unknown;
+    }>): Promise<void>;
+    addDisplaySet(displaySetId: string, options: unknown): Promise<void>;
+    removeData(displaySetId: string): void;
+    setDisplaySetPresentation(props: unknown): void;
+    setDisplaySetPresentation(dataId: string, props: unknown): void;
+    getDisplaySetPresentation(displaySetId: string): unknown;
+    setViewState(viewStatePatch: unknown): void;
+    getViewState(): unknown;
+    updateViewState(updater: unknown): void;
+    resetViewState(options?: unknown): boolean;
+    getCurrentMode(): ViewportContentMode;
+    setViewReference(viewReference: ViewReference): void;
+    getResolvedView(): ResolvedViewportView<unknown, ICamera<unknown>> | undefined;
+    getCurrentImageId(): string | undefined;
+}
+export type { IGenericViewport as default };

package/dist/esm/types/ScalingDescriptor.d.ts

@@ -0,0 +1,5 @@
+interface ScalingDescriptor {
+    modality?: string;
+    isPreScaled: boolean;
+}
+export type { ScalingDescriptor };

package/dist/esm/types/index.d.ts

@@ -15,6 +15,8 @@ import type IStreamingVolumeProperties from './IStreamingVolumeProperties';
 import type CustomEventType from './CustomEventType';
 import type { LocalVolumeOptions } from './../loaders/volumeLoader';
 import type { IViewport, PublicViewportInput, ViewReferenceSpecifier, DataSetOptions, ReferenceCompatibleOptions, ViewReference, ViewPresentation, ViewPresentationSelector, ViewportInput, RenderingEngineResizeOptions } from './IViewport';
+import type IGenericViewport from './IGenericViewport';
+import type { ViewportContentMode } from './IGenericViewport';
 import type { VolumeActor, Actor, ActorEntry, ActorMapperProxy, ImageActor, ICanvasActor } from './IActor';
 import { ActorRenderMode } from './IActor';
 import type { IImageLoadObject, IVolumeLoadObject, IGeometryLoadObject } from './ILoadObject';
@@ -36,6 +38,7 @@ import type CPUIImageData from './CPUIImageData';
 import type { CPUImageData } from './CPUIImageData';
 import type IImage from './IImage';
 import type { PTScaling, Scaling, ScalingParameters } from './ScalingParameters';
+import type { ScalingDescriptor } from './ScalingDescriptor';
 import type StackViewportProperties from './StackViewportProperties';
 import type VolumeViewportProperties from './VolumeViewportProperties';
 import type IViewportId from './IViewportId';
@@ -112,5 +115,5 @@ import type { ResetCameraOptions } from './ICamera';
 import type { ViewportType, ViewportTypeConstants, ViewportTypeRegistry } from './ViewportTypeRegistry';
 export type * from './MetadataModuleTypes';
 export type * from './InstanceTypes';
-export type { Cornerstone3DConfig, IBaseStreamingImageVolume, ICamera, ResetCameraOptions, IStackViewport, IVideoViewport, IECGViewport, IWSIViewport, IVolumeViewport, IEnabledElement, ICache, IVolume, IViewportId, IImageVolume, ImageVolumeProps, IDynamicImageVolume, IRenderingEngine, ScalingParameters, PTScaling, IPointsManager, PolyDataPointConfiguration, Scaling, IStreamingImageVolume, IImage, IImageData, IImageCalibration, CPUIImageData, CPUImageData, EventTypes, ImageLoaderFn, VolumeLoaderFn, IRegisterImageLoader, IStreamingVolumeProperties, IViewport, ViewReference, DataSetOptions as ImageSetOptions, ViewPresentation, ViewPresentationSelector, ReferenceCompatibleOptions, ViewReferenceSpecifier, RenderingEngineResizeOptions, StackViewportProperties, VolumeViewportProperties, ViewportProperties, PublicViewportInput, VolumeActor, Actor, ActorEntry, ActorMapperProxy, ImageActor, ICanvasActor, IImageLoadObject, IVolumeLoadObject, IVolumeInput, VolumeInputCallback, IStackInput, StackInputCallback, ViewportPreset, Metadata, OrientationVectors, AABB2, AABB3, Point2, Point3, PointsXYZ, Point4, Mat3, Plane, ViewportInputOptions, VideoViewportProperties, WSIViewportProperties, VOIRange, VOI, DisplayArea, FlipDirection, ICachedImage, ICachedVolume, CPUFallbackEnabledElement, CPUFallbackViewport, CPUFallbackTransform, CPUFallbackColormapData, CPUFallbackViewportDisplayedArea, CPUFallbackColormapsData, CPUFallbackColormap, TransformMatrix2D, CPUFallbackLookupTable, CPUFallbackLUT, CPUFallbackRenderingTools, CustomEventType, ActorSliceRange, ImageSliceData, IGeometry, IGeometryLoadObject, ICachedGeometry, PublicContourSetData, ContourSetData, ContourData, IContourSet, IContour, PublicSurfaceData, SurfaceData, ISurface, PublicMeshData, MeshData, IMesh, RGB, ColormapPublic, ColormapRegistration, PixelDataTypedArray, PixelDataTypedArrayString, ImagePixelModule, ImagePlaneModule, AffineMatrix, ImageLoadListener, InternalVideoCamera, VideoViewportInput, InternalECGCamera, ECGViewportInput, ECGChannel, ECGWaveformData, ECGViewportProperties, BoundsIJK, BoundsLPS, Color, ColorLUT, VolumeProps, IImageFrame, LocalVolumeOptions, IVoxelManager, IRLEVoxelMap, RLERun, ViewportInput, ImageLoadRequests, IBaseVolumeViewport, GeometryLoaderFn, ScrollOptions, JumpToSliceOptions, Memo, HistoryMemo, VoxelManager, RLEVoxelMap, RenderingEngineModeType, VtkOffscreenMultiRenderWindow, ViewportDataReference, ViewportType, ViewportTypeRegistry, ViewportTypeConstants, };
+export type { Cornerstone3DConfig, IBaseStreamingImageVolume, ICamera, ResetCameraOptions, IStackViewport, IVideoViewport, IECGViewport, IWSIViewport, IVolumeViewport, IEnabledElement, ICache, IVolume, IViewportId, IImageVolume, ImageVolumeProps, IDynamicImageVolume, IRenderingEngine, ScalingParameters, ScalingDescriptor, PTScaling, IPointsManager, PolyDataPointConfiguration, Scaling, IStreamingImageVolume, IImage, IImageData, IImageCalibration, CPUIImageData, CPUImageData, EventTypes, ImageLoaderFn, VolumeLoaderFn, IRegisterImageLoader, IStreamingVolumeProperties, IViewport, IGenericViewport, ViewportContentMode, ViewReference, DataSetOptions as ImageSetOptions, ViewPresentation, ViewPresentationSelector, ReferenceCompatibleOptions, ViewReferenceSpecifier, RenderingEngineResizeOptions, StackViewportProperties, VolumeViewportProperties, ViewportProperties, PublicViewportInput, VolumeActor, Actor, ActorEntry, ActorMapperProxy, ImageActor, ICanvasActor, IImageLoadObject, IVolumeLoadObject, IVolumeInput, VolumeInputCallback, IStackInput, StackInputCallback, ViewportPreset, Metadata, OrientationVectors, AABB2, AABB3, Point2, Point3, PointsXYZ, Point4, Mat3, Plane, ViewportInputOptions, VideoViewportProperties, WSIViewportProperties, VOIRange, VOI, DisplayArea, FlipDirection, ICachedImage, ICachedVolume, CPUFallbackEnabledElement, CPUFallbackViewport, CPUFallbackTransform, CPUFallbackColormapData, CPUFallbackViewportDisplayedArea, CPUFallbackColormapsData, CPUFallbackColormap, TransformMatrix2D, CPUFallbackLookupTable, CPUFallbackLUT, CPUFallbackRenderingTools, CustomEventType, ActorSliceRange, ImageSliceData, IGeometry, IGeometryLoadObject, ICachedGeometry, PublicContourSetData, ContourSetData, ContourData, IContourSet, IContour, PublicSurfaceData, SurfaceData, ISurface, PublicMeshData, MeshData, IMesh, RGB, ColormapPublic, ColormapRegistration, PixelDataTypedArray, PixelDataTypedArrayString, ImagePixelModule, ImagePlaneModule, AffineMatrix, ImageLoadListener, InternalVideoCamera, VideoViewportInput, InternalECGCamera, ECGViewportInput, ECGChannel, ECGWaveformData, ECGViewportProperties, BoundsIJK, BoundsLPS, Color, ColorLUT, VolumeProps, IImageFrame, LocalVolumeOptions, IVoxelManager, IRLEVoxelMap, RLERun, ViewportInput, ImageLoadRequests, IBaseVolumeViewport, GeometryLoaderFn, ScrollOptions, JumpToSliceOptions, Memo, HistoryMemo, VoxelManager, RLEVoxelMap, RenderingEngineModeType, VtkOffscreenMultiRenderWindow, ViewportDataReference, ViewportType, ViewportTypeRegistry, ViewportTypeConstants, };
 export { ActorRenderMode };

package/dist/esm/utilities/VoxelManager.d.ts

@@ -23,6 +23,7 @@ export default class VoxelManager<T> {
     invalidateCache?: () => void;
     getRange: () => [number, number];
     private scalarData;
+    private _scalarDataIsCachedExpansion;
     private _sliceDataCache;
     readonly _id: string;
     points: Set<number>;
@@ -59,6 +60,7 @@ export default class VoxelManager<T> {
         max: any;
     };
     setAtIndex: (index: any, v: any) => boolean;
+    private invalidateCachedScalarExpansion;
     toIJK(index: number): Point3;
     getMiddleSliceData: () => PixelDataTypedArray;
     toIndex(ijk: Point3): number;

package/dist/esm/utilities/VoxelManager.js

@@ -20,6 +20,7 @@ export default class VoxelManager {
             [Infinity, -Infinity],
         ];
         this.scalarData = null;
+        this._scalarDataIsCachedExpansion = false;
         this._sliceDataCache = null;
         this.getAtIJK = (i, j, k) => {
             return this._get(i + j * this.width + k * this.frameSize);
@@ -30,6 +31,7 @@ export default class VoxelManager {
             if (changed !== false) {
                 this.modifiedSlices.add(k);
                 VoxelManager.addBounds(this.boundsIJK, [i, j, k]);
+                this.invalidateCachedScalarExpansion();
             }
             return changed;
         };
@@ -44,6 +46,7 @@ export default class VoxelManager {
                 const pointIJK = this.toIJK(index);
                 this.modifiedSlices.add(pointIJK[2]);
                 VoxelManager.addBounds(this.boundsIJK, pointIJK);
+                this.invalidateCachedScalarExpansion();
             }
             return changed;
         };
@@ -209,6 +212,12 @@ export default class VoxelManager {
         this.forEach(callback, { boundsIJK: this.getDefaultBounds() });
         return { min, max };
     }
+    invalidateCachedScalarExpansion() {
+        if (this._scalarDataIsCachedExpansion) {
+            this.scalarData = null;
+            this._scalarDataIsCachedExpansion = false;
+        }
+    }
     toIJK(index) {
         return [
             index % this.width,
@@ -269,7 +278,8 @@ export default class VoxelManager {
         if (this._getScalarData) {
             const scalarData = this._getScalarData();
             if (storeScalarData) {
-                console.log('Not transient, should store value', scalarData);
+                this.scalarData = scalarData;
+                this._scalarDataIsCachedExpansion = true;
             }
             return scalarData;
         }
@@ -277,6 +287,7 @@ export default class VoxelManager {
     }
     setScalarData(newScalarData) {
         this.scalarData = newScalarData;
+        this._scalarDataIsCachedExpansion = false;
     }
     getScalarDataLength() {
         if (this.scalarData) {

package/dist/esm/utilities/getScalingDescriptor.d.ts

@@ -0,0 +1,10 @@
+import type { IViewport } from '../types/IViewport';
+import type { ScalingDescriptor } from '../types/ScalingDescriptor';
+type VolumeLike = {
+    metadata?: {
+        Modality?: string;
+    };
+    scaling?: object;
+} | undefined;
+declare function _getScalingDescriptor(viewport: IViewport, targetId?: string, getVolume?: (volumeId: string) => VolumeLike): ScalingDescriptor | undefined;
+export { _getScalingDescriptor };

package/dist/esm/utilities/getScalingDescriptor.js

@@ -0,0 +1,41 @@
+import { isGenericViewport } from './viewportCapabilities';
+import { getVolumeId } from './getVolumeId';
+import { resolveGenericViewportVolumeId } from './resolveGenericViewportVolumeId';
+function _getScalingDescriptor(viewport, targetId, getVolume) {
+    if (!getVolume) {
+        throw new Error('getVolume is required, use the utilities export instead');
+    }
+    if (isGenericViewport(viewport)) {
+        const resolvedVolumeId = resolveGenericViewportVolumeId(viewport, targetId);
+        const volume = resolvedVolumeId ? getVolume(resolvedVolumeId) : undefined;
+        const imageData = viewport.getImageData?.();
+        return {
+            modality: volume?.metadata?.Modality ?? imageData?.metadata?.Modality,
+            isPreScaled: isScalingPresent(volume?.scaling),
+        };
+    }
+    if (typeof viewport.setVolumes === 'function') {
+        const volumeViewport = viewport;
+        const volumeId = targetId
+            ? getVolumeId(targetId)
+            : volumeViewport.getVolumeId();
+        const volume = volumeId ? getVolume(volumeId) : undefined;
+        return {
+            modality: volume?.metadata?.Modality,
+            isPreScaled: isScalingPresent(volume?.scaling),
+        };
+    }
+    if (typeof viewport.setStack === 'function') {
+        const stackViewport = viewport;
+        const { preScale } = stackViewport.getImageData() || {};
+        return {
+            modality: stackViewport.modality,
+            isPreScaled: !!preScale?.scaled,
+        };
+    }
+    return undefined;
+}
+function isScalingPresent(scaling) {
+    return !!scaling && Object.keys(scaling).length > 0;
+}
+export { _getScalingDescriptor };

package/dist/esm/utilities/getTargetVolumeAndSpacingInNormalDir.js

@@ -59,10 +59,9 @@ export default function getTargetVolumeAndSpacingInNormalDir(viewport, camera, t
     return smallest;
 }
 function getSpacingInNormal(imageVolume, viewPlaneNormal, viewport, useSlabThickness = false) {
-    const { slabThickness } = viewport.getProperties();
-    let spacingInNormalDirection = slabThickness;
-    if (!slabThickness || !useSlabThickness) {
-        spacingInNormalDirection = getSpacingInNormalDirection(imageVolume, viewPlaneNormal);
+    const slabThickness = viewport.getProperties?.()?.slabThickness;
+    if (slabThickness && useSlabThickness) {
+        return slabThickness;
     }
-    return spacingInNormalDirection;
+    return getSpacingInNormalDirection(imageVolume, viewPlaneNormal);
 }

package/dist/esm/utilities/getViewportModality.js

@@ -1,18 +1,9 @@
+import { _getScalingDescriptor } from './getScalingDescriptor';
 function _getViewportModality(viewport, volumeId, getVolume) {
-    if (!getVolume) {
-        throw new Error('getVolume is required, use the utilities export instead ');
+    const descriptor = _getScalingDescriptor(viewport, volumeId, getVolume);
+    if (!descriptor) {
+        throw new Error('Invalid viewport type');
     }
-    if (viewport.modality) {
-        return viewport.modality;
-    }
-    if (viewport.setVolumes) {
-        volumeId = volumeId ?? viewport.getVolumeId();
-        if (!volumeId || !getVolume) {
-            return;
-        }
-        const volume = getVolume(volumeId);
-        return volume.metadata.Modality;
-    }
-    throw new Error('Invalid viewport type');
+    return descriptor.modality;
 }
 export { _getViewportModality };

package/dist/esm/utilities/index.d.ts

@@ -87,6 +87,7 @@ import FrameRange from './FrameRange';
 import fnv1aHash from './fnv1aHash';
 import { getImageDataMetadata } from './getImageDataMetadata';
 import { buildMetadata } from './buildMetadata';
+import { resolveGenericViewportVolumeId } from './resolveGenericViewportVolumeId';
 import getDynamicVolumeInfo from './getDynamicVolumeInfo';
 import autoLoad from './autoLoad';
 import scaleArray from './scaleArray';
@@ -106,9 +107,10 @@ export * from './getPixelSpacingInformation';
 export * from './getPlaneCubeIntersectionDimensions';
 export * from './rotateToViewCoordinates';
 import { asArray } from './asArray';
-import { viewportSupportsImageSlices, viewportSupportsStackCalibration, viewportSupportsStackCompatibility, viewportSupportsVolumeActors, viewportSupportsVolumeCompatibility, viewportSupportsVolumeId, viewportSupportsVolumeURI } from './viewportCapabilities';
+import { viewportSupportsImageSlices, viewportSupportsStackCalibration, viewportSupportsStackCompatibility, viewportSupportsVolumeActors, viewportSupportsVolumeCompatibility, viewportSupportsVolumeId, viewportSupportsVolumeURI, isGenericViewport, viewportSupportsDisplaySetPresentation, getViewportContentMode, viewportIsInVolumeMode, viewportIsInStackMode } from './viewportCapabilities';
 import { getNormalizedAspectRatio } from './getNormalizedAspectRatio';
 export { updatePlaneRestriction } from './updatePlaneRestriction';
 declare const getViewportModality: (viewport: IViewport, volumeId?: string) => string;
+declare const getScalingDescriptor: (viewport: IViewport, targetId?: string) => import("../types").ScalingDescriptor;
 export * from './isEqual';
-export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, getMinMax, clonePoint3, hasOwn, getRuntimeId, getVOIRangeFromWindowLevel, isOpposite, getViewportModality, windowLevel, convertToGrayscale, convertColorArrayToRgbString, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, genericViewportDisplaySetMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, handleMultiframe4D, generateFrameImageId, pointInShapeCallback, ECGUtilities, VideoUtilities, WSIUtilities, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getAcquisitionPlaneOrientation, getVolumeDirectionVectors, getVolumeViewReferenceId, calculateSpacingBetweenImageIds, getImageDataMetadata, buildMetadata, calculateNeighborhoodStats, asArray, viewportSupportsImageSlices, viewportSupportsStackCalibration, viewportSupportsStackCompatibility, viewportSupportsVolumeActors, viewportSupportsVolumeCompatibility, viewportSupportsVolumeId, viewportSupportsVolumeURI, getNormalizedAspectRatio, };
+export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, getMinMax, clonePoint3, hasOwn, getRuntimeId, getVOIRangeFromWindowLevel, isOpposite, getViewportModality, getScalingDescriptor, resolveGenericViewportVolumeId, windowLevel, convertToGrayscale, convertColorArrayToRgbString, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, genericViewportDisplaySetMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, handleMultiframe4D, generateFrameImageId, pointInShapeCallback, ECGUtilities, VideoUtilities, WSIUtilities, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getAcquisitionPlaneOrientation, getVolumeDirectionVectors, getVolumeViewReferenceId, calculateSpacingBetweenImageIds, getImageDataMetadata, buildMetadata, calculateNeighborhoodStats, asArray, viewportSupportsImageSlices, viewportSupportsStackCalibration, viewportSupportsStackCompatibility, viewportSupportsVolumeActors, viewportSupportsVolumeCompatibility, viewportSupportsVolumeId, viewportSupportsVolumeURI, isGenericViewport, viewportSupportsDisplaySetPresentation, getViewportContentMode, viewportIsInVolumeMode, viewportIsInStackMode, getNormalizedAspectRatio, };

package/dist/esm/utilities/index.js

@@ -87,6 +87,8 @@ import fnv1aHash from './fnv1aHash';
 import { getImageDataMetadata } from './getImageDataMetadata';
 import { buildMetadata } from './buildMetadata';
 import { _getViewportModality } from './getViewportModality';
+import { _getScalingDescriptor } from './getScalingDescriptor';
+import { resolveGenericViewportVolumeId } from './resolveGenericViewportVolumeId';
 import cache from '../cache/cache';
 import getDynamicVolumeInfo from './getDynamicVolumeInfo';
 import autoLoad from './autoLoad';
@@ -107,9 +109,10 @@ export * from './getPixelSpacingInformation';
 export * from './getPlaneCubeIntersectionDimensions';
 export * from './rotateToViewCoordinates';
 import { asArray } from './asArray';
-import { viewportSupportsImageSlices, viewportSupportsStackCalibration, viewportSupportsStackCompatibility, viewportSupportsVolumeActors, viewportSupportsVolumeCompatibility, viewportSupportsVolumeId, viewportSupportsVolumeURI, } from './viewportCapabilities';
+import { viewportSupportsImageSlices, viewportSupportsStackCalibration, viewportSupportsStackCompatibility, viewportSupportsVolumeActors, viewportSupportsVolumeCompatibility, viewportSupportsVolumeId, viewportSupportsVolumeURI, isGenericViewport, viewportSupportsDisplaySetPresentation, getViewportContentMode, viewportIsInVolumeMode, viewportIsInStackMode, } from './viewportCapabilities';
 import { getNormalizedAspectRatio } from './getNormalizedAspectRatio';
 export { updatePlaneRestriction } from './updatePlaneRestriction';
 const getViewportModality = (viewport, volumeId) => _getViewportModality(viewport, volumeId, cache.getVolume);
+const getScalingDescriptor = (viewport, targetId) => _getScalingDescriptor(viewport, targetId, cache.getVolume);
 export * from './isEqual';
-export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, getMinMax, clonePoint3, hasOwn, getRuntimeId, getVOIRangeFromWindowLevel, isOpposite, getViewportModality, windowLevel, convertToGrayscale, convertColorArrayToRgbString, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, genericViewportDisplaySetMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, handleMultiframe4D, generateFrameImageId, pointInShapeCallback, ECGUtilities, VideoUtilities, WSIUtilities, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getAcquisitionPlaneOrientation, getVolumeDirectionVectors, getVolumeViewReferenceId, calculateSpacingBetweenImageIds, getImageDataMetadata, buildMetadata, calculateNeighborhoodStats, asArray, viewportSupportsImageSlices, viewportSupportsStackCalibration, viewportSupportsStackCompatibility, viewportSupportsVolumeActors, viewportSupportsVolumeCompatibility, viewportSupportsVolumeId, viewportSupportsVolumeURI, getNormalizedAspectRatio, };
+export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, getMinMax, clonePoint3, hasOwn, getRuntimeId, getVOIRangeFromWindowLevel, isOpposite, getViewportModality, getScalingDescriptor, resolveGenericViewportVolumeId, windowLevel, convertToGrayscale, convertColorArrayToRgbString, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, genericViewportDisplaySetMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, handleMultiframe4D, generateFrameImageId, pointInShapeCallback, ECGUtilities, VideoUtilities, WSIUtilities, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getAcquisitionPlaneOrientation, getVolumeDirectionVectors, getVolumeViewReferenceId, calculateSpacingBetweenImageIds, getImageDataMetadata, buildMetadata, calculateNeighborhoodStats, asArray, viewportSupportsImageSlices, viewportSupportsStackCalibration, viewportSupportsStackCompatibility, viewportSupportsVolumeActors, viewportSupportsVolumeCompatibility, viewportSupportsVolumeId, viewportSupportsVolumeURI, isGenericViewport, viewportSupportsDisplaySetPresentation, getViewportContentMode, viewportIsInVolumeMode, viewportIsInStackMode, getNormalizedAspectRatio, };

package/dist/esm/utilities/isPTPrescaledWithSUV.d.ts

@@ -1,3 +1,3 @@
 import type { IImage } from '../types';
-declare const isPTPrescaledWithSUV: (image: IImage) => number;
+declare const isPTPrescaledWithSUV: (image: IImage) => boolean;
 export default isPTPrescaledWithSUV;

package/dist/esm/utilities/isPTPrescaledWithSUV.js

@@ -1,4 +1,4 @@
 const isPTPrescaledWithSUV = (image) => {
-    return image.preScale.scaled && image.preScale.scalingParameters.suvbw;
+    return Boolean(image.preScale?.scaled && image.preScale?.scalingParameters?.suvbw);
 };
 export default isPTPrescaledWithSUV;

package/dist/esm/utilities/resolveGenericViewportVolumeId.d.ts

@@ -0,0 +1,2 @@
+import type { IViewport } from '../types/IViewport';
+export declare function resolveGenericViewportVolumeId(viewport: IViewport, targetId?: string): string | undefined;

package/dist/esm/utilities/resolveGenericViewportVolumeId.js

@@ -0,0 +1,12 @@
+import { getVolumeId } from './getVolumeId';
+export function resolveGenericViewportVolumeId(viewport, targetId) {
+    const genericViewport = viewport;
+    const actors = genericViewport.getActors?.() ?? [];
+    const matchedActor = targetId
+        ? (actors.find((actor) => actor.referencedId === targetId) ??
+            actors.find((actor) => actor.referencedId?.endsWith(`:${targetId}`)))
+        : undefined;
+    return (matchedActor?.referencedId ??
+        (targetId ? getVolumeId(targetId) : undefined) ??
+        genericViewport.getDefaultActor?.()?.referencedId);
+}