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

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

@@ -1,36 +1,29 @@
-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 { triggerSegmentationModified, triggerSegmentationRemoved, triggerSegmentationRepresentationModified, triggerSegmentationRepresentationRemoved, } from './triggerSegmentationEvents';
+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,56 +31,119 @@ 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);
     }
+    updateSegmentation(segmentationId, payload) {
+        this.updateState((draftState) => {
+            const segmentation = draftState.segmentations.find((segmentation) => segmentation.segmentationId === segmentationId);
+            if (!segmentation) {
+                console.warn(`Segmentation with id ${segmentationId} not found. Update aborted.`);
+                return;
+            }
+            Object.assign(segmentation, payload);
+        });
+        triggerSegmentationModified(segmentationId);
+    }
     addSegmentation(segmentation) {
         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);
+        });
+        triggerSegmentationModified(segmentation.segmentationId);
     }
     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);
+            });
+        });
+        triggerSegmentationRemoved(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.setRenderInactiveSegmentations(viewportId, true);
+            }
+            if (type !== SegmentationRepresentations.Labelmap) {
+                this.addDefaultSegmentationRepresentation(state, viewportId, segmentationId, type, renderingConfig);
+            }
+            else {
+                this.addLabelmapRepresentation(state, viewportId, segmentationId, renderingConfig);
+            }
+        });
+        triggerSegmentationRepresentationModified(viewportId, segmentationId, type);
     }
-    addSegmentationRepresentationState(segmentationRepresentation) {
-        const { segmentationRepresentationUID } = segmentationRepresentation;
-        this.state.representations[segmentationRepresentationUID] =
-            segmentationRepresentation;
+    addDefaultSegmentationRepresentation(state, viewportId, segmentationId, type, renderingConfig) {
+        const segmentation = state.segmentations.find((segmentation) => segmentation.segmentationId === segmentationId);
+        if (!segmentation) {
+            return;
+        }
+        const segmentReps = {};
+        Object.keys(segmentation.segments).forEach((segmentIndex) => {
+            segmentReps[Number(segmentIndex)] = {
+                visible: true,
+            };
+        });
+        state.viewportSegRepresentations[viewportId].push({
+            segmentationId,
+            type,
+            active: true,
+            visible: true,
+            colorLUTIndex: 0,
+            segments: segmentReps,
+            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 +159,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 +177,7 @@ export default class SegmentationStateManager {
             }
         }
         if (updateCallback) {
-            updateCallback(stackViewport, segmentationId, labelmapImageIds);
+            updateCallback(viewport, segmentationId, labelmapImageIds);
         }
         return this._stackLabelmapImageIdReferenceMap
             .get(segmentationId)
@@ -216,157 +271,184 @@ 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);
+    removeSegmentationRepresentations(viewportId, specifier) {
+        const removedRepresentations = [];
+        this.updateState((state) => {
+            if (!state.viewportSegRepresentations[viewportId]) {
+                return;
+            }
+            const currentRepresentations = state.viewportSegRepresentations[viewportId];
+            if (!specifier ||
+                Object.values(specifier).every((value) => value === undefined)) {
+                removedRepresentations.push(...currentRepresentations);
+                delete state.viewportSegRepresentations[viewportId];
+            }
+            else {
+                const { segmentationId, type } = specifier;
+                state.viewportSegRepresentations[viewportId] =
+                    currentRepresentations.filter((representation) => {
+                        const shouldRemove = (segmentationId &&
+                            type &&
+                            representation.segmentationId === segmentationId &&
+                            representation.type === type) ||
+                            (segmentationId &&
+                                !type &&
+                                representation.segmentationId === segmentationId) ||
+                            (!segmentationId && type && representation.type === type);
+                        if (shouldRemove) {
+                            removedRepresentations.push(representation);
+                        }
+                        return !shouldRemove;
+                    });
+                if (state.viewportSegRepresentations[viewportId].length === 0) {
+                    delete state.viewportSegRepresentations[viewportId];
+                }
+            }
         });
-    }
-    removeRepresentation(segmentationRepresentationUID) {
-        delete this.state.representations[segmentationRepresentationUID];
-        Object.keys(this.state.viewports).forEach((viewportId) => {
-            delete this.state.viewports[viewportId][segmentationRepresentationUID];
+        removedRepresentations.forEach((representation) => {
+            triggerSegmentationRepresentationRemoved(viewportId, representation.segmentationId, representation.type);
         });
     }
-    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;
+        triggerSegmentationRepresentationRemoved(viewportId, specifier.segmentationId, specifier.type);
     }
-    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;
+            });
+        });
+        triggerSegmentationRepresentationModified(viewportId, 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;
+                Object.entries(representation.segments).forEach(([segmentIndex, segment]) => {
+                    segment.visible = visible;
+                });
+            });
+        });
+        triggerSegmentationRepresentationModified(viewportId, specifier.segmentationId, specifier.type);
     }
     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,
         };
     }
     else {
-        segmentation.representationData.Labelmap = {
-            ...segmentation.representationData.Labelmap,
-            volumeId,
-        };
+        return {};
     }
-    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,39 @@
+import type { SegmentationRepresentations } from '../../enums';
+import type { BaseContourStyle, ContourStyle } from '../../types/ContourTypes';
+import type { BaseLabelmapStyle, LabelmapStyle } from '../../types/LabelmapTypes';
+import type { SurfaceStyle } from '../../types/SurfaceTypes';
+export type RepresentationStyle = LabelmapStyle | ContourStyle | SurfaceStyle;
+export type BaseRepresentationStyle = BaseLabelmapStyle | BaseContourStyle;
+declare class SegmentationStyle {
+    private config;
+    constructor();
+    setStyle(specifier: {
+        type: SegmentationRepresentations;
+        viewportId?: string;
+        segmentationId?: string;
+        segmentIndex?: number;
+    }, styles: RepresentationStyle): void;
+    private copyActiveToInactiveIfNotProvided;
+    getStyle(specifier: {
+        viewportId?: string;
+        segmentationId?: string;
+        type?: SegmentationRepresentations;
+        segmentIndex?: number;
+    }): RepresentationStyle;
+    getRenderInactiveSegmentations(viewportId: string): boolean;
+    setRenderInactiveSegmentations(viewportId: string, renderInactiveSegmentations: boolean): void;
+    private getDefaultStyle;
+    clearSegmentationStyle(segmentationId: string): void;
+    clearAllSegmentationStyles(): void;
+    clearViewportStyle(viewportId: string): void;
+    clearAllViewportStyles(): void;
+    resetToGlobalStyle(): void;
+    hasCustomStyle(specifier: {
+        viewportId?: string;
+        segmentationId?: string;
+        type?: SegmentationRepresentations;
+        segmentIndex?: number;
+    }): boolean;
+}
+declare const segmentationStyle: SegmentationStyle;
+export { segmentationStyle };