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

package/dist/esm/utilities/generateVolumePropsFromImageIds.js

@@ -0,0 +1,71 @@
+import { vec3 } from 'gl-matrix';
+import makeVolumeMetadata from './makeVolumeMetadata';
+import sortImageIdsAndGetSpacing from './sortImageIdsAndGetSpacing';
+import getScalingParameters from './getScalingParameters';
+import { hasFloatScalingParameters } from './hasFloatScalingParameters';
+import { canRenderFloatTextures } from '../init';
+function generateVolumePropsFromImageIds(imageIds, volumeId) {
+    const volumeMetadata = makeVolumeMetadata(imageIds);
+    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();
+    vec3.cross(scanAxisNormal, rowCosineVec, colCosineVec);
+    const { zSpacing, origin, sortedImageIds } = sortImageIdsAndGetSpacing(imageIds, scanAxisNormal);
+    const numFrames = imageIds.length;
+    const spacing = [PixelSpacing[1], PixelSpacing[0], zSpacing];
+    const dimensions = [Columns, Rows, numFrames];
+    const direction = [
+        ...rowCosineVec,
+        ...colCosineVec,
+        ...scanAxisNormal,
+    ];
+    return {
+        dimensions,
+        spacing,
+        origin,
+        dataType: _determineDataType(sortedImageIds, volumeMetadata),
+        direction,
+        metadata: volumeMetadata,
+        imageIds: sortedImageIds,
+        volumeId,
+        voxelManager: null,
+        numberOfComponents: volumeMetadata.PhotometricInterpretation === 'RGB' ? 3 : 1,
+    };
+}
+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.');
+            }
+            return 'Uint8Array';
+        case 16:
+            if (canRenderFloat && floatAfterScale) {
+                return 'Float32Array';
+            }
+            if (signed || hasNegativeRescale) {
+                return 'Int16Array';
+            }
+            if (!signed && !hasNegativeRescale) {
+                return 'Uint16Array';
+            }
+            return 'Float32Array';
+        case 24:
+            return 'Uint8Array';
+        case 32:
+            return 'Float32Array';
+        default:
+            throw new Error(`Bits allocated of ${BitsAllocated} is not defined to generate scalarData for the volume.`);
+    }
+}
+export { generateVolumePropsFromImageIds };

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

@@ -0,0 +1,25 @@
+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] = payload.metadata;
+    },
+    get: (type, imageId) => {
+        return state[imageId]?.[type];
+    },
+    clear: () => {
+        state = {};
+    },
+};
+addProvider(metadataProvider.get);
+export default metadataProvider;

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

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

package/dist/esm/utilities/getBufferConfiguration.js

@@ -0,0 +1,33 @@
+function getBufferConfiguration(targetBufferType, length, options = {}) {
+    const { 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 {
+                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 {
+                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

@@ -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);
@@ -30,4 +30,3 @@ export default function getClosestImageId(imageVolume, worldPos, viewPlaneNormal
     }
     return imageIdForTool;
 }
-//# sourceMappingURL=getClosestImageId.js.map

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/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,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

@@ -0,0 +1,31 @@
+import { glMatrix, vec3 } from 'gl-matrix';
+import { transformCanvasToIJK } from './transformCanvasToIJK';
+function getCurrentVolumeViewportSlice(viewport) {
+    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]);
+    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 { voxelManager } = viewport.getImageData();
+    const sliceViewInfo = viewport.getSliceViewInfo();
+    const scalarData = voxelManager.getSliceData(sliceViewInfo);
+    return {
+        width: sliceViewInfo.width,
+        height: sliceViewInfo.height,
+        scalarData,
+        sliceToIndexMatrix,
+        indexToSliceMatrix,
+    };
+}
+export { getCurrentVolumeViewportSlice as default, getCurrentVolumeViewportSlice, };

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

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

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

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

@@ -1,5 +1,5 @@
-import { ICamera, IImageVolume, IVolumeViewport } from '../types';
-export default function getTargetVolumeAndSpacingInNormalDir(viewport: IVolumeViewport, camera: ICamera, targetVolumeId?: string): {
+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

@@ -2,13 +2,14 @@ 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) {
+    if (!volumeActors.length) {
         return {
             spacingInNormalDirection: null,
             imageVolume: null,
@@ -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) {
+        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/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 type { 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,7 @@
+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

@@ -0,0 +1,18 @@
+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 || !getVolume) {
+            return;
+        }
+        const volume = getVolume(volumeId);
+        return volume.metadata.Modality;
+    }
+    throw new Error('Invalid viewport type');
+}
+export { _getViewportModality };

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

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

@@ -1,3 +1,3 @@
-import { IVolumeViewport } from '../types';
-declare function getViewportsWithVolumeId(volumeId: string, renderingEngineId?: string): Array<IVolumeViewport>;
+import type { IVolumeViewport } from '../types';
+declare function getViewportsWithVolumeId(volumeId: string, renderingEngineId?: string): IVolumeViewport[];
 export default getViewportsWithVolumeId;

package/dist/esm/utilities/getViewportsWithVolumeId.js

@@ -1,12 +1,8 @@
 import { getRenderingEngines, getRenderingEngine, } from '../RenderingEngine/getRenderingEngine';
 function getViewportsWithVolumeId(volumeId, renderingEngineId) {
-    let renderingEngines;
-    if (renderingEngineId) {
-        renderingEngines = [getRenderingEngine(renderingEngineId)];
-    }
-    else {
-        renderingEngines = getRenderingEngines();
-    }
+    const renderingEngines = renderingEngineId
+        ? [getRenderingEngine(renderingEngineId)]
+        : getRenderingEngines();
     const targetViewports = [];
     renderingEngines.forEach((renderingEngine) => {
         const viewports = renderingEngine.getVolumeViewports();
@@ -16,4 +12,3 @@ function getViewportsWithVolumeId(volumeId, renderingEngineId) {
     return targetViewports;
 }
 export default getViewportsWithVolumeId;
-//# sourceMappingURL=getViewportsWithVolumeId.js.map

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

@@ -1,2 +1,2 @@
-import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
+import type vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
 export default function getVoiFromSigmoidRGBTransferFunction(cfun: vtkColorTransferFunction): [number, number];

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

@@ -1,2 +1,2 @@
-import { Point3 } from '../types';
-export default function getVolumeActorCorners(volumeActor: any): Array<Point3>;
+import type { Point3 } from '../types';
+export default function getVolumeActorCorners(volumeActor: any): Point3[];

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('sliceIndex=');
+    return index === -1 ? str : str.substring(0, index - 1);
+};

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

@@ -1,5 +1,5 @@
-import { ActorSliceRange, IVolumeViewport, ICamera } from '../types';
-declare function getVolumeSliceRangeInfo(viewport: IVolumeViewport, volumeId: string): {
+import type { ActorSliceRange, IVolumeViewport, ICamera } from '../types';
+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): {
+import type { IVolumeViewport } from '../types';
+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;