@cornerstonejs/tools 2.0.0-beta.16 → 2.0.0-beta.18

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

@@ -1,11 +1,11 @@
 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 { getToolGroupForViewport } from '../../store/ToolGroupManager';
 import Representations from '../../enums/SegmentationRepresentations';
 import * as SegmentationState from '../../stateManagement/segmentation/segmentationState';
 import { isVolumeSegmentation } from '../../tools/segmentation/strategies/utils/stackVolumeCheck';
 import triggerSegmentationRender from '../../utilities/segmentation/triggerSegmentationRender';
+import triggerSegmentationRenderForViewports from '../../utilities/segmentation/triggerSegmentationRenderForViewports';
 const enable = function (element) {
     const { viewport } = getEnabledElement(element);
     if (viewport instanceof BaseVolumeViewport) {
@@ -18,23 +18,20 @@ const disable = function (element) {
     element.removeEventListener(Enums.Events.STACK_NEW_IMAGE, _imageChangeEventListener);
     element.removeEventListener(Enums.Events.IMAGE_RENDERED, _imageChangeEventListener);
 };
-const perToolGroupManualTriggers = new Map();
+const perViewportManualTriggers = new Map();
 function _imageChangeEventListener(evt) {
     const eventData = evt.detail;
     const { viewportId, renderingEngineId } = eventData;
     const { viewport } = getEnabledElementByIds(viewportId, renderingEngineId);
-    const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
-    if (!toolGroup) {
+    const segmentationRepresentations = SegmentationState.getRepresentationsForViewport(viewportId);
+    if (!segmentationRepresentations?.length) {
         return;
     }
-    let toolGroupSegmentationRepresentations = SegmentationState.getSegmentationRepresentations(toolGroup.id) || [];
-    toolGroupSegmentationRepresentations =
-        toolGroupSegmentationRepresentations.filter((representation) => representation.type === Representations.Labelmap);
-    if (!toolGroupSegmentationRepresentations?.length) {
+    const labelmapRepresentations = segmentationRepresentations.filter((representation) => representation.type === Representations.Labelmap);
+    if (!labelmapRepresentations.length) {
         return;
     }
-    const segmentationRepresentations = {};
-    toolGroupSegmentationRepresentations.forEach((representation) => {
+    labelmapRepresentations.forEach((representation) => {
         const segmentation = SegmentationState.getSegmentation(representation.segmentationId);
         if (!segmentation || !segmentation.representationData?.LABELMAP) {
             return;
@@ -59,9 +56,9 @@ function _imageChangeEventListener(evt) {
         return true;
     });
     if (!segmentationFound) {
-        if (!perToolGroupManualTriggers.has(toolGroup.id)) {
-            perToolGroupManualTriggers.set(toolGroup.id, true);
-            triggerSegmentationRender(toolGroup.id);
+        if (!perViewportManualTriggers.has(viewportId)) {
+            perViewportManualTriggers.set(viewportId, true);
+            triggerSegmentationRenderForViewports([viewportId]);
         }
         return;
     }
@@ -121,7 +118,7 @@ function _imageChangeEventListener(evt) {
                     },
                 },
             ]);
-            triggerSegmentationRender(toolGroup.id);
+            triggerSegmentationRender();
             return;
         }
         if (segmentationImageData.setDerivedImage) {

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

@@ -1,10 +1,8 @@
-import { cache, getEnabledElementByIds, utilities as csUtils, VolumeViewport, } from '@cornerstonejs/core';
+import { cache, utilities as csUtils, VolumeViewport, getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
-import { getToolGroup } from '../../../store/ToolGroupManager';
 const onLabelmapSegmentationDataModified = function (evt) {
     const { segmentationId, modifiedSlicesToUse } = evt.detail;
     const { representationData, type } = SegmentationState.getSegmentation(segmentationId);
-    const toolGroupIds = SegmentationState.getToolGroupIdsWithSegmentation(segmentationId);
     const labelmapRepresentationData = representationData[type];
     if ('volumeId' in labelmapRepresentationData) {
         performVolumeLabelmapUpdate({
@@ -13,9 +11,10 @@ const onLabelmapSegmentationDataModified = function (evt) {
             type,
         });
     }
+    const viewportIds = SegmentationState.getViewportIdsWithSegmentationId(segmentationId);
     if ('imageIdReferenceMap' in labelmapRepresentationData) {
         performStackLabelmapUpdate({
-            toolGroupIds,
+            viewportIds,
             segmentationId,
             representationData,
             type,
@@ -42,32 +41,32 @@ function performVolumeLabelmapUpdate({ modifiedSlicesToUse, representationData,
     });
     imageData.modified();
 }
-function performStackLabelmapUpdate({ toolGroupIds, segmentationId, representationData, type, }) {
-    toolGroupIds.forEach((toolGroupId) => {
-        const toolGroupSegmentationRepresentations = SegmentationState.getSegmentationRepresentations(toolGroupId);
-        const toolGroup = getToolGroup(toolGroupId);
-        const viewportsInfo = toolGroup.getViewportsInfo();
-        toolGroupSegmentationRepresentations.forEach((representation) => {
+function performStackLabelmapUpdate({ viewportIds, segmentationId, representationData, type, }) {
+    viewportIds.forEach((viewportId) => {
+        const viewportSegReps = SegmentationState.getRepresentationsForViewport(viewportId);
+        viewportSegReps.forEach((representation) => {
             if (representation.segmentationId !== segmentationId) {
                 return;
             }
-            viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
-                const viewport = getEnabledElementByIds(viewportId, renderingEngineId).viewport;
-                if (viewport instanceof VolumeViewport) {
-                    return;
-                }
-                const actorEntry = viewport.getActor(representation.segmentationRepresentationUID);
-                if (!actorEntry) {
-                    return;
-                }
-                const currentImageId = viewport.getCurrentImageId();
-                const segImageData = actorEntry.actor.getMapper().getInputData();
-                const { imageIdReferenceMap } = representationData[type];
-                const currentSegmentationImageId = imageIdReferenceMap.get(currentImageId);
-                const segmentationImage = cache.getImage(currentSegmentationImageId);
-                segImageData.modified();
-                csUtils.updateVTKImageDataWithCornerstoneImage(segImageData, segmentationImage);
-            });
+            const enabledElement = getEnabledElementByViewportId(viewportId);
+            if (!enabledElement) {
+                return;
+            }
+            const { viewport } = enabledElement;
+            if (viewport instanceof VolumeViewport) {
+                return;
+            }
+            const actorEntry = viewport.getActor(representation.segmentationRepresentationUID);
+            if (!actorEntry) {
+                return;
+            }
+            const currentImageId = viewport.getCurrentImageId();
+            const segImageData = actorEntry.actor.getMapper().getInputData();
+            const { imageIdReferenceMap } = representationData[type];
+            const currentSegmentationImageId = imageIdReferenceMap.get(currentImageId);
+            const segmentationImage = cache.getImage(currentSegmentationImageId);
+            segImageData.modified();
+            csUtils.updateVTKImageDataWithCornerstoneImage(segImageData, segmentationImage);
         });
     });
 }

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

@@ -5,12 +5,9 @@ import onLabelmapSegmentationDataModified from './labelmap/onLabelmapSegmentatio
 const onSegmentationDataModified = function (evt) {
     const { segmentationId } = evt.detail;
     const { type } = SegmentationState.getSegmentation(segmentationId);
-    const toolGroupIds = SegmentationState.getToolGroupIdsWithSegmentation(segmentationId);
     if (type === SegmentationRepresentations.Labelmap) {
         onLabelmapSegmentationDataModified(evt);
     }
-    toolGroupIds.forEach((toolGroupId) => {
-        triggerSegmentationRender(toolGroupId);
-    });
+    triggerSegmentationRender(segmentationId);
 };
 export default onSegmentationDataModified;

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

@@ -1,15 +1,6 @@
-import { getToolGroupIdsWithSegmentation, getSegmentationRepresentations, } from '../../stateManagement/segmentation/segmentationState';
-import { triggerSegmentationRepresentationModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
+import { triggerSegmentationRender } from '../../utilities/segmentation';
 const segmentationModifiedListener = function (evt) {
     const { segmentationId } = evt.detail;
-    const toolGroupIds = getToolGroupIdsWithSegmentation(segmentationId);
-    toolGroupIds.forEach((toolGroupId) => {
-        const segRepresentations = getSegmentationRepresentations(toolGroupId);
-        segRepresentations.forEach((representation) => {
-            if (representation.segmentationId === segmentationId) {
-                triggerSegmentationRepresentationModified(toolGroupId, representation.segmentationRepresentationUID);
-            }
-        });
-    });
+    triggerSegmentationRender(segmentationId);
 };
 export default segmentationModifiedListener;

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

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

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

@@ -1,6 +1,6 @@
 import triggerSegmentationRender from '../../utilities/segmentation/triggerSegmentationRender';
 const segmentationRepresentationRemovedEventListener = function (evt) {
-    const { toolGroupId, segmentationRepresentationUID } = evt.detail;
-    triggerSegmentationRender(toolGroupId);
+    const { segmentationRepresentationUID } = evt.detail;
+    triggerSegmentationRender();
 };
 export default segmentationRepresentationRemovedEventListener;

package/dist/esm/index.d.ts

@@ -8,7 +8,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, SegmentationDisplayTool, 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, 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, SegmentationDisplayTool, 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, 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

@@ -8,7 +8,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, SegmentationDisplayTool, 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, 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, SegmentationDisplayTool, 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, 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/stateManagement/index.d.ts

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

package/dist/esm/stateManagement/index.js

@@ -2,5 +2,5 @@ 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, removeSegmentationsFromToolGroup, } from './segmentation';
-export { FrameOfReferenceSpecificAnnotationManager, defaultFrameOfReferenceSpecificAnnotationManager, annotationLocking, annotationSelection, getAnnotations, addAnnotation, getNumberOfAnnotations, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, addSegmentationRepresentations, removeSegmentationsFromToolGroup, };
+import { addRepresentations, removeRepresentationsFromViewport, } from './segmentation';
+export { FrameOfReferenceSpecificAnnotationManager, defaultFrameOfReferenceSpecificAnnotationManager, annotationLocking, annotationSelection, getAnnotations, addAnnotation, getNumberOfAnnotations, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, addRepresentations, removeRepresentationsFromViewport, };

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

@@ -1,36 +1,37 @@
 import type { Types } from '@cornerstonejs/core';
-import type { RepresentationConfig, Segmentation, SegmentationRepresentationConfig, SegmentationState, SegmentSpecificRepresentationConfig, ToolGroupSpecificRepresentation, ToolGroupSpecificRepresentations } from '../../types/SegmentationStateTypes';
+import type { RepresentationConfig, SegmentRepresentationConfig, Segmentation, SegmentationRepresentation, SegmentationRepresentationConfig, SegmentationState } from '../../types/SegmentationStateTypes';
 export default class SegmentationStateManager {
     private state;
     readonly uid: string;
     constructor(uid?: string);
     getState(): SegmentationState;
-    getToolGroups(): string[];
     getColorLUT(lutIndex: number): Types.ColorLUT | undefined;
     getNextColorLUTIndex(): number;
     resetState(): void;
     getSegmentation(segmentationId: string): Segmentation | undefined;
     addSegmentation(segmentation: Segmentation): void;
-    getSegmentationRepresentations(toolGroupId: string): ToolGroupSpecificRepresentations | undefined;
-    getAllSegmentationRepresentations(): Record<string, ToolGroupSpecificRepresentation[]>;
-    addSegmentationRepresentation(toolGroupId: string, segmentationRepresentation: ToolGroupSpecificRepresentation): void;
+    removeSegmentation(segmentationId: string): void;
+    getRepresentation(segmentationRepresentationUID: string): SegmentationRepresentation | undefined;
+    addRepresentation(segmentationRepresentation: SegmentationRepresentation): void;
+    addRepresentationToViewport(viewportId: string, segmentationRepresentationUID: string): void;
+    getRepresentationsForViewport(viewportId: string): SegmentationRepresentation[];
+    removeRepresentation(segmentationRepresentationUID: string): void;
+    setActiveRepresentation(viewportId: string, segmentationRepresentationUID: string): void;
+    getActiveRepresentation(viewportId: string): SegmentationRepresentation | undefined;
     getGlobalConfig(): SegmentationRepresentationConfig;
     setGlobalConfig(config: SegmentationRepresentationConfig): void;
-    getSegmentationRepresentationByUID(toolGroupId: string, segmentationRepresentationUID: string): ToolGroupSpecificRepresentation | undefined;
-    removeSegmentation(segmentationId: string): void;
-    removeSegmentationRepresentation(toolGroupId: string, segmentationRepresentationUID: string): void;
-    setActiveSegmentationRepresentation(toolGroupId: string, segmentationRepresentationUID: string): void;
-    getToolGroupSpecificConfig(toolGroupId: string): SegmentationRepresentationConfig | undefined;
-    getSegmentationRepresentationSpecificConfig(toolGroupId: string, segmentationRepresentationUID: string): RepresentationConfig;
-    setSegmentationRepresentationSpecificConfig(toolGroupId: string, segmentationRepresentationUID: string, config: RepresentationConfig): void;
-    getSegmentSpecificConfig(toolGroupId: string, segmentationRepresentationUID: string, segmentIndex: number): RepresentationConfig;
-    setSegmentSpecificConfig(toolGroupId: string, segmentationRepresentationUID: string, config: SegmentSpecificRepresentationConfig, options?: {
-        clear: false;
-    }): void;
-    setSegmentationRepresentationConfig(toolGroupId: string, config: SegmentationRepresentationConfig): void;
+    _getRepresentationConfig(segmentationRepresentationUID: string): {
+        allSegments?: RepresentationConfig;
+        perSegment?: SegmentRepresentationConfig;
+    };
+    getAllSegmentsConfig(segmentationRepresentationUID: string): RepresentationConfig;
+    getPerSegmentConfig(segmentationRepresentationUID: string): SegmentRepresentationConfig;
+    setAllSegmentsConfig(segmentationRepresentationUID: string, config: RepresentationConfig): void;
+    setPerSegmentConfig(segmentationRepresentationUID: string, config: SegmentRepresentationConfig): void;
+    getRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string): boolean;
+    setRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string, visible: boolean): void;
     addColorLUT(colorLUT: Types.ColorLUT, lutIndex: number): void;
     removeColorLUT(colorLUTIndex: number): void;
-    _handleActiveSegmentation(toolGroupId: string, recentlyAddedOrRemovedSegmentationRepresentation: ToolGroupSpecificRepresentation): void;
 }
 declare const defaultSegmentationStateManager: SegmentationStateManager;
 export { defaultSegmentationStateManager };

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

@@ -3,22 +3,20 @@ import { SegmentationRepresentations } from '../../enums';
 import getDefaultContourConfig from '../../tools/displayTools/Contour/contourConfig';
 import getDefaultLabelmapConfig from '../../tools/displayTools/Labelmap/labelmapConfig';
 import getDefaultSurfaceConfig from '../../tools/displayTools/Surface/surfaceConfig';
-const defaultLabelmapConfig = getDefaultLabelmapConfig();
-const defaultContourConfig = getDefaultContourConfig();
-const defaultSurfaceConfig = getDefaultSurfaceConfig();
 const newGlobalConfig = {
-    renderInactiveSegmentations: true,
+    renderInactiveRepresentations: true,
     representations: {
-        [SegmentationRepresentations.Labelmap]: defaultLabelmapConfig,
-        [SegmentationRepresentations.Contour]: defaultContourConfig,
-        [SegmentationRepresentations.Surface]: defaultSurfaceConfig,
+        [SegmentationRepresentations.Labelmap]: getDefaultLabelmapConfig(),
+        [SegmentationRepresentations.Contour]: getDefaultContourConfig(),
+        [SegmentationRepresentations.Surface]: getDefaultSurfaceConfig(),
     },
 };
 const initialDefaultState = {
     colorLUT: [],
     segmentations: [],
     globalConfig: newGlobalConfig,
-    toolGroups: {},
+    representations: {},
+    viewports: {},
 };
 export default class SegmentationStateManager {
     constructor(uid) {
@@ -31,9 +29,6 @@ export default class SegmentationStateManager {
     getState() {
         return this.state;
     }
-    getToolGroups() {
-        return Object.keys(this.state.toolGroups);
-    }
     getColorLUT(lutIndex) {
         return this.state.colorLUT[lutIndex];
     }
@@ -52,30 +47,64 @@ export default class SegmentationStateManager {
         }
         this.state.segmentations.push(segmentation);
     }
-    getSegmentationRepresentations(toolGroupId) {
-        const toolGroupSegRepresentationsWithConfig = this.state.toolGroups[toolGroupId];
-        if (!toolGroupSegRepresentationsWithConfig) {
-            return;
+    removeSegmentation(segmentationId) {
+        this.state.segmentations = this.state.segmentations.filter((segmentation) => segmentation.segmentationId !== segmentationId);
+    }
+    getRepresentation(segmentationRepresentationUID) {
+        return this.state.representations[segmentationRepresentationUID];
+    }
+    addRepresentation(segmentationRepresentation) {
+        const { segmentationRepresentationUID } = segmentationRepresentation;
+        this.state.representations[segmentationRepresentationUID] =
+            segmentationRepresentation;
+    }
+    addRepresentationToViewport(viewportId, segmentationRepresentationUID) {
+        if (!this.state.viewports[viewportId]) {
+            this.state.viewports[viewportId] = {};
         }
-        return toolGroupSegRepresentationsWithConfig.segmentationRepresentations;
+        this.setActiveRepresentation(viewportId, segmentationRepresentationUID);
     }
-    getAllSegmentationRepresentations() {
-        const toolGroupSegReps = {};
-        Object.entries(this.state.toolGroups).forEach(([toolGroupId, toolGroupSegRepresentationsWithConfig]) => {
-            toolGroupSegReps[toolGroupId] =
-                toolGroupSegRepresentationsWithConfig.segmentationRepresentations;
+    getRepresentationsForViewport(viewportId) {
+        const viewport = this.state.viewports[viewportId];
+        if (!viewport) {
+            return [];
+        }
+        return Object.keys(viewport).map((segRepUID) => {
+            return this.getRepresentation(segRepUID);
         });
-        return toolGroupSegReps;
     }
-    addSegmentationRepresentation(toolGroupId, segmentationRepresentation) {
-        if (!this.state.toolGroups[toolGroupId]) {
-            this.state.toolGroups[toolGroupId] = {
-                segmentationRepresentations: [],
-                config: {},
+    removeRepresentation(segmentationRepresentationUID) {
+        delete this.state.representations[segmentationRepresentationUID];
+        Object.keys(this.state.viewports).forEach((viewportId) => {
+            delete this.state.viewports[viewportId][segmentationRepresentationUID];
+        });
+    }
+    setActiveRepresentation(viewportId, segmentationRepresentationUID) {
+        Object.keys(this.state.viewports[viewportId]).forEach((segRepUID) => {
+            this.state.viewports[viewportId][segRepUID].active = false;
+        });
+        if (!this.state.viewports[viewportId]) {
+            this.state.viewports[viewportId] = {};
+        }
+        if (!this.state.viewports[viewportId][segmentationRepresentationUID]) {
+            this.state.viewports[viewportId][segmentationRepresentationUID] = {
+                active: false,
+                visible: true,
+                segmentsHidden: new Set(),
             };
         }
-        this.state.toolGroups[toolGroupId].segmentationRepresentations.push(segmentationRepresentation);
-        this._handleActiveSegmentation(toolGroupId, segmentationRepresentation);
+        this.state.viewports[viewportId][segmentationRepresentationUID].active =
+            true;
+    }
+    getActiveRepresentation(viewportId) {
+        if (!this.state.viewports?.[viewportId]) {
+            return;
+        }
+        const activeSegRep = Object.entries(this.state.viewports[viewportId]).find(([, value]) => value.active);
+        if (!activeSegRep) {
+            return;
+        }
+        return this.getRepresentation(activeSegRep[0]);
     }
     getGlobalConfig() {
         return this.state.globalConfig;
@@ -83,100 +112,51 @@ export default class SegmentationStateManager {
     setGlobalConfig(config) {
         this.state.globalConfig = config;
     }
-    getSegmentationRepresentationByUID(toolGroupId, segmentationRepresentationUID) {
-        const toolGroupSegRepresentations = this.getSegmentationRepresentations(toolGroupId);
-        const segmentationData = toolGroupSegRepresentations?.find((representation) => representation.segmentationRepresentationUID ===
-            segmentationRepresentationUID);
-        return segmentationData;
-    }
-    removeSegmentation(segmentationId) {
-        this.state.segmentations = this.state.segmentations.filter((segmentation) => segmentation.segmentationId !== segmentationId);
-    }
-    removeSegmentationRepresentation(toolGroupId, segmentationRepresentationUID) {
-        const toolGroupSegmentationRepresentations = this.getSegmentationRepresentations(toolGroupId);
-        if (!toolGroupSegmentationRepresentations ||
-            !toolGroupSegmentationRepresentations.length) {
-            throw new Error(`No viewport specific segmentation state found for viewport ${toolGroupId}`);
-        }
-        const state = toolGroupSegmentationRepresentations;
-        const index = state.findIndex((segData) => segData.segmentationRepresentationUID === segmentationRepresentationUID);
-        if (index === -1) {
-            console.warn(`No viewport specific segmentation state data found for viewport ${toolGroupId} and segmentation data UID ${segmentationRepresentationUID}`);
-        }
-        const removedSegmentationRepresentation = toolGroupSegmentationRepresentations[index];
-        toolGroupSegmentationRepresentations.splice(index, 1);
-        this._handleActiveSegmentation(toolGroupId, removedSegmentationRepresentation);
-    }
-    setActiveSegmentationRepresentation(toolGroupId, segmentationRepresentationUID) {
-        const toolGroupSegmentations = this.getSegmentationRepresentations(toolGroupId);
-        if (!toolGroupSegmentations || !toolGroupSegmentations.length) {
-            throw new Error(`No segmentation data found for toolGroupId: ${toolGroupId}`);
-        }
-        const segmentationData = toolGroupSegmentations.find((segmentationData) => segmentationData.segmentationRepresentationUID ===
-            segmentationRepresentationUID);
-        if (!segmentationData) {
-            throw new Error(`No segmentation data found for segmentation data UID ${segmentationRepresentationUID}`);
-        }
-        segmentationData.active = true;
-        this._handleActiveSegmentation(toolGroupId, segmentationData);
-    }
-    getToolGroupSpecificConfig(toolGroupId) {
-        const toolGroupStateWithConfig = this.state.toolGroups[toolGroupId];
-        if (!toolGroupStateWithConfig) {
+    _getRepresentationConfig(segmentationRepresentationUID) {
+        const segmentationRepresentation = this.getRepresentation(segmentationRepresentationUID);
+        if (!segmentationRepresentation) {
             return;
         }
-        return toolGroupStateWithConfig.config;
+        return segmentationRepresentation.config;
     }
-    getSegmentationRepresentationSpecificConfig(toolGroupId, segmentationRepresentationUID) {
-        const segmentationRepresentation = this.getSegmentationRepresentationByUID(toolGroupId, segmentationRepresentationUID);
-        if (!segmentationRepresentation) {
+    getAllSegmentsConfig(segmentationRepresentationUID) {
+        const config = this._getRepresentationConfig(segmentationRepresentationUID);
+        if (!config) {
             return;
         }
-        return segmentationRepresentation.segmentationRepresentationSpecificConfig;
+        return config.allSegments;
     }
-    setSegmentationRepresentationSpecificConfig(toolGroupId, segmentationRepresentationUID, config) {
-        const segmentationRepresentation = this.getSegmentationRepresentationByUID(toolGroupId, segmentationRepresentationUID);
-        if (!segmentationRepresentation) {
+    getPerSegmentConfig(segmentationRepresentationUID) {
+        const config = this._getRepresentationConfig(segmentationRepresentationUID);
+        if (!config) {
             return;
         }
-        segmentationRepresentation.segmentationRepresentationSpecificConfig =
-            config;
+        return config.perSegment;
     }
-    getSegmentSpecificConfig(toolGroupId, segmentationRepresentationUID, segmentIndex) {
-        const segmentationRepresentation = this.getSegmentationRepresentationByUID(toolGroupId, segmentationRepresentationUID);
-        if (!segmentationRepresentation) {
+    setAllSegmentsConfig(segmentationRepresentationUID, config) {
+        const _config = this._getRepresentationConfig(segmentationRepresentationUID);
+        if (!_config) {
             return;
         }
-        return segmentationRepresentation.segmentSpecificConfig[segmentIndex];
+        _config.allSegments = config;
     }
-    setSegmentSpecificConfig(toolGroupId, segmentationRepresentationUID, config, options) {
-        const segmentationRepresentation = this.getSegmentationRepresentationByUID(toolGroupId, segmentationRepresentationUID);
-        if (!segmentationRepresentation) {
+    setPerSegmentConfig(segmentationRepresentationUID, config) {
+        const _config = this._getRepresentationConfig(segmentationRepresentationUID);
+        if (!_config) {
             return;
         }
-        if (!segmentationRepresentation.segmentSpecificConfig || options?.clear) {
-            segmentationRepresentation.segmentSpecificConfig = {};
-        }
-        Object.keys(config).forEach((key) => {
-            segmentationRepresentation.segmentSpecificConfig[key] = config[key];
-        });
+        _config.perSegment = config;
     }
-    setSegmentationRepresentationConfig(toolGroupId, config) {
-        let toolGroupStateWithConfig = this.state.toolGroups[toolGroupId];
-        if (!toolGroupStateWithConfig) {
-            this.state.toolGroups[toolGroupId] = {
-                segmentationRepresentations: [],
-                config: {
-                    renderInactiveSegmentations: true,
-                    representations: {},
-                },
-            };
-            toolGroupStateWithConfig = this.state.toolGroups[toolGroupId];
+    getRepresentationVisibility(viewportId, segmentationRepresentationUID) {
+        const viewport = this.state.viewports[viewportId];
+        return viewport && viewport[segmentationRepresentationUID]?.visible;
+    }
+    setRepresentationVisibility(viewportId, segmentationRepresentationUID, visible) {
+        if (!this.state.viewports[viewportId]) {
+            this.state.viewports[viewportId] = {};
         }
-        toolGroupStateWithConfig.config = {
-            ...toolGroupStateWithConfig.config,
-            ...config,
-        };
+        this.state.viewports[viewportId][segmentationRepresentationUID].visible =
+            visible;
     }
     addColorLUT(colorLUT, lutIndex) {
         if (this.state.colorLUT[lutIndex]) {
@@ -187,29 +167,6 @@ export default class SegmentationStateManager {
     removeColorLUT(colorLUTIndex) {
         delete this.state.colorLUT[colorLUTIndex];
     }
-    _handleActiveSegmentation(toolGroupId, recentlyAddedOrRemovedSegmentationRepresentation) {
-        const segmentationRepresentations = this.getSegmentationRepresentations(toolGroupId);
-        if (segmentationRepresentations.length === 0) {
-            return;
-        }
-        if (segmentationRepresentations.length === 1) {
-            segmentationRepresentations[0].active = true;
-            return;
-        }
-        const activeSegmentationRepresentations = segmentationRepresentations.filter((representation) => representation.active);
-        if (activeSegmentationRepresentations.length === 0) {
-            segmentationRepresentations[0].active = true;
-            return;
-        }
-        if (recentlyAddedOrRemovedSegmentationRepresentation.active) {
-            segmentationRepresentations.forEach((representation) => {
-                if (representation.segmentationRepresentationUID !==
-                    recentlyAddedOrRemovedSegmentationRepresentation.segmentationRepresentationUID) {
-                    representation.active = false;
-                }
-            });
-        }
-    }
 }
 const defaultSegmentationStateManager = new SegmentationStateManager('DEFAULT');
 export { defaultSegmentationStateManager };

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

@@ -1,5 +1,4 @@
-import { ToolGroupSpecificRepresentation } from '../../types/SegmentationStateTypes';
-declare function getActiveSegmentationRepresentation(toolGroupId: string): ToolGroupSpecificRepresentation;
-declare function getActiveSegmentation(toolGroupId: string): import("../../types/SegmentationStateTypes").Segmentation;
-declare function setActiveSegmentationRepresentation(toolGroupId: string, segmentationRepresentationUID: string): void;
-export { getActiveSegmentationRepresentation, getActiveSegmentation, setActiveSegmentationRepresentation, };
+import { SegmentationRepresentation } from '../../types/SegmentationStateTypes';
+declare function getActiveRepresentation(viewportId: any): SegmentationRepresentation;
+declare function setActiveRepresentation(viewportId: any, segmentationRepresentationUID: any, suppressEvent?: boolean): void;
+export { getActiveRepresentation, setActiveRepresentation, };