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

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

@@ -1,7 +1,7 @@
 import { addColorLUT as _addColorLUT } from '../addColorLUT';
 import { getColorLUT as _getColorLUT } from '../getColorLUT';
 import { getSegmentationRepresentations } from '../getSegmentationRepresentation';
-import { triggerSegmentationModified } from '../triggerSegmentationEvents';
+import { triggerSegmentationRepresentationModified } from '../triggerSegmentationEvents';
 function addColorLUT(colorLUT, colorLUTIndex) {
     if (!colorLUT) {
         throw new Error('addColorLUT: colorLUT is required');
@@ -17,9 +17,9 @@ function setColorLUT(viewportId, segmentationId, colorLUTsIndex) {
         throw new Error(`viewport specific state for viewport ${viewportId} does not exist`);
     }
     segmentationRepresentations.forEach((segmentationRepresentation) => {
-        segmentationRepresentation.config.colorLUTIndex = colorLUTsIndex;
+        segmentationRepresentation.colorLUTIndex = colorLUTsIndex;
     });
-    triggerSegmentationModified(segmentationId);
+    triggerSegmentationRepresentationModified(viewportId, segmentationId);
 }
 function getSegmentIndexColor(viewportId, segmentationId, segmentIndex) {
     const representations = getSegmentationRepresentations(viewportId, {
@@ -29,7 +29,7 @@ function getSegmentIndexColor(viewportId, segmentationId, segmentIndex) {
         throw new Error(`segmentation representation with segmentationId ${segmentationId} does not exist`);
     }
     const representation = representations[0];
-    const { colorLUTIndex } = representation.config;
+    const { colorLUTIndex } = representation;
     const colorLUT = _getColorLUT(colorLUTIndex);
     let colorValue = colorLUT[segmentIndex];
     if (!colorValue) {
@@ -45,6 +45,6 @@ function setSegmentIndexColor(viewportId, segmentationId, segmentIndex, color) {
     for (let i = 0; i < color.length; i++) {
         colorReference[i] = color[i];
     }
-    triggerSegmentationModified(segmentationId);
+    triggerSegmentationRepresentationModified(viewportId, segmentationId);
 }
 export { getSegmentIndexColor, addColorLUT, setColorLUT, setSegmentIndexColor };

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

@@ -1,7 +1,8 @@
 import { getSegmentationRepresentation, getSegmentationRepresentations, } from '../getSegmentationRepresentation';
 import { setSegmentationRepresentationVisibility as _setSegmentationRepresentationVisibility } from '../setSegmentationRepresentationVisibility';
 import { getSegmentationRepresentationVisibility as _getSegmentationRepresentationVisibility } from '../getSegmentationRepresentationVisibility';
-import { triggerSegmentationModified } from '../triggerSegmentationEvents';
+import { triggerSegmentationRenderBySegmentationId } from '../SegmentationRenderingEngine';
+import { triggerSegmentationRepresentationModified } from '../triggerSegmentationEvents';
 function setSegmentationRepresentationVisibility(viewportId, specifier, visibility) {
     const representations = getSegmentationRepresentations(viewportId, specifier);
     if (!representations) {
@@ -13,7 +14,6 @@ function setSegmentationRepresentationVisibility(viewportId, specifier, visibili
             type: representation.type,
         }, visibility);
     });
-    triggerSegmentationModified(specifier.segmentationId);
 }
 function getSegmentationRepresentationVisibility(viewportId, specifier) {
     return _getSegmentationRepresentationVisibility(viewportId, specifier);
@@ -24,12 +24,10 @@ function setSegmentIndexVisibility(viewportId, specifier, segmentIndex, visibili
         return;
     }
     representations.forEach((representation) => {
-        const hiddenSegments = representation.segmentsHidden ?? new Set();
-        visibility
-            ? hiddenSegments.delete(segmentIndex)
-            : hiddenSegments.add(segmentIndex);
+        representation.segments[segmentIndex].visible = visibility;
     });
-    triggerSegmentationModified(specifier.segmentationId);
+    triggerSegmentationRenderBySegmentationId(specifier.segmentationId);
+    triggerSegmentationRepresentationModified(viewportId, specifier.segmentationId);
 }
 function getSegmentIndexVisibility(viewportId, specifier, segmentIndex) {
     const hiddenSegments = getHiddenSegmentIndices(viewportId, specifier);
@@ -40,6 +38,12 @@ function getHiddenSegmentIndices(viewportId, specifier) {
     if (!representation) {
         return new Set();
     }
-    return representation.segmentsHidden ?? 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

@@ -1,39 +1,25 @@
-import SegmentationRepresentations from '../../../enums/SegmentationRepresentations';
+import type 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: {
+type BaseSpecifier = {
     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;
+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;
-}, style: RepresentationStyle): void;
-declare function setViewportRenderInactiveSegmentations(viewportId: string, renderInactiveSegmentations: boolean): void;
-export { getStyle, getGlobalStyle, setGlobalStyle, setGlobalLabelmapStyle, setGlobalContourStyle, setGlobalSurfaceStyle, setSegmentationSpecificStyle, setLabelmapStyle, setViewportSpecificStyleForType, setViewportSpecificStyleForSegmentation, setViewportRenderInactiveSegmentations, };
+}): boolean;
+export { getStyle, setStyle, setRenderInactiveSegmentations, getRenderInactiveSegmentations, resetToGlobalStyle, hasCustomStyle, };

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

@@ -1,48 +1,25 @@
-import SegmentationRepresentations from '../../../enums/SegmentationRepresentations';
 import { triggerSegmentationRender } from '../SegmentationRenderingEngine';
 import { segmentationStyle } from '../SegmentationStyle';
+import { triggerSegmentationRepresentationModified } from '../triggerSegmentationEvents';
 function getStyle(specifier) {
     return segmentationStyle.getStyle(specifier);
 }
-function getGlobalStyle(type) {
-    return segmentationStyle.getGlobalStyle(type);
+function setStyle(specifier, style) {
+    segmentationStyle.setStyle(specifier, style);
+    triggerSegmentationRepresentationModified(specifier.viewportId, specifier.segmentationId, specifier.type);
 }
-function setGlobalStyle(type, style) {
-    segmentationStyle.setGlobalStyle(type, style);
-    triggerSegmentationRender();
-}
-function setGlobalLabelmapStyle(style) {
-    segmentationStyle.setGlobalLabelmapStyle(style);
-    triggerSegmentationRender();
+function setRenderInactiveSegmentations(viewportId, renderInactiveSegmentations) {
+    segmentationStyle.setRenderInactiveSegmentations(viewportId, renderInactiveSegmentations);
+    triggerSegmentationRender(viewportId);
 }
-function setGlobalContourStyle(style) {
-    segmentationStyle.setGlobalContourStyle(style);
-    triggerSegmentationRender();
+function getRenderInactiveSegmentations(viewportId) {
+    return segmentationStyle.getRenderInactiveSegmentations(viewportId);
 }
-function setGlobalSurfaceStyle(style) {
-    segmentationStyle.setGlobalSurfaceStyle(style);
+function resetToGlobalStyle() {
+    segmentationStyle.resetToGlobalStyle();
     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);
+function hasCustomStyle(specifier) {
+    return segmentationStyle.hasCustomStyle(specifier);
 }
-export { getStyle, getGlobalStyle, setGlobalStyle, setGlobalLabelmapStyle, setGlobalContourStyle, setGlobalSurfaceStyle, setSegmentationSpecificStyle, setLabelmapStyle, setViewportSpecificStyleForType, setViewportSpecificStyleForSegmentation, setViewportRenderInactiveSegmentations, };
+export { getStyle, setStyle, setRenderInactiveSegmentations, getRenderInactiveSegmentations, resetToGlobalStyle, hasCustomStyle, };

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

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

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

@@ -1,18 +1,8 @@
 import { triggerEvent, eventTarget } from '@cornerstonejs/core';
 import { Events } from '../../../enums';
-import { getSegmentations } from '../getSegmentations';
 export function triggerSegmentationModified(segmentationId) {
-    let segmentationIds;
-    if (segmentationId) {
-        segmentationIds = [segmentationId];
-    }
-    else {
-        segmentationIds = getSegmentations().map(({ segmentationId }) => segmentationId);
-    }
-    segmentationIds.forEach((segmentationId) => {
-        const eventDetail = {
-            segmentationId,
-        };
-        triggerEvent(eventTarget, Events.SEGMENTATION_MODIFIED, eventDetail);
-    });
+    const eventDetail = {
+        segmentationId,
+    };
+    triggerEvent(eventTarget, Events.SEGMENTATION_MODIFIED, 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;

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

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

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

@@ -2,6 +2,8 @@ import { getSegmentation } from './getSegmentation';
 export function getActiveSegmentIndex(segmentationId) {
     const segmentation = getSegmentation(segmentationId);
     if (segmentation) {
-        return segmentation.activeSegmentIndex;
+        const activeSegmentIndex = Object.keys(segmentation.segments).find((segmentIndex) => segmentation.segments[segmentIndex].active);
+        return activeSegmentIndex ? Number(activeSegmentIndex) : undefined;
     }
+    return undefined;
 }

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

@@ -1,4 +1,4 @@
 import { segmentationStyle } from './SegmentationStyle';
 export function getGlobalStyle(type) {
-    return segmentationStyle.getGlobalStyle(type);
+    return segmentationStyle.getStyle({ type });
 }

package/dist/esm/stateManagement/segmentation/helpers/clearSegmentValue.js

@@ -1,5 +1,4 @@
 import { cache } from '@cornerstonejs/core';
-import { SegmentationRepresentations } from '../../../enums';
 import { getSegmentation } from '../getSegmentation';
 import { triggerSegmentationDataModified } from '../triggerSegmentationEvents';
 export function clearSegmentValue(segmentationId, segmentIndex) {

package/dist/esm/stateManagement/segmentation/helpers/internalGetHiddenSegmentIndices.d.ts

@@ -0,0 +1,5 @@
+import type { SegmentationRepresentations } from '../../../enums';
+export declare function internalGetHiddenSegmentIndices(viewportId: any, specifier: {
+    segmentationId: string;
+    type: SegmentationRepresentations;
+}): Set<unknown>;

package/dist/esm/stateManagement/segmentation/helpers/internalGetHiddenSegmentIndices.js

@@ -0,0 +1,14 @@
+import { getSegmentationRepresentation } from '../getSegmentationRepresentation';
+export function internalGetHiddenSegmentIndices(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;
+}

package/dist/esm/stateManagement/segmentation/helpers/normalizeSegmentationInput.js

@@ -1,6 +1,6 @@
 import { SegmentationRepresentations } from '../../../enums';
 function normalizeSegmentationInput(segmentationInput) {
-    const { segmentationId, representation } = segmentationInput;
+    const { segmentationId, representation, config } = segmentationInput;
     const { type, data: inputData } = representation;
     const data = inputData ? { ...inputData } : {};
     if (!data) {
@@ -11,13 +11,20 @@ function normalizeSegmentationInput(segmentationInput) {
         contourData.geometryIds = contourData.geometryIds ?? [];
         contourData.annotationUIDsMap = contourData.annotationUIDsMap ?? new Map();
     }
+    const normalizedSegments = {};
+    Object.entries(config.segments).forEach(([segmentIndex, segment]) => {
+        normalizedSegments[segmentIndex] = {
+            segmentIndex: Number(segmentIndex),
+            label: segment.label ?? `Segment ${segmentIndex}`,
+            locked: segment.locked ?? false,
+            cachedStats: segment.cachedStats ?? {},
+            active: segment.active ?? false,
+        };
+    });
     return {
         segmentationId,
-        cachedStats: {},
-        segmentLabels: {},
-        label: null,
-        segmentsLocked: new Set(),
-        activeSegmentIndex: 1,
+        label: config.label ?? null,
+        segments: normalizedSegments,
         representationData: {
             [type]: {
                 ...data,

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

@@ -1,6 +1,7 @@
 import { removeContourRepresentation, removeLabelmapRepresentation, removeSegmentationRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentations, removeAllSegmentationRepresentations } from './removeSegmentationRepresentations';
 import { addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations } from './addSegmentationRepresentationsToViewport';
 import { addSegmentations } from './addSegmentations';
+import { updateSegmentations } from './updateSegmentations';
 import * as activeSegmentation from './activeSegmentation';
 import * as segmentLocking from './segmentLocking';
 import * as state from './segmentationState';
@@ -12,10 +13,11 @@ import { computeVolumeLabelmapFromStack } from './helpers/computeVolumeLabelmapF
 import * as polySegManager from './polySeg';
 import { clearSegmentValue } from './helpers/clearSegmentValue';
 import { convertVolumeToStackLabelmap } from './helpers/computeStackLabelmapFromVolume';
+import { removeSegment } from './removeSegment';
 declare const helpers: {
     clearSegmentValue: typeof clearSegmentValue;
     convertStackToVolumeLabelmap: typeof convertStackToVolumeLabelmap;
     computeVolumeLabelmapFromStack: typeof computeVolumeLabelmapFromStack;
     convertVolumeToStackLabelmap: typeof convertVolumeToStackLabelmap;
 };
-export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, helpers, polySegManager as polySeg, };
+export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, updateSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, helpers, polySegManager as polySeg, removeSegment, };

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

@@ -1,6 +1,7 @@
 import { removeContourRepresentation, removeLabelmapRepresentation, removeSegmentationRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentations, removeAllSegmentationRepresentations, } from './removeSegmentationRepresentations';
 import { addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, } from './addSegmentationRepresentationsToViewport';
 import { addSegmentations } from './addSegmentations';
+import { updateSegmentations } from './updateSegmentations';
 import * as activeSegmentation from './activeSegmentation';
 import * as segmentLocking from './segmentLocking';
 import * as state from './segmentationState';
@@ -12,10 +13,11 @@ import { computeVolumeLabelmapFromStack } from './helpers/computeVolumeLabelmapF
 import * as polySegManager from './polySeg';
 import { clearSegmentValue } from './helpers/clearSegmentValue';
 import { convertVolumeToStackLabelmap } from './helpers/computeStackLabelmapFromVolume';
+import { removeSegment } from './removeSegment';
 const helpers = {
     clearSegmentValue,
     convertStackToVolumeLabelmap,
     computeVolumeLabelmapFromStack,
     convertVolumeToStackLabelmap,
 };
-export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, helpers, polySegManager as polySeg, };
+export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, updateSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, helpers, polySegManager as polySeg, removeSegment, };

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

@@ -18,15 +18,16 @@ function internalAddSegmentationRepresentation(viewportId, representationInput)
     triggerSegmentationModified(segmentationId);
 }
 function getColorLUTIndex(config) {
-    const colorLUT = config?.colorLUT;
-    const nextIndex = getNextColorLUTIndex();
-    const colorLUTToAdd = Array.isArray(colorLUT)
-        ? colorLUT
+    const { colorLUTOrIndex } = config || {};
+    const isIndexProvided = typeof colorLUTOrIndex === 'number';
+    const selectedColorLUT = isIndexProvided
+        ? getColorLUT(colorLUTOrIndex)
         : CORNERSTONE_COLOR_LUT;
-    addColorLUT(colorLUTToAdd, nextIndex);
-    const colorLUTIndex = nextIndex;
-    if (!getColorLUT(colorLUTIndex)) {
-        throw new Error(`Color LUT with index ${colorLUTIndex} not found`);
+    const colorLUTIndex = isIndexProvided
+        ? colorLUTOrIndex
+        : getNextColorLUTIndex();
+    if (!isIndexProvided) {
+        addColorLUT(selectedColorLUT, colorLUTIndex);
     }
     return colorLUTIndex;
 }

package/dist/esm/stateManagement/segmentation/polySeg/Contour/contourComputationStrategies.js

@@ -37,7 +37,7 @@ export async function computeContourData(segmentationId, options = {}) {
     }
     const { viewport } = options;
     const annotationUIDsMap = createAndAddContourSegmentationsFromClippedSurfaces(rawContourData, viewport, segmentationId);
-    segmentationStyle.setSegmentationSpecificStyle({ segmentationId, type: SegmentationRepresentations.Contour }, {
+    segmentationStyle.setStyle({ segmentationId, type: SegmentationRepresentations.Contour }, {
         fillAlpha: 0,
     });
     return {

package/dist/esm/stateManagement/segmentation/polySeg/computeAndAddRepresentation.js

@@ -4,7 +4,6 @@ import addRepresentationData from '../internalAddRepresentationData';
 import { triggerSegmentationModified } from '../triggerSegmentationEvents';
 import debounce from '../../../utilities/debounce';
 import { registerPolySegWorker } from './registerPolySegWorker';
-import { defaultSegmentationStateManager } from '../SegmentationStateManager';
 const computedRepresentations = new Map();
 async function computeAndAddRepresentation(segmentationId, type, computeFunction, updateFunction, onComputationComplete) {
     registerPolySegWorker();

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

@@ -0,0 +1,3 @@
+export declare function removeSegment(segmentationId: string, segmentIndex: number, options?: {
+    setNextSegmentAsActive: boolean;
+}): void;

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

@@ -0,0 +1,50 @@
+import { getActiveSegmentIndex } from './getActiveSegmentIndex';
+import { getSegmentation } from './getSegmentation';
+import { getSegmentationRepresentations } from './getSegmentationRepresentation';
+import { getViewportIdsWithSegmentation } from './getViewportIdsWithSegmentation';
+import { clearSegmentValue } from './helpers/clearSegmentValue';
+import { setActiveSegmentIndex } from './segmentIndex';
+import { updateSegmentations } from './updateSegmentations';
+export function removeSegment(segmentationId, segmentIndex, options = {
+    setNextSegmentAsActive: true,
+}) {
+    clearSegmentValue(segmentationId, segmentIndex);
+    const isThisSegmentActive = getActiveSegmentIndex(segmentationId) === segmentIndex;
+    const segmentation = getSegmentation(segmentationId);
+    const { segments } = segmentation;
+    delete segments[segmentIndex];
+    const updatedSegments = {
+        ...segments,
+    };
+    updateSegmentations([
+        {
+            segmentationId,
+            payload: {
+                segments: updatedSegments,
+            },
+        },
+    ]);
+    if (isThisSegmentActive && options.setNextSegmentAsActive) {
+        const segmentIndices = Object.keys(segments)
+            .map(Number)
+            .sort((a, b) => a - b);
+        const currentIndex = segmentIndices.indexOf(segmentIndex);
+        const nextSegmentIndex = segmentIndices[currentIndex + 1];
+        const previousSegmentIndex = segmentIndices[currentIndex - 1];
+        if (nextSegmentIndex !== undefined) {
+            setActiveSegmentIndex(segmentationId, nextSegmentIndex);
+        }
+        else if (previousSegmentIndex !== undefined) {
+            setActiveSegmentIndex(segmentationId, previousSegmentIndex);
+        }
+    }
+    const viewportIds = getViewportIdsWithSegmentation(segmentationId);
+    viewportIds.forEach((viewportId) => {
+        const representations = getSegmentationRepresentations(viewportId, {
+            segmentationId,
+        });
+        representations.forEach((representation) => {
+            delete representation.segments[segmentIndex];
+        });
+    });
+}

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

@@ -4,7 +4,7 @@ declare function removeSegmentationRepresentation(viewportId: string, specifier:
     type: SegmentationRepresentations;
 }, immediate?: boolean): void;
 declare function removeSegmentationRepresentations(viewportId: string, specifier: {
-    segmentationId: string;
+    segmentationId?: string;
     type?: SegmentationRepresentations;
 }, immediate?: boolean): void;
 declare function removeAllSegmentationRepresentations(): void;

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

@@ -14,11 +14,11 @@ function removeSegmentationRepresentation(viewportId, specifier, immediate) {
 }
 function removeSegmentationRepresentations(viewportId, specifier, immediate) {
     const { segmentationId, type } = specifier;
+    _removeRepresentation(viewportId, segmentationId, type, immediate);
     defaultSegmentationStateManager.removeSegmentationRepresentations(viewportId, {
         segmentationId,
         type,
     });
-    _removeRepresentation(viewportId, segmentationId, type, immediate);
 }
 function removeAllSegmentationRepresentations() {
     const state = defaultSegmentationStateManager.getAllViewportSegmentationRepresentations();
@@ -56,19 +56,17 @@ function _removeRepresentation(viewportId, segmentationId, type, immediate) {
         type,
     });
     representations.forEach((representation) => {
-        if (representation.type === type) {
-            if (type === SegmentationRepresentations.Labelmap) {
-                labelmapDisplay.removeRepresentation(viewportId, segmentationId, immediate);
-            }
-            else if (type === SegmentationRepresentations.Contour) {
-                contourDisplay.removeRepresentation(viewportId, segmentationId, immediate);
-            }
-            else {
-                throw new Error(`The representation ${type} is not supported yet`);
-            }
+        if (representation.type === SegmentationRepresentations.Labelmap) {
+            labelmapDisplay.removeRepresentation(viewportId, segmentationId, immediate);
+        }
+        else if (representation.type === SegmentationRepresentations.Contour) {
+            contourDisplay.removeRepresentation(viewportId, segmentationId, immediate);
+        }
+        else {
+            throw new Error(`The representation ${representation.type} is not supported yet`);
         }
     });
-    const { viewport } = getEnabledElementByViewportId(viewportId);
+    const { viewport } = getEnabledElementByViewportId(viewportId) || {};
     if (viewport) {
         viewport.render();
     }

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

@@ -4,17 +4,33 @@ import { getSegmentation } from './getSegmentation';
 import { getViewportIdsWithSegmentation } from './getViewportIdsWithSegmentation';
 import { triggerSegmentationModified } from './triggerSegmentationEvents';
 import { getActiveSegmentIndex } from './getActiveSegmentIndex';
+import { getSegmentationRepresentations } from './getSegmentationRepresentation';
 function setActiveSegmentIndex(segmentationId, segmentIndex) {
     const segmentation = getSegmentation(segmentationId);
     if (typeof segmentIndex === 'string') {
         console.warn('segmentIndex is a string, converting to number');
         segmentIndex = Number(segmentIndex);
     }
-    if (segmentation?.activeSegmentIndex !== segmentIndex) {
-        segmentation.activeSegmentIndex = segmentIndex;
+    Object.values(segmentation.segments).forEach((segment) => {
+        segment.active = false;
+    });
+    if (segmentation.segments[segmentIndex].active !== true) {
+        segmentation.segments[segmentIndex].active = true;
         triggerSegmentationModified(segmentationId);
     }
     const viewportIds = getViewportIdsWithSegmentation(segmentationId);
+    viewportIds.forEach((viewportId) => {
+        const representations = getSegmentationRepresentations(viewportId, {
+            segmentationId,
+        });
+        representations.forEach((representation) => {
+            if (!representation.segments[segmentIndex]) {
+                representation.segments[segmentIndex] = {
+                    visible: true,
+                };
+            }
+        });
+    });
     viewportIds.forEach((viewportId) => {
         const toolGroup = getToolGroupForViewport(viewportId);
         invalidateBrushCursor(toolGroup.id);

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

@@ -5,21 +5,16 @@ function isSegmentIndexLocked(segmentationId, segmentIndex) {
     if (!segmentation) {
         throw new Error(`No segmentation state found for ${segmentationId}`);
     }
-    const { segmentsLocked } = segmentation;
-    return segmentsLocked.has(segmentIndex);
+    const { segments } = segmentation;
+    return segments[segmentIndex].locked;
 }
 function setSegmentIndexLocked(segmentationId, segmentIndex, locked = true) {
     const segmentation = getSegmentation(segmentationId);
     if (!segmentation) {
         throw new Error(`No segmentation state found for ${segmentationId}`);
     }
-    const { segmentsLocked } = segmentation;
-    if (locked) {
-        segmentsLocked.add(segmentIndex);
-    }
-    else {
-        segmentsLocked.delete(segmentIndex);
-    }
+    const { segments } = segmentation;
+    segments[segmentIndex].locked = locked;
     triggerSegmentationModified(segmentationId);
 }
 function getLockedSegmentIndices(segmentationId) {
@@ -27,7 +22,8 @@ function getLockedSegmentIndices(segmentationId) {
     if (!segmentation) {
         throw new Error(`No segmentation state found for ${segmentationId}`);
     }
-    const { segmentsLocked } = segmentation;
-    return Array.from(segmentsLocked);
+    const { segments } = segmentation;
+    const lockedSegmentIndices = Object.keys(segments).filter((segmentIndex) => segments[segmentIndex].locked);
+    return lockedSegmentIndices.map((segmentIndex) => parseInt(segmentIndex));
 }
 export { isSegmentIndexLocked, setSegmentIndexLocked, getLockedSegmentIndices };