@cornerstonejs/tools 2.0.0-beta.17 → 2.0.0-beta.18

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

@@ -1,25 +1,8 @@
-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 * as SegmentationState from './segmentationState';
+function getActiveRepresentation(viewportId) {
+    return SegmentationState.getActiveRepresentation(viewportId);
 }
-function getActiveSegmentation(toolGroupId) {
-    const activeRepresentation = getActiveSegmentationRepresentation(toolGroupId);
-    if (!activeRepresentation) {
-        return;
-    }
-    const activeSegmentation = getSegmentation(activeRepresentation.segmentationId);
-    return activeSegmentation;
+function setActiveRepresentation(viewportId, segmentationRepresentationUID, suppressEvent = false) {
+    SegmentationState.setActiveRepresentation(viewportId, segmentationRepresentationUID, suppressEvent);
 }
-function setActiveSegmentationRepresentation(toolGroupId, segmentationRepresentationUID) {
-    const segmentationStateManager = getDefaultSegmentationStateManager();
-    segmentationStateManager.setActiveSegmentationRepresentation(toolGroupId, segmentationRepresentationUID);
-    triggerSegmentationRepresentationModified(toolGroupId, segmentationRepresentationUID);
-}
-export { getActiveSegmentationRepresentation, getActiveSegmentation, setActiveSegmentationRepresentation, };
+export { getActiveRepresentation, setActiveRepresentation, };

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

@@ -0,0 +1,3 @@
+import { SegmentationRepresentationConfig, RepresentationPublicInput } from '../../types/SegmentationStateTypes';
+declare function addRepresentation(viewportId: string, representationInput: RepresentationPublicInput, initialConfig?: SegmentationRepresentationConfig): Promise<string>;
+export { addRepresentation };

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

@@ -0,0 +1,51 @@
+import { utilities } from '@cornerstonejs/core';
+import * as SegmentationState from './segmentationState';
+import { getRepresentationRenderingConfig } from './helpers/getRepresentationRenderingConfig';
+import CORNERSTONE_COLOR_LUT from '../../constants/COLOR_LUT';
+import { triggerAnnotationRenderForViewportIds } from '../../utilities';
+import { SegmentationRepresentations } from '../../enums';
+import { triggerSegmentationModified } from './triggerSegmentationEvents';
+async function addRepresentation(viewportId, representationInput, initialConfig) {
+    const { segmentationId, options = {} } = representationInput;
+    const segmentationRepresentationUID = representationInput.options?.segmentationRepresentationUID ||
+        utilities.uuidv4();
+    const colorLUTIndexToUse = getColorLUTIndex(options);
+    const representation = {
+        segmentationId,
+        segmentationRepresentationUID,
+        type: representationInput.type,
+        colorLUTIndex: colorLUTIndexToUse,
+        rendering: getRepresentationRenderingConfig(representationInput),
+        polySeg: options.polySeg,
+        config: {
+            allSegments: {},
+            perSegment: {},
+        },
+    };
+    SegmentationState.addRepresentationToViewport(viewportId, representation);
+    if (initialConfig) {
+        SegmentationState.setAllSegmentsConfig(segmentationRepresentationUID, initialConfig.representations);
+    }
+    if (representationInput.type === SegmentationRepresentations.Contour) {
+        triggerAnnotationRenderForViewportIds([viewportId]);
+    }
+    triggerSegmentationModified(segmentationId);
+    return segmentationRepresentationUID;
+}
+function getColorLUTIndex(options = {}) {
+    const colorLUTOrIndexInput = options.colorLUTOrIndex;
+    let colorLUTIndexToUse;
+    if (typeof colorLUTOrIndexInput === 'number') {
+        colorLUTIndexToUse = colorLUTOrIndexInput;
+    }
+    else {
+        const nextIndex = SegmentationState.getNextColorLUTIndex();
+        const colorLUTToAdd = Array.isArray(colorLUTOrIndexInput)
+            ? colorLUTOrIndexInput
+            : CORNERSTONE_COLOR_LUT;
+        SegmentationState.addColorLUT(colorLUTToAdd, nextIndex);
+        colorLUTIndexToUse = nextIndex;
+    }
+    return colorLUTIndexToUse;
+}
+export { addRepresentation };

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

@@ -0,0 +1,3 @@
+import { SegmentationRepresentationConfig, RepresentationPublicInput } from '../../types/SegmentationStateTypes';
+declare function addRepresentations(viewportId: string, representationInputArray: RepresentationPublicInput[], segmentationRepresentationConfig?: SegmentationRepresentationConfig): Promise<string[]>;
+export default addRepresentations;

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

@@ -0,0 +1,9 @@
+import { addRepresentation } from './addRepresentation';
+async function addRepresentations(viewportId, representationInputArray, segmentationRepresentationConfig) {
+    const promises = representationInputArray.map((representationInput) => {
+        return addRepresentation(viewportId, representationInput, segmentationRepresentationConfig);
+    });
+    const segmentationRepresentationUIDs = await Promise.all(promises);
+    return segmentationRepresentationUIDs;
+}
+export default addRepresentations;

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

@@ -1,4 +1,4 @@
 import * as color from './segmentationColor';
 import * as visibility from './segmentationVisibility';
-import { getGlobalConfig, getGlobalRepresentationConfig, getToolGroupSpecificConfig, setGlobalConfig, setGlobalRepresentationConfig, setToolGroupSpecificConfig, setSegmentSpecificConfig, getSegmentSpecificConfig, setSegmentationRepresentationSpecificConfig, getSegmentationRepresentationSpecificConfig } from './segmentationConfig';
-export { color, visibility, getGlobalConfig, getGlobalRepresentationConfig, getToolGroupSpecificConfig, setGlobalConfig, setGlobalRepresentationConfig, setToolGroupSpecificConfig, setSegmentSpecificConfig, getSegmentSpecificConfig, setSegmentationRepresentationSpecificConfig, getSegmentationRepresentationSpecificConfig, };
+import { getGlobalConfig, getGlobalRepresentationConfig, setGlobalConfig, setGlobalRepresentationConfig, getAllSegmentsConfig, getPerSegmentConfig, getSegmentIndexConfig, setAllSegmentsConfig, setPerSegmentConfig, setSegmentIndexConfig } from './segmentationConfig';
+export { color, visibility, getGlobalConfig, getGlobalRepresentationConfig, setGlobalConfig, setGlobalRepresentationConfig, getAllSegmentsConfig, getPerSegmentConfig, getSegmentIndexConfig, setAllSegmentsConfig, setPerSegmentConfig, setSegmentIndexConfig, };

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

@@ -1,4 +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, };
+import { getGlobalConfig, getGlobalRepresentationConfig, setGlobalConfig, setGlobalRepresentationConfig, getAllSegmentsConfig, getPerSegmentConfig, getSegmentIndexConfig, setAllSegmentsConfig, setPerSegmentConfig, setSegmentIndexConfig, } from './segmentationConfig';
+export { color, visibility, getGlobalConfig, getGlobalRepresentationConfig, setGlobalConfig, setGlobalRepresentationConfig, getAllSegmentsConfig, getPerSegmentConfig, getSegmentIndexConfig, setAllSegmentsConfig, setPerSegmentConfig, setSegmentIndexConfig, };

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

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

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

@@ -11,8 +11,8 @@ function addColorLUT(colorLUT, colorLUTIndex) {
     }
     SegmentationState.addColorLUT(colorLUT, colorLUTIndex);
 }
-function setColorLUT(toolGroupId, segmentationRepresentationUID, colorLUTIndex) {
-    const segRepresentation = SegmentationState.getSegmentationRepresentationByUID(toolGroupId, segmentationRepresentationUID);
+function setColorLUT(segmentationRepresentationUID, colorLUTIndex) {
+    const segRepresentation = SegmentationState.getRepresentation(segmentationRepresentationUID);
     if (!segRepresentation) {
         throw new Error(`setColorLUT: could not find segmentation representation with UID ${segmentationRepresentationUID}`);
     }
@@ -20,12 +20,12 @@ function setColorLUT(toolGroupId, segmentationRepresentationUID, colorLUTIndex)
         throw new Error(`setColorLUT: could not find colorLUT with index ${colorLUTIndex}`);
     }
     segRepresentation.colorLUTIndex = colorLUTIndex;
-    triggerSegmentationRepresentationModified(toolGroupId, segmentationRepresentationUID);
+    triggerSegmentationRepresentationModified(segmentationRepresentationUID);
 }
-function getColorForSegmentIndex(toolGroupId, segmentationRepresentationUID, segmentIndex) {
-    const segmentationRepresentation = SegmentationState.getSegmentationRepresentationByUID(toolGroupId, segmentationRepresentationUID);
+function getSegmentIndexColor(segmentationRepresentationUID, segmentIndex) {
+    const segmentationRepresentation = SegmentationState.getRepresentation(segmentationRepresentationUID);
     if (!segmentationRepresentation) {
-        throw new Error(`segmentation representation with UID ${segmentationRepresentationUID} does not exist for tool group ${toolGroupId}`);
+        throw new Error(`segmentation representation with UID ${segmentationRepresentationUID} does not exist`);
     }
     const { colorLUTIndex } = segmentationRepresentation;
     const colorLUT = SegmentationState.getColorLUT(colorLUTIndex);
@@ -38,11 +38,11 @@ function getColorForSegmentIndex(toolGroupId, segmentationRepresentationUID, seg
     }
     return colorValue;
 }
-function setColorForSegmentIndex(toolGroupId, segmentationRepresentationUID, segmentIndex, color) {
-    const colorReference = getColorForSegmentIndex(toolGroupId, segmentationRepresentationUID, segmentIndex);
+function setSegmentIndexColor(segmentationRepresentationUID, segmentIndex, color) {
+    const colorReference = getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
     for (let i = 0; i < color.length; i++) {
         colorReference[i] = color[i];
     }
-    triggerSegmentationRepresentationModified(toolGroupId, segmentationRepresentationUID);
+    triggerSegmentationRepresentationModified(segmentationRepresentationUID);
 }
-export { getColorForSegmentIndex, addColorLUT, setColorLUT, setColorForSegmentIndex, };
+export { getSegmentIndexColor, addColorLUT, setColorLUT, setSegmentIndexColor };

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

@@ -1,13 +1,13 @@
 import SegmentationRepresentations from '../../../enums/SegmentationRepresentations';
-import { RepresentationConfig, SegmentationRepresentationConfig, SegmentSpecificRepresentationConfig } from '../../../types/SegmentationStateTypes';
+import { RepresentationConfig, SegmentationRepresentationConfig, SegmentRepresentationConfig } from '../../../types/SegmentationStateTypes';
 declare function getGlobalConfig(): SegmentationRepresentationConfig;
 declare function setGlobalConfig(segmentationConfig: SegmentationRepresentationConfig): void;
 declare function getGlobalRepresentationConfig(representationType: SegmentationRepresentations): RepresentationConfig['LABELMAP'];
 declare function setGlobalRepresentationConfig(representationType: SegmentationRepresentations, config: RepresentationConfig['LABELMAP']): void;
-declare function getToolGroupSpecificConfig(toolGroupId: string): SegmentationRepresentationConfig;
-declare function setToolGroupSpecificConfig(toolGroupId: string, segmentationRepresentationConfig: SegmentationRepresentationConfig): void;
-declare function getSegmentationRepresentationSpecificConfig(toolGroupId: string, segmentationRepresentationUID: string): RepresentationConfig;
-declare function setSegmentationRepresentationSpecificConfig(toolGroupId: string, segmentationRepresentationUID: string, config: RepresentationConfig): void;
-declare function getSegmentSpecificConfig(toolGroupId: string, segmentationRepresentationUID: string, segmentIndex: number): RepresentationConfig;
-declare function setSegmentSpecificConfig(toolGroupId: string, segmentationRepresentationUID: string, config: SegmentSpecificRepresentationConfig): void;
-export { getGlobalConfig, setGlobalConfig, getGlobalRepresentationConfig, setGlobalRepresentationConfig, getToolGroupSpecificConfig, setToolGroupSpecificConfig, getSegmentationRepresentationSpecificConfig, setSegmentationRepresentationSpecificConfig, getSegmentSpecificConfig, setSegmentSpecificConfig, };
+declare function getAllSegmentsConfig(segmentationRepresentationUID: string): RepresentationConfig;
+declare function setAllSegmentsConfig(segmentationRepresentationUID: string, config: RepresentationConfig): void;
+declare function setPerSegmentConfig(segmentationRepresentationUID: string, config: SegmentRepresentationConfig): void;
+declare function getPerSegmentConfig(segmentationRepresentationUID: string): SegmentRepresentationConfig;
+declare function setSegmentIndexConfig(segmentationRepresentationUID: string, segmentIndex: number, config: RepresentationConfig, suppressEvent?: boolean): void;
+declare function getSegmentIndexConfig(segmentationRepresentationUID: string, segmentIndex: number): RepresentationConfig;
+export { getGlobalConfig, setGlobalConfig, getGlobalRepresentationConfig, setGlobalRepresentationConfig, getAllSegmentsConfig, setAllSegmentsConfig, setPerSegmentConfig, getPerSegmentConfig, setSegmentIndexConfig, getSegmentIndexConfig, };

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

@@ -1,4 +1,5 @@
 import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
+import { triggerSegmentationRepresentationModified } from '../triggerSegmentationEvents';
 function getGlobalConfig() {
     return SegmentationState.getGlobalConfig();
 }
@@ -22,22 +23,27 @@ function setGlobalRepresentationConfig(representationType, config) {
         },
     });
 }
-function getToolGroupSpecificConfig(toolGroupId) {
-    return SegmentationState.getToolGroupSpecificConfig(toolGroupId);
+function getAllSegmentsConfig(segmentationRepresentationUID) {
+    return SegmentationState.getAllSegmentsConfig(segmentationRepresentationUID);
 }
-function setToolGroupSpecificConfig(toolGroupId, segmentationRepresentationConfig) {
-    SegmentationState.setToolGroupSpecificConfig(toolGroupId, segmentationRepresentationConfig);
+function setAllSegmentsConfig(segmentationRepresentationUID, config) {
+    SegmentationState.setAllSegmentsConfig(segmentationRepresentationUID, config);
 }
-function getSegmentationRepresentationSpecificConfig(toolGroupId, segmentationRepresentationUID) {
-    return SegmentationState.getSegmentationRepresentationSpecificConfig(toolGroupId, segmentationRepresentationUID);
+function setPerSegmentConfig(segmentationRepresentationUID, config) {
+    SegmentationState.setPerSegmentConfig(segmentationRepresentationUID, config);
 }
-function setSegmentationRepresentationSpecificConfig(toolGroupId, segmentationRepresentationUID, config) {
-    SegmentationState.setSegmentationRepresentationSpecificConfig(toolGroupId, segmentationRepresentationUID, config);
+function getPerSegmentConfig(segmentationRepresentationUID) {
+    return SegmentationState.getPerSegmentConfig(segmentationRepresentationUID);
 }
-function getSegmentSpecificConfig(toolGroupId, segmentationRepresentationUID, segmentIndex) {
-    return SegmentationState.getSegmentSpecificRepresentationConfig(toolGroupId, segmentationRepresentationUID, segmentIndex);
+function setSegmentIndexConfig(segmentationRepresentationUID, segmentIndex, config, suppressEvent = false) {
+    const perSegment = SegmentationState.getPerSegmentConfig(segmentationRepresentationUID);
+    perSegment[segmentIndex] = config;
+    if (!suppressEvent) {
+        triggerSegmentationRepresentationModified(segmentationRepresentationUID);
+    }
 }
-function setSegmentSpecificConfig(toolGroupId, segmentationRepresentationUID, config) {
-    SegmentationState.setSegmentSpecificRepresentationConfig(toolGroupId, segmentationRepresentationUID, config);
+function getSegmentIndexConfig(segmentationRepresentationUID, segmentIndex) {
+    const perSegment = SegmentationState.getPerSegmentConfig(segmentationRepresentationUID);
+    return perSegment?.[segmentIndex];
 }
-export { getGlobalConfig, setGlobalConfig, getGlobalRepresentationConfig, setGlobalRepresentationConfig, getToolGroupSpecificConfig, setToolGroupSpecificConfig, getSegmentationRepresentationSpecificConfig, setSegmentationRepresentationSpecificConfig, getSegmentSpecificConfig, setSegmentSpecificConfig, };
+export { getGlobalConfig, setGlobalConfig, getGlobalRepresentationConfig, setGlobalRepresentationConfig, getAllSegmentsConfig, setAllSegmentsConfig, setPerSegmentConfig, getPerSegmentConfig, setSegmentIndexConfig, getSegmentIndexConfig, };

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

@@ -1,6 +1,7 @@
-declare function setSegmentationVisibility(toolGroupId: string, segmentationRepresentationUID: string, visibility: boolean): void;
-declare function getSegmentationVisibility(toolGroupId: string, segmentationRepresentationUID: string): boolean | undefined;
-declare function setSegmentsVisibility(toolGroupId: string, segmentationRepresentationUID: string, segmentIndices: number[], visibility: boolean): void;
-declare function setSegmentVisibility(toolGroupId: string, segmentationRepresentationUID: string, segmentIndex: number, visibility: boolean): void;
-declare function getSegmentVisibility(toolGroupId: string, segmentationRepresentationUID: string, segmentIndex: number): boolean;
-export { setSegmentationVisibility, getSegmentationVisibility, setSegmentVisibility, setSegmentsVisibility, getSegmentVisibility, };
+declare function setRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string, visibility: boolean): void;
+declare function getRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string): boolean | undefined;
+declare function setSegmentsVisibility(viewport: string, segmentationRepresentationUID: string, segmentIndices: number[], visibility: boolean): void;
+declare function setSegmentIndexVisibility(viewportId: string, segmentationRepresentationUID: string, segmentIndex: number, visibility: boolean): void;
+declare function getSegmentIndexVisibility(viewportId: string, segmentationRepresentationUID: string, segmentIndex: number): boolean;
+declare function getSegmentsHidden(viewportId: string, segmentationRepresentationUID: string): Set<number>;
+export { setRepresentationVisibility, getRepresentationVisibility, setSegmentsVisibility, setSegmentIndexVisibility, getSegmentIndexVisibility, getSegmentsHidden, };

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

@@ -1,69 +1,44 @@
 import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
-import { getSegmentationRepresentations } from '../../../stateManagement/segmentation/segmentationState';
-import { getUniqueSegmentIndices } from '../../../utilities/segmentation';
 import { triggerSegmentationRepresentationModified } from '../triggerSegmentationEvents';
-function setSegmentationVisibility(toolGroupId, segmentationRepresentationUID, visibility) {
-    const toolGroupSegmentationRepresentations = getSegmentationRepresentations(toolGroupId);
-    if (!toolGroupSegmentationRepresentations) {
-        return;
-    }
-    const representation = toolGroupSegmentationRepresentations.find((representation) => representation.segmentationRepresentationUID ===
-        segmentationRepresentationUID);
+function setRepresentationVisibility(viewportId, segmentationRepresentationUID, visibility) {
+    const representation = SegmentationState.getRepresentation(segmentationRepresentationUID);
+    debugger;
     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);
+    SegmentationState.setRepresentationVisibility(viewportId, segmentationRepresentationUID, visibility);
+    triggerSegmentationRepresentationModified(segmentationRepresentationUID);
 }
-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 getRepresentationVisibility(viewportId, segmentationRepresentationUID) {
+    return SegmentationState.getRepresentationVisibility(viewportId, segmentationRepresentationUID);
 }
-function setSegmentsVisibility(toolGroupId, segmentationRepresentationUID, segmentIndices, visibility) {
-    const segRepresentation = SegmentationState.getSegmentationRepresentationByUID(toolGroupId, segmentationRepresentationUID);
-    if (!segRepresentation) {
-        return;
-    }
+function setSegmentsVisibility(viewport, segmentationRepresentationUID, segmentIndices, visibility) {
+    const hiddenSegments = getSegmentsHidden(viewport, segmentationRepresentationUID);
     segmentIndices.forEach((segmentIndex) => {
         visibility
-            ? segRepresentation.segmentsHidden.delete(segmentIndex)
-            : segRepresentation.segmentsHidden.add(segmentIndex);
+            ? hiddenSegments.delete(segmentIndex)
+            : hiddenSegments.add(segmentIndex);
     });
-    triggerSegmentationRepresentationModified(toolGroupId, segmentationRepresentationUID);
+    triggerSegmentationRepresentationModified(segmentationRepresentationUID);
 }
-function setSegmentVisibility(toolGroupId, segmentationRepresentationUID, segmentIndex, visibility) {
-    const segRepresentation = SegmentationState.getSegmentationRepresentationByUID(toolGroupId, segmentationRepresentationUID);
-    if (!segRepresentation) {
-        return;
-    }
+function setSegmentIndexVisibility(viewportId, segmentationRepresentationUID, segmentIndex, visibility) {
+    const hiddenSegments = getSegmentsHidden(viewportId, segmentationRepresentationUID);
+    debugger;
     visibility
-        ? segRepresentation.segmentsHidden.delete(segmentIndex)
-        : segRepresentation.segmentsHidden.add(segmentIndex);
-    triggerSegmentationRepresentationModified(toolGroupId, segmentationRepresentationUID);
+        ? hiddenSegments.delete(segmentIndex)
+        : hiddenSegments.add(segmentIndex);
+    triggerSegmentationRepresentationModified(segmentationRepresentationUID);
+}
+function getSegmentIndexVisibility(viewportId, segmentationRepresentationUID, segmentIndex) {
+    const hiddenSegments = getSegmentsHidden(viewportId, segmentationRepresentationUID);
+    return !hiddenSegments.has(segmentIndex);
 }
-function getSegmentVisibility(toolGroupId, segmentationRepresentationUID, segmentIndex) {
-    const segRepresentation = SegmentationState.getSegmentationRepresentationByUID(toolGroupId, segmentationRepresentationUID);
-    if (!segRepresentation) {
-        return false;
+function getSegmentsHidden(viewportId, segmentationRepresentationUID) {
+    const viewportRenderingState = SegmentationState.getRepresentationsRenderingStateForViewport(viewportId);
+    if (!viewportRenderingState) {
+        return new Set();
     }
-    return !segRepresentation.segmentsHidden.has(segmentIndex);
+    return (viewportRenderingState[segmentationRepresentationUID]?.segmentsHidden ??
+        new Set());
 }
-export { setSegmentationVisibility, getSegmentationVisibility, setSegmentVisibility, setSegmentsVisibility, getSegmentVisibility, };
+export { setRepresentationVisibility, getRepresentationVisibility, setSegmentsVisibility, setSegmentIndexVisibility, getSegmentIndexVisibility, getSegmentsHidden, };

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

@@ -9,7 +9,7 @@ declare function computeVolumeSegmentationFromStack({ imageIdReferenceMap, optio
 declare function convertStackToVolumeSegmentation({ segmentationId, options, }: {
     segmentationId: string;
     options?: {
-        toolGroupId: string;
+        viewportId: string;
         volumeId?: string;
         removeOriginal?: boolean;
     };

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

@@ -1,6 +1,6 @@
 import { volumeLoader, utilities as csUtils, eventTarget, cache, } from '@cornerstonejs/core';
 import { Events, SegmentationRepresentations } from '../../enums';
-import addSegmentationRepresentations from './addSegmentationRepresentations';
+import addRepresentations from './addRepresentations';
 import { triggerSegmentationRender } from '../../utilities/segmentation';
 import { getSegmentation } from './segmentationState';
 import { triggerSegmentationDataModified } from './triggerSegmentationEvents';
@@ -25,12 +25,12 @@ async function convertStackToVolumeSegmentation({ segmentationId, options, }) {
     });
     await updateSegmentationState({
         segmentationId,
-        toolGroupId: options.toolGroupId,
+        viewportId: options.viewportId,
         options,
         volumeId,
     });
 }
-async function updateSegmentationState({ segmentationId, toolGroupId, volumeId, options, }) {
+async function updateSegmentationState({ segmentationId, viewportId, volumeId, options, }) {
     const segmentation = getSegmentation(segmentationId);
     if (options?.removeOriginal) {
         const data = segmentation.representationData
@@ -49,13 +49,13 @@ async function updateSegmentationState({ segmentationId, toolGroupId, volumeId,
             volumeId,
         };
     }
-    await addSegmentationRepresentations(toolGroupId, [
+    await addRepresentations(viewportId, [
         {
             segmentationId,
             type: SegmentationRepresentations.Labelmap,
         },
     ]);
-    triggerSegmentationRender(toolGroupId);
+    triggerSegmentationRender(viewportId);
     eventTarget.addEventListenerOnce(Events.SEGMENTATION_RENDERED, () => triggerSegmentationDataModified(segmentationId));
 }
 export { convertStackToVolumeSegmentation, computeVolumeSegmentationFromStack };

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

@@ -6,14 +6,14 @@ export declare function computeStackSegmentationFromVolume({ volumeId, }: {
 export declare function convertVolumeToStackSegmentation({ segmentationId, options, }: {
     segmentationId: string;
     options?: {
-        toolGroupId: string;
+        viewportId: string;
         newSegmentationId?: string;
         removeOriginal?: boolean;
     };
 }): Promise<void>;
-export declare function updateStackSegmentationState({ segmentationId, toolGroupId, imageIdReferenceMap, options, }: {
+export declare function updateStackSegmentationState({ segmentationId, viewportId, imageIdReferenceMap, options, }: {
     segmentationId: string;
-    toolGroupId: string;
+    viewportId: string;
     imageIdReferenceMap: Map<any, any>;
     options?: {
         removeOriginal?: boolean;

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

@@ -1,6 +1,6 @@
 import { cache, eventTarget, getRenderingEngines, } from '@cornerstonejs/core';
 import { Events, SegmentationRepresentations } from '../../enums';
-import addSegmentationRepresentations from './addSegmentationRepresentations';
+import addRepresentations from './addRepresentations';
 import { triggerSegmentationRender, createImageIdReferenceMap, } from '../../utilities/segmentation';
 import { getSegmentation } from './segmentationState';
 import { triggerSegmentationDataModified } from './triggerSegmentationEvents';
@@ -28,12 +28,12 @@ export async function convertVolumeToStackSegmentation({ segmentationId, options
     });
     await updateStackSegmentationState({
         segmentationId,
-        toolGroupId: options.toolGroupId,
+        viewportId: options.viewportId,
         imageIdReferenceMap,
         options,
     });
 }
-export async function updateStackSegmentationState({ segmentationId, toolGroupId, imageIdReferenceMap, options, }) {
+export async function updateStackSegmentationState({ segmentationId, viewportId, imageIdReferenceMap, options, }) {
     const segmentation = getSegmentation(segmentationId);
     if (options?.removeOriginal) {
         const data = segmentation.representationData
@@ -51,13 +51,13 @@ export async function updateStackSegmentationState({ segmentationId, toolGroupId
             imageIdReferenceMap,
         };
     }
-    await addSegmentationRepresentations(toolGroupId, [
+    await addRepresentations(viewportId, [
         {
             segmentationId,
             type: SegmentationRepresentations.Labelmap,
         },
     ]);
-    triggerSegmentationRender(toolGroupId);
+    triggerSegmentationRender();
     eventTarget.addEventListenerOnce(Events.SEGMENTATION_RENDERED, () => triggerSegmentationDataModified(segmentationId));
 }
 function _getImageIdReferenceMapForStackSegmentation(segmentationVolume) {

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

@@ -0,0 +1,2 @@
+import { RepresentationPublicInput } from '../../../types';
+export declare function getRepresentationRenderingConfig(representationInput: RepresentationPublicInput): {};

package/dist/esm/stateManagement/segmentation/helpers/{getRepresentationSpecificConfig.js → getRepresentationRenderingConfig.js}

@@ -1,6 +1,6 @@
 import SegmentationRepresentations from '../../../enums/SegmentationRepresentations';
 import { getRepresentationRenderingConfig as getLabelmapRenderingConfig } from '../../../tools/displayTools/Labelmap/labelmapDisplay';
-export function getRepresentationSpecificConfig(representationInput) {
+export function getRepresentationRenderingConfig(representationInput) {
     const { type } = representationInput;
     if (type === SegmentationRepresentations.Labelmap) {
         return getLabelmapRenderingConfig();

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

@@ -1,6 +1,6 @@
-import removeSegmentationsFromToolGroup from './removeSegmentationsFromToolGroup';
+import removeRepresentationsFromViewport from './removeRepresentationsFromViewport';
 import addSegmentations from './addSegmentations';
-import addSegmentationRepresentations from './addSegmentationRepresentations';
+import addRepresentations from './addRepresentations';
 import addRepresentationData from './addRepresentationData';
 import { convertStackToVolumeSegmentation } from './convertStackToVolumeSegmentation';
 import { convertVolumeToStackSegmentation } from './convertVolumeToStackSegmentation';
@@ -11,4 +11,4 @@ import * as config from './config';
 import * as segmentIndex from './segmentIndex';
 import * as triggerSegmentationEvents from './triggerSegmentationEvents';
 import * as polySegManager from './polySeg';
-export { addSegmentations, addSegmentationRepresentations, removeSegmentationsFromToolGroup, addRepresentationData, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, convertStackToVolumeSegmentation, convertVolumeToStackSegmentation, polySegManager as polySeg, };
+export { addSegmentations, addRepresentations, removeRepresentationsFromViewport, addRepresentationData, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, convertStackToVolumeSegmentation, convertVolumeToStackSegmentation, polySegManager as polySeg, };

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

@@ -1,6 +1,6 @@
-import removeSegmentationsFromToolGroup from './removeSegmentationsFromToolGroup';
+import removeRepresentationsFromViewport from './removeRepresentationsFromViewport';
 import addSegmentations from './addSegmentations';
-import addSegmentationRepresentations from './addSegmentationRepresentations';
+import addRepresentations from './addRepresentations';
 import addRepresentationData from './addRepresentationData';
 import { convertStackToVolumeSegmentation } from './convertStackToVolumeSegmentation';
 import { convertVolumeToStackSegmentation } from './convertVolumeToStackSegmentation';
@@ -11,4 +11,4 @@ import * as config from './config';
 import * as segmentIndex from './segmentIndex';
 import * as triggerSegmentationEvents from './triggerSegmentationEvents';
 import * as polySegManager from './polySeg';
-export { addSegmentations, addSegmentationRepresentations, removeSegmentationsFromToolGroup, addRepresentationData, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, convertStackToVolumeSegmentation, convertVolumeToStackSegmentation, polySegManager as polySeg, };
+export { addSegmentations, addRepresentations, removeRepresentationsFromViewport, addRepresentationData, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, convertStackToVolumeSegmentation, convertVolumeToStackSegmentation, polySegManager as polySeg, };

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

@@ -1,11 +1,10 @@
 import { cache } from '@cornerstonejs/core';
 import { getUniqueSegmentIndices } from '../../../../utilities/segmentation';
-import { getSegmentation, setSegmentationRepresentationSpecificConfig, } from '../../segmentationState';
+import { getSegmentation, setAllSegmentsConfig } from '../../segmentationState';
 import { computeSurfaceFromLabelmapSegmentation } from '../Surface/surfaceComputationStrategies';
 import { clipAndCacheSurfacesForViewport, } from '../../helpers/clipAndCacheSurfacesForViewport';
 import { extractContourData } from './utils/extractContourData';
 import { createAndAddContourSegmentationsFromClippedSurfaces } from './utils/createAndAddContourSegmentationsFromClippedSurfaces';
-import { getToolGroupForViewport } from '../../../../store/ToolGroupManager';
 export async function computeContourData(segmentationId, options = {}) {
     const segmentIndices = options.segmentIndices?.length
         ? options.segmentIndices
@@ -36,8 +35,7 @@ export async function computeContourData(segmentationId, options = {}) {
     }
     const { viewport, segmentationRepresentationUID } = options;
     const annotationUIDsMap = createAndAddContourSegmentationsFromClippedSurfaces(rawContourData, viewport, segmentationId);
-    const toolGroupId = getToolGroupForViewport(viewport.id)?.id;
-    setSegmentationRepresentationSpecificConfig(toolGroupId, segmentationRepresentationUID, {
+    setAllSegmentsConfig(segmentationRepresentationUID, {
         CONTOUR: {
             fillAlpha: 0,
         },

package/dist/esm/stateManagement/segmentation/polySeg/Surface/createAndCacheSurfacesFromRaw.js

@@ -1,11 +1,10 @@
 import { Enums, geometryLoader } from '@cornerstonejs/core';
-import { getColorForSegmentIndex } from '../../config/segmentationColor';
-import { findSegmentationRepresentationByUID, getSegmentation, } from '../../segmentationState';
+import { getSegmentIndexColor } from '../../config/segmentationColor';
+import { getRepresentation, getSegmentation } from '../../segmentationState';
 export async function createAndCacheSurfacesFromRaw(segmentationId, rawSurfacesData, options = {}) {
-    let segmentationRepresentation, toolGroupId;
+    let segmentationRepresentation;
     if (options.segmentationRepresentationUID) {
-        ({ segmentationRepresentation, toolGroupId } =
-            findSegmentationRepresentationByUID(options.segmentationRepresentationUID));
+        segmentationRepresentation = getRepresentation(options.segmentationRepresentationUID);
     }
     const segmentation = getSegmentation(segmentationId);
     const geometryIds = new Map();
@@ -13,7 +12,7 @@ export async function createAndCacheSurfacesFromRaw(segmentationId, rawSurfacesD
         const rawSurfaceData = rawSurfacesData[index];
         const segmentIndex = rawSurfaceData.segmentIndex;
         const color = segmentationRepresentation;
-        getColorForSegmentIndex(toolGroupId, segmentationRepresentation.segmentationRepresentationUID, segmentIndex).slice(0, 3);
+        getSegmentIndexColor(segmentationRepresentation.segmentationRepresentationUID, segmentIndex).slice(0, 3);
         if (!color) {
             throw new Error('No color found for segment index, unable to create surface');
         }

package/dist/esm/stateManagement/segmentation/polySeg/Surface/updateSurfaceData.js

@@ -1,6 +1,6 @@
 import { cache } from '@cornerstonejs/core';
 import { getUniqueSegmentIndices } from '../../../../utilities/segmentation';
-import { getSegmentation, getSegmentationRepresentations, getToolGroupIdsWithSegmentation, } from '../../segmentationState';
+import { getSegmentation, getRepresentationsForViewport, getViewportIdsWithSegmentationId, } from '../../segmentationState';
 import { triggerSegmentationModified } from '../../triggerSegmentationEvents';
 import { SegmentationRepresentations } from '../../../../enums';
 import { computeSurfaceFromLabelmapSegmentation } from './surfaceComputationStrategies';
@@ -27,9 +27,9 @@ export async function updateSurfaceData(segmentationId) {
         const geometryId = `segmentation_${segmentationId}_surface_${segmentIndex}`;
         const geometry = cache.getGeometry(geometryId);
         if (!geometry) {
-            const toolGroupIds = getToolGroupIdsWithSegmentation(segmentationId);
-            return toolGroupIds.map((toolGroupId) => {
-                const segmentationRepresentations = getSegmentationRepresentations(toolGroupId);
+            const viewportIds = getViewportIdsWithSegmentationId(segmentationId);
+            return viewportIds.map((viewportId) => {
+                const segmentationRepresentations = getRepresentationsForViewport(viewportId);
                 return segmentationRepresentations.map((segmentationRepresentation) => {
                     if (segmentationRepresentation.type !==
                         SegmentationRepresentations.Surface) {