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

package/dist/esm/utilities/getBufferConfiguration.js

@@ -0,0 +1,43 @@
+function getBufferConfiguration(targetBufferType, length, options = {}) {
+    const { use16BitTexture = false, isVolumeBuffer = false } = options;
+    switch (targetBufferType) {
+        case 'Float32Array':
+            return { numBytes: length * 4, TypedArrayConstructor: Float32Array };
+        case 'Uint8Array':
+            return { numBytes: length, TypedArrayConstructor: 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 };
+            }
+            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 };
+                }
+            }
+        default:
+            if (targetBufferType) {
+                throw new Error('TargetBuffer should be Float32Array, Uint8Array, Uint16Array, or Int16Array');
+            }
+            else {
+                return { numBytes: length * 4, TypedArrayConstructor: Float32Array };
+            }
+    }
+}
+export { getBufferConfiguration };

package/dist/esm/utilities/getClosestImageId.js

@@ -30,4 +30,3 @@ export default function getClosestImageId(imageVolume, worldPos, viewPlaneNormal
     }
     return imageIdForTool;
 }
-//# sourceMappingURL=getClosestImageId.js.map

package/dist/esm/utilities/getClosestStackImageIndexForPoint.js

@@ -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,10 @@
+import { mat4 } from 'gl-matrix';
+import { IVolumeViewport } from '../types';
+declare function getCurrentVolumeViewportSlice(viewport: IVolumeViewport): {
+    width: number;
+    height: number;
+    scalarData: any;
+    sliceToIndexMatrix: mat4;
+    indexToSliceMatrix: mat4;
+};
+export { getCurrentVolumeViewportSlice as default, getCurrentVolumeViewportSlice, };

package/dist/esm/utilities/getCurrentVolumeViewportSlice.js

@@ -0,0 +1,81 @@
+import { glMatrix, mat4, vec3 } from 'gl-matrix';
+import { transformIJKToCanvas } from './transformIJKToCanvas';
+import { transformCanvasToIJK } from './transformCanvasToIJK';
+function getCurrentVolumeViewportSlice(viewport) {
+    const { dimensions, scalarData } = viewport.getImageData();
+    const { width: canvasWidth, height: canvasHeight } = viewport.getCanvas();
+    const ijkOriginPoint = transformCanvasToIJK(viewport, [0, 0]);
+    const ijkRowPoint = transformCanvasToIJK(viewport, [canvasWidth - 1, 0]);
+    const ijkColPoint = transformCanvasToIJK(viewport, [0, canvasHeight - 1]);
+    const ijkRowVec = vec3.sub(vec3.create(), ijkRowPoint, ijkOriginPoint);
+    const ijkColVec = vec3.sub(vec3.create(), ijkColPoint, ijkOriginPoint);
+    const ijkSliceVec = vec3.cross(vec3.create(), ijkRowVec, ijkColVec);
+    vec3.normalize(ijkRowVec, ijkRowVec);
+    vec3.normalize(ijkColVec, ijkColVec);
+    vec3.normalize(ijkSliceVec, ijkSliceVec);
+    const maxIJKRowVec = Math.max(Math.abs(ijkRowVec[0]), Math.abs(ijkRowVec[1]), Math.abs(ijkRowVec[2]));
+    const maxIJKColVec = Math.max(Math.abs(ijkColVec[0]), Math.abs(ijkColVec[1]), Math.abs(ijkColVec[2]));
+    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);
+    }
+    return {
+        width: sliceWidth,
+        height: sliceHeight,
+        scalarData: sliceData,
+        sliceToIndexMatrix,
+        indexToSliceMatrix,
+    };
+}
+export { getCurrentVolumeViewportSlice as default, getCurrentVolumeViewportSlice, };

package/dist/esm/utilities/getImageLegacy.js

@@ -12,4 +12,3 @@ function getImageLegacy(element) {
     return viewport.getCornerstoneImage();
 }
 export default getImageLegacy;
-//# sourceMappingURL=getImageLegacy.js.map

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.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

@@ -0,0 +1,15 @@
+export function getRandomSampleFromArray(array, size) {
+    const clonedArray = [...array];
+    if (size >= clonedArray.length) {
+        shuffleArray(clonedArray);
+        return clonedArray;
+    }
+    shuffleArray(clonedArray);
+    return clonedArray.slice(0, size);
+}
+function shuffleArray(array) {
+    for (let i = array.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [array[i], array[j]] = [array[j], array[i]];
+    }
+}

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/getScalarDataType.js

@@ -17,4 +17,3 @@ export default function getScalarDataType(scalingParameters, scalarData) {
     }
     return type;
 }
-//# sourceMappingURL=getScalarDataType.js.map

package/dist/esm/utilities/getScalingParameters.js

@@ -4,8 +4,8 @@ export default function getScalingParameters(imageId) {
     const generalSeriesModule = metaDataGet('generalSeriesModule', imageId) || {};
     const { modality } = generalSeriesModule;
     const scalingParameters = {
-        rescaleSlope: modalityLutModule.rescaleSlope,
-        rescaleIntercept: modalityLutModule.rescaleIntercept,
+        rescaleSlope: modalityLutModule.rescaleSlope || 1,
+        rescaleIntercept: modalityLutModule.rescaleIntercept ?? 0,
         modality,
     };
     const suvFactor = metaDataGet('scalingModule', imageId) || {};
@@ -18,4 +18,3 @@ export default function getScalingParameters(imageId) {
         }),
     };
 }
-//# sourceMappingURL=getScalingParameters.js.map

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

@@ -1,2 +1,6 @@
+import { mat3 } from 'gl-matrix';
 import { IImageVolume, Point3 } from '../types';
-export default function getSpacingInNormalDirection(imageVolume: IImageVolume, viewPlaneNormal: Point3): number;
+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

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

package/dist/esm/utilities/getTargetVolumeAndSpacingInNormalDir.js

@@ -2,10 +2,11 @@ import cache from '../cache/cache';
 import { EPSILON } from '../constants';
 import getSpacingInNormalDirection from './getSpacingInNormalDirection';
 import { getVolumeLoaderSchemes } from '../loaders/volumeLoader';
+import { getVolumeId } from './getVolumeId';
 const EPSILON_PART = 1 + EPSILON;
 const startsWith = (str, starts) => starts === str.substring(0, Math.min(str.length, starts.length));
 const isPrimaryVolume = (volume) => !!getVolumeLoaderSchemes().find((scheme) => startsWith(volume.volumeId, scheme));
-export default function getTargetVolumeAndSpacingInNormalDir(viewport, camera, targetVolumeId) {
+export default function getTargetVolumeAndSpacingInNormalDir(viewport, camera, targetId, useSlabThickness = false) {
     const { viewPlaneNormal } = camera;
     const volumeActors = viewport.getActors();
     if (!volumeActors || !volumeActors.length) {
@@ -17,15 +18,16 @@ 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);
-    if (targetVolumeId) {
-        const imageVolumeIndex = imageVolumes.findIndex((iv) => iv.volumeId === targetVolumeId);
+    if (targetId) {
+        const targetVolumeId = getVolumeId(targetId);
+        const imageVolumeIndex = imageVolumes.findIndex((iv) => targetVolumeId.includes(iv.volumeId));
         const imageVolume = imageVolumes[imageVolumeIndex];
         const { uid: actorUID } = volumeActors[imageVolumeIndex];
-        const spacingInNormalDirection = getSpacingInNormalDirection(imageVolume, viewPlaneNormal);
+        const spacingInNormalDirection = getSpacingInNormal(imageVolume, viewPlaneNormal, viewport, useSlabThickness);
         return { imageVolume, spacingInNormalDirection, actorUID };
     }
     if (!imageVolumes.length) {
@@ -46,7 +48,7 @@ export default function getTargetVolumeAndSpacingInNormalDir(viewport, camera, t
         if (hasPrimaryVolume && !isPrimaryVolume(imageVolume)) {
             continue;
         }
-        const spacingInNormalDirection = getSpacingInNormalDirection(imageVolume, viewPlaneNormal);
+        const spacingInNormalDirection = getSpacingInNormal(imageVolume, viewPlaneNormal, viewport);
         if (spacingInNormalDirection * EPSILON_PART <
             smallest.spacingInNormalDirection) {
             smallest.spacingInNormalDirection = spacingInNormalDirection;
@@ -56,4 +58,11 @@ export default function getTargetVolumeAndSpacingInNormalDir(viewport, camera, t
     }
     return smallest;
 }
-//# sourceMappingURL=getTargetVolumeAndSpacingInNormalDir.js.map
+function getSpacingInNormal(imageVolume, viewPlaneNormal, viewport, useSlabThickness = false) {
+    const { slabThickness } = viewport.getProperties();
+    let spacingInNormalDirection = slabThickness;
+    if (!slabThickness || useSlabThickness === false) {
+        spacingInNormalDirection = getSpacingInNormalDirection(imageVolume, viewPlaneNormal);
+    }
+    return spacingInNormalDirection;
+}

package/dist/esm/utilities/getViewportImageCornersInWorld.js

@@ -1,10 +1,14 @@
 export default function getViewportImageCornersInWorld(viewport) {
     const { imageData, dimensions } = viewport.getImageData();
     const { canvas } = viewport;
+    const ratio = window.devicePixelRatio;
     const topLeftCanvas = [0, 0];
-    const topRightCanvas = [canvas.width, 0];
-    const bottomRightCanvas = [canvas.width, canvas.height];
-    const bottomLeftCanvas = [0, canvas.height];
+    const topRightCanvas = [canvas.width / ratio, 0];
+    const bottomRightCanvas = [
+        canvas.width / ratio,
+        canvas.height / ratio,
+    ];
+    const bottomLeftCanvas = [0, canvas.height / ratio];
     const topLeftWorld = viewport.canvasToWorld(topLeftCanvas);
     const topRightWorld = viewport.canvasToWorld(topRightCanvas);
     const bottomRightWorld = viewport.canvasToWorld(bottomRightCanvas);
@@ -58,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 { IViewport } from '../types';
+declare function getViewportImageIds(viewport: IViewport): string[];
+export default getViewportImageIds;

package/dist/esm/utilities/getViewportImageIds.js

@@ -0,0 +1,14 @@
+import { VolumeViewport } from '../RenderingEngine';
+import cache from '../cache';
+function getViewportImageIds(viewport) {
+    if (viewport instanceof VolumeViewport) {
+        const defaultActor = viewport.getDefaultActor();
+        const volumeId = defaultActor.uid;
+        const volume = cache.getVolume(volumeId);
+        return volume.imageIds;
+    }
+    else if (viewport.getImageIds) {
+        return viewport.getImageIds();
+    }
+}
+export default getViewportImageIds;

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

@@ -0,0 +1,3 @@
+import type { IViewport } from '../types';
+declare function getViewportModality(viewport: IViewport, volumeId?: string): string;
+export { getViewportModality as default, getViewportModality };

package/dist/esm/utilities/getViewportModality.js

@@ -0,0 +1,15 @@
+import cache from '../cache';
+function getViewportModality(viewport, volumeId) {
+    if (viewport.modality) {
+        return viewport.modality;
+    }
+    if (viewport.setVolumes) {
+        volumeId = volumeId ?? viewport.getDefaultActor()?.uid;
+        if (!volumeId) {
+            return;
+        }
+        return cache.getVolume(volumeId)?.metadata.Modality;
+    }
+    throw new Error('Invalid viewport type');
+}
+export { getViewportModality as default, getViewportModality };

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

@@ -1,4 +1,4 @@
 import { IStackViewport, IVolumeViewport } from '../types';
-declare type Viewport = IStackViewport | IVolumeViewport;
+type Viewport = IStackViewport | IVolumeViewport;
 export default function getViewportsWithImageURI(imageURI: string, renderingEngineId?: string): Array<Viewport>;
 export {};

package/dist/esm/utilities/getViewportsWithImageURI.js

@@ -10,12 +10,12 @@ export default function getViewportsWithImageURI(imageURI, renderingEngineId) {
     }
     const viewports = [];
     renderingEngines.forEach((renderingEngine) => {
-        const stackViewports = renderingEngine.getStackViewports();
-        const filteredStackViewports = stackViewports.filter((viewport) => viewport.hasImageURI(imageURI));
-        const volumeViewports = renderingEngine.getVolumeViewports();
-        const filteredVolumeViewports = volumeViewports.filter((viewport) => viewport.hasImageURI(imageURI));
-        viewports.push(...filteredStackViewports, ...filteredVolumeViewports);
+        const viewportsForRenderingEngine = renderingEngine.getViewports();
+        viewportsForRenderingEngine.forEach((viewport) => {
+            if (viewport.hasImageURI(imageURI)) {
+                viewports.push(viewport);
+            }
+        });
     });
     return viewports;
 }
-//# sourceMappingURL=getViewportsWithImageURI.js.map

package/dist/esm/utilities/getViewportsWithVolumeId.js

@@ -16,4 +16,3 @@ function getViewportsWithVolumeId(volumeId, renderingEngineId) {
     return targetViewports;
 }
 export default getViewportsWithVolumeId;
-//# sourceMappingURL=getViewportsWithVolumeId.js.map

package/dist/esm/utilities/getVoiFromSigmoidRGBTransferFunction.js

@@ -16,4 +16,3 @@ export default function getVoiFromSigmoidRGBTransferFunction(cfun) {
     const wc = Math.round(x1 + (ww * logy1) / 4);
     return [Math.round(wc - ww / 2), Math.round(wc + ww / 2)];
 }
-//# sourceMappingURL=getVoiFromSigmoidRGBTransferFunction.js.map

package/dist/esm/utilities/getVolumeActorCorners.js

@@ -12,4 +12,3 @@ export default function getVolumeActorCorners(volumeActor) {
         [bounds[1], bounds[3], bounds[5]],
     ];
 }
-//# sourceMappingURL=getVolumeActorCorners.js.map

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

@@ -0,0 +1 @@
+export declare const getVolumeId: (targetId: string) => string;

package/dist/esm/utilities/getVolumeId.js

@@ -0,0 +1,8 @@
+export const getVolumeId = (targetId) => {
+    const prefix = 'volumeId:';
+    const str = targetId.includes(prefix)
+        ? targetId.substring(prefix.length)
+        : targetId;
+    const index = str.indexOf('?');
+    return index === -1 ? str : str.substring(0, index);
+};

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

@@ -1,5 +1,5 @@
 import { ActorSliceRange, IVolumeViewport, ICamera } from '../types';
-declare function getVolumeSliceRangeInfo(viewport: IVolumeViewport, volumeId: string): {
+declare function getVolumeSliceRangeInfo(viewport: IVolumeViewport, volumeId: string, useSlabThickness?: boolean): {
     sliceRange: ActorSliceRange;
     spacingInNormalDirection: number;
     camera: ICamera;

package/dist/esm/utilities/getVolumeSliceRangeInfo.js

@@ -1,9 +1,9 @@
 import getSliceRange from './getSliceRange';
 import getTargetVolumeAndSpacingInNormalDir from './getTargetVolumeAndSpacingInNormalDir';
-function getVolumeSliceRangeInfo(viewport, volumeId) {
+function getVolumeSliceRangeInfo(viewport, volumeId, useSlabThickness = false) {
     const camera = viewport.getCamera();
     const { focalPoint, viewPlaneNormal } = camera;
-    const { spacingInNormalDirection, actorUID } = getTargetVolumeAndSpacingInNormalDir(viewport, camera, volumeId);
+    const { spacingInNormalDirection, actorUID } = getTargetVolumeAndSpacingInNormalDir(viewport, camera, volumeId, useSlabThickness);
     if (!actorUID) {
         throw new Error(`Could not find image volume with id ${volumeId} in the viewport`);
     }
@@ -21,4 +21,3 @@ function getVolumeSliceRangeInfo(viewport, volumeId) {
     };
 }
 export default getVolumeSliceRangeInfo;
-//# sourceMappingURL=getVolumeSliceRangeInfo.js.map

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

@@ -1,11 +1,11 @@
 import { IVolumeViewport } from '../types';
-declare function getVolumeViewportScrollInfo(viewport: IVolumeViewport, volumeId: string): {
+declare function getVolumeViewportScrollInfo(viewport: IVolumeViewport, volumeId: string, useSlabThickness?: boolean): {
     numScrollSteps: number;
     currentStepIndex: number;
     sliceRangeInfo: {
-        sliceRange: import("../types/ActorSliceRange").default;
+        sliceRange: import("../types").ActorSliceRange;
         spacingInNormalDirection: number;
-        camera: import("../types/ICamera").default;
+        camera: import("../types").ICamera;
     };
 };
 export default getVolumeViewportScrollInfo;

package/dist/esm/utilities/getVolumeViewportScrollInfo.js

@@ -1,6 +1,6 @@
 import getVolumeSliceRangeInfo from './getVolumeSliceRangeInfo';
-function getVolumeViewportScrollInfo(viewport, volumeId) {
-    const { sliceRange, spacingInNormalDirection, camera } = getVolumeSliceRangeInfo(viewport, volumeId);
+function getVolumeViewportScrollInfo(viewport, volumeId, useSlabThickness = false) {
+    const { sliceRange, spacingInNormalDirection, camera } = getVolumeSliceRangeInfo(viewport, volumeId, useSlabThickness);
     const { min, max, current } = sliceRange;
     const numScrollSteps = Math.round((max - min) / spacingInNormalDirection);
     const fraction = (current - min) / (max - min);
@@ -17,4 +17,3 @@ function getVolumeViewportScrollInfo(viewport, volumeId) {
     };
 }
 export default getVolumeViewportScrollInfo;
-//# sourceMappingURL=getVolumeViewportScrollInfo.js.map

package/dist/esm/utilities/getVolumeViewportsContainingSameVolumes.js

@@ -25,4 +25,3 @@ function getVolumeViewportsContainingSameVolumes(targetViewport, renderingEngine
     return sameVolumesViewports;
 }
 export default getVolumeViewportsContainingSameVolumes;
-//# sourceMappingURL=getVolumeViewportsContainingSameVolumes.js.map

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

@@ -0,0 +1,2 @@
+import { ScalingParameters } from '../types';
+export declare const hasFloatScalingParameters: (scalingParameters: ScalingParameters) => boolean;

package/dist/esm/utilities/hasFloatScalingParameters.js

@@ -0,0 +1,4 @@
+export const hasFloatScalingParameters = (scalingParameters) => {
+    const hasFloatRescale = Object.values(scalingParameters).some((value) => typeof value === 'number' && !Number.isInteger(value));
+    return hasFloatRescale;
+};

package/dist/esm/utilities/hasNaNValues.js

@@ -4,4 +4,3 @@ export default function hasNaNValues(input) {
     }
     return Number.isNaN(input);
 }
-//# sourceMappingURL=hasNaNValues.js.map

package/dist/esm/utilities/imageIdToURI.js

@@ -2,4 +2,3 @@ export default function imageIdToURI(imageId) {
     const colonIndex = imageId.indexOf(':');
     return imageId.substring(colonIndex + 1);
 }
-//# sourceMappingURL=imageIdToURI.js.map

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

@@ -0,0 +1,7 @@
+declare const imageRetrieveMetadataProvider: {
+    IMAGE_RETRIEVE_CONFIGURATION: string;
+    clear: () => void;
+    add: (key: string, payload: any) => void;
+    get: (type: string, ...queries: string[]) => any;
+};
+export default imageRetrieveMetadataProvider;

package/dist/esm/utilities/imageRetrieveMetadataProvider.js

@@ -0,0 +1,21 @@
+import { addProvider } from '../metaData';
+const retrieveConfigurationState = new Map();
+const IMAGE_RETRIEVE_CONFIGURATION = 'imageRetrieveConfiguration';
+const imageRetrieveMetadataProvider = {
+    IMAGE_RETRIEVE_CONFIGURATION,
+    clear: () => {
+        retrieveConfigurationState.clear();
+    },
+    add: (key, payload) => {
+        retrieveConfigurationState.set(key, payload);
+    },
+    get: (type, ...queries) => {
+        if (type === IMAGE_RETRIEVE_CONFIGURATION) {
+            return queries
+                .map((query) => retrieveConfigurationState.get(query))
+                .find((it) => it !== undefined);
+        }
+    },
+};
+addProvider(imageRetrieveMetadataProvider.get.bind(imageRetrieveMetadataProvider));
+export default imageRetrieveMetadataProvider;

package/dist/esm/utilities/imageToWorldCoords.js

@@ -14,4 +14,3 @@ export default function imageToWorldCoords(imageId, imageCoords) {
     vec3.scaleAndAdd(imageCoordsInWorld, imageCoordsInWorld, columnCosines, columnPixelSpacing * (imageCoords[1] - 0.5));
     return Array.from(imageCoordsInWorld);
 }
-//# sourceMappingURL=imageToWorldCoords.js.map