@cornerstonejs/tools 2.0.0-beta.21 → 2.0.0-beta.23

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

@@ -0,0 +1,2 @@
+import type { Annotation } from '../../types';
+export declare function getAnnotation(annotationUID: string): Annotation;

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

@@ -0,0 +1,6 @@
+import { defaultFrameOfReferenceSpecificAnnotationManager } from './FrameOfReferenceSpecificAnnotationManager';
+export function getAnnotation(annotationUID) {
+    const manager = defaultFrameOfReferenceSpecificAnnotationManager;
+    const annotation = manager.getAnnotation(annotationUID);
+    return annotation;
+}

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

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

package/dist/esm/stateManagement/index.js

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

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

@@ -15,5 +15,7 @@ declare class SegmentationRenderingEngine {
     _triggerRender(viewportId?: string): void;
     _addPlanarFreeHandToolIfAbsent(viewport: any): void;
 }
+declare function triggerSegmentationRender(viewportId?: string): void;
+declare function triggerSegmentationRenderBySegmentationId(segmentationId?: string): void;
 declare const segmentationRenderingEngine: SegmentationRenderingEngine;
-export { segmentationRenderingEngine };
+export { triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, segmentationRenderingEngine, };

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

@@ -1,11 +1,12 @@
 import { triggerEvent, eventTarget, Enums, getRenderingEngines, getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import { SegmentationRepresentations, Events as csToolsEvents, } from '../../enums';
 import Representations from '../../enums/SegmentationRepresentations';
-import { getSegmentationRepresentations } from '../../stateManagement/segmentation/segmentationState';
-import { surfaceDisplay } from '../../tools/displayTools/Surface';
-import { contourDisplay } from '../../tools/displayTools/Contour';
-import { labelmapDisplay } from '../../tools/displayTools/Labelmap';
-import { addTool, state } from '../../store';
+import { getSegmentationRepresentations } from './getSegmentationRepresentations';
+import surfaceDisplay from '../../tools/displayTools/Surface/surfaceDisplay';
+import contourDisplay from '../../tools/displayTools/Contour/contourDisplay';
+import labelmapDisplay from '../../tools/displayTools/Labelmap/labelmapDisplay';
+import { addTool } from '../../store/addTool';
+import { state } from '../../store/state';
 import PlanarFreehandContourSegmentationTool from '../../tools/annotation/PlanarFreehandContourSegmentationTool';
 import { getToolGroupForViewport } from '../../store/ToolGroupManager';
 const renderers = {
@@ -129,5 +130,11 @@ class SegmentationRenderingEngine {
         }
     }
 }
+function triggerSegmentationRender(viewportId) {
+    segmentationRenderingEngine.renderSegmentationsForViewport(viewportId);
+}
+function triggerSegmentationRenderBySegmentationId(segmentationId) {
+    segmentationRenderingEngine.renderSegmentation(segmentationId);
+}
 const segmentationRenderingEngine = new SegmentationRenderingEngine();
-export { segmentationRenderingEngine };
+export { triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, segmentationRenderingEngine, };

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

@@ -38,5 +38,21 @@ export default class SegmentationStateManager {
     removeColorLUT(colorLUTIndex: number): void;
     _getStackIdForImageIds(imageIds: string[]): string;
 }
+declare function computeVolumeSegmentationFromStack({ imageIds, options, }: {
+    imageIds: string[];
+    options?: {
+        volumeId?: string;
+    };
+}): Promise<{
+    volumeId: string;
+}>;
+declare function convertStackToVolumeSegmentation({ segmentationId, options, }: {
+    segmentationId: string;
+    options?: {
+        viewportId: string;
+        volumeId?: string;
+        removeOriginal?: boolean;
+    };
+}): Promise<void>;
 declare const defaultSegmentationStateManager: SegmentationStateManager;
-export { defaultSegmentationStateManager };
+export { convertStackToVolumeSegmentation, computeVolumeSegmentationFromStack, defaultSegmentationStateManager, };

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

@@ -1,9 +1,9 @@
-import { BaseVolumeViewport, cache, utilities as csUtils, getEnabledElementByViewportId, } from '@cornerstonejs/core';
-import { SegmentationRepresentations } from '../../enums';
+import { BaseVolumeViewport, cache, utilities as csUtils, getEnabledElementByViewportId, volumeLoader, eventTarget, } from '@cornerstonejs/core';
+import { SegmentationRepresentations, Events } from '../../enums';
 import getDefaultContourConfig from '../../tools/displayTools/Contour/contourConfig';
 import getDefaultLabelmapConfig from '../../tools/displayTools/Labelmap/labelmapConfig';
 import getDefaultSurfaceConfig from '../../tools/displayTools/Surface/surfaceConfig';
-import { convertStackToVolumeSegmentation } from './convertStackToVolumeSegmentation';
+import { triggerSegmentationDataModified } from './events/triggerSegmentationDataModified';
 const newGlobalConfig = {
     renderInactiveRepresentations: true,
     representations: {
@@ -277,5 +277,47 @@ export default class SegmentationStateManager {
             .join('_');
     }
 }
+async function computeVolumeSegmentationFromStack({ imageIds, options, }) {
+    const segmentationImageIds = imageIds;
+    const volumeId = options?.volumeId ?? csUtils.uuidv4();
+    await volumeLoader.createAndCacheVolumeFromImages(volumeId, segmentationImageIds);
+    return { volumeId };
+}
+async function convertStackToVolumeSegmentation({ segmentationId, options, }) {
+    const segmentation = defaultSegmentationStateManager.getSegmentation(segmentationId);
+    const data = segmentation.representationData
+        .LABELMAP;
+    const { volumeId } = await computeVolumeSegmentationFromStack({
+        imageIds: data.imageIds,
+        options,
+    });
+    await updateSegmentationState({
+        segmentationId,
+        viewportId: options.viewportId,
+        options,
+        volumeId,
+    });
+}
+async function updateSegmentationState({ segmentationId, viewportId, volumeId, options, }) {
+    const segmentation = defaultSegmentationStateManager.getSegmentation(segmentationId);
+    if (options?.removeOriginal) {
+        const data = segmentation.representationData
+            .LABELMAP;
+        const { imageIds } = data;
+        imageIds.forEach((imageId) => {
+            cache.removeImageLoadObject(imageId);
+        });
+        segmentation.representationData.LABELMAP = {
+            volumeId,
+        };
+    }
+    else {
+        segmentation.representationData.LABELMAP = {
+            ...segmentation.representationData.LABELMAP,
+            volumeId,
+        };
+    }
+    eventTarget.addEventListenerOnce(Events.SEGMENTATION_RENDERED, () => triggerSegmentationDataModified(segmentationId));
+}
 const defaultSegmentationStateManager = new SegmentationStateManager('DEFAULT');
-export { defaultSegmentationStateManager };
+export { convertStackToVolumeSegmentation, computeVolumeSegmentationFromStack, defaultSegmentationStateManager, };

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

@@ -1,15 +1,17 @@
-import * as SegmentationState from './segmentationState';
+import { getActiveSegmentationRepresentation as _getActiveSegmentationRepresentation } from './getActiveSegmentationRepresentation';
+import { setActiveSegmentationRepresentation as _setActiveSegmentationRepresentation } from './setActiveSegmentationRepresentation';
+import { getSegmentation } from './getSegmentation';
 function getActiveSegmentationRepresentation(viewportId) {
-    return SegmentationState.getActiveSegmentationRepresentation(viewportId);
+    return _getActiveSegmentationRepresentation(viewportId);
 }
 function getActiveSegmentation(viewportId) {
     const activeRepresentation = getActiveSegmentationRepresentation(viewportId);
     if (!activeRepresentation) {
         return null;
     }
-    return SegmentationState.getSegmentation(activeRepresentation.segmentationId);
+    return getSegmentation(activeRepresentation.segmentationId);
 }
 function setActiveSegmentationRepresentation(viewportId, segmentationRepresentationUID, suppressEvent = false) {
-    SegmentationState.setActiveSegmentationRepresentation(viewportId, segmentationRepresentationUID, suppressEvent);
+    _setActiveSegmentationRepresentation(viewportId, segmentationRepresentationUID, suppressEvent);
 }
 export { getActiveSegmentationRepresentation, getActiveSegmentation, setActiveSegmentationRepresentation, };

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

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export declare function addColorLUT(colorLUT: Types.ColorLUT, index: number): void;

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

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

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

@@ -1,4 +1,4 @@
-import { getSegmentation } from './segmentationState';
+import { getSegmentation } from './getSegmentation';
 import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
 function addRepresentationData({ segmentationId, type, data, }) {
     const segmentation = getSegmentation(segmentationId);

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

@@ -0,0 +1,2 @@
+import type { SegmentationPublicInput } from '../../types/SegmentationStateTypes';
+export declare function addSegmentation(segmentationInput: SegmentationPublicInput, suppressEvents?: boolean): void;

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

@@ -0,0 +1,11 @@
+import normalizeSegmentationInput from './helpers/normalizeSegmentationInput';
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+import { triggerSegmentationModified } from './triggerSegmentationEvents';
+export function addSegmentation(segmentationInput, suppressEvents) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    const segmentation = normalizeSegmentationInput(segmentationInput);
+    segmentationStateManager.addSegmentation(segmentation);
+    if (!suppressEvents) {
+        triggerSegmentationModified(segmentation.segmentationId);
+    }
+}

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

@@ -1,30 +1,51 @@
+import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
+import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
 import { utilities } from '@cornerstonejs/core';
-import * as SegmentationState from './segmentationState';
-import { getSegmentationRepresentationRenderingConfig } from './helpers/getSegmentationRepresentationRenderingConfig';
 import CORNERSTONE_COLOR_LUT from '../../constants/COLOR_LUT';
-import { triggerAnnotationRenderForViewportIds } from '../../utilities';
+import { triggerAnnotationRenderForViewportIds } from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { SegmentationRepresentations } from '../../enums';
 import { triggerSegmentationModified } from './triggerSegmentationEvents';
+import { addColorLUT } from './addColorLUT';
+import { getNextColorLUTIndex } from './getNextColorLUTIndex';
+import { setSegmentationRepresentationConfig } from './setSegmentationRepresentationConfig';
+import { addSegmentationRepresentationState } from './addSegmentationRepresentationState';
+function getLabelmapSegmentationRepresentationRenderingConfig() {
+    const cfun = vtkColorTransferFunction.newInstance();
+    const ofun = vtkPiecewiseFunction.newInstance();
+    ofun.addPoint(0, 0);
+    return {
+        ofun,
+        cfun,
+    };
+}
 async function addSegmentationRepresentation(viewportId, representationInput, initialConfig) {
     const { segmentationId, options = {} } = representationInput;
     const segmentationRepresentationUID = representationInput.options?.segmentationRepresentationUID ||
         utilities.uuidv4();
     const colorLUTIndexToUse = getColorLUTIndex(options);
+    const { type } = representationInput;
+    let renderingConfig;
+    if (type === SegmentationRepresentations.Labelmap) {
+        renderingConfig = getLabelmapSegmentationRepresentationRenderingConfig();
+    }
+    else {
+        renderingConfig = {};
+    }
     const representation = {
         segmentationId,
         segmentationRepresentationUID,
         type: representationInput.type,
         colorLUTIndex: colorLUTIndexToUse,
-        rendering: getSegmentationRepresentationRenderingConfig(representationInput),
+        rendering: renderingConfig,
         polySeg: options.polySeg,
         config: {
             allSegments: {},
             perSegment: {},
         },
     };
-    SegmentationState.addSegmentationRepresentation(viewportId, representation);
+    addSegmentationRepresentationState(viewportId, representation);
     if (initialConfig) {
-        SegmentationState.setSegmentationRepresentationConfig(segmentationRepresentationUID, initialConfig.representations);
+        setSegmentationRepresentationConfig(segmentationRepresentationUID, initialConfig.representations);
     }
     if (representationInput.type === SegmentationRepresentations.Contour) {
         triggerAnnotationRenderForViewportIds([viewportId]);
@@ -39,11 +60,11 @@ function getColorLUTIndex(options = {}) {
         colorLUTIndexToUse = colorLUTOrIndexInput;
     }
     else {
-        const nextIndex = SegmentationState.getNextColorLUTIndex();
+        const nextIndex = getNextColorLUTIndex();
         const colorLUTToAdd = Array.isArray(colorLUTOrIndexInput)
             ? colorLUTOrIndexInput
             : CORNERSTONE_COLOR_LUT;
-        SegmentationState.addColorLUT(colorLUTToAdd, nextIndex);
+        addColorLUT(colorLUTToAdd, nextIndex);
         colorLUTIndexToUse = nextIndex;
     }
     return colorLUTIndexToUse;

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

@@ -0,0 +1,2 @@
+import type { SegmentationRepresentation } from '../../types/SegmentationStateTypes';
+export declare function addSegmentationRepresentationState(viewportId: string, segmentationRepresentation: SegmentationRepresentation, suppressEvents?: boolean): void;

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

@@ -0,0 +1,10 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+import { triggerSegmentationRepresentationModified } from './triggerSegmentationEvents';
+export function addSegmentationRepresentationState(viewportId, segmentationRepresentation, suppressEvents) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    segmentationStateManager.addSegmentationRepresentationState(segmentationRepresentation);
+    segmentationStateManager.addSegmentationRepresentationToViewport(viewportId, segmentationRepresentation.segmentationRepresentationUID);
+    if (!suppressEvents) {
+        triggerSegmentationRepresentationModified(segmentationRepresentation.segmentationRepresentationUID);
+    }
+}

package/dist/esm/stateManagement/segmentation/config/segmentationColor.js

@@ -1,6 +1,8 @@
 import { utilities } from '@cornerstonejs/core';
-import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
 import { triggerSegmentationRepresentationModified } from '../triggerSegmentationEvents';
+import { addColorLUT as _addColorLUT } from '../addColorLUT';
+import { getColorLUT as _getColorLUT } from '../getColorLUT';
+import { getSegmentationRepresentation } from '../getSegmentationRepresentation';
 function addColorLUT(colorLUT, colorLUTIndex) {
     if (!colorLUT) {
         throw new Error('addColorLUT: colorLUT is required');
@@ -9,26 +11,26 @@ function addColorLUT(colorLUT, colorLUTIndex) {
         console.warn('addColorLUT: [0, 0, 0, 0] color is not provided for the background color (segmentIndex =0), automatically adding it');
         colorLUT.unshift([0, 0, 0, 0]);
     }
-    SegmentationState.addColorLUT(colorLUT, colorLUTIndex);
+    _addColorLUT(colorLUT, colorLUTIndex);
 }
 function setColorLUT(segmentationRepresentationUID, colorLUTIndex) {
-    const segRepresentation = SegmentationState.getSegmentationRepresentation(segmentationRepresentationUID);
+    const segRepresentation = getSegmentationRepresentation(segmentationRepresentationUID);
     if (!segRepresentation) {
         throw new Error(`setColorLUT: could not find segmentation representation with UID ${segmentationRepresentationUID}`);
     }
-    if (!SegmentationState.getColorLUT(colorLUTIndex)) {
+    if (!_getColorLUT(colorLUTIndex)) {
         throw new Error(`setColorLUT: could not find colorLUT with index ${colorLUTIndex}`);
     }
     segRepresentation.colorLUTIndex = colorLUTIndex;
     triggerSegmentationRepresentationModified(segmentationRepresentationUID);
 }
 function getSegmentIndexColor(segmentationRepresentationUID, segmentIndex) {
-    const segmentationRepresentation = SegmentationState.getSegmentationRepresentation(segmentationRepresentationUID);
+    const segmentationRepresentation = getSegmentationRepresentation(segmentationRepresentationUID);
     if (!segmentationRepresentation) {
         throw new Error(`segmentation representation with UID ${segmentationRepresentationUID} does not exist`);
     }
     const { colorLUTIndex } = segmentationRepresentation;
-    const colorLUT = SegmentationState.getColorLUT(colorLUTIndex);
+    const colorLUT = _getColorLUT(colorLUTIndex);
     let colorValue = colorLUT[segmentIndex];
     if (!colorValue) {
         if (typeof segmentIndex !== 'number') {

package/dist/esm/stateManagement/segmentation/config/segmentationConfig.js

@@ -1,10 +1,15 @@
-import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
 import { triggerSegmentationRepresentationModified } from '../triggerSegmentationEvents';
+import { getGlobalConfig as _getGlobalConfig } from '../getGlobalConfig';
+import { setGlobalConfig as _setGlobalConfig } from '../setGlobalConfig';
+import { getSegmentationRepresentationConfig as _getSegmentationRepresentationConfig } from '../getSegmentationRepresentationConfig';
+import { setSegmentationRepresentationConfig as _setSegmentationRepresentationConfig } from '../setSegmentationRepresentationConfig';
+import { setPerSegmentConfig as _setPerSegmentConfig } from '../setPerSegmentConfig';
+import { getPerSegmentConfig as _getPerSegmentConfig } from '../getPerSegmentConfig';
 function getGlobalConfig() {
-    return SegmentationState.getGlobalConfig();
+    return _getGlobalConfig();
 }
 function setGlobalConfig(segmentationConfig) {
-    SegmentationState.setGlobalConfig(segmentationConfig);
+    _setGlobalConfig(segmentationConfig);
 }
 function getGlobalRepresentationConfig(representationType) {
     const globalConfig = getGlobalConfig();
@@ -24,26 +29,26 @@ function setGlobalRepresentationConfig(representationType, config) {
     });
 }
 function getSegmentationRepresentationConfig(segmentationRepresentationUID) {
-    return SegmentationState.getSegmentationRepresentationConfig(segmentationRepresentationUID);
+    return _getSegmentationRepresentationConfig(segmentationRepresentationUID);
 }
 function setSegmentationRepresentationConfig(segmentationRepresentationUID, config) {
-    SegmentationState.setSegmentationRepresentationConfig(segmentationRepresentationUID, config);
+    _setSegmentationRepresentationConfig(segmentationRepresentationUID, config);
 }
 function setPerSegmentConfig(segmentationRepresentationUID, config) {
-    SegmentationState.setPerSegmentConfig(segmentationRepresentationUID, config);
+    _setPerSegmentConfig(segmentationRepresentationUID, config);
 }
 function getPerSegmentConfig(segmentationRepresentationUID) {
-    return SegmentationState.getPerSegmentConfig(segmentationRepresentationUID);
+    return _getPerSegmentConfig(segmentationRepresentationUID);
 }
 function setSegmentIndexConfig(segmentationRepresentationUID, segmentIndex, config, suppressEvent = false) {
-    const perSegment = SegmentationState.getPerSegmentConfig(segmentationRepresentationUID);
+    const perSegment = _getPerSegmentConfig(segmentationRepresentationUID);
     perSegment[segmentIndex] = config;
     if (!suppressEvent) {
         triggerSegmentationRepresentationModified(segmentationRepresentationUID);
     }
 }
 function getSegmentIndexConfig(segmentationRepresentationUID, segmentIndex) {
-    const perSegment = SegmentationState.getPerSegmentConfig(segmentationRepresentationUID);
+    const perSegment = _getPerSegmentConfig(segmentationRepresentationUID);
     return perSegment?.[segmentIndex];
 }
 export { getGlobalConfig, setGlobalConfig, getGlobalRepresentationConfig, setGlobalRepresentationConfig, getSegmentationRepresentationConfig, setSegmentationRepresentationConfig, setPerSegmentConfig, getPerSegmentConfig, setSegmentIndexConfig, getSegmentIndexConfig, };

package/dist/esm/stateManagement/segmentation/config/segmentationVisibility.js

@@ -1,15 +1,18 @@
-import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
+import { getSegmentationRepresentation } from '../getSegmentationRepresentation';
 import { triggerSegmentationRepresentationModified } from '../triggerSegmentationEvents';
+import { setSegmentationRepresentationVisibility as _setSegmentationRepresentationVisibility } from '../setSegmentationRepresentationVisibility';
+import { getSegmentationRepresentationVisibility as _getSegmentationRepresentationVisibility } from '../getSegmentationRepresentationVisibility';
+import { getSegmentationRepresentationViewportStates } from '../getSegmentationRepresentationViewportStates';
 function setSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID, visibility) {
-    const representation = SegmentationState.getSegmentationRepresentation(segmentationRepresentationUID);
+    const representation = getSegmentationRepresentation(segmentationRepresentationUID);
     if (!representation) {
         return;
     }
-    SegmentationState.setSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID, visibility);
+    _setSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID, visibility);
     triggerSegmentationRepresentationModified(segmentationRepresentationUID);
 }
 function getSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID) {
-    return SegmentationState.getSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID);
+    return _getSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID);
 }
 function setSegmentIndicesVisibility(viewport, segmentationRepresentationUID, segmentIndices, visibility) {
     const hiddenSegments = getHiddenSegmentIndices(viewport, segmentationRepresentationUID);
@@ -32,7 +35,7 @@ function getSegmentIndexVisibility(viewportId, segmentationRepresentationUID, se
     return !hiddenSegments.has(segmentIndex);
 }
 function getHiddenSegmentIndices(viewportId, segmentationRepresentationUID) {
-    const viewportRenderingState = SegmentationState.getSegmentationRepresentationViewportStates(viewportId);
+    const viewportRenderingState = getSegmentationRepresentationViewportStates(viewportId);
     if (!viewportRenderingState) {
         return new Set();
     }

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

@@ -11,11 +11,3 @@ export declare function convertVolumeToStackSegmentation({ segmentationId, optio
         removeOriginal?: boolean;
     };
 }): Promise<void>;
-export declare function updateStackSegmentationState({ segmentationId, viewportId, imageIds, options, }: {
-    segmentationId: string;
-    viewportId: string;
-    imageIds: string[];
-    options?: {
-        removeOriginal?: boolean;
-    };
-}): Promise<void>;

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

@@ -1,9 +1,6 @@
-import { cache, eventTarget } from '@cornerstonejs/core';
-import { Events, SegmentationRepresentations } from '../../enums';
-import addSegmentationRepresentations from './addSegmentationRepresentations';
-import { triggerSegmentationRender } from '../../utilities/segmentation';
-import { getSegmentation } from './segmentationState';
-import { triggerSegmentationDataModified } from './triggerSegmentationEvents';
+import { cache } from '@cornerstonejs/core';
+import { getSegmentation } from './getSegmentation';
+import { updateStackSegmentationState } from './helpers/updateStackSegmentationState';
 export async function computeStackSegmentationFromVolume({ volumeId, }) {
     const segmentationVolume = cache.getVolume(volumeId);
     return { imageIds: segmentationVolume.imageIds };
@@ -20,30 +17,3 @@ export async function convertVolumeToStackSegmentation({ segmentationId, options
         options,
     });
 }
-export async function updateStackSegmentationState({ segmentationId, viewportId, imageIds, options, }) {
-    const segmentation = getSegmentation(segmentationId);
-    if (options?.removeOriginal) {
-        const data = segmentation.representationData
-            .LABELMAP;
-        if (cache.getVolume(data.volumeId)) {
-            cache.removeVolumeLoadObject(data.volumeId);
-        }
-        segmentation.representationData.LABELMAP = {
-            imageIds,
-        };
-    }
-    else {
-        segmentation.representationData.LABELMAP = {
-            ...segmentation.representationData.LABELMAP,
-            imageIds,
-        };
-    }
-    await addSegmentationRepresentations(viewportId, [
-        {
-            segmentationId,
-            type: SegmentationRepresentations.Labelmap,
-        },
-    ]);
-    triggerSegmentationRender(viewportId);
-    eventTarget.addEventListenerOnce(Events.SEGMENTATION_RENDERED, () => triggerSegmentationDataModified(segmentationId));
-}

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationDataModified.d.ts

@@ -0,0 +1 @@
+export declare function triggerSegmentationDataModified(segmentationId: string, modifiedSlicesToUse?: number[]): void;

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationDataModified.js

@@ -0,0 +1,11 @@
+import { triggerEvent, eventTarget } from '@cornerstonejs/core';
+import { Events } from '../../../enums';
+import { setSegmentationDirty } from '../../../utilities/segmentation/utilities';
+export function triggerSegmentationDataModified(segmentationId, modifiedSlicesToUse) {
+    const eventDetail = {
+        segmentationId,
+        modifiedSlicesToUse,
+    };
+    setSegmentationDirty(segmentationId);
+    triggerEvent(eventTarget, Events.SEGMENTATION_DATA_MODIFIED, eventDetail);
+}

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationModified.d.ts

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

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationModified.js

@@ -0,0 +1,18 @@
+import { triggerEvent, eventTarget } from '@cornerstonejs/core';
+import { Events } from '../../../enums';
+import { getSegmentations } from '../getSegmentations';
+export function triggerSegmentationModified(segmentationId) {
+    let segmentationIds;
+    if (segmentationId) {
+        segmentationIds = [segmentationId];
+    }
+    else {
+        segmentationIds = getSegmentations().map(({ segmentationId }) => segmentationId);
+    }
+    segmentationIds.forEach((segmentationId) => {
+        const eventDetail = {
+            segmentationId,
+        };
+        triggerEvent(eventTarget, Events.SEGMENTATION_MODIFIED, eventDetail);
+    });
+}

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationRemoved.d.ts

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

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationRemoved.js

@@ -0,0 +1,8 @@
+import { triggerEvent, eventTarget } from '@cornerstonejs/core';
+import { Events } from '../../../enums';
+export function triggerSegmentationRemoved(segmentationId) {
+    const eventDetail = {
+        segmentationId,
+    };
+    triggerEvent(eventTarget, Events.SEGMENTATION_REMOVED, eventDetail);
+}

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationRepresentationModified.d.ts

@@ -0,0 +1 @@
+export declare function triggerSegmentationRepresentationModified(segmentationRepresentationUID: string): void;

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationRepresentationModified.js

@@ -0,0 +1,8 @@
+import { triggerEvent, eventTarget } from '@cornerstonejs/core';
+import { Events } from '../../../enums';
+export function triggerSegmentationRepresentationModified(segmentationRepresentationUID) {
+    const eventDetail = {
+        segmentationRepresentationUID,
+    };
+    triggerEvent(eventTarget, Events.SEGMENTATION_REPRESENTATION_MODIFIED, eventDetail);
+}

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationRepresentationRemoved.d.ts

@@ -0,0 +1 @@
+export declare function triggerSegmentationRepresentationRemoved(segmentationRepresentationUID: string): void;

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationRepresentationRemoved.js

@@ -0,0 +1,8 @@
+import { triggerEvent, eventTarget } from '@cornerstonejs/core';
+import { Events } from '../../../enums';
+export function triggerSegmentationRepresentationRemoved(segmentationRepresentationUID) {
+    const eventDetail = {
+        segmentationRepresentationUID,
+    };
+    triggerEvent(eventTarget, Events.SEGMENTATION_REPRESENTATION_REMOVED, eventDetail);
+}

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

@@ -0,0 +1 @@
+export declare function getActiveSegmentIndex(segmentationId: string): number | undefined;

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

@@ -0,0 +1,7 @@
+import { getSegmentation } from './getSegmentation';
+export function getActiveSegmentIndex(segmentationId) {
+    const segmentation = getSegmentation(segmentationId);
+    if (segmentation) {
+        return segmentation.activeSegmentIndex;
+    }
+}

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

@@ -0,0 +1,2 @@
+import type { SegmentationRepresentation } from '../../types/SegmentationStateTypes';
+export declare function getActiveSegmentationRepresentation(viewportId: string): SegmentationRepresentation | undefined;

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

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

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

@@ -0,0 +1,2 @@
+import type { SegmentationRepresentation } from '../../types/SegmentationStateTypes';
+export declare function getAllSegmentationRepresentations(): SegmentationRepresentation[];

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

@@ -0,0 +1,6 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function getAllSegmentationRepresentations() {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    const state = segmentationStateManager.getState();
+    return Object.values(state.representations);
+}

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

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export declare function getColorLUT(index: number): Types.ColorLUT | undefined;

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

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

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

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