@cornerstonejs/core 2.0.0-beta.20 → 2.0.0-beta.22

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

@@ -1,22 +1,31 @@
-import { BlendModes, InterpolationType, OrientationAxis } from '../enums';
+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, IVolumeViewport } from '../types';
-import { VoiModifiedEventDetail } from '../types/EventTypes';
+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 implements IVolumeViewport {
     useCPURendering: boolean;
-    useNativeDataType: boolean;
     private _FrameOfReferenceUID;
-    protected initialTransferFunctionNodes: any;
+    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;
-    protected resetVolumeViewportClippingRange(): void;
     private setVOILUTFunction;
     private setColormap;
     private setOpacity;
@@ -39,9 +48,9 @@ declare abstract class BaseVolumeViewport extends Viewport implements IVolumeVie
     getDefaultProperties: (volumeId?: string) => VolumeViewportProperties;
     getProperties: (volumeId?: string) => VolumeViewportProperties;
     private getColormap;
-    setVolumes(volumeInputArray: Array<IVolumeInput>, immediate?: boolean, suppressEvents?: boolean): Promise<void>;
-    addVolumes(volumeInputArray: Array<IVolumeInput>, immediate?: boolean, suppressEvents?: boolean): Promise<void>;
-    removeVolumeActors(actorUIDs: Array<string>, immediate?: boolean): void;
+    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;
@@ -59,12 +68,13 @@ declare abstract class BaseVolumeViewport extends Viewport implements IVolumeVie
     protected _getOrientationVectors(orientation: OrientationAxis | OrientationVectors): OrientationVectors;
     getSlabThickness(): number;
     getIntensityFromWorld(point: Point3): number;
-    getImageIds: (volumeId?: string) => Array<string>;
-    abstract getCurrentImageId(): string;
-    protected getVolumeId(specifier?: ViewReferenceSpecifier): string;
+    getImageIds: (volumeId?: string) => string[];
+    abstract getCurrentImageId(): string | undefined;
+    getVolumeId(specifier?: ViewReferenceSpecifier): string;
     getViewReferenceId(specifier?: ViewReferenceSpecifier): string;
-    abstract setBlendMode(blendMode: BlendModes, filterActorUIDs?: Array<string>, immediate?: boolean): void;
-    abstract setSlabThickness(slabThickness: number, filterActorUIDs?: Array<string>): void;
+    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;
 }

package/dist/esm/RenderingEngine/BaseVolumeViewport.js

@@ -2,28 +2,37 @@ 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 } 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';
 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();
@@ -177,14 +186,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) {
+                if (!volume?.imageIds) {
                     return false;
                 }
                 const volumeImageURIs = volume.imageIds.map(imageIdToURI);
@@ -204,7 +213,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.');
         }
@@ -229,6 +237,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();
@@ -266,17 +277,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();
@@ -474,7 +476,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;
@@ -538,7 +540,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);
@@ -646,15 +649,18 @@ 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 actor = await createVolumeActor(volumeInputArray[i], this.element, this.id, suppressEvents);
             const uid = actorUID || volumeId;
             volumeActors.push({
                 uid,
@@ -680,11 +686,14 @@ 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 actor = await createVolumeActor(volumeInputArray[i], this.element, this.id, suppressEvents);
+            if (!visibility) {
                 actor.setVisibility(false);
             }
             const uid = actorUID || volumeId;
@@ -727,7 +736,7 @@ class BaseVolumeViewport extends Viewport {
         }
         let volumeActor;
         if (volumeId) {
-            volumeActor = this.getActor(volumeId)?.actor;
+            volumeActor = this.getActor(volumeId).actor;
         }
         if (!volumeActor) {
             volumeActor = actorEntries[0].actor;
@@ -738,11 +747,7 @@ class BaseVolumeViewport extends Viewport {
     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`);
             }
@@ -758,10 +763,7 @@ 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);
     }
     getImageData(volumeId) {
         const defaultActor = this.getDefaultActor();
@@ -782,16 +784,17 @@ 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,
         };
     }
     _setVolumeActors(volumeActorEntries) {
@@ -836,12 +839,8 @@ class BaseVolumeViewport extends Viewport {
         const { actor, uid } = actorEntry;
         const imageData = actor.getMapper().getInputData();
         const volume = cache.getVolume(uid);
-        const { dimensions } = volume;
         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();
@@ -852,7 +851,7 @@ class BaseVolumeViewport extends Viewport {
             return actorEntries.find((actorEntry) => actorEntry.actor.getClassName() === 'vtkVolume')?.uid;
         }
         return actorEntries.find((actorEntry) => actorEntry.actor.getClassName() === 'vtkVolume' &&
-            actorEntry.uid === specifier.volumeId)?.uid;
+            actorEntry.uid === specifier?.volumeId)?.uid;
     }
     getViewReferenceId(specifier = {}) {
         let { volumeId, sliceIndex: sliceIndex } = specifier;
@@ -866,8 +865,11 @@ class BaseVolumeViewport extends Viewport {
         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);
+    }
 }
 export default BaseVolumeViewport;

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

@@ -1,4 +1,4 @@
-import CanvasActor from '.';
+import type CanvasActor from '.';
 export default class CanvasMapper {
     private actor;
     constructor(actor: CanvasActor);

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

@@ -1,4 +1,4 @@
-import CanvasActor from '.';
+import type CanvasActor from '.';
 export default class CanvasProperties {
     private actor;
     private opacity;

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;

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

@@ -1,14 +1,12 @@
 import type IStackViewport from '../types/IStackViewport';
-import type IVideoViewport from '../types/IVideoViewport';
 import type IRenderingEngine from '../types/IRenderingEngine';
 import type IVolumeViewport from '../types/IVolumeViewport';
-import type { IViewport } from '../types/IViewport';
-import type { PublicViewportInput } from '../types/IViewport';
+import type { PublicViewportInput, IViewport } from '../types/IViewport';
 declare class RenderingEngine implements IRenderingEngine {
     readonly id: string;
     hasBeenDestroyed: boolean;
     offscreenMultiRenderWindow: any;
-    readonly offScreenCanvasContainer: any;
+    readonly offScreenCanvasContainer: HTMLDivElement;
     private _viewports;
     private _needsRender;
     private _animationFrameSet;
@@ -17,16 +15,16 @@ declare class RenderingEngine implements IRenderingEngine {
     constructor(id?: string);
     enableElement(viewportInputEntry: PublicViewportInput): void;
     disableElement(viewportId: string): void;
-    setViewports(publicViewportInputEntries: Array<PublicViewportInput>): void;
+    setViewports(publicViewportInputEntries: PublicViewportInput[]): void;
     resize(immediate?: boolean, keepCamera?: boolean): void;
     getViewport(viewportId: string): IViewport;
-    getViewports(): Array<IViewport>;
-    getStackViewports(): Array<IStackViewport>;
-    getVideoViewports(): Array<IVideoViewport>;
-    getVolumeViewports(): Array<IVolumeViewport>;
+    getViewports(): IViewport[];
+    getStackViewport(viewportId: string): IStackViewport;
+    getStackViewports(): IStackViewport[];
+    getVolumeViewports(): IVolumeViewport[];
     render(): void;
     renderFrameOfReference: (FrameOfReferenceUID: string) => void;
-    renderViewports(viewportIds: Array<string>): void;
+    renderViewports(viewportIds: string[]): void;
     renderViewport(viewportId: string): void;
     destroy(): void;
     fillCanvasWithBackgroundColor(canvas: HTMLCanvasElement, backgroundColor: [number, number, number]): void;

package/dist/esm/RenderingEngine/RenderingEngine.js

@@ -1,7 +1,8 @@
 import Events from '../enums/Events';
 import renderingEngineCache from './renderingEngineCache';
 import eventTarget from '../eventTarget';
-import { triggerEvent, uuidv4 } from '../utilities';
+import uuidv4 from '../utilities/uuidv4';
+import triggerEvent from '../utilities/triggerEvent';
 import { vtkOffscreenMultiRenderWindow } from './vtkClasses';
 import ViewportType from '../enums/ViewportType';
 import VolumeViewport from './VolumeViewport';
@@ -10,7 +11,6 @@ import StackViewport from './StackViewport';
 import viewportTypeUsesCustomRenderingPipeline from './helpers/viewportTypeUsesCustomRenderingPipeline';
 import getOrCreateCanvas from './helpers/getOrCreateCanvas';
 import { getShouldUseCPURendering, isCornerstoneInitialized } from '../init';
-import VideoViewport from './VideoViewport';
 import viewportTypeToViewportClass from './helpers/viewportTypeToViewportClass';
 import { OrientationAxis } from '../enums';
 import VolumeViewport3D from './VolumeViewport3D';
@@ -27,7 +27,7 @@ class RenderingEngine {
                     return vp.id;
                 }
             });
-            return this.renderViewports(viewportIdsWithSameFrameOfReferenceUID);
+            this.renderViewports(viewportIdsWithSameFrameOfReferenceUID);
         };
         this._renderFlaggedViewports = () => {
             this._throwIfDestroyed();
@@ -165,21 +165,21 @@ class RenderingEngine {
         this._throwIfDestroyed();
         return this._getViewportsAsArray();
     }
-    getStackViewports() {
+    getStackViewport(viewportId) {
         this._throwIfDestroyed();
-        const viewports = this.getViewports();
-        const isStackViewport = (viewport) => {
-            return viewport instanceof StackViewport;
-        };
-        return viewports.filter(isStackViewport);
+        const viewport = this.getViewport(viewportId);
+        if (!viewport) {
+            throw new Error(`Viewport with Id ${viewportId} does not exist`);
+        }
+        if (!(viewport instanceof StackViewport)) {
+            throw new Error(`Viewport with Id ${viewportId} is not a StackViewport.`);
+        }
+        return viewport;
     }
-    getVideoViewports() {
+    getStackViewports() {
         this._throwIfDestroyed();
         const viewports = this.getViewports();
-        const isVideoViewport = (viewport) => {
-            return viewport instanceof VideoViewport;
-        };
-        return viewports.filter(isVideoViewport);
+        return viewports.filter((vp) => vp instanceof StackViewport);
     }
     getVolumeViewports() {
         this._throwIfDestroyed();
@@ -270,7 +270,7 @@ class RenderingEngine {
                 vp.setCamera(prevCamera);
             }
         });
-        if (immediate === true) {
+        if (immediate) {
             this.render();
         }
     }
@@ -314,7 +314,7 @@ class RenderingEngine {
                 }
             }
         });
-        if (immediate === true) {
+        if (immediate) {
             this.render();
         }
     }
@@ -426,7 +426,9 @@ class RenderingEngine {
         triggerEvent(eventTarget, Events.ELEMENT_ENABLED, eventDetail);
     }
     setCustomViewports(viewportInputEntries) {
-        viewportInputEntries.forEach((vpie) => this.addCustomViewport(vpie));
+        viewportInputEntries.forEach((vpie) => {
+            this.addCustomViewport(vpie);
+        });
     }
     setVtkjsDrivenViewports(viewportInputEntries) {
         if (viewportInputEntries.length) {
@@ -517,7 +519,7 @@ class RenderingEngine {
         this._render();
     }
     _render() {
-        if (this._needsRender.size > 0 && this._animationFrameSet === false) {
+        if (this._needsRender.size > 0 && !this._animationFrameSet) {
             this._animationFrameHandle = window.requestAnimationFrame(this._renderFlaggedViewports);
             this._animationFrameSet = true;
         }

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

@@ -1,12 +1,12 @@
 import type { vtkImageData as vtkImageDataType } from '@kitware/vtk.js/Common/DataModel/ImageData';
-import type { ActorEntry, CPUIImageData, ICamera, IImage, IImageData, IImagesLoader, IStackInput, IStackViewport, ImageLoadListener, Mat3, Point2, Point3, Scaling, StackViewportProperties, ViewReference } from '../types';
-import { ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewportInput } from '../types/IViewport';
+import { mat4 } from 'gl-matrix';
+import type { ActorEntry, CPUIImageData, ICamera, IImage, IImageData, IImagesLoader, IStackInput, IStackViewport, ImageLoadListener, Mat3, Point2, Point3, Scaling, StackViewportProperties, ViewReference, ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewportInput, ImagePixelModule, ImagePlaneModule } from '../types';
 import Viewport from './Viewport';
 import { InterpolationType, RequestType, ViewportStatus } from '../enums';
-import { ImagePixelModule, ImagePlaneModule } from '../types';
-interface ImageDataMetaData {
+import type vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
+export interface ImageDataMetaData {
     bitsAllocated: number;
-    numComps: number;
+    numberOfComponents: number;
     origin: Point3;
     direction: Mat3;
     dimensions: Point3;
@@ -38,7 +38,6 @@ declare class StackViewport extends Viewport implements IStackViewport, IImagesL
     private _calibrationEvent;
     private _cpuFallbackEnabledElement?;
     private useCPURendering;
-    private useNativeDataType;
     private cpuImagePixelData;
     private cpuRenderingInvalidated;
     private csImage;
@@ -61,12 +60,12 @@ declare class StackViewport extends Viewport implements IStackViewport, IImagesL
     resetCamera: (options?: any) => boolean;
     canvasToWorld: (canvasPos: Point2) => Point3;
     worldToCanvas: (worldPos: Point3) => Point2;
-    getRenderer: () => any;
+    getRenderer: () => vtkRenderer;
     getDefaultActor: () => ActorEntry;
-    getActors: () => Array<ActorEntry>;
+    getActors: () => ActorEntry[];
     getActor: (actorUID: string) => ActorEntry;
-    setActors: (actors: Array<ActorEntry>) => void;
-    addActors: (actors: Array<ActorEntry>) => void;
+    setActors: (actors: ActorEntry[]) => void;
+    addActors: (actors: ActorEntry[]) => void;
     addActor: (actorEntry: ActorEntry) => void;
     removeAllActors: () => void;
     private setVOI;
@@ -118,16 +117,16 @@ declare class StackViewport extends Viewport implements IStackViewport, IImagesL
     getImageDataMetadata(image: IImage): ImageDataMetaData;
     getImagePlaneReferenceData(sliceIndex?: number): ViewReference;
     private _getCameraOrientation;
-    createVTKImageData({ origin, direction, dimensions, spacing, numComps, pixelArray, }: {
+    createVTKImageData({ origin, direction, dimensions, spacing, numberOfComponents, pixelArray, }: {
         origin: any;
         direction: any;
         dimensions: any;
         spacing: any;
-        numComps: any;
+        numberOfComponents: any;
         pixelArray: any;
     }): vtkImageDataType;
     private _createVTKImageData;
-    setStack(imageIds: Array<string>, currentImageIdIndex?: number): Promise<string>;
+    setStack(imageIds: string[], currentImageIdIndex?: number): Promise<string>;
     private _throwIfDestroyed;
     private _checkVTKImageDataMatchesCornerstoneImage;
     private _updateVTKImageDataFromCornerstoneImage;
@@ -136,12 +135,8 @@ declare class StackViewport extends Viewport implements IStackViewport, IImagesL
     successCallback(imageId: any, image: any): void;
     errorCallback(imageId: any, permanent: any, error: any): void;
     getLoaderImageOptions(imageId: string): {
-        targetBuffer: {
-            type: string;
-        };
         useRGBA: boolean;
         transferSyntaxUID: any;
-        useNativeDataType: boolean;
         priority: number;
         requestType: RequestType;
         additionalDetails: {
@@ -154,7 +149,15 @@ declare class StackViewport extends Viewport implements IStackViewport, IImagesL
     renderImageObject: (image: any) => void;
     private _setCSImage;
     private _updateToDisplayImageCPU;
-    addImages(stackInputs: Array<IStackInput>): void;
+    getSliceViewInfo(): {
+        width: number;
+        height: number;
+        sliceIndex: number;
+        slicePlane: number;
+        sliceToIndexMatrix: mat4;
+        indexToSliceMatrix: mat4;
+    };
+    addImages(stackInputs: IStackInput[]): void;
     private _updateActorToDisplayImageId;
     private _getInitialVOIRange;
     private _getPTPreScaledRange;
@@ -178,12 +181,18 @@ declare class StackViewport extends Viewport implements IStackViewport, IImagesL
     private _getValidVOILUTFunction;
     getCurrentImageIdIndex: () => number;
     getSliceIndex: () => number;
+    getSliceInfo(): {
+        sliceIndex: number;
+        slicePlane: number;
+        width: number;
+        height: number;
+    };
     isReferenceViewable(viewRef: ViewReference, options?: ReferenceCompatibleOptions): boolean | unknown;
     getViewReference(viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
     setViewReference(viewRef: ViewReference): void;
     getViewReferenceId(specifier?: ViewReferenceSpecifier): string;
     getTargetImageIdIndex: () => number;
-    getImageIds: () => Array<string>;
+    getImageIds: () => string[];
     getCurrentImageId: () => string;
     hasImageId: (imageId: string) => boolean;
     hasImageURI: (imageURI: string) => boolean;