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

package/dist/esm/stateManagement/segmentation/polySeg/Labelmap/computeAndAddLabelmapRepresentation.js

@@ -1,6 +1,13 @@
 import { SegmentationRepresentations } from '../../../../enums';
 import { computeAndAddRepresentation } from '../computeAndAddRepresentation';
 import { computeLabelmapData } from './labelmapComputationStrategies';
-export function computeAndAddLabelmapRepresentation(segmentationId, options = {}) {
-    return computeAndAddRepresentation(segmentationId, SegmentationRepresentations.Labelmap, () => computeLabelmapData(segmentationId, options), () => undefined);
+import { defaultSegmentationStateManager } from '../../SegmentationStateManager';
+import { triggerSegmentationDataModified } from '../../triggerSegmentationEvents';
+export async function computeAndAddLabelmapRepresentation(segmentationId, options = {}) {
+    return computeAndAddRepresentation(segmentationId, SegmentationRepresentations.Labelmap, () => computeLabelmapData(segmentationId, options), () => null, () => {
+        defaultSegmentationStateManager.processLabelmapRepresentationAddition(options.viewport.id, segmentationId);
+        setTimeout(() => {
+            triggerSegmentationDataModified(segmentationId);
+        }, 0);
+    });
 }

package/dist/esm/stateManagement/segmentation/polySeg/Labelmap/convertContourToLabelmap.js

@@ -17,7 +17,7 @@ export async function convertContourToVolumeLabelmap(contourRepresentationData,
         throw new Error('No imageIds found, labelmap computation from contour requires viewports with imageIds');
     }
     const segmentationVolumeId = utilities.uuidv4();
-    const segmentationVolume = volumeLoader.createAndCacheDerivedSegmentationVolume(volumeId, {
+    const segmentationVolume = volumeLoader.createAndCacheDerivedLabelmapVolume(volumeId, {
         volumeId: segmentationVolumeId,
     });
     const { dimensions, origin, direction, spacing, voxelManager } = segmentationVolume;
@@ -59,7 +59,7 @@ export async function convertContourToStackLabelmap(contourRepresentationData, o
             throw new Error('ImageIds must be cached before converting contour to labelmap');
         }
     });
-    const segImages = await imageLoader.createAndCacheDerivedSegmentationImages(imageIds);
+    const segImages = await imageLoader.createAndCacheDerivedLabelmapImages(imageIds);
     const segmentationImageIds = segImages.map((it) => it.imageId);
     const { segmentIndices, annotationUIDsInSegmentMap } = _getAnnotationMapFromSegmentation(contourRepresentationData, options);
     const segmentationsInfo = new Map();

package/dist/esm/stateManagement/segmentation/polySeg/Labelmap/labelmapComputationStrategies.js

@@ -3,7 +3,7 @@ import { getUniqueSegmentIndices } from '../../../../utilities/segmentation/getU
 import { getSegmentation } from '../../getSegmentation';
 import { convertContourToStackLabelmap, convertContourToVolumeLabelmap, } from './convertContourToLabelmap';
 import { convertSurfaceToVolumeLabelmap } from './convertSurfaceToLabelmap';
-import { computeStackSegmentationFromVolume } from '../../convertVolumeToStackSegmentation';
+import { computeStackLabelmapFromVolume } from '../../helpers/computeStackLabelmapFromVolume';
 export async function computeLabelmapData(segmentationId, options = {}) {
     const segmentIndices = options.segmentIndices?.length
         ? options.segmentIndices
@@ -49,7 +49,6 @@ async function computeLabelmapFromContourSegmentation(segmentationId, options =
         : convertContourToStackLabelmap;
     const result = await convertFunction(representationData, {
         segmentIndices,
-        segmentationRepresentationUID: options.segmentationRepresentationUID,
         viewport: options.viewport,
     });
     return result;
@@ -74,12 +73,11 @@ async function computeLabelmapFromSurfaceSegmentation(segmentationId, options =
     let segmentationVolume;
     if (isVolume) {
         const volumeId = viewport.getVolumeId();
-        segmentationVolume =
-            await volumeLoader.createAndCacheDerivedSegmentationVolume(volumeId);
+        segmentationVolume = await volumeLoader.createAndCacheDerivedLabelmapVolume(volumeId);
     }
     else {
         const imageIds = options.viewport.getImageIds();
-        const segImages = imageLoader.createAndCacheDerivedSegmentationImages(imageIds);
+        const segImages = imageLoader.createAndCacheDerivedLabelmapImages(imageIds);
         const segImageIds = segImages.map((image) => image.imageId);
         segmentationVolume = await volumeLoader.createAndCacheVolumeFromImages('generatedSegmentationVolumeId', segImageIds);
     }
@@ -87,7 +85,7 @@ async function computeLabelmapFromSurfaceSegmentation(segmentationId, options =
     if (isVolume) {
         return result;
     }
-    const stackData = (await computeStackSegmentationFromVolume({
+    const stackData = (await computeStackLabelmapFromVolume({
         volumeId: segmentationVolume.volumeId,
     }));
     return stackData;

package/dist/esm/stateManagement/segmentation/polySeg/Surface/convertLabelmapToSurface.d.ts

@@ -1,3 +1,3 @@
 import type { Types } from '@cornerstonejs/core';
 import type { LabelmapSegmentationData } from '../../../../types/LabelmapTypes';
-export declare function convertLabelmapToSurface(labelmapRepresentationData: LabelmapSegmentationData, segmentIndex: number, isVolume?: boolean): Promise<Types.SurfaceData>;
+export declare function convertLabelmapToSurface(labelmapRepresentationData: LabelmapSegmentationData, segmentIndex: number): Promise<Types.SurfaceData>;

package/dist/esm/stateManagement/segmentation/polySeg/Surface/convertLabelmapToSurface.js

@@ -1,5 +1,5 @@
 import { cache, eventTarget, getWebWorkerManager, triggerEvent, Enums, } from '@cornerstonejs/core';
-import { computeVolumeSegmentationFromStack } from '../../SegmentationStateManager';
+import { computeVolumeLabelmapFromStack } from '../../helpers/computeVolumeLabelmapFromStack';
 import { WorkerTypes } from '../../../../enums';
 const workerManager = getWebWorkerManager();
 const triggerWorkerProgress = (eventTarget, progress) => {
@@ -8,15 +8,15 @@ const triggerWorkerProgress = (eventTarget, progress) => {
         type: WorkerTypes.POLYSEG_LABELMAP_TO_SURFACE,
     });
 };
-export async function convertLabelmapToSurface(labelmapRepresentationData, segmentIndex, isVolume = true) {
+export async function convertLabelmapToSurface(labelmapRepresentationData, segmentIndex) {
     let volumeId;
-    if (isVolume) {
+    if (labelmapRepresentationData.volumeId) {
         volumeId = labelmapRepresentationData
             .volumeId;
     }
     else {
         const { imageIds } = labelmapRepresentationData;
-        ({ volumeId } = await computeVolumeSegmentationFromStack({
+        ({ volumeId } = await computeVolumeLabelmapFromStack({
             imageIds,
         }));
     }

package/dist/esm/stateManagement/segmentation/polySeg/Surface/createAndCacheSurfacesFromRaw.js

@@ -1,19 +1,13 @@
 import { Enums, geometryLoader } from '@cornerstonejs/core';
 import { getSegmentIndexColor } from '../../config/segmentationColor';
-import { getSegmentationRepresentation } from '../../getSegmentationRepresentation';
 import { getSegmentation } from '../../getSegmentation';
 export async function createAndCacheSurfacesFromRaw(segmentationId, rawSurfacesData, options = {}) {
-    let segmentationRepresentation;
-    if (options.segmentationRepresentationUID) {
-        segmentationRepresentation = getSegmentationRepresentation(options.segmentationRepresentationUID);
-    }
     const segmentation = getSegmentation(segmentationId);
     const geometryIds = new Map();
     const promises = Object.keys(rawSurfacesData).map(async (index) => {
         const rawSurfaceData = rawSurfacesData[index];
         const segmentIndex = rawSurfaceData.segmentIndex;
-        const color = segmentationRepresentation;
-        getSegmentIndexColor(segmentationRepresentation.segmentationRepresentationUID, segmentIndex).slice(0, 3);
+        const color = getSegmentIndexColor(options.viewport.id, segmentation.segmentationId, segmentIndex).slice(0, 3);
         if (!color) {
             throw new Error('No color found for segment index, unable to create surface');
         }

package/dist/esm/stateManagement/segmentation/polySeg/Surface/surfaceComputationStrategies.js

@@ -2,7 +2,6 @@ import { getUniqueSegmentIndices } from '../../../../utilities/segmentation/getU
 import { getSegmentation } from '../../getSegmentation';
 import { convertContourToSurface } from './convertContourToSurface';
 import { createAndCacheSurfacesFromRaw } from './createAndCacheSurfacesFromRaw';
-import { isVolumeSegmentation } from '../../../../tools/segmentation/strategies/utils/stackVolumeCheck';
 import { convertLabelmapToSurface } from './convertLabelmapToSurface';
 export async function computeSurfaceData(segmentationId, options = {}) {
     const segmentIndices = options.segmentIndices?.length
@@ -41,11 +40,10 @@ async function computeSurfaceFromLabelmapSegmentation(segmentationId, options =
         console.warn('Only support surface update from labelmaps');
         return;
     }
-    const isVolume = isVolumeSegmentation(segmentation.representationData.Labelmap);
     const labelmapRepresentationData = segmentation.representationData.Labelmap;
     const segmentIndices = options.segmentIndices || getUniqueSegmentIndices(segmentationId);
     const promises = segmentIndices.map((index) => {
-        const surface = convertLabelmapToSurface(labelmapRepresentationData, index, isVolume);
+        const surface = convertLabelmapToSurface(labelmapRepresentationData, index);
         return surface;
     });
     const surfaces = await Promise.allSettled(promises);

package/dist/esm/stateManagement/segmentation/polySeg/Surface/updateSurfaceData.js

@@ -1,7 +1,9 @@
 import { cache } from '@cornerstonejs/core';
 import { getUniqueSegmentIndices } from '../../../../utilities/segmentation/getUniqueSegmentIndices';
-import { getSegmentation, getSegmentationRepresentations, getViewportIdsWithSegmentation, } from '../../segmentationState';
+import { getViewportIdsWithSegmentation } from '../../getViewportIdsWithSegmentation';
+import { getSegmentation } from '../../getSegmentation';
 import { triggerSegmentationModified } from '../../triggerSegmentationEvents';
+import { getSegmentationRepresentation } from '../../getSegmentationRepresentation';
 import { SegmentationRepresentations } from '../../../../enums';
 import { computeSurfaceFromLabelmapSegmentation } from './surfaceComputationStrategies';
 import { createAndCacheSurfacesFromRaw } from './createAndCacheSurfacesFromRaw';
@@ -29,15 +31,14 @@ export async function updateSurfaceData(segmentationId) {
         if (!geometry) {
             const viewportIds = getViewportIdsWithSegmentation(segmentationId);
             return viewportIds.map((viewportId) => {
-                const segmentationRepresentations = getSegmentationRepresentations(viewportId);
-                return segmentationRepresentations.map((segmentationRepresentation) => {
-                    if (segmentationRepresentation.type !==
-                        SegmentationRepresentations.Surface) {
-                        return;
-                    }
+                const surfaceRepresentation = getSegmentationRepresentation(viewportId, {
+                    segmentationId,
+                    type: SegmentationRepresentations.Surface,
+                });
+                return [surfaceRepresentation].map((surfaceRepresentation) => {
                     segmentation.representationData.Surface.geometryIds.set(segmentIndex, geometryId);
                     return createAndCacheSurfacesFromRaw(segmentationId, [{ segmentIndex, data }], {
-                        segmentationRepresentationUID: segmentationRepresentation.segmentationRepresentationUID,
+                        segmentationId: surfaceRepresentation.segmentationId,
                     });
                 });
             });

package/dist/esm/stateManagement/segmentation/polySeg/canComputeRequestedRepresentation.d.ts

@@ -1,2 +1,3 @@
-declare function canComputeRequestedRepresentation(segmentationRepresentationUID: string): boolean;
+import { SegmentationRepresentations } from '../../../enums';
+declare function canComputeRequestedRepresentation(segmentationId: string, type: SegmentationRepresentations): boolean;
 export { canComputeRequestedRepresentation };

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

@@ -1,6 +1,5 @@
 import { SegmentationRepresentations } from '../../../enums';
 import { getSegmentation } from '../getSegmentation';
-import { getSegmentationRepresentation } from '../getSegmentationRepresentation';
 import { validate as validateLabelmap } from '../../../tools/displayTools/Labelmap/validateLabelmap';
 const conversionPaths = new Map([
     [
@@ -22,15 +21,10 @@ const conversionPaths = new Map([
         new Set([SegmentationRepresentations.Labelmap]),
     ],
 ]);
-function canComputeRequestedRepresentation(segmentationRepresentationUID) {
-    const segmentationRepresentation = getSegmentationRepresentation(segmentationRepresentationUID);
-    const { type: representationType, polySeg } = segmentationRepresentation;
-    if (!polySeg || !polySeg.enabled) {
-        return false;
-    }
-    const { representationData } = getSegmentation(segmentationRepresentation.segmentationId);
+function canComputeRequestedRepresentation(segmentationId, type) {
+    const { representationData } = getSegmentation(segmentationId);
     const existingRepresentationTypes = getExistingRepresentationTypes(representationData);
-    return existingRepresentationTypes.some((existingRepresentationType) => canConvertFromTo(existingRepresentationType, representationType));
+    return existingRepresentationTypes.some((existingRepresentationType) => canConvertFromTo(existingRepresentationType, type));
 }
 function getExistingRepresentationTypes(representationData) {
     const supportedTypes = [];

package/dist/esm/stateManagement/segmentation/polySeg/computeAndAddRepresentation.d.ts

@@ -1,3 +1,3 @@
 import type { SegmentationRepresentations } from '../../../enums';
-declare function computeAndAddRepresentation<T>(segmentationId: string, representationType: SegmentationRepresentations, computeFunction: () => Promise<T>, updateFunction?: () => void): Promise<T>;
+declare function computeAndAddRepresentation<T>(segmentationId: string, type: SegmentationRepresentations, computeFunction: () => Promise<T>, updateFunction?: () => void, onComputationComplete?: () => void): Promise<T>;
 export { computeAndAddRepresentation };

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

@@ -1,24 +1,26 @@
 import { eventTarget } from '@cornerstonejs/core';
 import { Events } from '../../../enums';
-import addRepresentationData from '../addRepresentationData';
+import addRepresentationData from '../internalAddRepresentationData';
 import { triggerSegmentationModified } from '../triggerSegmentationEvents';
 import debounce from '../../../utilities/debounce';
 import { registerPolySegWorker } from './registerPolySegWorker';
+import { defaultSegmentationStateManager } from '../SegmentationStateManager';
 const computedRepresentations = new Map();
-async function computeAndAddRepresentation(segmentationId, representationType, computeFunction, updateFunction) {
+async function computeAndAddRepresentation(segmentationId, type, computeFunction, updateFunction, onComputationComplete) {
     registerPolySegWorker();
     const data = await computeFunction();
     addRepresentationData({
         segmentationId,
-        type: representationType,
+        type,
         data,
     });
+    onComputationComplete?.();
     if (!computedRepresentations.has(segmentationId)) {
         computedRepresentations.set(segmentationId, []);
     }
     const representations = computedRepresentations.get(segmentationId);
-    if (!representations.includes(representationType)) {
-        representations.push(representationType);
+    if (!representations.includes(type)) {
+        representations.push(type);
     }
     subscribeToSegmentationChanges(updateFunction);
     triggerSegmentationModified(segmentationId);

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,26 +1,76 @@
 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;
+    defaultSegmentationStateManager.removeSegmentationRepresentations(viewportId, {
+        segmentationId,
+        type,
+    });
+    _removeRepresentation(viewportId, segmentationId, type, immediate);
+}
+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 === type) {
+            if (type === SegmentationRepresentations.Labelmap) {
+                labelmapDisplay.removeRepresentation(viewportId, segmentationId, immediate);
+            }
+            else if (type === SegmentationRepresentations.Contour) {
+                contourDisplay.removeRepresentation(viewportId, segmentationId, immediate);
+            }
+            else {
+                throw new Error(`The representation ${type} is not supported yet`);
+            }
+        }
+    });
+    const { viewport } = getEnabledElementByViewportId(viewportId);
+    if (viewport) {
+        viewport.render();
     }
 }
-export default removeSegmentationRepresentations;
+export { removeSegmentationRepresentation, removeSegmentationRepresentations, removeAllSegmentationRepresentations, removeLabelmapRepresentation, removeContourRepresentation, removeSurfaceRepresentation, };

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,29 +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, };
+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 { segmentationStyle } from './SegmentationStyle';
+import { triggerSegmentationModified } from './triggerSegmentationEvents';
+export function setGlobalStyle(type, styles, suppressEvents) {
+    segmentationStyle.setGlobalStyle(type, styles);
+    if (!suppressEvents) {
+        triggerSegmentationModified();
+    }
+}

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,5 +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);
 }

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

@@ -1,6 +1,4 @@
-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, };
+export { triggerSegmentationDataModified, triggerSegmentationModified, triggerSegmentationRemoved, };

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

@@ -1,6 +1,4 @@
-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, };
+export { triggerSegmentationDataModified, triggerSegmentationModified, triggerSegmentationRemoved, };

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) {

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,10 +1,10 @@
 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);