@cornerstonejs/tools 2.0.0-beta.27 → 2.0.0-beta.29

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

@@ -0,0 +1,50 @@
+import { getActiveSegmentIndex } from './getActiveSegmentIndex';
+import { getSegmentation } from './getSegmentation';
+import { getSegmentationRepresentations } from './getSegmentationRepresentation';
+import { getViewportIdsWithSegmentation } from './getViewportIdsWithSegmentation';
+import { clearSegmentValue } from './helpers/clearSegmentValue';
+import { setActiveSegmentIndex } from './segmentIndex';
+import { updateSegmentations } from './updateSegmentations';
+export function removeSegment(segmentationId, segmentIndex, options = {
+    setNextSegmentAsActive: true,
+}) {
+    clearSegmentValue(segmentationId, segmentIndex);
+    const isThisSegmentActive = getActiveSegmentIndex(segmentationId) === segmentIndex;
+    const segmentation = getSegmentation(segmentationId);
+    const { segments } = segmentation;
+    delete segments[segmentIndex];
+    const updatedSegments = {
+        ...segments,
+    };
+    updateSegmentations([
+        {
+            segmentationId,
+            payload: {
+                segments: updatedSegments,
+            },
+        },
+    ]);
+    if (isThisSegmentActive && options.setNextSegmentAsActive) {
+        const segmentIndices = Object.keys(segments)
+            .map(Number)
+            .sort((a, b) => a - b);
+        const currentIndex = segmentIndices.indexOf(segmentIndex);
+        const nextSegmentIndex = segmentIndices[currentIndex + 1];
+        const previousSegmentIndex = segmentIndices[currentIndex - 1];
+        if (nextSegmentIndex !== undefined) {
+            setActiveSegmentIndex(segmentationId, nextSegmentIndex);
+        }
+        else if (previousSegmentIndex !== undefined) {
+            setActiveSegmentIndex(segmentationId, previousSegmentIndex);
+        }
+    }
+    const viewportIds = getViewportIdsWithSegmentation(segmentationId);
+    viewportIds.forEach((viewportId) => {
+        const representations = getSegmentationRepresentations(viewportId, {
+            segmentationId,
+        });
+        representations.forEach((representation) => {
+            delete representation.segments[segmentIndex];
+        });
+    });
+}

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

@@ -5,4 +5,3 @@ export function removeSegmentation(segmentationId) {
     segmentationStateManager.removeSegmentation(segmentationId);
     triggerSegmentationRemoved(segmentationId);
 }
-//# sourceMappingURL=removeSegmentation.js.map

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

@@ -1,2 +1,14 @@
-declare function removeSegmentationRepresentations(viewportId: string, segmentationRepresentationUIDs?: string[] | undefined, immediate?: boolean): void;
-export default removeSegmentationRepresentations;
+import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
+declare function removeSegmentationRepresentation(viewportId: string, specifier: {
+    segmentationId: string;
+    type: SegmentationRepresentations;
+}, immediate?: boolean): void;
+declare function removeSegmentationRepresentations(viewportId: string, specifier: {
+    segmentationId?: string;
+    type?: SegmentationRepresentations;
+}, immediate?: boolean): void;
+declare function removeAllSegmentationRepresentations(): void;
+declare function removeLabelmapRepresentation(viewportId: string, segmentationId: string, immediate?: boolean): void;
+declare function removeContourRepresentation(viewportId: string, segmentationId: string, immediate?: boolean): void;
+declare function removeSurfaceRepresentation(viewportId: string, segmentationId: string, immediate?: boolean): void;
+export { removeSegmentationRepresentation, removeSegmentationRepresentations, removeAllSegmentationRepresentations, removeLabelmapRepresentation, removeContourRepresentation, removeSurfaceRepresentation, };

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

@@ -1,27 +1,74 @@
 import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
 import labelmapDisplay from '../../tools/displayTools/Labelmap/labelmapDisplay';
 import contourDisplay from '../../tools/displayTools/Contour/contourDisplay';
-import { getSegmentationRepresentation } from './segmentationState';
-function removeSegmentationRepresentations(viewportId, segmentationRepresentationUIDs, immediate) {
-    if (!segmentationRepresentationUIDs) {
-        return;
-    }
-    segmentationRepresentationUIDs.forEach((segmentationDataUID) => {
-        _removeRepresentation(viewportId, segmentationDataUID, immediate);
+import { getSegmentationRepresentations } from './getSegmentationRepresentation';
+import { getEnabledElementByViewportId } from '@cornerstonejs/core';
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+function removeSegmentationRepresentation(viewportId, specifier, immediate) {
+    const { segmentationId, type } = specifier;
+    _removeRepresentation(viewportId, segmentationId, type, immediate);
+    defaultSegmentationStateManager.removeSegmentationRepresentation(viewportId, {
+        segmentationId,
+        type,
     });
 }
-function _removeRepresentation(viewportId, segmentationRepresentationUID, immediate) {
-    const segmentationRepresentation = getSegmentationRepresentation(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`);
+function removeSegmentationRepresentations(viewportId, specifier, immediate) {
+    const { segmentationId, type } = specifier;
+    _removeRepresentation(viewportId, segmentationId, type, immediate);
+    defaultSegmentationStateManager.removeSegmentationRepresentations(viewportId, {
+        segmentationId,
+        type,
+    });
+}
+function removeAllSegmentationRepresentations() {
+    const state = defaultSegmentationStateManager.getAllViewportSegmentationRepresentations();
+    state.forEach(({ viewportId, representations }) => {
+        representations.forEach(({ segmentationId, type }) => {
+            removeSegmentationRepresentation(viewportId, {
+                segmentationId,
+                type,
+            });
+        });
+    });
+    defaultSegmentationStateManager.resetState();
+}
+function removeLabelmapRepresentation(viewportId, segmentationId, immediate) {
+    removeSegmentationRepresentation(viewportId, {
+        segmentationId,
+        type: SegmentationRepresentations.Labelmap,
+    }, immediate);
+}
+function removeContourRepresentation(viewportId, segmentationId, immediate) {
+    removeSegmentationRepresentation(viewportId, {
+        segmentationId,
+        type: SegmentationRepresentations.Contour,
+    }, immediate);
+}
+function removeSurfaceRepresentation(viewportId, segmentationId, immediate) {
+    removeSegmentationRepresentation(viewportId, {
+        segmentationId,
+        type: SegmentationRepresentations.Surface,
+    }, immediate);
+}
+function _removeRepresentation(viewportId, segmentationId, type, immediate) {
+    const representations = getSegmentationRepresentations(viewportId, {
+        segmentationId,
+        type,
+    });
+    representations.forEach((representation) => {
+        if (representation.type === SegmentationRepresentations.Labelmap) {
+            labelmapDisplay.removeRepresentation(viewportId, segmentationId, immediate);
+        }
+        else if (representation.type === SegmentationRepresentations.Contour) {
+            contourDisplay.removeRepresentation(viewportId, segmentationId, immediate);
+        }
+        else {
+            throw new Error(`The representation ${representation.type} is not supported yet`);
+        }
+    });
+    const { viewport } = getEnabledElementByViewportId(viewportId) || {};
+    if (viewport) {
+        viewport.render();
     }
 }
-export default removeSegmentationRepresentations;
-//# sourceMappingURL=removeSegmentationRepresentations.js.map
+export { removeSegmentationRepresentation, removeSegmentationRepresentations, removeAllSegmentationRepresentations, removeLabelmapRepresentation, removeContourRepresentation, removeSurfaceRepresentation, };

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

@@ -4,21 +4,36 @@ import { getSegmentation } from './getSegmentation';
 import { getViewportIdsWithSegmentation } from './getViewportIdsWithSegmentation';
 import { triggerSegmentationModified } from './triggerSegmentationEvents';
 import { getActiveSegmentIndex } from './getActiveSegmentIndex';
+import { getSegmentationRepresentations } from './getSegmentationRepresentation';
 function setActiveSegmentIndex(segmentationId, segmentIndex) {
     const segmentation = getSegmentation(segmentationId);
     if (typeof segmentIndex === 'string') {
         console.warn('segmentIndex is a string, converting to number');
         segmentIndex = Number(segmentIndex);
     }
-    if (segmentation?.activeSegmentIndex !== segmentIndex) {
-        segmentation.activeSegmentIndex = segmentIndex;
+    Object.values(segmentation.segments).forEach((segment) => {
+        segment.active = false;
+    });
+    if (segmentation.segments[segmentIndex].active !== true) {
+        segmentation.segments[segmentIndex].active = true;
         triggerSegmentationModified(segmentationId);
     }
     const viewportIds = getViewportIdsWithSegmentation(segmentationId);
+    viewportIds.forEach((viewportId) => {
+        const representations = getSegmentationRepresentations(viewportId, {
+            segmentationId,
+        });
+        representations.forEach((representation) => {
+            if (!representation.segments[segmentIndex]) {
+                representation.segments[segmentIndex] = {
+                    visible: true,
+                };
+            }
+        });
+    });
     viewportIds.forEach((viewportId) => {
         const toolGroup = getToolGroupForViewport(viewportId);
         invalidateBrushCursor(toolGroup.id);
     });
 }
 export { setActiveSegmentIndex, getActiveSegmentIndex };
-//# sourceMappingURL=segmentIndex.js.map

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

@@ -5,21 +5,16 @@ function isSegmentIndexLocked(segmentationId, segmentIndex) {
     if (!segmentation) {
         throw new Error(`No segmentation state found for ${segmentationId}`);
     }
-    const { segmentsLocked } = segmentation;
-    return segmentsLocked.has(segmentIndex);
+    const { segments } = segmentation;
+    return segments[segmentIndex].locked;
 }
 function setSegmentIndexLocked(segmentationId, segmentIndex, locked = true) {
     const segmentation = getSegmentation(segmentationId);
     if (!segmentation) {
         throw new Error(`No segmentation state found for ${segmentationId}`);
     }
-    const { segmentsLocked } = segmentation;
-    if (locked) {
-        segmentsLocked.add(segmentIndex);
-    }
-    else {
-        segmentsLocked.delete(segmentIndex);
-    }
+    const { segments } = segmentation;
+    segments[segmentIndex].locked = locked;
     triggerSegmentationModified(segmentationId);
 }
 function getLockedSegmentIndices(segmentationId) {
@@ -27,8 +22,8 @@ function getLockedSegmentIndices(segmentationId) {
     if (!segmentation) {
         throw new Error(`No segmentation state found for ${segmentationId}`);
     }
-    const { segmentsLocked } = segmentation;
-    return Array.from(segmentsLocked);
+    const { segments } = segmentation;
+    const lockedSegmentIndices = Object.keys(segments).filter((segmentIndex) => segments[segmentIndex].locked);
+    return lockedSegmentIndices.map((segmentIndex) => parseInt(segmentIndex));
 }
 export { isSegmentIndexLocked, setSegmentIndexLocked, getLockedSegmentIndices };
-//# sourceMappingURL=segmentLocking.js.map

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

@@ -1,29 +1,17 @@
 import { getSegmentation } from './getSegmentation';
 import { getSegmentations } from './getSegmentations';
-import { addSegmentation } from './addSegmentation';
+import { addSegmentations } from './addSegmentations';
 import { removeSegmentation } from './removeSegmentation';
-import { getAllSegmentationRepresentations } from './getAllSegmentationRepresentations';
-import { getSegmentationRepresentation } from './getSegmentationRepresentation';
-import { removeRepresentation } from './removeRepresentation';
-import { getGlobalConfig } from './getGlobalConfig';
-import { setGlobalConfig } from './setGlobalConfig';
-import { getSegmentationRepresentationConfig } from './getSegmentationRepresentationConfig';
-import { setSegmentationRepresentationConfig } from './setSegmentationRepresentationConfig';
-import { getPerSegmentConfig } from './getPerSegmentConfig';
-import { setPerSegmentConfig } from './setPerSegmentConfig';
-import { getSegmentationRepresentations } from './getSegmentationRepresentations';
-import { getSegmentationRepresentationViewportStates } from './getSegmentationRepresentationViewportStates';
+import { removeLabelmapRepresentation, removeContourRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentation, removeAllSegmentationRepresentations } from './removeSegmentationRepresentations';
 import { addColorLUT } from './addColorLUT';
 import { getColorLUT } from './getColorLUT';
 import { getNextColorLUTIndex } from './getNextColorLUTIndex';
 import { removeColorLUT } from './removeColorLUT';
-import { getSegmentationRepresentationsForSegmentation } from './getSegmentationRepresentationsForSegmentation';
-import { getSegmentationRepresentationVisibility } from './getSegmentationRepresentationVisibility';
-import { setSegmentationRepresentationVisibility } from './setSegmentationRepresentationVisibility';
+import { getViewportSegmentations } from './getViewportSegmentations';
 import { getViewportIdsWithSegmentation } from './getViewportIdsWithSegmentation';
-import { getActiveSegmentationRepresentation } from './getActiveSegmentationRepresentation';
-import { setActiveSegmentationRepresentation } from './setActiveSegmentationRepresentation';
 import { getCurrentLabelmapImageIdForViewport } from './getCurrentLabelmapImageIdForViewport';
 import { updateLabelmapSegmentationImageReferences } from './updateLabelmapSegmentationImageReferences';
 import { getStackSegmentationImageIdsForViewport } from './getStackSegmentationImageIdsForViewport';
-export { getSegmentation, getSegmentations, addSegmentation, removeSegmentation, getAllSegmentationRepresentations, getSegmentationRepresentation, removeRepresentation, getGlobalConfig, setGlobalConfig, getSegmentationRepresentationConfig, setSegmentationRepresentationConfig, getPerSegmentConfig, setPerSegmentConfig, getSegmentationRepresentations, getSegmentationRepresentationViewportStates, addColorLUT, getColorLUT, getNextColorLUTIndex, removeColorLUT, getSegmentationRepresentationsForSegmentation, getSegmentationRepresentationVisibility, setSegmentationRepresentationVisibility, getViewportIdsWithSegmentation, getActiveSegmentationRepresentation, setActiveSegmentationRepresentation, getCurrentLabelmapImageIdForViewport, updateLabelmapSegmentationImageReferences, getStackSegmentationImageIdsForViewport, };
+import { getSegmentationRepresentation, getSegmentationRepresentations } from './getSegmentationRepresentation';
+declare function destroy(): void;
+export { getColorLUT, getCurrentLabelmapImageIdForViewport, getNextColorLUTIndex, getSegmentation, getSegmentations, getStackSegmentationImageIdsForViewport, getViewportIdsWithSegmentation, getSegmentationRepresentation, getSegmentationRepresentations, removeColorLUT, getViewportSegmentations, removeSegmentation, removeLabelmapRepresentation, removeContourRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentation, removeAllSegmentationRepresentations, addColorLUT, addSegmentations, updateLabelmapSegmentationImageReferences, destroy, };

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

@@ -1,30 +1,20 @@
 import { getSegmentation } from './getSegmentation';
 import { getSegmentations } from './getSegmentations';
-import { addSegmentation } from './addSegmentation';
+import { addSegmentations } from './addSegmentations';
 import { removeSegmentation } from './removeSegmentation';
-import { getAllSegmentationRepresentations } from './getAllSegmentationRepresentations';
-import { getSegmentationRepresentation } from './getSegmentationRepresentation';
-import { removeRepresentation } from './removeRepresentation';
-import { getGlobalConfig } from './getGlobalConfig';
-import { setGlobalConfig } from './setGlobalConfig';
-import { getSegmentationRepresentationConfig } from './getSegmentationRepresentationConfig';
-import { setSegmentationRepresentationConfig } from './setSegmentationRepresentationConfig';
-import { getPerSegmentConfig } from './getPerSegmentConfig';
-import { setPerSegmentConfig } from './setPerSegmentConfig';
-import { getSegmentationRepresentations } from './getSegmentationRepresentations';
-import { getSegmentationRepresentationViewportStates } from './getSegmentationRepresentationViewportStates';
+import { removeLabelmapRepresentation, removeContourRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentation, removeAllSegmentationRepresentations, } from './removeSegmentationRepresentations';
 import { addColorLUT } from './addColorLUT';
 import { getColorLUT } from './getColorLUT';
 import { getNextColorLUTIndex } from './getNextColorLUTIndex';
 import { removeColorLUT } from './removeColorLUT';
-import { getSegmentationRepresentationsForSegmentation } from './getSegmentationRepresentationsForSegmentation';
-import { getSegmentationRepresentationVisibility } from './getSegmentationRepresentationVisibility';
-import { setSegmentationRepresentationVisibility } from './setSegmentationRepresentationVisibility';
+import { getViewportSegmentations } from './getViewportSegmentations';
 import { getViewportIdsWithSegmentation } from './getViewportIdsWithSegmentation';
-import { getActiveSegmentationRepresentation } from './getActiveSegmentationRepresentation';
-import { setActiveSegmentationRepresentation } from './setActiveSegmentationRepresentation';
 import { getCurrentLabelmapImageIdForViewport } from './getCurrentLabelmapImageIdForViewport';
 import { updateLabelmapSegmentationImageReferences } from './updateLabelmapSegmentationImageReferences';
 import { getStackSegmentationImageIdsForViewport } from './getStackSegmentationImageIdsForViewport';
-export { getSegmentation, getSegmentations, addSegmentation, removeSegmentation, getAllSegmentationRepresentations, getSegmentationRepresentation, removeRepresentation, getGlobalConfig, setGlobalConfig, getSegmentationRepresentationConfig, setSegmentationRepresentationConfig, getPerSegmentConfig, setPerSegmentConfig, getSegmentationRepresentations, getSegmentationRepresentationViewportStates, addColorLUT, getColorLUT, getNextColorLUTIndex, removeColorLUT, getSegmentationRepresentationsForSegmentation, getSegmentationRepresentationVisibility, setSegmentationRepresentationVisibility, getViewportIdsWithSegmentation, getActiveSegmentationRepresentation, setActiveSegmentationRepresentation, getCurrentLabelmapImageIdForViewport, updateLabelmapSegmentationImageReferences, getStackSegmentationImageIdsForViewport, };
-//# sourceMappingURL=segmentationState.js.map
+import { getSegmentationRepresentation, getSegmentationRepresentations, } from './getSegmentationRepresentation';
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+function destroy() {
+    defaultSegmentationStateManager.resetState();
+}
+export { getColorLUT, getCurrentLabelmapImageIdForViewport, getNextColorLUTIndex, getSegmentation, getSegmentations, getStackSegmentationImageIdsForViewport, getViewportIdsWithSegmentation, getSegmentationRepresentation, getSegmentationRepresentations, removeColorLUT, getViewportSegmentations, removeSegmentation, removeLabelmapRepresentation, removeContourRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentation, removeAllSegmentationRepresentations, addColorLUT, addSegmentations, updateLabelmapSegmentationImageReferences, destroy, };

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

@@ -0,0 +1 @@
+export declare function setActiveSegmentation(viewportId: string, segmentationId: string): void;

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

@@ -0,0 +1,5 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function setActiveSegmentation(viewportId, segmentationId) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    segmentationStateManager.setActiveSegmentation(viewportId, segmentationId);
+}

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

@@ -0,0 +1,3 @@
+import type { SegmentationRepresentations } from '../../enums';
+import type { RepresentationStyle } from './SegmentationStyle';
+export declare function setGlobalStyle(type: SegmentationRepresentations, styles: RepresentationStyle, suppressEvents?: boolean): void;

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

@@ -0,0 +1,8 @@
+import { triggerSegmentationRender } from './SegmentationRenderingEngine';
+import { segmentationStyle } from './SegmentationStyle';
+export function setGlobalStyle(type, styles, suppressEvents) {
+    segmentationStyle.setStyle({ type }, styles);
+    if (!suppressEvents) {
+        triggerSegmentationRender();
+    }
+}

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

@@ -1 +1,5 @@
-export declare function setSegmentationRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string, visible: boolean): void;
+import type { SegmentationRepresentations } from '../../enums';
+export declare function setSegmentationRepresentationVisibility(viewportId: string, specifier: {
+    segmentationId: string;
+    type: SegmentationRepresentations;
+}, visible: boolean): void;

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

@@ -1,6 +1,5 @@
 import { defaultSegmentationStateManager } from './SegmentationStateManager';
-export function setSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID, visible) {
+export function setSegmentationRepresentationVisibility(viewportId, specifier, visible) {
     const segmentationStateManager = defaultSegmentationStateManager;
-    segmentationStateManager.setSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID, visible);
+    segmentationStateManager.setSegmentationRepresentationVisibility(viewportId, specifier, visible);
 }
-//# sourceMappingURL=setSegmentationRepresentationVisibility.js.map

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

@@ -1,6 +1,6 @@
-import { triggerSegmentationRepresentationModified } from './events/triggerSegmentationRepresentationModified';
-import { triggerSegmentationRepresentationRemoved } from './events/triggerSegmentationRepresentationRemoved';
 import { triggerSegmentationDataModified } from './events/triggerSegmentationDataModified';
 import { triggerSegmentationModified } from './events/triggerSegmentationModified';
 import { triggerSegmentationRemoved } from './events/triggerSegmentationRemoved';
-export { triggerSegmentationRepresentationModified, triggerSegmentationRepresentationRemoved, triggerSegmentationDataModified, triggerSegmentationModified, triggerSegmentationRemoved, };
+import { triggerSegmentationRepresentationModified } from './events/triggerSegmentationRepresentationModified';
+import { triggerSegmentationRepresentationRemoved } from './events/triggerSegmentationRepresentationRemoved';
+export { triggerSegmentationDataModified, triggerSegmentationModified, triggerSegmentationRemoved, triggerSegmentationRepresentationModified, triggerSegmentationRepresentationRemoved, };

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

@@ -1,7 +1,6 @@
-import { triggerSegmentationRepresentationModified } from './events/triggerSegmentationRepresentationModified';
-import { triggerSegmentationRepresentationRemoved } from './events/triggerSegmentationRepresentationRemoved';
 import { triggerSegmentationDataModified } from './events/triggerSegmentationDataModified';
 import { triggerSegmentationModified } from './events/triggerSegmentationModified';
 import { triggerSegmentationRemoved } from './events/triggerSegmentationRemoved';
-export { triggerSegmentationRepresentationModified, triggerSegmentationRepresentationRemoved, triggerSegmentationDataModified, triggerSegmentationModified, triggerSegmentationRemoved, };
-//# sourceMappingURL=triggerSegmentationEvents.js.map
+import { triggerSegmentationRepresentationModified } from './events/triggerSegmentationRepresentationModified';
+import { triggerSegmentationRepresentationRemoved } from './events/triggerSegmentationRepresentationRemoved';
+export { triggerSegmentationDataModified, triggerSegmentationModified, triggerSegmentationRemoved, triggerSegmentationRepresentationModified, triggerSegmentationRepresentationRemoved, };

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

@@ -3,4 +3,3 @@ export function updateLabelmapSegmentationImageReferences(viewportId, segmentati
     const segmentationStateManager = defaultSegmentationStateManager;
     segmentationStateManager.updateLabelmapSegmentationImageReferences(viewportId, segmentationId);
 }
-//# sourceMappingURL=updateLabelmapSegmentationImageReferences.js.map

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

@@ -0,0 +1,5 @@
+import type { Segmentation } from '../../types/SegmentationStateTypes';
+export declare function updateSegmentations(segmentationUpdateArray: {
+    segmentationId: string;
+    payload: Partial<Segmentation>;
+}[], suppressEvents?: boolean): void;

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

@@ -0,0 +1,11 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+import { triggerSegmentationModified } from './triggerSegmentationEvents';
+export function updateSegmentations(segmentationUpdateArray, suppressEvents) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    segmentationUpdateArray.forEach((segmentationUpdate) => {
+        segmentationStateManager.updateSegmentation(segmentationUpdate.segmentationId, segmentationUpdate.payload);
+        if (!suppressEvents) {
+            triggerSegmentationModified(segmentationUpdate.segmentationId);
+        }
+    });
+}

package/dist/esm/store/SynchronizerManager/Synchronizer.js

@@ -210,4 +210,3 @@ function _getViewportElement(vp) {
     return renderingEngine.getViewport(vp.viewportId).element;
 }
 export default Synchronizer;
-//# sourceMappingURL=Synchronizer.js.map

package/dist/esm/store/SynchronizerManager/createSynchronizer.js

@@ -10,4 +10,3 @@ function createSynchronizer(synchronizerId, eventName, eventHandler, options) {
     return synchronizer;
 }
 export default createSynchronizer;
-//# sourceMappingURL=createSynchronizer.js.map

package/dist/esm/store/SynchronizerManager/destroy.js

@@ -6,4 +6,3 @@ function destroy() {
     }
 }
 export default destroy;
-//# sourceMappingURL=destroy.js.map

package/dist/esm/store/SynchronizerManager/destroySynchronizer.js

@@ -8,4 +8,3 @@ function destroySynchronizer(synchronizerId) {
     }
 }
 export default destroySynchronizer;
-//# sourceMappingURL=destroySynchronizer.js.map

package/dist/esm/store/SynchronizerManager/getAllSynchronizers.js

@@ -3,4 +3,3 @@ function getAllSynchronizers() {
     return state.synchronizers;
 }
 export default getAllSynchronizers;
-//# sourceMappingURL=getAllSynchronizers.js.map

package/dist/esm/store/SynchronizerManager/getSynchronizer.js

@@ -3,4 +3,3 @@ function getSynchronizer(synchronizerId) {
     return state.synchronizers.find((s) => s.id === synchronizerId);
 }
 export default getSynchronizer;
-//# sourceMappingURL=getSynchronizer.js.map

package/dist/esm/store/SynchronizerManager/getSynchronizersForViewport.js

@@ -16,4 +16,3 @@ function getSynchronizersForViewport(viewportId, renderingEngineId) {
     return synchronizersFilteredByIds;
 }
 export default getSynchronizersForViewport;
-//# sourceMappingURL=getSynchronizersForViewport.js.map

package/dist/esm/store/SynchronizerManager/index.js

@@ -5,4 +5,3 @@ import getSynchronizer from './getSynchronizer';
 import getAllSynchronizers from './getAllSynchronizers';
 import destroySynchronizer from './destroySynchronizer';
 export { createSynchronizer, destroy, getSynchronizer, getSynchronizersForViewport, getAllSynchronizers, destroySynchronizer, };
-//# sourceMappingURL=index.js.map

package/dist/esm/store/ToolGroupManager/ToolGroup.d.ts

@@ -1,5 +1,5 @@
 import { MouseBindings, ToolModes } from '../../enums';
-import type { Types } from '@cornerstonejs/core';
+import { type Types } from '@cornerstonejs/core';
 import type { IToolBinding, IToolGroup, SetToolBindingsType, ToolOptionsType, ToolConfiguration } from '../../types';
 import { MouseCursor } from '../../cursors';
 export default class ToolGroup {
@@ -44,4 +44,5 @@ export default class ToolGroup {
     private _hasMousePrimaryButtonBinding;
     private _renderViewports;
     private _triggerToolModeChangedEvent;
+    private _findRenderingEngine;
 }

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

@@ -1,6 +1,7 @@
 import { MouseBindings, ToolModes, Events } from '../../enums';
 import get from 'lodash.get';
 import { triggerEvent, eventTarget, getRenderingEngine, getRenderingEngines, getEnabledElementByIds, Settings, } from '@cornerstonejs/core';
+import { utilities } from '@cornerstonejs/core';
 import { state } from '../state';
 import { MouseCursor, SVGMouseCursor } from '../../cursors';
 import { initElementCursor } from '../../cursors/elementCursor';
@@ -82,14 +83,7 @@ export default class ToolGroup {
         if (typeof viewportId !== 'string') {
             throw new Error('viewportId must be defined and be a string');
         }
-        const renderingEngines = getRenderingEngines();
-        if (renderingEngines?.length === 0) {
-            throw new Error('No rendering engines found.');
-        }
-        if (renderingEngines.length > 1) {
-            throw new Error('Multiple rendering engines found. You must specify a renderingEngineId.');
-        }
-        const renderingEngineUIDToUse = renderingEngineId || renderingEngines[0].id;
+        const renderingEngineUIDToUse = this._findRenderingEngine(viewportId, renderingEngineId);
         if (!this.viewportsInfo.some(({ viewportId: vpId }) => vpId === viewportId)) {
             this.viewportsInfo.push({
                 viewportId,
@@ -379,7 +373,7 @@ export default class ToolGroup {
         }
         const _configuration = get(this._toolInstances[toolName].configuration, configurationPath) ||
             this._toolInstances[toolName].configuration;
-        return structuredClone(_configuration);
+        return utilities.deepClone(_configuration);
     }
     getPrevActivePrimaryToolName() {
         return this.prevActivePrimaryToolName;
@@ -434,6 +428,26 @@ export default class ToolGroup {
         };
         triggerEvent(eventTarget, Events.TOOL_MODE_CHANGED, eventDetail);
     }
+    _findRenderingEngine(viewportId, renderingEngineId) {
+        const renderingEngines = getRenderingEngines();
+        if (renderingEngines?.length === 0) {
+            throw new Error('No rendering engines found.');
+        }
+        if (renderingEngineId) {
+            return renderingEngineId;
+        }
+        const matchingEngines = renderingEngines.filter((engine) => engine.getViewport(viewportId));
+        if (matchingEngines.length === 0) {
+            if (renderingEngines.length === 1) {
+                return renderingEngines[0].id;
+            }
+            throw new Error('No rendering engines found that contain the viewport with the same viewportId, you must specify a renderingEngineId.');
+        }
+        if (matchingEngines.length > 1) {
+            throw new Error('Multiple rendering engines found that contain the viewport with the same viewportId, you must specify a renderingEngineId.');
+        }
+        return matchingEngines[0].id;
+    }
 }
 function hasSameBinding(binding1, binding2) {
     if (binding1.mouseButton !== binding2.mouseButton) {
@@ -444,4 +458,3 @@ function hasSameBinding(binding1, binding2) {
     }
     return binding1.modifierKey === binding2.modifierKey;
 }
-//# sourceMappingURL=ToolGroup.js.map

package/dist/esm/store/ToolGroupManager/createToolGroup.d.ts

@@ -1,3 +1,3 @@
 import type { IToolGroup } from '../../types';
-declare function createToolGroup(toolGroupId: string): IToolGroup | undefined;
+declare function createToolGroup(toolGroupId: string): IToolGroup;
 export default createToolGroup;

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

@@ -1,14 +1,13 @@
 import { state } from '../state';
 import ToolGroup from './ToolGroup';
 function createToolGroup(toolGroupId) {
-    const toolGroupWithIdExists = state.toolGroups.some((tg) => tg.id === toolGroupId);
-    if (toolGroupWithIdExists) {
+    const toolGroupWithSameId = state.toolGroups.find((tg) => tg.id === toolGroupId);
+    if (toolGroupWithSameId) {
         console.warn(`'${toolGroupId}' already exists.`);
-        return;
+        return toolGroupWithSameId;
     }
     const toolGroup = new ToolGroup(toolGroupId);
     state.toolGroups.push(toolGroup);
     return toolGroup;
 }
 export default createToolGroup;
-//# sourceMappingURL=createToolGroup.js.map

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

@@ -8,4 +8,3 @@ function destroy() {
     state.toolGroups = [];
 }
 export default destroy;
-//# sourceMappingURL=destroy.js.map

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

@@ -6,4 +6,3 @@ function destroyToolGroup(toolGroupId) {
     }
 }
 export default destroyToolGroup;
-//# sourceMappingURL=destroyToolGroup.js.map

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

@@ -3,4 +3,3 @@ function getAllToolGroups() {
     return state.toolGroups;
 }
 export default getAllToolGroups;
-//# sourceMappingURL=getAllToolGroups.js.map

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

@@ -3,4 +3,3 @@ function getToolGroup(toolGroupId) {
     return state.toolGroups.find((s) => s.id === toolGroupId);
 }
 export default getToolGroup;
-//# sourceMappingURL=getToolGroup.js.map

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

@@ -16,4 +16,3 @@ function getToolGroupForViewport(viewportId, renderingEngineId) {
     return toolGroupFilteredByIds[0];
 }
 export default getToolGroupForViewport;
-//# sourceMappingURL=getToolGroupForViewport.js.map

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

@@ -19,4 +19,3 @@ function getToolGroupsWithToolName(toolName) {
     });
 }
 export default getToolGroupsWithToolName;
-//# sourceMappingURL=getToolGroupsWithToolName.js.map

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

@@ -6,4 +6,3 @@ import getToolGroupForViewport from './getToolGroupForViewport';
 import getAllToolGroups from './getAllToolGroups';
 import getToolGroupsWithToolName from './getToolGroupsWithToolName';
 export { createToolGroup, destroy, destroyToolGroup, getToolGroup, getToolGroupForViewport, getAllToolGroups, getToolGroupsWithToolName, };
-//# sourceMappingURL=index.js.map