@cornerstonejs/tools 3.0.2 → 3.0.3

package/dist/esm/utilities/segmentation/segmentContourAction.js

@@ -0,0 +1,95 @@
+import { getEnabledElement, utilities } from '@cornerstonejs/core';
+import { state as annotationState, config as annotationConfig, } from '../../stateManagement/annotation';
+import contourAndFindLargestBidirectional from './contourAndFindLargestBidirectional';
+import createBidirectionalToolData from './createBidirectionalToolData';
+import BidirectionalTool from '../../tools/annotation/BidirectionalTool';
+import { getSegmentations } from '../../stateManagement/segmentation/getSegmentations';
+import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getActiveSegmentIndex';
+export default function segmentContourAction(element, configuration) {
+    const { data: configurationData } = configuration;
+    const enabledElement = getEnabledElement(element);
+    const segment = (configurationData.getSegment || defaultGetSegment)(enabledElement, configurationData);
+    if (!segment) {
+        return;
+    }
+    const FrameOfReferenceUID = enabledElement.viewport.getFrameOfReferenceUID();
+    const segmentationsList = getSegmentations();
+    const { segmentIndex, segmentationId } = segment;
+    const bidirectionals = annotationState.getAnnotations(this.toolName || BidirectionalTool.toolName, FrameOfReferenceUID);
+    let hasExistingActiveSegment = false;
+    const existingLargestBidirectionals = bidirectionals.filter((existingBidirectionalItem) => {
+        const segment = existingBidirectionalItem.data.segment;
+        if (!segment) {
+            return false;
+        }
+        if (segment.segmentationId === segmentationId &&
+            segment.segmentIndex === segmentIndex) {
+            hasExistingActiveSegment = true;
+            existingBidirectionalItem.data.segment = segment;
+        }
+        return true;
+    });
+    if (!hasExistingActiveSegment) {
+        existingLargestBidirectionals.push({
+            data: { segment },
+        });
+    }
+    let newBidirectional;
+    existingLargestBidirectionals.forEach((existingLargestBidirectional) => {
+        const segments = [];
+        const updateSegment = existingLargestBidirectional.data.segment;
+        const { segmentIndex, segmentationId } = updateSegment;
+        segments[segmentIndex] = updateSegment;
+        annotationState.removeAnnotation(existingLargestBidirectional.annotationUID);
+        const bidirectionalData = contourAndFindLargestBidirectional({
+            ...segmentationsList.find((segmentation) => segmentation.segmentationId === segmentationId),
+            segments,
+        });
+        if (!bidirectionalData) {
+            return;
+        }
+        const bidirectionalToolData = createBidirectionalToolData(bidirectionalData, enabledElement.viewport);
+        bidirectionalToolData.annotationUID =
+            existingLargestBidirectional.annotationUID;
+        bidirectionalToolData.data.segment = updateSegment;
+        const annotationUID = annotationState.addAnnotation(bidirectionalToolData, FrameOfReferenceUID);
+        if (updateSegment.segmentIndex === segment.segmentIndex &&
+            updateSegment.segmentationId === segment.segmentationId) {
+            newBidirectional = bidirectionalData;
+            const { style } = segment;
+            if (style) {
+                annotationConfig.style.setAnnotationStyles(annotationUID, style);
+            }
+        }
+    });
+    if (newBidirectional) {
+        const { sliceIndex } = newBidirectional;
+        const imageIds = enabledElement.viewport.getImageIds();
+        utilities.jumpToSlice(element, {
+            imageIndex: imageIds.length - 1 - sliceIndex,
+        });
+        enabledElement.viewport.render();
+    }
+    else {
+        console.warn('No bidirectional found');
+    }
+    return newBidirectional;
+}
+export function defaultGetSegment(enabledElement, configuration) {
+    const segmentationsList = getSegmentations();
+    if (!segmentationsList.length) {
+        return;
+    }
+    const segmentationId = configuration.segmentationId || segmentationsList[0].segmentationId;
+    const segmentIndex = configuration.segmentIndex ?? getActiveSegmentIndex(segmentationId);
+    if (!segmentIndex) {
+        return;
+    }
+    const segmentData = configuration.segmentData?.get(segmentIndex);
+    return {
+        label: `Segment ${segmentIndex}`,
+        segmentIndex,
+        segmentationId,
+        ...segmentData,
+    };
+}

package/dist/esm/utilities/segmentation/thresholdSegmentationByRange.d.ts

@@ -0,0 +1,4 @@
+import type { Types } from '@cornerstonejs/core';
+import type { ThresholdInformation } from './utilities';
+declare function thresholdSegmentationByRange(segmentationVolume: Types.IImageVolume, segmentationIndex: number, thresholdVolumeInformation: ThresholdInformation[], overlapType: number): Types.IImageVolume;
+export default thresholdSegmentationByRange;

package/dist/esm/utilities/segmentation/thresholdSegmentationByRange.js

@@ -0,0 +1,58 @@
+import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
+import { getVoxelOverlap, processVolumes } from './utilities';
+function thresholdSegmentationByRange(segmentationVolume, segmentationIndex, thresholdVolumeInformation, overlapType) {
+    const { baseVolumeIdx, volumeInfoList } = processVolumes(segmentationVolume, thresholdVolumeInformation);
+    const { voxelManager } = volumeInfoList[baseVolumeIdx];
+    const refVoxelManager = voxelManager;
+    const scalarDataLength = segmentationVolume.voxelManager.getScalarDataLength();
+    const segVoxelManager = segmentationVolume.voxelManager;
+    volumeInfoList.forEach((volumeInfo) => {
+        const { volumeSize } = volumeInfo;
+        if (volumeSize === scalarDataLength) {
+            _handleSameSizeVolume(segVoxelManager, refVoxelManager, segmentationIndex, volumeInfo);
+        }
+        else {
+            _handleDifferentSizeVolume(segVoxelManager, refVoxelManager, segmentationIndex, volumeInfo, volumeInfoList, baseVolumeIdx, overlapType);
+        }
+    });
+    triggerSegmentationDataModified(segmentationVolume.volumeId);
+    return segmentationVolume;
+}
+function _handleDifferentSizeVolume(segVoxelManager, refVoxelManager, segmentationIndex, volumeInfo, volumeInfoList, baseVolumeIdx, overlapType) {
+    const { imageData, lower, upper, dimensions } = volumeInfo;
+    let total, overlaps, range;
+    const segScalarDataLength = segVoxelManager.getScalarDataLength();
+    for (let i = 0; i < segScalarDataLength; i++) {
+        if (segScalarDataLength.getAtIndex(i) === segmentationIndex) {
+            const overlapBounds = getVoxelOverlap(imageData, dimensions, volumeInfoList[baseVolumeIdx].spacing, volumeInfoList[baseVolumeIdx].imageData.getPoint(i));
+            const callbackOverlap = ({ value }) => {
+                total = total + 1;
+                if (value >= range.lower && value <= range.upper) {
+                    overlaps = overlaps + 1;
+                }
+            };
+            total = 0;
+            overlaps = 0;
+            range = { lower, upper };
+            let overlapTest = false;
+            segVoxelManager.forEach(callbackOverlap, {
+                imageData,
+                boundsIJK: overlapBounds,
+            });
+            overlapTest = overlapType === 0 ? overlaps > 0 : overlaps === total;
+            segVoxelManager.setAtIndex(i, overlapTest ? segmentationIndex : 0);
+        }
+    }
+    return { total, range, overlaps };
+}
+function _handleSameSizeVolume(segVoxelManager, refVoxelManager, segmentationIndex, volumeInfo) {
+    const { lower, upper } = volumeInfo;
+    const scalarDataLength = segVoxelManager.getScalarDataLength();
+    for (let i = 0; i < scalarDataLength; i++) {
+        if (segVoxelManager.getAtIndex[i] === segmentationIndex) {
+            const value = refVoxelManager.getAtIndex(i);
+            segVoxelManager.setAtIndex(i, value >= lower && value <= upper ? segmentationIndex : 0);
+        }
+    }
+}
+export default thresholdSegmentationByRange;

package/dist/esm/utilities/segmentation/thresholdVolumeByRange.d.ts

@@ -0,0 +1,11 @@
+import type { Types } from '@cornerstonejs/core';
+import type { BoundsIJK } from '../../types';
+import type { ThresholdInformation } from './utilities';
+export type ThresholdRangeOptions = {
+    overwrite: boolean;
+    boundsIJK: BoundsIJK;
+    overlapType?: number;
+    segmentIndex?: number;
+};
+declare function thresholdVolumeByRange(segmentationVolume: Types.IImageVolume, thresholdVolumeInformation: ThresholdInformation[], options: ThresholdRangeOptions): Types.IImageVolume;
+export default thresholdVolumeByRange;

package/dist/esm/utilities/segmentation/thresholdVolumeByRange.js

@@ -0,0 +1,79 @@
+import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
+import { getVoxelOverlap, processVolumes } from './utilities';
+function thresholdVolumeByRange(segmentationVolume, thresholdVolumeInformation, options) {
+    const { imageData: segmentationImageData } = segmentationVolume;
+    const { overwrite, boundsIJK } = options;
+    const overlapType = options?.overlapType || 0;
+    const segVoxelManager = segmentationVolume.voxelManager;
+    const scalarDataLength = segmentationVolume.voxelManager.getScalarDataLength();
+    if (overwrite) {
+        for (let i = 0; i < scalarDataLength; i++) {
+            segVoxelManager.setAtIndex(i, 0);
+        }
+    }
+    const { baseVolumeIdx, volumeInfoList } = processVolumes(segmentationVolume, thresholdVolumeInformation);
+    let overlaps, total, range;
+    const testOverlapRange = (volumeInfo, voxelSpacing, voxelCenter) => {
+        const callbackOverlap = ({ value }) => {
+            total = total + 1;
+            if (value >= range.lower && value <= range.upper) {
+                overlaps = overlaps + 1;
+            }
+        };
+        const { imageData, dimensions, lower, upper } = volumeInfo;
+        const overlapBounds = getVoxelOverlap(imageData, dimensions, voxelSpacing, voxelCenter);
+        total = 0;
+        overlaps = 0;
+        range = { lower, upper };
+        let overlapTest = false;
+        const { voxelManager } = imageData.get('voxelManager');
+        voxelManager.forEach(callbackOverlap, {
+            imageData,
+            boundsIJK: overlapBounds,
+        });
+        if (overlapType === 0) {
+            overlapTest = overlaps > 0;
+        }
+        else if (overlapType == 1) {
+            overlapTest = overlaps === total;
+        }
+        return overlapTest;
+    };
+    const testRange = (volumeInfo, pointIJK) => {
+        const { imageData, lower, upper } = volumeInfo;
+        const voxelManager = imageData.get('voxelManager').voxelManager;
+        const offset = voxelManager.toIndex(pointIJK);
+        const value = voxelManager.getAtIndex(offset);
+        if (value <= lower || value >= upper) {
+            return false;
+        }
+        else {
+            return true;
+        }
+    };
+    const callback = ({ index, pointIJK, pointLPS }) => {
+        let insert = volumeInfoList.length > 0;
+        for (let i = 0; i < volumeInfoList.length; i++) {
+            if (volumeInfoList[i].volumeSize === scalarDataLength) {
+                insert = testRange(volumeInfoList[i], pointIJK);
+            }
+            else {
+                insert = testOverlapRange(volumeInfoList[i], volumeInfoList[baseVolumeIdx].spacing, pointLPS);
+            }
+            if (!insert) {
+                break;
+            }
+        }
+        if (insert) {
+            segVoxelManager.setAtIndex(index, options.segmentIndex || 1);
+        }
+    };
+    const voxelManager = segmentationVolume.voxelManager;
+    voxelManager.forEach(callback, {
+        imageData: segmentationImageData,
+        boundsIJK,
+    });
+    triggerSegmentationDataModified(segmentationVolume.volumeId);
+    return segmentationVolume;
+}
+export default thresholdVolumeByRange;

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

@@ -0,0 +1,25 @@
+import type { Types } from '@cornerstonejs/core';
+import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+export type ThresholdInformation = {
+    volume: Types.IImageVolume;
+    lower: number;
+    upper: number;
+};
+export type VolumeInfo = {
+    imageData: vtkImageData;
+    lower: number;
+    upper: number;
+    spacing: Types.Point3;
+    dimensions: Types.Point3;
+    volumeSize: number;
+    voxelManager: Types.IVoxelManager<number> | Types.IVoxelManager<Types.RGB>;
+};
+export declare function getVoxelOverlap(imageData: any, dimensions: any, voxelSpacing: any, voxelCenter: any): [Types.Point2, Types.Point2, null] | [Types.Point2, Types.Point2, Types.Point2];
+export declare function processVolumes(segmentationVolume: Types.IImageVolume, thresholdVolumeInformation: ThresholdInformation[]): {
+    volumeInfoList: VolumeInfo[];
+    baseVolumeIdx: number;
+};
+export declare const setSegmentationDirty: (segmentationId: string) => void;
+export declare const setSegmentationClean: (segmentationId: string) => void;
+export declare const getCachedSegmentIndices: (segmentationId: string) => number[];
+export declare const setCachedSegmentIndices: (segmentationId: string, indices: number[]) => void;

package/dist/esm/utilities/segmentation/utilities.js

@@ -0,0 +1,86 @@
+import { utilities as csUtils } from '@cornerstonejs/core';
+import { getBoundingBoxAroundShapeIJK } from '../boundingBox/getBoundingBoxAroundShape';
+const equalsCheck = (a, b) => {
+    return JSON.stringify(a) === JSON.stringify(b);
+};
+export function getVoxelOverlap(imageData, dimensions, voxelSpacing, voxelCenter) {
+    const halfSpacingX = voxelSpacing[0] / 2;
+    const halfSpacingY = voxelSpacing[1] / 2;
+    const halfSpacingZ = voxelSpacing[2] / 2;
+    const voxelCornersIJK = new Array(8);
+    voxelCornersIJK[0] = csUtils.transformWorldToIndex(imageData, [
+        voxelCenter[0] - halfSpacingX,
+        voxelCenter[1] - halfSpacingY,
+        voxelCenter[2] - halfSpacingZ,
+    ]);
+    const offsets = [
+        [1, -1, -1],
+        [-1, 1, -1],
+        [1, 1, -1],
+        [-1, -1, 1],
+        [1, -1, 1],
+        [-1, 1, 1],
+        [1, 1, 1],
+    ];
+    for (let i = 0; i < 7; i++) {
+        const [xOff, yOff, zOff] = offsets[i];
+        voxelCornersIJK[i + 1] = csUtils.transformWorldToIndex(imageData, [
+            voxelCenter[0] + xOff * halfSpacingX,
+            voxelCenter[1] + yOff * halfSpacingY,
+            voxelCenter[2] + zOff * halfSpacingZ,
+        ]);
+    }
+    return getBoundingBoxAroundShapeIJK(voxelCornersIJK, dimensions);
+}
+export function processVolumes(segmentationVolume, thresholdVolumeInformation) {
+    const { spacing: segmentationSpacing } = segmentationVolume;
+    const scalarDataLength = segmentationVolume.voxelManager.getScalarDataLength();
+    const volumeInfoList = [];
+    let baseVolumeIdx = 0;
+    for (let i = 0; i < thresholdVolumeInformation.length; i++) {
+        const { imageData, spacing, dimensions, voxelManager } = thresholdVolumeInformation[i].volume;
+        const volumeSize = thresholdVolumeInformation[i].volume.voxelManager.getScalarDataLength();
+        if (volumeSize === scalarDataLength &&
+            equalsCheck(spacing, segmentationSpacing)) {
+            baseVolumeIdx = i;
+        }
+        const lower = thresholdVolumeInformation[i].lower;
+        const upper = thresholdVolumeInformation[i].upper;
+        volumeInfoList.push({
+            imageData,
+            lower,
+            upper,
+            spacing,
+            dimensions,
+            volumeSize,
+            voxelManager,
+        });
+    }
+    return {
+        volumeInfoList,
+        baseVolumeIdx,
+    };
+}
+const segmentIndicesCache = new Map();
+export const setSegmentationDirty = (segmentationId) => {
+    const cached = segmentIndicesCache.get(segmentationId);
+    if (cached) {
+        cached.isDirty = true;
+    }
+};
+export const setSegmentationClean = (segmentationId) => {
+    const cached = segmentIndicesCache.get(segmentationId);
+    if (cached) {
+        cached.isDirty = false;
+    }
+};
+export const getCachedSegmentIndices = (segmentationId) => {
+    const cached = segmentIndicesCache.get(segmentationId);
+    if (cached && !cached.isDirty) {
+        return cached.indices;
+    }
+    return null;
+};
+export const setCachedSegmentIndices = (segmentationId, indices) => {
+    segmentIndicesCache.set(segmentationId, { indices, isDirty: false });
+};

package/dist/esm/utilities/segmentation/validateLabelmap.d.ts

@@ -0,0 +1,4 @@
+import type { SegmentationPublicInput } from '../../types/SegmentationStateTypes';
+import type { LabelmapSegmentationData } from '../../types/LabelmapTypes';
+export declare function validatePublic(segmentationInput: SegmentationPublicInput): void;
+export declare function validate(segmentationRepresentationData: LabelmapSegmentationData): void;

package/dist/esm/utilities/segmentation/validateLabelmap.js

@@ -0,0 +1,32 @@
+import { cache } from '@cornerstonejs/core';
+function validateRepresentationData(segmentationRepresentationData) {
+    if ('volumeId' in segmentationRepresentationData) {
+        segmentationRepresentationData =
+            segmentationRepresentationData;
+        const cachedVolume = cache.getVolume(segmentationRepresentationData.volumeId);
+        if (!cachedVolume) {
+            throw new Error(`volumeId of ${segmentationRepresentationData.volumeId} not found in cache, you should load and cache volume before adding segmentation`);
+        }
+    }
+    else if ('imageIds' in segmentationRepresentationData) {
+        segmentationRepresentationData =
+            segmentationRepresentationData;
+        if (!segmentationRepresentationData.imageIds) {
+            throw new Error('The segmentationInput.representationData.imageIds is undefined, please provide a valid representationData.imageIds for stack data');
+        }
+    }
+    else {
+        throw new Error('The segmentationInput.representationData is undefined, please provide a valid representationData');
+    }
+}
+export function validatePublic(segmentationInput) {
+    if (!segmentationInput.representation.data) {
+        throw new Error('The segmentationInput.representationData.data is undefined, please provide a valid representationData.data');
+    }
+    const representationData = segmentationInput.representation
+        .data;
+    validateRepresentationData(representationData);
+}
+export function validate(segmentationRepresentationData) {
+    validateRepresentationData(segmentationRepresentationData);
+}

package/dist/esm/utilities/stackPrefetch/index.d.ts

@@ -0,0 +1,3 @@
+import stackPrefetch from './stackPrefetch';
+import stackContextPrefetch from './stackContextPrefetch';
+export { stackPrefetch, stackContextPrefetch };

package/dist/esm/utilities/stackPrefetch/index.js

@@ -0,0 +1,3 @@
+import stackPrefetch from './stackPrefetch';
+import stackContextPrefetch from './stackContextPrefetch';
+export { stackPrefetch, stackContextPrefetch };

package/dist/esm/utilities/stackPrefetch/stackContextPrefetch.d.ts

@@ -0,0 +1,16 @@
+declare function disable(element: any): void;
+declare function getConfiguration(): {
+    maxImagesToPrefetch: number;
+    minBefore: number;
+    maxAfter: number;
+    directionExtraImages: number;
+    preserveExistingPool: boolean;
+};
+declare function setConfiguration(config: any): void;
+declare const stackContextPrefetch: {
+    enable: (element: any) => void;
+    disable: typeof disable;
+    getConfiguration: typeof getConfiguration;
+    setConfiguration: typeof setConfiguration;
+};
+export default stackContextPrefetch;

package/dist/esm/utilities/stackPrefetch/stackContextPrefetch.js

@@ -0,0 +1,221 @@
+import { imageLoader, Enums, eventTarget, imageLoadPoolManager, cache, } from '@cornerstonejs/core';
+import { addToolState, getToolState } from './state';
+import { getStackData, requestType, priority, clearFromImageIds, getPromiseRemovedHandler, } from './stackPrefetchUtils';
+let configuration = {
+    maxImagesToPrefetch: Infinity,
+    minBefore: 2,
+    maxAfter: 2,
+    directionExtraImages: 10,
+    preserveExistingPool: false,
+};
+let resetPrefetchTimeout;
+const resetPrefetchDelay = 5;
+const enable = (element) => {
+    const stack = getStackData(element);
+    if (!stack) {
+        return;
+    }
+    if (!stack.imageIds?.length) {
+        console.warn('CornerstoneTools.stackPrefetch: No images in stack.');
+        return;
+    }
+    updateToolState(element);
+    prefetch(element);
+    element.removeEventListener(Enums.Events.STACK_NEW_IMAGE, onImageUpdated);
+    element.addEventListener(Enums.Events.STACK_NEW_IMAGE, onImageUpdated);
+    const promiseRemovedHandler = getPromiseRemovedHandler(element);
+    eventTarget.removeEventListener(Enums.Events.IMAGE_CACHE_IMAGE_REMOVED, promiseRemovedHandler);
+    eventTarget.addEventListener(Enums.Events.IMAGE_CACHE_IMAGE_REMOVED, promiseRemovedHandler);
+};
+function prefetch(element) {
+    const stack = getStackData(element);
+    if (!stack) {
+        return;
+    }
+    if (!stack?.imageIds?.length) {
+        console.warn('CornerstoneTools.stackPrefetch: No images in stack.');
+        return;
+    }
+    const stackPrefetchData = getToolState(element);
+    if (!stackPrefetchData) {
+        return;
+    }
+    const stackPrefetch = (stackPrefetchData || {});
+    stackPrefetch.enabled =
+        stackPrefetch.enabled && (stackPrefetch.indicesToRequest?.length ?? 0) > 0;
+    if (stackPrefetch.enabled === false) {
+        return;
+    }
+    function removeFromList(imageIdIndex) {
+        const index = stackPrefetch.indicesToRequest.indexOf(imageIdIndex);
+        if (index > -1) {
+            stackPrefetch.indicesToRequest.splice(index, 1);
+        }
+    }
+    const indicesToRequestCopy = stackPrefetch.indicesToRequest.slice();
+    const { currentImageIdIndex } = stack;
+    indicesToRequestCopy.forEach((imageIdIndex) => {
+        const imageId = stack.imageIds[imageIdIndex];
+        if (!imageId) {
+            return;
+        }
+        const distance = Math.abs(currentImageIdIndex - imageIdIndex);
+        const imageCached = distance < 6
+            ? cache.getImageLoadObject(imageId)
+            : cache.isLoaded(imageId);
+        if (imageCached) {
+            removeFromList(imageIdIndex);
+        }
+    });
+    if (!stackPrefetch.indicesToRequest.length) {
+        return;
+    }
+    if (!configuration.preserveExistingPool) {
+        imageLoadPoolManager.filterRequests(clearFromImageIds(stack));
+    }
+    function doneCallback(imageId) {
+        const imageIdIndex = stack.imageIds.indexOf(imageId);
+        removeFromList(imageIdIndex);
+        const image = cache.getCachedImageBasedOnImageURI(imageId);
+        const { stats } = stackPrefetch;
+        const decodeTimeInMS = image?.image?.decodeTimeInMS || 0;
+        if (decodeTimeInMS) {
+            stats.imageIds.set(imageId, decodeTimeInMS);
+            stats.decodeTimeInMS += decodeTimeInMS;
+            const loadTimeInMS = image?.image?.loadTimeInMS || 0;
+            stats.loadTimeInMS += loadTimeInMS;
+        }
+        if (!stackPrefetch.indicesToRequest.length) {
+            if (image?.sizeInBytes) {
+                const { sizeInBytes } = image;
+                const usage = cache.getMaxCacheSize() / 4 / sizeInBytes;
+                if (!stackPrefetch.cacheFill) {
+                    stats.initialTime = Date.now() - stats.start;
+                    stats.initialSize = stats.imageIds.size;
+                    updateToolState(element, usage);
+                    prefetch(element);
+                }
+                else if (stats.imageIds.size) {
+                    stats.fillTime = Date.now() - stats.start;
+                    const { size } = stats.imageIds;
+                    stats.fillSize = size;
+                }
+            }
+        }
+    }
+    const requestFn = (imageId, options) => imageLoader
+        .loadAndCacheImage(imageId, options)
+        .then(() => doneCallback(imageId));
+    stackPrefetch.indicesToRequest.forEach((imageIdIndex) => {
+        const imageId = stack.imageIds[imageIdIndex];
+        const options = {
+            requestType,
+        };
+        imageLoadPoolManager.addRequest(requestFn.bind(null, imageId, options), requestType, {
+            imageId,
+        }, priority);
+    });
+}
+function onImageUpdated(e) {
+    clearTimeout(resetPrefetchTimeout);
+    resetPrefetchTimeout = setTimeout(function () {
+        const element = e.target;
+        try {
+            updateToolState(element);
+            prefetch(element);
+        }
+        catch (error) {
+            return;
+        }
+    }, resetPrefetchDelay);
+}
+const signum = (x) => (x < 0 ? -1 : 1);
+const updateToolState = (element, usage) => {
+    const stack = getStackData(element);
+    if (!stack) {
+        return;
+    }
+    if (!stack.imageIds?.length) {
+        console.warn('CornerstoneTools.stackPrefetch: No images in stack.');
+        return;
+    }
+    const { currentImageIdIndex } = stack;
+    let { maxAfter = 2, minBefore = 2 } = configuration;
+    const { directionExtraImages = 10 } = configuration;
+    const stackPrefetchData = getToolState(element) ||
+        {
+            indicesToRequest: [],
+            currentImageIdIndex,
+            stackCount: 0,
+            enabled: true,
+            direction: 1,
+            stats: {
+                start: Date.now(),
+                imageIds: new Map(),
+                decodeTimeInMS: 0,
+                loadTimeInMS: 0,
+                totalBytes: 0,
+            },
+        };
+    const delta = currentImageIdIndex - stackPrefetchData.currentImageIdIndex;
+    stackPrefetchData.direction = signum(delta);
+    stackPrefetchData.currentImageIdIndex = currentImageIdIndex;
+    stackPrefetchData.enabled = true;
+    if (stackPrefetchData.stackCount < 100) {
+        stackPrefetchData.stackCount += directionExtraImages;
+    }
+    if (Math.abs(delta) > maxAfter || !delta) {
+        stackPrefetchData.stackCount = 0;
+        if (usage) {
+            const positionFraction = currentImageIdIndex / stack.imageIds.length;
+            minBefore = Math.ceil(usage * positionFraction);
+            maxAfter = Math.ceil(usage * (1 - positionFraction));
+            stackPrefetchData.cacheFill = true;
+        }
+        else {
+            stackPrefetchData.cacheFill = false;
+        }
+    }
+    else if (delta < 0) {
+        minBefore += stackPrefetchData.stackCount;
+        maxAfter = 0;
+    }
+    else {
+        maxAfter += stackPrefetchData.stackCount;
+        minBefore = 0;
+    }
+    const minIndex = Math.max(0, currentImageIdIndex - minBefore);
+    const maxIndex = Math.min(stack.imageIds.length - 1, currentImageIdIndex + maxAfter);
+    const indicesToRequest = [];
+    for (let i = currentImageIdIndex + 1; i <= maxIndex; i++) {
+        indicesToRequest.push(i);
+    }
+    for (let i = currentImageIdIndex - 1; i >= minIndex; i--) {
+        indicesToRequest.push(i);
+    }
+    stackPrefetchData.indicesToRequest = indicesToRequest;
+    addToolState(element, stackPrefetchData);
+};
+function disable(element) {
+    clearTimeout(resetPrefetchTimeout);
+    element.removeEventListener(Enums.Events.STACK_NEW_IMAGE, onImageUpdated);
+    const promiseRemovedHandler = getPromiseRemovedHandler(element);
+    eventTarget.removeEventListener(Enums.Events.IMAGE_CACHE_IMAGE_REMOVED, promiseRemovedHandler);
+    const stackPrefetchData = getToolState(element);
+    if (stackPrefetchData) {
+        stackPrefetchData.enabled = false;
+    }
+}
+function getConfiguration() {
+    return configuration;
+}
+function setConfiguration(config) {
+    configuration = config;
+}
+const stackContextPrefetch = {
+    enable,
+    disable,
+    getConfiguration,
+    setConfiguration,
+};
+export default stackContextPrefetch;

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

@@ -0,0 +1,14 @@
+declare function enable(element: any): void;
+declare function disable(element: any): void;
+declare function getConfiguration(): {
+    maxImagesToPrefetch: number;
+    preserveExistingPool: boolean;
+};
+declare function setConfiguration(config: any): void;
+declare const stackPrefetch: {
+    enable: typeof enable;
+    disable: typeof disable;
+    getConfiguration: typeof getConfiguration;
+    setConfiguration: typeof setConfiguration;
+};
+export default stackPrefetch;