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

package/dist/esm/utilities/calculateViewportsSpatialRegistration.js

@@ -3,10 +3,10 @@ import spatialRegistrationMetadataProvider from './spatialRegistrationMetadataPr
 import { metaData } from '..';
 const ALLOWED_DELTA = 0.05;
 function calculateViewportsSpatialRegistration(viewport1, viewport2) {
-    const imageId1 = viewport1.getCurrentImageId();
-    const imageId2 = viewport2.getCurrentImageId();
-    const imagePlaneModule1 = metaData.get('imagePlaneModule', imageId1);
-    const imagePlaneModule2 = metaData.get('imagePlaneModule', imageId2);
+    const imageId1 = viewport1.getSliceIndex();
+    const imageId2 = viewport2.getSliceIndex();
+    const imagePlaneModule1 = metaData.get('imagePlaneModule', imageId1.toString());
+    const imagePlaneModule2 = metaData.get('imagePlaneModule', imageId2.toString());
     if (!imagePlaneModule1 || !imagePlaneModule2) {
         console.log('Viewport spatial registration requires image plane module');
         return;

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

@@ -1,4 +1,4 @@
-import { IImageCalibration } from '../types';
+import type { IImageCalibration } from '../types/IImageCalibration';
 declare const metadataProvider: {
     add: (imageId: string, payload: IImageCalibration) => void;
     get: (type: string, imageId: string) => IImageCalibration;

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

@@ -1,4 +1,4 @@
-import { ColormapPublic, ColormapRegistration } from '../types';
+import type { ColormapPublic, ColormapRegistration } from '../types';
 declare function registerColormap(colormap: ColormapRegistration): void;
 declare function getColormap(name: any): any;
 declare function getColormapNames(): any[];

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

@@ -1,5 +1,5 @@
-import { IStackViewport, IVolumeViewport, Point3 } from '../types';
-import { OrientationAxis } from '../enums';
+import type { IStackViewport, IVolumeViewport, Point3 } from '../types';
+import type { OrientationAxis } from '../enums';
 declare function convertStackToVolumeViewport({ viewport, options, }: {
     viewport: IStackViewport;
     options: {

package/dist/esm/utilities/convertStackToVolumeViewport.js

@@ -1,5 +1,5 @@
 import { setVolumesForViewports } from '../RenderingEngine/helpers';
-import { createAndCacheEmptyVolume, getUnknownVolumeLoaderSchema, } from '../loaders/volumeLoader';
+import { createAndCacheVolume, getUnknownVolumeLoaderSchema, } from '../loaders/volumeLoader';
 import { Events, ViewportType } from '../enums';
 async function convertStackToVolumeViewport({ viewport, options, }) {
     const renderingEngine = viewport.getRenderingEngine();
@@ -21,12 +21,12 @@ async function convertStackToVolumeViewport({ viewport, options, }) {
             orientation: options.orientation,
         },
     });
-    const volume = await createAndCacheEmptyVolume(volumeId, {
+    const volume = await createAndCacheVolume(volumeId, {
         imageIds,
     });
     volume.load();
-    const volumeViewport = (renderingEngine.getViewport(viewportId));
-    setVolumesForViewports(renderingEngine, [
+    const volumeViewport = renderingEngine.getViewport(viewportId);
+    await setVolumesForViewports(renderingEngine, [
         {
             volumeId,
         },

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

@@ -1,4 +1,4 @@
-import * as Types from '../types';
+import type * as Types from '../types';
 declare function convertVolumeToStackViewport({ viewport, options, }: {
     viewport: Types.IVolumeViewport;
     options: {

package/dist/esm/utilities/convertVolumeToStackViewport.js

@@ -22,7 +22,7 @@ async function convertVolumeToStackViewport({ viewport, options, }) {
     };
     const prevView = volumeViewport.getViewReference();
     renderingEngine.enableElement(viewportInput);
-    const stackViewport = (renderingEngine.getViewport(viewportId));
+    const stackViewport = renderingEngine.getViewport(viewportId);
     await stackViewport.setStack(volume.imageIds);
     stackViewport.setViewReference(prevView);
     stackViewport.render();

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

@@ -1,3 +1,3 @@
 import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
-import { VOIRange } from '../types';
+import type { VOIRange } from '../types/voi';
 export default function createLinearRGBTransferFunction(voiRange: VOIRange): vtkColorTransferFunction;

package/dist/esm/utilities/createLinearRGBTransferFunction.js

@@ -3,9 +3,7 @@ export default function createLinearRGBTransferFunction(voiRange) {
     const cfun = vtkColorTransferFunction.newInstance();
     let lower = 0;
     let upper = 1024;
-    if (voiRange &&
-        voiRange.lower !== undefined &&
-        voiRange.upper !== undefined) {
+    if (voiRange.lower !== undefined && voiRange.upper !== undefined) {
         lower = voiRange.lower;
         upper = voiRange.upper;
     }

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

@@ -1,3 +1,2 @@
-import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
-import { VOIRange } from '../types';
-export default function createSigmoidRGBTransferFunction(voiRange: VOIRange, approximationNodes?: number): vtkColorTransferFunction;
+import type { VOIRange } from '../types/voi';
+export default function createSigmoidRGBTransferFunction(voiRange: VOIRange, approximationNodes?: number): unknown;

package/dist/esm/utilities/createSigmoidRGBTransferFunction.js

@@ -9,14 +9,15 @@ export default function createSigmoidRGBTransferFunction(voiRange, approximation
     const logit = (y, wc, ww) => {
         return wc - (ww / 4) * Math.log((1 - y) / y);
     };
-    const range = [...Array(approximationNodes + 2).keys()]
-        .map((v) => v / (approximationNodes + 2))
-        .slice(1, -1);
-    const table = range.reduce((res, y) => {
+    const range = Array.from({ length: approximationNodes }, (_, i) => (i + 1) / (approximationNodes + 2));
+    const table = range.flatMap((y) => {
         const x = logit(y, windowCenter, windowWidth);
-        return res.concat(x, y, y, y, 0.5, 0.0);
-    }, []);
+        return [x, y, y, y, 0.5, 0.0];
+    });
     const cfun = vtkColorTransferFunction.newInstance();
-    cfun.buildFunctionFromArray(vtkDataArray.newInstance({ values: table, numberOfComponents: 6 }));
+    cfun.buildFunctionFromArray(vtkDataArray.newInstance({
+        values: table,
+        numberOfComponents: 6,
+    }));
     return cfun;
 }

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

@@ -1 +1 @@
-export default function decimate(list: Array<unknown>, interleave: number, offset?: number): number[];
+export default function decimate(list: unknown[], interleave: number, offset?: number): number[];

package/dist/esm/utilities/eventListener/TargetEventListeners.js

@@ -67,7 +67,7 @@ class TargetEventListeners {
             listenersMap = new Map();
             this._eventListeners.set(type, listenersMap);
         }
-        const useCapture = options?.capture ?? false;
+        const useCapture = options.capture ?? false;
         const listenerPhase = useCapture
             ? EventListenerPhases.Capture
             : EventListenerPhases.Bubble;
@@ -80,7 +80,7 @@ class TargetEventListeners {
         this._target.addEventListener(type, callback, options);
     }
     _removeEventListener(type, callback, options) {
-        const useCapture = options?.capture ?? false;
+        const useCapture = options.capture ?? false;
         const listenerPhase = useCapture
             ? EventListenerPhases.Capture
             : EventListenerPhases.Bubble;
@@ -122,7 +122,9 @@ class TargetEventListeners {
         });
     }
     _unregisterAllEvents() {
-        Array.from(this._eventListeners.entries()).forEach(([type, listenersMap]) => this._unregisterAllListeners(type, listenersMap));
+        Array.from(this._eventListeners.entries()).forEach(([type, listenersMap]) => {
+            this._unregisterAllListeners(type, listenersMap);
+        });
     }
 }
 export { TargetEventListeners as default, TargetEventListeners };

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

@@ -1,3 +1,3 @@
-import { ImageVolumeProps } from '../types';
+import type { ImageVolumeProps } from '../types';
 declare function generateVolumePropsFromImageIds(imageIds: string[], volumeId: string): ImageVolumeProps;
 export { generateVolumePropsFromImageIds };

package/dist/esm/utilities/generateVolumePropsFromImageIds.js

@@ -1,27 +1,12 @@
 import { vec3 } from 'gl-matrix';
-import { canRenderFloatTextures, getConfiguration, getShouldUseSharedArrayBuffer, } from '../init';
-import createFloat32SharedArray from './createFloat32SharedArray';
-import createInt16SharedArray from './createInt16SharedArray';
-import createUint16SharedArray from './createUInt16SharedArray';
-import createUint8SharedArray from './createUint8SharedArray';
-import getScalingParameters from './getScalingParameters';
 import makeVolumeMetadata from './makeVolumeMetadata';
 import sortImageIdsAndGetSpacing from './sortImageIdsAndGetSpacing';
+import getScalingParameters from './getScalingParameters';
 import { hasFloatScalingParameters } from './hasFloatScalingParameters';
-import cache from '../cache';
-import { Events } from '../enums';
+import { canRenderFloatTextures } from '../init';
 function generateVolumePropsFromImageIds(imageIds, volumeId) {
-    const { useNorm16Texture, preferSizeOverAccuracy } = getConfiguration().rendering;
-    const use16BitDataType = useNorm16Texture || preferSizeOverAccuracy;
     const volumeMetadata = makeVolumeMetadata(imageIds);
-    const imageIdIndex = Math.floor(imageIds.length / 2);
-    const imageId = imageIds[imageIdIndex];
-    const scalingParameters = getScalingParameters(imageId);
-    const hasNegativeRescale = scalingParameters.rescaleIntercept < 0 ||
-        scalingParameters.rescaleSlope < 0;
-    const floatAfterScale = hasFloatScalingParameters(scalingParameters);
-    const canRenderFloat = canRenderFloatTextures();
-    const { BitsAllocated, PixelRepresentation, PhotometricInterpretation, ImageOrientationPatient, PixelSpacing, Columns, Rows, } = volumeMetadata;
+    const { ImageOrientationPatient, PixelSpacing, Columns, Rows } = volumeMetadata;
     const rowCosineVec = vec3.fromValues(ImageOrientationPatient[0], ImageOrientationPatient[1], ImageOrientationPatient[2]);
     const colCosineVec = vec3.fromValues(ImageOrientationPatient[3], ImageOrientationPatient[4], ImageOrientationPatient[5]);
     const scanAxisNormal = vec3.create();
@@ -35,84 +20,52 @@ function generateVolumePropsFromImageIds(imageIds, volumeId) {
         ...colCosineVec,
         ...scanAxisNormal,
     ];
-    const signed = PixelRepresentation === 1;
-    const numComponents = PhotometricInterpretation === 'RGB' ? 3 : 1;
-    const useSharedArrayBuffer = getShouldUseSharedArrayBuffer();
-    const length = dimensions[0] * dimensions[1] * dimensions[2];
-    const handleCache = (sizeInBytes) => {
-        if (!cache.isCacheable(sizeInBytes)) {
-            throw new Error(Events.CACHE_SIZE_EXCEEDED);
-        }
-        cache.decacheIfNecessaryUntilBytesAvailable(sizeInBytes);
+    return {
+        dimensions,
+        spacing,
+        origin,
+        dataType: _determineDataType(sortedImageIds, volumeMetadata),
+        direction,
+        metadata: volumeMetadata,
+        imageIds: sortedImageIds,
+        volumeId,
+        voxelManager: null,
+        numberOfComponents: volumeMetadata.PhotometricInterpretation === 'RGB' ? 3 : 1,
     };
-    let scalarData, sizeInBytes;
+}
+function _determineDataType(imageIds, volumeMetadata) {
+    const { BitsAllocated, PixelRepresentation, PhotometricInterpretation } = volumeMetadata;
+    const signed = PixelRepresentation === 1;
+    const imageIdIndex = Math.floor(imageIds.length / 2);
+    const imageId = imageIds[imageIdIndex];
+    const scalingParameters = getScalingParameters(imageId);
+    const hasNegativeRescale = scalingParameters.rescaleIntercept < 0 ||
+        scalingParameters.rescaleSlope < 0;
+    const floatAfterScale = hasFloatScalingParameters(scalingParameters);
+    const canRenderFloat = canRenderFloatTextures();
     switch (BitsAllocated) {
         case 8:
             if (signed) {
                 throw new Error('8 Bit signed images are not yet supported by this plugin.');
             }
-            sizeInBytes = length * numComponents;
-            handleCache(sizeInBytes);
-            scalarData = useSharedArrayBuffer
-                ? createUint8SharedArray(length * numComponents)
-                : new Uint8Array(length * numComponents);
-            break;
+            return 'Uint8Array';
         case 16:
-            if (!use16BitDataType || (canRenderFloat && floatAfterScale)) {
-                sizeInBytes = length * 4;
-                scalarData = useSharedArrayBuffer
-                    ? createFloat32SharedArray(length)
-                    : new Float32Array(length);
-                break;
+            if (canRenderFloat && floatAfterScale) {
+                return 'Float32Array';
             }
-            sizeInBytes = length * 2;
             if (signed || hasNegativeRescale) {
-                handleCache(sizeInBytes);
-                scalarData = useSharedArrayBuffer
-                    ? createInt16SharedArray(length)
-                    : new Int16Array(length);
-                break;
+                return 'Int16Array';
             }
             if (!signed && !hasNegativeRescale) {
-                handleCache(sizeInBytes);
-                scalarData = useSharedArrayBuffer
-                    ? createUint16SharedArray(length)
-                    : new Uint16Array(length);
-                break;
+                return 'Uint16Array';
             }
-            sizeInBytes = length * 4;
-            handleCache(sizeInBytes);
-            scalarData = useSharedArrayBuffer
-                ? createFloat32SharedArray(length)
-                : new Float32Array(length);
-            break;
+            return 'Float32Array';
         case 24:
-            sizeInBytes = length * numComponents;
-            handleCache(sizeInBytes);
-            scalarData = useSharedArrayBuffer
-                ? createUint8SharedArray(length * numComponents)
-                : new Uint8Array(length * numComponents);
-            break;
+            return 'Uint8Array';
         case 32:
-            sizeInBytes = length * 4;
-            handleCache(sizeInBytes);
-            scalarData = useSharedArrayBuffer
-                ? createFloat32SharedArray(length)
-                : new Float32Array(length);
-            break;
+            return 'Float32Array';
         default:
             throw new Error(`Bits allocated of ${BitsAllocated} is not defined to generate scalarData for the volume.`);
     }
-    return {
-        dimensions,
-        spacing,
-        origin,
-        direction,
-        scalarData,
-        sizeInBytes,
-        metadata: volumeMetadata,
-        imageIds: sortedImageIds,
-        volumeId,
-    };
 }
 export { generateVolumePropsFromImageIds };

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

@@ -1,6 +1,13 @@
 declare const metadataProvider: {
-    add: (imageId: string, payload: any) => void;
-    get: (type: string, imageId: string) => any;
+    add: (imageId: string, payload: {
+        metadata: unknown;
+        type: string;
+    }) => void;
+    addRaw: (imageId: string, payload: {
+        metadata: unknown;
+        type: string;
+    }) => void;
+    get: (type: string, imageId: string) => unknown;
     clear: () => void;
 };
 export default metadataProvider;

package/dist/esm/utilities/genericMetadataProvider.js

@@ -2,11 +2,17 @@ import { addProvider } from '../metaData';
 let state = {};
 const metadataProvider = {
     add: (imageId, payload) => {
+        metadataProvider.addRaw(imageId, {
+            ...payload,
+            metadata: structuredClone(payload.metadata),
+        });
+    },
+    addRaw: (imageId, payload) => {
         const type = payload.type;
         if (!state[imageId]) {
             state[imageId] = {};
         }
-        state[imageId][type] = JSON.parse(JSON.stringify(payload.metadata));
+        state[imageId][type] = payload.metadata;
     },
     get: (type, imageId) => {
         return state[imageId]?.[type];

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

@@ -1,9 +1,8 @@
-import { PixelDataTypedArray, PixelDataTypedArrayString } from '../types';
+import type { PixelDataTypedArray, PixelDataTypedArrayString } from '../types';
 declare function getBufferConfiguration(targetBufferType: PixelDataTypedArrayString, length: number, options?: {
-    use16BitTexture?: boolean;
     isVolumeBuffer?: boolean;
 }): {
     numBytes: number;
-    TypedArrayConstructor: new (length: number | SharedArrayBuffer) => PixelDataTypedArray;
+    TypedArrayConstructor: new (length: number) => PixelDataTypedArray;
 };
 export { getBufferConfiguration };

package/dist/esm/utilities/getBufferConfiguration.js

@@ -1,5 +1,5 @@
 function getBufferConfiguration(targetBufferType, length, options = {}) {
-    const { use16BitTexture = false, isVolumeBuffer = false } = options;
+    const { isVolumeBuffer = false } = options;
     switch (targetBufferType) {
         case 'Float32Array':
             return { numBytes: length * 4, TypedArrayConstructor: Float32Array };
@@ -10,26 +10,16 @@ function getBufferConfiguration(targetBufferType, length, options = {}) {
                 return { numBytes: length * 2, TypedArrayConstructor: Uint16Array };
             }
             else {
-                if (use16BitTexture) {
-                    return { numBytes: length * 2, TypedArrayConstructor: Uint16Array };
-                }
-                else {
-                    console.warn('Uint16Array is not supported for volume rendering, switching back to Float32Array');
-                    return { numBytes: length * 4, TypedArrayConstructor: Float32Array };
-                }
+                console.warn('Uint16Array is not supported for volume rendering, switching back to Float32Array');
+                return { numBytes: length * 4, TypedArrayConstructor: Float32Array };
             }
         case 'Int16Array':
             if (!isVolumeBuffer) {
                 return { numBytes: length * 2, TypedArrayConstructor: Int16Array };
             }
             else {
-                if (use16BitTexture) {
-                    return { numBytes: length * 2, TypedArrayConstructor: Int16Array };
-                }
-                else {
-                    console.warn('Int16Array is not supported for volume rendering, switching back to Float32Array');
-                    return { numBytes: length * 4, TypedArrayConstructor: Float32Array };
-                }
+                console.warn('Int16Array is not supported for volume rendering, switching back to Float32Array');
+                return { numBytes: length * 4, TypedArrayConstructor: Float32Array };
             }
         default:
             if (targetBufferType) {

package/dist/esm/utilities/getClosestImageId.js

@@ -7,7 +7,7 @@ export default function getClosestImageId(imageVolume, worldPos, viewPlaneNormal
         return;
     }
     const { direction, imageIds } = imageVolume;
-    if (!imageIds || !imageIds.length) {
+    if (!imageIds.length) {
         return;
     }
     const kVector = direction.slice(6, 9);

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

@@ -1,4 +1,4 @@
-import { IStackViewport, Point3 } from '../types';
+import type { IStackViewport, Point3 } from '../types';
 export default function getClosestStackImageIndexForPoint(point: Point3, viewport: IStackViewport): number | null;
 export declare function calculateMinimalDistanceForStackViewport(point: Point3, viewport: IStackViewport): {
     distance: number;

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

@@ -1,10 +1,9 @@
-import { mat4 } from 'gl-matrix';
-import { IVolumeViewport } from '../types';
+import type { IVolumeViewport } from '../types';
 declare function getCurrentVolumeViewportSlice(viewport: IVolumeViewport): {
     width: number;
     height: number;
-    scalarData: any;
-    sliceToIndexMatrix: mat4;
-    indexToSliceMatrix: mat4;
+    scalarData: import("../types").PixelDataTypedArray;
+    sliceToIndexMatrix: import("gl-matrix").mat4;
+    indexToSliceMatrix: import("gl-matrix").mat4;
 };
 export { getCurrentVolumeViewportSlice as default, getCurrentVolumeViewportSlice, };

package/dist/esm/utilities/getCurrentVolumeViewportSlice.js

@@ -1,9 +1,8 @@
-import { glMatrix, mat4, vec3 } from 'gl-matrix';
-import { transformIJKToCanvas } from './transformIJKToCanvas';
+import { glMatrix, vec3 } from 'gl-matrix';
 import { transformCanvasToIJK } from './transformCanvasToIJK';
 function getCurrentVolumeViewportSlice(viewport) {
-    const { dimensions, scalarData } = viewport.getImageData();
     const { width: canvasWidth, height: canvasHeight } = viewport.getCanvas();
+    const { sliceToIndexMatrix, indexToSliceMatrix } = viewport.getSliceViewInfo();
     const ijkOriginPoint = transformCanvasToIJK(viewport, [0, 0]);
     const ijkRowPoint = transformCanvasToIJK(viewport, [canvasWidth - 1, 0]);
     const ijkColPoint = transformCanvasToIJK(viewport, [0, canvasHeight - 1]);
@@ -18,62 +17,13 @@ function getCurrentVolumeViewportSlice(viewport) {
     if (!glMatrix.equals(1, maxIJKRowVec) || !glMatrix.equals(1, maxIJKColVec)) {
         throw new Error('Livewire is not available for rotate/oblique viewports');
     }
-    const [sx, sy, sz] = dimensions;
-    const ijkCorners = [
-        [0, 0, 0],
-        [sx - 1, 0, 0],
-        [0, sy - 1, 0],
-        [sx - 1, sy - 1, 0],
-        [0, 0, sz - 1],
-        [sx - 1, 0, sz - 1],
-        [0, sy - 1, sz - 1],
-        [sx - 1, sy - 1, sz - 1],
-    ];
-    const canvasCorners = ijkCorners.map((ijkCorner) => transformIJKToCanvas(viewport, ijkCorner));
-    const canvasAABB = canvasCorners.reduce((aabb, canvasPoint) => {
-        aabb.minX = Math.min(aabb.minX, canvasPoint[0]);
-        aabb.minY = Math.min(aabb.minY, canvasPoint[1]);
-        aabb.maxX = Math.max(aabb.maxX, canvasPoint[0]);
-        aabb.maxY = Math.max(aabb.maxY, canvasPoint[1]);
-        return aabb;
-    }, { minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity });
-    const ijkTopLeft = transformCanvasToIJK(viewport, [
-        canvasAABB.minX,
-        canvasAABB.minY,
-    ]);
-    const ijkBottomRight = transformCanvasToIJK(viewport, [
-        canvasAABB.maxX,
-        canvasAABB.maxY,
-    ]);
-    const ijkDiagonal = vec3.sub(vec3.create(), ijkBottomRight, ijkTopLeft);
-    const sliceToIndexMatrix = mat4.fromValues(ijkRowVec[0], ijkRowVec[1], ijkRowVec[2], 0, ijkColVec[0], ijkColVec[1], ijkColVec[2], 0, ijkSliceVec[0], ijkSliceVec[1], ijkSliceVec[2], 0, ijkTopLeft[0], ijkTopLeft[1], ijkTopLeft[2], 1);
-    const indexToSliceMatrix = mat4.invert(mat4.create(), sliceToIndexMatrix);
-    const sliceWidth = vec3.dot(ijkRowVec, ijkDiagonal) + 1;
-    const sliceHeight = vec3.dot(ijkColVec, ijkDiagonal) + 1;
-    const TypedArray = scalarData.constructor;
-    const sliceData = new TypedArray(sliceWidth * sliceHeight);
-    const pixelsPerSlice = dimensions[0] * dimensions[1];
-    const ijkPixelRow = vec3.clone(ijkTopLeft);
-    const ijkPixelCol = vec3.create();
-    let slicePixelIndex = 0;
-    for (let y = 0; y < sliceHeight; y++) {
-        vec3.copy(ijkPixelCol, ijkPixelRow);
-        for (let x = 0; x < sliceWidth; x++) {
-            const volumePixelIndex = ijkPixelCol[2] * pixelsPerSlice +
-                ijkPixelCol[1] * dimensions[0] +
-                ijkPixelCol[0];
-            if (volumePixelIndex < scalarData.length) {
-                sliceData[slicePixelIndex] = scalarData[volumePixelIndex];
-            }
-            slicePixelIndex++;
-            vec3.add(ijkPixelCol, ijkPixelCol, ijkRowVec);
-        }
-        vec3.add(ijkPixelRow, ijkPixelRow, ijkColVec);
-    }
+    const { voxelManager } = viewport.getImageData();
+    const sliceViewInfo = viewport.getSliceViewInfo();
+    const scalarData = voxelManager.getSliceData(sliceViewInfo);
     return {
-        width: sliceWidth,
-        height: sliceHeight,
-        scalarData: sliceData,
+        width: sliceViewInfo.width,
+        height: sliceViewInfo.height,
+        scalarData,
         sliceToIndexMatrix,
         indexToSliceMatrix,
     };

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

@@ -1,3 +1,3 @@
-import { Types } from '..';
+import type { Types } from '..';
 declare function getImageLegacy(element: HTMLDivElement): Types.IImage | undefined;
 export default getImageLegacy;

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

@@ -1,3 +1,3 @@
-import { ImageSliceData, IVolumeViewport } from '../types';
+import type { ImageSliceData, IVolumeViewport } from '../types';
 declare function getImageSliceDataForVolumeViewport(viewport: IVolumeViewport): ImageSliceData;
 export default getImageSliceDataForVolumeViewport;

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

@@ -1,4 +1,5 @@
-export default function getMinMax(storedPixelData: number[]): {
+import type { PixelDataTypedArray } from '../types/PixelDataTypedArray';
+export default function getMinMax(storedPixelData: PixelDataTypedArray): {
     min: number;
     max: number;
 };

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

@@ -1,2 +1,2 @@
-import { ScalingParameters } from '../types';
+import type { ScalingParameters } from '../types';
 export default function getScalingParameters(imageId: string): ScalingParameters;

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

@@ -1,5 +1,5 @@
-import { mat3 } from 'gl-matrix';
-import { IImageVolume, Point3 } from '../types';
+import type { mat3 } from 'gl-matrix';
+import type { IImageVolume, Point3 } from '../types';
 export default function getSpacingInNormalDirection(imageVolume: IImageVolume | {
     direction: mat3;
     spacing: Point3;

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

@@ -1,4 +1,4 @@
-import { ICamera, IImageVolume, IVolumeViewport } from '../types';
+import type { ICamera, IImageVolume, IVolumeViewport } from '../types';
 export default function getTargetVolumeAndSpacingInNormalDir(viewport: IVolumeViewport, camera: ICamera, targetId?: string, useSlabThickness?: boolean): {
     imageVolume: IImageVolume;
     spacingInNormalDirection: number;

package/dist/esm/utilities/getTargetVolumeAndSpacingInNormalDir.js

@@ -9,7 +9,7 @@ const isPrimaryVolume = (volume) => !!getVolumeLoaderSchemes().find((scheme) =>
 export default function getTargetVolumeAndSpacingInNormalDir(viewport, camera, targetId, useSlabThickness = false) {
     const { viewPlaneNormal } = camera;
     const volumeActors = viewport.getActors();
-    if (!volumeActors || !volumeActors.length) {
+    if (!volumeActors.length) {
         return {
             spacingInNormalDirection: null,
             imageVolume: null,
@@ -61,7 +61,7 @@ export default function getTargetVolumeAndSpacingInNormalDir(viewport, camera, t
 function getSpacingInNormal(imageVolume, viewPlaneNormal, viewport, useSlabThickness = false) {
     const { slabThickness } = viewport.getProperties();
     let spacingInNormalDirection = slabThickness;
-    if (!slabThickness || useSlabThickness === false) {
+    if (!slabThickness || !useSlabThickness) {
         spacingInNormalDirection = getSpacingInNormalDirection(imageVolume, viewPlaneNormal);
     }
     return spacingInNormalDirection;

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

@@ -1,2 +1,2 @@
-import { IStackViewport, IVolumeViewport, Point3 } from '../types';
+import type { IStackViewport, IVolumeViewport, Point3 } from '../types';
 export default function getViewportImageCornersInWorld(viewport: IStackViewport | IVolumeViewport): Point3[];

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

@@ -1,3 +1,3 @@
-import { IViewport } from '../types';
+import type { IViewport } from '../types';
 declare function getViewportImageIds(viewport: IViewport): string[];
 export default getViewportImageIds;

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

@@ -1,3 +1,7 @@
-import type { IViewport } from '../types';
-declare function getViewportModality(viewport: IViewport, volumeId?: string): string;
-export { getViewportModality as default, getViewportModality };
+import type { IViewport } from '../types/IViewport';
+declare function _getViewportModality(viewport: IViewport, volumeId?: string, getVolume?: (volumeId: string) => {
+    metadata: {
+        Modality: string;
+    };
+} | undefined): string;
+export { _getViewportModality };

package/dist/esm/utilities/getViewportModality.js

@@ -1,15 +1,18 @@
-import cache from '../cache';
-function getViewportModality(viewport, volumeId) {
+function _getViewportModality(viewport, volumeId, getVolume) {
+    if (!getVolume) {
+        throw new Error('getVolume is required, use the utilities export instead ');
+    }
     if (viewport.modality) {
         return viewport.modality;
     }
     if (viewport.setVolumes) {
-        volumeId = volumeId ?? viewport.getDefaultActor()?.uid;
-        if (!volumeId) {
+        volumeId = volumeId ?? viewport.getDefaultActor().uid;
+        if (!volumeId || !getVolume) {
             return;
         }
-        return cache.getVolume(volumeId)?.metadata.Modality;
+        const volume = getVolume(volumeId);
+        return volume.metadata.Modality;
     }
     throw new Error('Invalid viewport type');
 }
-export { getViewportModality as default, getViewportModality };
+export { _getViewportModality };