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

package/dist/esm/cursors/elementCursor.d.ts

@@ -1,4 +1,4 @@
-import { MouseCursor } from '.';
+import MouseCursor from './MouseCursor';
 declare function initElementCursor(element: HTMLDivElement, cursor: MouseCursor | null): void;
 declare function _setElementCursor(element: HTMLDivElement, cursor: MouseCursor | null): void;
 declare function resetElementCursor(element: HTMLDivElement): void;

package/dist/esm/cursors/elementCursor.js

@@ -1,4 +1,4 @@
-import { MouseCursor } from '.';
+import MouseCursor from './MouseCursor';
 const ELEMENT_CURSORS_MAP = Symbol('ElementCursorsMap');
 function initElementCursor(element, cursor) {
     _getElementCursors(element)[0] = cursor;

package/dist/esm/drawingSvg/getSvgDrawingHelper.js

@@ -1,4 +1,4 @@
-import { state } from '../store';
+import { state } from '../store/state';
 import { getEnabledElement } from '@cornerstonejs/core';
 const VIEWPORT_ELEMENT = 'viewport-element';
 function getSvgDrawingHelper(element) {

package/dist/esm/eventDispatchers/keyboardEventHandlers/keyDown.js

@@ -1,12 +1,12 @@
-import { ToolGroupManager } from '../../store';
 import getActiveToolForKeyboardEvent from '../shared/getActiveToolForKeyboardEvent';
 import getToolsWithActionsForKeyboardEvent from '../shared/getToolsWithActionsForKeyboardEvents';
 import ToolModes from '../../enums/ToolModes';
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
 export default function keyDown(evt) {
     const activeTool = getActiveToolForKeyboardEvent(evt);
     if (activeTool) {
         const { renderingEngineId, viewportId } = evt.detail;
-        const toolGroup = ToolGroupManager.getToolGroupForViewport(viewportId, renderingEngineId);
+        const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
         const toolName = activeTool.getToolName();
         if (Object.keys(toolGroup.toolOptions).includes(toolName)) {
             toolGroup.setViewportsCursorByToolName(toolName);

package/dist/esm/eventDispatchers/keyboardEventHandlers/keyUp.js

@@ -1,13 +1,13 @@
 import { resetModifierKey } from '../../eventListeners/keyboard/keyDownListener';
-import { ToolGroupManager } from '../../store';
 import getActiveToolForKeyboardEvent from '../shared/getActiveToolForKeyboardEvent';
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
 export default function keyUp(evt) {
     const activeTool = getActiveToolForKeyboardEvent(evt);
     if (!activeTool) {
         return;
     }
     const { renderingEngineId, viewportId } = evt.detail;
-    const toolGroup = ToolGroupManager.getToolGroupForViewport(viewportId, renderingEngineId);
+    const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
     resetModifierKey();
     const toolName = activeTool.getToolName();
     if (Object.keys(toolGroup.toolOptions).includes(toolName)) {

package/dist/esm/eventDispatchers/mouseEventHandlers/mouseDown.js

@@ -1,4 +1,4 @@
-import { state } from '../../store';
+import { state } from '../../store/state';
 import { ToolModes } from '../../enums';
 import { setAnnotationSelected, isAnnotationSelected, } from '../../stateManagement/annotation/annotationSelection';
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';

package/dist/esm/eventDispatchers/mouseEventHandlers/mouseDownActivate.js

@@ -1,4 +1,4 @@
-import { state } from '../../store';
+import { state } from '../../store/state';
 import getActiveToolForMouseEvent from '../shared/getActiveToolForMouseEvent';
 import { setAnnotationSelected } from '../../stateManagement/annotation/annotationSelection';
 export default function mouseDownActivate(evt) {

package/dist/esm/eventDispatchers/mouseEventHandlers/mouseDownAnnotationAction.js

@@ -1,5 +1,5 @@
 import { getEnabledElement } from '@cornerstonejs/core';
-import { state } from '../../store';
+import { state } from '../../store/state';
 import { ToolModes } from '../../enums';
 import filterToolsWithAnnotationsForElement from '../../store/filterToolsWithAnnotationsForElement';
 import filterMoveableAnnotationTools from '../../store/filterMoveableAnnotationTools';

package/dist/esm/eventDispatchers/mouseEventHandlers/mouseDrag.js

@@ -1,5 +1,5 @@
 import getActiveToolForMouseEvent from '../shared/getActiveToolForMouseEvent';
-import { state } from '../../store';
+import { state } from '../../store/state';
 export default function mouseDrag(evt) {
     if (state.isInteractingWithTool) {
         return;

package/dist/esm/eventDispatchers/mouseEventHandlers/mouseMove.js

@@ -1,4 +1,4 @@
-import { state } from '../../store';
+import { state } from '../../store/state';
 import { ToolModes } from '../../enums';
 import filterToolsWithAnnotationsForElement from '../../store/filterToolsWithAnnotationsForElement';
 import getToolsWithModesForMouseEvent from '../shared/getToolsWithModesForMouseEvent';

package/dist/esm/eventDispatchers/mouseEventHandlers/mouseWheel.js

@@ -1,4 +1,4 @@
-import { state } from '../../store';
+import { state } from '../../store/state';
 import getActiveToolForMouseEvent from '../shared/getActiveToolForMouseEvent';
 import { MouseBindings } from '../../enums/ToolBindings';
 function mouseWheel(evt) {

package/dist/esm/eventDispatchers/shared/customCallbackHandler.js

@@ -1,12 +1,13 @@
-import { state, ToolGroupManager } from '../../store';
+import { state } from '../../store/state';
 import ToolModes from '../../enums/ToolModes';
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
 const { Active } = ToolModes;
 export default function customCallbackHandler(handlerType, customFunction, evt) {
     if (state.isInteractingWithTool) {
         return false;
     }
     const { renderingEngineId, viewportId } = evt.detail;
-    const toolGroup = ToolGroupManager.getToolGroupForViewport(viewportId, renderingEngineId);
+    const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
     if (!toolGroup) {
         return false;
     }

package/dist/esm/eventDispatchers/shared/getActiveToolForKeyboardEvent.js

@@ -1,13 +1,13 @@
-import { ToolGroupManager } from '../../store';
 import { ToolModes } from '../../enums';
 import { keyEventListener } from '../../eventListeners';
 import { getMouseButton } from '../../eventListeners/mouse/mouseDownListener';
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
 const { Active } = ToolModes;
 export default function getActiveToolForKeyboardEvent(evt) {
     const { renderingEngineId, viewportId } = evt.detail;
     const mouseButton = getMouseButton();
     const modifierKey = keyEventListener.getModifierKey();
-    const toolGroup = ToolGroupManager.getToolGroupForViewport(viewportId, renderingEngineId);
+    const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
     if (!toolGroup) {
         return null;
     }

package/dist/esm/eventDispatchers/shared/getActiveToolForMouseEvent.js

@@ -1,12 +1,12 @@
-import { ToolGroupManager } from '../../store';
 import { ToolModes } from '../../enums';
 import { keyEventListener } from '../../eventListeners';
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
 import getMouseModifier from './getMouseModifier';
 const { Active } = ToolModes;
 export default function getActiveToolForMouseEvent(evt) {
     const { renderingEngineId, viewportId, event: mouseEvent } = evt.detail;
     const modifierKey = getMouseModifier(mouseEvent) || keyEventListener.getModifierKey();
-    const toolGroup = ToolGroupManager.getToolGroupForViewport(viewportId, renderingEngineId);
+    const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
     if (!toolGroup) {
         return null;
     }

package/dist/esm/eventDispatchers/shared/getActiveToolForTouchEvent.js

@@ -1,12 +1,12 @@
-import { ToolGroupManager } from '../../store';
-import { MouseBindings, ToolModes } from '../../enums';
+import { ToolModes } from '../../enums';
 import getMouseModifier from './getMouseModifier';
 import { keyEventListener } from '../../eventListeners';
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
 const { Active } = ToolModes;
 export default function getActiveToolForTouchEvent(evt) {
     const { renderingEngineId, viewportId } = evt.detail;
     const touchEvent = evt.detail.event;
-    const toolGroup = ToolGroupManager.getToolGroupForViewport(viewportId, renderingEngineId);
+    const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
     if (!toolGroup) {
         return null;
     }

package/dist/esm/eventDispatchers/shared/getToolsWithActionsForKeyboardEvents.js

@@ -1,8 +1,8 @@
-import { ToolGroupManager } from '../../store';
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
 export default function getToolsWithModesForKeyboardEvent(evt, toolModes) {
     const toolsWithActions = new Map();
     const { renderingEngineId, viewportId } = evt.detail;
-    const toolGroup = ToolGroupManager.getToolGroupForViewport(viewportId, renderingEngineId);
+    const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
     if (!toolGroup) {
         return toolsWithActions;
     }

package/dist/esm/eventDispatchers/shared/getToolsWithActionsForMouseEvent.js

@@ -1,10 +1,10 @@
-import { ToolGroupManager } from '../../store';
 import { keyEventListener } from '../../eventListeners';
 import getMouseModifier from './getMouseModifier';
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
 export default function getToolsWithActionsForMouseEvent(evt, toolModes) {
     const toolsWithActions = new Map();
     const { renderingEngineId, viewportId } = evt.detail;
-    const toolGroup = ToolGroupManager.getToolGroupForViewport(viewportId, renderingEngineId);
+    const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
     if (!toolGroup) {
         return toolsWithActions;
     }

package/dist/esm/eventDispatchers/shared/getToolsWithModesForMouseEvent.js

@@ -1,7 +1,7 @@
-import { ToolGroupManager } from '../../store';
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
 export default function getToolsWithModesForMouseEvent(evt, modesFilter, evtButton) {
     const { renderingEngineId, viewportId } = evt.detail;
-    const toolGroup = ToolGroupManager.getToolGroupForViewport(viewportId, renderingEngineId);
+    const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
     if (!toolGroup) {
         return [];
     }

package/dist/esm/eventDispatchers/shared/getToolsWithModesForTouchEvent.js

@@ -1,7 +1,7 @@
-import { ToolGroupManager } from '../../store';
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
 export default function getToolsWithModesForTouchEvent(evt, modesFilter, numTouchPoints) {
     const { renderingEngineId, viewportId } = evt.detail;
-    const toolGroup = ToolGroupManager.getToolGroupForViewport(viewportId, renderingEngineId);
+    const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
     if (!toolGroup) {
         return [];
     }

package/dist/esm/eventDispatchers/touchEventHandlers/touchDrag.js

@@ -1,5 +1,5 @@
 import getActiveToolForTouchEvent from '../shared/getActiveToolForTouchEvent';
-import { state } from '../../store';
+import { state } from '../../store/state';
 export default function touchDrag(evt) {
     if (state.isInteractingWithTool) {
         return;

package/dist/esm/eventDispatchers/touchEventHandlers/touchStart.js

@@ -1,4 +1,4 @@
-import { state } from '../../store';
+import { state } from '../../store/state';
 import { ToolModes } from '../../enums';
 import { setAnnotationSelected, isAnnotationSelected, } from '../../stateManagement/annotation/annotationSelection';
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';

package/dist/esm/eventDispatchers/touchEventHandlers/touchStartActivate.js

@@ -1,4 +1,4 @@
-import { state } from '../../store';
+import { state } from '../../store/state';
 import { setAnnotationSelected } from '../../stateManagement/annotation/annotationSelection';
 import getActiveToolForTouchEvent from '../shared/getActiveToolForTouchEvent';
 export default function touchStartActivate(evt) {

package/dist/esm/eventListeners/annotations/annotationSelectionListener.js

@@ -1,5 +1,5 @@
 import { getRenderingEngines } from '@cornerstonejs/core';
-import { triggerAnnotationRenderForViewportIds } from '../../utilities';
+import { triggerAnnotationRenderForViewportIds } from '../../utilities/triggerAnnotationRenderForViewportIds';
 function annotationSelectionListener(evt) {
     const deselectedAnnotation = evt.detail.removed;
     if (!deselectedAnnotation.length) {

package/dist/esm/eventListeners/annotations/contourSegmentation/contourSegmentationCompleted.js

@@ -1,19 +1,20 @@
 import { getEnabledElement, utilities as csUtils } from '@cornerstonejs/core';
 import getViewportsForAnnotation from '../../../utilities/getViewportsForAnnotation';
-import { math, triggerAnnotationRenderForViewportIds, } from '../../../utilities';
+import * as math from '../../../utilities/math';
+import triggerAnnotationRenderForViewportIds from '../../../utilities/triggerAnnotationRenderForViewportIds';
 import { getViewportIdsWithToolToRender } from '../../../utilities/viewportFilters';
 import { addAnnotation, removeAnnotation, getAllAnnotations, getChildAnnotations, addChildAnnotation, clearParentAnnotation, } from '../../../stateManagement/annotation/annotationState';
-import * as contourUtils from '../../../utilities/contours';
-import * as contourSegUtils from '../../../utilities/contourSegmentation';
-import { ToolGroupManager, hasTool as cstHasTool } from '../../../store';
-import { PlanarFreehandContourSegmentationTool } from '../../../tools';
 import { ContourWindingDirection } from '../../../types/ContourAnnotation';
 import { triggerAnnotationModified } from '../../../stateManagement/annotation/helpers/state';
-const DEFAULT_CONTOUR_SEG_TOOLNAME = 'PlanarFreehandContourSegmentationTool';
+import updateContourPolyline from '../../../utilities/contours/updateContourPolyline';
+import { addContourSegmentationAnnotation, areSameSegment, isContourSegmentationAnnotation, removeContourSegmentationAnnotation, } from '../../../utilities/contourSegmentation';
+import { getToolGroupForViewport } from '../../../store/ToolGroupManager';
+import { hasTool, hasToolByName } from '../../../store/addTool';
+const DEFAULT_CONTOUR_SEG_TOOL_NAME = 'PlanarFreehandContourSegmentationTool';
 export default async function contourSegmentationCompletedListener(evt) {
     const sourceAnnotation = evt.detail
         .annotation;
-    if (!contourSegUtils.isContourSegmentationAnnotation(sourceAnnotation)) {
+    if (!isContourSegmentationAnnotation(sourceAnnotation)) {
         return;
     }
     const viewport = getViewport(sourceAnnotation);
@@ -39,8 +40,8 @@ export default async function contourSegmentationCompletedListener(evt) {
     }
 }
 function isFreehandContourSegToolRegisteredForViewport(viewport, silent = false) {
-    const { toolName } = PlanarFreehandContourSegmentationTool;
-    const toolGroup = ToolGroupManager.getToolGroupForViewport(viewport.id, viewport.renderingEngineId);
+    const toolName = 'PlanarFreehandContourSegmentationTool';
+    const toolGroup = getToolGroupForViewport(viewport.id, viewport.renderingEngineId);
     let errorMessage;
     if (!toolGroup.hasTool(toolName)) {
         errorMessage = `Tool ${toolName} not added to ${toolGroup.id} toolGroup`;
@@ -71,8 +72,8 @@ function getValidContourSegmentationAnnotations(viewport, sourceAnnotation) {
     const allAnnotations = getAllAnnotations();
     return allAnnotations.filter((targetAnnotation) => targetAnnotation.annotationUID &&
         targetAnnotation.annotationUID !== sourceAnnotationUID &&
-        contourSegUtils.isContourSegmentationAnnotation(targetAnnotation) &&
-        contourSegUtils.areSameSegment(targetAnnotation, sourceAnnotation) &&
+        isContourSegmentationAnnotation(targetAnnotation) &&
+        areSameSegment(targetAnnotation, sourceAnnotation) &&
         viewport.isReferenceViewable(targetAnnotation.metadata));
 }
 function findIntersectingContour(viewport, sourcePolyline, contourSegmentationAnnotations) {
@@ -96,16 +97,16 @@ export function createPolylineHole(viewport, targetAnnotation, holeAnnotation) {
     const { windingDirection: targetWindingDirection } = targetAnnotation.data.contour;
     const { windingDirection: holeWindingDirection } = holeAnnotation.data.contour;
     addChildAnnotation(targetAnnotation, holeAnnotation);
-    contourSegUtils.removeContourSegmentationAnnotation(holeAnnotation);
+    removeContourSegmentationAnnotation(holeAnnotation);
     const { contour: holeContour } = holeAnnotation.data;
     const holePolyline = convertContourPolylineToCanvasSpace(holeContour.polyline, viewport);
-    contourUtils.updateContourPolyline(holeAnnotation, {
+    updateContourPolyline(holeAnnotation, {
         points: holePolyline,
         closed: holeContour.closed,
     }, viewport);
     const { element } = viewport;
     const updatedToolNames = new Set([
-        DEFAULT_CONTOUR_SEG_TOOLNAME,
+        DEFAULT_CONTOUR_SEG_TOOL_NAME,
         targetAnnotation.metadata.toolName,
         holeAnnotation.metadata.toolName,
     ]);
@@ -121,8 +122,8 @@ function getContourHolesData(viewport, annotation) {
     });
 }
 function combinePolylines(viewport, targetAnnotation, targetPolyline, sourceAnnotation, sourcePolyline) {
-    if (!cstHasTool(PlanarFreehandContourSegmentationTool)) {
-        console.warn(`${PlanarFreehandContourSegmentationTool.toolName} is not registered in cornerstone`);
+    if (!hasToolByName(DEFAULT_CONTOUR_SEG_TOOL_NAME)) {
+        console.warn(`${DEFAULT_CONTOUR_SEG_TOOL_NAME} is not registered in cornerstone`);
         return;
     }
     if (!isFreehandContourSegToolRegisteredForViewport(viewport)) {
@@ -176,7 +177,7 @@ function combinePolylines(viewport, targetAnnotation, targetPolyline, sourceAnno
         const newAnnotation = {
             metadata: {
                 ...metadata,
-                toolName: DEFAULT_CONTOUR_SEG_TOOLNAME,
+                toolName: DEFAULT_CONTOUR_SEG_TOOL_NAME,
                 originalToolName: metadata.originalToolName || metadata.toolName,
             },
             data: {
@@ -202,13 +203,13 @@ function combinePolylines(viewport, targetAnnotation, targetPolyline, sourceAnno
             interpolationUID: targetAnnotation.interpolationUID,
             interpolationCompleted: targetAnnotation.interpolationCompleted,
         };
-        contourUtils.updateContourPolyline(newAnnotation, {
+        updateContourPolyline(newAnnotation, {
             points: polyline,
             closed: true,
             targetWindingDirection: ContourWindingDirection.Clockwise,
         }, viewport);
         addAnnotation(newAnnotation, element);
-        contourSegUtils.addContourSegmentationAnnotation(newAnnotation);
+        addContourSegmentationAnnotation(newAnnotation);
         triggerAnnotationModified(newAnnotation, viewport.element);
         reassignedContourHolesMap
             .get(polyline)
@@ -220,7 +221,7 @@ function updateViewports(enabledElement, targetAnnotation, sourceAnnotation) {
     const { viewport } = enabledElement;
     const { element } = viewport;
     const updatedTtoolNames = new Set([
-        DEFAULT_CONTOUR_SEG_TOOLNAME,
+        DEFAULT_CONTOUR_SEG_TOOL_NAME,
         targetAnnotation.metadata.toolName,
         sourceAnnotation.metadata.toolName,
     ]);

package/dist/esm/eventListeners/segmentation/imageChangeEventListener.js

@@ -2,8 +2,10 @@ import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
 import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 import { BaseVolumeViewport, getEnabledElement, Enums, getEnabledElementByIds, cache, utilities, } from '@cornerstonejs/core';
 import Representations from '../../enums/SegmentationRepresentations';
-import * as SegmentationState from '../../stateManagement/segmentation/segmentationState';
-import { triggerSegmentationRender } from '../../utilities/segmentation/triggerSegmentationRender';
+import { triggerSegmentationRender } from '../../stateManagement/segmentation/SegmentationRenderingEngine';
+import { getSegmentationRepresentations } from '../../stateManagement/segmentation/getSegmentationRepresentations';
+import { updateLabelmapSegmentationImageReferences } from '../../stateManagement/segmentation/updateLabelmapSegmentationImageReferences';
+import { getCurrentLabelmapImageIdForViewport } from '../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
 const enable = function (element) {
     const { viewport } = getEnabledElement(element);
     if (viewport instanceof BaseVolumeViewport) {
@@ -21,7 +23,7 @@ function _imageChangeEventListener(evt) {
     const eventData = evt.detail;
     const { viewportId, renderingEngineId } = eventData;
     const { viewport } = getEnabledElementByIds(viewportId, renderingEngineId);
-    const segmentationRepresentations = SegmentationState.getSegmentationRepresentations(viewportId);
+    const segmentationRepresentations = getSegmentationRepresentations(viewportId);
     if (!segmentationRepresentations?.length) {
         return;
     }
@@ -32,12 +34,12 @@ function _imageChangeEventListener(evt) {
     const actors = viewport.getActors();
     labelmapRepresentations.forEach((representation) => {
         const { segmentationId } = representation;
-        const labelmapImageId = SegmentationState.updateLabelmapSegmentationImageReferences(viewportId, segmentationId);
+        const labelmapImageId = updateLabelmapSegmentationImageReferences(viewportId, segmentationId);
     });
     const allLabelmapActors = actors.filter((actor) => labelmapRepresentations.some((representation) => representation.segmentationRepresentationUID === actor.uid));
     allLabelmapActors.forEach((actor) => {
         const validActor = labelmapRepresentations.find((representation) => {
-            const derivedImageId = SegmentationState.getCurrentLabelmapImageIdForViewport(viewportId, representation.segmentationId);
+            const derivedImageId = getCurrentLabelmapImageIdForViewport(viewportId, representation.segmentationId);
             return derivedImageId === actor.referencedId;
         });
         if (!validActor) {
@@ -47,7 +49,7 @@ function _imageChangeEventListener(evt) {
     labelmapRepresentations.forEach((representation) => {
         const { segmentationId } = representation;
         const currentImageId = viewport.getCurrentImageId();
-        const derivedImageId = SegmentationState.getCurrentLabelmapImageIdForViewport(viewportId, segmentationId);
+        const derivedImageId = getCurrentLabelmapImageIdForViewport(viewportId, segmentationId);
         if (!derivedImageId) {
             return;
         }

package/dist/esm/eventListeners/segmentation/segmentationDataModifiedEventListener.js

@@ -1,6 +1,6 @@
 import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
 import * as SegmentationState from '../../stateManagement/segmentation/segmentationState';
-import { triggerSegmentationRenderBySegmentationId } from '../../utilities/segmentation';
+import { triggerSegmentationRenderBySegmentationId } from '../../stateManagement/segmentation/SegmentationRenderingEngine';
 import onLabelmapSegmentationDataModified from './labelmap/onLabelmapSegmentationDataModified';
 const onSegmentationDataModified = function (evt) {
     const { segmentationId } = evt.detail;

package/dist/esm/eventListeners/segmentation/segmentationModifiedEventListener.js

@@ -1,5 +1,5 @@
 import {} from '../../stateManagement/segmentation/triggerSegmentationEvents';
-import { triggerSegmentationRenderBySegmentationId } from '../../utilities/segmentation';
+import { triggerSegmentationRenderBySegmentationId } from '../../stateManagement/segmentation/SegmentationRenderingEngine';
 const segmentationModifiedListener = function (evt) {
     const { segmentationId } = evt.detail;
     triggerSegmentationRenderBySegmentationId(segmentationId);

package/dist/esm/eventListeners/segmentation/segmentationRepresentationModifiedEventListener.js

@@ -1,5 +1,5 @@
 import { getSegmentationRepresentation } from '../../stateManagement/segmentation/segmentationState';
-import { triggerSegmentationRenderBySegmentationId } from '../../utilities/segmentation';
+import { triggerSegmentationRenderBySegmentationId } from '../../stateManagement/segmentation/SegmentationRenderingEngine';
 const segmentationRepresentationModifiedListener = function (evt) {
     const { segmentationRepresentationUID } = evt.detail;
     const segmentationRepresentation = getSegmentationRepresentation

package/dist/esm/eventListeners/segmentation/segmentationRepresentationRemovedEventListener.js

@@ -1,5 +1,5 @@
 import { getSegmentationRepresentation } from '../../stateManagement/segmentation/segmentationState';
-import { triggerSegmentationRenderBySegmentationId } from '../../utilities/segmentation';
+import { triggerSegmentationRenderBySegmentationId } from '../../stateManagement/segmentation/SegmentationRenderingEngine';
 const segmentationRepresentationRemovedEventListener = function (evt) {
     const { segmentationRepresentationUID } = evt.detail;
     const segmentation = getSegmentationRepresentation(segmentationRepresentationUID);

package/dist/esm/index.d.ts

@@ -1,5 +1,6 @@
 import { init, destroy } from './init';
-import { addTool, removeTool, state, ToolGroupManager, SynchronizerManager, Synchronizer, cancelActiveManipulations } from './store';
+import { addTool, removeTool, ToolGroupManager, SynchronizerManager, Synchronizer, cancelActiveManipulations } from './store';
+import { state } from './store/state';
 import * as CONSTANTS from './constants';
 import * as synchronizers from './synchronizers';
 import * as drawing from './drawingSvg';
@@ -8,7 +9,7 @@ import * as cursors from './cursors';
 import * as Types from './types';
 import * as annotation from './stateManagement/annotation';
 import * as segmentation from './stateManagement/segmentation';
-import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, PlanarRotateTool, StackScrollMouseWheelTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ReferenceLines, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool } from './tools';
+import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, PlanarRotateTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool } from './tools';
 import VideoRedactionTool from './tools/annotation/VideoRedactionTool';
 import * as Enums from './enums';
-export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, StackScrollMouseWheelTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ReferenceLines, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, SegmentSelectTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, };
+export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, SegmentSelectTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, };

package/dist/esm/index.js

@@ -1,5 +1,6 @@
 import { init, destroy } from './init';
-import { addTool, removeTool, state, ToolGroupManager, SynchronizerManager, Synchronizer, cancelActiveManipulations, } from './store';
+import { addTool, removeTool, ToolGroupManager, SynchronizerManager, Synchronizer, cancelActiveManipulations, } from './store';
+import { state } from './store/state';
 import * as CONSTANTS from './constants';
 import * as synchronizers from './synchronizers';
 import * as drawing from './drawingSvg';
@@ -8,7 +9,7 @@ import * as cursors from './cursors';
 import * as Types from './types';
 import * as annotation from './stateManagement/annotation';
 import * as segmentation from './stateManagement/segmentation';
-import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, PlanarRotateTool, StackScrollMouseWheelTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ReferenceLines, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, } from './tools';
+import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, PlanarRotateTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, } from './tools';
 import VideoRedactionTool from './tools/annotation/VideoRedactionTool';
 import * as Enums from './enums';
-export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, StackScrollMouseWheelTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ReferenceLines, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, SegmentSelectTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, };
+export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, SegmentSelectTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, };

package/dist/esm/init.js

@@ -1,12 +1,12 @@
 import { eventTarget, Enums } from '@cornerstonejs/core';
 import { getAnnotationManager } from './stateManagement/annotation/annotationState';
-import { getDefaultSegmentationStateManager } from './stateManagement/segmentation/segmentationState';
 import { Events as TOOLS_EVENTS } from './enums';
 import { addEnabledElement, removeEnabledElement } from './store';
 import { resetCornerstoneToolsState } from './store/state';
 import { annotationCompletedListener, annotationRemovedListener, annotationSelectionListener, annotationModifiedListener, segmentationDataModifiedEventListener, segmentationRepresentationModifiedEventListener, segmentationRepresentationRemovedEventListener, segmentationModifiedListener, } from './eventListeners';
 import { annotationInterpolationEventDispatcher } from './eventDispatchers';
 import * as ToolGroupManager from './store/ToolGroupManager';
+import { defaultSegmentationStateManager } from './stateManagement/segmentation/SegmentationStateManager';
 let csToolsInitialized = false;
 export function init(defaultConfiguration = {}) {
     if (csToolsInitialized) {
@@ -22,7 +22,7 @@ export function destroy() {
     ToolGroupManager.destroy();
     resetCornerstoneToolsState();
     const annotationManager = getAnnotationManager();
-    const segmentationStateManager = getDefaultSegmentationStateManager();
+    const segmentationStateManager = defaultSegmentationStateManager;
     annotationManager.restoreAnnotations({});
     segmentationStateManager.resetState();
     csToolsInitialized = false;

package/dist/esm/stateManagement/annotation/FrameOfReferenceSpecificAnnotationManager.js

@@ -1,6 +1,5 @@
 import { Enums, eventTarget, getEnabledElement, utilities, } from '@cornerstonejs/core';
 import { checkAndDefineIsLockedProperty } from './annotationLocking';
-import { checkAndDefineIsVisibleProperty } from './annotationVisibility';
 import { checkAndDefineTextBoxProperty, checkAndDefineCachedStatsProperty, } from './utilities/defineProperties';
 class FrameOfReferenceSpecificAnnotationManager {
     constructor(uid) {
@@ -93,7 +92,6 @@ class FrameOfReferenceSpecificAnnotationManager {
             }
             toolSpecificAnnotations.push(annotation);
             checkAndDefineIsLockedProperty(annotation);
-            checkAndDefineIsVisibleProperty(annotation);
             checkAndDefineTextBoxProperty(annotation);
             checkAndDefineCachedStatsProperty(annotation);
         };

package/dist/esm/stateManagement/annotation/annotationSelection.js

@@ -1,6 +1,6 @@
 import { eventTarget, triggerEvent } from '@cornerstonejs/core';
 import { Events } from '../../enums';
-import { getAnnotation } from './annotationState';
+import { getAnnotation } from './getAnnotation';
 const selectedAnnotationUIDs = new Set();
 function setAnnotationSelected(annotationUID, selected = true, preserveSelected = false) {
     if (selected) {

package/dist/esm/stateManagement/annotation/annotationState.d.ts

@@ -1,5 +1,6 @@
 import type { Annotations, Annotation } from '../../types/AnnotationTypes';
 import type { AnnotationGroupSelector } from '../../types';
+import { getAnnotation } from './getAnnotation';
 declare function getAnnotationManager(): import("./FrameOfReferenceSpecificAnnotationManager").default;
 declare function setAnnotationManager(annotationManager: any): void;
 declare function resetAnnotationManager(): void;
@@ -12,8 +13,7 @@ declare function getChildAnnotations(annotation: Annotation): Annotation[];
 declare function addAnnotation(annotation: Annotation, annotationGroupSelector: AnnotationGroupSelector): string;
 declare function getNumberOfAnnotations(toolName: string, annotationGroupSelector: AnnotationGroupSelector): number;
 declare function removeAnnotation(annotationUID: string): void;
-declare function getAnnotation(annotationUID: string): Annotation;
 declare function removeAllAnnotations(): void;
 declare function removeAnnotations(toolName: string, annotationGroupSelector: AnnotationGroupSelector): void;
 declare function invalidateAnnotation(annotation: Annotation): void;
-export { getAllAnnotations, getAnnotations, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, getNumberOfAnnotations, addAnnotation, getAnnotation, removeAnnotation, removeAnnotations, removeAllAnnotations, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, };
+export { getAllAnnotations, getAnnotations, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, getNumberOfAnnotations, addAnnotation, removeAnnotation, removeAnnotations, removeAllAnnotations, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, getAnnotation, };

package/dist/esm/stateManagement/annotation/annotationState.js

@@ -1,6 +1,8 @@
 import { utilities as csUtils } from '@cornerstonejs/core';
 import { defaultFrameOfReferenceSpecificAnnotationManager } from './FrameOfReferenceSpecificAnnotationManager';
+import { getAnnotation } from './getAnnotation';
 import { triggerAnnotationAddedForElement, triggerAnnotationAddedForFOR, triggerAnnotationRemoved, } from './helpers/state';
+import { checkAndDefineIsVisibleProperty } from './annotationVisibility';
 let defaultManager = defaultFrameOfReferenceSpecificAnnotationManager;
 function getAnnotationManager() {
     return defaultManager;
@@ -55,6 +57,7 @@ function addAnnotation(annotation, annotationGroupSelector) {
     if (!annotation.annotationUID) {
         annotation.annotationUID = csUtils.uuidv4();
     }
+    checkAndDefineIsVisibleProperty(annotation);
     const manager = getAnnotationManager();
     if (annotationGroupSelector instanceof HTMLDivElement) {
         const groupKey = manager.getGroupKey(annotationGroupSelector);
@@ -85,11 +88,6 @@ function removeAnnotation(annotationUID) {
     manager.removeAnnotation(annotationUID);
     triggerAnnotationRemoved({ annotation, annotationManagerUID: manager.uid });
 }
-function getAnnotation(annotationUID) {
-    const manager = getAnnotationManager();
-    const annotation = manager.getAnnotation(annotationUID);
-    return annotation;
-}
 function removeAllAnnotations() {
     const manager = getAnnotationManager();
     const removedAnnotations = manager.removeAllAnnotations();
@@ -120,4 +118,4 @@ function invalidateAnnotation(annotation) {
             : undefined;
     }
 }
-export { getAllAnnotations, getAnnotations, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, getNumberOfAnnotations, addAnnotation, getAnnotation, removeAnnotation, removeAnnotations, removeAllAnnotations, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, };
+export { getAllAnnotations, getAnnotations, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, getNumberOfAnnotations, addAnnotation, removeAnnotation, removeAnnotations, removeAllAnnotations, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, getAnnotation, };

package/dist/esm/stateManagement/annotation/annotationVisibility.js

@@ -1,7 +1,7 @@
 import { eventTarget, triggerEvent } from '@cornerstonejs/core';
-import { getAnnotation } from './annotationState';
 import { Events } from '../../enums';
 import { isAnnotationSelected, deselectAnnotation, } from './annotationSelection';
+import { getAnnotation } from './getAnnotation';
 const globalHiddenAnnotationUIDsSet = new Set();
 function setAnnotationVisibility(annotationUID, visible = true) {
     const detail = makeEventDetail();