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

package/dist/esm/tools/annotation/EllipticalROITool.js

@@ -17,7 +17,7 @@ import { pointInEllipse, getCanvasEllipseCorners, } from '../../utilities/math/e
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { pointInShapeCallback } from '../../utilities/';
-import { getModalityUnit } from '../../utilities/getModalityUnit';
+import { getPixelValueUnits } from '../../utilities/getPixelValueUnits';
 import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
 import { BasicStatsCalculator } from '../../utilities/math/basic';
 const { transformWorldToIndex } = csUtils;
@@ -428,14 +428,14 @@ class EllipticalROITool extends AnnotationTool {
                 const canvasCorners = (getCanvasEllipseCorners(canvasCoordinates));
                 const { centerPointRadius } = this.configuration;
                 if (!data.cachedStats[targetId] ||
-                    data.cachedStats[targetId].areaUnit == null) {
+                    data.cachedStats[targetId].areaUnits == null) {
                     data.cachedStats[targetId] = {
                         Modality: null,
                         area: null,
                         max: null,
                         mean: null,
                         stdDev: null,
-                        areaUnit: null,
+                        areaUnits: null,
                     };
                     this._calculateCachedStats(annotation, viewport, renderingEngine);
                 }
@@ -592,11 +592,11 @@ class EllipticalROITool extends AnnotationTool {
                 const area = Math.abs(Math.PI * (worldWidth / 2) * (worldHeight / 2)) /
                     scale /
                     scale;
-                const modalityUnitOptions = {
+                const pixelUnitsOptions = {
                     isPreScaled: isViewportPreScaled(viewport, targetId),
                     isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
                 };
-                const modalityUnit = getModalityUnit(metadata.Modality, annotation.metadata.referencedImageId, modalityUnitOptions);
+                const pixelValueUnits = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
                 const pointsInShape = pointInShapeCallback(imageData, (pointLPS) => pointInEllipse(ellipseObj, pointLPS, { fast: true }), this.configuration.statsCalculator.statsCallback, boundsIJK);
                 const stats = this.configuration.statsCalculator.getStatistics();
                 cachedStats[targetId] = {
@@ -608,8 +608,8 @@ class EllipticalROITool extends AnnotationTool {
                     statsArray: stats.array,
                     pointsInShape,
                     isEmptyArea,
-                    areaUnit: areaUnits,
-                    modalityUnit,
+                    areaUnits,
+                    pixelValueUnits,
                 };
             }
             annotation.invalidated = false;
@@ -647,22 +647,22 @@ class EllipticalROITool extends AnnotationTool {
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { area, mean, stdDev, max, isEmptyArea, areaUnit, modalityUnit } = cachedVolumeStats;
+    const { area, mean, stdDev, max, isEmptyArea, areaUnits, pixelValueUnits } = cachedVolumeStats;
     const textLines = [];
     if (area) {
         const areaLine = isEmptyArea
             ? `Area: Oblique not supported`
-            : `Area: ${roundNumber(area)} ${areaUnit}`;
+            : `Area: ${roundNumber(area)} ${areaUnits}`;
         textLines.push(areaLine);
     }
     if (mean) {
-        textLines.push(`Mean: ${roundNumber(mean)} ${modalityUnit}`);
+        textLines.push(`Mean: ${roundNumber(mean)} ${pixelValueUnits}`);
     }
     if (max) {
-        textLines.push(`Max: ${roundNumber(max)} ${modalityUnit}`);
+        textLines.push(`Max: ${roundNumber(max)} ${pixelValueUnits}`);
     }
     if (stdDev) {
-        textLines.push(`Std Dev: ${roundNumber(stdDev)} ${modalityUnit}`);
+        textLines.push(`Std Dev: ${roundNumber(stdDev)} ${pixelValueUnits}`);
     }
     return textLines;
 }

package/dist/esm/tools/annotation/LengthTool.js

@@ -393,14 +393,14 @@ class LengthTool extends AnnotationTool {
             const index1 = transformWorldToIndex(imageData, worldPos1);
             const index2 = transformWorldToIndex(imageData, worldPos2);
             const handles = [index1, index2];
-            const { scale, units } = getCalibratedLengthUnitsAndScale(image, handles);
+            const { scale, lengthUnits } = getCalibratedLengthUnitsAndScale(image, handles);
             const length = this._calculateLength(worldPos1, worldPos2) / scale;
             this._isInsideVolume(index1, index2, dimensions)
                 ? (this.isHandleOutsideImage = false)
                 : (this.isHandleOutsideImage = true);
             cachedStats[targetId] = {
                 length,
-                unit: units,
+                lengthUnits,
             };
         }
         annotation.invalidated = false;

package/dist/esm/tools/annotation/PlanarFreehandROITool.js

@@ -19,7 +19,7 @@ import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
 import { getLineSegmentIntersectionsCoordinates } from '../../utilities/math/polyline';
 import pointInShapeCallback from '../../utilities/pointInShapeCallback';
 import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
-import { getModalityUnit } from '../../utilities/getModalityUnit';
+import { getPixelValueUnits } from '../../utilities/getPixelValueUnits';
 import { BasicStatsCalculator } from '../../utilities/math/basic';
 import calculatePerimeter from '../../utilities/contours/calculatePerimeter';
 import ContourSegmentationBaseTool from '../base/ContourSegmentationBaseTool';
@@ -70,8 +70,6 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
         this.addNewAnnotation = (evt) => {
             const eventDetail = evt.detail;
             const { element } = eventDetail;
-            const enabledElement = getEnabledElement(element);
-            const { renderingEngine } = enabledElement;
             const annotation = this.createAnnotation(evt);
             this.addAnnotation(annotation, element);
             const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName());
@@ -251,11 +249,11 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
                     }
                     return result;
                 }, this.configuration.statsCalculator.statsCallback, boundsIJK);
-                const modalityUnitOptions = {
+                const pixelUnitsOptions = {
                     isPreScaled: isViewportPreScaled(viewport, targetId),
                     isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
                 };
-                const modalityUnit = getModalityUnit(metadata.Modality, annotation.metadata.referencedImageId, modalityUnitOptions);
+                const pixelValueUnits = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
                 const stats = this.configuration.statsCalculator.getStatistics();
                 cachedStats[targetId] = {
                     Modality: metadata.Modality,
@@ -266,8 +264,8 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
                     stdDev: stats.stdDev?.value,
                     statsArray: stats.array,
                     pointsInShape: pointsInShape,
-                    areaUnit: areaUnits,
-                    modalityUnit,
+                    areaUnits,
+                    pixelValueUnits,
                 };
             }
             triggerAnnotationModified(annotation, enabledElement.viewport.element, ChangeTypes.StatsUpdated);
@@ -445,14 +443,14 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
         if (!this.commonData?.movingTextBox) {
             const { data } = annotation;
             if (!data.cachedStats[targetId] ||
-                data.cachedStats[targetId].areaUnit == null) {
+                data.cachedStats[targetId].areaUnits == null) {
                 data.cachedStats[targetId] = {
                     Modality: null,
                     area: null,
                     max: null,
                     mean: null,
                     stdDev: null,
-                    areaUnit: null,
+                    areaUnits: null,
                 };
                 this._calculateCachedStats(annotation, viewport, renderingEngine, enabledElement);
             }
@@ -464,25 +462,25 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { area, mean, stdDev, perimeter, max, isEmptyArea, areaUnit, modalityUnit, } = cachedVolumeStats || {};
+    const { area, mean, stdDev, perimeter, max, isEmptyArea, areaUnits, pixelValueUnits, } = cachedVolumeStats || {};
     const textLines = [];
     if (area) {
         const areaLine = isEmptyArea
             ? `Area: Oblique not supported`
-            : `Area: ${roundNumber(area)} ${areaUnit}`;
+            : `Area: ${roundNumber(area)} ${areaUnits}`;
         textLines.push(areaLine);
     }
     if (mean) {
-        textLines.push(`Mean: ${roundNumber(mean)} ${modalityUnit}`);
+        textLines.push(`Mean: ${roundNumber(mean)} ${pixelValueUnits}`);
     }
     if (max) {
-        textLines.push(`Max: ${roundNumber(max)} ${modalityUnit}`);
+        textLines.push(`Max: ${roundNumber(max)} ${pixelValueUnits}`);
     }
     if (stdDev) {
-        textLines.push(`Std Dev: ${roundNumber(stdDev)} ${modalityUnit}`);
+        textLines.push(`Std Dev: ${roundNumber(stdDev)} ${pixelValueUnits}`);
     }
     if (perimeter) {
-        textLines.push(`Perimeter: ${roundNumber(perimeter)} ${modalityUnit}`);
+        textLines.push(`Perimeter: ${roundNumber(perimeter)} ${pixelValueUnits}`);
     }
     return textLines;
 }

package/dist/esm/tools/annotation/ProbeTool.js

@@ -11,7 +11,7 @@ import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters'
 import { roundNumber } from '../../utilities';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
-import { getModalityUnit, } from '../../utilities/getModalityUnit';
+import { getPixelValueUnits, } from '../../utilities/getPixelValueUnits';
 import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
 const { transformWorldToIndex } = csUtils;
 class ProbeTool extends AnnotationTool {
@@ -257,7 +257,7 @@ class ProbeTool extends AnnotationTool {
         const targetIds = Object.keys(cachedStats);
         for (let i = 0; i < targetIds.length; i++) {
             const targetId = targetIds[i];
-            const modalityUnitOptions = {
+            const pixelUnitsOptions = {
                 isPreScaled: isViewportPreScaled(viewport, targetId),
                 isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
             };
@@ -294,25 +294,25 @@ class ProbeTool extends AnnotationTool {
                     const viewport = viewports[0];
                     index[2] = viewport.getCurrentImageIdIndex();
                 }
-                let modalityUnit;
+                let pixelValueUnits;
                 if (modality === 'US') {
                     const calibratedResults = getCalibratedProbeUnitsAndValue(image, [
                         index,
                     ]);
                     const hasEnhancedRegionValues = calibratedResults.values.every((value) => value !== null);
                     value = hasEnhancedRegionValues ? calibratedResults.values : value;
-                    modalityUnit = hasEnhancedRegionValues
+                    pixelValueUnits = hasEnhancedRegionValues
                         ? calibratedResults.units
                         : 'raw';
                 }
                 else {
-                    modalityUnit = getModalityUnit(modality, annotation.metadata.referencedImageId, modalityUnitOptions);
+                    pixelValueUnits = getPixelValueUnits(modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
                 }
                 cachedStats[targetId] = {
                     index,
                     value,
                     Modality: modality,
-                    modalityUnit,
+                    pixelValueUnits,
                 };
             }
             else {
@@ -330,19 +330,19 @@ class ProbeTool extends AnnotationTool {
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { index, value, modalityUnit } = cachedVolumeStats;
+    const { index, value, pixelValueUnits } = cachedVolumeStats;
     if (value === undefined) {
         return;
     }
     const textLines = [];
     textLines.push(`(${index[0]}, ${index[1]}, ${index[2]})`);
-    if (value instanceof Array && modalityUnit instanceof Array) {
+    if (value instanceof Array && pixelValueUnits instanceof Array) {
         for (let i = 0; i < value.length; i++) {
-            textLines.push(`${roundNumber(value[i])} ${modalityUnit[i]}`);
+            textLines.push(`${roundNumber(value[i])} ${pixelValueUnits[i]}`);
         }
     }
     else {
-        textLines.push(`${roundNumber(value)} ${modalityUnit}`);
+        textLines.push(`${roundNumber(value)} ${pixelValueUnits}`);
     }
     return textLines;
 }

package/dist/esm/tools/annotation/RectangleROITool.js

@@ -16,7 +16,7 @@ import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
 import getWorldWidthAndHeightFromCorners from '../../utilities/planar/getWorldWidthAndHeightFromCorners';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
-import { getModalityUnit } from '../../utilities/getModalityUnit';
+import { getPixelValueUnits } from '../../utilities/getPixelValueUnits';
 import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
 import { pointInShapeCallback } from '../../utilities/';
 import { BasicStatsCalculator } from '../../utilities/math/basic';
@@ -347,14 +347,14 @@ class RectangleROITool extends AnnotationTool {
                 });
                 const { viewPlaneNormal, viewUp } = viewport.getCamera();
                 if (!data.cachedStats[targetId] ||
-                    data.cachedStats[targetId].areaUnit == null) {
+                    data.cachedStats[targetId].areaUnits == null) {
                     data.cachedStats[targetId] = {
                         Modality: null,
                         area: null,
                         max: null,
                         mean: null,
                         stdDev: null,
-                        areaUnit: null,
+                        areaUnits: null,
                     };
                     this._calculateCachedStats(annotation, viewPlaneNormal, viewUp, renderingEngine, enabledElement);
                 }
@@ -490,11 +490,11 @@ class RectangleROITool extends AnnotationTool {
                     const handles = [pos1Index, pos2Index];
                     const { scale, areaUnits } = getCalibratedLengthUnitsAndScale(image, handles);
                     const area = Math.abs(worldWidth * worldHeight) / (scale * scale);
-                    const modalityUnitOptions = {
+                    const pixelUnitsOptions = {
                         isPreScaled: isViewportPreScaled(viewport, targetId),
                         isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
                     };
-                    const modalityUnit = getModalityUnit(metadata.Modality, annotation.metadata.referencedImageId, modalityUnitOptions);
+                    const pixelValueUnits = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
                     const pointsInShape = pointInShapeCallback(imageData, () => true, this.configuration.statsCalculator.statsCallback, boundsIJK);
                     const stats = this.configuration.statsCalculator.getStatistics();
                     cachedStats[targetId] = {
@@ -505,8 +505,8 @@ class RectangleROITool extends AnnotationTool {
                         max: stats.max?.value,
                         statsArray: stats.array,
                         pointsInShape: pointsInShape,
-                        areaUnit: areaUnits,
-                        modalityUnit,
+                        areaUnits,
+                        pixelValueUnits,
                     };
                 }
                 else {
@@ -529,15 +529,15 @@ class RectangleROITool extends AnnotationTool {
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { area, mean, max, stdDev, areaUnit, modalityUnit } = cachedVolumeStats;
+    const { area, mean, max, stdDev, areaUnits, pixelValueUnits } = cachedVolumeStats;
     if (mean === undefined) {
         return;
     }
     const textLines = [];
-    textLines.push(`Area: ${roundNumber(area)} ${areaUnit}`);
-    textLines.push(`Mean: ${roundNumber(mean)} ${modalityUnit}`);
-    textLines.push(`Max: ${roundNumber(max)} ${modalityUnit}`);
-    textLines.push(`Std Dev: ${roundNumber(stdDev)} ${modalityUnit}`);
+    textLines.push(`Area: ${roundNumber(area)} ${areaUnits}`);
+    textLines.push(`Mean: ${roundNumber(mean)} ${pixelValueUnits}`);
+    textLines.push(`Max: ${roundNumber(max)} ${pixelValueUnits}`);
+    textLines.push(`Std Dev: ${roundNumber(stdDev)} ${pixelValueUnits}`);
     return textLines;
 }
 RectangleROITool.toolName = 'RectangleROI';

package/dist/esm/tools/annotation/SplineROITool.js

@@ -468,7 +468,7 @@ class SplineROITool extends ContourSegmentationBaseTool {
                 cachedStats[targetId] = {
                     Modality: metadata.Modality,
                     area,
-                    areaUnit: areaUnits,
+                    areaUnits,
                 };
             }
             this.triggerAnnotationModified(annotation, enabledElement, ChangeTypes.StatsUpdated);
@@ -557,11 +557,11 @@ class SplineROITool extends ContourSegmentationBaseTool {
         });
         super.renderAnnotationInstance(renderContext);
         if (!data.cachedStats[targetId] ||
-            data.cachedStats[targetId].areaUnit == null) {
+            data.cachedStats[targetId].areaUnits == null) {
             data.cachedStats[targetId] = {
                 Modality: null,
                 area: null,
-                areaUnit: null,
+                areaUnits: null,
             };
             this._calculateCachedStats(annotation, element);
         }
@@ -712,12 +712,12 @@ class SplineROITool extends ContourSegmentationBaseTool {
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { area, isEmptyArea, areaUnit } = cachedVolumeStats;
+    const { area, isEmptyArea, areaUnits } = cachedVolumeStats;
     const textLines = [];
     if (area) {
         const areaLine = isEmptyArea
             ? `Area: Oblique not supported`
-            : `Area: ${roundNumber(area)} ${areaUnit}`;
+            : `Area: ${roundNumber(area)} ${areaUnits}`;
         textLines.push(areaLine);
     }
     return textLines;

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

@@ -13,6 +13,5 @@ declare abstract class ContourSegmentationBaseTool extends ContourBaseTool {
     }): any;
     protected renderAnnotationInstance(renderContext: AnnotationRenderContext): boolean;
     private _getContourSegmentationStyle;
-    private _getSegmentationRepresentation;
 }
 export { ContourSegmentationBaseTool as default, ContourSegmentationBaseTool };

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

@@ -1,12 +1,13 @@
-import { utilities } from '@cornerstonejs/core';
+import { getEnabledElement, utilities } from '@cornerstonejs/core';
 import { config as segmentationConfig, state as segmentationState, segmentLocking, segmentIndex as segmentIndexController, activeSegmentation, } from '../../stateManagement/segmentation';
 import { SegmentationRepresentations } from '../../enums';
 import ContourBaseTool from './ContourBaseTool';
 import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
 import { InterpolationManager } from '../../utilities/contours/interpolation';
 import { addContourSegmentationAnnotation, removeContourSegmentationAnnotation, } from '../../utilities/contourSegmentation';
-import { getToolGroupIdsWithSegmentation } from '../../stateManagement/segmentation/segmentationState';
 import { triggerAnnotationRenderForToolGroupIds } from '../../utilities';
+import { getActiveRepresentation, getRepresentationsBySegmentationId, getRepresentationsForViewport, getViewportIdsWithSegmentationId, } from '../../stateManagement/segmentation/segmentationState';
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
 class ContourSegmentationBaseTool extends ContourBaseTool {
     constructor(toolProps, defaultToolProps) {
         super(toolProps, defaultToolProps);
@@ -18,20 +19,26 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
         return true;
     }
     createAnnotation(evt) {
-        const { toolGroupId } = this;
+        const eventDetail = evt.detail;
+        const { element } = eventDetail;
+        const enabledElement = getEnabledElement(element);
+        if (!enabledElement) {
+            return;
+        }
+        const { viewport } = enabledElement;
         const contourAnnotation = super.createAnnotation(evt);
         if (!this.isContourSegmentationTool()) {
             return contourAnnotation;
         }
-        const activeSegmentationRepresentation = activeSegmentation.getActiveSegmentationRepresentation(toolGroupId);
-        if (!activeSegmentationRepresentation) {
+        const activeSeg = activeSegmentation.getActiveRepresentation(viewport.id);
+        if (!activeSeg) {
             throw new Error('No active segmentation detected, create one before using scissors tool');
         }
-        const { type: segmentationType } = activeSegmentationRepresentation;
+        const { type: segmentationType } = activeSeg;
         if (segmentationType !== SegmentationRepresentations.Contour) {
             throw new Error(`A contour segmentation must be active`);
         }
-        const { segmentationId } = activeSegmentationRepresentation;
+        const { segmentationId } = activeSeg;
         const segmentIndex = segmentIndexController.getActiveSegmentIndex(segmentationId);
         return utilities.deepMerge(contourAnnotation, {
             data: {
@@ -71,33 +78,48 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
         if (invalidated && this.isContourSegmentationTool()) {
             const { segmentationId } = (annotation).data.segmentation;
             triggerSegmentationDataModified(segmentationId);
-            const toolGroupIds = getToolGroupIdsWithSegmentation(segmentationId);
+            const viewportIds = getViewportIdsWithSegmentationId(segmentationId);
+            const toolGroupIds = viewportIds.map((viewportId) => {
+                const toolGroup = getToolGroupForViewport(viewportId);
+                return toolGroup.id;
+            });
             triggerAnnotationRenderForToolGroupIds(toolGroupIds);
         }
         return renderResult;
     }
     _getContourSegmentationStyle(context) {
-        const { toolGroupId } = this;
         const annotation = context.annotation;
         const { segmentationId, segmentIndex } = annotation.data.segmentation;
         const segmentation = segmentationState.getSegmentation(segmentationId);
-        const segmentationRepresentation = this._getSegmentationRepresentation(segmentationId);
-        if (!segmentationRepresentation) {
+        const segmentationRepresentations = getRepresentationsBySegmentationId(segmentationId);
+        if (!segmentationRepresentations?.length) {
             return {};
         }
+        const allUIDs = segmentationRepresentations.map((rep) => rep.segmentationRepresentationUID);
+        let segmentationRepresentation;
+        if (segmentationRepresentations.length > 1) {
+            const viewportReps = getRepresentationsForViewport(context.styleSpecifier.viewportId);
+            segmentationRepresentation = viewportReps.find((rep) => rep.segmentationId === segmentationId &&
+                allUIDs.includes(rep.segmentationRepresentationUID));
+        }
+        else {
+            segmentationRepresentation = segmentationRepresentations[0];
+        }
         const { segmentationRepresentationUID } = segmentationRepresentation;
-        const { active } = segmentationRepresentation;
         const { autoGenerated } = annotation;
         const segmentsLocked = segmentLocking.getLockedSegments(segmentationId);
         const annotationLocked = segmentsLocked.includes(segmentIndex);
-        const segmentColor = segmentationConfig.color.getColorForSegmentIndex(toolGroupId, segmentationRepresentationUID, segmentIndex);
-        const segmentationVisible = segmentationConfig.visibility.getSegmentationVisibility(toolGroupId, segmentationRepresentationUID);
+        const segmentColor = segmentationConfig.color.getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
+        const viewportId = context.styleSpecifier.viewportId;
+        const segmentationVisible = segmentationConfig.visibility.getRepresentationVisibility(viewportId, segmentationRepresentationUID);
         const globalConfig = segmentationConfig.getGlobalConfig();
-        const toolGroupConfig = segmentationConfig.getToolGroupSpecificConfig(toolGroupId);
-        const segmentationRepresentationConfig = segmentationConfig.getSegmentationRepresentationSpecificConfig(toolGroupId, segmentationRepresentationUID);
-        const segmentConfig = segmentationConfig.getSegmentSpecificConfig(toolGroupId, segmentationRepresentationUID, segmentIndex);
-        const segmentVisible = segmentationConfig.visibility.getSegmentVisibility(toolGroupId, segmentationRepresentationUID, segmentIndex);
-        const mergedConfig = Object.assign({}, globalConfig?.representations?.CONTOUR ?? {}, toolGroupConfig?.representations?.CONTOUR ?? {}, segmentationRepresentationConfig?.CONTOUR ?? {}, segmentConfig?.CONTOUR ?? {});
+        const getAllSegmentsConfig = segmentationConfig.getAllSegmentsConfig(segmentationRepresentationUID);
+        const segmentConfig = segmentationConfig.getSegmentIndexConfig(segmentationRepresentationUID, segmentIndex);
+        const segmentVisible = segmentationConfig.visibility.getSegmentIndexVisibility(viewportId, segmentationRepresentationUID, segmentIndex);
+        const activeSegRep = getActiveRepresentation(viewportId);
+        const isActive = activeSegRep.segmentationRepresentationUID ===
+            segmentationRepresentationUID;
+        const mergedConfig = Object.assign({}, globalConfig?.representations?.CONTOUR ?? {}, getAllSegmentsConfig?.CONTOUR ?? {}, segmentConfig?.CONTOUR ?? {});
         let lineWidth = 1;
         let lineDash = undefined;
         let lineOpacity = 1;
@@ -108,7 +130,7 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
             lineOpacity = mergedConfig.outlineOpacity ?? lineOpacity;
             fillOpacity = mergedConfig.fillAlphaAutoGenerated ?? fillOpacity;
         }
-        else if (active) {
+        else if (isActive) {
             lineWidth = mergedConfig.outlineWidthActive ?? lineWidth;
             lineDash = mergedConfig.outlineDashActive ?? lineDash;
             lineOpacity = mergedConfig.outlineOpacity ?? lineOpacity;
@@ -140,18 +162,5 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
             locked: annotationLocked,
         };
     }
-    _getSegmentationRepresentation(segmentationId) {
-        const segmentationRepresentations = segmentationState.getSegmentationRepresentations(this.toolGroupId);
-        const validSegmentationRepresentations = segmentationRepresentations.filter((representation) => representation.segmentationId === segmentationId);
-        if (!validSegmentationRepresentations) {
-            console.warn(`No segmentation representation found for toolGroupId: ${this.toolGroupId}`);
-            return;
-        }
-        if (segmentationState.getSegmentationRepresentations(this.toolGroupId)
-            .length > 1) {
-            console.warn('Multiple segmentation representations detected for this tool group. The first one will be used.');
-        }
-        return validSegmentationRepresentations[0];
-    }
 }
 export { ContourSegmentationBaseTool as default, ContourSegmentationBaseTool };

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

@@ -1,9 +1,9 @@
 import { StackViewport, Types } from '@cornerstonejs/core';
-import { SegmentationRepresentationConfig, ToolGroupSpecificRepresentation } from '../../../types/SegmentationStateTypes';
-declare function removeSegmentationRepresentation(toolGroupId: string, segmentationRepresentationUID: string, renderImmediate?: boolean): void;
-declare function render(viewport: StackViewport | Types.IVolumeViewport, representationConfig: ToolGroupSpecificRepresentation, toolGroupConfig: SegmentationRepresentationConfig): Promise<void>;
+import { ContourRepresentation } from '../../../types/SegmentationStateTypes';
+declare function removeRepresentation(viewportId: string, segmentationRepresentationUID: string, renderImmediate?: boolean): void;
+declare function render(viewport: StackViewport | Types.IVolumeViewport, contourRepresentation: ContourRepresentation): Promise<void>;
 declare const _default: {
     render: typeof render;
-    removeSegmentationRepresentation: typeof removeSegmentationRepresentation;
+    removeRepresentation: typeof removeRepresentation;
 };
 export default _default;

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

@@ -1,37 +1,36 @@
-import { getEnabledElementByIds, } from '@cornerstonejs/core';
+import { getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import Representations from '../../../enums/SegmentationRepresentations';
 import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
-import { getToolGroup } from '../../../store/ToolGroupManager';
-import removeContourFromElement from './removeContourFromElement';
 import { deleteConfigCache } from './contourHandler/contourConfigCache';
 import { polySeg } from '../../../stateManagement/segmentation';
 import { handleContourSegmentation } from './contourHandler/handleContourSegmentation';
 let polySegConversionInProgress = false;
-function removeSegmentationRepresentation(toolGroupId, segmentationRepresentationUID, renderImmediate = false) {
-    _removeContourFromToolGroupViewports(toolGroupId, segmentationRepresentationUID);
-    SegmentationState.removeSegmentationRepresentation(toolGroupId, segmentationRepresentationUID);
+function removeRepresentation(viewportId, segmentationRepresentationUID, renderImmediate = false) {
+    const enabledElement = getEnabledElementByViewportId(viewportId);
+    if (!enabledElement) {
+        return;
+    }
+    const { viewport } = enabledElement;
+    SegmentationState.removeRepresentation(segmentationRepresentationUID);
     deleteConfigCache(segmentationRepresentationUID);
-    if (renderImmediate) {
-        const viewportsInfo = getToolGroup(toolGroupId).getViewportsInfo();
-        viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
-            const enabledElement = getEnabledElementByIds(viewportId, renderingEngineId);
-            enabledElement.viewport.render();
-        });
+    if (!renderImmediate) {
+        return;
     }
+    viewport.render();
 }
-async function render(viewport, representationConfig, toolGroupConfig) {
-    const { segmentationId } = representationConfig;
+async function render(viewport, contourRepresentation) {
+    const { segmentationId } = contourRepresentation;
     const segmentation = SegmentationState.getSegmentation(segmentationId);
     if (!segmentation) {
         return;
     }
     let contourData = segmentation.representationData[Representations.Contour];
     if (!contourData &&
-        polySeg.canComputeRequestedRepresentation(representationConfig.segmentationRepresentationUID) &&
+        polySeg.canComputeRequestedRepresentation(contourRepresentation.segmentationRepresentationUID) &&
         !polySegConversionInProgress) {
         polySegConversionInProgress = true;
         contourData = await polySeg.computeAndAddContourRepresentation(segmentationId, {
-            segmentationRepresentationUID: representationConfig.segmentationRepresentationUID,
+            segmentationRepresentationUID: contourRepresentation.segmentationRepresentationUID,
             viewport,
         });
     }
@@ -39,22 +38,10 @@ async function render(viewport, representationConfig, toolGroupConfig) {
         return;
     }
     if (contourData?.geometryIds?.length) {
-        handleContourSegmentation(viewport, contourData.geometryIds, contourData.annotationUIDsMap, representationConfig, toolGroupConfig);
-    }
-}
-function _removeContourFromToolGroupViewports(toolGroupId, segmentationRepresentationUID) {
-    const toolGroup = getToolGroup(toolGroupId);
-    if (toolGroup === undefined) {
-        throw new Error(`ToolGroup with ToolGroupId ${toolGroupId} does not exist`);
-    }
-    const { viewportsInfo } = toolGroup;
-    for (const viewportInfo of viewportsInfo) {
-        const { viewportId, renderingEngineId } = viewportInfo;
-        const enabledElement = getEnabledElementByIds(viewportId, renderingEngineId);
-        removeContourFromElement(segmentationRepresentationUID, toolGroupId);
+        handleContourSegmentation(viewport, contourData.geometryIds, contourData.annotationUIDsMap, contourRepresentation);
     }
 }
 export default {
     render,
-    removeSegmentationRepresentation,
+    removeRepresentation,
 };

package/dist/esm/tools/displayTools/Contour/contourHandler/handleContourSegmentation.d.ts

@@ -1,6 +1,6 @@
 import { Types, StackViewport } from '@cornerstonejs/core';
-import { SegmentationRepresentationConfig, ToolGroupSpecificContourRepresentation } from '../../../../types';
-declare function handleContourSegmentation(viewport: StackViewport | Types.IVolumeViewport, geometryIds: string[], annotationUIDsMap: Map<number, Set<string>>, contourRepresentation: ToolGroupSpecificContourRepresentation, contourRepresentationConfig: SegmentationRepresentationConfig): void;
-declare function updateContourSets(viewport: Types.IVolumeViewport | StackViewport, geometryIds: string[], contourRepresentation: ToolGroupSpecificContourRepresentation, contourRepresentationConfig: SegmentationRepresentationConfig): void;
-declare function addContourSetsToElement(viewport: StackViewport | Types.IVolumeViewport, geometryIds: string[], contourRepresentation: ToolGroupSpecificContourRepresentation, contourRepresentationConfig: SegmentationRepresentationConfig): void;
+import { ContourRepresentation } from '../../../../types/SegmentationStateTypes';
+declare function handleContourSegmentation(viewport: StackViewport | Types.IVolumeViewport, geometryIds: string[], annotationUIDsMap: Map<number, Set<string>>, contourRepresentation: ContourRepresentation): void;
+declare function updateContourSets(viewport: Types.IVolumeViewport | StackViewport, geometryIds: string[], contourRepresentation: ContourRepresentation): void;
+declare function addContourSetsToElement(viewport: StackViewport | Types.IVolumeViewport, geometryIds: string[], contourRepresentation: ContourRepresentation): void;
 export { handleContourSegmentation, updateContourSets, addContourSetsToElement, };