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

package/dist/esm/tools/annotation/planarFreehandROITool/drawLoop.js

@@ -280,4 +280,3 @@ function registerDrawLoop(toolInstance) {
     toolInstance.haltDrawing = haltDrawing.bind(toolInstance);
 }
 export default registerDrawLoop;
-//# sourceMappingURL=drawLoop.js.map

package/dist/esm/tools/annotation/planarFreehandROITool/editLoopCommon.js

@@ -144,4 +144,3 @@ function registerEditLoopCommon(toolInstance) {
         checkAndRemoveCrossesOnEditLine.bind(toolInstance);
 }
 export default registerEditLoopCommon;
-//# sourceMappingURL=editLoopCommon.js.map

package/dist/esm/tools/annotation/planarFreehandROITool/findOpenUShapedContourVectorToPeak.js

@@ -37,4 +37,3 @@ export function findOpenUShapedContourVectorToPeakOnRender(enabledElement, annot
     const canvasPoints = annotation.data.contour.polyline.map(viewport.worldToCanvas);
     return findOpenUShapedContourVectorToPeak(canvasPoints, viewport);
 }
-//# sourceMappingURL=findOpenUShapedContourVectorToPeak.js.map

package/dist/esm/tools/annotation/planarFreehandROITool/openContourEditLoop.js

@@ -323,4 +323,3 @@ function registerOpenContourEditLoop(toolInstance) {
         completeOpenContourEdit.bind(toolInstance);
 }
 export default registerOpenContourEditLoop;
-//# sourceMappingURL=openContourEditLoop.js.map

package/dist/esm/tools/annotation/planarFreehandROITool/openContourEndEditLoop.js

@@ -46,4 +46,3 @@ function registerOpenContourEndEditLoop(toolInstance) {
         activateOpenContourEndEdit.bind(toolInstance);
 }
 export default registerOpenContourEndEditLoop;
-//# sourceMappingURL=openContourEndEditLoop.js.map

package/dist/esm/tools/annotation/planarFreehandROITool/renderMethods.js

@@ -214,4 +214,3 @@ function registerRenderMethods(toolInstance) {
     toolInstance._getRenderingOptions = _getRenderingOptions.bind(toolInstance);
 }
 export default registerRenderMethods;
-//# sourceMappingURL=renderMethods.js.map

package/dist/esm/tools/annotation/splines/BSpline.js

@@ -7,4 +7,3 @@ class BSpline extends CubicSpline {
     }
 }
 export { BSpline as default, BSpline };
-//# sourceMappingURL=BSpline.js.map

package/dist/esm/tools/annotation/splines/CardinalSpline.js

@@ -30,4 +30,3 @@ class CardinalSpline extends CubicSpline {
     }
 }
 export { CardinalSpline as default, CardinalSpline };
-//# sourceMappingURL=CardinalSpline.js.map

package/dist/esm/tools/annotation/splines/CatmullRomSpline.js

@@ -5,4 +5,3 @@ class CatmullRomSpline extends CardinalSpline {
     }
 }
 export { CatmullRomSpline as default, CatmullRomSpline };
-//# sourceMappingURL=CatmullRomSpline.js.map

package/dist/esm/tools/annotation/splines/CubicSpline.js

@@ -162,4 +162,3 @@ class CubicSpline extends Spline {
     }
 }
 export { CubicSpline as default, CubicSpline };
-//# sourceMappingURL=CubicSpline.js.map

package/dist/esm/tools/annotation/splines/LinearSpline.js

@@ -5,4 +5,3 @@ class LinearSpline extends CardinalSpline {
     }
 }
 export { LinearSpline as default, LinearSpline };
-//# sourceMappingURL=LinearSpline.js.map

package/dist/esm/tools/annotation/splines/QuadraticBezier.js

@@ -13,4 +13,3 @@ class QuadraticBezier extends QuadraticSpline {
     }
 }
 export { QuadraticBezier as default, QuadraticBezier };
-//# sourceMappingURL=QuadraticBezier.js.map

package/dist/esm/tools/annotation/splines/QuadraticSpline.js

@@ -11,4 +11,3 @@ class QuadraticSpline extends Spline {
     }
 }
 export { QuadraticSpline as default, QuadraticSpline };
-//# sourceMappingURL=QuadraticSpline.js.map

package/dist/esm/tools/annotation/splines/Spline.js

@@ -393,4 +393,3 @@ class Spline {
     }
 }
 export { Spline as default, Spline };
-//# sourceMappingURL=Spline.js.map

package/dist/esm/tools/base/AnnotationDisplayTool.js

@@ -57,4 +57,3 @@ class AnnotationDisplayTool extends BaseTool {
 }
 AnnotationDisplayTool.toolName = 'AnnotationDisplayTool';
 export default AnnotationDisplayTool;
-//# sourceMappingURL=AnnotationDisplayTool.js.map

package/dist/esm/tools/base/AnnotationTool.js

@@ -180,4 +180,3 @@ class AnnotationTool extends AnnotationDisplayTool {
 }
 AnnotationTool.toolName = 'AnnotationTool';
 export default AnnotationTool;
-//# sourceMappingURL=AnnotationTool.js.map

package/dist/esm/tools/base/BaseTool.d.ts

@@ -14,8 +14,7 @@ declare abstract class BaseTool {
     applyActiveStrategyCallback(enabledElement: Types.IEnabledElement, operationData: unknown, callbackType: StrategyCallbacks | string): any;
     setConfiguration(newConfiguration: Record<string, any>): void;
     setActiveStrategy(strategyName: string): void;
-    protected getTargetVolumeId(viewport: Types.IViewport): string | undefined;
-    protected getTargetIdImage(targetId: string, renderingEngine: Types.IRenderingEngine): Types.IImageData | Types.CPUIImageData | Types.IImageVolume;
+    protected getTargetImageData(targetId: string): Types.IImageData | Types.CPUIImageData;
     protected getTargetId(viewport: Types.IViewport): string | undefined;
 }
 export default BaseTool;

package/dist/esm/tools/base/BaseTool.js

@@ -35,21 +35,11 @@ class BaseTool {
     setActiveStrategy(strategyName) {
         this.setConfiguration({ activeStrategy: strategyName });
     }
-    getTargetVolumeId(viewport) {
-        if (this.configuration.volumeId) {
-            return this.configuration.volumeId;
-        }
-        const actorEntries = viewport.getActors();
-        if (!actorEntries) {
-            return;
-        }
-        return actorEntries.find((actorEntry) => actorEntry.actor.getClassName() === 'vtkVolume')?.uid;
-    }
-    getTargetIdImage(targetId, renderingEngine) {
+    getTargetImageData(targetId) {
         if (targetId.startsWith('imageId:')) {
             const imageId = targetId.split('imageId:')[1];
             const imageURI = utilities.imageIdToURI(imageId);
-            let viewports = utilities.getViewportsWithImageURI(imageURI, renderingEngine.id);
+            let viewports = utilities.getViewportsWithImageURI(imageURI);
             if (!viewports || !viewports.length) {
                 return;
             }
@@ -63,7 +53,7 @@ class BaseTool {
         }
         else if (targetId.startsWith('volumeId:')) {
             const volumeId = utilities.getVolumeId(targetId);
-            const viewports = utilities.getViewportsWithVolumeId(volumeId, renderingEngine.id);
+            const viewports = utilities.getViewportsWithVolumeId(volumeId);
             if (!viewports || !viewports.length) {
                 return;
             }
@@ -71,7 +61,7 @@ class BaseTool {
         }
         else if (targetId.startsWith('videoId:')) {
             const imageURI = utilities.imageIdToURI(targetId);
-            const viewports = utilities.getViewportsWithImageURI(imageURI, renderingEngine.id);
+            const viewports = utilities.getViewportsWithImageURI(imageURI);
             if (!viewports || !viewports.length) {
                 return;
             }
@@ -86,12 +76,8 @@ class BaseTool {
         if (targetId) {
             return targetId;
         }
-        if (viewport instanceof BaseVolumeViewport) {
-            return `volumeId:${this.getTargetVolumeId(viewport)}`;
-        }
-        throw new Error('getTargetId: viewport must have a getReferenceId method');
+        throw new Error('getTargetId: viewport must have a getViewReferenceId method');
     }
 }
 BaseTool.toolName = 'BaseTool';
 export default BaseTool;
-//# sourceMappingURL=BaseTool.js.map

package/dist/esm/tools/base/ContourBaseTool.js

@@ -148,4 +148,3 @@ class ContourBaseTool extends AnnotationTool {
     }
 }
 export { ContourBaseTool as default, ContourBaseTool };
-//# sourceMappingURL=ContourBaseTool.js.map

package/dist/esm/tools/base/ContourSegmentationBaseTool.js

@@ -1,5 +1,4 @@
 import { getEnabledElement, utilities } from '@cornerstonejs/core';
-import { getGlobalConfig, getSegmentationRepresentationConfig, getSegmentIndexConfig, } from '../../stateManagement/segmentation/config/segmentationConfig';
 import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
 import { SegmentationRepresentations } from '../../enums';
 import ContourBaseTool from './ContourBaseTool';
@@ -9,14 +8,14 @@ import { addContourSegmentationAnnotation, removeContourSegmentationAnnotation,
 import { triggerAnnotationRenderForToolGroupIds } from '../../utilities/triggerAnnotationRenderForToolGroupIds';
 import { getToolGroupForViewport } from '../../store/ToolGroupManager';
 import { getSegmentIndexColor } from '../../stateManagement/segmentation/config/segmentationColor';
-import { getSegmentationRepresentations } from '../../stateManagement/segmentation/getSegmentationRepresentations';
-import { getSegmentationRepresentationsForSegmentation } from '../../stateManagement/segmentation/getSegmentationRepresentationsForSegmentation';
-import { getActiveSegmentationRepresentation } from '../../stateManagement/segmentation/getActiveSegmentationRepresentation';
+import { getSegmentationRepresentations } from '../../stateManagement/segmentation/getSegmentationRepresentation';
+import { getActiveSegmentation } from '../../stateManagement/segmentation/getActiveSegmentation';
 import { getSegmentationRepresentationVisibility } from '../../stateManagement/segmentation/getSegmentationRepresentationVisibility';
 import { getViewportIdsWithSegmentation } from '../../stateManagement/segmentation/getViewportIdsWithSegmentation';
 import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getActiveSegmentIndex';
 import { getLockedSegmentIndices } from '../../stateManagement/segmentation/segmentLocking';
 import { getSegmentIndexVisibility } from '../../stateManagement/segmentation/config/segmentationVisibility';
+import { segmentationStyle } from '../../stateManagement/segmentation/SegmentationStyle';
 class ContourSegmentationBaseTool extends ContourBaseTool {
     constructor(toolProps, defaultToolProps) {
         super(toolProps, defaultToolProps);
@@ -39,12 +38,11 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
         if (!this.isContourSegmentationTool()) {
             return contourAnnotation;
         }
-        const activeSeg = getActiveSegmentationRepresentation(viewport.id);
+        const activeSeg = getActiveSegmentation(viewport.id);
         if (!activeSeg) {
             throw new Error('No active segmentation detected, create one before using scissors tool');
         }
-        const { type: segmentationType } = activeSeg;
-        if (segmentationType !== SegmentationRepresentations.Contour) {
+        if (!activeSeg.representationData.Contour) {
             throw new Error(`A contour segmentation must be active`);
         }
         const { segmentationId } = activeSeg;
@@ -100,35 +98,36 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
         const annotation = context.annotation;
         const { segmentationId, segmentIndex } = annotation.data.segmentation;
         const segmentation = getSegmentation(segmentationId);
-        const segmentationRepresentations = getSegmentationRepresentationsForSegmentation(segmentationId);
+        const { viewportId } = context.styleSpecifier;
+        const segmentationRepresentations = getSegmentationRepresentations(viewportId, { segmentationId });
         if (!segmentationRepresentations?.length) {
             return {};
         }
-        const allUIDs = segmentationRepresentations.map((rep) => rep.segmentationRepresentationUID);
         let segmentationRepresentation;
         if (segmentationRepresentations.length > 1) {
-            const viewportReps = getSegmentationRepresentations(context.styleSpecifier.viewportId);
-            segmentationRepresentation = viewportReps.find((rep) => rep.segmentationId === segmentationId &&
-                allUIDs.includes(rep.segmentationRepresentationUID));
+            segmentationRepresentation = segmentationRepresentations.find((rep) => rep.segmentationId === segmentationId &&
+                rep.type === SegmentationRepresentations.Contour);
         }
         else {
             segmentationRepresentation = segmentationRepresentations[0];
         }
-        const { segmentationRepresentationUID } = segmentationRepresentation;
         const { autoGenerated } = annotation;
         const segmentsLocked = getLockedSegmentIndices(segmentationId);
         const annotationLocked = segmentsLocked.includes(segmentIndex);
-        const segmentColor = getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
-        const viewportId = context.styleSpecifier.viewportId;
-        const segmentationVisible = getSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID);
-        const globalConfig = getGlobalConfig();
-        const segmentationRepresentationConfig = getSegmentationRepresentationConfig(segmentationRepresentationUID);
-        const segmentConfig = getSegmentIndexConfig(segmentationRepresentationUID, segmentIndex);
-        const segmentVisible = getSegmentIndexVisibility(viewportId, segmentationRepresentationUID, segmentIndex);
-        const activeSegRep = getActiveSegmentationRepresentation(viewportId);
-        const isActive = activeSegRep.segmentationRepresentationUID ===
-            segmentationRepresentationUID;
-        const mergedConfig = Object.assign({}, globalConfig?.representations?.Contour ?? {}, segmentationRepresentationConfig ?? {}, segmentConfig ?? {});
+        const segmentColor = getSegmentIndexColor(context.styleSpecifier.viewportId, segmentationId, segmentIndex);
+        const segmentationVisible = getSegmentationRepresentationVisibility(viewportId, {
+            segmentationId,
+            type: SegmentationRepresentations.Contour,
+        });
+        const activeSegmentation = getActiveSegmentation(viewportId);
+        const isActive = activeSegmentation?.segmentationId === segmentationId;
+        const { style } = segmentationStyle.getStyle({
+            viewportId,
+            segmentationId,
+            type: SegmentationRepresentations.Contour,
+            segmentIndex,
+        });
+        const mergedConfig = style;
         let lineWidth = 1;
         let lineDash = undefined;
         let lineOpacity = 1;
@@ -167,10 +166,13 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
             textbox: {
                 color,
             },
-            visibility: segmentationVisible && segmentVisible,
+            visibility: segmentationVisible &&
+                getSegmentIndexVisibility(viewportId, {
+                    segmentationId,
+                    type: SegmentationRepresentations.Contour,
+                }, segmentIndex),
             locked: annotationLocked,
         };
     }
 }
 export { ContourSegmentationBaseTool as default, ContourSegmentationBaseTool };
-//# sourceMappingURL=ContourSegmentationBaseTool.js.map

package/dist/esm/tools/base/index.js

@@ -2,4 +2,3 @@ import BaseTool from './BaseTool';
 import AnnotationTool from './AnnotationTool';
 import AnnotationDisplayTool from './AnnotationDisplayTool';
 export { BaseTool, AnnotationTool, AnnotationDisplayTool };
-//# sourceMappingURL=index.js.map

package/dist/esm/tools/displayTools/Contour/contourConfig.d.ts

@@ -1,3 +1,3 @@
-import type { ContourConfig } from '../../../types/ContourTypes';
-declare function getDefaultContourConfig(): ContourConfig;
-export default getDefaultContourConfig;
+import type { ContourStyle } from '../../../types/ContourTypes';
+declare function getDefaultContourStyle(): ContourStyle;
+export default getDefaultContourStyle;

package/dist/esm/tools/displayTools/Contour/contourConfig.js

@@ -14,8 +14,7 @@ const defaultContourConfig = {
     fillAlphaInactive: 0.3,
     fillAlphaAutoGenerated: 0.3,
 };
-function getDefaultContourConfig() {
+function getDefaultContourStyle() {
     return defaultContourConfig;
 }
-export default getDefaultContourConfig;
-//# sourceMappingURL=contourConfig.js.map
+export default getDefaultContourStyle;

package/dist/esm/tools/displayTools/Contour/contourDisplay.d.ts

@@ -1,6 +1,6 @@
 import type { StackViewport, Types } from '@cornerstonejs/core';
 import type { ContourRepresentation } from '../../../types/SegmentationStateTypes';
-declare function removeRepresentation(viewportId: string, segmentationRepresentationUID: string, renderImmediate?: boolean): void;
+declare function removeRepresentation(viewportId: string, segmentationId: string, renderImmediate?: boolean): void;
 declare function render(viewport: StackViewport | Types.IVolumeViewport, contourRepresentation: ContourRepresentation): Promise<void>;
 declare const _default: {
     render: typeof render;

package/dist/esm/tools/displayTools/Contour/contourDisplay.js

@@ -1,23 +1,21 @@
 import { getEnabledElementByViewportId } from '@cornerstonejs/core';
 import Representations from '../../../enums/SegmentationRepresentations';
-import { deleteConfigCache } from './contourHandler/contourConfigCache';
 import { handleContourSegmentation } from './contourHandler/handleContourSegmentation';
-import { removeRepresentation as _removeRepresentation } from '../../../stateManagement/segmentation/removeRepresentation';
 import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
 import { canComputeRequestedRepresentation } from '../../../stateManagement/segmentation/polySeg/canComputeRequestedRepresentation';
 import { computeAndAddContourRepresentation } from '../../../stateManagement/segmentation/polySeg/Contour/computeAndAddContourRepresentation';
+import removeContourFromElement from './removeContourFromElement';
 let polySegConversionInProgress = false;
-function removeRepresentation(viewportId, segmentationRepresentationUID, renderImmediate = false) {
+function removeRepresentation(viewportId, segmentationId, renderImmediate = false) {
     const enabledElement = getEnabledElementByViewportId(viewportId);
     if (!enabledElement) {
         return;
     }
     const { viewport } = enabledElement;
-    _removeRepresentation(segmentationRepresentationUID);
-    deleteConfigCache(segmentationRepresentationUID);
     if (!renderImmediate) {
         return;
     }
+    removeContourFromElement(viewportId, segmentationId);
     viewport.render();
 }
 async function render(viewport, contourRepresentation) {
@@ -28,11 +26,10 @@ async function render(viewport, contourRepresentation) {
     }
     let contourData = segmentation.representationData[Representations.Contour];
     if (!contourData &&
-        canComputeRequestedRepresentation(contourRepresentation.segmentationRepresentationUID) &&
+        canComputeRequestedRepresentation(segmentationId, Representations.Contour) &&
         !polySegConversionInProgress) {
         polySegConversionInProgress = true;
         contourData = await computeAndAddContourRepresentation(segmentationId, {
-            segmentationRepresentationUID: contourRepresentation.segmentationRepresentationUID,
             viewport,
         });
     }
@@ -47,4 +44,3 @@ export default {
     render,
     removeRepresentation,
 };
-//# sourceMappingURL=contourDisplay.js.map

package/dist/esm/tools/displayTools/Contour/contourHandler/handleContourSegmentation.js

@@ -1,68 +1,38 @@
 import { addAnnotation } from '../../../../stateManagement/annotation/annotationState';
 import { cache, utilities } from '@cornerstonejs/core';
 import { getClosestImageIdForStackViewport } from '../../../../utilities/annotationHydration';
-import { getConfigCache, setConfigCache } from './contourConfigCache';
 import { addContourSegmentationAnnotation } from '../../../../utilities/contourSegmentation';
 import { validateGeometry } from './utils';
-import { getGlobalConfig } from '../../../../stateManagement/segmentation/getGlobalConfig';
 import { getHiddenSegmentIndices } from '../../../../stateManagement/segmentation/config/segmentationVisibility';
-import { getSegmentIndexConfig } from '../../../../stateManagement/segmentation/config/segmentationConfig';
+import { SegmentationRepresentations } from '../../../../enums';
+import { segmentationStyle } from '../../../../stateManagement/segmentation/SegmentationStyle';
 function handleContourSegmentation(viewport, geometryIds, annotationUIDsMap, contourRepresentation) {
-    const addOrUpdateFn = annotationUIDsMap.size
-        ? updateContourSets
-        : addContourSetsToElement;
-    addOrUpdateFn(viewport, geometryIds, contourRepresentation);
-}
-function updateContourSets(viewport, geometryIds, contourRepresentation) {
-    const { segmentationRepresentationUID, config } = contourRepresentation;
-    const baseConfig = config?.allSegments;
-    const globalContourConfig = getGlobalConfig().representations.Contour;
-    const newContourConfig = utilities.deepMerge(globalContourConfig, baseConfig);
-    const cachedConfig = getConfigCache(segmentationRepresentationUID);
-    const newOutlineWithActive = newContourConfig.outlineWidthActive;
-    if (cachedConfig?.outlineWidthActive !== newOutlineWithActive) {
-        setConfigCache(segmentationRepresentationUID, Object.assign({}, cachedConfig, {
-            outlineWidthActive: newOutlineWithActive,
-        }));
-    }
-    const segmentsToSetToInvisible = [];
-    const segmentsToSetToVisible = [];
-    const segmentsHidden = getHiddenSegmentIndices(viewport.id, segmentationRepresentationUID);
-    for (const segmentIndex of segmentsHidden) {
-        if (!cachedConfig.segmentsHidden.has(segmentIndex)) {
-            segmentsToSetToInvisible.push(segmentIndex);
-        }
+    if (annotationUIDsMap.size) {
+        updateContourSets(viewport, geometryIds, contourRepresentation);
     }
-    for (const segmentIndex of cachedConfig.segmentsHidden) {
-        if (!segmentsHidden.has(segmentIndex)) {
-            segmentsToSetToVisible.push(segmentIndex);
-        }
+    else {
+        addContourSetsToElement(viewport, geometryIds, contourRepresentation);
     }
-    const mergedInvisibleSegments = Array.from(cachedConfig.segmentsHidden)
-        .filter((segmentIndex) => !segmentsToSetToVisible.includes(segmentIndex))
-        .concat(segmentsToSetToInvisible);
+}
+function updateContourSets(viewport, geometryIds, contourRepresentation) {
+    const { segmentationId } = contourRepresentation;
     const { segmentSpecificConfigs } = geometryIds.reduce((acc, geometryId) => {
         const geometry = cache.getGeometry(geometryId);
         const { data: contourSet } = geometry;
         const segmentIndex = contourSet.getSegmentIndex();
-        const segmentSpecificConfig = getSegmentIndexConfig(segmentationRepresentationUID, segmentIndex);
+        const segmentSpecificConfig = segmentationStyle.getStyle({
+            viewportId: viewport.id,
+            segmentationId,
+            type: SegmentationRepresentations.Contour,
+            segmentIndex,
+        });
         acc.segmentSpecificConfigs[segmentIndex] = segmentSpecificConfig ?? {};
         return acc;
     }, { contourSets: [], segmentSpecificConfigs: {} });
-    const affectedSegments = [
-        ...mergedInvisibleSegments,
-        ...segmentsToSetToVisible,
-    ];
-    const hasCustomSegmentSpecificConfig = Object.values(segmentSpecificConfigs).some((config) => Object.keys(config).length > 0);
-    if (affectedSegments.length || hasCustomSegmentSpecificConfig) {
-        setConfigCache(segmentationRepresentationUID, Object.assign({}, cachedConfig, {
-            segmentsHidden: new Set(segmentsHidden),
-        }));
-    }
     viewport.render();
 }
 function addContourSetsToElement(viewport, geometryIds, contourRepresentation) {
-    const { segmentationRepresentationUID, segmentationId } = contourRepresentation;
+    const { segmentationId } = contourRepresentation;
     const segmentSpecificMap = new Map();
     geometryIds.forEach((geometryId) => {
         const geometry = cache.getGeometry(geometryId);
@@ -72,7 +42,12 @@ function addContourSetsToElement(viewport, geometryIds, contourRepresentation) {
         }
         const segmentIndex = geometry.data.getSegmentIndex();
         validateGeometry(geometry);
-        const segmentSpecificConfig = getSegmentIndexConfig(segmentationRepresentationUID, segmentIndex);
+        const segmentSpecificConfig = segmentationStyle.getStyle({
+            viewportId: viewport.id,
+            segmentationId,
+            type: SegmentationRepresentations.Contour,
+            segmentIndex,
+        });
         const contourSet = geometry.data;
         contourSet.contours.forEach((contour) => {
             const { points, color, id } = contour;
@@ -112,18 +87,11 @@ function addContourSetsToElement(viewport, geometryIds, contourRepresentation) {
             segmentSpecificMap.set(segmentIndex, segmentSpecificConfig);
         }
     });
-    const baseConfig = contourRepresentation.config?.allSegments;
-    const globalContourConfig = getGlobalConfig().representations.Contour;
-    const newContourConfig = utilities.deepMerge(globalContourConfig, baseConfig);
-    const outlineWidthActive = newContourConfig.outlineWidthActive;
-    const segmentsHidden = getHiddenSegmentIndices(viewport.id, segmentationRepresentationUID);
-    setConfigCache(segmentationRepresentationUID, Object.assign({}, getConfigCache(segmentationRepresentationUID), {
-        segmentsHidden: new Set(segmentsHidden),
-        segmentSpecificMap,
-        outlineWidthActive,
-    }));
+    const segmentsHidden = getHiddenSegmentIndices(viewport.id, {
+        segmentationId,
+        type: SegmentationRepresentations.Contour,
+    });
     viewport.resetCamera();
     viewport.render();
 }
 export { handleContourSegmentation, updateContourSets, addContourSetsToElement, };
-//# sourceMappingURL=handleContourSegmentation.js.map

package/dist/esm/tools/displayTools/Contour/contourHandler/utils.js

@@ -39,4 +39,3 @@ export function getPolyData(contourSet) {
     polygon.setLines(lines);
     return polygon;
 }
-//# sourceMappingURL=utils.js.map

package/dist/esm/tools/displayTools/Contour/index.js

@@ -1,3 +1,2 @@
 import contourDisplay from './contourDisplay';
 export { contourDisplay };
-//# sourceMappingURL=index.js.map

package/dist/esm/tools/displayTools/Contour/removeContourFromElement.d.ts

@@ -1,2 +1,2 @@
-declare function removeContourFromElement(element: HTMLDivElement, segmentationRepresentationUID: string, removeFromCache?: boolean): void;
+declare function removeContourFromElement(viewportId: string, segmentationId: string, removeFromCache?: boolean): void;
 export default removeContourFromElement;

package/dist/esm/tools/displayTools/Contour/removeContourFromElement.js

@@ -1,8 +1,6 @@
-import { getSegmentationRepresentation, getSegmentation, } from '../../../stateManagement/segmentation/segmentationState';
+import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
 import { removeAnnotation } from '../../../stateManagement';
-function removeContourFromElement(element, segmentationRepresentationUID, removeFromCache = false) {
-    const segmentationRepresentation = getSegmentationRepresentation(segmentationRepresentationUID);
-    const { segmentationId } = segmentationRepresentation;
+function removeContourFromElement(viewportId, segmentationId, removeFromCache = false) {
     const segmentation = getSegmentation(segmentationId);
     const { annotationUIDsMap } = segmentation.representationData.Contour;
     annotationUIDsMap.forEach((annotationSet) => {
@@ -12,4 +10,3 @@ function removeContourFromElement(element, segmentationRepresentationUID, remove
     });
 }
 export default removeContourFromElement;
-//# sourceMappingURL=removeContourFromElement.js.map

package/dist/esm/tools/displayTools/Labelmap/addLabelmapToElement.d.ts

@@ -1,3 +1,3 @@
 import type { LabelmapSegmentationData } from '../../../types/LabelmapTypes';
-declare function addLabelmapToElement(element: HTMLDivElement, labelMapData: LabelmapSegmentationData, segmentationRepresentationUID: string): Promise<void>;
+declare function addLabelmapToElement(element: HTMLDivElement, labelMapData: LabelmapSegmentationData, segmentationId: string): Promise<void>;
 export default addLabelmapToElement;

package/dist/esm/tools/displayTools/Labelmap/addLabelmapToElement.js

@@ -1,19 +1,26 @@
-import { getEnabledElement, addVolumesToViewports, addImageSlicesToViewports, Enums, } from '@cornerstonejs/core';
-import { isVolumeSegmentation } from '../../segmentation/strategies/utils/stackVolumeCheck';
-import { getSegmentationRepresentation } from '../../../stateManagement/segmentation/getSegmentationRepresentation';
+import { getEnabledElement, addVolumesToViewports, addImageSlicesToViewports, Enums, cache, BaseVolumeViewport, volumeLoader, utilities, } from '@cornerstonejs/core';
 import { getCurrentLabelmapImageIdForViewport } from '../../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
-async function addLabelmapToElement(element, labelMapData, segmentationRepresentationUID) {
+import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
+import { triggerSegmentationModified } from '../../../stateManagement/segmentation/triggerSegmentationEvents';
+import { SegmentationRepresentations } from '../../../enums';
+const { uuidv4 } = utilities;
+async function addLabelmapToElement(element, labelMapData, segmentationId) {
     const enabledElement = getEnabledElement(element);
     const { renderingEngine, viewport } = enabledElement;
     const { id: viewportId } = viewport;
     const visibility = true;
     const immediateRender = false;
     const suppressEvents = true;
-    if (isVolumeSegmentation(labelMapData, viewport)) {
+    if (viewport instanceof BaseVolumeViewport) {
+        const volumeLabelMapData = labelMapData;
+        const volumeId = _ensureVolumeHasVolumeId(volumeLabelMapData, segmentationId);
+        if (!cache.getVolume(volumeId)) {
+            await _handleMissingVolume(labelMapData);
+        }
         const volumeInputs = [
             {
-                volumeId: labelMapData.volumeId,
-                actorUID: segmentationRepresentationUID,
+                volumeId,
+                actorUID: `${segmentationId}-${SegmentationRepresentations.Labelmap}`,
                 visibility,
                 blendMode: Enums.BlendModes.MAXIMUM_INTENSITY_BLEND,
             },
@@ -21,16 +28,37 @@ async function addLabelmapToElement(element, labelMapData, segmentationRepresent
         await addVolumesToViewports(renderingEngine, volumeInputs, [viewportId], immediateRender, suppressEvents);
     }
     else {
-        const representation = getSegmentationRepresentation(segmentationRepresentationUID);
-        const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, representation.segmentationId);
+        const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
         const stackInputs = [
             {
                 imageId: segmentationImageId,
-                actorUID: segmentationRepresentationUID,
+                actorUID: `${segmentationId}-${SegmentationRepresentations.Labelmap}`,
             },
         ];
         await addImageSlicesToViewports(renderingEngine, stackInputs, [viewportId]);
     }
 }
+function _ensureVolumeHasVolumeId(labelMapData, segmentationId) {
+    let { volumeId } = labelMapData;
+    if (!volumeId) {
+        volumeId = uuidv4();
+        const segmentation = getSegmentation(segmentationId);
+        segmentation.representationData.Labelmap = {
+            ...segmentation.representationData.Labelmap,
+            volumeId,
+        };
+        labelMapData.volumeId = volumeId;
+        triggerSegmentationModified(segmentationId);
+    }
+    return volumeId;
+}
+async function _handleMissingVolume(labelMapData) {
+    const stackData = labelMapData;
+    const hasImageIds = stackData.imageIds.length > 0;
+    if (!hasImageIds) {
+        throw new Error('cannot create labelmap, no imageIds found for the volume labelmap');
+    }
+    const volume = await volumeLoader.createAndCacheVolumeFromImages(labelMapData.volumeId || uuidv4(), stackData.imageIds);
+    return volume;
+}
 export default addLabelmapToElement;
-//# sourceMappingURL=addLabelmapToElement.js.map

package/dist/esm/tools/displayTools/Labelmap/index.js

@@ -2,4 +2,3 @@ import labelmapDisplay from './labelmapDisplay';
 import labelmapConfig from './labelmapConfig';
 import { validate as validateLabelmap, validatePublic as validateLabelmapPublic, } from './validateLabelmap';
 export { labelmapDisplay, labelmapConfig, validateLabelmap, validateLabelmapPublic, };
-//# sourceMappingURL=index.js.map

package/dist/esm/tools/displayTools/Labelmap/labelmapConfig.d.ts

@@ -1,5 +1,3 @@
-import type { LabelmapConfig } from '../../../types/LabelmapTypes';
-declare function getDefaultLabelmapConfig(): LabelmapConfig;
-declare function isValidLabelmapConfig(config: any): boolean;
-export default getDefaultLabelmapConfig;
-export { isValidLabelmapConfig };
+import type { LabelmapStyle } from '../../../types/LabelmapTypes';
+declare function getDefaultLabelmapStyle(): LabelmapStyle;
+export default getDefaultLabelmapStyle;