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

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

@@ -1,6 +1,7 @@
 import { getEnabledElement, addVolumesToViewports, addImageSlicesToViewports, Enums, } from '@cornerstonejs/core';
 import { isVolumeSegmentation } from '../../segmentation/strategies/utils/stackVolumeCheck';
-import { getCurrentLabelmapImageIdForViewport, getSegmentationRepresentation, } from '../../../stateManagement/segmentation/segmentationState';
+import { getSegmentationRepresentation } from '../../../stateManagement/segmentation/getSegmentationRepresentation';
+import { getCurrentLabelmapImageIdForViewport } from '../../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
 async function addLabelmapToElement(element, labelMapData, segmentationRepresentationUID) {
     const enabledElement = getEnabledElement(element);
     const { renderingEngine, viewport } = enabledElement;

package/dist/esm/tools/displayTools/Labelmap/labelmapDisplay.d.ts

@@ -1,17 +1,10 @@
-import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
-import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
 import type { Types } from '@cornerstonejs/core';
 import type { LabelmapRepresentation } from '../../../types/SegmentationStateTypes';
-declare function getSegmentationRepresentationRenderingConfig(): {
-    ofun: vtkPiecewiseFunction;
-    cfun: vtkColorTransferFunction;
-};
 declare function removeRepresentation(viewportId: string, segmentationRepresentationUID: string, renderImmediate?: boolean): void;
 declare function render(viewport: Types.IStackViewport | Types.IVolumeViewport, representation: LabelmapRepresentation): Promise<void>;
 declare const _default: {
-    getSegmentationRepresentationRenderingConfig: typeof getSegmentationRepresentationRenderingConfig;
     render: typeof render;
     removeRepresentation: typeof removeRepresentation;
 };
 export default _default;
-export { getSegmentationRepresentationRenderingConfig, render, removeRepresentation, };
+export { render, removeRepresentation };

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

@@ -1,24 +1,19 @@
-import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
-import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
 import { cache, getEnabledElementByViewportId, StackViewport, VolumeViewport, } from '@cornerstonejs/core';
 import Representations from '../../../enums/SegmentationRepresentations';
-import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
 import addLabelmapToElement from './addLabelmapToElement';
 import removeLabelmapFromElement from './removeLabelmapFromElement';
 import { isVolumeSegmentation } from '../../segmentation/strategies/utils/stackVolumeCheck';
-import { polySeg } from '../../../stateManagement/segmentation';
 import { getHiddenSegmentIndices } from '../../../stateManagement/segmentation/config/segmentationVisibility';
+import { removeRepresentation as _removeRepresentation } from '../../../stateManagement/segmentation/removeRepresentation';
+import { getActiveSegmentationRepresentation } from '../../../stateManagement/segmentation/getActiveSegmentationRepresentation';
+import { getColorLUT } from '../../../stateManagement/segmentation/getColorLUT';
+import { getCurrentLabelmapImageIdForViewport } from '../../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
+import { getGlobalConfig } from '../../../stateManagement/segmentation/getGlobalConfig';
+import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
+import { canComputeRequestedRepresentation } from '../../../stateManagement/segmentation/polySeg/canComputeRequestedRepresentation';
+import { computeAndAddLabelmapRepresentation } from '../../../stateManagement/segmentation/polySeg/Labelmap/computeAndAddLabelmapRepresentation';
 const MAX_NUMBER_COLORS = 255;
 const labelMapConfigCache = new Map();
-function getSegmentationRepresentationRenderingConfig() {
-    const cfun = vtkColorTransferFunction.newInstance();
-    const ofun = vtkPiecewiseFunction.newInstance();
-    ofun.addPoint(0, 0);
-    return {
-        ofun,
-        cfun,
-    };
-}
 let polySegConversionInProgress = false;
 function removeRepresentation(viewportId, segmentationRepresentationUID, renderImmediate = false) {
     const enabledElement = getEnabledElementByViewportId(viewportId);
@@ -27,7 +22,7 @@ function removeRepresentation(viewportId, segmentationRepresentationUID, renderI
     }
     const { viewport } = enabledElement;
     removeLabelmapFromElement(viewport.element, segmentationRepresentationUID);
-    SegmentationState.removeRepresentation(segmentationRepresentationUID);
+    _removeRepresentation(segmentationRepresentationUID);
     if (!renderImmediate) {
         return;
     }
@@ -55,7 +50,7 @@ function isSameFrameOfReference(viewport, referencedVolumeId) {
 }
 async function render(viewport, representation) {
     const { segmentationId, segmentationRepresentationUID } = representation;
-    const segmentation = SegmentationState.getSegmentation(segmentationId);
+    const segmentation = getSegmentation(segmentationId);
     if (!segmentation) {
         console.warn('No segmentation found for segmentationId: ', segmentationId);
         return;
@@ -63,10 +58,10 @@ async function render(viewport, representation) {
     let labelmapData = segmentation.representationData[Representations.Labelmap];
     let actorEntry = viewport.getActor(segmentationRepresentationUID);
     if (!labelmapData &&
-        polySeg.canComputeRequestedRepresentation(segmentationRepresentationUID) &&
+        canComputeRequestedRepresentation(segmentationRepresentationUID) &&
         !polySegConversionInProgress) {
         polySegConversionInProgress = true;
-        labelmapData = await polySeg.computeAndAddLabelmapRepresentation(segmentationId, {
+        labelmapData = await computeAndAddLabelmapRepresentation(segmentationId, {
             segmentationRepresentationUID,
             viewport,
         });
@@ -99,7 +94,7 @@ async function render(viewport, representation) {
         if (viewport instanceof VolumeViewport) {
             return;
         }
-        const labelmapImageId = SegmentationState.getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
+        const labelmapImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
         if (!labelmapImageId) {
             return;
         }
@@ -115,19 +110,19 @@ async function render(viewport, representation) {
 }
 function _setLabelmapColorAndOpacity(viewportId, actorEntry, segmentationRepresentation) {
     const { rendering, config, colorLUTIndex } = segmentationRepresentation;
-    const activeSegRep = SegmentationState.getActiveSegmentationRepresentation(viewportId);
+    const activeSegRep = getActiveSegmentationRepresentation(viewportId);
     const isActiveLabelmap = activeSegRep === segmentationRepresentation;
     const { cfun, ofun } = rendering;
     const { allSegments, perSegment } = config;
-    const globalLabelmapConfig = SegmentationState.getGlobalConfig().representations[Representations.Labelmap];
-    const globalConfig = SegmentationState.getGlobalConfig();
+    const globalLabelmapConfig = getGlobalConfig().representations[Representations.Labelmap];
+    const globalConfig = getGlobalConfig();
     const renderInactiveRepresentations = globalConfig.renderInactiveRepresentations;
     const configToUse = {
         ...globalLabelmapConfig,
         ...allSegments[Representations.Labelmap],
     };
     const labelmapConfig = configToUse;
-    const colorLUT = SegmentationState.getColorLUT(colorLUTIndex);
+    const colorLUT = getColorLUT(colorLUTIndex);
     const numColors = Math.min(256, colorLUT.length);
     const { uid: actorUID } = actorEntry;
     const { outlineWidth, renderOutline, outlineOpacity, activeSegmentOutlineWidthDelta, } = _getLabelmapConfig(labelmapConfig, isActiveLabelmap);
@@ -167,7 +162,7 @@ function _setLabelmapColorAndOpacity(viewportId, actorEntry, segmentationReprese
     actor.getProperty().setInterpolationTypeToNearest();
     actor.getProperty().setUseLabelOutline(renderOutline);
     actor.getProperty().setLabelOutlineOpacity(outlineOpacity);
-    const { activeSegmentIndex } = SegmentationState.getSegmentation(segmentationRepresentation.segmentationId);
+    const { activeSegmentIndex } = getSegmentation(segmentationRepresentation.segmentationId);
     const outlineWidths = new Array(numColors - 1);
     for (let i = 1; i < numColors; i++) {
         const isHidden = segmentsHidden.has(i);
@@ -256,8 +251,7 @@ async function _addLabelmapToViewport(viewport, labelmapData, segmentationRepres
     await addLabelmapToElement(viewport.element, labelmapData, segmentationRepresentationUID);
 }
 export default {
-    getSegmentationRepresentationRenderingConfig,
     render,
     removeRepresentation,
 };
-export { getSegmentationRepresentationRenderingConfig, render, removeRepresentation, };
+export { render, removeRepresentation };

package/dist/esm/tools/displayTools/Surface/surfaceDisplay.js

@@ -1,9 +1,12 @@
 import { cache, getEnabledElementByViewportId, VolumeViewport3D, } from '@cornerstonejs/core';
-import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
 import Representations from '../../../enums/SegmentationRepresentations';
+import { removeRepresentation as _removeRepresentation } from '../../../stateManagement/segmentation/removeRepresentation';
 import removeSurfaceFromElement from './removeSurfaceFromElement';
 import addOrUpdateSurfaceToElement from './addOrUpdateSurfaceToElement';
-import { polySeg } from '../../../stateManagement/segmentation';
+import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
+import { getColorLUT } from '../../../stateManagement/segmentation/getColorLUT';
+import { canComputeRequestedRepresentation } from '../../../stateManagement/segmentation/polySeg/canComputeRequestedRepresentation';
+import { computeAndAddSurfaceRepresentation } from '../../../stateManagement/segmentation/polySeg';
 function removeRepresentation(viewportId, segmentationRepresentationUID, renderImmediate = false) {
     const enabledElement = getEnabledElementByViewportId(viewportId);
     if (!enabledElement) {
@@ -11,7 +14,7 @@ function removeRepresentation(viewportId, segmentationRepresentationUID, renderI
     }
     const { viewport } = enabledElement;
     removeSurfaceFromElement(viewport.element, segmentationRepresentationUID);
-    SegmentationState.removeRepresentation(segmentationRepresentationUID);
+    _removeRepresentation(segmentationRepresentationUID);
     if (!renderImmediate) {
         return;
     }
@@ -19,7 +22,7 @@ function removeRepresentation(viewportId, segmentationRepresentationUID, renderI
 }
 async function render(viewport, representation) {
     const { colorLUTIndex, segmentationId, segmentationRepresentationUID } = representation;
-    const segmentation = SegmentationState.getSegmentation(segmentationId);
+    const segmentation = getSegmentation(segmentationId);
     if (!segmentation) {
         return;
     }
@@ -28,8 +31,8 @@ async function render(viewport, representation) {
     }
     let SurfaceData = segmentation.representationData[Representations.Surface];
     if (!SurfaceData &&
-        polySeg.canComputeRequestedRepresentation(segmentationRepresentationUID)) {
-        SurfaceData = await polySeg.computeAndAddSurfaceRepresentation(segmentationId, {
+        canComputeRequestedRepresentation(segmentationRepresentationUID)) {
+        SurfaceData = await computeAndAddSurfaceRepresentation(segmentationId, {
             segmentationRepresentationUID,
         });
         if (!SurfaceData) {
@@ -40,7 +43,7 @@ async function render(viewport, representation) {
     if (!geometryIds?.size) {
         console.warn(`No Surfaces found for segmentationId ${segmentationId}. Skipping render.`);
     }
-    const colorLUT = SegmentationState.getColorLUT(colorLUTIndex);
+    const colorLUT = getColorLUT(colorLUTIndex);
     const surfaces = [];
     geometryIds.forEach((geometryId, segmentIndex) => {
         const geometry = cache.getGeometry(geometryId);

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

@@ -9,9 +9,11 @@ import { Events, ToolModes, SegmentationRepresentations, StrategyCallbacks, } fr
 import { drawCircle as drawCircleSvg } from '../../drawingSvg';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 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 { getCurrentLabelmapImageIdForViewport } from '../../stateManagement/segmentation/segmentationState';
+import { getActiveSegmentationRepresentation, getCurrentLabelmapImageIdForViewport, getSegmentation, } from '../../stateManagement/segmentation/segmentationState';
+import { getLockedSegmentIndices } from '../../stateManagement/segmentation/segmentLocking';
+import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getActiveSegmentIndex';
+import { getSegmentIndexColor } from '../../stateManagement/segmentation/config/segmentationColor';
 class BrushTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -192,7 +194,7 @@ class BrushTool extends BaseTool {
     createEditData(element) {
         const enabledElement = getEnabledElement(element);
         const { viewport } = enabledElement;
-        const activeRepresentation = activeSegmentation.getActiveSegmentationRepresentation(viewport.id);
+        const activeRepresentation = getActiveSegmentationRepresentation(viewport.id);
         if (!activeRepresentation) {
             throw new Error('No active segmentation detected, create a segmentation representation before using the brush tool');
         }
@@ -200,8 +202,8 @@ class BrushTool extends BaseTool {
         if (type === SegmentationRepresentations.Contour) {
             throw new Error('Not implemented yet');
         }
-        const segmentsLocked = segmentLocking.getLockedSegmentIndices(segmentationId);
-        const { representationData } = segmentationState.getSegmentation(segmentationId);
+        const segmentsLocked = getLockedSegmentIndices(segmentationId);
+        const { representationData } = getSegmentation(segmentationId);
         const labelmapData = representationData[SegmentationRepresentations.Labelmap];
         if (isVolumeSegmentation(labelmapData, viewport)) {
             const { volumeId } = representationData[type];
@@ -272,14 +274,14 @@ class BrushTool extends BaseTool {
     }
     getActiveSegmentationData(viewport) {
         const viewportId = viewport.id;
-        const activeRepresentation = activeSegmentation.getActiveSegmentationRepresentation(viewportId);
+        const activeRepresentation = getActiveSegmentationRepresentation(viewportId);
         if (!activeRepresentation) {
             console.warn('No active segmentation detected, create one before using the brush tool');
             return;
         }
         const { segmentationId, segmentationRepresentationUID } = activeRepresentation;
-        const segmentIndex = segmentIndexController.getActiveSegmentIndex(segmentationId);
-        const segmentColor = segmentationConfig.color.getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
+        const segmentIndex = getActiveSegmentIndex(segmentationId);
+        const segmentColor = getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
         return {
             segmentIndex,
             segmentationId,

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

@@ -16,7 +16,6 @@ import { getCanvasCircleCorners, getCanvasCircleRadius, } from '../../utilities/
 import { getCalibratedLengthUnitsAndScale, getCalibratedAspect, } from '../../utilities/getCalibratedUnits';
 import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
 import { pointInEllipse } from '../../utilities/math/ellipse';
-import { roundNumber } from '../../utilities';
 import { BasicStatsCalculator } from '../../utilities/math/basic';
 import cloneDeep from 'lodash.clonedeep';
 import { filterAnnotationsWithinSamePlane } from '../../utilities/planar';
@@ -462,10 +461,10 @@ function defaultGetTextLines(data) {
         return;
     }
     const textLines = [];
-    textLines.push(`Area: ${roundNumber(area)} ${areaUnits}`);
-    textLines.push(`Mean: ${roundNumber(mean)} ${pixelValueUnits}`);
-    textLines.push(`Max: ${roundNumber(max)} ${pixelValueUnits}`);
-    textLines.push(`Std Dev: ${roundNumber(stdDev)} ${pixelValueUnits}`);
+    textLines.push(`Area: ${csUtils.roundNumber(area)} ${areaUnits}`);
+    textLines.push(`Mean: ${csUtils.roundNumber(mean)} ${pixelValueUnits}`);
+    textLines.push(`Max: ${csUtils.roundNumber(max)} ${pixelValueUnits}`);
+    textLines.push(`Std Dev: ${csUtils.roundNumber(stdDev)} ${pixelValueUnits}`);
     return textLines;
 }
 CircleROIStartEndThresholdTool.toolName = 'CircleROIStartEndThreshold';

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

@@ -1,5 +1,4 @@
 import { getEnabledElement, cache, StackViewport, utilities as csUtils, } from '@cornerstonejs/core';
-import { utilities as coreUtils } from '@cornerstonejs/core';
 import { getCalibratedLengthUnitsAndScale } from '../../utilities/getCalibratedUnits';
 import { vec3 } from 'gl-matrix';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateManagement';
@@ -14,7 +13,6 @@ import { hideElementCursor, resetElementCursor, } from '../../cursors/elementCur
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { triggerAnnotationCompleted, triggerAnnotationModified, } from '../../stateManagement/annotation/helpers/state';
 import RectangleROITool from '../annotation/RectangleROITool';
-import { roundNumber } from '../../utilities/';
 import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
 import { BasicStatsCalculator } from '../../utilities/math/basic';
 import { filterAnnotationsWithinSamePlane } from '../../utilities/planar';
@@ -178,10 +176,10 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
                 if (Array.isArray(endCoordinate)) {
                     endCoord = this._getCoordinateForViewplaneNormal(endCoord, viewplaneNormal);
                 }
-                const roundedStartCoord = coreUtils.roundToPrecision(startCoord);
-                const roundedEndCoord = coreUtils.roundToPrecision(endCoord);
+                const roundedStartCoord = csUtils.roundToPrecision(startCoord);
+                const roundedEndCoord = csUtils.roundToPrecision(endCoord);
                 const coord = this._getCoordinateForViewplaneNormal(focalPoint, viewplaneNormal);
-                const roundedCoord = coreUtils.roundToPrecision(coord);
+                const roundedCoord = csUtils.roundToPrecision(coord);
                 if (roundedCoord < Math.min(roundedStartCoord, roundedEndCoord) ||
                     roundedCoord > Math.max(roundedStartCoord, roundedEndCoord)) {
                     continue;
@@ -417,10 +415,10 @@ function defaultGetTextLines(data) {
         return;
     }
     const textLines = [];
-    textLines.push(`Area: ${roundNumber(area)} ${areaUnits}`);
-    textLines.push(`Mean: ${roundNumber(mean)} ${pixelValueUnits}`);
-    textLines.push(`Max: ${roundNumber(max)} ${pixelValueUnits}`);
-    textLines.push(`Std Dev: ${roundNumber(stdDev)} ${pixelValueUnits}`);
+    textLines.push(`Area: ${csUtils.roundNumber(area)} ${areaUnits}`);
+    textLines.push(`Mean: ${csUtils.roundNumber(mean)} ${pixelValueUnits}`);
+    textLines.push(`Max: ${csUtils.roundNumber(max)} ${pixelValueUnits}`);
+    textLines.push(`Std Dev: ${csUtils.roundNumber(stdDev)} ${pixelValueUnits}`);
     return textLines;
 }
 RectangleROIStartEndThresholdTool.toolName = 'RectangleROIStartEndThreshold';

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

@@ -6,7 +6,7 @@ import { getActiveSegmentationRepresentation } from '../../stateManagement/segme
 import RepresentationTypes from '../../enums/SegmentationRepresentations';
 import { setActiveSegmentIndex } from '../../stateManagement/segmentation/segmentIndex';
 import { getHoveredContourSegmentationAnnotation, getSegmentIndexAtLabelmapBorder, getSegmentIndexAtWorldPoint, } from '../../utilities/segmentation';
-import { state } from '../../store';
+import { state } from '../../store/state';
 import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
 class SegmentSelectTool extends BaseTool {
     static { this.SelectMode = {

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

@@ -1,6 +1,6 @@
-import { triggerSegmentationDataModified } from '../../../../stateManagement/segmentation/triggerSegmentationEvents';
-import { config as segmentationConfig } from '../../../../stateManagement/segmentation';
+import { triggerSegmentationDataModified } from '../../../../stateManagement/segmentation/events/triggerSegmentationDataModified';
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+import { getSegmentIndexColor, setSegmentIndexColor, } from '../../../../stateManagement/segmentation/config/segmentationColor';
 function lightenColor(r, g, b, a, factor = 0.4) {
     return [
         Math.round(r + (255 - r) * factor),
@@ -42,12 +42,12 @@ export default {
             return;
         }
         const configColor = previewColors?.[segmentIndex];
-        const segmentColor = segmentationConfig.color.getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
+        const segmentColor = getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
         if (!configColor && !segmentColor) {
             return;
         }
         const previewColor = configColor || lightenColor(...segmentColor);
-        segmentationConfig.color.setSegmentIndexColor(segmentationRepresentationUID, previewSegmentIndex, previewColor);
+        setSegmentIndexColor(segmentationRepresentationUID, previewSegmentIndex, previewColor);
     },
     [StrategyCallbacks.AcceptPreview]: (operationData) => {
         const { segmentationVoxelManager, previewVoxelManager: previewVoxelManager, previewSegmentIndex, preview, } = operationData || {};

package/dist/esm/utilities/annotationHydration.js

@@ -1,5 +1,5 @@
 import { utilities, BaseVolumeViewport, StackViewport, cache, metaData, } from '@cornerstonejs/core';
-import { addAnnotation } from '../stateManagement';
+import { addAnnotation } from '../stateManagement/annotation/annotationState';
 import { vec3 } from 'gl-matrix';
 function annotationHydration(viewport, toolName, worldPoints, options) {
     const viewReference = viewport.getViewReference();

package/dist/esm/utilities/contourSegmentation/addContourSegmentationAnnotation.js

@@ -1,4 +1,4 @@
-import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
+import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
 export function addContourSegmentationAnnotation(annotation) {
     if (annotation.parentAnnotationUID) {
         return;

package/dist/esm/utilities/contourSegmentation/removeContourSegmentationAnnotation.js

@@ -1,10 +1,10 @@
-import { state } from '../../stateManagement/segmentation';
+import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
 export function removeContourSegmentationAnnotation(annotation) {
     if (!annotation.data.segmentation) {
         throw new Error('removeContourSegmentationAnnotation: annotation does not have a segmentation data');
     }
     const { segmentationId, segmentIndex } = annotation.data.segmentation;
-    const segmentation = state.getSegmentation(segmentationId);
+    const segmentation = getSegmentation(segmentationId);
     const { annotationUIDsMap } = segmentation?.representationData.CONTOUR || {};
     const annotationsUIDsSet = annotationUIDsMap?.get(segmentIndex);
     if (!annotationsUIDsSet) {

package/dist/esm/utilities/contours/generateContourSetsFromLabelmap.js

@@ -2,7 +2,7 @@ import { cache as cornerstoneCache } from '@cornerstonejs/core';
 import vtkImageMarchingSquares from '@kitware/vtk.js/Filters/General/ImageMarchingSquares';
 import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
 import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
-import { getDeduplicatedVTKPolyDataPoints } from '../contours';
+import { getDeduplicatedVTKPolyDataPoints } from './getDeduplicatedVTKPolyDataPoints';
 import { findContoursFromReducedSet } from './contourFinder';
 import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
 const { Labelmap } = SegmentationRepresentations;

package/dist/esm/utilities/contours/getContourHolesDataWorld.js

@@ -1,4 +1,4 @@
-import { getAnnotation } from '../../stateManagement';
+import { getAnnotation } from '../../stateManagement/annotation/annotationState';
 export default function getContourHolesDataWorld(annotation) {
     const childAnnotationUIDs = annotation.childAnnotationUIDs ?? [];
     return childAnnotationUIDs.map((uid) => getAnnotation(uid).data.contour.polyline);

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

@@ -8,7 +8,6 @@ import getContourHolesDataWorld from './getContourHolesDataWorld';
 import getContourHolesDataCanvas from './getContourHolesDataCanvas';
 import updateContourPolyline from './updateContourPolyline';
 import acceptAutogeneratedInterpolations from './interpolation/acceptAutogeneratedInterpolations';
-import * as interpolation from './interpolation';
 import findHandlePolylineIndex from './findHandlePolylineIndex';
 import calculatePerimeter from './calculatePerimeter';
-export { areCoplanarContours, contourFinder, getDeduplicatedVTKPolyDataPoints, detectContourHoles, generateContourSetsFromLabelmap, AnnotationToPointData, getContourHolesDataWorld, getContourHolesDataCanvas, updateContourPolyline, interpolation, acceptAutogeneratedInterpolations, findHandlePolylineIndex, calculatePerimeter, };
+export { areCoplanarContours, contourFinder, getDeduplicatedVTKPolyDataPoints, detectContourHoles, generateContourSetsFromLabelmap, AnnotationToPointData, getContourHolesDataWorld, getContourHolesDataCanvas, updateContourPolyline, acceptAutogeneratedInterpolations, findHandlePolylineIndex, calculatePerimeter, };

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

@@ -8,7 +8,6 @@ import getContourHolesDataWorld from './getContourHolesDataWorld';
 import getContourHolesDataCanvas from './getContourHolesDataCanvas';
 import updateContourPolyline from './updateContourPolyline';
 import acceptAutogeneratedInterpolations from './interpolation/acceptAutogeneratedInterpolations';
-import * as interpolation from './interpolation';
 import findHandlePolylineIndex from './findHandlePolylineIndex';
 import calculatePerimeter from './calculatePerimeter';
-export { areCoplanarContours, contourFinder, getDeduplicatedVTKPolyDataPoints, detectContourHoles, generateContourSetsFromLabelmap, AnnotationToPointData, getContourHolesDataWorld, getContourHolesDataCanvas, updateContourPolyline, interpolation, acceptAutogeneratedInterpolations, findHandlePolylineIndex, calculatePerimeter, };
+export { areCoplanarContours, contourFinder, getDeduplicatedVTKPolyDataPoints, detectContourHoles, generateContourSetsFromLabelmap, AnnotationToPointData, getContourHolesDataWorld, getContourHolesDataCanvas, updateContourPolyline, acceptAutogeneratedInterpolations, findHandlePolylineIndex, calculatePerimeter, };

package/dist/esm/utilities/contours/updateContourPolyline.js

@@ -1,6 +1,6 @@
 import { utilities as csUtils } from '@cornerstonejs/core';
 import * as math from '../math';
-import { getParentAnnotation, invalidateAnnotation, } from '../../stateManagement';
+import { getParentAnnotation, invalidateAnnotation, } from '../../stateManagement/annotation/annotationState';
 export default function updateContourPolyline(annotation, polylineData, transforms, options) {
     const { canvasToWorld, worldToCanvas } = transforms;
     const { data } = annotation;

package/dist/esm/utilities/getToolsWithModesForElement.js

@@ -1,9 +1,9 @@
-import { ToolGroupManager } from '../store';
 import { getEnabledElement } from '@cornerstonejs/core';
+import { getToolGroupForViewport } from '../store/ToolGroupManager';
 export default function getToolsWithModesForElement(element, modesFilter) {
     const enabledElement = getEnabledElement(element);
     const { renderingEngineId, viewportId } = enabledElement;
-    const toolGroup = ToolGroupManager.getToolGroupForViewport(viewportId, renderingEngineId);
+    const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
     if (!toolGroup) {
         return [];
     }

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

@@ -1,4 +1,4 @@
-import { utilities } from '@cornerstonejs/core';
+import { utilities, triggerEvent } from '@cornerstonejs/core';
 import { getAnnotationNearPoint, getAnnotationNearPointOnEnabledElement } from './getAnnotationNearPoint';
 import debounce from './debounce';
 import throttle from './throttle';
@@ -35,5 +35,4 @@ import * as polyDataUtils from './polyData/utils';
 import * as voi from './voi';
 import * as contourSegmentation from './contourSegmentation';
 declare const roundNumber: typeof utilities.roundNumber;
-import { triggerEvent } from '@cornerstonejs/core';
 export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, jumpToSlice, viewport, cine, clip, boundingBox, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, scroll, roundNumber, pointToString, polyDataUtils, voi, annotationFrameRange, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, };

package/dist/esm/utilities/index.js

@@ -1,4 +1,4 @@
-import { utilities } from '@cornerstonejs/core';
+import { utilities, triggerEvent } from '@cornerstonejs/core';
 import { getAnnotationNearPoint, getAnnotationNearPointOnEnabledElement, } from './getAnnotationNearPoint';
 import debounce from './debounce';
 import throttle from './throttle';
@@ -35,5 +35,4 @@ import * as polyDataUtils from './polyData/utils';
 import * as voi from './voi';
 import * as contourSegmentation from './contourSegmentation';
 const roundNumber = utilities.roundNumber;
-import { triggerEvent } from '@cornerstonejs/core';
 export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, jumpToSlice, viewport, cine, clip, boundingBox, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, scroll, roundNumber, pointToString, polyDataUtils, voi, annotationFrameRange, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, };

package/dist/esm/utilities/math/line/distanceToPointSquaredInfo.js

@@ -1,7 +1,7 @@
-import * as math from '../';
+import { distanceToPointSquared } from '../point';
 export default function distanceToPointSquaredInfo(lineStart, lineEnd, point) {
     let closestPoint;
-    const distanceSquared = math.point.distanceToPointSquared(lineStart, lineEnd);
+    const distanceSquared = distanceToPointSquared(lineStart, lineEnd);
     if (lineStart[0] === lineEnd[0] && lineStart[1] === lineEnd[1]) {
         closestPoint = lineStart;
     }
@@ -24,6 +24,6 @@ export default function distanceToPointSquaredInfo(lineStart, lineEnd, point) {
     }
     return {
         point: [...closestPoint],
-        distanceSquared: math.point.distanceToPointSquared(point, closestPoint),
+        distanceSquared: distanceToPointSquared(point, closestPoint),
     };
 }

package/dist/esm/utilities/math/polyline/isClosed.js

@@ -1,5 +1,5 @@
 import { glMatrix } from 'gl-matrix';
-import * as math from '..';
+import { distanceToPointSquared } from '../point';
 export default function isClosed(polyline) {
     if (polyline.length < 3) {
         return false;
@@ -7,6 +7,6 @@ export default function isClosed(polyline) {
     const numPolylinePoints = polyline.length;
     const firstPoint = polyline[0];
     const lastPoint = polyline[numPolylinePoints - 1];
-    const distFirstToLastPoints = math.point.distanceToPointSquared(firstPoint, lastPoint);
+    const distFirstToLastPoints = distanceToPointSquared(firstPoint, lastPoint);
     return glMatrix.equals(0, distFirstToLastPoints);
 }

package/dist/esm/utilities/planarFreehandROITool/smoothAnnotation.js

@@ -1,6 +1,6 @@
-import { PlanarFreehandROITool } from '../../tools';
-import { ToolGroupManager } from '../../store';
+import PlanarFreehandROITool from '../../tools/annotation/PlanarFreehandROITool';
 import interpolateSegmentPoints from './interpolation/interpolateSegmentPoints';
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
 function shouldPreventInterpolation(enabledElement, annotation, knotsRatioPercentage) {
     if (!annotation?.data?.polyline || knotsRatioPercentage <= 0) {
         return true;
@@ -9,7 +9,7 @@ function shouldPreventInterpolation(enabledElement, annotation, knotsRatioPercen
         return true;
     }
     const { renderingEngineId, viewportId, FrameOfReferenceUID } = enabledElement;
-    const toolGroup = ToolGroupManager.getToolGroupForViewport(viewportId, renderingEngineId);
+    const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
     if (annotation.metadata.FrameOfReferenceUID !== FrameOfReferenceUID) {
         return true;
     }

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

@@ -1,7 +1,7 @@
 import { getToolGroup } from '../../store/ToolGroupManager';
 import triggerAnnotationRenderForViewportIds from '../triggerAnnotationRenderForViewportIds';
 import { getRenderingEngine } from '@cornerstonejs/core';
-import { getBrushToolInstances } from './utilities';
+import { getBrushToolInstances } from './getBrushToolInstances';
 export function setBrushSizeForToolGroup(toolGroupId, brushSize, toolName) {
     const toolGroup = getToolGroup(toolGroupId);
     if (toolGroup === undefined) {

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

@@ -1,7 +1,7 @@
 import { getToolGroup } from '../../store/ToolGroupManager';
 import triggerAnnotationRenderForViewportIds from '../triggerAnnotationRenderForViewportIds';
 import { getRenderingEngine } from '@cornerstonejs/core';
-import { getBrushToolInstances } from './utilities';
+import { getBrushToolInstances } from './getBrushToolInstances';
 export function setBrushThresholdForToolGroup(toolGroupId, threshold, otherArgs = { isDynamic: false }) {
     const toolGroup = getToolGroup(toolGroupId);
     if (toolGroup === undefined) {

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

@@ -0,0 +1 @@
+export declare function getBrushToolInstances(toolGroupId: string, toolName?: string): any[];

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

@@ -0,0 +1,17 @@
+import { getToolGroup } from '../../store/ToolGroupManager';
+import BrushTool from '../../tools/segmentation/BrushTool';
+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;
+}

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

@@ -1,4 +1,2 @@
-export declare const setSegmentationDirty: (segmentationId: string) => void;
-export declare const setSegmentationClean: (segmentationId: string) => void;
 declare function getUniqueSegmentIndices(segmentationId: any): any;
 export { getUniqueSegmentIndices };

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

@@ -1,27 +1,8 @@
 import { cache } from '@cornerstonejs/core';
-import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
 import { isVolumeSegmentation } from '../../tools/segmentation/strategies/utils/stackVolumeCheck';
 import { SegmentationRepresentations } from '../../enums';
-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;
-    }
-};
-function getCachedSegmentIndices(segmentationId) {
-    const cached = segmentIndicesCache.get(segmentationId);
-    if (cached && !cached.isDirty) {
-        return cached.indices;
-    }
-    return null;
-}
+import { getCachedSegmentIndices, setCachedSegmentIndices } from './utilities';
+import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
 function getUniqueSegmentIndices(segmentationId) {
     const cachedResult = getCachedSegmentIndices(segmentationId);
     if (cachedResult) {
@@ -45,7 +26,7 @@ function getUniqueSegmentIndices(segmentationId) {
         default:
             throw new Error(`Unsupported segmentation type: ${segmentation.type}`);
     }
-    segmentIndicesCache.set(segmentationId, { indices, isDirty: false });
+    setCachedSegmentIndices(segmentationId, indices);
     return indices;
 }
 function handleLabelmapSegmentation(segmentation, segmentationId) {