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

package/dist/esm/constants/COLOR_LUT.d.ts

@@ -1,2 +1,3 @@
-declare const CORNERSTONE_COLOR_LUT: number[][];
+import type { Types } from '@cornerstonejs/core';
+declare const CORNERSTONE_COLOR_LUT: Types.Color[];
 export default CORNERSTONE_COLOR_LUT;

package/dist/esm/eventListeners/segmentation/imageChangeEventListener.js

@@ -94,7 +94,7 @@ function _imageChangeEventListener(evt) {
                     },
                 },
             ]);
-            triggerSegmentationRender();
+            triggerSegmentationRender(viewportId);
             return;
         }
         else {

package/dist/esm/eventListeners/segmentation/segmentationModifiedEventListener.js

@@ -1,4 +1,3 @@
-import {} from '../../stateManagement/segmentation/triggerSegmentationEvents';
 import { triggerSegmentationRenderBySegmentationId } from '../../stateManagement/segmentation/SegmentationRenderingEngine';
 const segmentationModifiedListener = function (evt) {
     const { segmentationId } = evt.detail;

package/dist/esm/eventListeners/segmentation/segmentationRepresentationModifiedListener.d.ts

@@ -0,0 +1,3 @@
+import type { SegmentationRepresentationModifiedEventType } from '../../types/EventTypes';
+declare const segmentationRepresentationModifiedListener: (evt: SegmentationRepresentationModifiedEventType) => void;
+export default segmentationRepresentationModifiedListener;

package/dist/esm/eventListeners/segmentation/segmentationRepresentationModifiedListener.js

@@ -0,0 +1,6 @@
+import { triggerSegmentationRender } from '../../stateManagement/segmentation/SegmentationRenderingEngine';
+const segmentationRepresentationModifiedListener = function (evt) {
+    const { viewportId } = evt.detail;
+    triggerSegmentationRender(viewportId);
+};
+export default segmentationRepresentationModifiedListener;

package/dist/esm/init.js

@@ -1,3 +1,4 @@
+console.debug("tools: link: init: 3DA675F2-86A1-41A1-9E15-A7019E085C0F");
 import { eventTarget, Enums } from '@cornerstonejs/core';
 import { getAnnotationManager } from './stateManagement/annotation/annotationState';
 import { Events as TOOLS_EVENTS } from './enums';
@@ -7,6 +8,7 @@ import { annotationCompletedListener, annotationRemovedListener, annotationSelec
 import { annotationInterpolationEventDispatcher } from './eventDispatchers';
 import * as ToolGroupManager from './store/ToolGroupManager';
 import { defaultSegmentationStateManager } from './stateManagement/segmentation/SegmentationStateManager';
+import segmentationRepresentationModifiedListener from './eventListeners/segmentation/segmentationRepresentationModifiedListener';
 let csToolsInitialized = false;
 export function init(defaultConfiguration = {}) {
     if (csToolsInitialized) {
@@ -51,6 +53,7 @@ function _addCornerstoneToolsEventListeners() {
     eventTarget.addEventListener(TOOLS_EVENTS.ANNOTATION_REMOVED, annotationRemovedListener);
     eventTarget.addEventListener(TOOLS_EVENTS.SEGMENTATION_MODIFIED, segmentationModifiedListener);
     eventTarget.addEventListener(TOOLS_EVENTS.SEGMENTATION_DATA_MODIFIED, segmentationDataModifiedEventListener);
+    eventTarget.addEventListener(TOOLS_EVENTS.SEGMENTATION_REPRESENTATION_MODIFIED, segmentationRepresentationModifiedListener);
 }
 function _removeCornerstoneToolsEventListeners() {
     eventTarget.removeEventListener(TOOLS_EVENTS.ANNOTATION_COMPLETED, annotationCompletedListener);
@@ -59,5 +62,6 @@ function _removeCornerstoneToolsEventListeners() {
     eventTarget.removeEventListener(TOOLS_EVENTS.ANNOTATION_SELECTION_CHANGE, annotationSelectionListener);
     eventTarget.removeEventListener(TOOLS_EVENTS.SEGMENTATION_MODIFIED, segmentationModifiedListener);
     eventTarget.removeEventListener(TOOLS_EVENTS.SEGMENTATION_DATA_MODIFIED, segmentationDataModifiedEventListener);
+    eventTarget.removeEventListener(TOOLS_EVENTS.SEGMENTATION_REPRESENTATION_MODIFIED, segmentationRepresentationModifiedListener);
 }
 export default init;

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

@@ -104,19 +104,29 @@ class SegmentationRenderingEngine {
             catch (error) {
                 console.error(error);
             }
-            return Promise.resolve();
-        });
-        function onSegmentationRender(evt) {
-            const { element, viewportId } = evt.detail;
-            element.removeEventListener(Enums.Events.IMAGE_RENDERED, onSegmentationRender);
-            const eventDetail = {
-                viewportId,
-            };
-            triggerEvent(eventTarget, csToolsEvents.SEGMENTATION_RENDERED, {
-                ...eventDetail,
+            return Promise.resolve({
+                segmentationId: representation.segmentationId,
+                type: representation.type,
             });
-        }
-        Promise.allSettled(segmentationRenderList).then(() => {
+        });
+        Promise.allSettled(segmentationRenderList).then((results) => {
+            const segmentationDetails = results
+                .filter((r) => r.status === 'fulfilled')
+                .map((r) => r.value);
+            function onSegmentationRender(evt) {
+                const { element, viewportId } = evt.detail;
+                element.removeEventListener(Enums.Events.IMAGE_RENDERED, onSegmentationRender);
+                segmentationDetails.forEach((detail) => {
+                    const eventDetail = {
+                        viewportId,
+                        segmentationId: detail.segmentationId,
+                        type: detail.type,
+                    };
+                    triggerEvent(eventTarget, csToolsEvents.SEGMENTATION_RENDERED, {
+                        ...eventDetail,
+                    });
+                });
+            }
             const element = viewport.element;
             element.addEventListener(Enums.Events.IMAGE_RENDERED, onSegmentationRender);
             viewport.render();

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

@@ -12,6 +12,7 @@ export default class SegmentationStateManager {
     getNextColorLUTIndex(): number;
     resetState(): void;
     getSegmentation(segmentationId: string): Segmentation | undefined;
+    updateSegmentation(segmentationId: string, payload: Partial<Segmentation>): void;
     addSegmentation(segmentation: Segmentation): void;
     removeSegmentation(segmentationId: string): void;
     addSegmentationRepresentation(viewportId: string, segmentationId: string, type: SegmentationRepresentations, renderingConfig: RenderingConfig): void;

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

@@ -2,6 +2,7 @@ import { BaseVolumeViewport, cache, utilities as csUtils, getEnabledElementByVie
 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: [],
@@ -35,6 +36,17 @@ export default class SegmentationStateManager {
     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`);
@@ -50,6 +62,7 @@ export default class SegmentationStateManager {
             }
             state.segmentations.push(newSegmentation);
         });
+        triggerSegmentationModified(segmentation.segmentationId);
     }
     removeSegmentation(segmentationId) {
         this.updateState((state) => {
@@ -58,6 +71,7 @@ export default class SegmentationStateManager {
                 representations = representations.filter((representation) => representation.segmentationId !== segmentationId);
             });
         });
+        triggerSegmentationRemoved(segmentationId);
     }
     addSegmentationRepresentation(viewportId, segmentationId, type, renderingConfig) {
         const enabledElement = getEnabledElementByViewportId(viewportId);
@@ -67,7 +81,7 @@ export default class SegmentationStateManager {
         this.updateState((state) => {
             if (!state.viewportSegRepresentations[viewportId]) {
                 state.viewportSegRepresentations[viewportId] = [];
-                segmentationStyle.setViewportRenderInactiveSegmentations(viewportId, true);
+                segmentationStyle.setRenderInactiveSegmentations(viewportId, true);
             }
             if (type !== SegmentationRepresentations.Labelmap) {
                 this.addDefaultSegmentationRepresentation(state, viewportId, segmentationId, type, renderingConfig);
@@ -76,14 +90,26 @@ export default class SegmentationStateManager {
                 this.addLabelmapRepresentation(state, viewportId, segmentationId, renderingConfig);
             }
         });
+        triggerSegmentationRepresentationModified(viewportId, segmentationId, type);
     }
     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,
-            segmentsHidden: new Set(),
+            colorLUTIndex: 0,
+            segments: segmentReps,
             config: {
                 ...getDefaultRenderingConfig(type),
                 ...renderingConfig,
@@ -246,33 +272,42 @@ export default class SegmentationStateManager {
         });
     }
     removeSegmentationRepresentations(viewportId, specifier) {
+        const removedRepresentations = [];
         this.updateState((state) => {
             if (!state.viewportSegRepresentations[viewportId]) {
                 return;
             }
-            if (!specifier) {
+            const currentRepresentations = state.viewportSegRepresentations[viewportId];
+            if (!specifier ||
+                Object.values(specifier).every((value) => value === undefined)) {
+                removedRepresentations.push(...currentRepresentations);
                 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];
+            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];
+                }
             }
         });
+        removedRepresentations.forEach((representation) => {
+            triggerSegmentationRepresentationRemoved(viewportId, representation.segmentationId, representation.type);
+        });
     }
     removeSegmentationRepresentation(viewportId, specifier) {
         this.updateState((state) => {
@@ -287,6 +322,7 @@ export default class SegmentationStateManager {
             }
             viewport.splice(viewport.indexOf(viewportRendering), 1);
         });
+        triggerSegmentationRepresentationRemoved(viewportId, specifier.segmentationId, specifier.type);
     }
     _setActiveSegmentation(state, viewportId, segmentationId) {
         const viewport = state.viewportSegRepresentations[viewportId];
@@ -307,6 +343,7 @@ export default class SegmentationStateManager {
                 value.active = value.segmentationId === segmentationId;
             });
         });
+        triggerSegmentationRepresentationModified(viewportId, segmentationId);
     }
     getActiveSegmentation(viewportId) {
         if (!this.state.viewportSegRepresentations[viewportId]) {
@@ -351,8 +388,12 @@ export default class SegmentationStateManager {
             }
             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) {
         this.updateState((state) => {
@@ -403,13 +444,10 @@ function getDefaultRenderingConfig(type) {
         return {
             cfun,
             ofun,
-            colorLUTIndex: 0,
         };
     }
     else {
-        return {
-            colorLUTIndex: 0,
-        };
+        return {};
     }
 }
 const defaultSegmentationStateManager = new SegmentationStateManager('DEFAULT');

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

@@ -1,42 +1,39 @@
-import { SegmentationRepresentations } from '../../enums';
-import type { ContourStyle } from '../../types/ContourTypes';
-import type { LabelmapStyle } from '../../types/LabelmapTypes';
+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();
-    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;
+    setStyle(specifier: {
         type: SegmentationRepresentations;
+        viewportId?: string;
+        segmentationId?: string;
         segmentIndex?: number;
     }, styles: RepresentationStyle): void;
-    setViewportRenderInactiveSegmentations(viewportId: string, renderInactiveSegmentations: boolean): void;
+    private copyActiveToInactiveIfNotProvided;
     getStyle(specifier: {
         viewportId?: string;
         segmentationId?: string;
         type?: SegmentationRepresentations;
         segmentIndex?: number;
-    }): {
-        style: RepresentationStyle;
-        renderInactiveSegmentations: boolean;
-    };
+    }): 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 };

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

@@ -1,7 +1,7 @@
-import { SegmentationRepresentations } from '../../enums';
 import getDefaultContourConfig from '../../tools/displayTools/Contour/contourConfig';
 import getDefaultLabelmapConfig from '../../tools/displayTools/Labelmap/labelmapConfig';
 import * as Enums from '../../enums';
+import { utilities } from '@cornerstonejs/core';
 class SegmentationStyle {
     constructor() {
         this.config = {
@@ -10,90 +10,105 @@ class SegmentationStyle {
             viewportsStyle: {},
         };
     }
-    setGlobalStyle(type, styles) {
-        this.config.global[type] = styles;
-    }
-    getGlobalStyle(type) {
-        return this.config.global[type];
-    }
-    setGlobalLabelmapStyle(styles) {
-        this.setGlobalStyle(SegmentationRepresentations.Labelmap, styles);
-    }
-    setGlobalContourStyle(styles) {
-        this.setGlobalStyle(SegmentationRepresentations.Contour, styles);
-    }
-    setGlobalSurfaceStyle(styles) {
-        this.setGlobalStyle(SegmentationRepresentations.Surface, styles);
-    }
-    setSegmentationSpecificStyle(specifier, styles) {
-        const { segmentationId, type, segmentIndex } = specifier;
-        if (!this.config.segmentations[segmentationId]) {
-            this.config.segmentations[segmentationId] = {};
-        }
-        if (!this.config.segmentations[segmentationId][type]) {
-            this.config.segmentations[segmentationId][type] = {};
-        }
-        if (segmentIndex !== undefined) {
-            if (!this.config.segmentations[segmentationId][type].perSegment) {
-                this.config.segmentations[segmentationId][type].perSegment = {};
-            }
-            this.config.segmentations[segmentationId][type].perSegment[segmentIndex] =
-                styles;
-        }
-        else {
-            this.config.segmentations[segmentationId][type].allSegments = styles;
-        }
-    }
-    setViewportSpecificStyleForType(specifier, styles) {
-        const { viewportId, type } = specifier;
-        if (!this.config.viewportsStyle[viewportId]) {
-            this.config.viewportsStyle[viewportId] = {
-                renderInactiveSegmentations: false,
-                representations: {},
-            };
-        }
-        const allSegmentationsKey = '__allSegmentations__';
-        if (!this.config.viewportsStyle[viewportId].representations[allSegmentationsKey]) {
-            this.config.viewportsStyle[viewportId].representations[allSegmentationsKey] = {};
-        }
-        this.config.viewportsStyle[viewportId].representations[allSegmentationsKey][type] = {
-            allSegments: styles,
-        };
-    }
-    setViewportSpecificStyleForSegmentation(specifier, styles) {
+    setStyle(specifier, styles) {
         const { viewportId, segmentationId, type, segmentIndex } = specifier;
-        if (!this.config.viewportsStyle[viewportId]) {
-            this.config.viewportsStyle[viewportId] = {
-                renderInactiveSegmentations: false,
-                representations: {},
+        const currentStyles = this.getStyle(specifier);
+        let updatedStyles;
+        if (!viewportId && !segmentationId) {
+            updatedStyles = {
+                ...currentStyles,
+                ...styles,
             };
         }
-        if (!this.config.viewportsStyle[viewportId].representations[segmentationId]) {
-            this.config.viewportsStyle[viewportId].representations[segmentationId] =
-                {};
-        }
-        if (!this.config.viewportsStyle[viewportId].representations[segmentationId][type]) {
-            this.config.viewportsStyle[viewportId].representations[segmentationId][type] = {};
+        else {
+            updatedStyles = this.copyActiveToInactiveIfNotProvided({
+                ...currentStyles,
+                ...styles,
+            }, type);
+        }
+        if (!type) {
+            throw new Error('Type is required to set a style');
+        }
+        if (viewportId) {
+            if (!this.config.viewportsStyle[viewportId]) {
+                this.config.viewportsStyle[viewportId] = {
+                    renderInactiveSegmentations: false,
+                    representations: {},
+                };
+            }
+            const representations = this.config.viewportsStyle[viewportId].representations;
+            if (segmentationId) {
+                if (!representations[segmentationId]) {
+                    representations[segmentationId] = {};
+                }
+                if (!representations[segmentationId][type]) {
+                    representations[segmentationId][type] = {};
+                }
+                const repConfig = representations[segmentationId][type];
+                if (segmentIndex !== undefined) {
+                    if (!repConfig.perSegment) {
+                        repConfig.perSegment = {};
+                    }
+                    repConfig.perSegment[segmentIndex] = updatedStyles;
+                }
+                else {
+                    repConfig.allSegments = updatedStyles;
+                }
+            }
+            else {
+                const ALL_SEGMENTATIONS_KEY = '__allSegmentations__';
+                if (!representations[ALL_SEGMENTATIONS_KEY]) {
+                    representations[ALL_SEGMENTATIONS_KEY] = {};
+                }
+                if (!representations[ALL_SEGMENTATIONS_KEY][type]) {
+                    representations[ALL_SEGMENTATIONS_KEY][type] = {};
+                }
+                representations[ALL_SEGMENTATIONS_KEY][type].allSegments =
+                    updatedStyles;
+            }
         }
-        if (segmentIndex !== undefined) {
-            if (!this.config.viewportsStyle[viewportId].representations[segmentationId][type].perSegment) {
-                this.config.viewportsStyle[viewportId].representations[segmentationId][type].perSegment = {};
+        else if (segmentationId) {
+            if (!this.config.segmentations[segmentationId]) {
+                this.config.segmentations[segmentationId] = {};
+            }
+            if (!this.config.segmentations[segmentationId][type]) {
+                this.config.segmentations[segmentationId][type] = {};
+            }
+            const segConfig = this.config.segmentations[segmentationId][type];
+            if (segmentIndex !== undefined) {
+                if (!segConfig.perSegment) {
+                    segConfig.perSegment = {};
+                }
+                segConfig.perSegment[segmentIndex] = updatedStyles;
+            }
+            else {
+                segConfig.allSegments = updatedStyles;
             }
-            this.config.viewportsStyle[viewportId].representations[segmentationId][type].perSegment[segmentIndex] = styles;
         }
         else {
-            this.config.viewportsStyle[viewportId].representations[segmentationId][type].allSegments = styles;
+            this.config.global[type] = updatedStyles;
         }
     }
-    setViewportRenderInactiveSegmentations(viewportId, renderInactiveSegmentations) {
-        if (!this.config.viewportsStyle[viewportId]) {
-            this.config.viewportsStyle[viewportId] = {
-                renderInactiveSegmentations: false,
-                representations: {},
-            };
-        }
-        this.config.viewportsStyle[viewportId].renderInactiveSegmentations =
-            renderInactiveSegmentations;
+    copyActiveToInactiveIfNotProvided(styles, type) {
+        const processedStyles = { ...styles };
+        if (type === Enums.SegmentationRepresentations.Labelmap) {
+            const labelmapStyles = processedStyles;
+            labelmapStyles.renderOutlineInactive = labelmapStyles.renderOutline;
+            labelmapStyles.outlineWidthInactive = labelmapStyles.outlineWidth;
+            labelmapStyles.renderFillInactive = labelmapStyles.renderFill;
+            labelmapStyles.fillAlphaInactive = labelmapStyles.fillAlpha;
+            labelmapStyles.outlineOpacityInactive = labelmapStyles.outlineOpacity;
+        }
+        else if (type === Enums.SegmentationRepresentations.Contour) {
+            const contourStyles = processedStyles;
+            contourStyles.outlineWidthInactive = contourStyles.outlineWidth;
+            contourStyles.outlineOpacityInactive = contourStyles.outlineOpacity;
+            contourStyles.outlineDashInactive = contourStyles.outlineDash;
+            contourStyles.renderOutlineInactive = contourStyles.renderOutline;
+            contourStyles.renderFillInactive = contourStyles.renderFill;
+            contourStyles.fillAlphaInactive = contourStyles.fillAlpha;
+        }
+        return processedStyles;
     }
     getStyle(specifier) {
         const { viewportId, segmentationId, type, segmentIndex } = specifier;
@@ -143,7 +158,20 @@ class SegmentationStyle {
                 }
             }
         }
-        return { style: combinedStyle, renderInactiveSegmentations };
+        return combinedStyle;
+    }
+    getRenderInactiveSegmentations(viewportId) {
+        return this.config.viewportsStyle[viewportId]?.renderInactiveSegmentations;
+    }
+    setRenderInactiveSegmentations(viewportId, renderInactiveSegmentations) {
+        if (!this.config.viewportsStyle[viewportId]) {
+            this.config.viewportsStyle[viewportId] = {
+                renderInactiveSegmentations: false,
+                representations: {},
+            };
+        }
+        this.config.viewportsStyle[viewportId].renderInactiveSegmentations =
+            renderInactiveSegmentations;
     }
     getDefaultStyle(type) {
         switch (type) {
@@ -157,6 +185,39 @@ class SegmentationStyle {
                 throw new Error(`Unknown representation type: ${type}`);
         }
     }
+    clearSegmentationStyle(segmentationId) {
+        if (this.config.segmentations[segmentationId]) {
+            delete this.config.segmentations[segmentationId];
+        }
+    }
+    clearAllSegmentationStyles() {
+        this.config.segmentations = {};
+    }
+    clearViewportStyle(viewportId) {
+        if (this.config.viewportsStyle[viewportId]) {
+            delete this.config.viewportsStyle[viewportId];
+        }
+    }
+    clearAllViewportStyles() {
+        for (const viewportId in this.config.viewportsStyle) {
+            const viewportStyle = this.config.viewportsStyle[viewportId];
+            const renderInactiveSegmentations = viewportStyle.renderInactiveSegmentations;
+            this.config.viewportsStyle[viewportId] = {
+                renderInactiveSegmentations,
+                representations: {},
+            };
+        }
+    }
+    resetToGlobalStyle() {
+        this.clearAllSegmentationStyles();
+        this.clearAllViewportStyles();
+    }
+    hasCustomStyle(specifier) {
+        const { type } = specifier;
+        const style = this.getStyle(specifier);
+        const defaultStyle = this.getDefaultStyle(type);
+        return !utilities.deepEqual(style, defaultStyle);
+    }
 }
 const segmentationStyle = new SegmentationStyle();
 export { segmentationStyle };

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

@@ -1,13 +1,9 @@
 import { getActiveSegmentation as _getActiveSegmentation } from './getActiveSegmentation';
-import { triggerSegmentationRender } from './SegmentationRenderingEngine';
 import { setActiveSegmentation as _setActiveSegmentation } from './setActiveSegmentation';
 function getActiveSegmentation(viewportId) {
     return _getActiveSegmentation(viewportId);
 }
 function setActiveSegmentation(viewportId, segmentationId, suppressEvent = false) {
     _setActiveSegmentation(viewportId, segmentationId);
-    if (!suppressEvent) {
-        triggerSegmentationRender(viewportId);
-    }
 }
 export { getActiveSegmentation, setActiveSegmentation, };