@cornerstonejs/tools 2.0.0-beta.26 → 2.0.0-beta.28

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

@@ -2,6 +2,6 @@ import mouseEventListeners from './mouse';
 import touchEventListeners from './touch';
 import wheelEventListener from './wheel';
 import keyEventListener from './keyboard';
-import { segmentationDataModifiedEventListener, segmentationRepresentationModifiedEventListener, segmentationRepresentationRemovedEventListener, segmentationModifiedListener, imageChangeEventListener } from './segmentation';
+import { segmentationDataModifiedEventListener, segmentationModifiedListener, imageChangeEventListener } from './segmentation';
 import { annotationCompletedListener, annotationSelectionListener, annotationModifiedListener, annotationRemovedListener } from './annotations';
-export { mouseEventListeners, touchEventListeners, wheelEventListener, keyEventListener, segmentationRepresentationModifiedEventListener, segmentationModifiedListener, segmentationRepresentationRemovedEventListener, segmentationDataModifiedEventListener, imageChangeEventListener, annotationCompletedListener, annotationSelectionListener, annotationModifiedListener, annotationRemovedListener, };
+export { mouseEventListeners, touchEventListeners, wheelEventListener, keyEventListener, segmentationModifiedListener, segmentationDataModifiedEventListener, imageChangeEventListener, annotationCompletedListener, annotationSelectionListener, annotationModifiedListener, annotationRemovedListener, };

package/dist/esm/eventListeners/index.js

@@ -2,6 +2,6 @@ import mouseEventListeners from './mouse';
 import touchEventListeners from './touch';
 import wheelEventListener from './wheel';
 import keyEventListener from './keyboard';
-import { segmentationDataModifiedEventListener, segmentationRepresentationModifiedEventListener, segmentationRepresentationRemovedEventListener, segmentationModifiedListener, imageChangeEventListener, } from './segmentation';
+import { segmentationDataModifiedEventListener, segmentationModifiedListener, imageChangeEventListener, } from './segmentation';
 import { annotationCompletedListener, annotationSelectionListener, annotationModifiedListener, annotationRemovedListener, } from './annotations';
-export { mouseEventListeners, touchEventListeners, wheelEventListener, keyEventListener, segmentationRepresentationModifiedEventListener, segmentationModifiedListener, segmentationRepresentationRemovedEventListener, segmentationDataModifiedEventListener, imageChangeEventListener, annotationCompletedListener, annotationSelectionListener, annotationModifiedListener, annotationRemovedListener, };
+export { mouseEventListeners, touchEventListeners, wheelEventListener, keyEventListener, segmentationModifiedListener, segmentationDataModifiedEventListener, imageChangeEventListener, annotationCompletedListener, annotationSelectionListener, annotationModifiedListener, annotationRemovedListener, };

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

@@ -229,6 +229,14 @@ function _updateMouseEventsLastPoints(element, lastPoints) {
     };
 }
 function _getDeltaPoints(currentPoints, lastPoints) {
+    if (!currentPoints || !lastPoints) {
+        return {
+            page: [0, 0],
+            client: [0, 0],
+            canvas: [0, 0],
+            world: [0, 0, 0],
+        };
+    }
     return {
         page: _subtractPoints2D(currentPoints.page, lastPoints.page),
         client: _subtractPoints2D(currentPoints.client, lastPoints.client),

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

@@ -1,11 +1,12 @@
 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 { triggerSegmentationRender } from '../../stateManagement/segmentation/SegmentationRenderingEngine';
-import { getSegmentationRepresentations } from '../../stateManagement/segmentation/getSegmentationRepresentations';
 import { updateLabelmapSegmentationImageReferences } from '../../stateManagement/segmentation/updateLabelmapSegmentationImageReferences';
 import { getCurrentLabelmapImageIdForViewport } from '../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
+import { SegmentationRepresentations } from '../../enums';
+import { getLabelmapActorUID } from '../../stateManagement/segmentation/helpers/getSegmentationActor';
+import { getSegmentationRepresentations } from '../../stateManagement/segmentation/getSegmentationRepresentation';
 const enable = function (element) {
     const { viewport } = getEnabledElement(element);
     if (viewport instanceof BaseVolumeViewport) {
@@ -23,21 +24,26 @@ function _imageChangeEventListener(evt) {
     const eventData = evt.detail;
     const { viewportId, renderingEngineId } = eventData;
     const { viewport } = getEnabledElementByIds(viewportId, renderingEngineId);
-    const segmentationRepresentations = getSegmentationRepresentations(viewportId);
-    if (!segmentationRepresentations?.length) {
-        return;
-    }
-    const labelmapRepresentations = segmentationRepresentations.filter((representation) => representation.type === Representations.Labelmap);
-    if (!labelmapRepresentations.length) {
+    const representations = getSegmentationRepresentations(viewportId);
+    if (!representations?.length) {
         return;
     }
+    const labelmapRepresentations = representations.filter((representation) => representation.type === SegmentationRepresentations.Labelmap);
     const actors = viewport.getActors();
     labelmapRepresentations.forEach((representation) => {
         const { segmentationId } = representation;
-        const labelmapImageId = updateLabelmapSegmentationImageReferences(viewportId, segmentationId);
+        updateLabelmapSegmentationImageReferences(viewportId, segmentationId);
     });
-    const allLabelmapActors = actors.filter((actor) => labelmapRepresentations.some((representation) => representation.segmentationRepresentationUID === actor.uid));
-    allLabelmapActors.forEach((actor) => {
+    const labelmapActors = labelmapRepresentations
+        .map((representation) => {
+        const actorUID = getLabelmapActorUID(representation.segmentationId);
+        return actors.find((actor) => actor.uid === actorUID);
+    })
+        .filter((actor) => actor !== undefined);
+    if (!labelmapActors.length) {
+        return;
+    }
+    labelmapActors.forEach((actor) => {
         const validActor = labelmapRepresentations.find((representation) => {
             const derivedImageId = getCurrentLabelmapImageIdForViewport(viewportId, representation.segmentationId);
             return derivedImageId === actor.referencedId;
@@ -82,7 +88,7 @@ function _imageChangeEventListener(evt) {
             viewport.addImages([
                 {
                     imageId: derivedImageId,
-                    actorUID: representation.segmentationRepresentationUID,
+                    actorUID: getLabelmapActorUID(segmentationId),
                     callback: ({ imageActor }) => {
                         imageActor.getMapper().setInputData(imageData);
                     },

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

@@ -1,6 +1,4 @@
-import segmentationRepresentationModifiedEventListener from './segmentationRepresentationModifiedEventListener';
 import segmentationDataModifiedEventListener from './segmentationDataModifiedEventListener';
-import segmentationRepresentationRemovedEventListener from './segmentationRepresentationRemovedEventListener';
 import segmentationModifiedListener from './segmentationModifiedEventListener';
 import imageChangeEventListener from './imageChangeEventListener';
-export { segmentationRepresentationModifiedEventListener, segmentationDataModifiedEventListener, segmentationRepresentationRemovedEventListener, segmentationModifiedListener, imageChangeEventListener, };
+export { segmentationDataModifiedEventListener, segmentationModifiedListener, imageChangeEventListener, };

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

@@ -1,6 +1,4 @@
-import segmentationRepresentationModifiedEventListener from './segmentationRepresentationModifiedEventListener';
 import segmentationDataModifiedEventListener from './segmentationDataModifiedEventListener';
-import segmentationRepresentationRemovedEventListener from './segmentationRepresentationRemovedEventListener';
 import segmentationModifiedListener from './segmentationModifiedEventListener';
 import imageChangeEventListener from './imageChangeEventListener';
-export { segmentationRepresentationModifiedEventListener, segmentationDataModifiedEventListener, segmentationRepresentationRemovedEventListener, segmentationModifiedListener, imageChangeEventListener, };
+export { segmentationDataModifiedEventListener, segmentationModifiedListener, imageChangeEventListener, };

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

@@ -1,8 +1,10 @@
 import { cache, utilities as csUtils, VolumeViewport, getEnabledElementByViewportId, StackViewport, } from '@cornerstonejs/core';
 import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
+import { getSegmentationActor } from '../../../stateManagement/segmentation/helpers';
+import { SegmentationRepresentations } from '../../../enums';
 const onLabelmapSegmentationDataModified = function (evt) {
     const { segmentationId, modifiedSlicesToUse } = evt.detail;
-    const { representationData, type } = SegmentationState.getSegmentation(segmentationId);
+    const { representationData } = SegmentationState.getSegmentation(segmentationId);
     const viewportIds = SegmentationState.getViewportIdsWithSegmentation(segmentationId);
     const hasVolumeViewport = viewportIds.some((viewportId) => {
         const { viewport } = getEnabledElementByViewportId(viewportId);
@@ -19,7 +21,7 @@ const onLabelmapSegmentationDataModified = function (evt) {
             performVolumeLabelmapUpdate({
                 modifiedSlicesToUse: hasBothStackAndVolume ? [] : modifiedSlicesToUse,
                 representationData,
-                type,
+                type: SegmentationRepresentations.Labelmap,
             });
         }
         if (viewport instanceof StackViewport) {
@@ -52,8 +54,9 @@ function performVolumeLabelmapUpdate({ modifiedSlicesToUse, representationData,
 }
 function performStackLabelmapUpdate({ viewportIds, segmentationId }) {
     viewportIds.forEach((viewportId) => {
-        const viewportSegReps = SegmentationState.getSegmentationRepresentations(viewportId);
-        viewportSegReps.forEach((representation) => {
+        let representations = SegmentationState.getSegmentationRepresentations(viewportId, { segmentationId });
+        representations = representations.filter((representation) => representation.type === SegmentationRepresentations.Labelmap);
+        representations.forEach((representation) => {
             if (representation.segmentationId !== segmentationId) {
                 return;
             }
@@ -65,12 +68,12 @@ function performStackLabelmapUpdate({ viewportIds, segmentationId }) {
             if (viewport instanceof VolumeViewport) {
                 return;
             }
-            const actorEntry = viewport.getActor(representation.segmentationRepresentationUID);
-            if (!actorEntry) {
-                return;
-            }
-            const segImageData = actorEntry.actor.getMapper().getInputData();
-            const currentSegmentationImageId = SegmentationState.getCurrentLabelmapImageIdForViewport(viewportId, representation.segmentationId);
+            const actor = getSegmentationActor(viewportId, {
+                segmentationId,
+                type: SegmentationRepresentations.Labelmap,
+            });
+            const segImageData = actor.getMapper().getInputData();
+            const currentSegmentationImageId = SegmentationState.getCurrentLabelmapImageIdForViewport(viewportId, segmentationId);
             const segmentationImage = cache.getImage(currentSegmentationImageId);
             segImageData.modified();
             csUtils.updateVTKImageDataWithCornerstoneImage(segImageData, segmentationImage);

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

@@ -1,11 +1,10 @@
-import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
 import { triggerSegmentationRenderBySegmentationId } from '../../stateManagement/segmentation/SegmentationRenderingEngine';
 import onLabelmapSegmentationDataModified from './labelmap/onLabelmapSegmentationDataModified';
 import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
 const onSegmentationDataModified = function (evt) {
     const { segmentationId } = evt.detail;
-    const { type } = getSegmentation(segmentationId);
-    if (type === SegmentationRepresentations.Labelmap) {
+    const { representationData } = getSegmentation(segmentationId);
+    if (representationData.Labelmap) {
         onLabelmapSegmentationDataModified(evt);
     }
     triggerSegmentationRenderBySegmentationId(segmentationId);

package/dist/esm/index.d.ts

@@ -9,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, 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 { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, PlanarRotateTool, 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, 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, };
+export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, 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

@@ -9,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, 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 { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, PlanarRotateTool, 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, 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, };
+export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, 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

@@ -3,7 +3,7 @@ import { getAnnotationManager } from './stateManagement/annotation/annotationSta
 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 { annotationCompletedListener, annotationRemovedListener, annotationSelectionListener, annotationModifiedListener, segmentationDataModifiedEventListener, segmentationModifiedListener, } from './eventListeners';
 import { annotationInterpolationEventDispatcher } from './eventDispatchers';
 import * as ToolGroupManager from './store/ToolGroupManager';
 import { defaultSegmentationStateManager } from './stateManagement/segmentation/SegmentationStateManager';
@@ -51,8 +51,6 @@ function _addCornerstoneToolsEventListeners() {
     eventTarget.addEventListener(TOOLS_EVENTS.ANNOTATION_REMOVED, annotationRemovedListener);
     eventTarget.addEventListener(TOOLS_EVENTS.SEGMENTATION_MODIFIED, segmentationModifiedListener);
     eventTarget.addEventListener(TOOLS_EVENTS.SEGMENTATION_DATA_MODIFIED, segmentationDataModifiedEventListener);
-    eventTarget.addEventListener(TOOLS_EVENTS.SEGMENTATION_REPRESENTATION_MODIFIED, segmentationRepresentationModifiedEventListener);
-    eventTarget.addEventListener(TOOLS_EVENTS.SEGMENTATION_REPRESENTATION_REMOVED, segmentationRepresentationRemovedEventListener);
 }
 function _removeCornerstoneToolsEventListeners() {
     eventTarget.removeEventListener(TOOLS_EVENTS.ANNOTATION_COMPLETED, annotationCompletedListener);
@@ -61,7 +59,5 @@ function _removeCornerstoneToolsEventListeners() {
     eventTarget.removeEventListener(TOOLS_EVENTS.ANNOTATION_SELECTION_CHANGE, annotationSelectionListener);
     eventTarget.removeEventListener(TOOLS_EVENTS.SEGMENTATION_MODIFIED, segmentationModifiedListener);
     eventTarget.removeEventListener(TOOLS_EVENTS.SEGMENTATION_DATA_MODIFIED, segmentationDataModifiedEventListener);
-    eventTarget.removeEventListener(TOOLS_EVENTS.SEGMENTATION_REPRESENTATION_MODIFIED, segmentationRepresentationModifiedEventListener);
-    eventTarget.removeEventListener(TOOLS_EVENTS.SEGMENTATION_REPRESENTATION_REMOVED, segmentationRepresentationRemovedEventListener);
 }
 export default init;

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

@@ -4,6 +4,7 @@ import type { Types } from '@cornerstonejs/core';
 declare class FrameOfReferenceSpecificAnnotationManager implements IAnnotationManager {
     private annotations;
     readonly uid: string;
+    private preprocessingFn;
     constructor(uid?: string);
     getGroupKey: (annotationGroupSelector: AnnotationGroupSelector) => string;
     _imageVolumeModifiedHandler: (evt: Types.EventTypes.ImageVolumeModifiedEvent) => void;
@@ -19,6 +20,7 @@ declare class FrameOfReferenceSpecificAnnotationManager implements IAnnotationMa
     getAllAnnotations: () => Annotations;
     getNumberOfAllAnnotations: () => number;
     removeAllAnnotations: () => Annotations;
+    setPreprocessingFn(preprocessingFn: (annotation: Annotation) => Annotation): void;
 }
 declare const defaultFrameOfReferenceSpecificAnnotationManager: FrameOfReferenceSpecificAnnotationManager;
 export { defaultFrameOfReferenceSpecificAnnotationManager };

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

@@ -1,6 +1,4 @@
 import { Enums, eventTarget, getEnabledElement, utilities, } from '@cornerstonejs/core';
-import { checkAndDefineIsLockedProperty } from './annotationLocking';
-import { checkAndDefineTextBoxProperty, checkAndDefineCachedStatsProperty, } from './utilities/defineProperties';
 class FrameOfReferenceSpecificAnnotationManager {
     constructor(uid) {
         this.getGroupKey = (annotationGroupSelector) => {
@@ -90,10 +88,10 @@ class FrameOfReferenceSpecificAnnotationManager {
                 frameOfReferenceSpecificAnnotations[toolName] = [];
                 toolSpecificAnnotations = frameOfReferenceSpecificAnnotations[toolName];
             }
+            if (this.preprocessingFn) {
+                annotation = this.preprocessingFn(annotation);
+            }
             toolSpecificAnnotations.push(annotation);
-            checkAndDefineIsLockedProperty(annotation);
-            checkAndDefineTextBoxProperty(annotation);
-            checkAndDefineCachedStatsProperty(annotation);
         };
         this.removeAnnotation = (annotationUID) => {
             const { annotations } = this;
@@ -203,6 +201,9 @@ class FrameOfReferenceSpecificAnnotationManager {
         this.uid = uid;
         eventTarget.addEventListener(Enums.Events.IMAGE_VOLUME_MODIFIED, this._imageVolumeModifiedHandler);
     }
+    setPreprocessingFn(preprocessingFn) {
+        this.preprocessingFn = preprocessingFn;
+    }
 }
 const defaultFrameOfReferenceSpecificAnnotationManager = new FrameOfReferenceSpecificAnnotationManager('DEFAULT');
 export { defaultFrameOfReferenceSpecificAnnotationManager };

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

@@ -2,8 +2,18 @@ import { utilities as csUtils } from '@cornerstonejs/core';
 import { defaultFrameOfReferenceSpecificAnnotationManager } from './FrameOfReferenceSpecificAnnotationManager';
 import { getAnnotation } from './getAnnotation';
 import { triggerAnnotationAddedForElement, triggerAnnotationAddedForFOR, triggerAnnotationRemoved, } from './helpers/state';
+import { checkAndDefineIsLockedProperty } from './annotationLocking';
+import { checkAndDefineCachedStatsProperty, checkAndDefineTextBoxProperty, } from './utilities/defineProperties';
 import { checkAndDefineIsVisibleProperty } from './annotationVisibility';
 let defaultManager = defaultFrameOfReferenceSpecificAnnotationManager;
+const preprocessingFn = (annotation) => {
+    checkAndDefineIsLockedProperty(annotation);
+    checkAndDefineTextBoxProperty(annotation);
+    checkAndDefineIsVisibleProperty(annotation);
+    checkAndDefineCachedStatsProperty(annotation);
+    return annotation;
+};
+defaultManager.setPreprocessingFn(preprocessingFn);
 function getAnnotationManager() {
     return defaultManager;
 }
@@ -57,7 +67,6 @@ 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);
@@ -65,7 +74,7 @@ function addAnnotation(annotation, annotationGroupSelector) {
         triggerAnnotationAddedForElement(annotation, annotationGroupSelector);
     }
     else {
-        manager.addAnnotation(annotation);
+        manager.addAnnotation(annotation, undefined);
         triggerAnnotationAddedForFOR(annotation);
     }
     return annotation.annotationUID;

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

@@ -15,7 +15,4 @@ import { setAnnotationManager } from './annotation/annotationState';
 import { getAnnotationManager } from './annotation/annotationState';
 import { resetAnnotationManager } from './annotation/annotationState';
 import { invalidateAnnotation } from './annotation/annotationState';
-import { addSegmentationRepresentations } from './segmentation/addSegmentationRepresentations';
-import { addMultiViewportSegmentationRepresentations } from './segmentation/addSegmentationRepresentations';
-import removeSegmentationRepresentations from './segmentation/removeSegmentationRepresentations';
-export { FrameOfReferenceSpecificAnnotationManager, defaultFrameOfReferenceSpecificAnnotationManager, annotationLocking, annotationSelection, getAnnotations, addAnnotation, getNumberOfAnnotations, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, addSegmentationRepresentations, addMultiViewportSegmentationRepresentations, removeSegmentationRepresentations };
+export { FrameOfReferenceSpecificAnnotationManager, defaultFrameOfReferenceSpecificAnnotationManager, annotationLocking, annotationSelection, getAnnotations, addAnnotation, getNumberOfAnnotations, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation };

package/dist/esm/stateManagement/index.js

@@ -2,6 +2,4 @@ import FrameOfReferenceSpecificAnnotationManager, { defaultFrameOfReferenceSpeci
 import * as annotationLocking from './annotation/annotationLocking';
 import * as annotationSelection from './annotation/annotationSelection';
 import { getAnnotations, addAnnotation, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, getNumberOfAnnotations, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, } from './annotation/annotationState';
-import { addSegmentationRepresentations, addMultiViewportSegmentationRepresentations, } from './segmentation/addSegmentationRepresentations';
-import removeSegmentationRepresentations from './segmentation/removeSegmentationRepresentations';
-export { FrameOfReferenceSpecificAnnotationManager, defaultFrameOfReferenceSpecificAnnotationManager, annotationLocking, annotationSelection, getAnnotations, addAnnotation, getNumberOfAnnotations, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, addSegmentationRepresentations, addMultiViewportSegmentationRepresentations, removeSegmentationRepresentations, };
+export { FrameOfReferenceSpecificAnnotationManager, defaultFrameOfReferenceSpecificAnnotationManager, annotationLocking, annotationSelection, getAnnotations, addAnnotation, getNumberOfAnnotations, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, };

package/dist/esm/stateManagement/segmentation/SegmentationRenderingEngine.js

@@ -1,7 +1,7 @@
 import { triggerEvent, eventTarget, Enums, getRenderingEngines, getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import { SegmentationRepresentations, Events as csToolsEvents, } from '../../enums';
 import Representations from '../../enums/SegmentationRepresentations';
-import { getSegmentationRepresentations } from './getSegmentationRepresentations';
+import { getSegmentationRepresentations } from './getSegmentationRepresentation';
 import surfaceDisplay from '../../tools/displayTools/Surface/surfaceDisplay';
 import contourDisplay from '../../tools/displayTools/Contour/contourDisplay';
 import labelmapDisplay from '../../tools/displayTools/Labelmap/labelmapDisplay';
@@ -50,15 +50,15 @@ class SegmentationRenderingEngine {
         const viewportIds = [];
         for (const viewport of viewports) {
             const viewportId = viewport.id;
-            const segmentationRepresentations = getSegmentationRepresentations(viewportId);
             if (segmentationId) {
-                const hasSegmentationRepresentation = segmentationRepresentations.some((representation) => representation.segmentationId === segmentationId);
-                if (hasSegmentationRepresentation) {
+                const segmentationRepresentations = getSegmentationRepresentations(viewportId, { segmentationId });
+                if (segmentationRepresentations?.length > 0) {
                     viewportIds.push(viewportId);
                 }
             }
             else {
-                if (segmentationRepresentations.length > 0) {
+                const segmentationRepresentations = getSegmentationRepresentations(viewportId);
+                if (segmentationRepresentations?.length > 0) {
                     viewportIds.push(viewportId);
                 }
             }
@@ -87,7 +87,10 @@ class SegmentationRenderingEngine {
         if (!segmentationRepresentations?.length) {
             return;
         }
-        const { viewport } = getEnabledElementByViewportId(viewportId);
+        const { viewport } = getEnabledElementByViewportId(viewportId) || {};
+        if (!viewport) {
+            return;
+        }
         const viewportRenderList = [];
         const segmentationRenderList = segmentationRepresentations.map((representation) => {
             if (representation.type === SegmentationRepresentations.Contour) {

package/dist/esm/stateManagement/segmentation/SegmentationStateManager.d.ts

@@ -1,47 +1,65 @@
 import type { Types } from '@cornerstonejs/core';
-import type { GlobalConfig, RepresentationConfig, Segmentation, SegmentationRepresentation, SegmentationState } from '../../types/SegmentationStateTypes';
+import { SegmentationRepresentations } from '../../enums';
+import type { RenderingConfig, Segmentation, SegmentationRepresentation, SegmentationState } from '../../types/SegmentationStateTypes';
 export default class SegmentationStateManager {
     private state;
     readonly uid: string;
     private _stackLabelmapImageIdReferenceMap;
     constructor(uid?: string);
-    getState(): SegmentationState;
+    getState(): Readonly<SegmentationState>;
+    private updateState;
     getColorLUT(lutIndex: number): Types.ColorLUT | undefined;
     getNextColorLUTIndex(): number;
     resetState(): void;
     getSegmentation(segmentationId: string): Segmentation | undefined;
     addSegmentation(segmentation: Segmentation): void;
     removeSegmentation(segmentationId: string): void;
-    getSegmentationRepresentation(segmentationRepresentationUID: string): SegmentationRepresentation | undefined;
-    addSegmentationRepresentationState(segmentationRepresentation: SegmentationRepresentation): void;
-    addSegmentationRepresentationToViewport(viewportId: string, segmentationRepresentationUID: string): void;
-    _updateLabelmapSegmentationReferences(segmentationId: any, stackViewport: any, labelmapImageIds: any, updateCallback: any): string;
+    addSegmentationRepresentation(viewportId: string, segmentationId: string, type: SegmentationRepresentations, renderingConfig: RenderingConfig): void;
+    private addDefaultSegmentationRepresentation;
+    addLabelmapRepresentation(state: SegmentationState, viewportId: string, segmentationId: string, renderingConfig?: RenderingConfig): void;
+    processLabelmapRepresentationAddition(viewportId: string, segmentationId: string): void;
+    _updateLabelmapSegmentationReferences(segmentationId: any, viewport: any, labelmapImageIds: any, updateCallback: any): string;
     updateLabelmapSegmentationImageReferences(viewportId: any, segmentationId: any): string;
     _updateAllLabelmapSegmentationImageReferences(viewportId: any, segmentationId: any): void;
     private getLabelmapImageIds;
     getCurrentLabelmapImageIdForViewport(viewportId: string, segmentationId: string): string | undefined;
     getStackSegmentationImageIdsForViewport(viewportId: string, segmentationId: string): string[];
-    getSegmentationRepresentations(viewportId: string): SegmentationRepresentation[];
-    removeRepresentation(segmentationRepresentationUID: string): void;
-    setActiveSegmentationRepresentation(viewportId: string, segmentationRepresentationUID: string): void;
-    getActiveSegmentationRepresentation(viewportId: string): SegmentationRepresentation | undefined;
-    getGlobalConfig(): GlobalConfig;
-    setGlobalConfig(config: GlobalConfig): void;
-    _getRepresentationConfig(segmentationRepresentationUID: string): {
-        allSegments?: RepresentationConfig;
-        perSegment?: RepresentationConfig;
-    };
-    getSegmentationRepresentationConfig(segmentationRepresentationUID: string): RepresentationConfig;
-    getPerSegmentConfig(segmentationRepresentationUID: string): RepresentationConfig;
-    setSegmentationRepresentationConfig(segmentationRepresentationUID: string, config: RepresentationConfig): void;
-    setPerSegmentConfig(segmentationRepresentationUID: string, config: RepresentationConfig): void;
-    getSegmentationRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string): boolean;
-    setSegmentationRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string, visible: boolean): void;
+    removeSegmentationRepresentations(viewportId: string, specifier?: {
+        segmentationId?: string;
+        type?: SegmentationRepresentations;
+    }): void;
+    removeSegmentationRepresentation(viewportId: string, specifier: {
+        segmentationId: string;
+        type: SegmentationRepresentations;
+    }): void;
+    _setActiveSegmentation(state: SegmentationState, viewportId: string, segmentationId: string): void;
+    setActiveSegmentation(viewportId: string, segmentationId: string): void;
+    getActiveSegmentation(viewportId: string): Segmentation | undefined;
+    getSegmentationRepresentations(viewportId: string, specifier?: {
+        segmentationId?: string;
+        type?: SegmentationRepresentations;
+    }): SegmentationRepresentation[];
+    getSegmentationRepresentation(viewportId: string, specifier: {
+        segmentationId: string;
+        type: SegmentationRepresentations;
+    }): SegmentationRepresentation | undefined;
+    getSegmentationRepresentationVisibility(viewportId: string, specifier: {
+        segmentationId: string;
+        type: SegmentationRepresentations;
+    }): boolean;
+    setSegmentationRepresentationVisibility(viewportId: string, specifier: {
+        segmentationId: string;
+        type: SegmentationRepresentations;
+    }, visible: boolean): void;
     addColorLUT(colorLUT: Types.ColorLUT, lutIndex: number): void;
     removeColorLUT(colorLUTIndex: number): void;
     _getStackIdForImageIds(imageIds: string[]): string;
+    getAllViewportSegmentationRepresentations(): Array<{
+        viewportId: string;
+        representations: SegmentationRepresentation[];
+    }>;
 }
-declare function computeVolumeSegmentationFromStack({ imageIds, options, }: {
+declare function internalComputeVolumeLabelmapFromStack({ imageIds, options, }: {
     imageIds: string[];
     options?: {
         volumeId?: string;
@@ -49,7 +67,7 @@ declare function computeVolumeSegmentationFromStack({ imageIds, options, }: {
 }): Promise<{
     volumeId: string;
 }>;
-declare function convertStackToVolumeSegmentation({ segmentationId, options, }: {
+declare function internalConvertStackToVolumeLabelmap({ segmentationId, options, }: {
     segmentationId: string;
     options?: {
         viewportId: string;
@@ -58,4 +76,4 @@ declare function convertStackToVolumeSegmentation({ segmentationId, options, }:
     };
 }): Promise<void>;
 declare const defaultSegmentationStateManager: SegmentationStateManager;
-export { convertStackToVolumeSegmentation, computeVolumeSegmentationFromStack, defaultSegmentationStateManager, };
+export { internalConvertStackToVolumeLabelmap, internalComputeVolumeLabelmapFromStack, defaultSegmentationStateManager, };