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

package/dist/esm/store/ToolGroupManager/ToolGroup.js

@@ -381,6 +381,16 @@ export default class ToolGroup {
     getPrevActivePrimaryToolName() {
         return this.prevActivePrimaryToolName;
     }
+    setActivePrimaryTool(toolName) {
+        const activeToolName = this.getCurrentActivePrimaryToolName();
+        this.setToolDisabled(activeToolName);
+        this.setToolActive(toolName, {
+            bindings: [{ mouseButton: MouseBindings.Primary }],
+        });
+    }
+    getCurrentActivePrimaryToolName() {
+        return this.currentActivePrimaryToolName;
+    }
     clone(newToolGroupId, fnToolFilter = null) {
         let toolGroup = ToolGroupManager.getToolGroup(newToolGroupId);
         if (toolGroup) {

package/dist/esm/tools/base/BaseTool.js

@@ -82,7 +82,7 @@ class BaseTool {
         }
     }
     getTargetId(viewport) {
-        const targetId = viewport.getReferenceId?.();
+        const targetId = viewport.getViewReferenceId?.();
         if (targetId) {
             return targetId;
         }

package/dist/esm/tools/displayTools/Labelmap/addLabelmapToElement.js

@@ -1,5 +1,6 @@
 import { getEnabledElement, addVolumesToViewports, addImageSlicesToViewports, Enums, } from '@cornerstonejs/core';
 import { isVolumeSegmentation } from '../../segmentation/strategies/utils/stackVolumeCheck';
+import { getLabelmapImageIdsForViewport, getRepresentation, } from '../../../stateManagement/segmentation/segmentationState';
 async function addLabelmapToElement(element, labelMapData, segmentationRepresentationUID) {
     const enabledElement = getEnabledElement(element);
     const { renderingEngine, viewport } = enabledElement;
@@ -19,7 +20,8 @@ async function addLabelmapToElement(element, labelMapData, segmentationRepresent
         await addVolumesToViewports(renderingEngine, volumeInputs, [viewportId], immediateRender, suppressEvents);
     }
     else {
-        const segmentationImageId = labelMapData.imageIdReferenceMap.get(viewport.getCurrentImageId());
+        const representation = getRepresentation(segmentationRepresentationUID);
+        const segmentationImageId = getLabelmapImageIdsForViewport(viewport.id, representation.segmentationId);
         const stackInputs = [
             {
                 imageId: segmentationImageId,

package/dist/esm/tools/displayTools/Labelmap/labelmapDisplay.js

@@ -99,9 +99,8 @@ async function render(viewport, representation) {
         if (viewport instanceof VolumeViewport) {
             return;
         }
-        const imageId = viewport.getCurrentImageId();
-        const { imageIdReferenceMap } = labelmapData;
-        if (!imageIdReferenceMap.has(imageId)) {
+        const labelmapImageId = SegmentationState.getLabelmapImageIdsForViewport(viewport.id, segmentationId);
+        if (!labelmapImageId) {
             return;
         }
         if (!actorEntry) {

package/dist/esm/tools/displayTools/Labelmap/validateLabelmap.js

@@ -8,11 +8,11 @@ function validateRepresentationData(segmentationRepresentationData) {
             throw new Error(`volumeId of ${segmentationRepresentationData.volumeId} not found in cache, you should load and cache volume before adding segmentation`);
         }
     }
-    else if ('imageIdReferenceMap' in segmentationRepresentationData) {
+    else if ('imageIds' in segmentationRepresentationData) {
         segmentationRepresentationData =
             segmentationRepresentationData;
-        if (!segmentationRepresentationData.imageIdReferenceMap) {
-            throw new Error('The segmentationInput.representationData.imageIdReferenceMap is undefined, please provide a valid representationData.imageIdReferenceMap');
+        if (!segmentationRepresentationData.imageIds) {
+            throw new Error('The segmentationInput.representationData.imageIds is undefined, please provide a valid representationData.imageIds for stack data');
         }
     }
     else {

package/dist/esm/tools/segmentation/BrushTool.d.ts

@@ -23,9 +23,9 @@ declare class BrushTool extends BaseTool {
         volumeId: string;
         referencedVolumeId: any;
         segmentsLocked: number[] | [];
-        imageIdReferenceMap?: undefined;
+        imageId?: undefined;
     } | {
-        imageIdReferenceMap: Map<string, string>;
+        imageId: string;
         segmentsLocked: number[] | [];
         volumeId?: undefined;
         referencedVolumeId?: undefined;
@@ -49,7 +49,7 @@ declare class BrushTool extends BaseTool {
         strategySpecificConfiguration: any;
         preview: unknown;
         segmentsLocked: number[];
-        imageIdReferenceMap?: Map<string, string>;
+        imageId?: string;
         volumeId?: string;
         referencedVolumeId?: string;
     } | {
@@ -66,7 +66,7 @@ declare class BrushTool extends BaseTool {
         volumeId: string;
         referencedVolumeId: any;
         segmentsLocked: number[] | [];
-        imageIdReferenceMap?: undefined;
+        imageId?: undefined;
     } | {
         points: any;
         segmentIndex: number;
@@ -78,7 +78,7 @@ declare class BrushTool extends BaseTool {
         viewUp: any;
         strategySpecificConfiguration: any;
         preview: unknown;
-        imageIdReferenceMap: Map<string, string>;
+        imageId: string;
         segmentsLocked: number[] | [];
         volumeId?: undefined;
         referencedVolumeId?: undefined;

package/dist/esm/tools/segmentation/BrushTool.js

@@ -11,6 +11,7 @@ import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCur
 import triggerAnnotationRenderForViewportUIDs from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { config as segmentationConfig, segmentLocking, segmentIndex as segmentIndexController, state as segmentationState, activeSegmentation, } from '../../stateManagement/segmentation';
 import { isVolumeSegmentation } from './strategies/utils/stackVolumeCheck';
+import { getLabelmapImageIdsForViewport } from '../../stateManagement/segmentation/segmentationState';
 class BrushTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -90,7 +91,8 @@ class BrushTool extends BaseTool {
             this._previewData.timerStart = Date.now();
             const hoverData = this._hoverData || this.createHoverData(element);
             triggerAnnotationRenderForViewportUIDs(hoverData.viewportIdsToRender);
-            this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.OnInteractionStart);
+            const operationData = this.getOperationData(element);
+            this.applyActiveStrategyCallback(enabledElement, operationData, StrategyCallbacks.OnInteractionStart);
             return true;
         };
         this.mouseMoveCallback = (evt) => {
@@ -226,16 +228,15 @@ class BrushTool extends BaseTool {
             };
         }
         else {
-            const { imageIdReferenceMap } = labelmapData;
-            const currentImageId = viewport.getCurrentImageId();
-            if (!imageIdReferenceMap.get(currentImageId)) {
+            const segmentationImageId = getLabelmapImageIdsForViewport(viewport.id, segmentationId);
+            if (!segmentationImageId) {
                 return;
             }
             if (this.configuration.activeStrategy.includes('SPHERE')) {
                 throw new Error('Sphere manipulation is not supported for stacks of image segmentations yet');
             }
             return {
-                imageIdReferenceMap,
+                imageId: segmentationImageId,
                 segmentsLocked,
             };
         }

package/dist/esm/tools/segmentation/CircleScissorsTool.d.ts

@@ -8,7 +8,7 @@ declare class CircleScissorsTool extends BaseTool {
         segmentIndex: number;
         volumeId: string;
         referencedVolumeId: string;
-        imageIdReferenceMap: Map<string, string>;
+        imageId: string;
         segmentsLocked: number[];
         segmentColor: [number, number, number, number];
         viewportIdsToRender: string[];

package/dist/esm/tools/segmentation/CircleScissorsTool.js

@@ -93,10 +93,8 @@ class CircleScissorsTool extends BaseTool {
                 };
             }
             else {
-                const { imageIdReferenceMap } = labelmapData;
                 this.editData = {
                     ...this.editData,
-                    imageIdReferenceMap,
                 };
             }
             this._activateDraw(element);

package/dist/esm/tools/segmentation/PaintFillTool.js

@@ -4,7 +4,7 @@ import { SegmentationRepresentations } from '../../enums';
 import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
 import { segmentLocking, activeSegmentation, segmentIndex as segmentIndexController, } from '../../stateManagement/segmentation';
 import floodFill from '../../utilities/segmentation/floodFill';
-import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
+import { getLabelmapImageIdsForViewport, getSegmentation, } from '../../stateManagement/segmentation/segmentationState';
 import { isVolumeSegmentation } from './strategies/utils/stackVolumeCheck';
 const { transformWorldToIndex, isEqual } = csUtils;
 class PaintFillTool extends BaseTool {
@@ -24,7 +24,7 @@ class PaintFillTool extends BaseTool {
             if (!activeSegmentationRepresentation) {
                 throw new Error('No active segmentation detected, create one before using scissors tool');
             }
-            const { segmentationId, type } = activeSegmentationRepresentation;
+            const { segmentationId, type, segmentationRepresentationUID } = activeSegmentationRepresentation;
             const segmentIndex = segmentIndexController.getActiveSegmentIndex(segmentationId);
             const segmentsLocked = segmentLocking.getLockedSegments(segmentationId);
             const { representationData } = getSegmentation(segmentationId);
@@ -41,9 +41,7 @@ class PaintFillTool extends BaseTool {
                 index = transformWorldToIndex(segmentation.imageData, worldPos);
             }
             else {
-                const { imageIdReferenceMap } = labelmapData;
-                const currentImageId = enabledElement.viewport.getCurrentImageId();
-                const currentSegmentationImageId = imageIdReferenceMap.get(currentImageId);
+                const currentSegmentationImageId = getLabelmapImageIdsForViewport(viewport.id, segmentationId);
                 if (!currentSegmentationImageId) {
                     throw new Error('No active segmentation imageId detected, create one before using scissors tool');
                 }

package/dist/esm/tools/segmentation/RectangleScissorsTool.d.ts

@@ -5,9 +5,9 @@ declare class RectangleScissorsTool extends BaseTool {
     static toolName: any;
     _throttledCalculateCachedStats: any;
     editData: {
-        imageIdReferenceMap: Map<string, string>;
         volumeId: string;
         referencedVolumeId: string;
+        imageId: string;
         annotation: any;
         segmentationId: string;
         segmentIndex: number;

package/dist/esm/tools/segmentation/RectangleScissorsTool.js

@@ -8,7 +8,7 @@ import { drawRect as drawRectSvg } from '../../drawingSvg';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { config as segmentationConfig, segmentLocking, segmentIndex as segmentIndexController, activeSegmentation, } from '../../stateManagement/segmentation';
-import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
+import { getSegmentation, } from '../../stateManagement/segmentation/segmentationState';
 import { isVolumeSegmentation } from './strategies/utils/stackVolumeCheck';
 class RectangleScissorsTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
@@ -92,10 +92,8 @@ class RectangleScissorsTool extends BaseTool {
                 };
             }
             else {
-                const { imageIdReferenceMap } = labelmapData;
                 this.editData = {
                     ...this.editData,
-                    imageIdReferenceMap,
                 };
             }
             this._activateDraw(element);

package/dist/esm/tools/segmentation/SphereScissorsTool.d.ts

@@ -10,7 +10,7 @@ declare class SphereScissorsTool extends BaseTool {
         segmentationRepresentationUID: string;
         volumeId: string;
         referencedVolumeId: string;
-        imageIdReferenceMap: Map<string, string>;
+        imageId: string;
         toolGroupId: string;
         segmentColor: [number, number, number, number];
         viewportIdsToRender: string[];

package/dist/esm/tools/segmentation/SphereScissorsTool.js

@@ -7,7 +7,7 @@ import { drawCircle as drawCircleSvg } from '../../drawingSvg';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { config as segmentationConfig, segmentLocking, segmentIndex as segmentIndexController, activeSegmentation, } from '../../stateManagement/segmentation';
-import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
+import { getSegmentation, } from '../../stateManagement/segmentation/segmentationState';
 import { isVolumeSegmentation } from './strategies/utils/stackVolumeCheck';
 class SphereScissorsTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
@@ -91,10 +91,8 @@ class SphereScissorsTool extends BaseTool {
                 };
             }
             else {
-                const { imageIdReferenceMap } = labelmapData;
                 this.editData = {
                     ...this.editData,
-                    imageIdReferenceMap,
                 };
             }
             this._activateDraw(element);

package/dist/esm/tools/segmentation/strategies/compositions/dynamicThreshold.js

@@ -43,7 +43,11 @@ export default {
         if (dynamicRadius === 0) {
             return;
         }
-        const { spacing } = viewport.getImageData();
+        const imageData = viewport.getImageData();
+        if (!imageData) {
+            return;
+        }
+        const { spacing } = imageData;
         const centerCanvas = [
             viewport.element.clientWidth / 2,
             viewport.element.clientHeight / 2,

package/dist/esm/tools/segmentation/strategies/utils/getStrategyData.js

@@ -1,5 +1,6 @@
 import { cache, utilities } from '@cornerstonejs/core';
 import { isVolumeSegmentation } from './stackVolumeCheck';
+import { getLabelmapImageIdsForViewport } from '../../../../stateManagement/segmentation/segmentationState';
 const { VoxelManager } = utilities;
 function getStrategyData({ operationData, viewport }) {
     let segmentationImageData, segmentationScalarData, imageScalarData;
@@ -24,8 +25,9 @@ function getStrategyData({ operationData, viewport }) {
         segmentationDimensions = segmentationVolume.dimensions;
     }
     else {
-        const { imageIdReferenceMap, segmentationRepresentationUID } = operationData;
-        if (!imageIdReferenceMap) {
+        const { segmentationRepresentationUID, segmentationId } = operationData;
+        const labelmapImageId = getLabelmapImageIdsForViewport(viewport.id, segmentationId);
+        if (!labelmapImageId) {
             return;
         }
         const currentImageId = viewport.getCurrentImageId();
@@ -38,7 +40,7 @@ function getStrategyData({ operationData, viewport }) {
         }
         segmentationImageData = actor.actor.getMapper().getInputData();
         segmentationVoxelManager = segmentationImageData.voxelManager;
-        const currentSegmentationImageId = imageIdReferenceMap.get(currentImageId);
+        const currentSegmentationImageId = operationData.imageId;
         const segmentationImage = cache.getImage(currentSegmentationImageId);
         if (!segmentationImage) {
             return;

package/dist/esm/tools/segmentation/strategies/utils/stackVolumeCheck.js

@@ -1,15 +1,15 @@
 import { VolumeViewport } from '@cornerstonejs/core';
 function isVolumeSegmentation(operationData, viewport) {
-    const { imageIdReferenceMap } = operationData;
+    const { imageIds } = operationData;
     const { volumeId } = operationData;
-    if (volumeId && !imageIdReferenceMap) {
+    if (volumeId && !imageIds) {
         return true;
     }
-    if (imageIdReferenceMap && !volumeId) {
+    if (imageIds && !volumeId) {
         return false;
     }
-    if (volumeId && imageIdReferenceMap && !viewport) {
-        throw new Error('isVolumeSegmentation: viewport is required when both volumeId and imageIdReferenceMap are provided');
+    if (volumeId && imageIds && !viewport) {
+        throw new Error('isVolumeSegmentation: viewport is required when both volumeId and imageIds are provided');
     }
     return viewport instanceof VolumeViewport;
 }

package/dist/esm/types/LabelmapTypes.d.ts

@@ -21,10 +21,10 @@ export type LabelmapSegmentationDataVolume = {
     referencedVolumeId?: string;
 };
 export type LabelmapSegmentationDataStack = {
-    imageIdReferenceMap: Map<string, string>;
+    imageIds: string[];
 };
 export type LabelmapSegmentationData = LabelmapSegmentationDataVolume | LabelmapSegmentationDataStack | {
     volumeId?: string;
     referencedVolumeId?: string;
-    imageIdReferenceMap?: Map<string, string>;
+    imageIds?: string[];
 };

package/dist/esm/utilities/annotationHydration.js

@@ -44,7 +44,7 @@ function getReferencedImageId(viewport, worldPos, viewPlaneNormal) {
     return referencedImageId;
 }
 function getTargetId(viewport) {
-    const targetId = viewport.getReferenceId?.();
+    const targetId = viewport.getViewReferenceId?.();
     if (targetId) {
         return targetId;
     }

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

@@ -1,5 +1,5 @@
 import { cache, utilities } from '@cornerstonejs/core';
-import { getSegmentation, getRepresentationsBySegmentationId, } from '../../stateManagement/segmentation/segmentationState';
+import { getSegmentation, getRepresentationsBySegmentationId, getLabelmapImageIdsForViewport, } from '../../stateManagement/segmentation/segmentationState';
 import { isVolumeSegmentation } from '../../tools/segmentation/strategies/utils/stackVolumeCheck';
 export function getSegmentIndexAtLabelmapBorder(segmentationId, worldPoint, { viewport, searchRadius }) {
     const segmentation = getSegmentation(segmentationId);
@@ -16,9 +16,8 @@ export function getSegmentIndexAtLabelmapBorder(segmentationId, worldPoint, { vi
         const onEdge = isSegmentOnEdgeCanvas(canvasPoint, segmentIndex, viewport, imageData, searchRadius);
         return onEdge ? segmentIndex : undefined;
     }
-    const { imageIdReferenceMap } = labelmapData;
+    const segmentationImageId = getLabelmapImageIdsForViewport(viewport.id, segmentationId);
     const currentImageId = viewport.getCurrentImageId();
-    const segmentationImageId = imageIdReferenceMap.get(currentImageId);
     const image = cache.getImage(segmentationImageId);
     if (!image) {
         return;

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

@@ -1,6 +1,6 @@
 import { cache, utilities } from '@cornerstonejs/core';
 import { SegmentationRepresentations } from '../../enums';
-import { getSegmentation, getRepresentationsBySegmentationId, } from '../../stateManagement/segmentation/segmentationState';
+import { getSegmentation, getRepresentationsBySegmentationId, getLabelmapImageIdsForViewport, } from '../../stateManagement/segmentation/segmentationState';
 import { isVolumeSegmentation } from '../../tools/segmentation/strategies/utils/stackVolumeCheck';
 import { getAnnotation } from '../../stateManagement';
 import { isPointInsidePolyline3D } from '../math/polyline';
@@ -31,9 +31,7 @@ export function getSegmentIndexAtWorldForLabelmap(segmentation, worldPoint, { vi
         const segmentIndex = segmentationVolume.imageData.getScalarValueFromWorld(worldPoint);
         return segmentIndex;
     }
-    const { imageIdReferenceMap } = labelmapData;
-    const currentImageId = viewport.getCurrentImageId();
-    const segmentationImageId = imageIdReferenceMap.get(currentImageId);
+    const segmentationImageId = getLabelmapImageIdsForViewport(viewport.id, segmentation.segmentationId);
     const image = cache.getImage(segmentationImageId);
     if (!image) {
         return;

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

@@ -55,7 +55,7 @@ function handleLabelmapSegmentation(segmentation, segmentationId) {
         addVolumeSegmentIndices(keySet, segmentationId);
     }
     else {
-        addImageSegmentIndices(keySet, labelmapData.imageIdReferenceMap);
+        addImageSegmentIndices(keySet, labelmapData.imageIds);
     }
     return Array.from(keySet)
         .map(Number)
@@ -70,8 +70,8 @@ function addVolumeSegmentIndices(keySet, segmentationId) {
         }
     });
 }
-function addImageSegmentIndices(keySet, imageIdReferenceMap) {
-    imageIdReferenceMap.forEach((segmentationImageId) => {
+function addImageSegmentIndices(keySet, imageIds) {
+    imageIds.forEach((segmentationImageId) => {
         const image = cache.getImage(segmentationImageId);
         const scalarData = image.getPixelData();
         scalarData.forEach((segmentIndex) => {

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

@@ -9,7 +9,6 @@ import floodFill from './floodFill';
 import { getBrushSizeForToolGroup, setBrushSizeForToolGroup } from './brushSizeForToolGroup';
 import { getBrushThresholdForToolGroup, setBrushThresholdForToolGroup } from './brushThresholdForToolGroup';
 import thresholdSegmentationByRange from './thresholdSegmentationByRange';
-import { createImageIdReferenceMap } from './createImageIdReferenceMap';
 import contourAndFindLargestBidirectional from './contourAndFindLargestBidirectional';
 import createBidirectionalToolData from './createBidirectionalToolData';
 import segmentContourAction from './segmentContourAction';
@@ -19,4 +18,4 @@ import { getSegmentIndexAtWorldPoint } from './getSegmentIndexAtWorldPoint';
 import { getSegmentIndexAtLabelmapBorder } from './getSegmentIndexAtLabelmapBorder';
 import { getHoveredContourSegmentationAnnotation } from './getHoveredContourSegmentationAnnotation';
 import { getBrushToolInstances } from './utilities';
-export { thresholdVolumeByRange, createMergedLabelmapForIndex, isValidRepresentationConfig, getDefaultRepresentationConfig, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, thresholdSegmentationByRange, createImageIdReferenceMap, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, };
+export { thresholdVolumeByRange, createMergedLabelmapForIndex, isValidRepresentationConfig, getDefaultRepresentationConfig, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, };

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

@@ -9,7 +9,6 @@ import floodFill from './floodFill';
 import { getBrushSizeForToolGroup, setBrushSizeForToolGroup, } from './brushSizeForToolGroup';
 import { getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, } from './brushThresholdForToolGroup';
 import thresholdSegmentationByRange from './thresholdSegmentationByRange';
-import { createImageIdReferenceMap } from './createImageIdReferenceMap';
 import contourAndFindLargestBidirectional from './contourAndFindLargestBidirectional';
 import createBidirectionalToolData from './createBidirectionalToolData';
 import segmentContourAction from './segmentContourAction';
@@ -19,4 +18,4 @@ import { getSegmentIndexAtWorldPoint } from './getSegmentIndexAtWorldPoint';
 import { getSegmentIndexAtLabelmapBorder } from './getSegmentIndexAtLabelmapBorder';
 import { getHoveredContourSegmentationAnnotation } from './getHoveredContourSegmentationAnnotation';
 import { getBrushToolInstances } from './utilities';
-export { thresholdVolumeByRange, createMergedLabelmapForIndex, isValidRepresentationConfig, getDefaultRepresentationConfig, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, thresholdSegmentationByRange, createImageIdReferenceMap, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, };
+export { thresholdVolumeByRange, createMergedLabelmapForIndex, isValidRepresentationConfig, getDefaultRepresentationConfig, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, };

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

@@ -1,7 +1,6 @@
 import { imageLoader, Enums, eventTarget, imageLoadPoolManager, cache, getConfiguration as getCoreConfiguration, } from '@cornerstonejs/core';
 import { addToolState, getToolState } from './state';
 import { getStackData, requestType, priority, clearFromImageIds, getPromiseRemovedHandler, } from './stackPrefetchUtils';
-import { roundNumber } from '../../utilities';
 let configuration = {
     maxImagesToPrefetch: Infinity,
     minBefore: 2,
@@ -93,7 +92,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');
                 }
             }
         }