@cornerstonejs/tools 2.0.0-beta.8 → 2.0.1

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

@@ -0,0 +1,223 @@
+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 = {
+            global: {},
+            segmentations: {},
+            viewportsStyle: {},
+        };
+    }
+    setStyle(specifier, styles) {
+        const { viewportId, segmentationId, type, segmentIndex } = specifier;
+        const currentStyles = this.getStyle(specifier);
+        let updatedStyles;
+        if (!viewportId && !segmentationId) {
+            updatedStyles = {
+                ...currentStyles,
+                ...styles,
+            };
+        }
+        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;
+            }
+        }
+        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;
+            }
+        }
+        else {
+            this.config.global[type] = updatedStyles;
+        }
+    }
+    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;
+        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 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) {
+            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}`);
+        }
+    }
+    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.d.ts

@@ -0,0 +1,4 @@
+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,26 +1,9 @@
-import { getDefaultSegmentationStateManager, getSegmentation, } from './segmentationState';
-import { triggerSegmentationRepresentationModified } from './triggerSegmentationEvents';
-function getActiveSegmentationRepresentation(toolGroupId) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    const toolGroupSegmentationRepresentations = segmentationStateManager.getSegmentationRepresentations(toolGroupId);
-    if (!toolGroupSegmentationRepresentations) {
-        return;
-    }
-    const activeRepresentation = toolGroupSegmentationRepresentations.find((representation) => representation.active);
-    return activeRepresentation;
+import { getActiveSegmentation as _getActiveSegmentation } from './getActiveSegmentation';
+import { setActiveSegmentation as _setActiveSegmentation } from './setActiveSegmentation';
+function getActiveSegmentation(viewportId) {
+    return _getActiveSegmentation(viewportId);
 }
-function getActiveSegmentation(toolGroupId) {
-    const activeRepresentation = getActiveSegmentationRepresentation(toolGroupId);
-    if (!activeRepresentation) {
-        return;
-    }
-    const activeSegmentation = getSegmentation(activeRepresentation.segmentationId);
-    return activeSegmentation;
+function setActiveSegmentation(viewportId, segmentationId, suppressEvent = false) {
+    _setActiveSegmentation(viewportId, segmentationId);
 }
-function setActiveSegmentationRepresentation(toolGroupId, segmentationRepresentationUID) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.setActiveSegmentationRepresentation(toolGroupId, segmentationRepresentationUID);
-    triggerSegmentationRepresentationModified(toolGroupId, segmentationRepresentationUID);
-}
-export { getActiveSegmentationRepresentation, getActiveSegmentation, setActiveSegmentationRepresentation, };
-//# sourceMappingURL=activeSegmentation.js.map
+export { getActiveSegmentation, setActiveSegmentation, };

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

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

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

@@ -0,0 +1,25 @@
+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;
+    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];
+    }
+    colorLUTToUse = colorLUTToUse.map((color) => {
+        if (color.length === 3) {
+            return [color[0], color[1], color[2], 255];
+        }
+        return color;
+    });
+    if (colorLUTToUse.length < 255) {
+        const missingColorLUTs = CORNERSTONE_COLOR_LUT.slice(colorLUTToUse.length);
+        colorLUTToUse = [...colorLUTToUse, ...missingColorLUTs];
+    }
+    segmentationStateManager.addColorLUT(colorLUTToUse, indexToUse);
+    return indexToUse;
+}

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

@@ -0,0 +1,3 @@
+import type { SegmentationPublicInput } from '../../types/SegmentationStateTypes';
+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

@@ -0,0 +1,4 @@
+import * as color from './segmentationColor';
+import * as visibility from './segmentationVisibility';
+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, getToolGroupSpecificConfig, setGlobalConfig, setGlobalRepresentationConfig, setToolGroupSpecificConfig, setSegmentSpecificConfig, getSegmentSpecificConfig, setSegmentationRepresentationSpecificConfig, getSegmentationRepresentationSpecificConfig, } from './segmentationConfig';
-export { color, visibility, getGlobalConfig, getGlobalRepresentationConfig, getToolGroupSpecificConfig, setGlobalConfig, setGlobalRepresentationConfig, setToolGroupSpecificConfig, setSegmentSpecificConfig, getSegmentSpecificConfig, setSegmentationRepresentationSpecificConfig, getSegmentationRepresentationSpecificConfig, };
-//# sourceMappingURL=index.js.map
+import * as style from './styleHelpers';
+export { color, visibility, style };

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

@@ -0,0 +1,6 @@
+import type { Types } from '@cornerstonejs/core';
+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,34 +1,36 @@
-import { utilities } from '@cornerstonejs/core';
-import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
+import { addColorLUT as _addColorLUT } from '../addColorLUT';
+import { getColorLUT as _getColorLUT } from '../getColorLUT';
+import { getSegmentationRepresentations } from '../getSegmentationRepresentation';
 import { triggerSegmentationRepresentationModified } 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]);
-    }
-    SegmentationState.addColorLUT(colorLUT, colorLUTIndex);
+    return _addColorLUT(colorLUT, colorLUTIndex);
 }
-function setColorLUT(toolGroupId, segmentationRepresentationUID, colorLUTIndex) {
-    const segRepresentation = SegmentationState.getSegmentationRepresentationByUID(toolGroupId, 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 (!SegmentationState.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(toolGroupId, segmentationRepresentationUID);
+    segmentationRepresentations.forEach((segmentationRepresentation) => {
+        segmentationRepresentation.colorLUTIndex = colorLUTsIndex;
+    });
+    triggerSegmentationRepresentationModified(viewportId, segmentationId);
 }
-function getColorForSegmentIndex(toolGroupId, segmentationRepresentationUID, segmentIndex) {
-    const segmentationRepresentation = SegmentationState.getSegmentationRepresentationByUID(toolGroupId, segmentationRepresentationUID);
-    if (!segmentationRepresentation) {
-        throw new Error(`segmentation representation with UID ${segmentationRepresentationUID} does not exist for tool group ${toolGroupId}`);
+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 colorLUT = SegmentationState.getColorLUT(colorLUTIndex);
+    const representation = representations[0];
+    const { colorLUTIndex } = representation;
+    const colorLUT = _getColorLUT(colorLUTIndex);
     let colorValue = colorLUT[segmentIndex];
     if (!colorValue) {
         if (typeof segmentIndex !== 'number') {
@@ -38,12 +40,11 @@ function getColorForSegmentIndex(toolGroupId, segmentationRepresentationUID, seg
     }
     return colorValue;
 }
-function setColorForSegmentIndex(toolGroupId, segmentationRepresentationUID, segmentIndex, color) {
-    const colorReference = getColorForSegmentIndex(toolGroupId, 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(toolGroupId, segmentationRepresentationUID);
+    triggerSegmentationRepresentationModified(viewportId, segmentationId);
 }
-export { getColorForSegmentIndex, addColorLUT, setColorLUT, setColorForSegmentIndex, };
-//# sourceMappingURL=segmentationColor.js.map
+export { getSegmentIndexColor, addColorLUT, setColorLUT, setSegmentIndexColor };

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

@@ -0,0 +1,22 @@
+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,70 +1,49 @@
-import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
-import { getSegmentationRepresentations } from '../../../stateManagement/segmentation/segmentationState';
-import { getUniqueSegmentIndices } from '../../../utilities/segmentation';
+import { getSegmentationRepresentation, getSegmentationRepresentations, } from '../getSegmentationRepresentation';
+import { setSegmentationRepresentationVisibility as _setSegmentationRepresentationVisibility } from '../setSegmentationRepresentationVisibility';
+import { getSegmentationRepresentationVisibility as _getSegmentationRepresentationVisibility } from '../getSegmentationRepresentationVisibility';
+import { triggerSegmentationRenderBySegmentationId } from '../SegmentationRenderingEngine';
 import { triggerSegmentationRepresentationModified } from '../triggerSegmentationEvents';
-function setSegmentationVisibility(toolGroupId, segmentationRepresentationUID, visibility) {
-    const toolGroupSegmentationRepresentations = getSegmentationRepresentations(toolGroupId);
-    if (!toolGroupSegmentationRepresentations) {
+function setSegmentationRepresentationVisibility(viewportId, specifier, visibility) {
+    const representations = getSegmentationRepresentations(viewportId, specifier);
+    if (!representations) {
         return;
     }
-    const representation = toolGroupSegmentationRepresentations.find((representation) => representation.segmentationRepresentationUID ===
-        segmentationRepresentationUID);
-    if (!representation) {
-        return;
-    }
-    const { segmentsHidden, segmentationId } = representation;
-    const indices = getUniqueSegmentIndices(segmentationId);
-    if (visibility) {
-        segmentsHidden.clear();
-    }
-    else {
-        indices.forEach((index) => {
-            segmentsHidden.add(index);
-        });
-    }
-    triggerSegmentationRepresentationModified(toolGroupId, representation.segmentationRepresentationUID);
+    representations.forEach((representation) => {
+        _setSegmentationRepresentationVisibility(viewportId, {
+            segmentationId: representation.segmentationId,
+            type: representation.type,
+        }, visibility);
+    });
 }
-function getSegmentationVisibility(toolGroupId, segmentationRepresentationUID) {
-    const toolGroupSegmentationRepresentations = getSegmentationRepresentations(toolGroupId);
-    const representation = toolGroupSegmentationRepresentations.find((representation) => representation.segmentationRepresentationUID ===
-        segmentationRepresentationUID);
-    if (!representation) {
-        return;
-    }
-    const { segmentsHidden, segmentationId } = representation;
-    const indices = getUniqueSegmentIndices(segmentationId);
-    const indicesSet = new Set(indices);
-    segmentsHidden.forEach((segmentIndex) => indicesSet.delete(segmentIndex));
-    return !!indicesSet.size;
+function getSegmentationRepresentationVisibility(viewportId, specifier) {
+    return _getSegmentationRepresentationVisibility(viewportId, specifier);
 }
-function setSegmentsVisibility(toolGroupId, segmentationRepresentationUID, segmentIndices, visibility) {
-    const segRepresentation = SegmentationState.getSegmentationRepresentationByUID(toolGroupId, segmentationRepresentationUID);
-    if (!segRepresentation) {
+function setSegmentIndexVisibility(viewportId, specifier, segmentIndex, visibility) {
+    const representations = getSegmentationRepresentations(viewportId, specifier);
+    if (!representations) {
         return;
     }
-    segmentIndices.forEach((segmentIndex) => {
-        visibility
-            ? segRepresentation.segmentsHidden.delete(segmentIndex)
-            : segRepresentation.segmentsHidden.add(segmentIndex);
+    representations.forEach((representation) => {
+        representation.segments[segmentIndex].visible = visibility;
     });
-    triggerSegmentationRepresentationModified(toolGroupId, segmentationRepresentationUID);
+    triggerSegmentationRenderBySegmentationId(specifier.segmentationId);
+    triggerSegmentationRepresentationModified(viewportId, specifier.segmentationId);
 }
-function setSegmentVisibility(toolGroupId, segmentationRepresentationUID, segmentIndex, visibility) {
-    const segRepresentation = SegmentationState.getSegmentationRepresentationByUID(toolGroupId, segmentationRepresentationUID);
-    if (!segRepresentation) {
-        return;
-    }
-    visibility
-        ? segRepresentation.segmentsHidden.delete(segmentIndex)
-        : segRepresentation.segmentsHidden.add(segmentIndex);
-    triggerSegmentationRepresentationModified(toolGroupId, segmentationRepresentationUID);
+function getSegmentIndexVisibility(viewportId, specifier, segmentIndex) {
+    const hiddenSegments = getHiddenSegmentIndices(viewportId, specifier);
+    return !hiddenSegments.has(segmentIndex);
 }
-function getSegmentVisibility(toolGroupId, segmentationRepresentationUID, segmentIndex) {
-    const segRepresentation = SegmentationState.getSegmentationRepresentationByUID(toolGroupId, segmentationRepresentationUID);
-    if (!segRepresentation) {
-        return false;
-    }
-    return !segRepresentation.segmentsHidden.has(segmentIndex);
+function getHiddenSegmentIndices(viewportId, specifier) {
+    const representation = getSegmentationRepresentation(viewportId, specifier);
+    if (!representation) {
+        return new Set();
+    }
+    const segmentsHidden = Object.entries(representation.segments).reduce((acc, [segmentIndex, segment]) => {
+        if (!segment.visible) {
+            acc.add(Number(segmentIndex));
+        }
+        return acc;
+    }, new Set());
+    return segmentsHidden;
 }
-export { setSegmentationVisibility, getSegmentationVisibility, setSegmentVisibility, setSegmentsVisibility, getSegmentVisibility, };
-//# sourceMappingURL=segmentationVisibility.js.map
+export { setSegmentationRepresentationVisibility, getSegmentationRepresentationVisibility, setSegmentIndexVisibility, getSegmentIndexVisibility, getHiddenSegmentIndices, };