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

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

@@ -1,47 +1,65 @@
 import type { Types } from '@cornerstonejs/core';
-import type { GlobalConfig, RepresentationConfig, Segmentation, SegmentationRepresentation, SegmentationState } from '../../types/SegmentationStateTypes';
+import { SegmentationRepresentations } from '../../enums';
+import type { RenderingConfig, Segmentation, SegmentationRepresentation, SegmentationState } from '../../types/SegmentationStateTypes';
 export default class SegmentationStateManager {
     private state;
     readonly uid: string;
     private _stackLabelmapImageIdReferenceMap;
     constructor(uid?: string);
-    getState(): SegmentationState;
+    getState(): Readonly<SegmentationState>;
+    private updateState;
     getColorLUT(lutIndex: number): Types.ColorLUT | undefined;
     getNextColorLUTIndex(): number;
     resetState(): void;
     getSegmentation(segmentationId: string): Segmentation | undefined;
     addSegmentation(segmentation: Segmentation): void;
     removeSegmentation(segmentationId: string): void;
-    getSegmentationRepresentation(segmentationRepresentationUID: string): SegmentationRepresentation | undefined;
-    addSegmentationRepresentationState(segmentationRepresentation: SegmentationRepresentation): void;
-    addSegmentationRepresentationToViewport(viewportId: string, segmentationRepresentationUID: string): void;
-    _updateLabelmapSegmentationReferences(segmentationId: any, stackViewport: any, labelmapImageIds: any, updateCallback: any): string;
+    addSegmentationRepresentation(viewportId: string, segmentationId: string, type: SegmentationRepresentations, renderingConfig: RenderingConfig): void;
+    private addDefaultSegmentationRepresentation;
+    addLabelmapRepresentation(state: SegmentationState, viewportId: string, segmentationId: string, renderingConfig?: RenderingConfig): void;
+    processLabelmapRepresentationAddition(viewportId: string, segmentationId: string): void;
+    _updateLabelmapSegmentationReferences(segmentationId: any, viewport: any, labelmapImageIds: any, updateCallback: any): string;
     updateLabelmapSegmentationImageReferences(viewportId: any, segmentationId: any): string;
     _updateAllLabelmapSegmentationImageReferences(viewportId: any, segmentationId: any): void;
     private getLabelmapImageIds;
     getCurrentLabelmapImageIdForViewport(viewportId: string, segmentationId: string): string | undefined;
     getStackSegmentationImageIdsForViewport(viewportId: string, segmentationId: string): string[];
-    getSegmentationRepresentations(viewportId: string): SegmentationRepresentation[];
-    removeRepresentation(segmentationRepresentationUID: string): void;
-    setActiveSegmentationRepresentation(viewportId: string, segmentationRepresentationUID: string): void;
-    getActiveSegmentationRepresentation(viewportId: string): SegmentationRepresentation | undefined;
-    getGlobalConfig(): GlobalConfig;
-    setGlobalConfig(config: GlobalConfig): void;
-    _getRepresentationConfig(segmentationRepresentationUID: string): {
-        allSegments?: RepresentationConfig;
-        perSegment?: RepresentationConfig;
-    };
-    getSegmentationRepresentationConfig(segmentationRepresentationUID: string): RepresentationConfig;
-    getPerSegmentConfig(segmentationRepresentationUID: string): RepresentationConfig;
-    setSegmentationRepresentationConfig(segmentationRepresentationUID: string, config: RepresentationConfig): void;
-    setPerSegmentConfig(segmentationRepresentationUID: string, config: RepresentationConfig): void;
-    getSegmentationRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string): boolean;
-    setSegmentationRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string, visible: boolean): void;
+    removeSegmentationRepresentations(viewportId: string, specifier?: {
+        segmentationId?: string;
+        type?: SegmentationRepresentations;
+    }): void;
+    removeSegmentationRepresentation(viewportId: string, specifier: {
+        segmentationId: string;
+        type: SegmentationRepresentations;
+    }): void;
+    _setActiveSegmentation(state: SegmentationState, viewportId: string, segmentationId: string): void;
+    setActiveSegmentation(viewportId: string, segmentationId: string): void;
+    getActiveSegmentation(viewportId: string): Segmentation | undefined;
+    getSegmentationRepresentations(viewportId: string, specifier?: {
+        segmentationId?: string;
+        type?: SegmentationRepresentations;
+    }): SegmentationRepresentation[];
+    getSegmentationRepresentation(viewportId: string, specifier: {
+        segmentationId: string;
+        type: SegmentationRepresentations;
+    }): SegmentationRepresentation | undefined;
+    getSegmentationRepresentationVisibility(viewportId: string, specifier: {
+        segmentationId: string;
+        type: SegmentationRepresentations;
+    }): boolean;
+    setSegmentationRepresentationVisibility(viewportId: string, specifier: {
+        segmentationId: string;
+        type: SegmentationRepresentations;
+    }, visible: boolean): void;
     addColorLUT(colorLUT: Types.ColorLUT, lutIndex: number): void;
     removeColorLUT(colorLUTIndex: number): void;
     _getStackIdForImageIds(imageIds: string[]): string;
+    getAllViewportSegmentationRepresentations(): Array<{
+        viewportId: string;
+        representations: SegmentationRepresentation[];
+    }>;
 }
-declare function computeVolumeSegmentationFromStack({ imageIds, options, }: {
+declare function internalComputeVolumeLabelmapFromStack({ imageIds, options, }: {
     imageIds: string[];
     options?: {
         volumeId?: string;
@@ -49,7 +67,7 @@ declare function computeVolumeSegmentationFromStack({ imageIds, options, }: {
 }): Promise<{
     volumeId: string;
 }>;
-declare function convertStackToVolumeSegmentation({ segmentationId, options, }: {
+declare function internalConvertStackToVolumeLabelmap({ segmentationId, options, }: {
     segmentationId: string;
     options?: {
         viewportId: string;
@@ -58,4 +76,4 @@ declare function convertStackToVolumeSegmentation({ segmentationId, options, }:
     };
 }): Promise<void>;
 declare const defaultSegmentationStateManager: SegmentationStateManager;
-export { convertStackToVolumeSegmentation, computeVolumeSegmentationFromStack, defaultSegmentationStateManager, };
+export { internalConvertStackToVolumeLabelmap, internalComputeVolumeLabelmapFromStack, defaultSegmentationStateManager, };

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

@@ -1,36 +1,28 @@
-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 { triggerSegmentationDataModified } from './events/triggerSegmentationDataModified';
-const newGlobalConfig = {
-    renderInactiveRepresentations: true,
-    representations: {
-        [SegmentationRepresentations.Labelmap]: getDefaultLabelmapConfig(),
-        [SegmentationRepresentations.Contour]: getDefaultContourConfig(),
-        [SegmentationRepresentations.Surface]: getDefaultSurfaceConfig(),
-    },
-};
+import { BaseVolumeViewport, cache, utilities as csUtils, getEnabledElementByViewportId, volumeLoader, } from '@cornerstonejs/core';
+import { SegmentationRepresentations } from '../../enums';
+import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
+import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
+import { segmentationStyle } from './SegmentationStyle';
 const initialDefaultState = {
     colorLUT: [],
     segmentations: [],
-    globalConfig: newGlobalConfig,
-    representations: {},
-    viewports: {},
+    viewportSegRepresentations: {},
 };
 export default class SegmentationStateManager {
     constructor(uid) {
         this._stackLabelmapImageIdReferenceMap = new Map();
-        if (!uid) {
-            uid = csUtils.uuidv4();
-        }
-        this.state = structuredClone(initialDefaultState);
+        uid ||= csUtils.uuidv4();
+        this.state = Object.freeze(csUtils.deepClone(initialDefaultState));
         this.uid = uid;
     }
     getState() {
         return this.state;
     }
+    updateState(updater) {
+        const newState = csUtils.deepClone(this.state);
+        updater(newState);
+        this.state = Object.freeze(newState);
+    }
     getColorLUT(lutIndex) {
         return this.state.colorLUT[lutIndex];
     }
@@ -38,7 +30,7 @@ export default class SegmentationStateManager {
         return this.state.colorLUT.length;
     }
     resetState() {
-        this.state = structuredClone(initialDefaultState);
+        this.state = Object.freeze(csUtils.deepClone(initialDefaultState));
     }
     getSegmentation(segmentationId) {
         return this.state.segmentations.find((segmentation) => segmentation.segmentationId === segmentationId);
@@ -47,47 +39,85 @@ export default class SegmentationStateManager {
         if (this.getSegmentation(segmentation.segmentationId)) {
             throw new Error(`Segmentation with id ${segmentation.segmentationId} already exists`);
         }
-        if (segmentation.representationData.Labelmap &&
-            'volumeId' in segmentation.representationData.Labelmap &&
-            !('imageIds' in segmentation.representationData.Labelmap)) {
-            const imageIds = this.getLabelmapImageIds(segmentation.representationData);
-            segmentation.representationData
-                .Labelmap.imageIds = imageIds;
-        }
-        this.state.segmentations.push(segmentation);
+        this.updateState((state) => {
+            const newSegmentation = csUtils.deepClone(segmentation);
+            if (newSegmentation.representationData.Labelmap &&
+                'volumeId' in newSegmentation.representationData.Labelmap &&
+                !('imageIds' in newSegmentation.representationData.Labelmap)) {
+                const imageIds = this.getLabelmapImageIds(newSegmentation.representationData);
+                newSegmentation.representationData
+                    .Labelmap.imageIds = imageIds;
+            }
+            state.segmentations.push(newSegmentation);
+        });
     }
     removeSegmentation(segmentationId) {
-        this.state.segmentations = this.state.segmentations.filter((segmentation) => segmentation.segmentationId !== segmentationId);
+        this.updateState((state) => {
+            state.segmentations = state.segmentations.filter((segmentation) => segmentation.segmentationId !== segmentationId);
+            Object.values(state.viewportSegRepresentations).forEach((representations) => {
+                representations = representations.filter((representation) => representation.segmentationId !== segmentationId);
+            });
+        });
     }
-    getSegmentationRepresentation(segmentationRepresentationUID) {
-        return this.state.representations[segmentationRepresentationUID];
+    addSegmentationRepresentation(viewportId, segmentationId, type, renderingConfig) {
+        const enabledElement = getEnabledElementByViewportId(viewportId);
+        if (!enabledElement) {
+            return;
+        }
+        this.updateState((state) => {
+            if (!state.viewportSegRepresentations[viewportId]) {
+                state.viewportSegRepresentations[viewportId] = [];
+                segmentationStyle.setViewportRenderInactiveSegmentations(viewportId, true);
+            }
+            if (type !== SegmentationRepresentations.Labelmap) {
+                this.addDefaultSegmentationRepresentation(state, viewportId, segmentationId, type, renderingConfig);
+            }
+            else {
+                this.addLabelmapRepresentation(state, viewportId, segmentationId, renderingConfig);
+            }
+        });
     }
-    addSegmentationRepresentationState(segmentationRepresentation) {
-        const { segmentationRepresentationUID } = segmentationRepresentation;
-        this.state.representations[segmentationRepresentationUID] =
-            segmentationRepresentation;
+    addDefaultSegmentationRepresentation(state, viewportId, segmentationId, type, renderingConfig) {
+        state.viewportSegRepresentations[viewportId].push({
+            segmentationId,
+            type,
+            active: true,
+            visible: true,
+            segmentsHidden: new Set(),
+            config: {
+                ...getDefaultRenderingConfig(type),
+                ...renderingConfig,
+            },
+        });
+        this._setActiveSegmentation(state, viewportId, segmentationId);
     }
-    addSegmentationRepresentationToViewport(viewportId, segmentationRepresentationUID) {
+    addLabelmapRepresentation(state, viewportId, segmentationId, renderingConfig = getDefaultRenderingConfig(SegmentationRepresentations.Labelmap)) {
         const enabledElement = getEnabledElementByViewportId(viewportId);
         if (!enabledElement) {
             return;
         }
-        if (!this.state.viewports[viewportId]) {
-            this.state.viewports[viewportId] = {};
-        }
-        const representation = this.getSegmentationRepresentation(segmentationRepresentationUID);
-        if (representation.type !== SegmentationRepresentations.Labelmap) {
-            this.setActiveSegmentationRepresentation(viewportId, segmentationRepresentationUID);
+        const segmentation = this.getSegmentation(segmentationId);
+        if (!segmentation) {
             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);
+        if (!representationData.Labelmap) {
+            return this.addDefaultSegmentationRepresentation(state, viewportId, segmentationId, SegmentationRepresentations.Labelmap, renderingConfig);
+        }
+        this.processLabelmapRepresentationAddition(viewportId, segmentationId);
+        this.addDefaultSegmentationRepresentation(state, viewportId, segmentationId, SegmentationRepresentations.Labelmap, renderingConfig);
+    }
+    processLabelmapRepresentationAddition(viewportId, segmentationId) {
+        const enabledElement = getEnabledElementByViewportId(viewportId);
+        if (!enabledElement) {
+            return;
+        }
+        const segmentation = this.getSegmentation(segmentationId);
+        if (!segmentation) {
             return;
         }
+        const volumeViewport = enabledElement.viewport instanceof BaseVolumeViewport;
+        const { representationData } = segmentation;
         const isBaseVolumeSegmentation = 'volumeId' in representationData.Labelmap;
         if (!volumeViewport) {
             if (isBaseVolumeSegmentation) {
@@ -103,18 +133,17 @@ export default class SegmentationStateManager {
                 const imageIds = this.getLabelmapImageIds(segmentation.representationData);
                 const segImage = cache.getImage(imageIds[0]);
                 if (segImage?.FrameOfReferenceUID === frameOfReferenceUID) {
-                    convertStackToVolumeSegmentation(segmentation);
+                    internalConvertStackToVolumeLabelmap(segmentation);
                 }
             }
             else {
             }
         }
-        this.setActiveSegmentationRepresentation(viewportId, segmentationRepresentationUID);
     }
-    _updateLabelmapSegmentationReferences(segmentationId, stackViewport, labelmapImageIds, updateCallback) {
-        const currentImageId = stackViewport.getCurrentImageId();
+    _updateLabelmapSegmentationReferences(segmentationId, viewport, labelmapImageIds, updateCallback) {
+        const currentImageId = viewport.getCurrentImageId();
         for (const labelmapImageId of labelmapImageIds) {
-            const viewableImageId = stackViewport.isReferenceViewable({ referencedImageId: labelmapImageId }, { asOverlay: true });
+            const viewableImageId = viewport.isReferenceViewable({ referencedImageId: labelmapImageId }, { asOverlay: true });
             if (viewableImageId) {
                 this._stackLabelmapImageIdReferenceMap
                     .get(segmentationId)
@@ -122,7 +151,7 @@ export default class SegmentationStateManager {
             }
         }
         if (updateCallback) {
-            updateCallback(stackViewport, segmentationId, labelmapImageIds);
+            updateCallback(viewport, segmentationId, labelmapImageIds);
         }
         return this._stackLabelmapImageIdReferenceMap
             .get(segmentationId)
@@ -216,157 +245,172 @@ export default class SegmentationStateManager {
             return associatedReferenceImageAndLabelmapImageIds.get(imageId);
         });
     }
-    getSegmentationRepresentations(viewportId) {
-        const viewport = this.state.viewports[viewportId];
-        if (!viewport) {
-            return [];
-        }
-        return Object.keys(viewport).map((segRepUID) => {
-            return this.getSegmentationRepresentation(segRepUID);
-        });
-    }
-    removeRepresentation(segmentationRepresentationUID) {
-        delete this.state.representations[segmentationRepresentationUID];
-        Object.keys(this.state.viewports).forEach((viewportId) => {
-            delete this.state.viewports[viewportId][segmentationRepresentationUID];
+    removeSegmentationRepresentations(viewportId, specifier) {
+        this.updateState((state) => {
+            if (!state.viewportSegRepresentations[viewportId]) {
+                return;
+            }
+            if (!specifier) {
+                delete state.viewportSegRepresentations[viewportId];
+                return;
+            }
+            const { segmentationId, type } = specifier;
+            state.viewportSegRepresentations[viewportId] =
+                state.viewportSegRepresentations[viewportId].filter((representation) => {
+                    if (segmentationId && type) {
+                        return !(representation.segmentationId === segmentationId &&
+                            representation.type === type);
+                    }
+                    else if (segmentationId) {
+                        return representation.segmentationId !== segmentationId;
+                    }
+                    else if (type) {
+                        return representation.type !== type;
+                    }
+                    return true;
+                });
+            if (state.viewportSegRepresentations[viewportId].length === 0) {
+                delete state.viewportSegRepresentations[viewportId];
+            }
         });
     }
-    setActiveSegmentationRepresentation(viewportId, segmentationRepresentationUID) {
-        Object.keys(this.state.viewports[viewportId]).forEach((segRepUID) => {
-            this.state.viewports[viewportId][segRepUID].active = false;
+    removeSegmentationRepresentation(viewportId, specifier) {
+        this.updateState((state) => {
+            const viewport = state.viewportSegRepresentations[viewportId];
+            if (!viewport) {
+                return;
+            }
+            const viewportRendering = viewport.find((segRep) => segRep.segmentationId === specifier.segmentationId &&
+                segRep.type === specifier.type);
+            if (!viewportRendering) {
+                return;
+            }
+            viewport.splice(viewport.indexOf(viewportRendering), 1);
         });
-        if (!this.state.viewports[viewportId]) {
-            this.state.viewports[viewportId] = {};
-        }
-        if (!this.state.viewports[viewportId][segmentationRepresentationUID]) {
-            this.state.viewports[viewportId][segmentationRepresentationUID] = {
-                active: false,
-                visible: true,
-                segmentsHidden: new Set(),
-            };
-        }
-        this.state.viewports[viewportId][segmentationRepresentationUID].active =
-            true;
     }
-    getActiveSegmentationRepresentation(viewportId) {
-        if (!this.state.viewports?.[viewportId]) {
-            return;
-        }
-        const activeSegRep = Object.entries(this.state.viewports[viewportId]).find(([, value]) => value.active);
-        if (!activeSegRep) {
+    _setActiveSegmentation(state, viewportId, segmentationId) {
+        const viewport = state.viewportSegRepresentations[viewportId];
+        if (!viewport) {
             return;
         }
-        return this.getSegmentationRepresentation(activeSegRep[0]);
-    }
-    getGlobalConfig() {
-        return this.state.globalConfig;
-    }
-    setGlobalConfig(config) {
-        this.state.globalConfig = config;
+        viewport.forEach((value) => {
+            value.active = value.segmentationId === segmentationId;
+        });
     }
-    _getRepresentationConfig(segmentationRepresentationUID) {
-        const segmentationRepresentation = this.getSegmentationRepresentation(segmentationRepresentationUID);
-        if (!segmentationRepresentation) {
-            return;
-        }
-        return segmentationRepresentation.config;
+    setActiveSegmentation(viewportId, segmentationId) {
+        this.updateState((state) => {
+            const viewport = state.viewportSegRepresentations[viewportId];
+            if (!viewport) {
+                return;
+            }
+            viewport.forEach((value) => {
+                value.active = value.segmentationId === segmentationId;
+            });
+        });
     }
-    getSegmentationRepresentationConfig(segmentationRepresentationUID) {
-        const config = this._getRepresentationConfig(segmentationRepresentationUID);
-        if (!config) {
+    getActiveSegmentation(viewportId) {
+        if (!this.state.viewportSegRepresentations[viewportId]) {
             return;
         }
-        return config.allSegments;
-    }
-    getPerSegmentConfig(segmentationRepresentationUID) {
-        const config = this._getRepresentationConfig(segmentationRepresentationUID);
-        if (!config) {
+        const activeSegRep = this.state.viewportSegRepresentations[viewportId].find((segRep) => segRep.active);
+        if (!activeSegRep) {
             return;
         }
-        return config.perSegment;
+        return this.getSegmentation(activeSegRep.segmentationId);
     }
-    setSegmentationRepresentationConfig(segmentationRepresentationUID, config) {
-        const _config = this._getRepresentationConfig(segmentationRepresentationUID);
-        if (!_config) {
-            return;
+    getSegmentationRepresentations(viewportId, specifier = {}) {
+        const viewportRepresentations = this.state.viewportSegRepresentations[viewportId];
+        if (!viewportRepresentations) {
+            return [];
         }
-        _config.allSegments = config;
+        if (!specifier.type && !specifier.segmentationId) {
+            return viewportRepresentations;
+        }
+        return viewportRepresentations.filter((representation) => {
+            const typeMatch = specifier.type
+                ? representation.type === specifier.type
+                : true;
+            const idMatch = specifier.segmentationId
+                ? representation.segmentationId === specifier.segmentationId
+                : true;
+            return typeMatch && idMatch;
+        });
     }
-    setPerSegmentConfig(segmentationRepresentationUID, config) {
-        const _config = this._getRepresentationConfig(segmentationRepresentationUID);
-        if (!_config) {
-            return;
-        }
-        _config.perSegment = config;
+    getSegmentationRepresentation(viewportId, specifier) {
+        return this.getSegmentationRepresentations(viewportId, specifier)[0];
     }
-    getSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID) {
-        const viewport = this.state.viewports[viewportId];
-        return viewport && viewport[segmentationRepresentationUID]?.visible;
+    getSegmentationRepresentationVisibility(viewportId, specifier) {
+        const viewportRepresentation = this.getSegmentationRepresentation(viewportId, specifier);
+        return viewportRepresentation?.visible;
     }
-    setSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID, visible) {
-        if (!this.state.viewports[viewportId]) {
-            this.state.viewports[viewportId] = {};
-        }
-        this.state.viewports[viewportId][segmentationRepresentationUID].visible =
-            visible;
+    setSegmentationRepresentationVisibility(viewportId, specifier, visible) {
+        this.updateState((state) => {
+            const viewportRepresentations = this.getSegmentationRepresentations(viewportId, specifier);
+            if (!viewportRepresentations) {
+                return;
+            }
+            viewportRepresentations.forEach((representation) => {
+                representation.visible = visible;
+            });
+        });
     }
     addColorLUT(colorLUT, lutIndex) {
-        if (this.state.colorLUT[lutIndex]) {
-            console.warn('Color LUT table already exists, overwriting');
-        }
-        this.state.colorLUT[lutIndex] = structuredClone(colorLUT);
+        this.updateState((state) => {
+            if (state.colorLUT[lutIndex]) {
+                console.warn('Color LUT table already exists, overwriting');
+            }
+            state.colorLUT[lutIndex] = csUtils.deepClone(colorLUT);
+        });
     }
     removeColorLUT(colorLUTIndex) {
-        delete this.state.colorLUT[colorLUTIndex];
+        this.updateState((state) => {
+            delete state.colorLUT[colorLUTIndex];
+        });
     }
     _getStackIdForImageIds(imageIds) {
         return imageIds
             .map((imageId) => imageId.slice(-Math.round(imageId.length * 0.15)))
             .join('_');
     }
+    getAllViewportSegmentationRepresentations() {
+        return Object.entries(this.state.viewportSegRepresentations).map(([viewportId, representations]) => ({
+            viewportId,
+            representations,
+        }));
+    }
 }
-async function computeVolumeSegmentationFromStack({ imageIds, options, }) {
+async function internalComputeVolumeLabelmapFromStack({ imageIds, options, }) {
     const segmentationImageIds = imageIds;
-    const volumeId = options?.volumeId ?? csUtils.uuidv4();
+    const volumeId = options?.volumeId || csUtils.uuidv4();
     await volumeLoader.createAndCacheVolumeFromImages(volumeId, segmentationImageIds);
     return { volumeId };
 }
-async function convertStackToVolumeSegmentation({ segmentationId, options, }) {
+async function internalConvertStackToVolumeLabelmap({ segmentationId, options, }) {
     const segmentation = defaultSegmentationStateManager.getSegmentation(segmentationId);
     const data = segmentation.representationData
         .Labelmap;
-    const { volumeId } = await computeVolumeSegmentationFromStack({
+    const { volumeId } = await internalComputeVolumeLabelmapFromStack({
         imageIds: data.imageIds,
         options,
     });
-    await updateSegmentationState({
-        segmentationId,
-        viewportId: options.viewportId,
-        options,
-        volumeId,
-    });
+    segmentation.representationData.Labelmap.volumeId = 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,
+function getDefaultRenderingConfig(type) {
+    const cfun = vtkColorTransferFunction.newInstance();
+    const ofun = vtkPiecewiseFunction.newInstance();
+    ofun.addPoint(0, 0);
+    if (type === SegmentationRepresentations.Labelmap) {
+        return {
+            cfun,
+            ofun,
+            colorLUTIndex: 0,
         };
     }
     else {
-        segmentation.representationData.Labelmap = {
-            ...segmentation.representationData.Labelmap,
-            volumeId,
+        return {
+            colorLUTIndex: 0,
         };
     }
-    eventTarget.addEventListenerOnce(Events.SEGMENTATION_RENDERED, () => triggerSegmentationDataModified(segmentationId));
 }
 const defaultSegmentationStateManager = new SegmentationStateManager('DEFAULT');
-export { convertStackToVolumeSegmentation, computeVolumeSegmentationFromStack, defaultSegmentationStateManager, };
-//# sourceMappingURL=SegmentationStateManager.js.map
+export { internalConvertStackToVolumeLabelmap, internalComputeVolumeLabelmapFromStack, defaultSegmentationStateManager, };

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

@@ -0,0 +1,42 @@
+import { SegmentationRepresentations } from '../../enums';
+import type { ContourStyle } from '../../types/ContourTypes';
+import type { LabelmapStyle } from '../../types/LabelmapTypes';
+import type { SurfaceStyle } from '../../types/SurfaceTypes';
+export type RepresentationStyle = LabelmapStyle | ContourStyle | SurfaceStyle;
+declare class SegmentationStyle {
+    private config;
+    constructor();
+    setGlobalStyle(type: SegmentationRepresentations, styles: RepresentationStyle): void;
+    getGlobalStyle(type: SegmentationRepresentations): RepresentationStyle;
+    setGlobalLabelmapStyle(styles: LabelmapStyle): void;
+    setGlobalContourStyle(styles: ContourStyle): void;
+    setGlobalSurfaceStyle(styles: SurfaceStyle): void;
+    setSegmentationSpecificStyle(specifier: {
+        segmentationId: string;
+        type: SegmentationRepresentations;
+        segmentIndex?: number;
+    }, styles: RepresentationStyle): void;
+    setViewportSpecificStyleForType(specifier: {
+        viewportId: string;
+        type: SegmentationRepresentations;
+    }, styles: RepresentationStyle): void;
+    setViewportSpecificStyleForSegmentation(specifier: {
+        viewportId: string;
+        segmentationId: string;
+        type: SegmentationRepresentations;
+        segmentIndex?: number;
+    }, styles: RepresentationStyle): void;
+    setViewportRenderInactiveSegmentations(viewportId: string, renderInactiveSegmentations: boolean): void;
+    getStyle(specifier: {
+        viewportId?: string;
+        segmentationId?: string;
+        type?: SegmentationRepresentations;
+        segmentIndex?: number;
+    }): {
+        style: RepresentationStyle;
+        renderInactiveSegmentations: boolean;
+    };
+    private getDefaultStyle;
+}
+declare const segmentationStyle: SegmentationStyle;
+export { segmentationStyle };