@cornerstonejs/core 2.0.0-beta.8 → 2.0.1

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

@@ -0,0 +1,86 @@
+import type { mat4 } from 'gl-matrix';
+import type { BlendModes, InterpolationType, OrientationAxis } from '../enums';
+import type { FlipDirection, IImageData, IVolumeInput, OrientationVectors, Point2, Point3, VolumeViewportProperties, ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewReference, ICamera } from '../types';
+import type { VoiModifiedEventDetail } from '../types/EventTypes';
+import type { ViewportInput } from '../types/IViewport';
+import type { TransferFunctionNodes } from '../types/ITransferFunctionNode';
+import Viewport from './Viewport';
+declare abstract class BaseVolumeViewport extends Viewport {
+    useCPURendering: boolean;
+    private _FrameOfReferenceUID;
+    protected initialTransferFunctionNodes: TransferFunctionNodes;
+    private globalDefaultProperties;
+    private perVolumeIdDefaultProperties;
+    protected initialViewUp: Point3;
+    protected viewportProperties: VolumeViewportProperties;
+    private volumeIds;
+    constructor(props: ViewportInput);
+    static get useCustomRenderingPipeline(): boolean;
+    getSliceViewInfo(): {
+        width: number;
+        height: number;
+        sliceIndex: number;
+        slicePlane: number;
+        sliceToIndexMatrix: mat4;
+        indexToSliceMatrix: mat4;
+    };
+    protected applyViewOrientation(orientation: OrientationAxis | OrientationVectors, resetCamera?: boolean): void;
+    private initializeVolumeNewImageEventDispatcher;
+    private setVOILUTFunction;
+    private setColormap;
+    private setOpacity;
+    private setInvert;
+    protected getVOIModifiedEventDetail(volumeId: string): VoiModifiedEventDetail;
+    private _getOrCreateColorTransferFunction;
+    protected setInterpolationType(interpolationType: InterpolationType, volumeId?: string): void;
+    private setVOI;
+    protected setRotation: (rotation: number) => void;
+    private rotateCamera;
+    setDefaultProperties(ViewportProperties: VolumeViewportProperties, volumeId?: string): void;
+    clearDefaultProperties(volumeId?: string): void;
+    getViewReference(viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
+    isReferenceViewable(viewRef: ViewReference, options?: ReferenceCompatibleOptions): boolean;
+    scroll(delta?: number): void;
+    setViewReference(viewRef: ViewReference): void;
+    setProperties({ voiRange, VOILUTFunction, invert, colormap, preset, interpolationType, slabThickness, }?: VolumeViewportProperties, volumeId?: string, suppressEvents?: boolean): void;
+    resetToDefaultProperties(volumeId: string): void;
+    private setPreset;
+    getDefaultProperties: (volumeId?: string) => VolumeViewportProperties;
+    getProperties: (volumeId?: string) => VolumeViewportProperties;
+    private getColormap;
+    setVolumes(volumeInputArray: IVolumeInput[], immediate?: boolean, suppressEvents?: boolean): Promise<void>;
+    addVolumes(volumeInputArray: IVolumeInput[], immediate?: boolean, suppressEvents?: boolean): Promise<void>;
+    removeVolumeActors(actorUIDs: string[], immediate?: boolean): void;
+    setOrientation(_orientation: OrientationAxis | OrientationVectors, _immediate?: boolean): void;
+    private initializeColorTransferFunction;
+    private _getApplicableVolumeActor;
+    private _isValidVolumeInputArray;
+    getRotation: () => number;
+    getBounds(): number[];
+    flip(flipDirection: FlipDirection): void;
+    getFrameOfReferenceUID: () => string;
+    hasVolumeId(volumeId: string): boolean;
+    hasVolumeURI(volumeURI: string): boolean;
+    getImageData(volumeId?: string): IImageData | undefined;
+    protected setCameraClippingRange(): void;
+    getSliceIndex(): number;
+    setCamera(cameraInterface: ICamera, storeAsInitialCamera?: boolean): void;
+    private _setVolumeActors;
+    canvasToWorld: (canvasPos: Point2) => Point3;
+    worldToCanvas: (worldPos: Point3) => Point2;
+    hasImageURI: (imageURI: string) => boolean;
+    protected _getOrientationVectors(orientation: OrientationAxis | OrientationVectors): OrientationVectors;
+    getSlabThickness(): number;
+    getIntensityFromWorld(point: Point3): number;
+    getImageIds: (volumeId?: string) => string[];
+    abstract getCurrentImageId(): string | undefined;
+    getVolumeId(specifier?: ViewReferenceSpecifier): string;
+    getViewReferenceId(specifier?: ViewReferenceSpecifier): string;
+    private _addVolumeId;
+    abstract setBlendMode(blendMode: BlendModes, filterActorUIDs?: string[], immediate?: boolean): void;
+    abstract setSlabThickness(slabThickness: number, filterActorUIDs?: string[]): void;
+    abstract resetSlabThickness(): void;
+    abstract resetProperties(volumeId?: string): void;
+    getAllVolumeIds(): string[];
+}
+export default BaseVolumeViewport;

package/dist/esm/RenderingEngine/BaseVolumeViewport.js

@@ -2,28 +2,38 @@ import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransf
 import vtkColorMaps from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps';
 import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
 import { vec2, vec3 } from 'gl-matrix';
-import cache from '../cache';
+import cache from '../cache/cache';
 import { MPR_CAMERA_VALUES, RENDERING_DEFAULTS, VIEWPORT_PRESETS, } from '../constants';
-import { Events, ViewportStatus, VOILUTFunctionType, } from '../enums';
+import { Events, ViewportStatus, VOILUTFunctionType } from '../enums';
 import ViewportType from '../enums/ViewportType';
 import eventTarget from '../eventTarget';
 import { getShouldUseCPURendering } from '../init';
-import { loadVolume } from '../loaders/volumeLoader';
-import { actorIsA, applyPreset, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, imageIdToURI, invertRgbTransferFunction, triggerEvent, colormap as colormapUtils, isEqualNegative, getVolumeViewportScrollInfo, snapFocalPointToSlice, isEqual, } from '../utilities';
-import { createVolumeActor } from './helpers';
-import volumeNewImageEventDispatcher, { resetVolumeNewImageState, } from './helpers/volumeNewImageEventDispatcher';
-import Viewport from './Viewport';
-import vtkSlabCamera from './vtkClasses/vtkSlabCamera';
+import triggerEvent from '../utilities/triggerEvent';
+import * as colormapUtils from '../utilities/colormap';
+import invertRgbTransferFunction from '../utilities/invertRgbTransferFunction';
+import createSigmoidRGBTransferFunction from '../utilities/createSigmoidRGBTransferFunction';
 import transformWorldToIndex from '../utilities/transformWorldToIndex';
 import { findMatchingColormap } from '../utilities/colormap';
 import { getTransferFunctionNodes } from '../utilities/transferFunctionUtils';
+import createVolumeActor from './helpers/createVolumeActor';
+import volumeNewImageEventDispatcher, { resetVolumeNewImageState, } from './helpers/volumeNewImageEventDispatcher';
+import Viewport from './Viewport';
+import vtkSlabCamera from './vtkClasses/vtkSlabCamera';
+import getVolumeViewportScrollInfo from '../utilities/getVolumeViewportScrollInfo';
+import { actorIsA, isImageActor } from '../utilities/actorCheck';
+import snapFocalPointToSlice from '../utilities/snapFocalPointToSlice';
+import getVoiFromSigmoidRGBTransferFunction from '../utilities/getVoiFromSigmoidRGBTransferFunction';
+import isEqual, { isEqualNegative } from '../utilities/isEqual';
+import applyPreset from '../utilities/applyPreset';
+import imageIdToURI from '../utilities/imageIdToURI';
+import uuidv4 from '../utilities/uuidv4';
 class BaseVolumeViewport extends Viewport {
     constructor(props) {
         super(props);
         this.useCPURendering = false;
-        this.useNativeDataType = false;
         this.perVolumeIdDefaultProperties = new Map();
         this.viewportProperties = {};
+        this.volumeIds = new Set();
         this.setRotation = (rotation) => {
             const panFit = this.getPan(this.fitToCanvasCamera);
             const pan = this.getPan();
@@ -53,10 +63,8 @@ class BaseVolumeViewport extends Viewport {
                 element: this.element,
                 viewportId: this.id,
                 renderingEngineId: this.renderingEngineId,
-                rotation,
             };
             triggerEvent(this.element, Events.CAMERA_MODIFIED, eventDetail);
-            this.viewportProperties.rotation = rotation;
         };
         this.getDefaultProperties = (volumeId) => {
             let volumeProperties;
@@ -75,13 +83,15 @@ class BaseVolumeViewport extends Viewport {
             if (!applicableVolumeActorInfo) {
                 return;
             }
-            const { colormap: latestColormap, VOILUTFunction, interpolationType, invert, slabThickness, rotation, preset, } = this.viewportProperties;
+            const { colormap: latestColormap, VOILUTFunction, interpolationType, invert, slabThickness, preset, } = this.viewportProperties;
+            const volume = cache.getVolume(this.getVolumeId());
+            if (!volume) {
+                return null;
+            }
             const voiRanges = this.getActors()
                 .map((actorEntry) => {
                 const volumeActor = actorEntry.actor;
-                const volumeId = actorEntry.uid;
-                const volume = cache.getVolume(volumeId);
-                if (!volume) {
+                if (!actorIsA(actorEntry, 'vtkVolume')) {
                     return null;
                 }
                 const cfun = volumeActor.getProperty().getRGBTransferFunction(0);
@@ -103,7 +113,6 @@ class BaseVolumeViewport extends Viewport {
                 interpolationType: interpolationType,
                 invert: invert,
                 slabThickness: slabThickness,
-                rotation: rotation,
                 preset,
             };
         };
@@ -113,7 +122,7 @@ class BaseVolumeViewport extends Viewport {
                 return;
             }
             const { volumeActor } = applicableVolumeActorInfo;
-            const cfun = volumeActor.getProperty().getRGBTransferFunction(0);
+            const cfun = this._getOrCreateColorTransferFunction(volumeId);
             const { nodes } = cfun.getState();
             const RGBPoints = nodes.reduce((acc, node) => {
                 acc.push(node.x, node.r, node.g, node.b);
@@ -123,7 +132,7 @@ class BaseVolumeViewport extends Viewport {
             return matchedColormap;
         };
         this.getRotation = () => {
-            const { viewUp: currentViewUp, viewPlaneNormal, flipVertical, } = this.getCamera();
+            const { viewUp: currentViewUp, viewPlaneNormal, flipVertical, } = this.getCameraNoRotation();
             const initialViewUp = flipVertical
                 ? vec3.negate([0, 0, 0], this.initialViewUp)
                 : this.initialViewUp;
@@ -180,14 +189,14 @@ class BaseVolumeViewport extends Viewport {
                 canvasCoord[0] / devicePixelRatio,
                 canvasCoord[1] / devicePixelRatio,
             ];
-            vtkCamera.setIsPerformingCoordinateTransformation?.(false);
+            vtkCamera.setIsPerformingCoordinateTransformation(false);
             return canvasCoordWithDPR;
         };
         this.hasImageURI = (imageURI) => {
             const volumeActors = this.getActors().filter((actorEntry) => actorIsA(actorEntry, 'vtkVolume'));
-            return volumeActors.some(({ uid }) => {
-                const volume = cache.getVolume(uid);
-                if (!volume || !volume.imageIds) {
+            return volumeActors.some(({ uid, referencedId }) => {
+                const volume = cache.getVolume(referencedId || uid);
+                if (!volume?.imageIds) {
                     return false;
                 }
                 const volumeImageURIs = volume.imageIds.map(imageIdToURI);
@@ -207,7 +216,6 @@ class BaseVolumeViewport extends Viewport {
             return imageVolume.imageIds;
         };
         this.useCPURendering = getShouldUseCPURendering();
-        this.useNativeDataType = this._shouldUseNativeDataType();
         if (this.useCPURendering) {
             throw new Error('VolumeViewports cannot be used whilst CPU Fallback Rendering is enabled.');
         }
@@ -232,6 +240,9 @@ class BaseVolumeViewport extends Viewport {
     static get useCustomRenderingPipeline() {
         return false;
     }
+    getSliceViewInfo() {
+        throw new Error('Method not implemented.');
+    }
     applyViewOrientation(orientation, resetCamera = true) {
         const { viewPlaneNormal, viewUp } = this._getOrientationVectors(orientation);
         const camera = this.getVtkActiveCamera();
@@ -269,17 +280,8 @@ class BaseVolumeViewport extends Viewport {
         this.element.addEventListener(Events.CAMERA_MODIFIED, volumeNewImageHandlerBound);
         eventTarget.addEventListener(Events.ELEMENT_DISABLED, volumeNewImageCleanUpBound);
     }
-    resetVolumeViewportClippingRange() {
-        const activeCamera = this.getVtkActiveCamera();
-        if (activeCamera.getParallelProjection()) {
-            activeCamera.setClippingRange(-RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE, RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE);
-        }
-        else {
-            activeCamera.setClippingRange(RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS, RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE);
-        }
-    }
     setVOILUTFunction(voiLUTFunction, volumeId, suppressEvents) {
-        if (Object.values(VOILUTFunctionType).indexOf(voiLUTFunction) === -1) {
+        if (!Object.values(VOILUTFunctionType).includes(voiLUTFunction)) {
             voiLUTFunction = VOILUTFunctionType.LINEAR;
         }
         const { voiRange } = this.getProperties();
@@ -420,6 +422,7 @@ class BaseVolumeViewport extends Viewport {
         const volumeIdToUse = applicableVolumeActorInfo.volumeId;
         let voiRangeToUse = voiRange;
         if (typeof voiRangeToUse === 'undefined') {
+            throw new Error('voiRangeToUse is undefined, need to implement this in the new volume model');
             const imageData = volumeActor.getMapper().getInputData();
             const range = imageData.getPointData().getScalars().getRange();
             const maxVoiRange = { lower: range[0], upper: range[1] };
@@ -477,7 +480,7 @@ class BaseVolumeViewport extends Viewport {
             return target;
         }
         const { viewPlaneNormal } = target;
-        const delta = viewRefSpecifier.sliceIndex - this.getSliceIndex();
+        const delta = viewRefSpecifier?.sliceIndex - this.getSliceIndex();
         const { sliceRangeInfo } = getVolumeViewportScrollInfo(this, volumeId, true);
         const { sliceRange, spacingInNormalDirection, camera } = sliceRangeInfo;
         const { focalPoint, position } = camera;
@@ -541,7 +544,8 @@ class BaseVolumeViewport extends Viewport {
         else if (refFrameOfReference === this.getFrameOfReferenceUID()) {
             if (refViewPlaneNormal && !isNegativeNormal && !isSameNormal) {
                 this.setOrientation({ viewPlaneNormal: refViewPlaneNormal, viewUp });
-                return this.setViewReference(viewRef);
+                this.setViewReference(viewRef);
+                return;
             }
             if (cameraFocalPoint) {
                 const focalDelta = vec3.subtract([0, 0, 0], cameraFocalPoint, focalPoint);
@@ -559,7 +563,7 @@ class BaseVolumeViewport extends Viewport {
             throw new Error(`Incompatible view refs: ${refFrameOfReference}!==${this.getFrameOfReferenceUID()}`);
         }
     }
-    setProperties({ voiRange, VOILUTFunction, invert, colormap, preset, interpolationType, slabThickness, rotation, } = {}, volumeId, suppressEvents = false) {
+    setProperties({ voiRange, VOILUTFunction, invert, colormap, preset, interpolationType, slabThickness, } = {}, volumeId, suppressEvents = false) {
         if (this.globalDefaultProperties == null) {
             this.setDefaultProperties({
                 voiRange,
@@ -568,9 +572,11 @@ class BaseVolumeViewport extends Viewport {
                 colormap,
                 preset,
                 slabThickness,
-                rotation,
             });
         }
+        if (invert !== undefined && this.viewportProperties.invert !== invert) {
+            this.setInvert(invert, volumeId, suppressEvents);
+        }
         if (colormap?.name) {
             this.setColormap(colormap, volumeId, suppressEvents);
         }
@@ -586,9 +592,6 @@ class BaseVolumeViewport extends Viewport {
         if (VOILUTFunction !== undefined) {
             this.setVOILUTFunction(VOILUTFunction, volumeId, suppressEvents);
         }
-        if (invert !== undefined && this.viewportProperties.invert !== invert) {
-            this.setInvert(invert, volumeId, suppressEvents);
-        }
         if (preset !== undefined) {
             this.setPreset(preset, volumeId, suppressEvents);
         }
@@ -596,9 +599,6 @@ class BaseVolumeViewport extends Viewport {
             this.setSlabThickness(slabThickness);
             this.viewportProperties.slabThickness = slabThickness;
         }
-        if (rotation !== undefined) {
-            this.setRotation(rotation);
-        }
     }
     resetToDefaultProperties(volumeId) {
         const properties = this.globalDefaultProperties;
@@ -621,8 +621,11 @@ class BaseVolumeViewport extends Viewport {
             this.setSlabThickness(properties.slabThickness);
             this.viewportProperties.slabThickness = properties.slabThickness;
         }
-        if (properties.rotation !== undefined) {
-            this.setRotation(properties.rotation);
+        if (properties.preset !== undefined) {
+            this.setPreset(properties.preset, volumeId, false);
+        }
+        if (properties.preset !== undefined) {
+            this.setPreset(properties.preset, volumeId, false);
         }
         this.render();
     }
@@ -656,21 +659,25 @@ class BaseVolumeViewport extends Viewport {
     async setVolumes(volumeInputArray, immediate = false, suppressEvents = false) {
         const firstImageVolume = cache.getVolume(volumeInputArray[0].volumeId);
         if (!firstImageVolume) {
-            throw new Error(`imageVolume with id: ${firstImageVolume.volumeId} does not exist`);
+            throw new Error(`imageVolume with id: ${firstImageVolume.volumeId} does not exist, you need to create/allocate the volume first`);
         }
         const FrameOfReferenceUID = firstImageVolume.metadata.FrameOfReferenceUID;
-        await this._isValidVolumeInputArray(volumeInputArray, FrameOfReferenceUID);
+        this._isValidVolumeInputArray(volumeInputArray, FrameOfReferenceUID);
         this._FrameOfReferenceUID = FrameOfReferenceUID;
+        volumeInputArray.forEach((volumeInput) => {
+            this._addVolumeId(volumeInput.volumeId);
+        });
         const volumeActors = [];
         for (let i = 0; i < volumeInputArray.length; i++) {
-            const { volumeId, actorUID, slabThickness } = volumeInputArray[i];
-            const actor = await createVolumeActor(volumeInputArray[i], this.element, this.id, suppressEvents, this.useNativeDataType);
-            const uid = actorUID || volumeId;
+            const { volumeId, actorUID, slabThickness, ...rest } = volumeInputArray[i];
+            const actor = await createVolumeActor(volumeInputArray[i], this.element, this.id, suppressEvents);
+            const uid = actorUID || uuidv4();
             volumeActors.push({
                 uid,
                 actor,
                 slabThickness,
-                referenceId: volumeId,
+                referencedId: volumeId,
+                ...rest,
             });
         }
         this._setVolumeActors(volumeActors);
@@ -690,19 +697,23 @@ class BaseVolumeViewport extends Viewport {
             throw new Error(`imageVolume with id: ${firstImageVolume.volumeId} does not exist`);
         }
         const volumeActors = [];
-        await this._isValidVolumeInputArray(volumeInputArray, this._FrameOfReferenceUID);
+        this._isValidVolumeInputArray(volumeInputArray, this._FrameOfReferenceUID);
+        volumeInputArray.forEach((volumeInput) => {
+            this._addVolumeId(volumeInput.volumeId);
+        });
         for (let i = 0; i < volumeInputArray.length; i++) {
-            const { volumeId, visibility, actorUID, slabThickness } = volumeInputArray[i];
-            const actor = await createVolumeActor(volumeInputArray[i], this.element, this.id, suppressEvents, this.useNativeDataType);
-            if (visibility === false) {
+            const { volumeId, visibility, actorUID, slabThickness, ...rest } = volumeInputArray[i];
+            const actor = await createVolumeActor(volumeInputArray[i], this.element, this.id, suppressEvents);
+            if (!visibility) {
                 actor.setVisibility(false);
             }
-            const uid = actorUID || volumeId;
+            const uid = actorUID || uuidv4();
             volumeActors.push({
                 uid,
                 actor,
                 slabThickness,
-                referenceId: volumeId,
+                referencedId: volumeId,
+                ...rest,
             });
         }
         this.addActors(volumeActors);
@@ -723,36 +734,37 @@ class BaseVolumeViewport extends Viewport {
     initializeColorTransferFunction(volumeInputArray) {
         const selectedVolumeId = volumeInputArray[0].volumeId;
         const colorTransferFunction = this._getOrCreateColorTransferFunction(selectedVolumeId);
-        if (!this.initialTransferFunctionNodes) {
+        if (!this.initialTransferFunctionNodes && colorTransferFunction) {
             this.initialTransferFunctionNodes = getTransferFunctionNodes(colorTransferFunction);
         }
     }
     _getApplicableVolumeActor(volumeId) {
-        if (volumeId !== undefined && !this.getActor(volumeId)) {
-            return;
-        }
         const actorEntries = this.getActors();
-        if (!actorEntries.length) {
+        if (!actorEntries?.length) {
             return;
         }
-        let volumeActor;
         if (volumeId) {
-            volumeActor = this.getActor(volumeId)?.actor;
-        }
-        if (!volumeActor) {
-            volumeActor = actorEntries[0].actor;
-            volumeId = actorEntries[0].uid;
+            const actorEntry = actorEntries.find((actor) => actor.referencedId === volumeId);
+            if (!actorEntry) {
+                return;
+            }
+            return {
+                volumeActor: actorEntry.actor,
+                volumeId,
+                actorUID: actorEntry.uid,
+            };
         }
-        return { volumeActor, volumeId };
+        const defaultActorEntry = actorEntries[0];
+        return {
+            volumeActor: defaultActorEntry.actor,
+            volumeId: defaultActorEntry.referencedId,
+            actorUID: defaultActorEntry.uid,
+        };
     }
     async _isValidVolumeInputArray(volumeInputArray, FrameOfReferenceUID) {
         const numVolumes = volumeInputArray.length;
         for (let i = 1; i < numVolumes; i++) {
-            const volumeInput = volumeInputArray[i];
-            const imageVolume = await loadVolume(volumeInput.volumeId);
-            if (!imageVolume) {
-                throw new Error(`imageVolume with id: ${imageVolume.volumeId} does not exist`);
-            }
+            const imageVolume = cache.getVolume(volumeInputArray[i].volumeId);
             if (FrameOfReferenceUID !== imageVolume.metadata.FrameOfReferenceUID) {
                 throw new Error(`Volumes being added to viewport ${this.id} do not share the same FrameOfReferenceUID. This is not yet supported`);
             }
@@ -768,19 +780,23 @@ class BaseVolumeViewport extends Viewport {
         super.flip(flipDirection);
     }
     hasVolumeId(volumeId) {
-        const actorEntries = this.getActors();
-        return actorEntries.some((actorEntry) => {
-            return actorEntry.uid === volumeId;
-        });
+        return this.volumeIds.has(volumeId);
+    }
+    hasVolumeURI(volumeURI) {
+        for (const volumeId of this.volumeIds) {
+            if (volumeId.includes(volumeURI)) {
+                return true;
+            }
+        }
+        return false;
     }
     getImageData(volumeId) {
         const defaultActor = this.getDefaultActor();
         if (!defaultActor) {
             return;
         }
-        const { uid: defaultActorUID } = defaultActor;
-        volumeId = volumeId ?? defaultActorUID;
-        const actorEntry = this.getActor(volumeId);
+        volumeId ||= this.getVolumeId();
+        const actorEntry = this.getActors()?.find((actor) => actor.referencedId === volumeId);
         if (!actorIsA(actorEntry, 'vtkVolume')) {
             return;
         }
@@ -792,17 +808,29 @@ class BaseVolumeViewport extends Viewport {
             spacing: vtkImageData.getSpacing(),
             origin: vtkImageData.getOrigin(),
             direction: vtkImageData.getDirection(),
-            scalarData: vtkImageData.getPointData().getScalars().isDeleted()
-                ? null
-                : vtkImageData.getPointData().getScalars().getData(),
             imageData: actor.getMapper().getInputData(),
             metadata: {
                 Modality: volume?.metadata?.Modality,
+                FrameOfReferenceUID: volume?.metadata?.FrameOfReferenceUID,
+            },
+            get scalarData() {
+                return volume?.voxelManager?.getScalarData();
             },
             scaling: volume?.scaling,
             hasPixelSpacing: true,
+            voxelManager: volume?.voxelManager,
         };
     }
+    setCameraClippingRange() {
+        throw new Error('Method not implemented.');
+    }
+    getSliceIndex() {
+        throw new Error('Method not implemented.');
+    }
+    setCamera(cameraInterface, storeAsInitialCamera) {
+        super.setCamera(cameraInterface, storeAsInitialCamera);
+        this.setCameraClippingRange();
+    }
     _setVolumeActors(volumeActorEntries) {
         for (let i = 0; i < volumeActorEntries.length; i++) {
             this.viewportProperties.invert = false;
@@ -842,15 +870,11 @@ class BaseVolumeViewport extends Viewport {
         if (!actorIsA(actorEntry, 'vtkVolume')) {
             return;
         }
-        const { actor, uid } = actorEntry;
+        const { actor } = actorEntry;
         const imageData = actor.getMapper().getInputData();
-        const volume = cache.getVolume(uid);
-        const { dimensions } = volume;
+        const volume = cache.getVolume(this.getVolumeId());
         const index = transformWorldToIndex(imageData, point);
-        const voxelIndex = index[2] * dimensions[0] * dimensions[1] +
-            index[1] * dimensions[0] +
-            index[0];
-        return volume.getScalarData()[voxelIndex];
+        return volume.voxelManager.getAtIJKPoint(index);
     }
     getVolumeId(specifier) {
         const actorEntries = this.getActors();
@@ -858,26 +882,33 @@ class BaseVolumeViewport extends Viewport {
             return;
         }
         if (!specifier?.volumeId) {
-            return actorEntries.find((actorEntry) => actorEntry.actor.getClassName() === 'vtkVolume')?.uid;
+            const found = actorEntries.find((actorEntry) => actorEntry.actor.getClassName() === 'vtkVolume');
+            return found?.referencedId || found?.uid;
         }
-        return actorEntries.find((actorEntry) => actorEntry.actor.getClassName() === 'vtkVolume' &&
-            actorEntry.uid === specifier.volumeId)?.uid;
+        const found = actorEntries.find((actorEntry) => actorEntry.actor.getClassName() === 'vtkVolume' &&
+            actorEntry.referencedId === specifier?.volumeId);
+        return found?.referencedId || found?.uid;
     }
-    getReferenceId(specifier = {}) {
+    getViewReferenceId(specifier = {}) {
         let { volumeId, sliceIndex: sliceIndex } = specifier;
         if (!volumeId) {
             const actorEntries = this.getActors();
             if (!actorEntries) {
                 return;
             }
-            volumeId = actorEntries.find((actorEntry) => actorEntry.actor.getClassName() === 'vtkVolume')?.uid;
+            volumeId = actorEntries.find((actorEntry) => actorEntry.actor.getClassName() === 'vtkVolume')?.referencedId;
         }
         const currentIndex = this.getSliceIndex();
         sliceIndex ??= currentIndex;
         const { viewPlaneNormal, focalPoint } = this.getCamera();
-        const querySeparator = volumeId.indexOf('?') > -1 ? '&' : '?';
+        const querySeparator = volumeId.includes('?') ? '&' : '?';
         return `volumeId:${volumeId}${querySeparator}sliceIndex=${sliceIndex}&viewPlaneNormal=${viewPlaneNormal.join(',')}&focalPoint=${focalPoint.join(',')}`;
     }
+    _addVolumeId(volumeId) {
+        this.volumeIds.add(volumeId);
+    }
+    getAllVolumeIds() {
+        return Array.from(this.volumeIds);
+    }
 }
 export default BaseVolumeViewport;
-//# sourceMappingURL=BaseVolumeViewport.js.map

package/dist/esm/RenderingEngine/CanvasActor/CanvasMapper.d.ts

@@ -0,0 +1,6 @@
+import type CanvasActor from '.';
+export default class CanvasMapper {
+    private actor;
+    constructor(actor: CanvasActor);
+    getInputData(): any;
+}

package/dist/esm/RenderingEngine/CanvasActor/CanvasMapper.js

@@ -6,4 +6,3 @@ export default class CanvasMapper {
         return this.actor.getImage();
     }
 }
-//# sourceMappingURL=CanvasMapper.js.map

package/dist/esm/RenderingEngine/CanvasActor/CanvasProperties.d.ts

@@ -0,0 +1,15 @@
+import type CanvasActor from '.';
+export default class CanvasProperties {
+    private actor;
+    private opacity;
+    private outlineOpacity;
+    private transferFunction;
+    constructor(actor: CanvasActor);
+    setRGBTransferFunction(index: any, cfun: any): void;
+    setScalarOpacity(opacity: number): void;
+    setInterpolationTypeToNearest(): void;
+    setUseLabelOutline(): void;
+    setLabelOutlineOpacity(opacity: any): void;
+    setLabelOutlineThickness(): void;
+    getColor(index: number): any[];
+}

package/dist/esm/RenderingEngine/CanvasActor/CanvasProperties.js

@@ -27,4 +27,3 @@ export default class CanvasProperties {
         return [r, g, b, this.opacity];
     }
 }
-//# sourceMappingURL=CanvasProperties.js.map

package/dist/esm/RenderingEngine/CanvasActor/index.d.ts

@@ -0,0 +1,22 @@
+import type { IViewport } from '../../types/IViewport';
+import CanvasProperties from './CanvasProperties';
+import CanvasMapper from './CanvasMapper';
+export default class CanvasActor {
+    private image;
+    private derivedImage;
+    private canvasProperties;
+    private visibility;
+    private mapper;
+    private viewport;
+    protected className: string;
+    protected canvas: any;
+    constructor(viewport: IViewport, derivedImage: any);
+    protected renderRLE(viewport: any, context: any, voxelManager: any): void;
+    render(viewport: IViewport, context: CanvasRenderingContext2D): void;
+    getClassName(): string;
+    getProperty(): CanvasProperties;
+    setVisibility(visibility: boolean): void;
+    getMapper(): CanvasMapper;
+    isA(actorType: any): boolean;
+    getImage(): any;
+}

package/dist/esm/RenderingEngine/CanvasActor/index.js

@@ -75,7 +75,8 @@ export default class CanvasActor {
         const { voxelManager } = image;
         if (voxelManager) {
             if (voxelManager.map.getRun) {
-                return this.renderRLE(viewport, context, voxelManager);
+                this.renderRLE(viewport, context, voxelManager);
+                return;
             }
         }
         let { canvas } = this;
@@ -154,4 +155,3 @@ export default class CanvasActor {
         return this.image;
     }
 }
-//# sourceMappingURL=index.js.map