@cornerstonejs/tools 2.0.0-beta.20 → 2.0.0-beta.22

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

@@ -1,6 +1,6 @@
-import { Types } from '@cornerstonejs/core';
-import { BoundsIJK } from '../../types';
-import { ThresholdInformation } from './utilities';
+import type { Types } from '@cornerstonejs/core';
+import type { BoundsIJK } from '../../types';
+import type { ThresholdInformation } from './utilities';
 export type ThresholdRangeOptions = {
     overwrite: boolean;
     boundsIJK: BoundsIJK;

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

@@ -1,14 +1,14 @@
-import { pointInShapeCallback } from '../../utilities';
 import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
-import { getVoxelOverlap, processVolumes, } from './utilities';
+import { getVoxelOverlap, processVolumes } from './utilities';
 function thresholdVolumeByRange(segmentationVolume, thresholdVolumeInformation, options) {
     const { imageData: segmentationImageData } = segmentationVolume;
-    const scalarData = segmentationVolume.getScalarData();
     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 < scalarData.length; i++) {
-            scalarData[i] = 0;
+        for (let i = 0; i < scalarDataLength; i++) {
+            segVoxelManager.setAtIndex(i, 0);
         }
     }
     const { baseVolumeIdx, volumeInfoList } = processVolumes(segmentationVolume, thresholdVolumeInformation);
@@ -26,7 +26,11 @@ function thresholdVolumeByRange(segmentationVolume, thresholdVolumeInformation,
         overlaps = 0;
         range = { lower, upper };
         let overlapTest = false;
-        pointInShapeCallback(imageData, () => true, callbackOverlap, overlapBounds);
+        const { voxelManager } = imageData.get('voxelManager');
+        voxelManager.forEach(callbackOverlap, {
+            imageData,
+            boundsIJK: overlapBounds,
+        });
         if (overlapType === 0) {
             overlapTest = overlaps > 0;
         }
@@ -36,9 +40,10 @@ function thresholdVolumeByRange(segmentationVolume, thresholdVolumeInformation,
         return overlapTest;
     };
     const testRange = (volumeInfo, pointIJK) => {
-        const { imageData, referenceValues, lower, upper } = volumeInfo;
-        const offset = imageData.computeOffsetIndex(pointIJK);
-        const value = referenceValues[offset];
+        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;
         }
@@ -49,7 +54,7 @@ function thresholdVolumeByRange(segmentationVolume, thresholdVolumeInformation,
     const callback = ({ index, pointIJK, pointLPS }) => {
         let insert = volumeInfoList.length > 0;
         for (let i = 0; i < volumeInfoList.length; i++) {
-            if (volumeInfoList[i].volumeSize === scalarData.length) {
+            if (volumeInfoList[i].volumeSize === scalarDataLength) {
                 insert = testRange(volumeInfoList[i], pointIJK);
             }
             else {
@@ -60,10 +65,14 @@ function thresholdVolumeByRange(segmentationVolume, thresholdVolumeInformation,
             }
         }
         if (insert) {
-            scalarData[index] = options.segmentIndex || 1;
+            segVoxelManager.setAtIndex(index, options.segmentIndex || 1);
         }
     };
-    pointInShapeCallback(segmentationImageData, () => true, callback, boundsIJK);
+    const voxelManager = segmentationVolume.voxelManager;
+    voxelManager.forEach(callback, {
+        imageData: segmentationImageData,
+        boundsIJK,
+    });
     triggerSegmentationDataModified(segmentationVolume.volumeId);
     return segmentationVolume;
 }

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

@@ -1,12 +1,25 @@
-import { Types } from '@cornerstonejs/core';
+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 declare function getBrushToolInstances(toolGroupId: string, toolName?: string): any[];
+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: any[];
+    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

@@ -1,22 +1,5 @@
 import { utilities as csUtils } from '@cornerstonejs/core';
-import { getToolGroup } from '../../store/ToolGroupManager';
-import BrushTool from '../../tools/segmentation/BrushTool';
 import { getBoundingBoxAroundShapeIJK } from '../boundingBox/getBoundingBoxAroundShape';
-export 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;
-}
 const equalsCheck = (a, b) => {
     return JSON.stringify(a) === JSON.stringify(b);
 };
@@ -39,27 +22,26 @@ export function getVoxelOverlap(imageData, dimensions, voxelSpacing, voxelCenter
 }
 export function processVolumes(segmentationVolume, thresholdVolumeInformation) {
     const { spacing: segmentationSpacing } = segmentationVolume;
-    const scalarData = segmentationVolume.getScalarData();
+    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,3 +49,26 @@ export function processVolumes(segmentationVolume, thresholdVolumeInformation) {
         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/stackPrefetch/stackContextPrefetch.js

@@ -1,4 +1,4 @@
-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';
 let configuration = {
@@ -12,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;
     }
@@ -26,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;
@@ -34,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;
     }
@@ -99,15 +106,9 @@ function prefetch(element) {
     const requestFn = (imageId, options) => imageLoader
         .loadAndCacheImage(imageId, options)
         .then(() => doneCallback(imageId));
-    const { useNorm16Texture, preferSizeOverAccuracy } = getCoreConfiguration().rendering;
-    const useNativeDataType = useNorm16Texture || preferSizeOverAccuracy;
     stackPrefetch.indicesToRequest.forEach((imageIdIndex) => {
         const imageId = stack.imageIds[imageIdIndex];
         const options = {
-            targetBuffer: {
-                type: useNativeDataType ? undefined : 'Float32Array',
-            },
-            useNativeDataType,
             requestType,
         };
         imageLoadPoolManager.addRequest(requestFn.bind(null, imageId, options), requestType, {
@@ -131,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;

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,14 +87,8 @@ function prefetch(element) {
         }
     }
     const requestFn = (imageId, options) => imageLoader.loadAndCacheImage(imageId, options);
-    const { useNorm16Texture, preferSizeOverAccuracy } = getCoreConfiguration().rendering;
-    const useNativeDataType = useNorm16Texture || preferSizeOverAccuracy;
     imageIdsToPrefetch.forEach((imageId) => {
         const options = {
-            targetBuffer: {
-                type: useNativeDataType ? undefined : 'Float32Array',
-            },
-            useNativeDataType,
             requestType,
         };
         imageLoadPoolManager.addRequest(requestFn.bind(null, imageId, options), requestType, {

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

@@ -35,7 +35,6 @@ export function getStackData(element) {
     }
     const { viewport } = enabledElement;
     if (!(viewport instanceof StackViewport)) {
-        console.warn('stackPrefetch: element must be a StackViewport, VolumeViewport stackPrefetch not yet implemented');
         return null;
     }
     return {
@@ -63,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);

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/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/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,116 +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) {
-                        break;
-                    }
-                }
-            }
-            this._animationFrameSet = false;
-            this._animationFrameHandle = null;
-            this._render();
-        };
-        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) {
-            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;

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,10 +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 targetIdTokens = targetId.split('volumeId:');
-        const volumeId = targetIdTokens.length > 1
-            ? targetIdTokens[1].split('?')[0]
-            : targetIdTokens[0];
+        const volumeId = utilities.getVolumeId(targetId);
         const volume = cache.getVolume(volumeId);
         return !!volume?.scaling && Object.keys(volume.scaling).length > 0;
     }

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,12 +22,10 @@ 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;

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

@@ -1,12 +1,12 @@
-import { ToolGroupManager } from '../../store';
 import { ToolModes } from '../../enums';
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
 const { Active, Passive, Enabled } = ToolModes;
 export default function filterViewportsWithToolEnabled(viewports, toolName) {
     const numViewports = viewports.length;
     const viewportsWithToolEnabled = [];
     for (let vp = 0; vp < numViewports; vp++) {
         const viewport = viewports[vp];
-        const toolGroup = ToolGroupManager.getToolGroupForViewport(viewport.id, viewport.renderingEngineId);
+        const toolGroup = getToolGroupForViewport(viewport.id, viewport.renderingEngineId);
         if (!toolGroup) {
             continue;
         }

package/dist/esm/utilities/voi/colorbar/ColorbarCanvas.d.ts

@@ -1,5 +1,5 @@
-import { IColorMapPreset } from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps';
-import { ColorbarCanvasProps } from './types/ColorbarCanvasProps';
+import type { IColorMapPreset } from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps';
+import type { ColorbarCanvasProps } from './types/ColorbarCanvasProps';
 import type { ColorbarImageRange, ColorbarVOIRange } from './types';
 import type { ColorbarSize } from './types/ColorbarSize';
 declare class ColorbarCanvas {

package/dist/esm/utilities/voi/colorbar/ViewportColorbar.d.ts

@@ -1,4 +1,4 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 import { Colorbar } from './Colorbar';
 import type { ViewportColorbarProps, ColorbarVOIRange } from './types';
 declare class ViewportColorbar extends Colorbar {

package/dist/esm/utilities/voi/colorbar/ViewportColorbar.js

@@ -28,7 +28,7 @@ class ViewportColorbar extends Colorbar {
             this.imageRange = ViewportColorbar._getImageRange(this._element);
         };
         this._imageVolumeModifiedCallback = (evt) => {
-            const { volumeId } = evt.detail.imageVolume;
+            const { volumeId } = evt.detail;
             if (volumeId !== this._volumeId) {
                 return;
             }

package/dist/esm/utilities/voi/colorbar/types/ColorbarCanvasProps.d.ts

@@ -1,4 +1,4 @@
-import { IColorMapPreset } from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps';
+import type { IColorMapPreset } from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps';
 import type { ColorbarImageRange } from './ColorbarImageRange';
 import type { ColorbarSize } from './ColorbarSize';
 import type { ColorbarVOIRange } from './ColorbarVOIRange';

package/dist/esm/utilities/voi/colorbar/types/ColorbarCommonProps.d.ts

@@ -1,4 +1,4 @@
-import { ColorbarRangeTextPosition } from '../enums/ColorbarRangeTextPosition';
+import type { ColorbarRangeTextPosition } from '../enums/ColorbarRangeTextPosition';
 import type { ColorbarImageRange, ColorbarTicksStyle, ColorbarVOIRange } from '.';
 export type ColorbarCommonProps = {
     imageRange?: ColorbarImageRange;

package/dist/esm/utilities/voi/colorbar/types/ColorbarProps.d.ts

@@ -1,6 +1,6 @@
-import { IColorMapPreset } from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps';
-import { WidgetProps } from '../../../../widgets/types';
-import { ColorbarCommonProps } from '.';
+import type { IColorMapPreset } from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps';
+import type { WidgetProps } from '../../../../widgets/types';
+import type { ColorbarCommonProps } from '.';
 export type ColorbarProps = (WidgetProps & ColorbarCommonProps) & {
     colormaps: IColorMapPreset[];
     activeColormapName?: string;

package/dist/esm/utilities/voi/windowlevel/extractWindowLevelRegionToolData.d.ts

@@ -1,4 +1,12 @@
 declare function extractWindowLevelRegionToolData(viewport: any): {
+    scalarData: import("packages/core/dist/esm/types").PixelDataTypedArray;
+    minPixelValue: number;
+    maxPixelValue: number;
+    width: number;
+    height: number;
+    rows: number;
+    columns: number;
+} | {
     scalarData: any;
     width: any;
     height: any;