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

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

@@ -0,0 +1,162 @@
+import { SegmentationRepresentations } from '../../enums';
+import getDefaultContourConfig from '../../tools/displayTools/Contour/contourConfig';
+import getDefaultLabelmapConfig from '../../tools/displayTools/Labelmap/labelmapConfig';
+import * as Enums from '../../enums';
+class SegmentationStyle {
+    constructor() {
+        this.config = {
+            global: {},
+            segmentations: {},
+            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) {
+        const { viewportId, segmentationId, type, segmentIndex } = specifier;
+        if (!this.config.viewportsStyle[viewportId]) {
+            this.config.viewportsStyle[viewportId] = {
+                renderInactiveSegmentations: false,
+                representations: {},
+            };
+        }
+        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] = {};
+        }
+        if (segmentIndex !== undefined) {
+            if (!this.config.viewportsStyle[viewportId].representations[segmentationId][type].perSegment) {
+                this.config.viewportsStyle[viewportId].representations[segmentationId][type].perSegment = {};
+            }
+            this.config.viewportsStyle[viewportId].representations[segmentationId][type].perSegment[segmentIndex] = styles;
+        }
+        else {
+            this.config.viewportsStyle[viewportId].representations[segmentationId][type].allSegments = styles;
+        }
+    }
+    setViewportRenderInactiveSegmentations(viewportId, renderInactiveSegmentations) {
+        if (!this.config.viewportsStyle[viewportId]) {
+            this.config.viewportsStyle[viewportId] = {
+                renderInactiveSegmentations: false,
+                representations: {},
+            };
+        }
+        this.config.viewportsStyle[viewportId].renderInactiveSegmentations =
+            renderInactiveSegmentations;
+    }
+    getStyle(specifier) {
+        const { viewportId, segmentationId, type, segmentIndex } = specifier;
+        let combinedStyle = this.getDefaultStyle(type);
+        let renderInactiveSegmentations = false;
+        if (this.config.global[type]) {
+            combinedStyle = {
+                ...combinedStyle,
+                ...this.config.global[type],
+            };
+        }
+        if (this.config.segmentations[segmentationId]?.[type]) {
+            combinedStyle = {
+                ...combinedStyle,
+                ...this.config.segmentations[segmentationId][type].allSegments,
+            };
+            if (segmentIndex !== undefined &&
+                this.config.segmentations[segmentationId][type].perSegment?.[segmentIndex]) {
+                combinedStyle = {
+                    ...combinedStyle,
+                    ...this.config.segmentations[segmentationId][type].perSegment[segmentIndex],
+                };
+            }
+        }
+        if (viewportId && this.config.viewportsStyle[viewportId]) {
+            renderInactiveSegmentations =
+                this.config.viewportsStyle[viewportId].renderInactiveSegmentations;
+            const allSegmentationsKey = '__allSegmentations__';
+            if (this.config.viewportsStyle[viewportId].representations[allSegmentationsKey]?.[type]) {
+                combinedStyle = {
+                    ...combinedStyle,
+                    ...this.config.viewportsStyle[viewportId].representations[allSegmentationsKey][type].allSegments,
+                };
+            }
+            if (segmentationId &&
+                this.config.viewportsStyle[viewportId].representations[segmentationId]?.[type]) {
+                combinedStyle = {
+                    ...combinedStyle,
+                    ...this.config.viewportsStyle[viewportId].representations[segmentationId][type].allSegments,
+                };
+                if (segmentIndex !== undefined &&
+                    this.config.viewportsStyle[viewportId].representations[segmentationId][type].perSegment?.[segmentIndex]) {
+                    combinedStyle = {
+                        ...combinedStyle,
+                        ...this.config.viewportsStyle[viewportId].representations[segmentationId][type].perSegment[segmentIndex],
+                    };
+                }
+            }
+        }
+        return { style: combinedStyle, renderInactiveSegmentations };
+    }
+    getDefaultStyle(type) {
+        switch (type) {
+            case Enums.SegmentationRepresentations.Labelmap:
+                return getDefaultLabelmapConfig();
+            case Enums.SegmentationRepresentations.Contour:
+                return getDefaultContourConfig();
+            case Enums.SegmentationRepresentations.Surface:
+                return {};
+            default:
+                throw new Error(`Unknown representation type: ${type}`);
+        }
+    }
+}
+const segmentationStyle = new SegmentationStyle();
+export { segmentationStyle };

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

@@ -1,5 +1,4 @@
-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, };
+import type { Segmentation } from '../../types/SegmentationStateTypes';
+declare function getActiveSegmentation(viewportId: string): Segmentation;
+declare function setActiveSegmentation(viewportId: string, segmentationId: string, suppressEvent?: boolean): void;
+export { getActiveSegmentation, setActiveSegmentation, };

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

@@ -1,18 +1,13 @@
-import { getActiveSegmentationRepresentation as _getActiveSegmentationRepresentation } from './getActiveSegmentationRepresentation';
-import { setActiveSegmentationRepresentation as _setActiveSegmentationRepresentation } from './setActiveSegmentationRepresentation';
-import { getSegmentation } from './getSegmentation';
-function getActiveSegmentationRepresentation(viewportId) {
-    return _getActiveSegmentationRepresentation(viewportId);
-}
+import { getActiveSegmentation as _getActiveSegmentation } from './getActiveSegmentation';
+import { triggerSegmentationRender } from './SegmentationRenderingEngine';
+import { setActiveSegmentation as _setActiveSegmentation } from './setActiveSegmentation';
 function getActiveSegmentation(viewportId) {
-    const activeRepresentation = getActiveSegmentationRepresentation(viewportId);
-    if (!activeRepresentation) {
-        return null;
-    }
-    return getSegmentation(activeRepresentation.segmentationId);
+    return _getActiveSegmentation(viewportId);
 }
-function setActiveSegmentationRepresentation(viewportId, segmentationRepresentationUID, suppressEvent = false) {
-    _setActiveSegmentationRepresentation(viewportId, segmentationRepresentationUID, suppressEvent);
+function setActiveSegmentation(viewportId, segmentationId, suppressEvent = false) {
+    _setActiveSegmentation(viewportId, segmentationId);
+    if (!suppressEvent) {
+        triggerSegmentationRender(viewportId);
+    }
 }
-export { getActiveSegmentationRepresentation, getActiveSegmentation, setActiveSegmentationRepresentation, };
-//# sourceMappingURL=activeSegmentation.js.map
+export { getActiveSegmentation, setActiveSegmentation, };

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

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

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

@@ -1,6 +1,19 @@
+import { utilities } from '@cornerstonejs/core';
 import { defaultSegmentationStateManager } from './SegmentationStateManager';
+import { getNextColorLUTIndex } from './getNextColorLUTIndex';
+import CORNERSTONE_COLOR_LUT from '../../constants/COLOR_LUT';
 export function addColorLUT(colorLUT, index) {
     const segmentationStateManager = defaultSegmentationStateManager;
-    segmentationStateManager.addColorLUT(colorLUT, index);
+    const indexToUse = index ?? getNextColorLUTIndex();
+    let colorLUTToUse = [...colorLUT];
+    if (!utilities.isEqual(colorLUTToUse[0], [0, 0, 0, 0])) {
+        console.warn('addColorLUT: [0, 0, 0, 0] color is not provided for the background color (segmentIndex =0), automatically adding it');
+        colorLUTToUse = [[0, 0, 0, 0], ...colorLUTToUse];
+    }
+    if (colorLUTToUse.length < 255) {
+        const missingColorLUTs = CORNERSTONE_COLOR_LUT.slice(colorLUTToUse.length);
+        colorLUTToUse = [...colorLUTToUse, ...missingColorLUTs];
+    }
+    segmentationStateManager.addColorLUT(colorLUTToUse, indexToUse);
+    return indexToUse;
 }
-//# sourceMappingURL=addColorLUT.js.map

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

@@ -0,0 +1,15 @@
+import type { RepresentationPublicInput } from '../../types/SegmentationStateTypes';
+export declare function addSegmentationRepresentations(viewportId: string, segmentationInputArray: RepresentationPublicInput[]): void;
+declare function addContourRepresentationToViewport(viewportId: string, contourInputArray: RepresentationPublicInput[]): void;
+declare function addContourRepresentationToViewportMap(viewportInputMap: {
+    [viewportId: string]: RepresentationPublicInput[];
+}): {};
+declare function addLabelmapRepresentationToViewport(viewportId: string, labelmapInputArray: RepresentationPublicInput[]): void;
+declare function addLabelmapRepresentationToViewportMap(viewportInputMap: {
+    [viewportId: string]: RepresentationPublicInput[];
+}): void;
+declare function addSurfaceRepresentationToViewport(viewportId: string, surfaceInputArray: RepresentationPublicInput[]): void;
+declare function addSurfaceRepresentationToViewportMap(viewportInputMap: {
+    [viewportId: string]: RepresentationPublicInput[];
+}): {};
+export { addContourRepresentationToViewport, addLabelmapRepresentationToViewport, addSurfaceRepresentationToViewport, addContourRepresentationToViewportMap, addLabelmapRepresentationToViewportMap, addSurfaceRepresentationToViewportMap, };

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

@@ -0,0 +1,49 @@
+import { SegmentationRepresentations } from '../../enums';
+import { internalAddSegmentationRepresentation } from './internalAddSegmentationRepresentation';
+export function addSegmentationRepresentations(viewportId, segmentationInputArray) {
+    segmentationInputArray.map((segmentationInput) => {
+        return internalAddSegmentationRepresentation(viewportId, segmentationInput);
+    });
+}
+function addContourRepresentationToViewport(viewportId, contourInputArray) {
+    return addSegmentationRepresentations(viewportId, contourInputArray.map((input) => ({
+        ...input,
+        type: SegmentationRepresentations.Contour,
+    })));
+}
+function addContourRepresentationToViewportMap(viewportInputMap) {
+    const results = {};
+    for (const [viewportId, inputArray] of Object.entries(viewportInputMap)) {
+        results[viewportId] = addContourRepresentationToViewport(viewportId, inputArray);
+    }
+    return results;
+}
+function addLabelmapRepresentationToViewport(viewportId, labelmapInputArray) {
+    return addSegmentationRepresentations(viewportId, labelmapInputArray.map((input) => ({
+        ...input,
+        type: SegmentationRepresentations.Labelmap,
+    })));
+}
+function addLabelmapRepresentationToViewportMap(viewportInputMap) {
+    const results = {};
+    for (const [viewportId, inputArray] of Object.entries(viewportInputMap)) {
+        results[viewportId] = addLabelmapRepresentationToViewport(viewportId, inputArray.map((input) => ({
+            ...input,
+            type: SegmentationRepresentations.Labelmap,
+        })));
+    }
+}
+function addSurfaceRepresentationToViewport(viewportId, surfaceInputArray) {
+    return addSegmentationRepresentations(viewportId, surfaceInputArray.map((input) => ({
+        ...input,
+        type: SegmentationRepresentations.Surface,
+    })));
+}
+function addSurfaceRepresentationToViewportMap(viewportInputMap) {
+    const results = {};
+    for (const [viewportId, inputArray] of Object.entries(viewportInputMap)) {
+        results[viewportId] = addSurfaceRepresentationToViewport(viewportId, inputArray);
+    }
+    return results;
+}
+export { addContourRepresentationToViewport, addLabelmapRepresentationToViewport, addSurfaceRepresentationToViewport, addContourRepresentationToViewportMap, addLabelmapRepresentationToViewportMap, addSurfaceRepresentationToViewportMap, };

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

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

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

@@ -1,11 +1,14 @@
-import { validateSegmentationInput } from './helpers';
-import { addSegmentation as addSegmentationToState } from './segmentationState';
-function addSegmentations(segmentationInputArray) {
-    validateSegmentationInput(segmentationInputArray);
-    segmentationInputArray.map((segInput) => {
-        const segmentationInput = structuredClone(segInput);
-        addSegmentationToState(segmentationInput);
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+import { triggerSegmentationModified } from './triggerSegmentationEvents';
+import normalizeSegmentationInput from './helpers/normalizeSegmentationInput';
+export function addSegmentations(segmentationInputArray, suppressEvents) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    segmentationInputArray.forEach((segmentationInput) => {
+        const segmentation = normalizeSegmentationInput(segmentationInput);
+        segmentationStateManager.addSegmentation(segmentation);
+        if (!suppressEvents) {
+            triggerSegmentationModified(segmentation.segmentationId);
+        }
     });
 }
 export default addSegmentations;
-//# sourceMappingURL=addSegmentations.js.map

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, getSegmentationRepresentationConfig, getPerSegmentConfig, getSegmentIndexConfig, setSegmentationRepresentationConfig, setPerSegmentConfig, setSegmentIndexConfig } from './segmentationConfig';
-export { color, visibility, getGlobalConfig, getGlobalRepresentationConfig, setGlobalConfig, setGlobalRepresentationConfig, getSegmentationRepresentationConfig, getPerSegmentConfig, getSegmentIndexConfig, setSegmentationRepresentationConfig, setPerSegmentConfig, setSegmentIndexConfig, };
+import * as style from './styleHelpers';
+export { color, visibility, style };

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

@@ -1,5 +1,4 @@
 import * as color from './segmentationColor';
 import * as visibility from './segmentationVisibility';
-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, };
-//# sourceMappingURL=index.js.map
+import * as style from './styleHelpers';
+export { color, visibility, style };

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

@@ -1,6 +1,6 @@
 import type { Types } from '@cornerstonejs/core';
-declare function addColorLUT(colorLUT: Types.ColorLUT, colorLUTIndex: number): void;
-declare function setColorLUT(segmentationRepresentationUID: string, colorLUTIndex: number): void;
-declare function getSegmentIndexColor(segmentationRepresentationUID: string, segmentIndex: number): Types.Color;
-declare function setSegmentIndexColor(segmentationRepresentationUID: string, segmentIndex: number, color: Types.Color): void;
+declare function addColorLUT(colorLUT: Types.ColorLUT, colorLUTIndex?: number): number;
+declare function setColorLUT(viewportId: string, segmentationId: string, colorLUTsIndex: number): void;
+declare function getSegmentIndexColor(viewportId: string, segmentationId: string, segmentIndex: number): Types.Color;
+declare function setSegmentIndexColor(viewportId: string, segmentationId: string, segmentIndex: number, color: Types.Color): void;
 export { getSegmentIndexColor, addColorLUT, setColorLUT, setSegmentIndexColor };

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

@@ -1,35 +1,35 @@
-import { utilities } from '@cornerstonejs/core';
-import { triggerSegmentationRepresentationModified } from '../triggerSegmentationEvents';
 import { addColorLUT as _addColorLUT } from '../addColorLUT';
 import { getColorLUT as _getColorLUT } from '../getColorLUT';
-import { getSegmentationRepresentation } from '../getSegmentationRepresentation';
+import { getSegmentationRepresentations } from '../getSegmentationRepresentation';
+import { triggerSegmentationModified } from '../triggerSegmentationEvents';
 function addColorLUT(colorLUT, colorLUTIndex) {
     if (!colorLUT) {
         throw new Error('addColorLUT: colorLUT is required');
     }
-    if (!utilities.isEqual(colorLUT[0], [0, 0, 0, 0])) {
-        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]);
-    }
-    _addColorLUT(colorLUT, colorLUTIndex);
+    return _addColorLUT(colorLUT, colorLUTIndex);
 }
-function setColorLUT(segmentationRepresentationUID, colorLUTIndex) {
-    const segRepresentation = getSegmentationRepresentation(segmentationRepresentationUID);
-    if (!segRepresentation) {
-        throw new Error(`setColorLUT: could not find segmentation representation with UID ${segmentationRepresentationUID}`);
+function setColorLUT(viewportId, segmentationId, colorLUTsIndex) {
+    if (!_getColorLUT(colorLUTsIndex)) {
+        throw new Error(`setColorLUT: could not find colorLUT with index ${colorLUTsIndex}`);
     }
-    if (!_getColorLUT(colorLUTIndex)) {
-        throw new Error(`setColorLUT: could not find colorLUT with index ${colorLUTIndex}`);
+    const segmentationRepresentations = getSegmentationRepresentations(viewportId, { segmentationId });
+    if (!segmentationRepresentations) {
+        throw new Error(`viewport specific state for viewport ${viewportId} does not exist`);
     }
-    segRepresentation.colorLUTIndex = colorLUTIndex;
-    triggerSegmentationRepresentationModified(segmentationRepresentationUID);
+    segmentationRepresentations.forEach((segmentationRepresentation) => {
+        segmentationRepresentation.config.colorLUTIndex = colorLUTsIndex;
+    });
+    triggerSegmentationModified(segmentationId);
 }
-function getSegmentIndexColor(segmentationRepresentationUID, segmentIndex) {
-    const segmentationRepresentation = getSegmentationRepresentation(segmentationRepresentationUID);
-    if (!segmentationRepresentation) {
-        throw new Error(`segmentation representation with UID ${segmentationRepresentationUID} does not exist`);
+function getSegmentIndexColor(viewportId, segmentationId, segmentIndex) {
+    const representations = getSegmentationRepresentations(viewportId, {
+        segmentationId,
+    });
+    if (!representations) {
+        throw new Error(`segmentation representation with segmentationId ${segmentationId} does not exist`);
     }
-    const { colorLUTIndex } = segmentationRepresentation;
+    const representation = representations[0];
+    const { colorLUTIndex } = representation.config;
     const colorLUT = _getColorLUT(colorLUTIndex);
     let colorValue = colorLUT[segmentIndex];
     if (!colorValue) {
@@ -40,12 +40,11 @@ function getSegmentIndexColor(segmentationRepresentationUID, segmentIndex) {
     }
     return colorValue;
 }
-function setSegmentIndexColor(segmentationRepresentationUID, segmentIndex, color) {
-    const colorReference = getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
+function setSegmentIndexColor(viewportId, segmentationId, segmentIndex, color) {
+    const colorReference = getSegmentIndexColor(viewportId, segmentationId, segmentIndex);
     for (let i = 0; i < color.length; i++) {
         colorReference[i] = color[i];
     }
-    triggerSegmentationRepresentationModified(segmentationRepresentationUID);
+    triggerSegmentationModified(segmentationId);
 }
 export { getSegmentIndexColor, addColorLUT, setColorLUT, setSegmentIndexColor };
-//# sourceMappingURL=segmentationColor.js.map

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

@@ -1,7 +1,22 @@
-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 getHiddenSegmentIndices(viewportId: string, segmentationRepresentationUID: string): Set<number>;
-export { setSegmentationRepresentationVisibility, getSegmentationRepresentationVisibility, setSegmentIndicesVisibility, setSegmentIndexVisibility, getSegmentIndexVisibility, getHiddenSegmentIndices, };
+import type { SegmentationRepresentations } from '../../../enums';
+declare function setSegmentationRepresentationVisibility(viewportId: string, specifier: {
+    segmentationId: string;
+    type?: SegmentationRepresentations;
+}, visibility: boolean): void;
+declare function getSegmentationRepresentationVisibility(viewportId: string, specifier: {
+    segmentationId: string;
+    type: SegmentationRepresentations;
+}): boolean | undefined;
+declare function setSegmentIndexVisibility(viewportId: string, specifier: {
+    segmentationId: string;
+    type?: SegmentationRepresentations;
+}, segmentIndex: number, visibility: boolean): void;
+declare function getSegmentIndexVisibility(viewportId: string, specifier: {
+    segmentationId: string;
+    type: SegmentationRepresentations;
+}, segmentIndex: number): boolean;
+declare function getHiddenSegmentIndices(viewportId: string, specifier: {
+    segmentationId: string;
+    type: SegmentationRepresentations;
+}): Set<number>;
+export { setSegmentationRepresentationVisibility, getSegmentationRepresentationVisibility, setSegmentIndexVisibility, getSegmentIndexVisibility, getHiddenSegmentIndices, };

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

@@ -1,46 +1,45 @@
-import { getSegmentationRepresentation } from '../getSegmentationRepresentation';
-import { triggerSegmentationRepresentationModified } from '../triggerSegmentationEvents';
+import { getSegmentationRepresentation, getSegmentationRepresentations, } from '../getSegmentationRepresentation';
 import { setSegmentationRepresentationVisibility as _setSegmentationRepresentationVisibility } from '../setSegmentationRepresentationVisibility';
 import { getSegmentationRepresentationVisibility as _getSegmentationRepresentationVisibility } from '../getSegmentationRepresentationVisibility';
-import { getSegmentationRepresentationViewportStates } from '../getSegmentationRepresentationViewportStates';
-function setSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID, visibility) {
-    const representation = getSegmentationRepresentation(segmentationRepresentationUID);
-    if (!representation) {
+import { triggerSegmentationModified } from '../triggerSegmentationEvents';
+function setSegmentationRepresentationVisibility(viewportId, specifier, visibility) {
+    const representations = getSegmentationRepresentations(viewportId, specifier);
+    if (!representations) {
         return;
     }
-    _setSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID, visibility);
-    triggerSegmentationRepresentationModified(segmentationRepresentationUID);
+    representations.forEach((representation) => {
+        _setSegmentationRepresentationVisibility(viewportId, {
+            segmentationId: representation.segmentationId,
+            type: representation.type,
+        }, visibility);
+    });
+    triggerSegmentationModified(specifier.segmentationId);
 }
-function getSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID) {
-    return _getSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID);
+function getSegmentationRepresentationVisibility(viewportId, specifier) {
+    return _getSegmentationRepresentationVisibility(viewportId, specifier);
 }
-function setSegmentIndicesVisibility(viewport, segmentationRepresentationUID, segmentIndices, visibility) {
-    const hiddenSegments = getHiddenSegmentIndices(viewport, segmentationRepresentationUID);
-    segmentIndices.forEach((segmentIndex) => {
+function setSegmentIndexVisibility(viewportId, specifier, segmentIndex, visibility) {
+    const representations = getSegmentationRepresentations(viewportId, specifier);
+    if (!representations) {
+        return;
+    }
+    representations.forEach((representation) => {
+        const hiddenSegments = representation.segmentsHidden ?? new Set();
         visibility
             ? hiddenSegments.delete(segmentIndex)
             : hiddenSegments.add(segmentIndex);
     });
-    triggerSegmentationRepresentationModified(segmentationRepresentationUID);
-}
-function setSegmentIndexVisibility(viewportId, segmentationRepresentationUID, segmentIndex, visibility) {
-    const hiddenSegments = getHiddenSegmentIndices(viewportId, segmentationRepresentationUID);
-    visibility
-        ? hiddenSegments.delete(segmentIndex)
-        : hiddenSegments.add(segmentIndex);
-    triggerSegmentationRepresentationModified(segmentationRepresentationUID);
+    triggerSegmentationModified(specifier.segmentationId);
 }
-function getSegmentIndexVisibility(viewportId, segmentationRepresentationUID, segmentIndex) {
-    const hiddenSegments = getHiddenSegmentIndices(viewportId, segmentationRepresentationUID);
+function getSegmentIndexVisibility(viewportId, specifier, segmentIndex) {
+    const hiddenSegments = getHiddenSegmentIndices(viewportId, specifier);
     return !hiddenSegments.has(segmentIndex);
 }
-function getHiddenSegmentIndices(viewportId, segmentationRepresentationUID) {
-    const viewportRenderingState = getSegmentationRepresentationViewportStates(viewportId);
-    if (!viewportRenderingState) {
+function getHiddenSegmentIndices(viewportId, specifier) {
+    const representation = getSegmentationRepresentation(viewportId, specifier);
+    if (!representation) {
         return new Set();
     }
-    return (viewportRenderingState[segmentationRepresentationUID]?.segmentsHidden ??
-        new Set());
+    return representation.segmentsHidden ?? new Set();
 }
-export { setSegmentationRepresentationVisibility, getSegmentationRepresentationVisibility, setSegmentIndicesVisibility, setSegmentIndexVisibility, getSegmentIndexVisibility, getHiddenSegmentIndices, };
-//# sourceMappingURL=segmentationVisibility.js.map
+export { setSegmentationRepresentationVisibility, getSegmentationRepresentationVisibility, setSegmentIndexVisibility, getSegmentIndexVisibility, getHiddenSegmentIndices, };

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

@@ -0,0 +1,39 @@
+import SegmentationRepresentations from '../../../enums/SegmentationRepresentations';
+import type { ContourStyle } from '../../../types/ContourTypes';
+import type { LabelmapStyle } from '../../../types/LabelmapTypes';
+import type { SurfaceStyle } from '../../../types/SurfaceTypes';
+import type { RepresentationStyle } from '../SegmentationStyle';
+declare function getStyle(specifier: {
+    viewportId?: string;
+    segmentationId?: string;
+    type?: SegmentationRepresentations;
+    segmentIndex?: number;
+}): {
+    style: RepresentationStyle;
+    renderInactiveSegmentations: boolean;
+};
+declare function getGlobalStyle(type: SegmentationRepresentations): RepresentationStyle;
+declare function setGlobalStyle(type: SegmentationRepresentations, style: RepresentationStyle): void;
+declare function setGlobalLabelmapStyle(style: LabelmapStyle): void;
+declare function setGlobalContourStyle(style: ContourStyle): void;
+declare function setGlobalSurfaceStyle(style: SurfaceStyle): void;
+declare function setSegmentationSpecificStyle(specifier: {
+    segmentationId: string;
+    type: SegmentationRepresentations;
+    segmentIndex?: number;
+}, style: RepresentationStyle): void;
+declare function setLabelmapStyle(specifier: {
+    segmentationId: string;
+}, style: LabelmapStyle): void;
+declare function setViewportSpecificStyleForType(specifier: {
+    viewportId: string;
+    type: SegmentationRepresentations;
+}, style: RepresentationStyle): void;
+declare function setViewportSpecificStyleForSegmentation(specifier: {
+    viewportId: string;
+    segmentationId: string;
+    type: SegmentationRepresentations;
+    segmentIndex?: number;
+}, style: RepresentationStyle): void;
+declare function setViewportRenderInactiveSegmentations(viewportId: string, renderInactiveSegmentations: boolean): void;
+export { getStyle, getGlobalStyle, setGlobalStyle, setGlobalLabelmapStyle, setGlobalContourStyle, setGlobalSurfaceStyle, setSegmentationSpecificStyle, setLabelmapStyle, setViewportSpecificStyleForType, setViewportSpecificStyleForSegmentation, setViewportRenderInactiveSegmentations, };

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

@@ -0,0 +1,48 @@
+import SegmentationRepresentations from '../../../enums/SegmentationRepresentations';
+import { triggerSegmentationRender } from '../SegmentationRenderingEngine';
+import { segmentationStyle } from '../SegmentationStyle';
+function getStyle(specifier) {
+    return segmentationStyle.getStyle(specifier);
+}
+function getGlobalStyle(type) {
+    return segmentationStyle.getGlobalStyle(type);
+}
+function setGlobalStyle(type, style) {
+    segmentationStyle.setGlobalStyle(type, style);
+    triggerSegmentationRender();
+}
+function setGlobalLabelmapStyle(style) {
+    segmentationStyle.setGlobalLabelmapStyle(style);
+    triggerSegmentationRender();
+}
+function setGlobalContourStyle(style) {
+    segmentationStyle.setGlobalContourStyle(style);
+    triggerSegmentationRender();
+}
+function setGlobalSurfaceStyle(style) {
+    segmentationStyle.setGlobalSurfaceStyle(style);
+    triggerSegmentationRender();
+}
+function setSegmentationSpecificStyle(specifier, style) {
+    segmentationStyle.setSegmentationSpecificStyle(specifier, style);
+    triggerSegmentationRender();
+}
+function setLabelmapStyle(specifier, style) {
+    setSegmentationSpecificStyle({
+        ...specifier,
+        type: SegmentationRepresentations.Labelmap,
+    }, style);
+}
+function setViewportSpecificStyleForType(specifier, style) {
+    segmentationStyle.setViewportSpecificStyleForType(specifier, style);
+    triggerSegmentationRender(specifier.viewportId);
+}
+function setViewportSpecificStyleForSegmentation(specifier, style) {
+    segmentationStyle.setViewportSpecificStyleForSegmentation(specifier, style);
+    triggerSegmentationRender(specifier.viewportId);
+}
+function setViewportRenderInactiveSegmentations(viewportId, renderInactiveSegmentations) {
+    segmentationStyle.setViewportRenderInactiveSegmentations(viewportId, renderInactiveSegmentations);
+    triggerSegmentationRender(viewportId);
+}
+export { getStyle, getGlobalStyle, setGlobalStyle, setGlobalLabelmapStyle, setGlobalContourStyle, setGlobalSurfaceStyle, setSegmentationSpecificStyle, setLabelmapStyle, setViewportSpecificStyleForType, setViewportSpecificStyleForSegmentation, setViewportRenderInactiveSegmentations, };

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

@@ -9,4 +9,3 @@ export function triggerSegmentationDataModified(segmentationId, modifiedSlicesTo
     setSegmentationDirty(segmentationId);
     triggerEvent(eventTarget, Events.SEGMENTATION_DATA_MODIFIED, eventDetail);
 }
-//# sourceMappingURL=triggerSegmentationDataModified.js.map