@cornerstonejs/tools 2.0.0-beta.24 → 2.0.0-beta.26

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/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/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;
@@ -25,16 +25,16 @@ export default class SegmentationStateManager {
     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) {
             }
@@ -137,7 +137,7 @@ 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);
@@ -154,7 +154,7 @@ 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);
@@ -175,7 +175,7 @@ export default class SegmentationStateManager {
         });
     }
     getLabelmapImageIds(representationData) {
-        const labelmapData = representationData.LABELMAP;
+        const labelmapData = representationData.Labelmap;
         let labelmapImageIds;
         if (labelmapData.imageIds) {
             labelmapImageIds = labelmapData
@@ -334,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,
@@ -350,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/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);

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

@@ -29,7 +29,7 @@ export async function createAndCacheSurfacesFromRaw(segmentationId, rawSurfacesD
         const geometryId = closedSurface.id;
         geometryIds.set(segmentIndex, geometryId);
         return geometryLoader.createAndCacheGeometry(geometryId, {
-            type: Enums.GeometryType.SURFACE,
+            type: Enums.GeometryType.Surface,
             geometryData: closedSurface,
         });
     });

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

@@ -12,13 +12,13 @@ export async function computeSurfaceData(segmentationId, options = {}) {
     const segmentation = getSegmentation(segmentationId);
     const representationData = segmentation.representationData;
     try {
-        if (representationData.CONTOUR) {
+        if (representationData.Contour) {
             rawSurfacesData = await computeSurfaceFromContourSegmentation(segmentationId, {
                 segmentIndices,
                 ...options,
             });
         }
-        else if (representationData.LABELMAP) {
+        else if (representationData.Labelmap) {
             rawSurfacesData = await computeSurfaceFromLabelmapSegmentation(segmentation.segmentationId, {
                 segmentIndices,
                 ...options,
@@ -37,12 +37,12 @@ export async function computeSurfaceData(segmentationId, options = {}) {
 }
 async function computeSurfaceFromLabelmapSegmentation(segmentationId, options = {}) {
     const segmentation = getSegmentation(segmentationId);
-    if (!segmentation?.representationData?.LABELMAP) {
+    if (!segmentation?.representationData?.Labelmap) {
         console.warn('Only support surface update from labelmaps');
         return;
     }
-    const isVolume = isVolumeSegmentation(segmentation.representationData.LABELMAP);
-    const labelmapRepresentationData = segmentation.representationData.LABELMAP;
+    const isVolume = isVolumeSegmentation(segmentation.representationData.Labelmap);
+    const labelmapRepresentationData = segmentation.representationData.Labelmap;
     const segmentIndices = options.segmentIndices || getUniqueSegmentIndices(segmentationId);
     const promises = segmentIndices.map((index) => {
         const surface = convertLabelmapToSurface(labelmapRepresentationData, index, isVolume);
@@ -65,7 +65,7 @@ async function computeSurfaceFromLabelmapSegmentation(segmentationId, options =
 }
 async function computeSurfaceFromContourSegmentation(segmentationId, options = {}) {
     const segmentation = getSegmentation(segmentationId);
-    const contourRepresentationData = segmentation.representationData.CONTOUR;
+    const contourRepresentationData = segmentation.representationData.Contour;
     const segmentIndices = options.segmentIndices || getUniqueSegmentIndices(segmentationId);
     const promises = segmentIndices.map(async (index) => {
         const surface = await convertContourToSurface(contourRepresentationData, index);

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

@@ -13,7 +13,7 @@ export async function updateSurfaceData(segmentationId) {
     const segmentation = getSegmentation(segmentationId);
     const indices = getUniqueSegmentIndices(segmentationId);
     if (!indices.length) {
-        const geometryIds = segmentation.representationData.SURFACE.geometryIds;
+        const geometryIds = segmentation.representationData.Surface.geometryIds;
         geometryIds.forEach((geometryId) => {
             const geometry = cache.getGeometry(geometryId);
             const surface = geometry.data;
@@ -35,7 +35,7 @@ export async function updateSurfaceData(segmentationId) {
                         SegmentationRepresentations.Surface) {
                         return;
                     }
-                    segmentation.representationData.SURFACE.geometryIds.set(segmentIndex, geometryId);
+                    segmentation.representationData.Surface.geometryIds.set(segmentIndex, geometryId);
                     return createAndCacheSurfacesFromRaw(segmentationId, [{ segmentIndex, data }], {
                         segmentationRepresentationUID: segmentationRepresentation.segmentationRepresentationUID,
                     });

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

@@ -12,7 +12,6 @@ import { setSegmentationRepresentationConfig } from './setSegmentationRepresenta
 import { getPerSegmentConfig } from './getPerSegmentConfig';
 import { setPerSegmentConfig } from './setPerSegmentConfig';
 import { getSegmentationRepresentations } from './getSegmentationRepresentations';
-import { addSegmentationRepresentation } from './addSegmentationRepresentation';
 import { getSegmentationRepresentationViewportStates } from './getSegmentationRepresentationViewportStates';
 import { addColorLUT } from './addColorLUT';
 import { getColorLUT } from './getColorLUT';
@@ -27,4 +26,4 @@ import { setActiveSegmentationRepresentation } from './setActiveSegmentationRepr
 import { getCurrentLabelmapImageIdForViewport } from './getCurrentLabelmapImageIdForViewport';
 import { updateLabelmapSegmentationImageReferences } from './updateLabelmapSegmentationImageReferences';
 import { getStackSegmentationImageIdsForViewport } from './getStackSegmentationImageIdsForViewport';
-export { getSegmentation, getSegmentations, addSegmentation, removeSegmentation, getAllSegmentationRepresentations, getSegmentationRepresentation, removeRepresentation, getGlobalConfig, setGlobalConfig, getSegmentationRepresentationConfig, setSegmentationRepresentationConfig, getPerSegmentConfig, setPerSegmentConfig, getSegmentationRepresentations, addSegmentationRepresentation, getSegmentationRepresentationViewportStates, addColorLUT, getColorLUT, getNextColorLUTIndex, removeColorLUT, getSegmentationRepresentationsForSegmentation, getSegmentationRepresentationVisibility, setSegmentationRepresentationVisibility, getViewportIdsWithSegmentation, getActiveSegmentationRepresentation, setActiveSegmentationRepresentation, getCurrentLabelmapImageIdForViewport, updateLabelmapSegmentationImageReferences, getStackSegmentationImageIdsForViewport, };
+export { getSegmentation, getSegmentations, addSegmentation, removeSegmentation, getAllSegmentationRepresentations, getSegmentationRepresentation, removeRepresentation, getGlobalConfig, setGlobalConfig, getSegmentationRepresentationConfig, setSegmentationRepresentationConfig, getPerSegmentConfig, setPerSegmentConfig, getSegmentationRepresentations, getSegmentationRepresentationViewportStates, addColorLUT, getColorLUT, getNextColorLUTIndex, removeColorLUT, getSegmentationRepresentationsForSegmentation, getSegmentationRepresentationVisibility, setSegmentationRepresentationVisibility, getViewportIdsWithSegmentation, getActiveSegmentationRepresentation, setActiveSegmentationRepresentation, getCurrentLabelmapImageIdForViewport, updateLabelmapSegmentationImageReferences, getStackSegmentationImageIdsForViewport, };

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

@@ -12,7 +12,6 @@ import { setSegmentationRepresentationConfig } from './setSegmentationRepresenta
 import { getPerSegmentConfig } from './getPerSegmentConfig';
 import { setPerSegmentConfig } from './setPerSegmentConfig';
 import { getSegmentationRepresentations } from './getSegmentationRepresentations';
-import { addSegmentationRepresentation } from './addSegmentationRepresentation';
 import { getSegmentationRepresentationViewportStates } from './getSegmentationRepresentationViewportStates';
 import { addColorLUT } from './addColorLUT';
 import { getColorLUT } from './getColorLUT';
@@ -27,4 +26,4 @@ import { setActiveSegmentationRepresentation } from './setActiveSegmentationRepr
 import { getCurrentLabelmapImageIdForViewport } from './getCurrentLabelmapImageIdForViewport';
 import { updateLabelmapSegmentationImageReferences } from './updateLabelmapSegmentationImageReferences';
 import { getStackSegmentationImageIdsForViewport } from './getStackSegmentationImageIdsForViewport';
-export { getSegmentation, getSegmentations, addSegmentation, removeSegmentation, getAllSegmentationRepresentations, getSegmentationRepresentation, removeRepresentation, getGlobalConfig, setGlobalConfig, getSegmentationRepresentationConfig, setSegmentationRepresentationConfig, getPerSegmentConfig, setPerSegmentConfig, getSegmentationRepresentations, addSegmentationRepresentation, getSegmentationRepresentationViewportStates, addColorLUT, getColorLUT, getNextColorLUTIndex, removeColorLUT, getSegmentationRepresentationsForSegmentation, getSegmentationRepresentationVisibility, setSegmentationRepresentationVisibility, getViewportIdsWithSegmentation, getActiveSegmentationRepresentation, setActiveSegmentationRepresentation, getCurrentLabelmapImageIdForViewport, updateLabelmapSegmentationImageReferences, getStackSegmentationImageIdsForViewport, };
+export { getSegmentation, getSegmentations, addSegmentation, removeSegmentation, getAllSegmentationRepresentations, getSegmentationRepresentation, removeRepresentation, getGlobalConfig, setGlobalConfig, getSegmentationRepresentationConfig, setSegmentationRepresentationConfig, getPerSegmentConfig, setPerSegmentConfig, getSegmentationRepresentations, getSegmentationRepresentationViewportStates, addColorLUT, getColorLUT, getNextColorLUTIndex, removeColorLUT, getSegmentationRepresentationsForSegmentation, getSegmentationRepresentationVisibility, setSegmentationRepresentationVisibility, getViewportIdsWithSegmentation, getActiveSegmentationRepresentation, setActiveSegmentationRepresentation, getCurrentLabelmapImageIdForViewport, updateLabelmapSegmentationImageReferences, getStackSegmentationImageIdsForViewport, };

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

@@ -1,2 +1,2 @@
-import type { SegmentationRepresentationConfig } from '../../types';
-export declare function setGlobalConfig(config: SegmentationRepresentationConfig, suppressEvents?: boolean): void;
+import type { GlobalConfig } from '../../types';
+export declare function setGlobalConfig(config: GlobalConfig, suppressEvents?: boolean): void;

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

@@ -1,2 +1,2 @@
-import type { SegmentRepresentationConfig } from '../../types/SegmentationStateTypes';
-export declare function setPerSegmentConfig(segmentationRepresentationUID: string, config: SegmentRepresentationConfig, suppressEvents?: boolean): void;
+import type { RepresentationConfig } from '../../types';
+export declare function setPerSegmentConfig(segmentationRepresentationUID: string, config: RepresentationConfig, suppressEvents?: boolean): void;

package/dist/esm/store/ToolGroupManager/ToolGroup.d.ts

@@ -2,7 +2,7 @@ import { MouseBindings, ToolModes } from '../../enums';
 import type { Types } from '@cornerstonejs/core';
 import type { IToolBinding, IToolGroup, SetToolBindingsType, ToolOptionsType, ToolConfiguration } from '../../types';
 import { MouseCursor } from '../../cursors';
-export default class ToolGroup implements IToolGroup {
+export default class ToolGroup {
     id: string;
     viewportsInfo: any[];
     toolOptions: {};

package/dist/esm/tools/AdvancedMagnifyTool.js

@@ -562,7 +562,7 @@ class AdvancedMagnifyViewportManager {
             const { viewportId: sourceViewportId } = evt.detail;
             this._reset(sourceViewportId);
         };
-        element.addEventListener(csEvents.STACK_VIEWPORT_NEW_STACK, newStackHandler);
+        element.addEventListener(csEvents.VIEWPORT_NEW_IMAGE_SET, newStackHandler);
         const newVolumeHandler = (evt) => {
             const { viewportId: sourceViewportId } = evt.detail;
             this._reset(sourceViewportId);
@@ -575,7 +575,7 @@ class AdvancedMagnifyViewportManager {
     _removeSourceElementEventListener(element) {
         element.removeEventListener(csEvents.STACK_NEW_IMAGE, this._newStackImageCallback);
         element.removeEventListener(csEvents.VOLUME_NEW_IMAGE, this._newVolumeImageCallback);
-        element.removeEventListener(csEvents.STACK_VIEWPORT_NEW_STACK, element.newStackHandler);
+        element.removeEventListener(csEvents.VIEWPORT_NEW_IMAGE_SET, element.newStackHandler);
         element.removeEventListener(csEvents.VOLUME_VIEWPORT_NEW_VOLUME, element.newVolumeHandler);
         delete element.newStackHandler;
         delete element.newVolumeHandler;