@cornerstonejs/tools 3.0.2 → 3.0.3

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): void;
+export { getActiveSegmentation, setActiveSegmentation, };

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

@@ -0,0 +1,9 @@
+import { getActiveSegmentation as _getActiveSegmentation } from './getActiveSegmentation';
+import { setActiveSegmentation as _setActiveSegmentation } from './setActiveSegmentation';
+function getActiveSegmentation(viewportId) {
+    return _getActiveSegmentation(viewportId);
+}
+function setActiveSegmentation(viewportId, segmentationId) {
+    _setActiveSegmentation(viewportId, segmentationId);
+}
+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

@@ -0,0 +1,14 @@
+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;

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

@@ -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/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

@@ -0,0 +1,50 @@
+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');
+    }
+    return _addColorLUT(colorLUT, colorLUTIndex);
+}
+function setColorLUT(viewportId, segmentationId, colorLUTsIndex) {
+    if (!_getColorLUT(colorLUTsIndex)) {
+        throw new Error(`setColorLUT: could not find colorLUT with index ${colorLUTsIndex}`);
+    }
+    const segmentationRepresentations = getSegmentationRepresentations(viewportId, { segmentationId });
+    if (!segmentationRepresentations) {
+        throw new Error(`viewport specific state for viewport ${viewportId} does not exist`);
+    }
+    segmentationRepresentations.forEach((segmentationRepresentation) => {
+        segmentationRepresentation.colorLUTIndex = colorLUTsIndex;
+    });
+    triggerSegmentationRepresentationModified(viewportId, segmentationId);
+}
+function getSegmentIndexColor(viewportId, segmentationId, segmentIndex) {
+    const representations = getSegmentationRepresentations(viewportId, {
+        segmentationId,
+    });
+    if (!representations || representations.length === 0) {
+        return null;
+    }
+    const representation = representations[0];
+    const { colorLUTIndex } = representation;
+    const colorLUT = _getColorLUT(colorLUTIndex);
+    let colorValue = colorLUT[segmentIndex];
+    if (!colorValue) {
+        if (typeof segmentIndex !== 'number') {
+            throw new Error(`Can't create colour for LUT index ${segmentIndex}`);
+        }
+        colorValue = colorLUT[segmentIndex] = [0, 0, 0, 0];
+    }
+    return colorValue;
+}
+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(viewportId, segmentationId);
+}
+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

@@ -0,0 +1,49 @@
+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 setSegmentationRepresentationVisibility(viewportId, specifier, visibility) {
+    const representations = getSegmentationRepresentations(viewportId, specifier);
+    if (!representations) {
+        return;
+    }
+    representations.forEach((representation) => {
+        _setSegmentationRepresentationVisibility(viewportId, {
+            segmentationId: representation.segmentationId,
+            type: representation.type,
+        }, visibility);
+    });
+}
+function getSegmentationRepresentationVisibility(viewportId, specifier) {
+    return _getSegmentationRepresentationVisibility(viewportId, specifier);
+}
+function setSegmentIndexVisibility(viewportId, specifier, segmentIndex, visibility) {
+    const representations = getSegmentationRepresentations(viewportId, specifier);
+    if (!representations) {
+        return;
+    }
+    representations.forEach((representation) => {
+        representation.segments[segmentIndex].visible = visibility;
+    });
+    triggerSegmentationRenderBySegmentationId(specifier.segmentationId);
+    triggerSegmentationRepresentationModified(viewportId, specifier.segmentationId);
+}
+function getSegmentIndexVisibility(viewportId, specifier, segmentIndex) {
+    const hiddenSegments = getHiddenSegmentIndices(viewportId, specifier);
+    return !hiddenSegments.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 { setSegmentationRepresentationVisibility, getSegmentationRepresentationVisibility, setSegmentIndexVisibility, getSegmentIndexVisibility, getHiddenSegmentIndices, };

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

@@ -0,0 +1,25 @@
+import type SegmentationRepresentations from '../../../enums/SegmentationRepresentations';
+import type { ContourStyle } from '../../../types/ContourTypes';
+import type { LabelmapStyle } from '../../../types/LabelmapTypes';
+import type { SurfaceStyle } from '../../../types/SurfaceTypes';
+type BaseSpecifier = {
+    viewportId?: string;
+    segmentationId?: string;
+    segmentIndex?: number;
+};
+type SpecifierWithType<T extends SegmentationRepresentations> = BaseSpecifier & {
+    type: T;
+};
+type StyleForType<T extends SegmentationRepresentations> = T extends SegmentationRepresentations.Labelmap ? LabelmapStyle : T extends SegmentationRepresentations.Contour ? ContourStyle : T extends SegmentationRepresentations.Surface ? SurfaceStyle : never;
+declare function getStyle<T extends SegmentationRepresentations>(specifier: SpecifierWithType<T>): StyleForType<T>;
+declare function setStyle<T extends SegmentationRepresentations>(specifier: SpecifierWithType<T>, style: StyleForType<T>): void;
+declare function setRenderInactiveSegmentations(viewportId: string, renderInactiveSegmentations: boolean): void;
+declare function getRenderInactiveSegmentations(viewportId: string): boolean;
+declare function resetToGlobalStyle(): void;
+declare function hasCustomStyle(specifier: {
+    viewportId?: string;
+    segmentationId?: string;
+    type?: SegmentationRepresentations;
+    segmentIndex?: number;
+}): boolean;
+export { getStyle, setStyle, setRenderInactiveSegmentations, getRenderInactiveSegmentations, resetToGlobalStyle, hasCustomStyle, };

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

@@ -0,0 +1,37 @@
+import { getSegmentations } from '../getSegmentations';
+import { getViewportSegmentations } from '../getViewportSegmentations';
+import { triggerSegmentationRender } from '../SegmentationRenderingEngine';
+import { segmentationStyle } from '../SegmentationStyle';
+import { triggerSegmentationRepresentationModified } from '../triggerSegmentationEvents';
+function getStyle(specifier) {
+    return segmentationStyle.getStyle(specifier);
+}
+function setStyle(specifier, style) {
+    segmentationStyle.setStyle(specifier, style);
+    if (!specifier.viewportId && !specifier.segmentationId) {
+        const segmentations = getSegmentations();
+        segmentations.forEach((segmentation) => {
+            triggerSegmentationRender(segmentation.segmentationId);
+        });
+    }
+    triggerSegmentationRepresentationModified(specifier.viewportId, specifier.segmentationId, specifier.type);
+}
+function setRenderInactiveSegmentations(viewportId, renderInactiveSegmentations) {
+    segmentationStyle.setRenderInactiveSegmentations(viewportId, renderInactiveSegmentations);
+    triggerSegmentationRender(viewportId);
+    const segmentations = getViewportSegmentations(viewportId);
+    segmentations.forEach((segmentation) => {
+        triggerSegmentationRepresentationModified(viewportId, segmentation.segmentationId);
+    });
+}
+function getRenderInactiveSegmentations(viewportId) {
+    return segmentationStyle.getRenderInactiveSegmentations(viewportId);
+}
+function resetToGlobalStyle() {
+    segmentationStyle.resetToGlobalStyle();
+    triggerSegmentationRender();
+}
+function hasCustomStyle(specifier) {
+    return segmentationStyle.hasCustomStyle(specifier);
+}
+export { getStyle, setStyle, setRenderInactiveSegmentations, getRenderInactiveSegmentations, resetToGlobalStyle, hasCustomStyle, };

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationAdded.d.ts

@@ -0,0 +1 @@
+export declare function triggerSegmentationAdded(segmentationId: string): void;

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

@@ -0,0 +1,8 @@
+import { triggerEvent, eventTarget } from '@cornerstonejs/core';
+import { Events } from '../../../enums';
+export function triggerSegmentationAdded(segmentationId) {
+    const eventDetail = {
+        segmentationId,
+    };
+    triggerEvent(eventTarget, Events.SEGMENTATION_ADDED, eventDetail);
+}

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationDataModified.d.ts

@@ -0,0 +1 @@
+export declare function triggerSegmentationDataModified(segmentationId: string, modifiedSlicesToUse?: number[], segmentIndex?: number): void;

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

@@ -0,0 +1,12 @@
+import { triggerEvent, eventTarget } from '@cornerstonejs/core';
+import { Events } from '../../../enums';
+import { setSegmentationDirty } from '../../../utilities/segmentation/utilities';
+export function triggerSegmentationDataModified(segmentationId, modifiedSlicesToUse, segmentIndex) {
+    const eventDetail = {
+        segmentationId,
+        modifiedSlicesToUse,
+        segmentIndex,
+    };
+    setSegmentationDirty(segmentationId);
+    triggerEvent(eventTarget, Events.SEGMENTATION_DATA_MODIFIED, eventDetail);
+}

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationModified.d.ts

@@ -0,0 +1 @@
+export declare function triggerSegmentationModified(segmentationId: string): void;

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

@@ -0,0 +1,8 @@
+import { triggerEvent, eventTarget } from '@cornerstonejs/core';
+import { Events } from '../../../enums';
+export function triggerSegmentationModified(segmentationId) {
+    const eventDetail = {
+        segmentationId,
+    };
+    triggerEvent(eventTarget, Events.SEGMENTATION_MODIFIED, eventDetail);
+}

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationRemoved.d.ts

@@ -0,0 +1 @@
+export declare function triggerSegmentationRemoved(segmentationId: string): void;

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

@@ -0,0 +1,8 @@
+import { triggerEvent, eventTarget } from '@cornerstonejs/core';
+import { Events } from '../../../enums';
+export function triggerSegmentationRemoved(segmentationId) {
+    const eventDetail = {
+        segmentationId,
+    };
+    triggerEvent(eventTarget, Events.SEGMENTATION_REMOVED, eventDetail);
+}

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationRepresentationModified.d.ts

@@ -0,0 +1,2 @@
+import type { SegmentationRepresentations } from '../../../enums';
+export declare function triggerSegmentationRepresentationModified(viewportId: string, segmentationId: string, type?: SegmentationRepresentations): void;

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

@@ -0,0 +1,10 @@
+import { triggerEvent, eventTarget } from '@cornerstonejs/core';
+import { Events } from '../../../enums';
+export function triggerSegmentationRepresentationModified(viewportId, segmentationId, type) {
+    const eventDetail = {
+        segmentationId,
+        type,
+        viewportId,
+    };
+    triggerEvent(eventTarget, Events.SEGMENTATION_REPRESENTATION_MODIFIED, eventDetail);
+}

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationRepresentationRemoved.d.ts

@@ -0,0 +1,2 @@
+import type { SegmentationRepresentations } from '../../../enums';
+export declare function triggerSegmentationRepresentationRemoved(viewportId: string, segmentationId: string, type: SegmentationRepresentations): void;