@cornerstonejs/tools 2.0.0-beta.3 → 2.0.0-beta.30

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

@@ -1,22 +1,5 @@
 import { utilities as csUtils } from '@cornerstonejs/core';
-import { getToolGroup } from '../../store/ToolGroupManager';
-import BrushTool from '../../tools/segmentation/BrushTool';
-import getBoundingBoxAroundShape from '../boundingBox/getBoundingBoxAroundShape';
-export default function getBrushToolInstances(toolGroupId, toolName) {
-    const toolGroup = getToolGroup(toolGroupId);
-    if (toolGroup === undefined) {
-        return;
-    }
-    const toolInstances = toolGroup._toolInstances;
-    if (!Object.keys(toolInstances).length) {
-        return;
-    }
-    if (toolName && toolInstances[toolName]) {
-        return [toolInstances[toolName]];
-    }
-    const brushBasedToolInstances = Object.values(toolInstances).filter((toolInstance) => toolInstance instanceof BrushTool);
-    return brushBasedToolInstances;
-}
+import { getBoundingBoxAroundShapeIJK } from '../boundingBox/getBoundingBoxAroundShape';
 const equalsCheck = (a, b) => {
     return JSON.stringify(a) === JSON.stringify(b);
 };
@@ -25,7 +8,7 @@ export function getVoxelOverlap(imageData, dimensions, voxelSpacing, voxelCenter
     for (let i = 0; i < 2; i++) {
         for (let j = 0; j < 2; j++) {
             for (let k = 0; k < 2; k++) {
-                const point = voxelCenter;
+                const point = [...voxelCenter];
                 point[0] = point[0] + ((i * 2 - 1) * voxelSpacing[0]) / 2;
                 point[1] = point[1] + ((j * 2 - 1) * voxelSpacing[1]) / 2;
                 point[2] = point[2] + ((k * 2 - 1) * voxelSpacing[2]) / 2;
@@ -34,32 +17,31 @@ export function getVoxelOverlap(imageData, dimensions, voxelSpacing, voxelCenter
         }
     }
     const voxelCornersIJK = voxelCornersWorld.map((world) => csUtils.transformWorldToIndex(imageData, world));
-    const overlapBounds = getBoundingBoxAroundShape(voxelCornersIJK, dimensions);
+    const overlapBounds = getBoundingBoxAroundShapeIJK(voxelCornersIJK, dimensions);
     return overlapBounds;
 }
 export function processVolumes(segmentationVolume, thresholdVolumeInformation) {
-    const { spacing: segmentationSpacing, imageData: segmentationImageData } = segmentationVolume;
-    const scalarData = segmentationVolume.getScalarData();
+    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 } = thresholdVolumeInformation[i].volume;
-        const volumeSize = thresholdVolumeInformation[i].volume.getScalarData().length;
-        if (volumeSize === scalarData.length &&
+        const { imageData, spacing, dimensions, voxelManager } = thresholdVolumeInformation[i].volume;
+        const volumeSize = thresholdVolumeInformation[i].volume.voxelManager.getScalarDataLength();
+        if (volumeSize === scalarDataLength &&
             equalsCheck(spacing, segmentationSpacing)) {
             baseVolumeIdx = i;
         }
-        const referenceValues = imageData.getPointData().getScalars().getData();
         const lower = thresholdVolumeInformation[i].lower;
         const upper = thresholdVolumeInformation[i].upper;
         volumeInfoList.push({
             imageData,
-            referenceValues,
             lower,
             upper,
             spacing,
             dimensions,
             volumeSize,
+            voxelManager,
         });
     }
     return {
@@ -67,4 +49,26 @@ export function processVolumes(segmentationVolume, thresholdVolumeInformation) {
         baseVolumeIdx,
     };
 }
-//# sourceMappingURL=utilities.js.map
+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/stackPrefetch/index.js

@@ -1,4 +1,3 @@
 import stackPrefetch from './stackPrefetch';
 import stackContextPrefetch from './stackContextPrefetch';
 export { stackPrefetch, stackContextPrefetch };
-//# sourceMappingURL=index.js.map

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

@@ -1,7 +1,6 @@
-import { imageLoader, Enums, eventTarget, imageLoadPoolManager, cache, getConfiguration as getCoreConfiguration, } from '@cornerstonejs/core';
+import { imageLoader, Enums, eventTarget, imageLoadPoolManager, cache, } from '@cornerstonejs/core';
 import { addToolState, getToolState } from './state';
 import { getStackData, requestType, priority, clearFromImageIds, getPromiseRemovedHandler, } from './stackPrefetchUtils';
-import roundNumber from '../roundNumber';
 let configuration = {
     maxImagesToPrefetch: Infinity,
     minBefore: 2,
@@ -13,7 +12,10 @@ let resetPrefetchTimeout;
 const resetPrefetchDelay = 5;
 const enable = (element) => {
     const stack = getStackData(element);
-    if (!stack || !stack.imageIds || stack.imageIds.length === 0) {
+    if (!stack) {
+        return;
+    }
+    if (!stack.imageIds?.length) {
         console.warn('CornerstoneTools.stackPrefetch: No images in stack.');
         return;
     }
@@ -27,6 +29,9 @@ const enable = (element) => {
 };
 function prefetch(element) {
     const stack = getStackData(element);
+    if (!stack) {
+        return;
+    }
     if (!stack?.imageIds?.length) {
         console.warn('CornerstoneTools.stackPrefetch: No images in stack.');
         return;
@@ -35,8 +40,9 @@ function prefetch(element) {
     if (!stackPrefetchData) {
         return;
     }
-    const stackPrefetch = stackPrefetchData || {};
-    stackPrefetch.enabled &&= stackPrefetch.indicesToRequest?.length;
+    const stackPrefetch = (stackPrefetchData || {});
+    stackPrefetch.enabled =
+        stackPrefetch.enabled && (stackPrefetch.indicesToRequest?.length ?? 0) > 0;
     if (stackPrefetch.enabled === false) {
         return;
     }
@@ -93,7 +99,6 @@ function prefetch(element) {
                     stats.fillTime = Date.now() - stats.start;
                     const { size } = stats.imageIds;
                     stats.fillSize = size;
-                    console.log('Done cache fill', stats.fillTime, 'ms', size, 'items', 'average total time', roundNumber(stats.fillTime / size), 'ms', 'average load', roundNumber(stats.loadTimeInMS / size), 'ms', 'average decode', roundNumber(stats.decodeTimeInMS / size), 'ms');
                 }
             }
         }
@@ -101,16 +106,9 @@ function prefetch(element) {
     const requestFn = (imageId, options) => imageLoader
         .loadAndCacheImage(imageId, options)
         .then(() => doneCallback(imageId));
-    const { useNorm16Texture } = getCoreConfiguration().rendering;
-    indicesToRequestCopy.forEach((imageIdIndex) => {
+    stackPrefetch.indicesToRequest.forEach((imageIdIndex) => {
         const imageId = stack.imageIds[imageIdIndex];
         const options = {
-            targetBuffer: {
-                type: useNorm16Texture ? undefined : 'Float32Array',
-            },
-            preScale: {
-                enabled: true,
-            },
             requestType,
         };
         imageLoadPoolManager.addRequest(requestFn.bind(null, imageId, options), requestType, {
@@ -134,27 +132,31 @@ function onImageUpdated(e) {
 const signum = (x) => (x < 0 ? -1 : 1);
 const updateToolState = (element, usage) => {
     const stack = getStackData(element);
-    if (!stack || !stack.imageIds || stack.imageIds.length === 0) {
+    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 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;
@@ -200,7 +202,7 @@ function disable(element) {
     const promiseRemovedHandler = getPromiseRemovedHandler(element);
     eventTarget.removeEventListener(Enums.Events.IMAGE_CACHE_IMAGE_REMOVED, promiseRemovedHandler);
     const stackPrefetchData = getToolState(element);
-    if (stackPrefetchData && stackPrefetchData.data.length) {
+    if (stackPrefetchData) {
         stackPrefetchData.enabled = false;
     }
 }
@@ -217,4 +219,3 @@ const stackContextPrefetch = {
     setConfiguration,
 };
 export default stackContextPrefetch;
-//# sourceMappingURL=stackContextPrefetch.js.map

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

@@ -12,14 +12,15 @@ function prefetch(element) {
     if (!stackPrefetchData) {
         return;
     }
-    const stackPrefetch = stackPrefetchData || {};
+    const stackPrefetch = (stackPrefetchData || {});
     const stack = getStackData(element);
     if (!stack?.imageIds?.length) {
         console.warn('CornerstoneTools.stackPrefetch: No images in stack.');
         return;
     }
     const { currentImageIdIndex } = stack;
-    stackPrefetch.enabled &&= stackPrefetch.indicesToRequest?.length;
+    stackPrefetch.enabled =
+        stackPrefetch.enabled && (stackPrefetch.indicesToRequest?.length ?? 0) > 0;
     if (stackPrefetch.enabled === false) {
         return;
     }
@@ -86,15 +87,8 @@ function prefetch(element) {
         }
     }
     const requestFn = (imageId, options) => imageLoader.loadAndCacheImage(imageId, options);
-    const { useNorm16Texture } = getCoreConfiguration().rendering;
     imageIdsToPrefetch.forEach((imageId) => {
         const options = {
-            targetBuffer: {
-                type: useNorm16Texture ? undefined : 'Float32Array',
-            },
-            preScale: {
-                enabled: true,
-            },
             requestType,
         };
         imageLoadPoolManager.addRequest(requestFn.bind(null, imageId, options), requestType, {
@@ -154,4 +148,3 @@ function setConfiguration(config) {
 }
 const stackPrefetch = { enable, disable, getConfiguration, setConfiguration };
 export default stackPrefetch;
-//# sourceMappingURL=stackPrefetch.js.map

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

@@ -1,5 +1,5 @@
 import { Enums } from '@cornerstonejs/core';
-export declare const requestType = Enums.RequestType.Prefetch;
+export declare const requestType = Enums.RequestType.PREFETCH;
 export declare const priority = 0;
 export declare function range(lowEnd: any, highEnd: any): any[];
 export declare function nearestIndex(arr: any, x: any): {

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

@@ -1,6 +1,6 @@
 import { getEnabledElement, StackViewport, Enums } from '@cornerstonejs/core';
 import { getToolState } from './state';
-export const requestType = Enums.RequestType.Prefetch;
+export const requestType = Enums.RequestType.PREFETCH;
 export const priority = 0;
 export function range(lowEnd, highEnd) {
     lowEnd = Math.round(lowEnd) || 0;
@@ -35,7 +35,7 @@ export function getStackData(element) {
     }
     const { viewport } = enabledElement;
     if (!(viewport instanceof StackViewport)) {
-        throw new Error('stackPrefetch: element must be a StackViewport, VolumeViewport stackPrefetch not yet implemented');
+        return null;
     }
     return {
         currentImageIdIndex: viewport.getCurrentImageIdIndex(),
@@ -62,8 +62,8 @@ export function getPromiseRemovedHandler(element) {
         }
         const stackPrefetchData = getToolState(element);
         if (!stackPrefetchData ||
-            !stackPrefetchData.data ||
-            !stackPrefetchData.data.length) {
+            !stackPrefetchData.indicesToRequest ||
+            !stackPrefetchData.indicesToRequest.length) {
             return;
         }
         stackPrefetchData.indicesToRequest.push(imageIdIndex);
@@ -74,4 +74,3 @@ export const clearFromImageIds = (stack) => {
     return (requestDetails) => requestDetails.type !== requestType ||
         !imageIdSet.has(requestDetails.additionalDetails.imageId);
 };
-//# sourceMappingURL=stackPrefetchUtils.js.map

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

@@ -1,3 +1,22 @@
+export interface StackPrefetchData {
+    indicesToRequest: number[];
+    currentImageIdIndex: number;
+    stackCount: number;
+    enabled: boolean;
+    direction: number;
+    cacheFill?: boolean;
+    stats: {
+        start: number;
+        imageIds: Map<string, number>;
+        decodeTimeInMS: number;
+        loadTimeInMS: number;
+        totalBytes: number;
+        initialTime?: number;
+        initialSize?: number;
+        fillTime?: number;
+        fillSize?: number;
+    };
+}
 declare function addToolState(element: HTMLDivElement, data: any): void;
-declare function getToolState(element: HTMLDivElement): any;
+declare function getToolState(element: HTMLDivElement): StackPrefetchData;
 export { addToolState, getToolState };

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

@@ -11,4 +11,3 @@ function getToolState(element) {
     return state[viewportId];
 }
 export { addToolState, getToolState };
-//# sourceMappingURL=state.js.map

package/dist/esm/utilities/throttle.js

@@ -17,4 +17,3 @@ function throttle(func, wait, options) {
     });
 }
 export default throttle;
-//# sourceMappingURL=throttle.js.map

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

@@ -1,4 +1,4 @@
-import { IDistance, IPoints, ITouchPoints } from '../../types';
+import type { IDistance, IPoints, ITouchPoints } from '../../types';
 declare function getDeltaPoints(currentPoints: IPoints[], lastPoints: IPoints[]): IPoints;
 declare function getDeltaDistance(currentPoints: IPoints[], lastPoints: IPoints[]): IDistance;
 declare function getDeltaRotation(currentPoints: ITouchPoints[], lastPoints: ITouchPoints[]): void;

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

@@ -150,4 +150,3 @@ function _getDistance3D(point0, point1) {
         Math.pow(point0[2] - point1[2], 2));
 }
 export { getMeanPoints, getMeanTouchPoints, copyPoints, copyPointsList, getDeltaDistanceBetweenIPoints, getDeltaPoints, getDeltaDistance, getDeltaRotation, };
-//# sourceMappingURL=index.js.map

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

@@ -1,22 +1,2 @@
-declare class AnnotationRenderingEngine {
-    hasBeenDestroyed: boolean;
-    private _needsRender;
-    private _animationFrameSet;
-    private _animationFrameHandle;
-    private _viewportElements;
-    constructor();
-    addViewportElement(viewportId: string, element: HTMLDivElement): void;
-    removeViewportElement(viewportId: string, element: HTMLDivElement): void;
-    renderViewport(element: HTMLDivElement): void;
-    private _throwIfDestroyed;
-    private _renderFlaggedViewports;
-    private _setAllViewportsToBeRenderedNextFrame;
-    private _setViewportsToBeRenderedNextFrame;
-    private _render;
-    _triggerRender(element: any): void;
-    private _reset;
-}
-declare const annotationRenderingEngine: AnnotationRenderingEngine;
 declare function triggerAnnotationRender(element: HTMLDivElement): void;
-export { annotationRenderingEngine, triggerAnnotationRender };
 export default triggerAnnotationRender;

package/dist/esm/utilities/triggerAnnotationRender.js

@@ -1,117 +1,5 @@
-import { getEnabledElement, triggerEvent, getRenderingEngine, } from '@cornerstonejs/core';
-import { Events, ToolModes } from '../enums';
-import { draw as drawSvg } from '../drawingSvg';
-import getToolsWithModesForElement from './getToolsWithModesForElement';
-const { Active, Passive, Enabled } = ToolModes;
-class AnnotationRenderingEngine {
-    constructor() {
-        this._needsRender = new Set();
-        this._animationFrameSet = false;
-        this._animationFrameHandle = null;
-        this._renderFlaggedViewports = () => {
-            this._throwIfDestroyed();
-            const elements = Array.from(this._viewportElements.values());
-            for (let i = 0; i < elements.length; i++) {
-                const element = elements[i];
-                if (this._needsRender.has(element)) {
-                    this._triggerRender(element);
-                    this._needsRender.delete(element);
-                    if (this._needsRender.size === 0) {
-                        this._animationFrameSet = false;
-                        this._animationFrameHandle = null;
-                        return;
-                    }
-                }
-            }
-        };
-        this._viewportElements = new Map();
-    }
-    addViewportElement(viewportId, element) {
-        this._viewportElements.set(viewportId, element);
-    }
-    removeViewportElement(viewportId, element) {
-        this._viewportElements.delete(viewportId);
-        this._needsRender.delete(element);
-        this._reset();
-    }
-    renderViewport(element) {
-        this._setViewportsToBeRenderedNextFrame([element]);
-    }
-    _throwIfDestroyed() {
-        if (this.hasBeenDestroyed) {
-            throw new Error('this.destroy() has been manually called to free up memory, can not longer use this instance. Instead make a new one.');
-        }
-    }
-    _setAllViewportsToBeRenderedNextFrame() {
-        const elements = [...this._viewportElements.values()];
-        elements.forEach((element) => {
-            this._needsRender.add(element);
-        });
-        this._renderFlaggedViewports();
-    }
-    _setViewportsToBeRenderedNextFrame(elements) {
-        const elementsEnabled = [...this._viewportElements.values()];
-        elements.forEach((element) => {
-            if (elementsEnabled.indexOf(element) !== -1) {
-                this._needsRender.add(element);
-            }
-        });
-        this._render();
-    }
-    _render() {
-        if (this._needsRender.size > 0 && this._animationFrameSet === false) {
-            this._animationFrameHandle = window.requestAnimationFrame(this._renderFlaggedViewports);
-            this._animationFrameSet = true;
-        }
-    }
-    _triggerRender(element) {
-        const enabledElement = getEnabledElement(element);
-        if (!enabledElement) {
-            console.warn('Element has been disabled');
-            return;
-        }
-        const renderingEngine = getRenderingEngine(enabledElement.renderingEngineId);
-        if (!renderingEngine) {
-            console.warn('rendering Engine has been destroyed');
-            return;
-        }
-        const enabledTools = getToolsWithModesForElement(element, [
-            Active,
-            Passive,
-            Enabled,
-        ]);
-        const { renderingEngineId, viewportId } = enabledElement;
-        const eventDetail = {
-            element,
-            renderingEngineId,
-            viewportId,
-        };
-        drawSvg(element, (svgDrawingHelper) => {
-            let anyRendered = false;
-            const handleDrawSvg = (tool) => {
-                if (tool.renderAnnotation) {
-                    const rendered = tool.renderAnnotation(enabledElement, svgDrawingHelper);
-                    anyRendered = anyRendered || rendered;
-                }
-            };
-            enabledTools.forEach(handleDrawSvg);
-            if (anyRendered) {
-                triggerEvent(element, Events.ANNOTATION_RENDERED, { ...eventDetail });
-            }
-        });
-    }
-    _reset() {
-        window.cancelAnimationFrame(this._animationFrameHandle);
-        this._needsRender.clear();
-        this._animationFrameSet = false;
-        this._animationFrameHandle = null;
-        this._setAllViewportsToBeRenderedNextFrame();
-    }
-}
-const annotationRenderingEngine = new AnnotationRenderingEngine();
+import { annotationRenderingEngine } from '../stateManagement/annotation/AnnotationRenderingEngine';
 function triggerAnnotationRender(element) {
     annotationRenderingEngine.renderViewport(element);
 }
-export { annotationRenderingEngine, triggerAnnotationRender };
 export default triggerAnnotationRender;
-//# sourceMappingURL=triggerAnnotationRender.js.map

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

@@ -0,0 +1,2 @@
+export declare function triggerAnnotationRenderForToolGroupIds(toolGroupIds: string[]): void;
+export default triggerAnnotationRenderForToolGroupIds;

package/dist/esm/utilities/triggerAnnotationRenderForToolGroupIds.js

@@ -0,0 +1,24 @@
+import { getRenderingEngine } from '@cornerstonejs/core';
+import triggerAnnotationRender from './triggerAnnotationRender';
+import { getToolGroup } from '../store/ToolGroupManager';
+export function triggerAnnotationRenderForToolGroupIds(toolGroupIds) {
+    toolGroupIds.forEach((toolGroupId) => {
+        const toolGroup = getToolGroup(toolGroupId);
+        if (!toolGroup) {
+            console.warn(`ToolGroup not available for ${toolGroupId}`);
+            return;
+        }
+        const viewportsInfo = toolGroup.getViewportsInfo();
+        viewportsInfo.forEach((viewportInfo) => {
+            const { renderingEngineId, viewportId } = viewportInfo;
+            const renderingEngine = getRenderingEngine(renderingEngineId);
+            if (!renderingEngine) {
+                console.warn(`RenderingEngine not available for ${renderingEngineId}`);
+                return;
+            }
+            const viewport = renderingEngine.getViewport(viewportId);
+            triggerAnnotationRender(viewport.element);
+        });
+    });
+}
+export default triggerAnnotationRenderForToolGroupIds;

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

@@ -1,3 +1,2 @@
-import type { Types } from '@cornerstonejs/core';
-export declare function triggerAnnotationRenderForViewportIds(renderingEngine: Types.IRenderingEngine, viewportIdsToRender: string[]): void;
+export declare function triggerAnnotationRenderForViewportIds(viewportIdsToRender: string[]): void;
 export default triggerAnnotationRenderForViewportIds;

package/dist/esm/utilities/triggerAnnotationRenderForViewportIds.js

@@ -1,12 +1,22 @@
+import { getEnabledElementByViewportId } from '@cornerstonejs/core';
 import triggerAnnotationRender from './triggerAnnotationRender';
-export function triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender) {
+export function triggerAnnotationRenderForViewportIds(viewportIdsToRender) {
     if (!viewportIdsToRender.length) {
         return;
     }
     viewportIdsToRender.forEach((viewportId) => {
-        const { element } = renderingEngine.getViewport(viewportId);
+        const enabledElement = getEnabledElementByViewportId(viewportId);
+        if (!enabledElement) {
+            console.warn(`Viewport not available for ${viewportId}`);
+            return;
+        }
+        const { viewport } = enabledElement;
+        if (!viewport) {
+            console.warn(`Viewport not available for ${viewportId}`);
+            return;
+        }
+        const element = viewport.element;
         triggerAnnotationRender(element);
     });
 }
 export default triggerAnnotationRenderForViewportIds;
-//# sourceMappingURL=triggerAnnotationRenderForViewportIds.js.map

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

@@ -2,4 +2,3 @@ import { isViewportPreScaled } from './isViewportPreScaled';
 import jumpToSlice from './jumpToSlice';
 import jumpToWorld from './jumpToWorld';
 export { isViewportPreScaled, jumpToSlice, jumpToWorld };
-//# sourceMappingURL=index.js.map

package/dist/esm/utilities/viewport/isViewportPreScaled.d.ts

@@ -1,3 +1,3 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 declare function isViewportPreScaled(viewport: Types.IStackViewport | Types.IVolumeViewport, targetId: string): boolean;
 export { isViewportPreScaled };

package/dist/esm/utilities/viewport/isViewportPreScaled.js

@@ -1,7 +1,7 @@
-import { cache, StackViewport, BaseVolumeViewport, } from '@cornerstonejs/core';
+import { cache, StackViewport, BaseVolumeViewport, utilities, } from '@cornerstonejs/core';
 function isViewportPreScaled(viewport, targetId) {
     if (viewport instanceof BaseVolumeViewport) {
-        const volumeId = targetId.split('volumeId:')[1];
+        const volumeId = utilities.getVolumeId(targetId);
         const volume = cache.getVolume(volumeId);
         return !!volume?.scaling && Object.keys(volume.scaling).length > 0;
     }
@@ -10,8 +10,7 @@ function isViewportPreScaled(viewport, targetId) {
         return !!preScale?.scaled;
     }
     else {
-        throw new Error('Viewport is not a valid type');
+        return false;
     }
 }
 export { isViewportPreScaled };
-//# sourceMappingURL=isViewportPreScaled.js.map

package/dist/esm/utilities/viewport/jumpToSlice.d.ts

@@ -1,3 +1,3 @@
-import JumpToSliceOptions from '../../types/JumpToSliceOptions';
+import type JumpToSliceOptions from '../../types/JumpToSliceOptions';
 declare function jumpToSlice(element: HTMLDivElement, options?: JumpToSliceOptions): Promise<void>;
 export default jumpToSlice;

package/dist/esm/utilities/viewport/jumpToSlice.js

@@ -22,16 +22,13 @@ function _getImageSliceData(viewport, debounceLoading) {
                 : viewport.getCurrentImageIdIndex(),
         };
     }
-    else if (viewport instanceof VolumeViewport) {
-        return csUtils.getImageSliceDataForVolumeViewport(viewport);
-    }
-    else {
-        throw new Error('Unsupported viewport type');
-    }
+    return {
+        numberOfSlices: viewport.getNumberOfSlices(),
+        imageIndex: viewport.getSliceIndex(),
+    };
 }
 function _getImageIndexToJump(numberOfSlices, imageIndex) {
     const lastSliceIndex = numberOfSlices - 1;
     return clip(imageIndex, 0, lastSliceIndex);
 }
 export default jumpToSlice;
-//# sourceMappingURL=jumpToSlice.js.map

package/dist/esm/utilities/viewport/jumpToWorld.js

@@ -30,4 +30,3 @@ function _applyShift(viewport, delta) {
         viewport.render();
     }
 }
-//# sourceMappingURL=jumpToWorld.js.map

package/dist/esm/utilities/viewportFilters/filterViewportsWithFrameOfReferenceUID.d.ts

@@ -1,2 +1,2 @@
 import type { Types } from '@cornerstonejs/core';
-export default function filterViewportsWithFrameOfReferenceUID(viewports: Array<Types.IStackViewport | Types.IVolumeViewport>, FrameOfReferenceUID: string): Array<Types.IStackViewport | Types.IVolumeViewport>;
+export default function filterViewportsWithFrameOfReferenceUID(viewports: Array<Types.IViewport>, FrameOfReferenceUID: string): Array<Types.IStackViewport | Types.IVolumeViewport>;

package/dist/esm/utilities/viewportFilters/filterViewportsWithFrameOfReferenceUID.js

@@ -9,4 +9,3 @@ export default function filterViewportsWithFrameOfReferenceUID(viewports, FrameO
     }
     return viewportsWithFrameOfReferenceUID;
 }
-//# sourceMappingURL=filterViewportsWithFrameOfReferenceUID.js.map

package/dist/esm/utilities/viewportFilters/filterViewportsWithParallelNormals.js

@@ -8,4 +8,3 @@ export function filterViewportsWithParallelNormals(viewports, camera, EPS = 0.99
     });
 }
 export default filterViewportsWithParallelNormals;
-//# sourceMappingURL=filterViewportsWithParallelNormals.js.map