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

package/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/renderColorImage.d.ts

@@ -1,2 +1,2 @@
-import { CPUFallbackEnabledElement } from '../../../../types';
+import type { CPUFallbackEnabledElement } from '../../../../types';
 export declare function renderColorImage(enabledElement: CPUFallbackEnabledElement, invalidated: boolean): void;

package/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/renderColorImage.js

@@ -20,7 +20,7 @@ function getLut(image, viewport) {
     return image.cachedLut.lutArray;
 }
 function getRenderCanvas(enabledElement, image, invalidated) {
-    const canvasWasColor = enabledElement.renderingTools.lastRenderedIsColor === true;
+    const canvasWasColor = enabledElement.renderingTools.lastRenderedIsColor;
     if (!enabledElement.renderingTools.renderCanvas || !canvasWasColor) {
         enabledElement.renderingTools.renderCanvas =
             document.createElement('canvas');
@@ -29,13 +29,12 @@ function getRenderCanvas(enabledElement, image, invalidated) {
     const { windowWidth, windowCenter } = enabledElement.viewport.voi;
     if ((windowWidth === 256 || windowWidth === 255) &&
         (windowCenter === 128 || windowCenter === 127) &&
-        enabledElement.viewport.invert === false &&
+        !enabledElement.viewport.invert &&
         image.getCanvas &&
         image.getCanvas()) {
         return image.getCanvas();
     }
-    if (doesImageNeedToBeRendered(enabledElement, image) === false &&
-        invalidated !== true) {
+    if (!doesImageNeedToBeRendered(enabledElement, image) && !invalidated) {
         return renderCanvas;
     }
     if (renderCanvas.width !== image.width ||

package/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/renderGrayscaleImage.d.ts

@@ -1,2 +1,2 @@
-import { CPUFallbackEnabledElement } from '../../../../types';
+import type { CPUFallbackEnabledElement } from '../../../../types';
 export declare function renderGrayscaleImage(enabledElement: CPUFallbackEnabledElement, invalidated: boolean): void;

package/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/renderGrayscaleImage.js

@@ -8,15 +8,14 @@ import doesImageNeedToBeRendered from './doesImageNeedToBeRendered';
 import initializeRenderCanvas from './initializeRenderCanvas';
 import saveLastRendered from './saveLastRendered';
 function getRenderCanvas(enabledElement, image, invalidated, useAlphaChannel = true) {
-    const canvasWasColor = enabledElement.renderingTools.lastRenderedIsColor === true;
+    const canvasWasColor = enabledElement.renderingTools.lastRenderedIsColor;
     if (!enabledElement.renderingTools.renderCanvas || canvasWasColor) {
         enabledElement.renderingTools.renderCanvas =
             document.createElement('canvas');
         initializeRenderCanvas(enabledElement, image);
     }
     const renderCanvas = enabledElement.renderingTools.renderCanvas;
-    if (doesImageNeedToBeRendered(enabledElement, image) === false &&
-        invalidated !== true) {
+    if (!doesImageNeedToBeRendered(enabledElement, image) && !invalidated) {
         return renderCanvas;
     }
     if (renderCanvas.width !== image.width ||

package/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/renderPseudoColorImage.js

@@ -25,8 +25,8 @@ function getRenderCanvas(enabledElement, image, invalidated) {
         throw new Error('renderPseudoColorImage: colormap not found.');
     }
     const colormapId = colormap.getId();
-    if (doesImageNeedToBeRendered(enabledElement, image) === false &&
-        invalidated !== true &&
+    if (!doesImageNeedToBeRendered(enabledElement, image) &&
+        !invalidated &&
         enabledElement.renderingTools.colormapId === colormapId) {
         return renderCanvas;
     }

package/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/resetCamera.d.ts

@@ -1,2 +1,2 @@
-import { CPUFallbackEnabledElement } from '../../../../types';
+import type { CPUFallbackEnabledElement } from '../../../../types';
 export default function (enabledElement: CPUFallbackEnabledElement, resetPan?: boolean, resetZoom?: boolean): void;

package/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/resize.d.ts

@@ -1,2 +1,2 @@
-import { CPUFallbackEnabledElement } from '../../../../types';
+import type { CPUFallbackEnabledElement } from '../../../../types';
 export default function (enabledElement: CPUFallbackEnabledElement, forceFitToWindow?: boolean): void;

package/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/saveLastRendered.d.ts

@@ -1,2 +1,2 @@
-import { CPUFallbackEnabledElement, CPUFallbackRenderingTools } from '../../../../types';
+import type { CPUFallbackEnabledElement, CPUFallbackRenderingTools } from '../../../../types';
 export default function (enabledElement: CPUFallbackEnabledElement): CPUFallbackRenderingTools;

package/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/setDefaultViewport.d.ts

@@ -1,4 +1,4 @@
-import { CPUFallbackViewport } from '../../../../types';
+import type { CPUFallbackViewport } from '../../../../types';
 declare const state: {
     viewport: {};
 };

package/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/setToPixelCoordinateSystem.d.ts

@@ -1,2 +1,2 @@
-import { CPUFallbackEnabledElement } from '../../../../types';
+import type { CPUFallbackEnabledElement } from '../../../../types';
 export default function (enabledElement: CPUFallbackEnabledElement, context: CanvasRenderingContext2D, scale?: number): void;

package/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/storedColorPixelDataToCanvasImageData.d.ts

@@ -1,2 +1,2 @@
-import { IImage } from '../../../../types';
+import type { IImage } from '../../../../types';
 export default function (image: IImage, lut: Uint8ClampedArray, canvasImageDataData: Uint8ClampedArray): void;

package/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/storedColorPixelDataToCanvasImageData.js

@@ -1,7 +1,7 @@
 import now from './now';
 export default function (image, lut, canvasImageDataData) {
     let start = now();
-    const pixelData = image.getPixelData();
+    const pixelData = image.voxelManager.getScalarData();
     image.stats.lastGetPixelDataTime = now() - start;
     const minPixelValue = image.minPixelValue;
     let canvasImageDataIndex = 0;

package/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/storedPixelDataToCanvasImageData.d.ts

@@ -1,2 +1,2 @@
-import { IImage } from '../../../../types';
+import type { IImage } from '../../../../types';
 export default function (image: IImage, lut: Uint8ClampedArray, canvasImageDataData: Uint8ClampedArray): void;

package/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/storedPixelDataToCanvasImageData.js

@@ -1,7 +1,7 @@
 import now from './now';
 export default function (image, lut, canvasImageDataData) {
     let start = now();
-    const pixelData = image.getPixelData();
+    const pixelData = image.voxelManager.getScalarData();
     image.stats.lastGetPixelDataTime = now() - start;
     const numPixels = pixelData.length;
     const minPixelValue = image.minPixelValue;

package/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/storedPixelDataToCanvasImageDataColorLUT.js

@@ -2,7 +2,7 @@ import * as colors from '../colors';
 import now from './now';
 function storedPixelDataToCanvasImageDataColorLUT(image, colorLUT, canvasImageDataData) {
     let start = now();
-    const pixelData = image.getPixelData();
+    const pixelData = image.voxelManager.getScalarData();
     image.stats.lastGetPixelDataTime = now() - start;
     const numPixels = pixelData.length;
     const minPixelValue = image.minPixelValue;

package/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/storedPixelDataToCanvasImageDataPET.d.ts

@@ -1,2 +1,2 @@
-import { IImage } from '../../../../types';
+import type { IImage } from '../../../../types';
 export default function (image: IImage, lutFunction: (value: number) => number, canvasImageDataData: Uint8ClampedArray): void;

package/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/storedPixelDataToCanvasImageDataPET.js

@@ -1,7 +1,7 @@
 import now from './now';
 export default function (image, lutFunction, canvasImageDataData) {
     let start = now();
-    const pixelData = image.getPixelData();
+    const pixelData = image.voxelManager.getScalarData();
     image.stats.lastGetPixelDataTime = now() - start;
     const numPixels = pixelData.length;
     let canvasImageDataIndex = 3;

package/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/storedPixelDataToCanvasImageDataPseudocolorLUT.js

@@ -2,7 +2,7 @@ import * as colors from '../colors/index';
 import now from './now';
 function storedPixelDataToCanvasImageDataPseudocolorLUT(image, grayscaleLut, colorLUT, canvasImageDataData) {
     let start = now();
-    const pixelData = image.getPixelData();
+    const pixelData = image.voxelManager.getScalarData();
     image.stats.lastGetPixelDataTime = now() - start;
     const numPixels = pixelData.length;
     const minPixelValue = image.minPixelValue;

package/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/storedPixelDataToCanvasImageDataPseudocolorLUTPET.js

@@ -2,7 +2,7 @@ import * as colors from '../colors/index';
 import now from './now';
 function storedPixelDataToCanvasImageDataPseudocolorLUTPET(image, lutFunction, colorLUT, canvasImageDataData) {
     let start = now();
-    const pixelData = image.getPixelData();
+    const pixelData = image.voxelManager.getScalarData();
     image.stats.lastGetPixelDataTime = now() - start;
     const numPixels = pixelData.length;
     const minPixelValue = image.minPixelValue;

package/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/storedPixelDataToCanvasImageDataRGBA.d.ts

@@ -1,2 +1,2 @@
-import { IImage } from '../../../../types';
+import type { IImage } from '../../../../types';
 export default function (image: IImage, lut: Uint8ClampedArray, canvasImageDataData: Uint8ClampedArray): void;

package/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/storedPixelDataToCanvasImageDataRGBA.js

@@ -1,7 +1,7 @@
 import now from './now';
 export default function (image, lut, canvasImageDataData) {
     let start = now();
-    const pixelData = image.getPixelData();
+    const pixelData = image.voxelManager.getScalarData();
     image.stats.lastGetPixelDataTime = now() - start;
     const numPixels = pixelData.length;
     const minPixelValue = image.minPixelValue;

package/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/storedRGBAPixelDataToCanvasImageData.d.ts

@@ -1,2 +1,2 @@
-import { IImage } from '../../../../types';
+import type { IImage } from '../../../../types';
 export default function (image: IImage, lut: Uint8ClampedArray, canvasImageDataData: Uint8ClampedArray): void;

package/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/storedRGBAPixelDataToCanvasImageData.js

@@ -1,7 +1,7 @@
 import now from './now';
 export default function (image, lut, canvasImageDataData) {
     let start = now();
-    const pixelData = image.getPixelData();
+    const pixelData = image.voxelManager.getScalarData();
     image.stats.lastGetPixelDataTime = now() - start;
     const minPixelValue = image.minPixelValue;
     let canvasImageDataIndex = 0;

package/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/transform.d.ts

@@ -1,4 +1,4 @@
-import { CPUFallbackTransform, Point2, TransformMatrix2D } from '../../../../types';
+import type { CPUFallbackTransform, Point2, TransformMatrix2D } from '../../../../types';
 export declare class Transform implements CPUFallbackTransform {
     private m;
     constructor();

package/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/validator.d.ts

@@ -1,2 +1,2 @@
-export declare function validateParameterUndefined(checkParam: any | undefined, errorMsg: string): void;
-export declare function validateParameterUndefinedOrNull(checkParam: any | null | undefined, errorMsg: string): void;
+export declare function validateParameterUndefined(checkParam: unknown, errorMsg: string): void;
+export declare function validateParameterUndefinedOrNull(checkParam: unknown, errorMsg: string): void;

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

@@ -1,5 +1,5 @@
-import { VolumeActor } from './../../types/IActor';
-import BlendModes from '../../enums/BlendModes';
+import type { VolumeActor } from './../../types/IActor';
+import type BlendModes from '../../enums/BlendModes';
 interface createVolumeActorInterface {
     volumeId: string;
     callback?: ({ volumeActor, volumeId, }: {
@@ -8,5 +8,5 @@ interface createVolumeActorInterface {
     }) => void;
     blendMode?: BlendModes;
 }
-declare function createVolumeActor(props: createVolumeActorInterface, element: HTMLDivElement, viewportId: string, suppressEvents?: boolean, useNativeDataType?: boolean): Promise<VolumeActor>;
+declare function createVolumeActor(props: createVolumeActorInterface, element: HTMLDivElement, viewportId: string, suppressEvents?: boolean): Promise<VolumeActor>;
 export default createVolumeActor;

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

@@ -4,7 +4,7 @@ import createVolumeMapper from './createVolumeMapper';
 import { triggerEvent } from '../../utilities';
 import { Events } from '../../enums';
 import setDefaultVolumeVOI from './setDefaultVolumeVOI';
-async function createVolumeActor(props, element, viewportId, suppressEvents = false, useNativeDataType = false) {
+async function createVolumeActor(props, element, viewportId, suppressEvents = false) {
     const { volumeId, callback, blendMode } = props;
     const imageVolume = await loadVolume(volumeId);
     if (!imageVolume) {
@@ -17,14 +17,11 @@ async function createVolumeActor(props, element, viewportId, suppressEvents = fa
     }
     const volumeActor = vtkVolume.newInstance();
     volumeActor.setMapper(volumeMapper);
-    const numberOfComponents = imageData
-        .getPointData()
-        .getScalars()
-        .getNumberOfComponents();
+    const { numberOfComponents } = imageData.get('numberOfComponents');
     if (numberOfComponents === 3) {
         volumeActor.getProperty().setIndependentComponents(false);
     }
-    await setDefaultVolumeVOI(volumeActor, imageVolume, useNativeDataType);
+    await setDefaultVolumeVOI(volumeActor, imageVolume);
     if (callback) {
         callback({ volumeActor, volumeId });
     }

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

@@ -1 +1,4 @@
-export default function createVolumeMapper(imageData: any, vtkOpenGLTexture: any): any;
+import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import type vtkOpenGLTexture from '@kitware/vtk.js/Rendering/OpenGL/Texture';
+import type vtkVolumeMapper from '@kitware/vtk.js/Rendering/Core/VolumeMapper';
+export default function createVolumeMapper(imageData: vtkImageData, vtkOpenGLTexture: vtkOpenGLTexture): vtkVolumeMapper;

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

@@ -25,15 +25,16 @@ export default function getOrCreateCanvas(element) {
     const canvasSelector = `canvas.${CANVAS_CSS_CLASS}`;
     const viewportElement = `div.${VIEWPORT_ELEMENT}`;
     const internalDiv = element.querySelector(viewportElement) || createViewportElement(element);
-    const canvas = (internalDiv.querySelector(canvasSelector) ||
-        createCanvas(internalDiv));
+    const existingCanvas = internalDiv.querySelector(canvasSelector);
+    if (existingCanvas) {
+        return existingCanvas;
+    }
+    const canvas = createCanvas(internalDiv);
     const rect = internalDiv.getBoundingClientRect();
     const devicePixelRatio = window.devicePixelRatio || 1;
     const width = Math.ceil(rect.width * devicePixelRatio);
     const height = Math.ceil(rect.height * devicePixelRatio);
     canvas.width = width;
     canvas.height = height;
-    canvas.style.width = (width + EPSILON) / devicePixelRatio + 'px';
-    canvas.style.height = (height + EPSILON) / devicePixelRatio + 'px';
     return canvas;
 }

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

@@ -1,3 +1,3 @@
-import { VolumeActor, IImageVolume } from '../../types';
-declare function setDefaultVolumeVOI(volumeActor: VolumeActor, imageVolume: IImageVolume, useNativeDataType: boolean): Promise<void>;
+import type { VolumeActor, IImageVolume } from '../../types';
+declare function setDefaultVolumeVOI(volumeActor: VolumeActor, imageVolume: IImageVolume): Promise<void>;
 export default setDefaultVolumeVOI;

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

@@ -5,15 +5,15 @@ import { RequestType } from '../../enums';
 import cache from '../../cache';
 const PRIORITY = 0;
 const REQUEST_TYPE = RequestType.Prefetch;
-async function setDefaultVolumeVOI(volumeActor, imageVolume, useNativeDataType) {
+async function setDefaultVolumeVOI(volumeActor, imageVolume) {
     let voi = getVOIFromMetadata(imageVolume);
-    if (!voi && imageVolume?.imageIds?.length) {
-        voi = await getVOIFromMinMax(imageVolume, useNativeDataType);
+    if (!voi && imageVolume.imageIds.length) {
+        voi = await getVOIFromMiddleSliceMinMax(imageVolume);
         voi = handlePreScaledVolume(imageVolume, voi);
     }
-    if ((voi?.lower === 0 && voi?.upper === 0) ||
-        voi?.lower === undefined ||
-        voi?.upper === undefined) {
+    if ((voi.lower === 0 && voi.upper === 0) ||
+        voi.lower === undefined ||
+        voi.upper === undefined) {
         return;
     }
     volumeActor
@@ -41,7 +41,7 @@ function getVOIFromMetadata(imageVolume) {
         const imageIdIndex = Math.floor(imageIds.length / 2);
         const imageId = imageIds[imageIdIndex];
         const voiLutModule = metaData.get('voiLutModule', imageId);
-        if (voiLutModule && voiLutModule.windowWidth && voiLutModule.windowCenter) {
+        if (voiLutModule?.windowWidth && voiLutModule.windowCenter) {
             const { windowWidth, windowCenter } = voiLutModule;
             voi = {
                 windowWidth: Array.isArray(windowWidth) ? windowWidth[0] : windowWidth,
@@ -52,7 +52,7 @@ function getVOIFromMetadata(imageVolume) {
         }
     }
     else {
-        voi = metadata?.voiLut?.[0];
+        voi = metadata.voiLut[0];
     }
     if (voi) {
         const { lower, upper } = windowLevel.toLowHighRange(Number(voi.windowWidth), Number(voi.windowCenter));
@@ -62,18 +62,13 @@ function getVOIFromMetadata(imageVolume) {
         };
     }
 }
-async function getVOIFromMinMax(imageVolume, useNativeDataType) {
+async function getVOIFromMiddleSliceMinMax(imageVolume) {
     const { imageIds } = imageVolume;
-    const scalarData = imageVolume.getScalarData();
     const imageIdIndex = Math.floor(imageIds.length / 2);
     const imageId = imageVolume.imageIds[imageIdIndex];
     const generalSeriesModule = metaData.get('generalSeriesModule', imageId) || {};
     const { modality } = generalSeriesModule;
     const modalityLutModule = metaData.get('modalityLutModule', imageId) || {};
-    const numImages = imageIds.length;
-    const bytesPerImage = scalarData.byteLength / numImages;
-    const voxelsPerImage = scalarData.length / numImages;
-    const bytePerPixel = scalarData.BYTES_PER_ELEMENT;
     const scalingParameters = {
         rescaleSlope: modalityLutModule.rescaleSlope,
         rescaleIntercept: modalityLutModule.rescaleIntercept,
@@ -89,16 +84,10 @@ async function getVOIFromMinMax(imageVolume, useNativeDataType) {
             };
         }
     }
-    const byteOffset = imageIdIndex * bytesPerImage;
     const options = {
-        targetBuffer: {
-            type: useNativeDataType ? undefined : 'Float32Array',
-        },
         priority: PRIORITY,
         requestType: REQUEST_TYPE,
-        useNativeDataType,
         preScale: {
-            enabled: true,
             scalingParameters: scalingParametersToUse,
         },
     };
@@ -106,27 +95,13 @@ async function getVOIFromMinMax(imageVolume, useNativeDataType) {
     if (!imageVolume.referencedImageIds?.length) {
         image = await loadAndCacheImage(imageId, { ...options, ignoreCache: true });
     }
-    const imageScalarData = image
-        ? image.getPixelData()
-        : _getImageScalarDataFromImageVolume(imageVolume, byteOffset, bytePerPixel, voxelsPerImage);
+    const imageScalarData = image.getPixelData();
     const { min, max } = getMinMax(imageScalarData);
     return {
         lower: min,
         upper: max,
     };
 }
-function _getImageScalarDataFromImageVolume(imageVolume, byteOffset, bytePerPixel, voxelsPerImage) {
-    const { scalarData } = imageVolume;
-    const { buffer } = scalarData;
-    if (scalarData.BYTES_PER_ELEMENT !== bytePerPixel) {
-        byteOffset *= scalarData.BYTES_PER_ELEMENT / bytePerPixel;
-    }
-    const TypedArray = scalarData.constructor;
-    const imageScalarData = new TypedArray(voxelsPerImage);
-    const volumeBufferView = new TypedArray(buffer, byteOffset, voxelsPerImage);
-    imageScalarData.set(volumeBufferView);
-    return imageScalarData;
-}
 function _isCurrentImagePTPrescaled(modality, imageVolume) {
     if (modality !== 'PT' || !imageVolume.isPreScaled) {
         return false;

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

@@ -1,3 +1,3 @@
 import type { IVolumeInput, IRenderingEngine } from '../../types';
-declare function setVolumesForViewports(renderingEngine: IRenderingEngine, volumeInputs: Array<IVolumeInput>, viewportIds: Array<string>, immediateRender?: boolean, suppressEvents?: boolean): Promise<void>;
+declare function setVolumesForViewports(renderingEngine: IRenderingEngine, volumeInputs: IVolumeInput[], viewportIds: string[], immediateRender?: boolean, suppressEvents?: boolean): Promise<void>;
 export default setVolumesForViewports;

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

@@ -2,11 +2,13 @@ import StackViewport from '../StackViewport';
 import VolumeViewport from '../VolumeViewport';
 import VolumeViewport3D from '../VolumeViewport3D';
 import VideoViewport from '../VideoViewport';
+import WSIViewport from '../WSIViewport';
 declare const viewportTypeToViewportClass: {
     orthographic: typeof VolumeViewport;
     perspective: typeof VolumeViewport;
     stack: typeof StackViewport;
     volume3d: typeof VolumeViewport3D;
     video: typeof VideoViewport;
+    wholeSlide: typeof WSIViewport;
 };
 export default viewportTypeToViewportClass;

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

@@ -3,11 +3,13 @@ import VolumeViewport from '../VolumeViewport';
 import ViewportType from '../../enums/ViewportType';
 import VolumeViewport3D from '../VolumeViewport3D';
 import VideoViewport from '../VideoViewport';
+import WSIViewport from '../WSIViewport';
 const viewportTypeToViewportClass = {
     [ViewportType.ORTHOGRAPHIC]: VolumeViewport,
     [ViewportType.PERSPECTIVE]: VolumeViewport,
     [ViewportType.STACK]: StackViewport,
     [ViewportType.VOLUME_3D]: VolumeViewport3D,
     [ViewportType.VIDEO]: VideoViewport,
+    [ViewportType.WholeSlide]: WSIViewport,
 };
 export default viewportTypeToViewportClass;

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

@@ -1,4 +1,4 @@
-import { EventTypes } from '../../types';
+import type { EventTypes } from '../../types';
 export declare function resetVolumeNewImageState(viewportId: string): void;
 declare function volumeNewImageEventDispatcher(cameraEvent: EventTypes.CameraModifiedEvent): void;
 export default volumeNewImageEventDispatcher;

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

@@ -3,6 +3,6 @@ declare const renderingEngineCache: {
     get: (id: string) => IRenderingEngine;
     set: (re: IRenderingEngine) => void;
     delete: (id: string) => boolean;
-    getAll: () => Array<IRenderingEngine>;
+    getAll: () => IRenderingEngine[];
 };
 export default renderingEngineCache;

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

@@ -1,5 +1,6 @@
 import { mat4 } from 'gl-matrix';
 import type { vtkObject } from '@kitware/vtk.js/interfaces';
+import type { Range } from '@kitware/vtk.js/types';
 interface ICameraInitialValues {
     position?: number[];
     focalPoint?: number[];
@@ -25,7 +26,7 @@ interface ICameraInitialValues {
 export interface vtkSlabCamera extends vtkObject {
     applyTransform(transformMat4: mat4): void;
     azimuth(angle: number): void;
-    computeClippingRange(bounds: number[]): number[];
+    computeClippingRange(bounds: number[]): Range;
     computeDistance(): void;
     computeViewParametersFromPhysicalMatrix(mat: mat4): void;
     computeViewParametersFromViewMatrix(vmat: mat4): void;
@@ -80,7 +81,7 @@ export interface vtkSlabCamera extends vtkObject {
     getWorldToPhysicalMatrix(result: mat4): void;
     getIsPerformingCoordinateTransformation(status: boolean): void;
     orthogonalizeViewUp(): void;
-    physicalOrientationToWorldDirection(ori: number[]): any;
+    physicalOrientationToWorldDirection(ori: number[]): number[];
     pitch(angle: number): void;
     roll(angle: number): void;
     setClippingRange(near: number, far: number): boolean;
@@ -129,6 +130,7 @@ export interface vtkSlabCamera extends vtkObject {
     yaw(angle: number): void;
     zoom(factor: number): void;
     setIsPerformingCoordinateTransformation(status: boolean): void;
+    computeCameraLightTransform(): void;
 }
 declare function extend(publicAPI: any, model: any, initialValues?: ICameraInitialValues): void;
 declare const newInstance: (initialValues?: ICameraInitialValues) => vtkSlabCamera;