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

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.d.ts

@@ -1,2 +1,2 @@
-import { TouchDragEventType } from '../../types/EventTypes';
+import type { TouchDragEventType } from '../../types/EventTypes';
 export default function touchDrag(evt: TouchDragEventType): void;

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.d.ts

@@ -1,2 +1,2 @@
-import { EventTypes } from '../../types';
+import type { EventTypes } from '../../types';
 export default function touchStart(evt: EventTypes.TouchStartEventType): void;

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.d.ts

@@ -1,2 +1,2 @@
-import { EventTypes } from '../../types';
+import type { EventTypes } from '../../types';
 export default function touchStartActivate(evt: EventTypes.TouchStartActivateEventType): void;

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/annotationCompletedListener.d.ts

@@ -1,2 +1,2 @@
-import { AnnotationCompletedEventType } from '../../types/EventTypes';
+import type { AnnotationCompletedEventType } from '../../types/EventTypes';
 export default function annotationCompletedListener(evt: AnnotationCompletedEventType): void;

package/dist/esm/eventListeners/annotations/annotationRemovedListener.d.ts

@@ -1,2 +1,2 @@
-import { AnnotationRemovedEventType } from '../../types/EventTypes';
+import type { AnnotationRemovedEventType } from '../../types/EventTypes';
 export default function annotationRemovedListener(evt: AnnotationRemovedEventType): void;

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.d.ts

@@ -1,5 +1,5 @@
-import { Types } from '@cornerstonejs/core';
-import { ContourSegmentationAnnotation } from '../../../types/ContourSegmentationAnnotation';
-import { AnnotationCompletedEventType } from '../../../types/EventTypes';
+import type { Types } from '@cornerstonejs/core';
+import type { ContourSegmentationAnnotation } from '../../../types/ContourSegmentationAnnotation';
+import type { AnnotationCompletedEventType } from '../../../types/EventTypes';
 export default function contourSegmentationCompletedListener(evt: AnnotationCompletedEventType): Promise<void>;
 export declare function createPolylineHole(viewport: Types.IViewport, targetAnnotation: ContourSegmentationAnnotation, holeAnnotation: ContourSegmentationAnnotation): void;

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

@@ -1,19 +1,20 @@
-import { getEnabledElement, utilities as csUtils, } from '@cornerstonejs/core';
+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/mouse/getMouseEventPoints.d.ts

@@ -1,2 +1,2 @@
-import { IPoints } from '../../types';
+import type { IPoints } from '../../types';
 export default function getMouseEventPoints(evt: MouseEvent, element?: HTMLDivElement): IPoints;

package/dist/esm/eventListeners/mouse/getMouseEventPoints.js

@@ -1,7 +1,10 @@
 import { getEnabledElement } from '@cornerstonejs/core';
 export default function getMouseEventPoints(evt, element) {
     const elementToUse = element || evt.currentTarget;
-    const { viewport } = getEnabledElement(elementToUse);
+    const { viewport } = getEnabledElement(elementToUse) || {};
+    if (!viewport) {
+        return;
+    }
     const clientPoint = _clientToPoint(evt);
     const pagePoint = _pageToPoint(evt);
     const canvasPoint = _pagePointsToCanvasPoints(elementToUse, pagePoint);

package/dist/esm/eventListeners/mouse/mouseDownListener.js

@@ -1,5 +1,6 @@
 import { getEnabledElement, triggerEvent } from '@cornerstonejs/core';
 import Events from '../../enums/Events';
+import { MouseBindings } from '../../enums/ToolBindings';
 import mouseMoveListener from './mouseMoveListener';
 import getMouseEventPoints from './getMouseEventPoints';
 const { MOUSE_DOWN, MOUSE_DOWN_ACTIVATE, MOUSE_CLICK, MOUSE_UP, MOUSE_DRAG } = Events;
@@ -102,6 +103,10 @@ function _doMouseDown(evt) {
     }
 }
 function _onMouseDrag(evt) {
+    const enabledElement = getEnabledElement(state.element);
+    if (!enabledElement?.viewport) {
+        return;
+    }
     const currentPoints = getMouseEventPoints(evt, state.element);
     const lastPoints = _updateMouseEventsLastPoints(state.element, state.lastPoints);
     const deltaPoints = _getDeltaPoints(currentPoints, lastPoints);
@@ -211,7 +216,10 @@ function _copyPoints(points) {
     return JSON.parse(JSON.stringify(points));
 }
 function _updateMouseEventsLastPoints(element, lastPoints) {
-    const { viewport } = getEnabledElement(element);
+    const { viewport } = getEnabledElement(element) || {};
+    if (!viewport) {
+        return lastPoints;
+    }
     const world = viewport.canvasToWorld(lastPoints.canvas);
     return {
         page: lastPoints.page,

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.getRepresentationsForViewport(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.updateSegmentationImageReferences(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.getLabelmapImageIdsForViewport(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.getLabelmapImageIdsForViewport(viewportId, segmentationId);
+        const derivedImageId = getCurrentLabelmapImageIdForViewport(viewportId, segmentationId);
         if (!derivedImageId) {
             return;
         }
@@ -68,7 +70,7 @@ function _imageChangeEventListener(evt) {
             const scalarArray = vtkDataArray.newInstance({
                 name: 'Pixels',
                 numberOfComponents: 1,
-                values: [...derivedImage.getPixelData()],
+                values: [...derivedImage.voxelManager.getScalarData()],
             });
             const imageData = vtkImageData.newInstance();
             imageData.setDimensions(dimensions[0], dimensions[1], 1);

package/dist/esm/eventListeners/segmentation/labelmap/onLabelmapSegmentationDataModified.d.ts

@@ -1,3 +1,3 @@
-import { SegmentationDataModifiedEventType } from '../../../types/EventTypes';
+import type { SegmentationDataModifiedEventType } from '../../../types/EventTypes';
 declare const onLabelmapSegmentationDataModified: (evt: SegmentationDataModifiedEventType) => void;
 export default onLabelmapSegmentationDataModified;

package/dist/esm/eventListeners/segmentation/labelmap/onLabelmapSegmentationDataModified.js

@@ -16,7 +16,7 @@ const onLabelmapSegmentationDataModified = function (evt) {
             type,
         });
     }
-    const viewportIds = SegmentationState.getViewportIdsWithSegmentationId(segmentationId);
+    const viewportIds = SegmentationState.getViewportIdsWithSegmentation(segmentationId);
     if ('imageIds' in labelmapRepresentationData) {
         performStackLabelmapUpdate({
             viewportIds,
@@ -48,7 +48,7 @@ function performVolumeLabelmapUpdate({ modifiedSlicesToUse, representationData,
 }
 function performStackLabelmapUpdate({ viewportIds, segmentationId, representationData, type, }) {
     viewportIds.forEach((viewportId) => {
-        const viewportSegReps = SegmentationState.getRepresentationsForViewport(viewportId);
+        const viewportSegReps = SegmentationState.getSegmentationRepresentations(viewportId);
         viewportSegReps.forEach((representation) => {
             if (representation.segmentationId !== segmentationId) {
                 return;
@@ -66,7 +66,7 @@ function performStackLabelmapUpdate({ viewportIds, segmentationId, representatio
                 return;
             }
             const segImageData = actorEntry.actor.getMapper().getInputData();
-            const currentSegmentationImageId = SegmentationState.getLabelmapImageIdsForViewport(viewportId, representation.segmentationId);
+            const currentSegmentationImageId = SegmentationState.getCurrentLabelmapImageIdForViewport(viewportId, representation.segmentationId);
             const segmentationImage = cache.getImage(currentSegmentationImageId);
             segImageData.modified();
             csUtils.updateVTKImageDataWithCornerstoneImage(segImageData, segmentationImage);

package/dist/esm/eventListeners/segmentation/segmentationDataModifiedEventListener.d.ts

@@ -1,3 +1,3 @@
-import { SegmentationDataModifiedEventType } from '../../types/EventTypes';
+import type { SegmentationDataModifiedEventType } from '../../types/EventTypes';
 declare const onSegmentationDataModified: (evt: SegmentationDataModifiedEventType) => void;
 export default onSegmentationDataModified;

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

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

package/dist/esm/eventListeners/segmentation/segmentationModifiedEventListener.d.ts

@@ -1,3 +1,3 @@
-import { SegmentationModifiedEventType } from '../../types/EventTypes';
+import type { SegmentationModifiedEventType } from '../../types/EventTypes';
 declare const segmentationModifiedListener: (evt: SegmentationModifiedEventType) => void;
 export default segmentationModifiedListener;

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

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

package/dist/esm/eventListeners/segmentation/segmentationRepresentationModifiedEventListener.d.ts

@@ -1,3 +1,3 @@
-import { SegmentationRepresentationModifiedEventType } from '../../types/EventTypes';
+import type { SegmentationRepresentationModifiedEventType } from '../../types/EventTypes';
 declare const segmentationRepresentationModifiedListener: (evt: SegmentationRepresentationModifiedEventType) => void;
 export default segmentationRepresentationModifiedListener;

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

@@ -1,14 +1,14 @@
-import triggerSegmentationRender from '../../utilities/segmentation/triggerSegmentationRender';
-import { getRepresentation } from '../../stateManagement/segmentation/segmentationState';
+import { getSegmentationRepresentation } from '../../stateManagement/segmentation/segmentationState';
+import { triggerSegmentationRenderBySegmentationId } from '../../stateManagement/segmentation/SegmentationRenderingEngine';
 const segmentationRepresentationModifiedListener = function (evt) {
     const { segmentationRepresentationUID } = evt.detail;
-    const segmentationRepresentation = getRepresentation
-        ? getRepresentation(segmentationRepresentationUID)
+    const segmentationRepresentation = getSegmentationRepresentation
+        ? getSegmentationRepresentation(segmentationRepresentationUID)
         : null;
     if (!segmentationRepresentation) {
         return;
     }
     const segmentationId = segmentationRepresentation?.segmentationId;
-    triggerSegmentationRender(segmentationId);
+    triggerSegmentationRenderBySegmentationId(segmentationId);
 };
 export default segmentationRepresentationModifiedListener;

package/dist/esm/eventListeners/segmentation/segmentationRepresentationRemovedEventListener.d.ts

@@ -1,3 +1,3 @@
-import { SegmentationRepresentationRemovedEventType } from '../../types/EventTypes';
+import type { SegmentationRepresentationRemovedEventType } from '../../types/EventTypes';
 declare const segmentationRepresentationRemovedEventListener: (evt: SegmentationRepresentationRemovedEventType) => void;
 export default segmentationRepresentationRemovedEventListener;

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

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

package/dist/esm/eventListeners/touch/getTouchEventPoints.d.ts

@@ -1,2 +1,2 @@
-import { ITouchPoints } from '../../types';
+import type { ITouchPoints } from '../../types';
 export default function getTouchEventPoints(evt: TouchEvent, element?: HTMLDivElement): ITouchPoints[];

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, 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, 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 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, 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, 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, };

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, 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, 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 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, 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, 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, };

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/AnnotationRenderingEngine.d.ts

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