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

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

@@ -1,3 +1,3 @@
 import type { IStackInput, IRenderingEngine } from '../../types';
-declare function addImageSlicesToViewports(renderingEngine: IRenderingEngine, stackInputs: Array<IStackInput>, viewportIds: Array<string>): Promise<void>;
+declare function addImageSlicesToViewports(renderingEngine: IRenderingEngine, stackInputs: IStackInput[], viewportIds: string[]): Promise<void>;
 export default addImageSlicesToViewports;

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

@@ -1,6 +1,6 @@
 async function addImageSlicesToViewports(renderingEngine, stackInputs, viewportIds) {
     for (const viewportId of viewportIds) {
-        const viewport = renderingEngine.getViewport(viewportId);
+        const viewport = renderingEngine.getStackViewport(viewportId);
         if (!viewport) {
             throw new Error(`Viewport with Id ${viewportId} does not exist`);
         }
@@ -10,8 +10,8 @@ async function addImageSlicesToViewports(renderingEngine, stackInputs, viewportI
         }
     }
     const addStackPromises = viewportIds.map(async (viewportId) => {
-        const viewport = renderingEngine.getViewport(viewportId);
-        return viewport.addImages(stackInputs);
+        const viewport = renderingEngine.getStackViewport(viewportId);
+        viewport.addImages(stackInputs);
     });
     await Promise.all(addStackPromises);
 }

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

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

package/dist/esm/RenderingEngine/helpers/cpuFallback/colors/colormap.d.ts

@@ -1,3 +1,3 @@
-import { CPUFallbackColormap, CPUFallbackColormapData } from '../../../../types';
+import type { CPUFallbackColormap, CPUFallbackColormapData } from '../../../../types';
 export declare function getColormapsList(): any[];
 export declare function getColormap(id: string, colormapData?: CPUFallbackColormapData): CPUFallbackColormap;

package/dist/esm/RenderingEngine/helpers/cpuFallback/colors/colormap.js

@@ -91,7 +91,7 @@ export function getColormapsList() {
     const colormaps = [];
     const keys = Object.keys(CPU_COLORMAPS);
     keys.forEach(function (key) {
-        if (CPU_COLORMAPS.hasOwnProperty(key)) {
+        if (Object.prototype.hasOwnProperty.call(CPU_COLORMAPS, key)) {
             const colormap = CPU_COLORMAPS[key];
             colormaps.push({
                 id: key,

package/dist/esm/RenderingEngine/helpers/cpuFallback/colors/lookupTable.d.ts

@@ -1,4 +1,4 @@
-import { Point2, Point4, CPUFallbackLookupTable } from '../../../../types';
+import type { Point2, Point4, CPUFallbackLookupTable } from '../../../../types';
 declare class LookupTable implements CPUFallbackLookupTable {
     NumberOfColors: number;
     Ramp: string;
@@ -28,6 +28,6 @@ declare class LookupTable implements CPUFallbackLookupTable {
     private buildSpecialColors;
     private mapValue;
     private getIndex;
-    setTableValue(index: any, rgba: any): void;
+    setTableValue(index: number, rgba: Point4 | number, g?: number, b?: number, a?: number): void;
 }
 export default LookupTable;

package/dist/esm/RenderingEngine/helpers/cpuFallback/colors/lookupTable.js

@@ -227,17 +227,27 @@ class LookupTable {
         }
         return index;
     }
-    setTableValue(index, rgba) {
-        if (arguments.length === 5) {
-            rgba = Array.prototype.slice.call(arguments, 1);
+    setTableValue(index, rgba, g, b, a) {
+        let colorArray;
+        if (typeof rgba === 'number' &&
+            g !== undefined &&
+            b !== undefined &&
+            a !== undefined) {
+            colorArray = [rgba, g, b, a];
+        }
+        else if (Array.isArray(rgba)) {
+            colorArray = rgba;
+        }
+        else {
+            throw new Error('Invalid arguments for setTableValue');
         }
         if (index < 0) {
             throw new Error(`Can't set the table value for negative index (${index})`);
         }
         if (index >= this.NumberOfColors) {
-            new Error(`Index ${index} is greater than the number of colors ${this.NumberOfColors}`);
+            throw new Error(`Index ${index} is greater than the number of colors ${this.NumberOfColors}`);
         }
-        this.Table[index] = rgba;
+        this.Table[index] = colorArray;
         if (index === 0 || index === this.NumberOfColors - 1) {
             this.buildSpecialColors();
         }

package/dist/esm/RenderingEngine/helpers/cpuFallback/drawImageSync.d.ts

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

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

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

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

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

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

@@ -1,7 +1,7 @@
-import { CPUFallbackViewport } from '../../../../types';
-type Shift = {
+import type { CPUFallbackViewport } from '../../../../types';
+interface Shift {
     x: number;
     y: number;
-};
+}
 export default function (shift: Shift, viewportOrientation: CPUFallbackViewport): Shift;
 export {};

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

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

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

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

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

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

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

@@ -1,2 +1,2 @@
-import { IImage, CPUFallbackLUT } from '../../../../types';
+import type { IImage, CPUFallbackLUT } from '../../../../types';
 export default function generateColorLUT(image: IImage, windowWidth: number | number[], windowCenter: number | number[], invert: boolean, voiLUT?: CPUFallbackLUT): Uint8ClampedArray;

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

@@ -10,7 +10,7 @@ export default function generateColorLUT(image, windowWidth, windowCenter, inver
     }
     const lut = image.cachedLut.lutArray;
     const vlutfn = getVOILUT(Array.isArray(windowWidth) ? windowWidth[0] : windowWidth, Array.isArray(windowCenter) ? windowCenter[0] : windowCenter, voiLUT);
-    if (invert === true) {
+    if (invert) {
         for (let storedValue = minPixelValue; storedValue <= maxPixelValue; storedValue++) {
             lut[storedValue + -offset] = 255 - vlutfn(storedValue);
         }

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

@@ -1,2 +1,2 @@
-import { IImage, CPUFallbackLUT } from '../../../../types';
+import type { IImage, CPUFallbackLUT } from '../../../../types';
 export default function (image: IImage, windowWidth: number, windowCenter: number, invert: boolean, modalityLUT: CPUFallbackLUT, voiLUT: CPUFallbackLUT): Uint8ClampedArray;

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

@@ -13,7 +13,7 @@ export default function (image, windowWidth, windowCenter, invert, modalityLUT,
     const mlutfn = getModalityLut(image.slope, image.intercept, modalityLUT);
     const vlutfn = getVOILUT(windowWidth, windowCenter, voiLUT);
     if (image.isPreScaled) {
-        if (invert === true) {
+        if (invert) {
             for (let storedValue = minPixelValue; storedValue <= maxPixelValue; storedValue++) {
                 lut[storedValue + -offset] = 255 - vlutfn(storedValue);
             }
@@ -25,7 +25,7 @@ export default function (image, windowWidth, windowCenter, invert, modalityLUT,
         }
     }
     else {
-        if (invert === true) {
+        if (invert) {
             for (let storedValue = minPixelValue; storedValue <= maxPixelValue; storedValue++) {
                 lut[storedValue + -offset] = 255 - vlutfn(mlutfn(storedValue));
             }

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

@@ -1,2 +1,2 @@
-import { IImage, CPUFallbackColormap, CPUFallbackViewport } from '../../../../types';
+import type { IImage, CPUFallbackColormap, CPUFallbackViewport } from '../../../../types';
 export default function (canvas: HTMLCanvasElement, image: IImage, modality?: string, colormap?: CPUFallbackColormap): CPUFallbackViewport;

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

@@ -1,4 +1,4 @@
-import { IImage } from '../../../../types';
+import type { IImage } from '../../../../types';
 export default function (canvas: HTMLCanvasElement, image: IImage, rotation?: number | null): {
     verticalScale: number;
     horizontalScale: number;

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

@@ -1,4 +1,4 @@
-import { IImage } from '../../../../types';
+import type { IImage } from '../../../../types';
 export default function (image: IImage, rotation?: any): {
     height: number;
     width: number;

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

@@ -1,2 +1,2 @@
-import { IImage, CPUFallbackViewport } from '../../../../types';
+import type { IImage, CPUFallbackViewport } from '../../../../types';
 export default function (image: IImage, viewport: CPUFallbackViewport, invalidated: boolean): Uint8ClampedArray;

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

@@ -8,7 +8,7 @@ export default function (image, viewport, invalidated) {
         lutMatches(image.cachedLut.modalityLUT, viewport.modalityLUT) &&
         lutMatches(image.cachedLut.voiLUT, viewport.voiLUT) &&
         image.cachedLut.invert === viewport.invert &&
-        invalidated !== true) {
+        !invalidated) {
         return image.cachedLut.lutArray;
     }
     computeAutoVoi(viewport, image);

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

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

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

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

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

@@ -1 +1,2 @@
-export default function (a: any, b: any): boolean;
+import type { CPUFallbackLUT } from '../../../../types';
+export default function lutMatches(a: CPUFallbackLUT, b: CPUFallbackLUT): boolean;

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

@@ -1,4 +1,4 @@
-export default function (a, b) {
+export default function lutMatches(a, b) {
     if (!a && !b) {
         return true;
     }

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

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

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

@@ -7,7 +7,7 @@ import doesImageNeedToBeRendered from './doesImageNeedToBeRendered';
 import storedPixelDataToCanvasImageDataPseudocolorLUT from './storedPixelDataToCanvasImageDataPseudocolorLUT';
 import storedPixelDataToCanvasImageDataPseudocolorLUTPET from './storedPixelDataToCanvasImageDataPseudocolorLUTPET';
 import * as colors from '../colors/index';
-import { clamp } from '../../../../utilities';
+import { clamp } from '../../../../utilities/clamp';
 function getRenderCanvas(enabledElement, image, invalidated) {
     if (!enabledElement.renderingTools.renderCanvas) {
         enabledElement.renderingTools.renderCanvas =
@@ -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

@@ -1,10 +1,10 @@
 import vtkVolume from '@kitware/vtk.js/Rendering/Core/Volume';
 import { loadVolume } from '../../loaders/volumeLoader';
 import createVolumeMapper from './createVolumeMapper';
-import { triggerEvent } from '../../utilities';
+import triggerEvent from '../../utilities/triggerEvent';
 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;