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

package/dist/esm/stateManagement/segmentation/polySeg/canComputeRequestedRepresentation.js

@@ -1,6 +1,6 @@
 import { SegmentationRepresentations } from '../../../enums';
 import { validateLabelmap } from '../../../tools/displayTools/Labelmap';
-import { findSegmentationRepresentationByUID, getSegmentation, } from '../segmentationState';
+import { getRepresentation, getSegmentation } from '../segmentationState';
 const conversionPaths = new Map([
     [
         SegmentationRepresentations.Labelmap,
@@ -22,11 +22,7 @@ const conversionPaths = new Map([
     ],
 ]);
 function canComputeRequestedRepresentation(segmentationRepresentationUID) {
-    const representationInfo = findSegmentationRepresentationByUID(segmentationRepresentationUID);
-    if (!representationInfo?.segmentationRepresentation) {
-        return false;
-    }
-    const { segmentationRepresentation } = representationInfo;
+    const segmentationRepresentation = getRepresentation(segmentationRepresentationUID);
     const { type: representationType, polySeg } = segmentationRepresentation;
     if (!polySeg || !polySeg.enabled) {
         return false;

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

@@ -0,0 +1,2 @@
+declare function removeRepresentationsFromViewport(viewportId: string, segmentationRepresentationUIDs?: string[] | undefined, immediate?: boolean): void;
+export default removeRepresentationsFromViewport;

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

@@ -0,0 +1,23 @@
+import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
+import { labelmapDisplay } from '../../tools/displayTools/Labelmap';
+import { contourDisplay } from '../../tools/displayTools/Contour';
+import { getRepresentation } from './segmentationState';
+function removeRepresentationsFromViewport(viewportId, segmentationRepresentationUIDs, immediate) {
+    segmentationRepresentationUIDs.forEach((segmentationDataUID) => {
+        _removeSegmentation(viewportId, segmentationDataUID, immediate);
+    });
+}
+function _removeSegmentation(viewportId, segmentationRepresentationUID, immediate) {
+    const segmentationRepresentation = getRepresentation(segmentationRepresentationUID);
+    const { type } = segmentationRepresentation;
+    if (type === SegmentationRepresentations.Labelmap) {
+        labelmapDisplay.removeRepresentation(viewportId, segmentationRepresentationUID, immediate);
+    }
+    else if (type === SegmentationRepresentations.Contour) {
+        contourDisplay.removeRepresentation(viewportId, segmentationRepresentationUID, immediate);
+    }
+    else {
+        throw new Error(`The representation ${type} is not supported yet`);
+    }
+}
+export default removeRepresentationsFromViewport;

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

@@ -1,5 +1,6 @@
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
 import { invalidateBrushCursor } from '../../utilities/segmentation/';
-import { getSegmentation, getToolGroupIdsWithSegmentation, } from './segmentationState';
+import { getSegmentation, getViewportIdsWithSegmentationId, } from './segmentationState';
 import { triggerSegmentationModified } from './triggerSegmentationEvents';
 function setActiveSegmentIndex(segmentationId, segmentIndex) {
     const segmentation = getSegmentation(segmentationId);
@@ -11,9 +12,10 @@ function setActiveSegmentIndex(segmentationId, segmentIndex) {
         segmentation.activeSegmentIndex = segmentIndex;
         triggerSegmentationModified(segmentationId);
     }
-    const toolGroups = getToolGroupIdsWithSegmentation(segmentationId);
-    toolGroups.forEach((toolGroupId) => {
-        invalidateBrushCursor(toolGroupId);
+    const viewportIds = getViewportIdsWithSegmentationId(segmentationId);
+    viewportIds.forEach((viewportId) => {
+        const toolGroup = getToolGroupForViewport(viewportId);
+        invalidateBrushCursor(toolGroup.id);
     });
 }
 function getActiveSegmentIndex(segmentationId) {

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

@@ -1,33 +1,36 @@
 import type { Types } from '@cornerstonejs/core';
-import type { RepresentationConfig, Segmentation, SegmentationPublicInput, SegmentationRepresentationConfig, SegmentSpecificRepresentationConfig, ToolGroupSpecificRepresentation, ToolGroupSpecificRepresentations } from '../../types/SegmentationStateTypes';
+import type { RepresentationConfig, Segmentation, SegmentationPublicInput, SegmentationRepresentationConfig, SegmentRepresentationConfig, SegmentationRepresentation } from '../../types/SegmentationStateTypes';
 declare function getDefaultSegmentationStateManager(): import("./SegmentationStateManager").default;
 declare function getSegmentation(segmentationId: string): Segmentation | undefined;
 declare function getSegmentations(): Segmentation[] | [];
 declare function addSegmentation(segmentationInput: SegmentationPublicInput, suppressEvents?: boolean): void;
-declare function getSegmentationRepresentations(toolGroupId: string): ToolGroupSpecificRepresentations | [];
-declare function getAllSegmentationRepresentations(): Record<string, ToolGroupSpecificRepresentation[]>;
-declare function getSegmentationIdRepresentations(segmentationId: any): any[];
-declare function findSegmentationRepresentationByUID(segmentationRepresentationUID: string): {
-    toolGroupId: string;
-    segmentationRepresentation: ToolGroupSpecificRepresentation;
+declare function getRepresentations(): SegmentationRepresentation[];
+declare function getRepresentation(segmentationRepresentationUID: string): SegmentationRepresentation | undefined;
+declare function getRepresentationsBySegmentationId(segmentationId: string): SegmentationRepresentation[];
+declare function getAllSegmentsConfig(segmentationRepresentationUID: string): RepresentationConfig;
+declare function setAllSegmentsConfig(segmentationRepresentationUID: string, config: RepresentationConfig, suppressEvents?: boolean): void;
+declare function getPerSegmentConfig(segmentationRepresentationUID: string): SegmentRepresentationConfig;
+declare function setPerSegmentConfig(segmentationRepresentationUID: string, config: SegmentRepresentationConfig, suppressEvents?: boolean): void;
+declare function getViewportIdsWithSegmentationId(segmentationId: string): string[];
+declare function getRepresentationsForViewport(viewportId: string): SegmentationRepresentation[] | [];
+declare function getRepresentationsRenderingStateForViewport(viewportId: string): {
+    [segRepUID: string]: {
+        visible: boolean;
+        segmentsHidden: Set<number>;
+        active: boolean;
+    };
 };
-declare function getToolGroupIdsWithSegmentation(segmentationId: string): string[];
-declare function getToolGroupSpecificConfig(toolGroupId: string): SegmentationRepresentationConfig;
-declare function setToolGroupSpecificConfig(toolGroupId: string, config: SegmentationRepresentationConfig, suppressEvents?: boolean): void;
-declare function setSegmentationRepresentationSpecificConfig(toolGroupId: string, segmentationRepresentationUID: string, config: RepresentationConfig, suppressEvents?: boolean): void;
-declare function getSegmentationRepresentationSpecificConfig(toolGroupId: string, segmentationRepresentationUID: string): RepresentationConfig;
-declare function getSegmentSpecificRepresentationConfig(toolGroupId: string, segmentationRepresentationUID: string, segmentIndex: number): RepresentationConfig;
-declare function setSegmentSpecificRepresentationConfig(toolGroupId: string, segmentationRepresentationUID: string, config: SegmentSpecificRepresentationConfig, suppressEvents?: boolean): void;
-declare function getToolGroupIdFromSegmentationRepresentationUID(segmentationRepresentationUID: string): string;
-declare function addSegmentationRepresentation(toolGroupId: string, segmentationRepresentation: ToolGroupSpecificRepresentation, suppressEvents?: boolean): void;
+declare function addRepresentationToViewport(viewportId: string, segmentationRepresentation: SegmentationRepresentation, suppressEvents?: boolean): void;
 declare function getGlobalConfig(): SegmentationRepresentationConfig;
 declare function setGlobalConfig(config: SegmentationRepresentationConfig, suppressEvents?: boolean): void;
-declare function getSegmentationRepresentationByUID(toolGroupId: string, segmentationRepresentationUID: string): ToolGroupSpecificRepresentation | undefined;
 declare function removeSegmentation(segmentationId: string): void;
-declare function removeSegmentationRepresentation(toolGroupId: string, segmentationRepresentationUID: string): void;
-declare function removeSegmentationRepresentations(toolGroupId: string): void;
+declare function removeRepresentation(segmentationRepresentationUID: string, suppressEvents?: boolean): void;
 declare function removeColorLUT(colorLUTIndex: number): void;
 declare function getColorLUT(index: number): Types.ColorLUT | undefined;
 declare function getNextColorLUTIndex(): number;
 declare function addColorLUT(colorLUT: Types.ColorLUT, index: number): void;
-export { getDefaultSegmentationStateManager, getSegmentation, getSegmentations, addSegmentation, removeSegmentation, getSegmentationRepresentations, addSegmentationRepresentation, removeSegmentationRepresentation, removeSegmentationRepresentations, getToolGroupSpecificConfig, setToolGroupSpecificConfig, getGlobalConfig, setGlobalConfig, getSegmentationRepresentationSpecificConfig, setSegmentationRepresentationSpecificConfig, getSegmentSpecificRepresentationConfig, setSegmentSpecificRepresentationConfig, getToolGroupIdsWithSegmentation, getAllSegmentationRepresentations, getSegmentationRepresentationByUID, getSegmentationIdRepresentations, addColorLUT, getColorLUT, getNextColorLUTIndex, removeColorLUT, findSegmentationRepresentationByUID, getToolGroupIdFromSegmentationRepresentationUID, };
+declare function getRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string): boolean;
+declare function setRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string, visible: boolean): void;
+declare function getActiveRepresentation(viewportId: string): SegmentationRepresentation | undefined;
+declare function setActiveRepresentation(viewportId: string, segmentationRepresentationUID: string, suppressEvents?: boolean): void;
+export { getDefaultSegmentationStateManager, getSegmentation, getSegmentations, addSegmentation, removeSegmentation, getRepresentations, getRepresentation, removeRepresentation, getGlobalConfig, setGlobalConfig, getAllSegmentsConfig, setAllSegmentsConfig, getPerSegmentConfig, setPerSegmentConfig, getRepresentationsForViewport, addRepresentationToViewport, getRepresentationsRenderingStateForViewport, addColorLUT, getColorLUT, getNextColorLUTIndex, removeColorLUT, getRepresentationsBySegmentationId, getRepresentationVisibility, setRepresentationVisibility, getViewportIdsWithSegmentationId, getActiveRepresentation, setActiveRepresentation, };

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

@@ -21,109 +21,71 @@ function addSegmentation(segmentationInput, suppressEvents) {
         triggerSegmentationModified(segmentation.segmentationId);
     }
 }
-function getSegmentationRepresentations(toolGroupId) {
+function getRepresentations() {
     const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getSegmentationRepresentations(toolGroupId);
+    const state = segmentationStateManager.getState();
+    return Object.values(state.representations);
 }
-function getAllSegmentationRepresentations() {
+function getRepresentation(segmentationRepresentationUID) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getAllSegmentationRepresentations();
+    return segmentationStateManager.getRepresentation(segmentationRepresentationUID);
 }
-function getSegmentationIdRepresentations(segmentationId) {
-    const allRepresentations = getAllSegmentationRepresentations() || {};
-    const foundRepresentations = [];
-    for (const toolGroupId in allRepresentations) {
-        const toolGroupRepresentations = allRepresentations[toolGroupId];
-        const foundRepresentation = toolGroupRepresentations.find((representation) => representation.segmentationId === segmentationId);
-        if (foundRepresentation) {
-            foundRepresentations.push(foundRepresentation);
-        }
-    }
-    return foundRepresentations;
-}
-function findSegmentationRepresentationByUID(segmentationRepresentationUID) {
-    const allToolGroupRepresentations = getAllSegmentationRepresentations() || [];
-    const toolGroupIds = Object.keys(allToolGroupRepresentations);
-    for (const toolGroupId of toolGroupIds) {
-        const toolGroupRepresentations = getAllSegmentationRepresentations()[toolGroupId];
-        const foundRepresentation = toolGroupRepresentations.find((representation) => representation.segmentationRepresentationUID ===
-            segmentationRepresentationUID);
-        if (foundRepresentation) {
-            return {
-                segmentationRepresentation: foundRepresentation,
-                toolGroupId,
-            };
-        }
-    }
+function getRepresentationsBySegmentationId(segmentationId) {
+    const allRepresentations = getRepresentations();
+    return allRepresentations.filter((representation) => representation.segmentationId === segmentationId);
 }
-function getToolGroupIdsWithSegmentation(segmentationId) {
-    if (!segmentationId) {
-        throw new Error('getToolGroupIdsWithSegmentation: segmentationId is empty');
-    }
+function getAllSegmentsConfig(segmentationRepresentationUID) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
-    const state = segmentationStateManager.getState();
-    const toolGroupIds = Object.keys(state.toolGroups);
-    const foundToolGroupIds = [];
-    toolGroupIds.forEach((toolGroupId) => {
-        const toolGroupSegmentationRepresentations = segmentationStateManager.getSegmentationRepresentations(toolGroupId);
-        toolGroupSegmentationRepresentations.forEach((representation) => {
-            if (representation.segmentationId === segmentationId) {
-                foundToolGroupIds.push(toolGroupId);
-            }
-        });
-    });
-    return foundToolGroupIds;
-}
-function getToolGroupSpecificConfig(toolGroupId) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getToolGroupSpecificConfig(toolGroupId);
+    return segmentationStateManager.getAllSegmentsConfig(segmentationRepresentationUID);
 }
-function setToolGroupSpecificConfig(toolGroupId, config, suppressEvents) {
+function setAllSegmentsConfig(segmentationRepresentationUID, config, suppressEvents) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.setSegmentationRepresentationConfig(toolGroupId, config);
+    segmentationStateManager.setAllSegmentsConfig(segmentationRepresentationUID, config);
     if (!suppressEvents) {
-        triggerSegmentationRepresentationModified(toolGroupId);
+        triggerSegmentationRepresentationModified(segmentationRepresentationUID);
     }
 }
-function setSegmentationRepresentationSpecificConfig(toolGroupId, segmentationRepresentationUID, config, suppressEvents = false) {
+function getPerSegmentConfig(segmentationRepresentationUID) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.setSegmentationRepresentationSpecificConfig(toolGroupId, segmentationRepresentationUID, config);
-    if (!suppressEvents) {
-        triggerSegmentationRepresentationModified(toolGroupId, segmentationRepresentationUID);
-    }
+    return segmentationStateManager.getPerSegmentConfig(segmentationRepresentationUID);
 }
-function getSegmentationRepresentationSpecificConfig(toolGroupId, segmentationRepresentationUID) {
+function setPerSegmentConfig(segmentationRepresentationUID, config, suppressEvents) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getSegmentationRepresentationSpecificConfig(toolGroupId, segmentationRepresentationUID);
+    segmentationStateManager.setPerSegmentConfig(segmentationRepresentationUID, config);
+    if (!suppressEvents) {
+        triggerSegmentationRepresentationModified(segmentationRepresentationUID);
+    }
 }
-function getSegmentSpecificRepresentationConfig(toolGroupId, segmentationRepresentationUID, segmentIndex) {
+function getViewportIdsWithSegmentationId(segmentationId) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getSegmentSpecificConfig(toolGroupId, segmentationRepresentationUID, segmentIndex);
+    const state = segmentationStateManager.getState();
+    const viewports = state.viewports;
+    return Object.keys(viewports).filter((viewportId) => {
+        const viewport = viewports[viewportId];
+        return Object.keys(viewport).some((segRepUID) => state.representations[segRepUID].segmentationId === segmentationId);
+    });
 }
-function setSegmentSpecificRepresentationConfig(toolGroupId, segmentationRepresentationUID, config, suppressEvents = false) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.setSegmentSpecificConfig(toolGroupId, segmentationRepresentationUID, config);
-    if (!suppressEvents) {
-        triggerSegmentationRepresentationModified(toolGroupId, segmentationRepresentationUID);
+function getRepresentationsForViewport(viewportId) {
+    const viewportRenderingState = getRepresentationsRenderingStateForViewport(viewportId);
+    if (!viewportRenderingState) {
+        return [];
     }
+    const segRepUIDs = Object.keys(viewportRenderingState);
+    return segRepUIDs
+        .map((segRepUID) => getRepresentation(segRepUID))
+        .filter(Boolean);
 }
-function getToolGroupIdFromSegmentationRepresentationUID(segmentationRepresentationUID) {
-    const allToolGroupRepresentations = getAllSegmentationRepresentations() || [];
-    const toolGroupIds = Object.keys(allToolGroupRepresentations);
-    for (const toolGroupId of toolGroupIds) {
-        const toolGroupRepresentations = getAllSegmentationRepresentations()[toolGroupId];
-        const foundRepresentation = toolGroupRepresentations.find((representation) => representation.segmentationRepresentationUID ===
-            segmentationRepresentationUID);
-        if (foundRepresentation) {
-            return toolGroupId;
-        }
-    }
+function getRepresentationsRenderingStateForViewport(viewportId) {
+    const segmentationStateManager = getDefaultSegmentationStateManager();
+    const state = segmentationStateManager.getState();
+    return state.viewports?.[viewportId] || {};
 }
-function addSegmentationRepresentation(toolGroupId, segmentationRepresentation, suppressEvents) {
+function addRepresentationToViewport(viewportId, segmentationRepresentation, suppressEvents) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.addSegmentationRepresentation(toolGroupId, segmentationRepresentation);
+    segmentationStateManager.addRepresentation(segmentationRepresentation);
+    segmentationStateManager.addRepresentationToViewport(viewportId, segmentationRepresentation.segmentationRepresentationUID);
     if (!suppressEvents) {
-        triggerSegmentationRepresentationModified(toolGroupId, segmentationRepresentation.segmentationRepresentationUID);
+        triggerSegmentationRepresentationModified(segmentationRepresentation.segmentationRepresentationUID);
     }
 }
 function getGlobalConfig() {
@@ -137,25 +99,17 @@ function setGlobalConfig(config, suppressEvents) {
         triggerSegmentationModified();
     }
 }
-function getSegmentationRepresentationByUID(toolGroupId, segmentationRepresentationUID) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    return segmentationStateManager.getSegmentationRepresentationByUID(toolGroupId, segmentationRepresentationUID);
-}
 function removeSegmentation(segmentationId) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
     segmentationStateManager.removeSegmentation(segmentationId);
     triggerSegmentationRemoved(segmentationId);
 }
-function removeSegmentationRepresentation(toolGroupId, segmentationRepresentationUID) {
+function removeRepresentation(segmentationRepresentationUID, suppressEvents) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.removeSegmentationRepresentation(toolGroupId, segmentationRepresentationUID);
-    triggerSegmentationRepresentationRemoved(toolGroupId, segmentationRepresentationUID);
-}
-function removeSegmentationRepresentations(toolGroupId) {
-    const segmentationRepresentations = getSegmentationRepresentations(toolGroupId) || [];
-    segmentationRepresentations.forEach((representation) => {
-        removeSegmentationRepresentation(toolGroupId, representation.segmentationRepresentationUID);
-    });
+    segmentationStateManager.removeRepresentation(segmentationRepresentationUID);
+    if (!suppressEvents) {
+        triggerSegmentationRepresentationRemoved(segmentationRepresentationUID);
+    }
 }
 function removeColorLUT(colorLUTIndex) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
@@ -173,4 +127,23 @@ function addColorLUT(colorLUT, index) {
     const segmentationStateManager = getDefaultSegmentationStateManager();
     segmentationStateManager.addColorLUT(colorLUT, index);
 }
-export { getDefaultSegmentationStateManager, getSegmentation, getSegmentations, addSegmentation, removeSegmentation, getSegmentationRepresentations, addSegmentationRepresentation, removeSegmentationRepresentation, removeSegmentationRepresentations, getToolGroupSpecificConfig, setToolGroupSpecificConfig, getGlobalConfig, setGlobalConfig, getSegmentationRepresentationSpecificConfig, setSegmentationRepresentationSpecificConfig, getSegmentSpecificRepresentationConfig, setSegmentSpecificRepresentationConfig, getToolGroupIdsWithSegmentation, getAllSegmentationRepresentations, getSegmentationRepresentationByUID, getSegmentationIdRepresentations, addColorLUT, getColorLUT, getNextColorLUTIndex, removeColorLUT, findSegmentationRepresentationByUID, getToolGroupIdFromSegmentationRepresentationUID, };
+function getRepresentationVisibility(viewportId, segmentationRepresentationUID) {
+    const segmentationStateManager = getDefaultSegmentationStateManager();
+    return segmentationStateManager.getRepresentationVisibility(viewportId, segmentationRepresentationUID);
+}
+function setRepresentationVisibility(viewportId, segmentationRepresentationUID, visible) {
+    const segmentationStateManager = getDefaultSegmentationStateManager();
+    segmentationStateManager.setRepresentationVisibility(viewportId, segmentationRepresentationUID, visible);
+}
+function getActiveRepresentation(viewportId) {
+    const segmentationStateManager = getDefaultSegmentationStateManager();
+    return segmentationStateManager.getActiveRepresentation(viewportId);
+}
+function setActiveRepresentation(viewportId, segmentationRepresentationUID, suppressEvents) {
+    const segmentationStateManager = getDefaultSegmentationStateManager();
+    segmentationStateManager.setActiveRepresentation(viewportId, segmentationRepresentationUID);
+    if (!suppressEvents) {
+        triggerSegmentationRepresentationModified(segmentationRepresentationUID);
+    }
+}
+export { getDefaultSegmentationStateManager, getSegmentation, getSegmentations, addSegmentation, removeSegmentation, getRepresentations, getRepresentation, removeRepresentation, getGlobalConfig, setGlobalConfig, getAllSegmentsConfig, setAllSegmentsConfig, getPerSegmentConfig, setPerSegmentConfig, getRepresentationsForViewport, addRepresentationToViewport, getRepresentationsRenderingStateForViewport, addColorLUT, getColorLUT, getNextColorLUTIndex, removeColorLUT, getRepresentationsBySegmentationId, getRepresentationVisibility, setRepresentationVisibility, getViewportIdsWithSegmentationId, getActiveRepresentation, setActiveRepresentation, };

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

@@ -1,6 +1,6 @@
 declare function triggerSegmentationRemoved(segmentationId: string): void;
-declare function triggerSegmentationRepresentationRemoved(toolGroupId: string, segmentationRepresentationUID: string): void;
-declare function triggerSegmentationRepresentationModified(toolGroupId: string, segmentationRepresentationUID?: string): void;
+declare function triggerSegmentationRepresentationRemoved(segmentationRepresentationUID: string): void;
+declare function triggerSegmentationRepresentationModified(segmentationRepresentationUID: string): void;
 declare function triggerSegmentationModified(segmentationId?: string): void;
 declare function triggerSegmentationDataModified(segmentationId: string, modifiedSlicesToUse?: number[]): void;
 export { triggerSegmentationRepresentationModified, triggerSegmentationRepresentationRemoved, triggerSegmentationDataModified, triggerSegmentationModified, triggerSegmentationRemoved, };

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

@@ -1,6 +1,6 @@
 import { triggerEvent, eventTarget } from '@cornerstonejs/core';
 import { Events } from '../../enums';
-import { getSegmentationRepresentations, getSegmentations, } from '../../stateManagement/segmentation/segmentationState';
+import { getSegmentations } from '../../stateManagement/segmentation/segmentationState';
 import { setSegmentationDirty } from '../../utilities/segmentation/getUniqueSegmentIndices';
 function triggerSegmentationRemoved(segmentationId) {
     const eventDetail = {
@@ -8,31 +8,17 @@ function triggerSegmentationRemoved(segmentationId) {
     };
     triggerEvent(eventTarget, Events.SEGMENTATION_REMOVED, eventDetail);
 }
-function triggerSegmentationRepresentationRemoved(toolGroupId, segmentationRepresentationUID) {
+function triggerSegmentationRepresentationRemoved(segmentationRepresentationUID) {
     const eventDetail = {
-        toolGroupId,
         segmentationRepresentationUID,
     };
     triggerEvent(eventTarget, Events.SEGMENTATION_REPRESENTATION_REMOVED, eventDetail);
 }
-function triggerSegmentationRepresentationModified(toolGroupId, segmentationRepresentationUID) {
+function triggerSegmentationRepresentationModified(segmentationRepresentationUID) {
     const eventDetail = {
-        toolGroupId,
         segmentationRepresentationUID,
     };
-    if (segmentationRepresentationUID) {
-        triggerEvent(eventTarget, Events.SEGMENTATION_REPRESENTATION_MODIFIED, eventDetail);
-        return;
-    }
-    const segmentationRepresentations = getSegmentationRepresentations(toolGroupId) || [];
-    segmentationRepresentations.forEach((segmentationRepresentation) => {
-        const { segmentationRepresentationUID } = segmentationRepresentation;
-        const eventDetail = {
-            toolGroupId,
-            segmentationRepresentationUID,
-        };
-        triggerEvent(eventTarget, Events.SEGMENTATION_REPRESENTATION_MODIFIED, eventDetail);
-    });
+    triggerEvent(eventTarget, Events.SEGMENTATION_REPRESENTATION_MODIFIED, eventDetail);
 }
 function triggerSegmentationModified(segmentationId) {
     let segmentationIds;

package/dist/esm/store/ToolGroupManager/destroyToolGroup.js

@@ -1,11 +1,7 @@
 import { state } from '../index';
-import { removeSegmentationsFromToolGroup } from '../../stateManagement/segmentation';
-import { segmentationRenderingEngine } from '../../utilities/segmentation/triggerSegmentationRender';
 function destroyToolGroup(toolGroupId) {
     const toolGroupIndex = state.toolGroups.findIndex((tg) => tg.id === toolGroupId);
     if (toolGroupIndex > -1) {
-        segmentationRenderingEngine.removeToolGroup(toolGroupId);
-        removeSegmentationsFromToolGroup(toolGroupId);
         state.toolGroups.splice(toolGroupIndex, 1);
     }
 }

package/dist/esm/tools/AdvancedMagnifyViewport.js

@@ -4,7 +4,7 @@ import { SegmentationRepresentations, ToolModes, Events as cstEvents, } from '..
 import { ToolGroupManager, state } from '../store';
 import { debounce } from '../utilities';
 import { segmentation } from '..';
-import { AnnotationTool, AdvancedMagnifyTool, SegmentationDisplayTool, } from './';
+import { AnnotationTool, AdvancedMagnifyTool } from './';
 import { distanceToPoint } from '../utilities/math/point';
 const MAGNIFY_CLASSNAME = 'advancedMagnifyTool';
 const MAGNIFY_VIEWPORT_INITIAL_RADIUS = 125;
@@ -147,11 +147,11 @@ class AdvancedMagnifyViewport {
             const toolInstance = sourceToolGroup.getToolInstance(toolName);
             const isAnnotationTool = toolInstance instanceof AnnotationTool &&
                 !(toolInstance instanceof AdvancedMagnifyTool);
-            return (isAnnotationTool || toolName === SegmentationDisplayTool.toolName);
+            return isAnnotationTool;
         });
         magnifyToolGroup.addViewport(magnifyViewport.id, magnifyViewport.renderingEngineId);
         sourceActors.filter(isSegmentation).forEach((actor) => {
-            segmentation.addSegmentationRepresentations(magnifyToolGroupId, [
+            segmentation.addRepresentations(this.viewportId, [
                 {
                     segmentationId: actor.referencedId,
                     type: SegmentationRepresentations.Labelmap,

package/dist/esm/tools/annotation/PlanarFreehandROITool.js

@@ -70,8 +70,6 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
         this.addNewAnnotation = (evt) => {
             const eventDetail = evt.detail;
             const { element } = eventDetail;
-            const enabledElement = getEnabledElement(element);
-            const { renderingEngine } = enabledElement;
             const annotation = this.createAnnotation(evt);
             this.addAnnotation(annotation, element);
             const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName());

package/dist/esm/tools/base/ContourSegmentationBaseTool.d.ts

@@ -13,6 +13,5 @@ declare abstract class ContourSegmentationBaseTool extends ContourBaseTool {
     }): any;
     protected renderAnnotationInstance(renderContext: AnnotationRenderContext): boolean;
     private _getContourSegmentationStyle;
-    private _getSegmentationRepresentation;
 }
 export { ContourSegmentationBaseTool as default, ContourSegmentationBaseTool };

package/dist/esm/tools/base/ContourSegmentationBaseTool.js

@@ -1,12 +1,13 @@
-import { utilities } from '@cornerstonejs/core';
+import { getEnabledElement, utilities } from '@cornerstonejs/core';
 import { config as segmentationConfig, state as segmentationState, segmentLocking, segmentIndex as segmentIndexController, activeSegmentation, } from '../../stateManagement/segmentation';
 import { SegmentationRepresentations } from '../../enums';
 import ContourBaseTool from './ContourBaseTool';
 import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
 import { InterpolationManager } from '../../utilities/contours/interpolation';
 import { addContourSegmentationAnnotation, removeContourSegmentationAnnotation, } from '../../utilities/contourSegmentation';
-import { getToolGroupIdsWithSegmentation } from '../../stateManagement/segmentation/segmentationState';
 import { triggerAnnotationRenderForToolGroupIds } from '../../utilities';
+import { getActiveRepresentation, getRepresentationsBySegmentationId, getRepresentationsForViewport, getViewportIdsWithSegmentationId, } from '../../stateManagement/segmentation/segmentationState';
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
 class ContourSegmentationBaseTool extends ContourBaseTool {
     constructor(toolProps, defaultToolProps) {
         super(toolProps, defaultToolProps);
@@ -18,20 +19,26 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
         return true;
     }
     createAnnotation(evt) {
-        const { toolGroupId } = this;
+        const eventDetail = evt.detail;
+        const { element } = eventDetail;
+        const enabledElement = getEnabledElement(element);
+        if (!enabledElement) {
+            return;
+        }
+        const { viewport } = enabledElement;
         const contourAnnotation = super.createAnnotation(evt);
         if (!this.isContourSegmentationTool()) {
             return contourAnnotation;
         }
-        const activeSegmentationRepresentation = activeSegmentation.getActiveSegmentationRepresentation(toolGroupId);
-        if (!activeSegmentationRepresentation) {
+        const activeSeg = activeSegmentation.getActiveRepresentation(viewport.id);
+        if (!activeSeg) {
             throw new Error('No active segmentation detected, create one before using scissors tool');
         }
-        const { type: segmentationType } = activeSegmentationRepresentation;
+        const { type: segmentationType } = activeSeg;
         if (segmentationType !== SegmentationRepresentations.Contour) {
             throw new Error(`A contour segmentation must be active`);
         }
-        const { segmentationId } = activeSegmentationRepresentation;
+        const { segmentationId } = activeSeg;
         const segmentIndex = segmentIndexController.getActiveSegmentIndex(segmentationId);
         return utilities.deepMerge(contourAnnotation, {
             data: {
@@ -71,33 +78,48 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
         if (invalidated && this.isContourSegmentationTool()) {
             const { segmentationId } = (annotation).data.segmentation;
             triggerSegmentationDataModified(segmentationId);
-            const toolGroupIds = getToolGroupIdsWithSegmentation(segmentationId);
+            const viewportIds = getViewportIdsWithSegmentationId(segmentationId);
+            const toolGroupIds = viewportIds.map((viewportId) => {
+                const toolGroup = getToolGroupForViewport(viewportId);
+                return toolGroup.id;
+            });
             triggerAnnotationRenderForToolGroupIds(toolGroupIds);
         }
         return renderResult;
     }
     _getContourSegmentationStyle(context) {
-        const { toolGroupId } = this;
         const annotation = context.annotation;
         const { segmentationId, segmentIndex } = annotation.data.segmentation;
         const segmentation = segmentationState.getSegmentation(segmentationId);
-        const segmentationRepresentation = this._getSegmentationRepresentation(segmentationId);
-        if (!segmentationRepresentation) {
+        const segmentationRepresentations = getRepresentationsBySegmentationId(segmentationId);
+        if (!segmentationRepresentations?.length) {
             return {};
         }
+        const allUIDs = segmentationRepresentations.map((rep) => rep.segmentationRepresentationUID);
+        let segmentationRepresentation;
+        if (segmentationRepresentations.length > 1) {
+            const viewportReps = getRepresentationsForViewport(context.styleSpecifier.viewportId);
+            segmentationRepresentation = viewportReps.find((rep) => rep.segmentationId === segmentationId &&
+                allUIDs.includes(rep.segmentationRepresentationUID));
+        }
+        else {
+            segmentationRepresentation = segmentationRepresentations[0];
+        }
         const { segmentationRepresentationUID } = segmentationRepresentation;
-        const { active } = segmentationRepresentation;
         const { autoGenerated } = annotation;
         const segmentsLocked = segmentLocking.getLockedSegments(segmentationId);
         const annotationLocked = segmentsLocked.includes(segmentIndex);
-        const segmentColor = segmentationConfig.color.getColorForSegmentIndex(toolGroupId, segmentationRepresentationUID, segmentIndex);
-        const segmentationVisible = segmentationConfig.visibility.getSegmentationVisibility(toolGroupId, segmentationRepresentationUID);
+        const segmentColor = segmentationConfig.color.getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
+        const viewportId = context.styleSpecifier.viewportId;
+        const segmentationVisible = segmentationConfig.visibility.getRepresentationVisibility(viewportId, segmentationRepresentationUID);
         const globalConfig = segmentationConfig.getGlobalConfig();
-        const toolGroupConfig = segmentationConfig.getToolGroupSpecificConfig(toolGroupId);
-        const segmentationRepresentationConfig = segmentationConfig.getSegmentationRepresentationSpecificConfig(toolGroupId, segmentationRepresentationUID);
-        const segmentConfig = segmentationConfig.getSegmentSpecificConfig(toolGroupId, segmentationRepresentationUID, segmentIndex);
-        const segmentVisible = segmentationConfig.visibility.getSegmentVisibility(toolGroupId, segmentationRepresentationUID, segmentIndex);
-        const mergedConfig = Object.assign({}, globalConfig?.representations?.CONTOUR ?? {}, toolGroupConfig?.representations?.CONTOUR ?? {}, segmentationRepresentationConfig?.CONTOUR ?? {}, segmentConfig?.CONTOUR ?? {});
+        const getAllSegmentsConfig = segmentationConfig.getAllSegmentsConfig(segmentationRepresentationUID);
+        const segmentConfig = segmentationConfig.getSegmentIndexConfig(segmentationRepresentationUID, segmentIndex);
+        const segmentVisible = segmentationConfig.visibility.getSegmentIndexVisibility(viewportId, segmentationRepresentationUID, segmentIndex);
+        const activeSegRep = getActiveRepresentation(viewportId);
+        const isActive = activeSegRep.segmentationRepresentationUID ===
+            segmentationRepresentationUID;
+        const mergedConfig = Object.assign({}, globalConfig?.representations?.CONTOUR ?? {}, getAllSegmentsConfig?.CONTOUR ?? {}, segmentConfig?.CONTOUR ?? {});
         let lineWidth = 1;
         let lineDash = undefined;
         let lineOpacity = 1;
@@ -108,7 +130,7 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
             lineOpacity = mergedConfig.outlineOpacity ?? lineOpacity;
             fillOpacity = mergedConfig.fillAlphaAutoGenerated ?? fillOpacity;
         }
-        else if (active) {
+        else if (isActive) {
             lineWidth = mergedConfig.outlineWidthActive ?? lineWidth;
             lineDash = mergedConfig.outlineDashActive ?? lineDash;
             lineOpacity = mergedConfig.outlineOpacity ?? lineOpacity;
@@ -140,18 +162,5 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
             locked: annotationLocked,
         };
     }
-    _getSegmentationRepresentation(segmentationId) {
-        const segmentationRepresentations = segmentationState.getSegmentationRepresentations(this.toolGroupId);
-        const validSegmentationRepresentations = segmentationRepresentations.filter((representation) => representation.segmentationId === segmentationId);
-        if (!validSegmentationRepresentations) {
-            console.warn(`No segmentation representation found for toolGroupId: ${this.toolGroupId}`);
-            return;
-        }
-        if (segmentationState.getSegmentationRepresentations(this.toolGroupId)
-            .length > 1) {
-            console.warn('Multiple segmentation representations detected for this tool group. The first one will be used.');
-        }
-        return validSegmentationRepresentations[0];
-    }
 }
 export { ContourSegmentationBaseTool as default, ContourSegmentationBaseTool };

package/dist/esm/tools/displayTools/Contour/contourDisplay.d.ts

@@ -1,9 +1,9 @@
 import { StackViewport, Types } from '@cornerstonejs/core';
-import { SegmentationRepresentationConfig, ToolGroupSpecificRepresentation } from '../../../types/SegmentationStateTypes';
-declare function removeSegmentationRepresentation(toolGroupId: string, segmentationRepresentationUID: string, renderImmediate?: boolean): void;
-declare function render(viewport: StackViewport | Types.IVolumeViewport, representationConfig: ToolGroupSpecificRepresentation, toolGroupConfig: SegmentationRepresentationConfig): Promise<void>;
+import { ContourRepresentation } from '../../../types/SegmentationStateTypes';
+declare function removeRepresentation(viewportId: string, segmentationRepresentationUID: string, renderImmediate?: boolean): void;
+declare function render(viewport: StackViewport | Types.IVolumeViewport, contourRepresentation: ContourRepresentation): Promise<void>;
 declare const _default: {
     render: typeof render;
-    removeSegmentationRepresentation: typeof removeSegmentationRepresentation;
+    removeRepresentation: typeof removeRepresentation;
 };
 export default _default;