@cornerstonejs/core 2.0.0-beta.7 → 2.0.0

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();
@@ -29,91 +14,58 @@ function generateVolumePropsFromImageIds(imageIds, volumeId) {
     const { zSpacing, origin, sortedImageIds } = sortImageIdsAndGetSpacing(imageIds, scanAxisNormal);
     const numFrames = imageIds.length;
     const spacing = [PixelSpacing[1], PixelSpacing[0], zSpacing];
-    const dimensions = [Columns, Rows, numFrames];
+    const dimensions = [Columns, Rows, numFrames].map((it) => Math.floor(it));
     const direction = [
         ...rowCosineVec,
         ...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, x } = 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 };
-//# sourceMappingURL=generateVolumePropsFromImageIds.js.map

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

@@ -0,0 +1,13 @@
+declare const metadataProvider: {
+    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];
@@ -17,4 +23,3 @@ const metadataProvider = {
 };
 addProvider(metadataProvider.get);
 export default metadataProvider;
-//# sourceMappingURL=genericMetadataProvider.js.map

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

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

package/dist/esm/utilities/getBufferConfiguration.js

@@ -1,44 +1,32 @@
-function getBufferConfiguration(targetBufferType, length, options = {}) {
-    const { use16BitTexture = false, isVolumeBuffer = false } = options;
-    switch (targetBufferType) {
+function getConstructorFromType(bufferType, isVolumeBuffer) {
+    switch (bufferType) {
         case 'Float32Array':
-            return { numBytes: length * 4, TypedArrayConstructor: Float32Array };
+            return Float32Array;
         case 'Uint8Array':
-            return { numBytes: length, TypedArrayConstructor: Uint8Array };
+            return Uint8Array;
         case 'Uint16Array':
-            if (!isVolumeBuffer) {
-                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 };
-                }
-            }
         case 'Int16Array':
             if (!isVolumeBuffer) {
-                return { numBytes: length * 2, TypedArrayConstructor: Int16Array };
+                return bufferType === 'Uint16Array' ? Uint16Array : 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.debug(`${bufferType} is not supported for volume rendering, switching back to Float32Array`);
+                return Float32Array;
             }
         default:
-            if (targetBufferType) {
+            if (bufferType) {
                 throw new Error('TargetBuffer should be Float32Array, Uint8Array, Uint16Array, or Int16Array');
             }
             else {
-                return { numBytes: length * 4, TypedArrayConstructor: Float32Array };
+                return Float32Array;
             }
     }
 }
-export { getBufferConfiguration };
-//# sourceMappingURL=getBufferConfiguration.js.map
+function getBufferConfiguration(targetBufferType, length, options = {}) {
+    const { isVolumeBuffer = false } = options;
+    const TypedArrayConstructor = getConstructorFromType(targetBufferType, isVolumeBuffer);
+    const bytesPerElement = TypedArrayConstructor.BYTES_PER_ELEMENT;
+    const numBytes = length * bytesPerElement;
+    return { numBytes, TypedArrayConstructor };
+}
+export { getBufferConfiguration, getConstructorFromType };

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

@@ -0,0 +1,7 @@
+import type { mat3 } from 'gl-matrix';
+import type { IImageVolume, Point3 } from '../types';
+export default function getClosestImageId(imageVolume: IImageVolume | {
+    direction: mat3;
+    spacing: Point3;
+    imageIds: string[];
+}, worldPos: Point3, viewPlaneNormal: Point3): string;

package/dist/esm/utilities/getClosestImageId.js

@@ -3,11 +3,8 @@ import * as metaData from '../metaData';
 import getSpacingInNormalDirection from './getSpacingInNormalDirection';
 import { EPSILON } from '../constants';
 export default function getClosestImageId(imageVolume, worldPos, viewPlaneNormal) {
-    if (!imageVolume) {
-        return;
-    }
-    const { direction, imageIds } = imageVolume;
-    if (!imageIds || !imageIds.length) {
+    const { direction, spacing, imageIds } = imageVolume;
+    if (!imageIds.length) {
         return;
     }
     const kVector = direction.slice(6, 9);
@@ -15,7 +12,7 @@ export default function getClosestImageId(imageVolume, worldPos, viewPlaneNormal
     if (Math.abs(dotProducts) < 1 - EPSILON) {
         return;
     }
-    const spacingInNormalDirection = getSpacingInNormalDirection(imageVolume, viewPlaneNormal);
+    const spacingInNormalDirection = getSpacingInNormalDirection({ direction, spacing }, viewPlaneNormal);
     const halfSpacingInNormalDirection = spacingInNormalDirection / 2;
     let imageIdForTool;
     for (let i = 0; i < imageIds.length; i++) {
@@ -30,4 +27,3 @@ export default function getClosestImageId(imageVolume, worldPos, viewPlaneNormal
     }
     return imageIdForTool;
 }
-//# sourceMappingURL=getClosestImageId.js.map

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

@@ -0,0 +1,6 @@
+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;
+    index: number;
+} | null;

package/dist/esm/utilities/getClosestStackImageIndexForPoint.js

@@ -1,6 +1,6 @@
 import { vec3 } from 'gl-matrix';
-import { planar } from '.';
-import { metaData } from '..';
+import * as planar from './planar';
+import * as metaData from '../metaData';
 export default function getClosestStackImageIndexForPoint(point, viewport) {
     const minimalDistance = calculateMinimalDistanceForStackViewport(point, viewport);
     return minimalDistance ? minimalDistance.index : null;
@@ -73,4 +73,3 @@ function getPlaneMetadata(imageId) {
     const planeNormal = vec3.cross(vec3.create(), rowVec, colVec);
     return { rowCosines, columnCosines, imagePositionPatient, planeNormal };
 }
-//# sourceMappingURL=getClosestStackImageIndexForPoint.js.map

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

@@ -0,0 +1,9 @@
+import type { IVolumeViewport } from '../types';
+declare function getCurrentVolumeViewportSlice(viewport: IVolumeViewport): {
+    width: number;
+    height: number;
+    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,65 +17,15 @@ 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,
     };
 }
 export { getCurrentVolumeViewportSlice as default, getCurrentVolumeViewportSlice, };
-//# sourceMappingURL=getCurrentVolumeViewportSlice.js.map

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

@@ -0,0 +1,6 @@
+declare function getDynamicVolumeInfo(imageIds: any): {
+    isDynamicVolume: boolean;
+    timePoints: string[][];
+    splittingTag: string;
+};
+export default getDynamicVolumeInfo;

package/dist/esm/utilities/getDynamicVolumeInfo.js

@@ -0,0 +1,7 @@
+import splitImageIdsBy4DTags from './splitImageIdsBy4DTags';
+function getDynamicVolumeInfo(imageIds) {
+    const { imageIdGroups: timePoints, splittingTag } = splitImageIdsBy4DTags(imageIds);
+    const isDynamicVolume = timePoints.length > 1;
+    return { isDynamicVolume, timePoints, splittingTag };
+}
+export default getDynamicVolumeInfo;

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

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

package/dist/esm/utilities/getImageLegacy.js

@@ -1,4 +1,4 @@
-import { StackViewport } from '..';
+import StackViewport from '../RenderingEngine/StackViewport';
 import getEnabledElement from '../getEnabledElement';
 function getImageLegacy(element) {
     const enabledElement = getEnabledElement(element);
@@ -12,4 +12,3 @@ function getImageLegacy(element) {
     return viewport.getCornerstoneImage();
 }
 export default getImageLegacy;
-//# sourceMappingURL=getImageLegacy.js.map

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

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

package/dist/esm/utilities/getImageSliceDataForVolumeViewport.js

@@ -9,7 +9,8 @@ function getImageSliceDataForVolumeViewport(viewport) {
     const { viewPlaneNormal, focalPoint } = camera;
     const actorEntry = viewport
         .getActors()
-        .find((a) => a.referenceId === imageVolume.volumeId || a.uid === imageVolume.volumeId);
+        .find((a) => a.referencedId === imageVolume.volumeId ||
+        a.uid === imageVolume.volumeId);
     if (!actorEntry) {
         console.warn('No actor found for with actorUID of', imageVolume.volumeId);
     }
@@ -31,4 +32,3 @@ function getImageSliceDataForVolumeViewport(viewport) {
     };
 }
 export default getImageSliceDataForVolumeViewport;
-//# sourceMappingURL=getImageSliceDataForVolumeViewport.js.map

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

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

package/dist/esm/utilities/getMinMax.js

@@ -13,4 +13,3 @@ export default function getMinMax(storedPixelData) {
         max,
     };
 }
-//# sourceMappingURL=getMinMax.js.map

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

@@ -0,0 +1 @@
+export declare function getRandomSampleFromArray<T>(array: T[], size: number): T[];

package/dist/esm/utilities/getRandomSampleFromArray.js

@@ -13,4 +13,3 @@ function shuffleArray(array) {
         [array[i], array[j]] = [array[j], array[i]];
     }
 }
-//# sourceMappingURL=getRandomSampleFromArray.js.map

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

@@ -0,0 +1 @@
+export default function getRuntimeId(context?: unknown, separator?: string, max?: number): string;

package/dist/esm/utilities/getRuntimeId.js

@@ -27,4 +27,3 @@ function getNextRuntimeId(context, symbol, max) {
     }
     return idComponents;
 }
-//# sourceMappingURL=getRuntimeId.js.map

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

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

package/dist/esm/utilities/getScalingParameters.js

@@ -1,14 +1,14 @@
-import { get as metaDataGet } from '../metaData';
+import * as metaData from '../metaData';
 export default function getScalingParameters(imageId) {
-    const modalityLutModule = metaDataGet('modalityLutModule', imageId) || {};
-    const generalSeriesModule = metaDataGet('generalSeriesModule', imageId) || {};
+    const modalityLutModule = metaData.get('modalityLutModule', imageId) || {};
+    const generalSeriesModule = metaData.get('generalSeriesModule', imageId) || {};
     const { modality } = generalSeriesModule;
     const scalingParameters = {
         rescaleSlope: modalityLutModule.rescaleSlope || 1,
         rescaleIntercept: modalityLutModule.rescaleIntercept ?? 0,
         modality,
     };
-    const suvFactor = metaDataGet('scalingModule', imageId) || {};
+    const suvFactor = metaData.get('scalingModule', imageId) || {};
     return {
         ...scalingParameters,
         ...(modality === 'PT' && {
@@ -18,4 +18,3 @@ export default function getScalingParameters(imageId) {
         }),
     };
 }
-//# sourceMappingURL=getScalingParameters.js.map

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

@@ -0,0 +1,2 @@
+import type { VolumeActor, Point3, ActorSliceRange } from '../types';
+export default function getSliceRange(volumeActor: VolumeActor, viewPlaneNormal: Point3, focalPoint: Point3): ActorSliceRange;

package/dist/esm/utilities/getSliceRange.js

@@ -54,4 +54,3 @@ export default function getSliceRange(volumeActor, viewPlaneNormal, focalPoint)
         focalPoint,
     };
 }
-//# sourceMappingURL=getSliceRange.js.map

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

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

package/dist/esm/utilities/getSpacingInNormalDirection.js

@@ -14,4 +14,3 @@ export default function getSpacingInNormalDirection(imageVolume, viewPlaneNormal
     const spacingInNormalDirection = vec3.length(projectedSpacing);
     return spacingInNormalDirection;
 }
-//# sourceMappingURL=getSpacingInNormalDirection.js.map

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

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

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,
@@ -18,7 +18,7 @@ export default function getTargetVolumeAndSpacingInNormalDir(viewport, camera, t
     }
     const imageVolumes = volumeActors
         .map((va) => {
-        const actorUID = va.referenceId ?? va.uid;
+        const actorUID = va.referencedId ?? va.uid;
         return cache.getVolume(actorUID);
     })
         .filter((iv) => !!iv);
@@ -61,9 +61,8 @@ 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;
 }
-//# sourceMappingURL=getTargetVolumeAndSpacingInNormalDir.js.map

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

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

package/dist/esm/utilities/getViewportImageCornersInWorld.js

@@ -62,4 +62,3 @@ function _isInBounds(imageCoord, dimensions) {
         imageCoord[2] > 0 ||
         imageCoord[2] < dimensions[2] - 1);
 }
-//# sourceMappingURL=getViewportImageCornersInWorld.js.map

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

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

package/dist/esm/utilities/getViewportImageIds.js

@@ -1,10 +1,8 @@
 import { VolumeViewport } from '../RenderingEngine';
-import cache from '../cache';
+import cache from '../cache/cache';
 function getViewportImageIds(viewport) {
     if (viewport instanceof VolumeViewport) {
-        const defaultActor = viewport.getDefaultActor();
-        const volumeId = defaultActor.uid;
-        const volume = cache.getVolume(volumeId);
+        const volume = cache.getVolume(viewport.getVolumeId());
         return volume.imageIds;
     }
     else if (viewport.getImageIds) {
@@ -12,4 +10,3 @@ function getViewportImageIds(viewport) {
     }
 }
 export default getViewportImageIds;
-//# sourceMappingURL=getViewportImageIds.js.map

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

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