@cornerstonejs/tools 2.0.0-beta.20 → 2.0.0-beta.22

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: {
@@ -59,15 +59,15 @@ export default class SegmentationStateManager {
     removeSegmentation(segmentationId) {
         this.state.segmentations = this.state.segmentations.filter((segmentation) => segmentation.segmentationId !== segmentationId);
     }
-    getRepresentation(segmentationRepresentationUID) {
+    getSegmentationRepresentation(segmentationRepresentationUID) {
         return this.state.representations[segmentationRepresentationUID];
     }
-    addRepresentation(segmentationRepresentation) {
+    addSegmentationRepresentationState(segmentationRepresentation) {
         const { segmentationRepresentationUID } = segmentationRepresentation;
         this.state.representations[segmentationRepresentationUID] =
             segmentationRepresentation;
     }
-    addRepresentationToViewport(viewportId, segmentationRepresentationUID) {
+    addSegmentationRepresentationToViewport(viewportId, segmentationRepresentationUID) {
         const enabledElement = getEnabledElementByViewportId(viewportId);
         if (!enabledElement) {
             return;
@@ -75,20 +75,25 @@ export default class SegmentationStateManager {
         if (!this.state.viewports[viewportId]) {
             this.state.viewports[viewportId] = {};
         }
-        const representation = this.getRepresentation(segmentationRepresentationUID);
+        const representation = this.getSegmentationRepresentation(segmentationRepresentationUID);
         if (representation.type !== SegmentationRepresentations.Labelmap) {
-            this.setActiveRepresentation(viewportId, segmentationRepresentationUID);
+            this.setActiveSegmentationRepresentation(viewportId, segmentationRepresentationUID);
             return;
         }
         const volumeViewport = enabledElement.viewport instanceof BaseVolumeViewport;
         const segmentation = this.getSegmentation(representation.segmentationId);
         const { representationData } = segmentation;
+        const isLabelmap = representationData.LABELMAP;
+        if (!isLabelmap) {
+            this.setActiveSegmentationRepresentation(viewportId, segmentationRepresentationUID);
+            return;
+        }
         const isBaseVolumeSegmentation = 'volumeId' in representationData.LABELMAP;
         if (!volumeViewport) {
             if (isBaseVolumeSegmentation) {
             }
             else {
-                this.updateSegmentationImageReferences(viewportId, segmentation.segmentationId);
+                this.updateLabelmapSegmentationImageReferences(viewportId, segmentation.segmentationId);
             }
         }
         else {
@@ -104,9 +109,9 @@ export default class SegmentationStateManager {
             else {
             }
         }
-        this.setActiveRepresentation(viewportId, segmentationRepresentationUID);
+        this.setActiveSegmentationRepresentation(viewportId, segmentationRepresentationUID);
     }
-    updateSegmentationImageReferences(viewportId, segmentationId) {
+    updateLabelmapSegmentationImageReferences(viewportId, segmentationId) {
         const segmentation = this.getSegmentation(segmentationId);
         if (!segmentation) {
             return;
@@ -115,6 +120,9 @@ export default class SegmentationStateManager {
             this._stackLabelmapImageIdReferenceMap.set(segmentationId, new Map());
         }
         const { representationData } = segmentation;
+        if (!representationData.LABELMAP) {
+            return;
+        }
         const labelmapImageIds = this.getLabelmapImageIds(representationData);
         const enabledElement = getEnabledElementByViewportId(viewportId);
         const stackViewport = enabledElement.viewport;
@@ -147,7 +155,7 @@ export default class SegmentationStateManager {
         }
         return labelmapImageIds;
     }
-    getLabelmapImageIdsForViewport(viewportId, segmentationId) {
+    getCurrentLabelmapImageIdForViewport(viewportId, segmentationId) {
         const enabledElement = getEnabledElementByViewportId(viewportId);
         if (!enabledElement) {
             return;
@@ -160,13 +168,13 @@ export default class SegmentationStateManager {
         const imageIdReferenceMap = this._stackLabelmapImageIdReferenceMap.get(segmentationId);
         return imageIdReferenceMap.get(currentImageId);
     }
-    getRepresentationsForViewport(viewportId) {
+    getSegmentationRepresentations(viewportId) {
         const viewport = this.state.viewports[viewportId];
         if (!viewport) {
             return [];
         }
         return Object.keys(viewport).map((segRepUID) => {
-            return this.getRepresentation(segRepUID);
+            return this.getSegmentationRepresentation(segRepUID);
         });
     }
     removeRepresentation(segmentationRepresentationUID) {
@@ -175,7 +183,7 @@ export default class SegmentationStateManager {
             delete this.state.viewports[viewportId][segmentationRepresentationUID];
         });
     }
-    setActiveRepresentation(viewportId, segmentationRepresentationUID) {
+    setActiveSegmentationRepresentation(viewportId, segmentationRepresentationUID) {
         Object.keys(this.state.viewports[viewportId]).forEach((segRepUID) => {
             this.state.viewports[viewportId][segRepUID].active = false;
         });
@@ -192,7 +200,7 @@ export default class SegmentationStateManager {
         this.state.viewports[viewportId][segmentationRepresentationUID].active =
             true;
     }
-    getActiveRepresentation(viewportId) {
+    getActiveSegmentationRepresentation(viewportId) {
         if (!this.state.viewports?.[viewportId]) {
             return;
         }
@@ -200,7 +208,7 @@ export default class SegmentationStateManager {
         if (!activeSegRep) {
             return;
         }
-        return this.getRepresentation(activeSegRep[0]);
+        return this.getSegmentationRepresentation(activeSegRep[0]);
     }
     getGlobalConfig() {
         return this.state.globalConfig;
@@ -209,13 +217,13 @@ export default class SegmentationStateManager {
         this.state.globalConfig = config;
     }
     _getRepresentationConfig(segmentationRepresentationUID) {
-        const segmentationRepresentation = this.getRepresentation(segmentationRepresentationUID);
+        const segmentationRepresentation = this.getSegmentationRepresentation(segmentationRepresentationUID);
         if (!segmentationRepresentation) {
             return;
         }
         return segmentationRepresentation.config;
     }
-    getAllSegmentsConfig(segmentationRepresentationUID) {
+    getSegmentationRepresentationConfig(segmentationRepresentationUID) {
         const config = this._getRepresentationConfig(segmentationRepresentationUID);
         if (!config) {
             return;
@@ -229,7 +237,7 @@ export default class SegmentationStateManager {
         }
         return config.perSegment;
     }
-    setAllSegmentsConfig(segmentationRepresentationUID, config) {
+    setSegmentationRepresentationConfig(segmentationRepresentationUID, config) {
         const _config = this._getRepresentationConfig(segmentationRepresentationUID);
         if (!_config) {
             return;
@@ -243,11 +251,11 @@ export default class SegmentationStateManager {
         }
         _config.perSegment = config;
     }
-    getRepresentationVisibility(viewportId, segmentationRepresentationUID) {
+    getSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID) {
         const viewport = this.state.viewports[viewportId];
         return viewport && viewport[segmentationRepresentationUID]?.visible;
     }
-    setRepresentationVisibility(viewportId, segmentationRepresentationUID, visible) {
+    setSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID, visible) {
         if (!this.state.viewports[viewportId]) {
             this.state.viewports[viewportId] = {};
         }
@@ -269,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.d.ts

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

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

@@ -1,8 +1,17 @@
-import * as SegmentationState from './segmentationState';
-function getActiveRepresentation(viewportId) {
-    return SegmentationState.getActiveRepresentation(viewportId);
+import { getActiveSegmentationRepresentation as _getActiveSegmentationRepresentation } from './getActiveSegmentationRepresentation';
+import { setActiveSegmentationRepresentation as _setActiveSegmentationRepresentation } from './setActiveSegmentationRepresentation';
+import { getSegmentation } from './getSegmentation';
+function getActiveSegmentationRepresentation(viewportId) {
+    return _getActiveSegmentationRepresentation(viewportId);
 }
-function setActiveRepresentation(viewportId, segmentationRepresentationUID, suppressEvent = false) {
-    SegmentationState.setActiveRepresentation(viewportId, segmentationRepresentationUID, suppressEvent);
+function getActiveSegmentation(viewportId) {
+    const activeRepresentation = getActiveSegmentationRepresentation(viewportId);
+    if (!activeRepresentation) {
+        return null;
+    }
+    return getSegmentation(activeRepresentation.segmentationId);
 }
-export { getActiveRepresentation, setActiveRepresentation, };
+function setActiveSegmentationRepresentation(viewportId, segmentationRepresentationUID, suppressEvent = false) {
+    _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.d.ts

@@ -1,6 +1,6 @@
-import { LabelmapSegmentationData } from '../../types/LabelmapTypes';
-import { ContourSegmentationData } from '../../types/ContourTypes';
-import { SurfaceSegmentationData } from '../../types/SurfaceTypes';
+import type { LabelmapSegmentationData } from '../../types/LabelmapTypes';
+import type { ContourSegmentationData } from '../../types/ContourTypes';
+import type { SurfaceSegmentationData } from '../../types/SurfaceTypes';
 import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
 type SegmentationData = LabelmapSegmentationData | ContourSegmentationData | SurfaceSegmentationData;
 type AddRepresentationData = {

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.d.ts

@@ -0,0 +1,3 @@
+import type { SegmentationRepresentationConfig, RepresentationPublicInput } from '../../types/SegmentationStateTypes';
+declare function addSegmentationRepresentation(viewportId: string, representationInput: RepresentationPublicInput, initialConfig?: SegmentationRepresentationConfig): Promise<string>;
+export { addSegmentationRepresentation };

package/dist/esm/stateManagement/segmentation/{addRepresentation.js → 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 { getRepresentationRenderingConfig } from './helpers/getRepresentationRenderingConfig';
 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';
-async function addRepresentation(viewportId, representationInput, initialConfig) {
+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: getRepresentationRenderingConfig(representationInput),
+        rendering: renderingConfig,
         polySeg: options.polySeg,
         config: {
             allSegments: {},
             perSegment: {},
         },
     };
-    SegmentationState.addRepresentationToViewport(viewportId, representation);
+    addSegmentationRepresentationState(viewportId, representation);
     if (initialConfig) {
-        SegmentationState.setAllSegmentsConfig(segmentationRepresentationUID, initialConfig.representations);
+        setSegmentationRepresentationConfig(segmentationRepresentationUID, initialConfig.representations);
     }
     if (representationInput.type === SegmentationRepresentations.Contour) {
         triggerAnnotationRenderForViewportIds([viewportId]);
@@ -39,13 +60,13 @@ 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;
 }
-export { addRepresentation };
+export { addSegmentationRepresentation };

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/addSegmentationRepresentations.d.ts

@@ -0,0 +1,3 @@
+import type { SegmentationRepresentationConfig, RepresentationPublicInput } from '../../types/SegmentationStateTypes';
+declare function addSegmentationRepresentations(viewportId: string, representationInputArray: RepresentationPublicInput[], segmentationRepresentationConfig?: SegmentationRepresentationConfig): Promise<string[]>;
+export default addSegmentationRepresentations;

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

@@ -0,0 +1,9 @@
+import { addSegmentationRepresentation } from './addSegmentationRepresentation';
+async function addSegmentationRepresentations(viewportId, representationInputArray, segmentationRepresentationConfig) {
+    const promises = representationInputArray.map((representationInput) => {
+        return addSegmentationRepresentation(viewportId, representationInput, segmentationRepresentationConfig);
+    });
+    const segmentationRepresentationUIDs = await Promise.all(promises);
+    return segmentationRepresentationUIDs;
+}
+export default addSegmentationRepresentations;

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

@@ -1,3 +1,3 @@
-import { SegmentationPublicInput } from '../../types/SegmentationStateTypes';
+import type { SegmentationPublicInput } from '../../types/SegmentationStateTypes';
 declare function addSegmentations(segmentationInputArray: SegmentationPublicInput[]): void;
 export default addSegmentations;

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

@@ -1,4 +1,4 @@
 import * as color from './segmentationColor';
 import * as visibility from './segmentationVisibility';
-import { getGlobalConfig, getGlobalRepresentationConfig, setGlobalConfig, setGlobalRepresentationConfig, getAllSegmentsConfig, getPerSegmentConfig, getSegmentIndexConfig, setAllSegmentsConfig, setPerSegmentConfig, setSegmentIndexConfig } from './segmentationConfig';
-export { color, visibility, getGlobalConfig, getGlobalRepresentationConfig, setGlobalConfig, setGlobalRepresentationConfig, getAllSegmentsConfig, getPerSegmentConfig, getSegmentIndexConfig, setAllSegmentsConfig, setPerSegmentConfig, setSegmentIndexConfig, };
+import { getGlobalConfig, getGlobalRepresentationConfig, setGlobalConfig, setGlobalRepresentationConfig, getSegmentationRepresentationConfig, getPerSegmentConfig, getSegmentIndexConfig, setSegmentationRepresentationConfig, setPerSegmentConfig, setSegmentIndexConfig } from './segmentationConfig';
+export { color, visibility, getGlobalConfig, getGlobalRepresentationConfig, setGlobalConfig, setGlobalRepresentationConfig, getSegmentationRepresentationConfig, getPerSegmentConfig, getSegmentIndexConfig, setSegmentationRepresentationConfig, setPerSegmentConfig, setSegmentIndexConfig, };

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

@@ -1,4 +1,4 @@
 import * as color from './segmentationColor';
 import * as visibility from './segmentationVisibility';
-import { getGlobalConfig, getGlobalRepresentationConfig, setGlobalConfig, setGlobalRepresentationConfig, getAllSegmentsConfig, getPerSegmentConfig, getSegmentIndexConfig, setAllSegmentsConfig, setPerSegmentConfig, setSegmentIndexConfig, } from './segmentationConfig';
-export { color, visibility, getGlobalConfig, getGlobalRepresentationConfig, setGlobalConfig, setGlobalRepresentationConfig, getAllSegmentsConfig, getPerSegmentConfig, getSegmentIndexConfig, setAllSegmentsConfig, setPerSegmentConfig, setSegmentIndexConfig, };
+import { getGlobalConfig, getGlobalRepresentationConfig, setGlobalConfig, setGlobalRepresentationConfig, getSegmentationRepresentationConfig, getPerSegmentConfig, getSegmentIndexConfig, setSegmentationRepresentationConfig, setPerSegmentConfig, setSegmentIndexConfig, } from './segmentationConfig';
+export { color, visibility, getGlobalConfig, getGlobalRepresentationConfig, setGlobalConfig, setGlobalRepresentationConfig, getSegmentationRepresentationConfig, getPerSegmentConfig, getSegmentIndexConfig, setSegmentationRepresentationConfig, setPerSegmentConfig, setSegmentIndexConfig, };

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.getRepresentation(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.getRepresentation(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.d.ts

@@ -1,13 +1,13 @@
-import SegmentationRepresentations from '../../../enums/SegmentationRepresentations';
-import { RepresentationConfig, SegmentationRepresentationConfig, SegmentRepresentationConfig } from '../../../types/SegmentationStateTypes';
+import type SegmentationRepresentations from '../../../enums/SegmentationRepresentations';
+import type { RepresentationConfig, SegmentationRepresentationConfig, SegmentRepresentationConfig } from '../../../types/SegmentationStateTypes';
 declare function getGlobalConfig(): SegmentationRepresentationConfig;
 declare function setGlobalConfig(segmentationConfig: SegmentationRepresentationConfig): void;
 declare function getGlobalRepresentationConfig(representationType: SegmentationRepresentations): RepresentationConfig['LABELMAP'];
 declare function setGlobalRepresentationConfig(representationType: SegmentationRepresentations, config: RepresentationConfig['LABELMAP']): void;
-declare function getAllSegmentsConfig(segmentationRepresentationUID: string): RepresentationConfig;
-declare function setAllSegmentsConfig(segmentationRepresentationUID: string, config: RepresentationConfig): void;
+declare function getSegmentationRepresentationConfig(segmentationRepresentationUID: string): RepresentationConfig;
+declare function setSegmentationRepresentationConfig(segmentationRepresentationUID: string, config: RepresentationConfig): void;
 declare function setPerSegmentConfig(segmentationRepresentationUID: string, config: SegmentRepresentationConfig): void;
 declare function getPerSegmentConfig(segmentationRepresentationUID: string): SegmentRepresentationConfig;
 declare function setSegmentIndexConfig(segmentationRepresentationUID: string, segmentIndex: number, config: RepresentationConfig, suppressEvent?: boolean): void;
 declare function getSegmentIndexConfig(segmentationRepresentationUID: string, segmentIndex: number): RepresentationConfig;
-export { getGlobalConfig, setGlobalConfig, getGlobalRepresentationConfig, setGlobalRepresentationConfig, getAllSegmentsConfig, setAllSegmentsConfig, setPerSegmentConfig, getPerSegmentConfig, setSegmentIndexConfig, getSegmentIndexConfig, };
+export { getGlobalConfig, setGlobalConfig, getGlobalRepresentationConfig, setGlobalRepresentationConfig, getSegmentationRepresentationConfig, setSegmentationRepresentationConfig, setPerSegmentConfig, getPerSegmentConfig, setSegmentIndexConfig, getSegmentIndexConfig, };

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();
@@ -23,27 +28,27 @@ function setGlobalRepresentationConfig(representationType, config) {
         },
     });
 }
-function getAllSegmentsConfig(segmentationRepresentationUID) {
-    return SegmentationState.getAllSegmentsConfig(segmentationRepresentationUID);
+function getSegmentationRepresentationConfig(segmentationRepresentationUID) {
+    return _getSegmentationRepresentationConfig(segmentationRepresentationUID);
 }
-function setAllSegmentsConfig(segmentationRepresentationUID, config) {
-    SegmentationState.setAllSegmentsConfig(segmentationRepresentationUID, config);
+function 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, getAllSegmentsConfig, setAllSegmentsConfig, setPerSegmentConfig, getPerSegmentConfig, setSegmentIndexConfig, getSegmentIndexConfig, };
+export { getGlobalConfig, setGlobalConfig, getGlobalRepresentationConfig, setGlobalRepresentationConfig, getSegmentationRepresentationConfig, setSegmentationRepresentationConfig, setPerSegmentConfig, getPerSegmentConfig, setSegmentIndexConfig, getSegmentIndexConfig, };

package/dist/esm/stateManagement/segmentation/config/segmentationVisibility.d.ts

@@ -1,7 +1,7 @@
-declare function setRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string, visibility: boolean): void;
-declare function getRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string): boolean | undefined;
-declare function setSegmentsVisibility(viewport: string, segmentationRepresentationUID: string, segmentIndices: number[], visibility: boolean): void;
+declare function setSegmentationRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string, visibility: boolean): void;
+declare function getSegmentationRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string): boolean | undefined;
+declare function setSegmentIndicesVisibility(viewport: string, segmentationRepresentationUID: string, segmentIndices: number[], visibility: boolean): void;
 declare function setSegmentIndexVisibility(viewportId: string, segmentationRepresentationUID: string, segmentIndex: number, visibility: boolean): void;
 declare function getSegmentIndexVisibility(viewportId: string, segmentationRepresentationUID: string, segmentIndex: number): boolean;
-declare function getSegmentsHidden(viewportId: string, segmentationRepresentationUID: string): Set<number>;
-export { setRepresentationVisibility, getRepresentationVisibility, setSegmentsVisibility, setSegmentIndexVisibility, getSegmentIndexVisibility, getSegmentsHidden, };
+declare function getHiddenSegmentIndices(viewportId: string, segmentationRepresentationUID: string): Set<number>;
+export { setSegmentationRepresentationVisibility, getSegmentationRepresentationVisibility, setSegmentIndicesVisibility, setSegmentIndexVisibility, getSegmentIndexVisibility, getHiddenSegmentIndices, };