@cornerstonejs/tools 2.0.0-beta.23 → 2.0.0-beta.25

package/dist/esm/enums/SegmentationRepresentations.d.ts

@@ -1,6 +1,6 @@
 declare enum SegmentationRepresentations {
-    Labelmap = "LABELMAP",
-    Contour = "CONTOUR",
-    Surface = "SURFACE"
+    Labelmap = "Labelmap",
+    Contour = "Contour",
+    Surface = "Surface"
 }
 export default SegmentationRepresentations;

package/dist/esm/enums/SegmentationRepresentations.js

@@ -1,7 +1,7 @@
 var SegmentationRepresentations;
 (function (SegmentationRepresentations) {
-    SegmentationRepresentations["Labelmap"] = "LABELMAP";
-    SegmentationRepresentations["Contour"] = "CONTOUR";
-    SegmentationRepresentations["Surface"] = "SURFACE";
+    SegmentationRepresentations["Labelmap"] = "Labelmap";
+    SegmentationRepresentations["Contour"] = "Contour";
+    SegmentationRepresentations["Surface"] = "Surface";
 })(SegmentationRepresentations || (SegmentationRepresentations = {}));
 export default SegmentationRepresentations;

package/dist/esm/eventDispatchers/mouseEventHandlers/mouseMove.js

@@ -3,6 +3,7 @@ import { ToolModes } from '../../enums';
 import filterToolsWithAnnotationsForElement from '../../store/filterToolsWithAnnotationsForElement';
 import getToolsWithModesForMouseEvent from '../shared/getToolsWithModesForMouseEvent';
 import triggerAnnotationRender from '../../utilities/triggerAnnotationRender';
+import { initElementCursor } from '../../cursors/elementCursor';
 const { Active, Passive } = ToolModes;
 export default function mouseMove(evt) {
     if (state.isInteractingWithTool || state.isMultiPartToolActive) {
@@ -34,4 +35,7 @@ export default function mouseMove(evt) {
     if (annotationsNeedToBeRedrawn === true) {
         triggerAnnotationRender(element);
     }
+    if (!state.isInteractingWithTool) {
+        initElementCursor(element, null);
+    }
 }

package/dist/esm/eventListeners/segmentation/labelmap/onLabelmapSegmentationDataModified.js

@@ -1,30 +1,34 @@
-import { cache, utilities as csUtils, VolumeViewport, getEnabledElementByViewportId, } from '@cornerstonejs/core';
+import { cache, utilities as csUtils, VolumeViewport, getEnabledElementByViewportId, StackViewport, } from '@cornerstonejs/core';
 import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
 const onLabelmapSegmentationDataModified = function (evt) {
     const { segmentationId, modifiedSlicesToUse } = evt.detail;
-    let modifiedSlices = modifiedSlicesToUse;
     const { representationData, type } = SegmentationState.getSegmentation(segmentationId);
-    const labelmapRepresentationData = representationData[type];
-    if ('stack' in labelmapRepresentationData &&
-        'volumeId' in labelmapRepresentationData) {
-        modifiedSlices = [];
-    }
-    if ('volumeId' in labelmapRepresentationData) {
-        performVolumeLabelmapUpdate({
-            modifiedSlicesToUse: modifiedSlices,
-            representationData,
-            type,
-        });
-    }
     const viewportIds = SegmentationState.getViewportIdsWithSegmentation(segmentationId);
-    if ('imageIds' in labelmapRepresentationData) {
-        performStackLabelmapUpdate({
-            viewportIds,
-            segmentationId,
-            representationData,
-            type,
-        });
-    }
+    const hasVolumeViewport = viewportIds.some((viewportId) => {
+        const { viewport } = getEnabledElementByViewportId(viewportId);
+        return viewport instanceof VolumeViewport;
+    });
+    const hasStackViewport = viewportIds.some((viewportId) => {
+        const { viewport } = getEnabledElementByViewportId(viewportId);
+        return viewport instanceof StackViewport;
+    });
+    const hasBothStackAndVolume = hasVolumeViewport && hasStackViewport;
+    viewportIds.forEach((viewportId) => {
+        const { viewport } = getEnabledElementByViewportId(viewportId);
+        if (viewport instanceof VolumeViewport) {
+            performVolumeLabelmapUpdate({
+                modifiedSlicesToUse: hasBothStackAndVolume ? [] : modifiedSlicesToUse,
+                representationData,
+                type,
+            });
+        }
+        if (viewport instanceof StackViewport) {
+            performStackLabelmapUpdate({
+                viewportIds,
+                segmentationId,
+            });
+        }
+    });
 };
 function performVolumeLabelmapUpdate({ modifiedSlicesToUse, representationData, type, }) {
     const segmentationVolume = cache.getVolume(representationData[type].volumeId);
@@ -46,7 +50,7 @@ function performVolumeLabelmapUpdate({ modifiedSlicesToUse, representationData,
     });
     imageData.modified();
 }
-function performStackLabelmapUpdate({ viewportIds, segmentationId, representationData, type, }) {
+function performStackLabelmapUpdate({ viewportIds, segmentationId }) {
     viewportIds.forEach((viewportId) => {
         const viewportSegReps = SegmentationState.getSegmentationRepresentations(viewportId);
         viewportSegReps.forEach((representation) => {

package/dist/esm/eventListeners/segmentation/segmentationDataModifiedEventListener.js

@@ -1,10 +1,10 @@
 import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
-import * as SegmentationState from '../../stateManagement/segmentation/segmentationState';
 import { triggerSegmentationRenderBySegmentationId } from '../../stateManagement/segmentation/SegmentationRenderingEngine';
 import onLabelmapSegmentationDataModified from './labelmap/onLabelmapSegmentationDataModified';
+import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
 const onSegmentationDataModified = function (evt) {
     const { segmentationId } = evt.detail;
-    const { type } = SegmentationState.getSegmentation(segmentationId);
+    const { type } = getSegmentation(segmentationId);
     if (type === SegmentationRepresentations.Labelmap) {
         onLabelmapSegmentationDataModified(evt);
     }

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

@@ -15,6 +15,7 @@ import { setAnnotationManager } from './annotation/annotationState';
 import { getAnnotationManager } from './annotation/annotationState';
 import { resetAnnotationManager } from './annotation/annotationState';
 import { invalidateAnnotation } from './annotation/annotationState';
-import addSegmentationRepresentations from './segmentation/addSegmentationRepresentations';
+import { addSegmentationRepresentations } from './segmentation/addSegmentationRepresentations';
+import { addMultiViewportSegmentationRepresentations } from './segmentation/addSegmentationRepresentations';
 import removeSegmentationRepresentations from './segmentation/removeSegmentationRepresentations';
-export { FrameOfReferenceSpecificAnnotationManager, defaultFrameOfReferenceSpecificAnnotationManager, annotationLocking, annotationSelection, getAnnotations, addAnnotation, getNumberOfAnnotations, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, addSegmentationRepresentations, removeSegmentationRepresentations };
+export { FrameOfReferenceSpecificAnnotationManager, defaultFrameOfReferenceSpecificAnnotationManager, annotationLocking, annotationSelection, getAnnotations, addAnnotation, getNumberOfAnnotations, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, addSegmentationRepresentations, addMultiViewportSegmentationRepresentations, removeSegmentationRepresentations };

package/dist/esm/stateManagement/index.js

@@ -2,6 +2,6 @@ import FrameOfReferenceSpecificAnnotationManager, { defaultFrameOfReferenceSpeci
 import * as annotationLocking from './annotation/annotationLocking';
 import * as annotationSelection from './annotation/annotationSelection';
 import { getAnnotations, addAnnotation, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, getNumberOfAnnotations, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, } from './annotation/annotationState';
-import addSegmentationRepresentations from './segmentation/addSegmentationRepresentations';
+import { addSegmentationRepresentations, addMultiViewportSegmentationRepresentations, } from './segmentation/addSegmentationRepresentations';
 import removeSegmentationRepresentations from './segmentation/removeSegmentationRepresentations';
-export { FrameOfReferenceSpecificAnnotationManager, defaultFrameOfReferenceSpecificAnnotationManager, annotationLocking, annotationSelection, getAnnotations, addAnnotation, getNumberOfAnnotations, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, addSegmentationRepresentations, removeSegmentationRepresentations, };
+export { FrameOfReferenceSpecificAnnotationManager, defaultFrameOfReferenceSpecificAnnotationManager, annotationLocking, annotationSelection, getAnnotations, addAnnotation, getNumberOfAnnotations, removeAnnotation, getAnnotation, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, setAnnotationManager, getAnnotationManager, resetAnnotationManager, invalidateAnnotation, addSegmentationRepresentations, addMultiViewportSegmentationRepresentations, removeSegmentationRepresentations, };

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

@@ -1,4 +1,3 @@
-import type { Types } from '@cornerstonejs/core';
 declare class SegmentationRenderingEngine {
     private _needsRender;
     private _animationFrameSet;
@@ -6,7 +5,7 @@ declare class SegmentationRenderingEngine {
     hasBeenDestroyed: boolean;
     renderSegmentationsForViewport(viewportId?: string): void;
     renderSegmentation(segmentationId: string): void;
-    _getAllViewports: () => Types.IViewport[];
+    _getAllViewports: () => import("@cornerstonejs/core").Viewport[];
     _getViewportIdsForSegmentation(segmentationId?: string): string[];
     private _throwIfDestroyed;
     private _setViewportsToBeRenderedNextFrame;

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

@@ -1,5 +1,5 @@
 import type { Types } from '@cornerstonejs/core';
-import type { RepresentationConfig, SegmentRepresentationConfig, Segmentation, SegmentationRepresentation, SegmentationRepresentationConfig, SegmentationState } from '../../types/SegmentationStateTypes';
+import type { GlobalConfig, RepresentationConfig, Segmentation, SegmentationRepresentation, SegmentationState } from '../../types/SegmentationStateTypes';
 export default class SegmentationStateManager {
     private state;
     readonly uid: string;
@@ -15,23 +15,26 @@ export default class SegmentationStateManager {
     getSegmentationRepresentation(segmentationRepresentationUID: string): SegmentationRepresentation | undefined;
     addSegmentationRepresentationState(segmentationRepresentation: SegmentationRepresentation): void;
     addSegmentationRepresentationToViewport(viewportId: string, segmentationRepresentationUID: string): void;
+    _updateLabelmapSegmentationReferences(segmentationId: any, stackViewport: any, labelmapImageIds: any, updateCallback: any): string;
     updateLabelmapSegmentationImageReferences(viewportId: any, segmentationId: any): string;
+    _updateAllLabelmapSegmentationImageReferences(viewportId: any, segmentationId: any): void;
     private getLabelmapImageIds;
     getCurrentLabelmapImageIdForViewport(viewportId: string, segmentationId: string): string | undefined;
+    getStackSegmentationImageIdsForViewport(viewportId: string, segmentationId: string): string[];
     getSegmentationRepresentations(viewportId: string): SegmentationRepresentation[];
     removeRepresentation(segmentationRepresentationUID: string): void;
     setActiveSegmentationRepresentation(viewportId: string, segmentationRepresentationUID: string): void;
     getActiveSegmentationRepresentation(viewportId: string): SegmentationRepresentation | undefined;
-    getGlobalConfig(): SegmentationRepresentationConfig;
-    setGlobalConfig(config: SegmentationRepresentationConfig): void;
+    getGlobalConfig(): GlobalConfig;
+    setGlobalConfig(config: GlobalConfig): void;
     _getRepresentationConfig(segmentationRepresentationUID: string): {
         allSegments?: RepresentationConfig;
-        perSegment?: SegmentRepresentationConfig;
+        perSegment?: RepresentationConfig;
     };
     getSegmentationRepresentationConfig(segmentationRepresentationUID: string): RepresentationConfig;
-    getPerSegmentConfig(segmentationRepresentationUID: string): SegmentRepresentationConfig;
+    getPerSegmentConfig(segmentationRepresentationUID: string): RepresentationConfig;
     setSegmentationRepresentationConfig(segmentationRepresentationUID: string, config: RepresentationConfig): void;
-    setPerSegmentConfig(segmentationRepresentationUID: string, config: SegmentRepresentationConfig): void;
+    setPerSegmentConfig(segmentationRepresentationUID: string, config: RepresentationConfig): void;
     getSegmentationRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string): boolean;
     setSegmentationRepresentationVisibility(viewportId: string, segmentationRepresentationUID: string, visible: boolean): void;
     addColorLUT(colorLUT: Types.ColorLUT, lutIndex: number): void;

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

@@ -47,12 +47,12 @@ export default class SegmentationStateManager {
         if (this.getSegmentation(segmentation.segmentationId)) {
             throw new Error(`Segmentation with id ${segmentation.segmentationId} already exists`);
         }
-        if (segmentation.representationData.LABELMAP &&
-            'volumeId' in segmentation.representationData.LABELMAP &&
-            !('imageIds' in segmentation.representationData.LABELMAP)) {
+        if (segmentation.representationData.Labelmap &&
+            'volumeId' in segmentation.representationData.Labelmap &&
+            !('imageIds' in segmentation.representationData.Labelmap)) {
             const imageIds = this.getLabelmapImageIds(segmentation.representationData);
             segmentation.representationData
-                .LABELMAP.imageIds = imageIds;
+                .Labelmap.imageIds = imageIds;
         }
         this.state.segmentations.push(segmentation);
     }
@@ -83,12 +83,12 @@ export default class SegmentationStateManager {
         const volumeViewport = enabledElement.viewport instanceof BaseVolumeViewport;
         const segmentation = this.getSegmentation(representation.segmentationId);
         const { representationData } = segmentation;
-        const isLabelmap = representationData.LABELMAP;
+        const isLabelmap = representationData.Labelmap;
         if (!isLabelmap) {
             this.setActiveSegmentationRepresentation(viewportId, segmentationRepresentationUID);
             return;
         }
-        const isBaseVolumeSegmentation = 'volumeId' in representationData.LABELMAP;
+        const isBaseVolumeSegmentation = 'volumeId' in representationData.Labelmap;
         if (!volumeViewport) {
             if (isBaseVolumeSegmentation) {
             }
@@ -111,6 +111,23 @@ export default class SegmentationStateManager {
         }
         this.setActiveSegmentationRepresentation(viewportId, segmentationRepresentationUID);
     }
+    _updateLabelmapSegmentationReferences(segmentationId, stackViewport, labelmapImageIds, updateCallback) {
+        const currentImageId = stackViewport.getCurrentImageId();
+        for (const labelmapImageId of labelmapImageIds) {
+            const viewableImageId = stackViewport.isReferenceViewable({ referencedImageId: labelmapImageId }, { asOverlay: true });
+            if (viewableImageId) {
+                this._stackLabelmapImageIdReferenceMap
+                    .get(segmentationId)
+                    .set(currentImageId, labelmapImageId);
+            }
+        }
+        if (updateCallback) {
+            updateCallback(stackViewport, segmentationId, labelmapImageIds);
+        }
+        return this._stackLabelmapImageIdReferenceMap
+            .get(segmentationId)
+            .get(currentImageId);
+    }
     updateLabelmapSegmentationImageReferences(viewportId, segmentationId) {
         const segmentation = this.getSegmentation(segmentationId);
         if (!segmentation) {
@@ -120,27 +137,45 @@ export default class SegmentationStateManager {
             this._stackLabelmapImageIdReferenceMap.set(segmentationId, new Map());
         }
         const { representationData } = segmentation;
-        if (!representationData.LABELMAP) {
+        if (!representationData.Labelmap) {
             return;
         }
         const labelmapImageIds = this.getLabelmapImageIds(representationData);
         const enabledElement = getEnabledElementByViewportId(viewportId);
         const stackViewport = enabledElement.viewport;
-        const currentImageId = stackViewport.getCurrentImageId();
-        for (const labelmapImageId of labelmapImageIds) {
-            const viewableImageId = stackViewport.isReferenceViewable({ referencedImageId: labelmapImageId }, { asOverlay: true });
-            if (viewableImageId) {
-                this._stackLabelmapImageIdReferenceMap
-                    .get(segmentationId)
-                    .set(currentImageId, labelmapImageId);
-            }
+        return this._updateLabelmapSegmentationReferences(segmentationId, stackViewport, labelmapImageIds, null);
+    }
+    _updateAllLabelmapSegmentationImageReferences(viewportId, segmentationId) {
+        const segmentation = this.getSegmentation(segmentationId);
+        if (!segmentation) {
+            return;
         }
-        return this._stackLabelmapImageIdReferenceMap
-            .get(segmentationId)
-            .get(currentImageId);
+        if (!this._stackLabelmapImageIdReferenceMap.has(segmentationId)) {
+            this._stackLabelmapImageIdReferenceMap.set(segmentationId, new Map());
+        }
+        const { representationData } = segmentation;
+        if (!representationData.Labelmap) {
+            return;
+        }
+        const labelmapImageIds = this.getLabelmapImageIds(representationData);
+        const enabledElement = getEnabledElementByViewportId(viewportId);
+        const stackViewport = enabledElement.viewport;
+        this._updateLabelmapSegmentationReferences(segmentationId, stackViewport, labelmapImageIds, (stackViewport, segmentationId, labelmapImageIds) => {
+            const imageIds = stackViewport.getImageIds();
+            imageIds.forEach((imageId, index) => {
+                for (const labelmapImageId of labelmapImageIds) {
+                    const viewableImageId = stackViewport.isReferenceViewable({ referencedImageId: labelmapImageId, sliceIndex: index }, { asOverlay: true, withNavigation: true });
+                    if (viewableImageId) {
+                        this._stackLabelmapImageIdReferenceMap
+                            .get(segmentationId)
+                            .set(imageId, labelmapImageId);
+                    }
+                }
+            });
+        });
     }
     getLabelmapImageIds(representationData) {
-        const labelmapData = representationData.LABELMAP;
+        const labelmapData = representationData.Labelmap;
         let labelmapImageIds;
         if (labelmapData.imageIds) {
             labelmapImageIds = labelmapData
@@ -168,6 +203,19 @@ export default class SegmentationStateManager {
         const imageIdReferenceMap = this._stackLabelmapImageIdReferenceMap.get(segmentationId);
         return imageIdReferenceMap.get(currentImageId);
     }
+    getStackSegmentationImageIdsForViewport(viewportId, segmentationId) {
+        const segmentation = this.getSegmentation(segmentationId);
+        if (!segmentation) {
+            return [];
+        }
+        this._updateAllLabelmapSegmentationImageReferences(viewportId, segmentationId);
+        const { viewport } = getEnabledElementByViewportId(viewportId);
+        const imageIds = viewport.getImageIds();
+        const associatedReferenceImageAndLabelmapImageIds = this._stackLabelmapImageIdReferenceMap.get(segmentationId);
+        return imageIds.map((imageId) => {
+            return associatedReferenceImageAndLabelmapImageIds.get(imageId);
+        });
+    }
     getSegmentationRepresentations(viewportId) {
         const viewport = this.state.viewports[viewportId];
         if (!viewport) {
@@ -286,7 +334,7 @@ async function computeVolumeSegmentationFromStack({ imageIds, options, }) {
 async function convertStackToVolumeSegmentation({ segmentationId, options, }) {
     const segmentation = defaultSegmentationStateManager.getSegmentation(segmentationId);
     const data = segmentation.representationData
-        .LABELMAP;
+        .Labelmap;
     const { volumeId } = await computeVolumeSegmentationFromStack({
         imageIds: data.imageIds,
         options,
@@ -302,18 +350,18 @@ async function updateSegmentationState({ segmentationId, viewportId, volumeId, o
     const segmentation = defaultSegmentationStateManager.getSegmentation(segmentationId);
     if (options?.removeOriginal) {
         const data = segmentation.representationData
-            .LABELMAP;
+            .Labelmap;
         const { imageIds } = data;
         imageIds.forEach((imageId) => {
             cache.removeImageLoadObject(imageId);
         });
-        segmentation.representationData.LABELMAP = {
+        segmentation.representationData.Labelmap = {
             volumeId,
         };
     }
     else {
-        segmentation.representationData.LABELMAP = {
-            ...segmentation.representationData.LABELMAP,
+        segmentation.representationData.Labelmap = {
+            ...segmentation.representationData.Labelmap,
             volumeId,
         };
     }

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

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

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

@@ -1,9 +1,19 @@
-import { addSegmentationRepresentation } from './addSegmentationRepresentation';
-async function addSegmentationRepresentations(viewportId, representationInputArray, segmentationRepresentationConfig) {
+import { internalAddSegmentationRepresentation } from './internalAddSegmentationRepresentation';
+async function addSegmentationRepresentations(viewportId, representationInputArray) {
     const promises = representationInputArray.map((representationInput) => {
-        return addSegmentationRepresentation(viewportId, representationInput, segmentationRepresentationConfig);
+        return internalAddSegmentationRepresentation(viewportId, representationInput);
     });
     const segmentationRepresentationUIDs = await Promise.all(promises);
     return segmentationRepresentationUIDs;
 }
-export default addSegmentationRepresentations;
+async function addMultiViewportSegmentationRepresentations(viewportInputMap) {
+    const results = {};
+    for (const [viewportId, inputArray] of Object.entries(viewportInputMap)) {
+        const promises = inputArray.map((representationInput) => {
+            return internalAddSegmentationRepresentation(viewportId, representationInput);
+        });
+        results[viewportId] = await Promise.all(promises);
+    }
+    return results;
+}
+export { addSegmentationRepresentations, addMultiViewportSegmentationRepresentations, };

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

@@ -1,13 +1,14 @@
 import type SegmentationRepresentations from '../../../enums/SegmentationRepresentations';
-import type { 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;
+import type { GlobalConfig, RepresentationConfig } from '../../../types/SegmentationStateTypes';
+import type { LabelmapConfig } from '../../../types/LabelmapTypes';
+declare function getGlobalConfig(): GlobalConfig;
+declare function setGlobalConfig(segmentationConfig: GlobalConfig): void;
+declare function getGlobalRepresentationConfig(representationType: SegmentationRepresentations): LabelmapConfig;
+declare function setGlobalRepresentationConfig(representationType: SegmentationRepresentations, config: LabelmapConfig): void;
 declare function getSegmentationRepresentationConfig(segmentationRepresentationUID: string): RepresentationConfig;
 declare function setSegmentationRepresentationConfig(segmentationRepresentationUID: string, config: RepresentationConfig): void;
-declare function setPerSegmentConfig(segmentationRepresentationUID: string, config: SegmentRepresentationConfig): void;
-declare function getPerSegmentConfig(segmentationRepresentationUID: string): SegmentRepresentationConfig;
+declare function setPerSegmentConfig(segmentationRepresentationUID: string, config: RepresentationConfig): void;
+declare function getPerSegmentConfig(segmentationRepresentationUID: string): RepresentationConfig;
 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, getSegmentationRepresentationConfig, setSegmentationRepresentationConfig, setPerSegmentConfig, getPerSegmentConfig, setSegmentIndexConfig, getSegmentIndexConfig, };

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

@@ -8,7 +8,7 @@ export async function computeStackSegmentationFromVolume({ volumeId, }) {
 export async function convertVolumeToStackSegmentation({ segmentationId, options, }) {
     const segmentation = getSegmentation(segmentationId);
     const { volumeId } = segmentation.representationData
-        .LABELMAP;
+        .Labelmap;
     const segmentationVolume = cache.getVolume(volumeId);
     await updateStackSegmentationState({
         segmentationId,

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

@@ -1,2 +1,2 @@
-import type { SegmentationRepresentationConfig } from '../../types';
-export declare function getGlobalConfig(): SegmentationRepresentationConfig;
+import type { GlobalConfig } from '../../types';
+export declare function getGlobalConfig(): GlobalConfig;

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

@@ -1,2 +1,2 @@
-import type { SegmentRepresentationConfig } from '../../types/SegmentationStateTypes';
-export declare function getPerSegmentConfig(segmentationRepresentationUID: string): SegmentRepresentationConfig;
+import type { RepresentationConfig } from '../../types/SegmentationStateTypes';
+export declare function getPerSegmentConfig(segmentationRepresentationUID: string): RepresentationConfig;

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

@@ -0,0 +1 @@
+export declare function getStackSegmentationImageIdsForViewport(viewportId: string, segmentationId: string): string[];

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

@@ -0,0 +1,5 @@
+import { defaultSegmentationStateManager } from './SegmentationStateManager';
+export function getStackSegmentationImageIdsForViewport(viewportId, segmentationId) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    return segmentationStateManager.getStackSegmentationImageIdsForViewport(viewportId, segmentationId);
+}

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

@@ -2,22 +2,22 @@ import { cache, eventTarget } from '@cornerstonejs/core';
 import { Events, SegmentationRepresentations } from '../../../enums';
 import { getSegmentation } from '../getSegmentation';
 import { triggerSegmentationDataModified } from '../triggerSegmentationEvents';
-import addSegmentationRepresentations from '../addSegmentationRepresentations';
+import { addSegmentationRepresentations } from '../addSegmentationRepresentations';
 export async function updateStackSegmentationState({ segmentationId, viewportId, imageIds, options, }) {
     const segmentation = getSegmentation(segmentationId);
     if (options?.removeOriginal) {
         const data = segmentation.representationData
-            .LABELMAP;
+            .Labelmap;
         if (cache.getVolume(data.volumeId)) {
             cache.removeVolumeLoadObject(data.volumeId);
         }
-        segmentation.representationData.LABELMAP = {
+        segmentation.representationData.Labelmap = {
             imageIds,
         };
     }
     else {
-        segmentation.representationData.LABELMAP = {
-            ...segmentation.representationData.LABELMAP,
+        segmentation.representationData.Labelmap = {
+            ...segmentation.representationData.Labelmap,
             imageIds,
         };
     }

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

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

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

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

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

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

package/dist/esm/stateManagement/segmentation/{addSegmentationRepresentation.js → internalAddSegmentationRepresentation.js}

@@ -18,7 +18,7 @@ function getLabelmapSegmentationRepresentationRenderingConfig() {
         cfun,
     };
 }
-async function addSegmentationRepresentation(viewportId, representationInput, initialConfig) {
+async function internalAddSegmentationRepresentation(viewportId, representationInput) {
     const { segmentationId, options = {} } = representationInput;
     const segmentationRepresentationUID = representationInput.options?.segmentationRepresentationUID ||
         utilities.uuidv4();
@@ -44,8 +44,9 @@ async function addSegmentationRepresentation(viewportId, representationInput, in
         },
     };
     addSegmentationRepresentationState(viewportId, representation);
+    const initialConfig = representationInput.config;
     if (initialConfig) {
-        setSegmentationRepresentationConfig(segmentationRepresentationUID, initialConfig.representations);
+        setSegmentationRepresentationConfig(segmentationRepresentationUID, initialConfig);
     }
     if (representationInput.type === SegmentationRepresentations.Contour) {
         triggerAnnotationRenderForViewportIds([viewportId]);
@@ -69,4 +70,4 @@ function getColorLUTIndex(options = {}) {
     }
     return colorLUTIndexToUse;
 }
-export { addSegmentationRepresentation };
+export { internalAddSegmentationRepresentation };

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

@@ -14,13 +14,13 @@ export async function computeContourData(segmentationId, options = {}) {
     const segmentation = getSegmentation(segmentationId);
     const representationData = segmentation.representationData;
     try {
-        if (representationData.SURFACE) {
+        if (representationData.Surface) {
             rawContourData = await computeContourFromSurfaceSegmentation(segmentationId, {
                 segmentIndices,
                 ...options,
             });
         }
-        else if (representationData.LABELMAP) {
+        else if (representationData.Labelmap) {
             rawContourData = await computeContourFromLabelmapSegmentation(segmentationId, {
                 segmentIndices,
                 ...options,
@@ -37,7 +37,7 @@ export async function computeContourData(segmentationId, options = {}) {
     const { viewport, segmentationRepresentationUID } = options;
     const annotationUIDsMap = createAndAddContourSegmentationsFromClippedSurfaces(rawContourData, viewport, segmentationId);
     setSegmentationRepresentationConfig(segmentationRepresentationUID, {
-        CONTOUR: {
+        Contour: {
             fillAlpha: 0,
         },
     });
@@ -78,7 +78,7 @@ async function computeContourFromSurfaceSegmentation(segmentationId, options = {
     const segmentIndexToSurfaceId = new Map();
     const surfaceIdToSegmentIndex = new Map();
     const segmentation = getSegmentation(segmentationId);
-    const representationData = segmentation.representationData.SURFACE;
+    const representationData = segmentation.representationData.Surface;
     const surfacesInfo = [];
     representationData.geometryIds.forEach((geometryId, segmentIndex) => {
         if (segmentIndices.includes(segmentIndex)) {

package/dist/esm/stateManagement/segmentation/polySeg/Labelmap/labelmapComputationStrategies.js

@@ -12,13 +12,13 @@ export async function computeLabelmapData(segmentationId, options = {}) {
     const segmentation = getSegmentation(segmentationId);
     const representationData = segmentation.representationData;
     try {
-        if (representationData.CONTOUR) {
+        if (representationData.Contour) {
             rawLabelmapData = await computeLabelmapFromContourSegmentation(segmentationId, {
                 segmentIndices,
                 ...options,
             });
         }
-        else if (representationData.SURFACE) {
+        else if (representationData.Surface) {
             rawLabelmapData = await computeLabelmapFromSurfaceSegmentation(segmentation.segmentationId, {
                 segmentIndices,
                 ...options,
@@ -43,7 +43,7 @@ async function computeLabelmapFromContourSegmentation(segmentationId, options =
         ? options.segmentIndices
         : getUniqueSegmentIndices(segmentationId);
     const segmentation = getSegmentation(segmentationId);
-    const representationData = segmentation.representationData.CONTOUR;
+    const representationData = segmentation.representationData.Contour;
     const convertFunction = isVolume
         ? convertContourToVolumeLabelmap
         : convertContourToStackLabelmap;
@@ -62,7 +62,7 @@ async function computeLabelmapFromSurfaceSegmentation(segmentationId, options =
         : getUniqueSegmentIndices(segmentationId);
     const segmentation = getSegmentation(segmentationId);
     const segmentsGeometryIds = new Map();
-    const representationData = segmentation.representationData.SURFACE;
+    const representationData = segmentation.representationData.Surface;
     representationData.geometryIds.forEach((geometryId, segmentIndex) => {
         if (segmentIndices.includes(segmentIndex)) {
             segmentsGeometryIds.set(segmentIndex, geometryId);