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

package/dist/esm/tools/displayTools/Surface/surfaceDisplay.js

@@ -1,20 +1,21 @@
-import { cache, getEnabledElementByIds, VolumeViewport3D, } from '@cornerstonejs/core';
+import { cache, getEnabledElementByViewportId, VolumeViewport3D, } from '@cornerstonejs/core';
 import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
 import Representations from '../../../enums/SegmentationRepresentations';
-import { getToolGroup } from '../../../store/ToolGroupManager';
 import removeSurfaceFromElement from './removeSurfaceFromElement';
 import addOrUpdateSurfaceToElement from './addOrUpdateSurfaceToElement';
 import { polySeg } from '../../../stateManagement/segmentation';
-function removeSegmentationRepresentation(toolGroupId, segmentationRepresentationUID, renderImmediate = false) {
-    _removeSurfaceFromToolGroupViewports(toolGroupId, segmentationRepresentationUID);
-    SegmentationState.removeSegmentationRepresentation(toolGroupId, segmentationRepresentationUID);
-    if (renderImmediate) {
-        const viewportsInfo = getToolGroup(toolGroupId).getViewportsInfo();
-        viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
-            const enabledElement = getEnabledElementByIds(viewportId, renderingEngineId);
-            enabledElement.viewport.render();
-        });
+function removeRepresentation(viewportId, segmentationRepresentationUID, renderImmediate = false) {
+    const enabledElement = getEnabledElementByViewportId(viewportId);
+    if (!enabledElement) {
+        return;
+    }
+    const { viewport } = enabledElement;
+    removeSurfaceFromElement(viewport.element, segmentationRepresentationUID);
+    SegmentationState.removeRepresentation(segmentationRepresentationUID);
+    if (!renderImmediate) {
+        return;
     }
+    viewport.render();
 }
 async function render(viewport, representation) {
     const { colorLUTIndex, segmentationId, segmentationRepresentationUID } = representation;
@@ -55,20 +56,8 @@ async function render(viewport, representation) {
     });
     viewport.render();
 }
-function _removeSurfaceFromToolGroupViewports(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);
-        removeSurfaceFromElement(enabledElement.viewport.element, segmentationRepresentationUID);
-    }
-}
 export default {
     render,
-    removeSegmentationRepresentation,
+    removeRepresentation,
 };
-export { render, removeSegmentationRepresentation };
+export { render, removeRepresentation };

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

@@ -38,7 +38,6 @@ import CobbAngleTool from './annotation/CobbAngleTool';
 import UltrasoundDirectionalTool from './annotation/UltrasoundDirectionalTool';
 import KeyImageTool from './annotation/KeyImageTool';
 import AnnotationEraserTool from './AnnotationEraserTool';
-import SegmentationDisplayTool from './displayTools/SegmentationDisplayTool';
 import RectangleScissorsTool from './segmentation/RectangleScissorsTool';
 import CircleScissorsTool from './segmentation/CircleScissorsTool';
 import SphereScissorsTool from './segmentation/SphereScissorsTool';
@@ -49,4 +48,4 @@ import BrushTool from './segmentation/BrushTool';
 import PaintFillTool from './segmentation/PaintFillTool';
 import OrientationMarkerTool from './OrientationMarkerTool';
 import SegmentSelectTool from './segmentation/SegmentSelectTool';
-export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, StackScrollMouseWheelTool, ZoomTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LengthTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, AnnotationEraserTool as EraserTool, SegmentationDisplayTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, ReferenceLines, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, };
+export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, StackScrollMouseWheelTool, ZoomTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LengthTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, ReferenceLines, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, };

package/dist/esm/tools/index.js

@@ -38,7 +38,6 @@ import CobbAngleTool from './annotation/CobbAngleTool';
 import UltrasoundDirectionalTool from './annotation/UltrasoundDirectionalTool';
 import KeyImageTool from './annotation/KeyImageTool';
 import AnnotationEraserTool from './AnnotationEraserTool';
-import SegmentationDisplayTool from './displayTools/SegmentationDisplayTool';
 import RectangleScissorsTool from './segmentation/RectangleScissorsTool';
 import CircleScissorsTool from './segmentation/CircleScissorsTool';
 import SphereScissorsTool from './segmentation/SphereScissorsTool';
@@ -49,4 +48,4 @@ import BrushTool from './segmentation/BrushTool';
 import PaintFillTool from './segmentation/PaintFillTool';
 import OrientationMarkerTool from './OrientationMarkerTool';
 import SegmentSelectTool from './segmentation/SegmentSelectTool';
-export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, StackScrollMouseWheelTool, ZoomTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LengthTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, AnnotationEraserTool as EraserTool, SegmentationDisplayTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, ReferenceLines, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, };
+export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, StackScrollMouseWheelTool, ZoomTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LengthTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, ReferenceLines, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, };

package/dist/esm/tools/segmentation/BrushTool.d.ts

@@ -23,12 +23,10 @@ declare class BrushTool extends BaseTool {
         volumeId: string;
         referencedVolumeId: any;
         segmentsLocked: number[] | [];
-        segmentationRepresentationUID: string;
         imageIdReferenceMap?: undefined;
     } | {
         imageIdReferenceMap: Map<string, string>;
         segmentsLocked: number[] | [];
-        segmentationRepresentationUID: string;
         volumeId?: undefined;
         referencedVolumeId?: undefined;
     };
@@ -69,6 +67,21 @@ declare class BrushTool extends BaseTool {
         referencedVolumeId: any;
         segmentsLocked: number[] | [];
         imageIdReferenceMap?: undefined;
+    } | {
+        points: any;
+        segmentIndex: number;
+        previewColors: any;
+        viewPlaneNormal: any;
+        toolGroupId: string;
+        segmentationId: string;
+        segmentationRepresentationUID: string;
+        viewUp: any;
+        strategySpecificConfiguration: any;
+        preview: unknown;
+        imageIdReferenceMap: Map<string, string>;
+        segmentsLocked: number[] | [];
+        volumeId?: undefined;
+        referencedVolumeId?: undefined;
     };
     private _calculateCursor;
     private _endCallback;

package/dist/esm/tools/segmentation/BrushTool.js

@@ -190,12 +190,11 @@ class BrushTool extends BaseTool {
     createEditData(element) {
         const enabledElement = getEnabledElement(element);
         const { viewport } = enabledElement;
-        const toolGroupId = this.toolGroupId;
-        const activeSegmentationRepresentation = activeSegmentation.getActiveSegmentationRepresentation(toolGroupId);
-        if (!activeSegmentationRepresentation) {
+        const activeRepresentation = activeSegmentation.getActiveRepresentation(viewport.id);
+        if (!activeRepresentation) {
             throw new Error('No active segmentation detected, create a segmentation representation before using the brush tool');
         }
-        const { segmentationId, type, segmentationRepresentationUID } = activeSegmentationRepresentation;
+        const { segmentationId, type } = activeRepresentation;
         if (type === SegmentationRepresentations.Contour) {
             throw new Error('Not implemented yet');
         }
@@ -224,7 +223,6 @@ class BrushTool extends BaseTool {
                 volumeId,
                 referencedVolumeId: this.configuration.thresholdVolumeId ?? referencedVolumeIdToThreshold,
                 segmentsLocked,
-                segmentationRepresentationUID,
             };
         }
         else {
@@ -239,7 +237,6 @@ class BrushTool extends BaseTool {
             return {
                 imageIdReferenceMap,
                 segmentsLocked,
-                segmentationRepresentationUID,
             };
         }
     }
@@ -249,7 +246,7 @@ class BrushTool extends BaseTool {
         const camera = viewport.getCamera();
         const { viewPlaneNormal, viewUp } = camera;
         const viewportIdsToRender = [viewport.id];
-        const { segmentIndex, segmentationId, segmentationRepresentationUID, segmentColor, } = this.getActiveSegmentationData() || {};
+        const { segmentIndex, segmentationId, segmentationRepresentationUID, segmentColor, } = this.getActiveSegmentationData(viewport) || {};
         const brushCursor = {
             metadata: {
                 viewPlaneNormal: [...viewPlaneNormal],
@@ -265,22 +262,23 @@ class BrushTool extends BaseTool {
             brushCursor,
             centerCanvas,
             segmentIndex,
+            viewport,
             segmentationId,
             segmentationRepresentationUID,
             segmentColor,
             viewportIdsToRender,
         };
     }
-    getActiveSegmentationData() {
-        const toolGroupId = this.toolGroupId;
-        const activeSegmentationRepresentation = activeSegmentation.getActiveSegmentationRepresentation(toolGroupId);
-        if (!activeSegmentationRepresentation) {
+    getActiveSegmentationData(viewport) {
+        const viewportId = viewport.id;
+        const activeRepresentation = activeSegmentation.getActiveRepresentation(viewportId);
+        if (!activeRepresentation) {
             console.warn('No active segmentation detected, create one before using the brush tool');
             return;
         }
-        const { segmentationRepresentationUID, segmentationId } = activeSegmentationRepresentation;
+        const { segmentationId, segmentationRepresentationUID } = activeRepresentation;
         const segmentIndex = segmentIndexController.getActiveSegmentIndex(segmentationId);
-        const segmentColor = segmentationConfig.color.getColorForSegmentIndex(toolGroupId, segmentationRepresentationUID, segmentIndex);
+        const segmentColor = segmentationConfig.color.getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
         return {
             segmentIndex,
             segmentationId,
@@ -393,8 +391,9 @@ class BrushTool extends BaseTool {
             return;
         }
         const { data } = this._hoverData.brushCursor;
+        const { viewport } = this._hoverData;
         data.invalidated = true;
-        const { segmentColor } = this.getActiveSegmentationData() || {};
+        const { segmentColor } = this.getActiveSegmentationData(viewport) || {};
         this._hoverData.brushCursor.metadata.segmentColor = segmentColor;
     }
     renderAnnotation(enabledElement, svgDrawingHelper) {

package/dist/esm/tools/segmentation/CircleScissorsTool.js

@@ -31,19 +31,18 @@ class CircleScissorsTool extends BaseTool {
             const worldPos = currentPoints.world;
             const canvasPos = currentPoints.canvas;
             const enabledElement = getEnabledElement(element);
-            const { viewport, renderingEngine } = enabledElement;
+            const { viewport } = enabledElement;
             this.isDrawing = true;
             const camera = viewport.getCamera();
             const { viewPlaneNormal, viewUp } = camera;
-            const toolGroupId = this.toolGroupId;
-            const activeSegmentationRepresentation = activeSegmentation.getActiveSegmentationRepresentation(toolGroupId);
+            const activeSegmentationRepresentation = activeSegmentation.getActiveRepresentation(viewport.id);
             if (!activeSegmentationRepresentation) {
                 throw new Error('No active segmentation detected, create one before using scissors tool');
             }
             const { segmentationRepresentationUID, segmentationId, type } = activeSegmentationRepresentation;
             const segmentIndex = segmentIndexController.getActiveSegmentIndex(segmentationId);
             const segmentsLocked = segmentLocking.getLockedSegments(segmentationId);
-            const segmentColor = segmentationConfig.color.getColorForSegmentIndex(toolGroupId, segmentationRepresentationUID, segmentIndex);
+            const segmentColor = segmentationConfig.color.getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
             const { representationData } = getSegmentation(segmentationId);
             const labelmapData = representationData[type];
             if (!labelmapData) {

package/dist/esm/tools/segmentation/PaintFillTool.js

@@ -20,8 +20,7 @@ class PaintFillTool extends BaseTool {
             const { viewport } = enabledElement;
             const camera = viewport.getCamera();
             const { viewPlaneNormal } = camera;
-            const toolGroupId = this.toolGroupId;
-            const activeSegmentationRepresentation = activeSegmentation.getActiveSegmentationRepresentation(toolGroupId);
+            const activeSegmentationRepresentation = activeSegmentation.getActiveRepresentation(viewport.id);
             if (!activeSegmentationRepresentation) {
                 throw new Error('No active segmentation detected, create one before using scissors tool');
             }

package/dist/esm/tools/segmentation/RectangleScissorsTool.js

@@ -31,19 +31,18 @@ class RectangleScissorsTool extends BaseTool {
             const { currentPoints, element } = eventDetail;
             const worldPos = currentPoints.world;
             const enabledElement = getEnabledElement(element);
-            const { viewport, renderingEngine } = enabledElement;
+            const { viewport } = enabledElement;
             this.isDrawing = true;
             const camera = viewport.getCamera();
             const { viewPlaneNormal, viewUp } = camera;
-            const toolGroupId = this.toolGroupId;
-            const activeSegmentationRepresentation = activeSegmentation.getActiveSegmentationRepresentation(toolGroupId);
+            const activeSegmentationRepresentation = activeSegmentation.getActiveRepresentation(viewport.id);
             if (!activeSegmentationRepresentation) {
                 throw new Error('No active segmentation detected, create one before using scissors tool');
             }
             const { segmentationRepresentationUID, segmentationId, type } = activeSegmentationRepresentation;
             const segmentIndex = segmentIndexController.getActiveSegmentIndex(segmentationId);
             const segmentsLocked = segmentLocking.getLockedSegments(segmentationId);
-            const segmentColor = segmentationConfig.color.getColorForSegmentIndex(toolGroupId, segmentationRepresentationUID, segmentIndex);
+            const segmentColor = segmentationConfig.color.getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
             const { representationData } = getSegmentation(segmentationId);
             const labelmapData = representationData[SegmentationRepresentations.Labelmap];
             const annotation = {

package/dist/esm/tools/segmentation/SegmentSelectTool.d.ts

@@ -1,6 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
-import { PublicToolProps, ToolProps, EventTypes, ToolGroupSpecificRepresentation } from '../../types';
+import { PublicToolProps, ToolProps, EventTypes } from '../../types';
+import { SegmentationRepresentation } from '../../types/SegmentationStateTypes';
 declare class SegmentSelectTool extends BaseTool {
     static toolName: any;
     private hoverTimer;
@@ -14,6 +15,6 @@ declare class SegmentSelectTool extends BaseTool {
     onSetToolActive: () => void;
     onSetToolDisabled: () => void;
     _setActiveSegment(evt?: EventTypes.InteractionEventType): void;
-    _setActiveSegmentForType(activeSegmentationReps: ToolGroupSpecificRepresentation, worldPoint: Types.Point3, viewport: Types.IStackViewport | Types.IVolumeViewport): void;
+    _setActiveSegmentForType(activeSegmentationReps: SegmentationRepresentation, worldPoint: Types.Point3, viewport: Types.IStackViewport | Types.IVolumeViewport): void;
 }
 export default SegmentSelectTool;

package/dist/esm/tools/segmentation/SegmentSelectTool.js

@@ -2,10 +2,10 @@ import { getEnabledElement } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
 import { triggerSegmentationModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
-import { getActiveSegmentationRepresentation } from '../../stateManagement/segmentation/activeSegmentation';
+import { getActiveRepresentation } from '../../stateManagement/segmentation/activeSegmentation';
 import RepresentationTypes from '../../enums/SegmentationRepresentations';
 import { setActiveSegmentIndex } from '../../stateManagement/segmentation/segmentIndex';
-import { getHoveredContourSegmentationAnnotation, getSegmentAtLabelmapBorder, getSegmentAtWorldPoint, } from '../../utilities/segmentation';
+import { getHoveredContourSegmentationAnnotation, getSegmentIndexAtLabelmapBorder, getSegmentIndexAtWorldPoint, } from '../../utilities/segmentation';
 import { state } from '../../store';
 import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
 class SegmentSelectTool extends BaseTool {
@@ -54,7 +54,7 @@ class SegmentSelectTool extends BaseTool {
             return;
         }
         const { viewport } = enabledElement;
-        const activeSegmentationReps = getActiveSegmentationRepresentation(this.toolGroupId);
+        const activeSegmentationReps = getActiveRepresentation(viewport.id);
         if (!activeSegmentationReps) {
             return;
         }
@@ -77,14 +77,14 @@ class SegmentSelectTool extends BaseTool {
         const { segmentationId, type } = activeSegmentationReps;
         let hoveredSegmentIndex;
         if (this.configuration.mode === SegmentSelectTool.SelectMode.Inside) {
-            hoveredSegmentIndex = getSegmentAtWorldPoint(segmentationId, worldPoint, {
+            hoveredSegmentIndex = getSegmentIndexAtWorldPoint(segmentationId, worldPoint, {
                 viewport,
             });
         }
         else {
             switch (type) {
                 case SegmentationRepresentations.Labelmap:
-                    hoveredSegmentIndex = getSegmentAtLabelmapBorder(segmentationId, worldPoint, {
+                    hoveredSegmentIndex = getSegmentIndexAtLabelmapBorder(segmentationId, worldPoint, {
                         viewport,
                         searchRadius: this.configuration.searchRadius,
                     });

package/dist/esm/tools/segmentation/SphereScissorsTool.js

@@ -31,19 +31,18 @@ class SphereScissorsTool extends BaseTool {
             const worldPos = currentPoints.world;
             const canvasPos = currentPoints.canvas;
             const enabledElement = getEnabledElement(element);
-            const { viewport, renderingEngine } = enabledElement;
+            const { viewport } = enabledElement;
             this.isDrawing = true;
             const camera = viewport.getCamera();
             const { viewPlaneNormal, viewUp } = camera;
-            const toolGroupId = this.toolGroupId;
-            const activeSegmentationRepresentation = activeSegmentation.getActiveSegmentationRepresentation(toolGroupId);
+            const activeSegmentationRepresentation = activeSegmentation.getActiveRepresentation(viewport.id);
             if (!activeSegmentationRepresentation) {
                 throw new Error('No active segmentation detected, create one before using scissors tool');
             }
             const { segmentationRepresentationUID, segmentationId } = activeSegmentationRepresentation;
             const segmentIndex = segmentIndexController.getActiveSegmentIndex(segmentationId);
             const segmentsLocked = segmentLocking.getLockedSegments(segmentationId);
-            const segmentColor = segmentationConfig.color.getColorForSegmentIndex(toolGroupId, segmentationRepresentationUID, segmentIndex);
+            const segmentColor = segmentationConfig.color.getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
             this.isDrawing = true;
             const annotation = {
                 metadata: {
@@ -73,7 +72,7 @@ class SphereScissorsTool extends BaseTool {
                 segmentationId,
                 segmentsLocked,
                 segmentColor,
-                toolGroupId,
+                toolGroupId: this.toolGroupId,
                 viewportIdsToRender,
                 handleIndex: 3,
                 movingTextBox: false,

package/dist/esm/tools/segmentation/strategies/compositions/preview.js

@@ -42,12 +42,12 @@ export default {
             return;
         }
         const configColor = previewColors?.[segmentIndex];
-        const segmentColor = segmentationConfig.color.getColorForSegmentIndex(toolGroupId, segmentationRepresentationUID, segmentIndex);
+        const segmentColor = segmentationConfig.color.getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
         if (!configColor && !segmentColor) {
             return;
         }
         const previewColor = configColor || lightenColor(...segmentColor);
-        segmentationConfig.color.setColorForSegmentIndex(toolGroupId, segmentationRepresentationUID, previewSegmentIndex, previewColor);
+        segmentationConfig.color.setSegmentIndexColor(segmentationRepresentationUID, previewSegmentIndex, previewColor);
     },
     [StrategyCallbacks.AcceptPreview]: (operationData) => {
         const { segmentationVoxelManager: segmentationVoxelManager, previewVoxelManager: previewVoxelManager, previewSegmentIndex, preview, } = operationData || {};

package/dist/esm/types/EventTypes.d.ts

@@ -111,17 +111,14 @@ type SegmentationDataModifiedEventDetail = {
 };
 type SegmentationRenderedEventDetail = {
     viewportId: string;
-    toolGroupId: string;
 };
 type SegmentationRepresentationModifiedEventDetail = {
-    toolGroupId: string;
     segmentationRepresentationUID: string;
 };
 type SegmentationRemovedEventDetail = {
     segmentationId: string;
 };
 type SegmentationRepresentationRemovedEventDetail = {
-    toolGroupId: string;
     segmentationRepresentationUID: string;
 };
 type SegmentationModifiedEventDetail = {

package/dist/esm/types/SegmentationStateTypes.d.ts

@@ -3,7 +3,7 @@ import * as Enums from '../enums';
 import { ContourConfig, ContourRenderingConfig, ContourSegmentationData } from './ContourTypes';
 import type { LabelmapConfig, LabelmapRenderingConfig, LabelmapSegmentationData } from './LabelmapTypes';
 import { SurfaceSegmentationData, SurfaceRenderingConfig } from './SurfaceTypes';
-export type SegmentSpecificRepresentationConfig = {
+export type SegmentRepresentationConfig = {
     [key: number | string]: RepresentationConfig;
 };
 export type RepresentationConfig = {
@@ -12,7 +12,7 @@ export type RepresentationConfig = {
     SURFACE?: any;
 };
 export type SegmentationRepresentationConfig = {
-    renderInactiveSegmentations: boolean;
+    renderInactiveRepresentations: boolean;
     representations: RepresentationConfig;
 };
 export type SegmentationRepresentationData = {
@@ -34,43 +34,44 @@ export type Segmentation = {
     };
     representationData: SegmentationRepresentationData;
 };
-export type ToolGroupSpecificRepresentationState = {
+export type BaseSegmentationRepresentation = {
     segmentationRepresentationUID: string;
     segmentationId: string;
     type: Enums.SegmentationRepresentations;
-    active: boolean;
-    segmentsHidden: Set<number>;
     colorLUTIndex: number;
     polySeg?: {
         enabled: boolean;
         options?: any;
     };
+    config: {
+        allSegments?: RepresentationConfig;
+        perSegment?: SegmentRepresentationConfig;
+    };
 };
-export type ToolGroupSpecificLabelmapRepresentation = ToolGroupSpecificRepresentationState & {
-    config: LabelmapRenderingConfig;
-    segmentationRepresentationSpecificConfig?: RepresentationConfig;
-    segmentSpecificConfig?: SegmentSpecificRepresentationConfig;
+export type LabelmapRepresentation = BaseSegmentationRepresentation & {
+    rendering: LabelmapRenderingConfig;
 };
-export type ToolGroupSpecificContourRepresentation = ToolGroupSpecificRepresentationState & {
-    config: ContourRenderingConfig;
-    segmentationRepresentationSpecificConfig?: RepresentationConfig;
-    segmentSpecificConfig?: SegmentSpecificRepresentationConfig;
+export type ContourRepresentation = BaseSegmentationRepresentation & {
+    rendering: ContourRenderingConfig;
 };
-export type ToolGroupSpecificSurfaceRepresentation = ToolGroupSpecificRepresentationState & {
-    config: SurfaceRenderingConfig;
-    segmentationRepresentationSpecificConfig?: RepresentationConfig;
-    segmentSpecificConfig?: SegmentSpecificRepresentationConfig;
+export type SurfaceRepresentation = BaseSegmentationRepresentation & {
+    rendering: SurfaceRenderingConfig;
 };
-export type ToolGroupSpecificRepresentation = ToolGroupSpecificLabelmapRepresentation | ToolGroupSpecificContourRepresentation;
-export type ToolGroupSpecificRepresentations = Array<ToolGroupSpecificRepresentation>;
+export type SegmentationRepresentation = LabelmapRepresentation | ContourRepresentation | SurfaceRepresentation;
 export type SegmentationState = {
     colorLUT: Types.ColorLUT[];
     segmentations: Segmentation[];
     globalConfig: SegmentationRepresentationConfig;
-    toolGroups: {
-        [key: string]: {
-            segmentationRepresentations: ToolGroupSpecificRepresentations;
-            config: SegmentationRepresentationConfig;
+    representations: {
+        [key: string]: SegmentationRepresentation;
+    };
+    viewports: {
+        [viewportId: string]: {
+            [segRepresentationUID: string]: {
+                visible: boolean;
+                active: boolean;
+                segmentsHidden: Set<number>;
+            };
         };
     };
 };

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

@@ -22,7 +22,7 @@ import type ScrollOptions from './ScrollOptions';
 import type BoundsIJK from './BoundsIJK';
 import type SVGDrawingHelper from './SVGDrawingHelper';
 import type * as CINETypes from './CINETypes';
-import type { RepresentationConfig, SegmentationRepresentationConfig, SegmentationRepresentationData, Segmentation, ToolGroupSpecificRepresentationState, ToolGroupSpecificContourRepresentation, ToolGroupSpecificLabelmapRepresentation, ToolGroupSpecificRepresentation, SegmentationState, RepresentationPublicInput } from './SegmentationStateTypes';
+import type { RepresentationConfig, SegmentationRepresentationConfig, SegmentationRepresentationData, Segmentation, SegmentationState, RepresentationPublicInput } from './SegmentationStateTypes';
 import { ISculptToolShape } from './ISculptToolShape';
 import type ISynchronizerEventHandler from './ISynchronizerEventHandler';
 import type { FloodFillGetter, FloodFillOptions, FloodFillResult } from './FloodFillTypes';
@@ -46,4 +46,4 @@ import type { SplineLineSegment } from './SplineLineSegment';
 import type { SplineProps } from './SplineProps';
 import type { BidirectionalData } from '../utilities/segmentation/createBidirectionalToolData';
 import type { PolySegConversionOptions } from './PolySeg';
-export type { Annotation, Annotations, ContourAnnotationData, ContourAnnotation, ContourSegmentationAnnotationData, ContourSegmentationAnnotation, BidirectionalData, CanvasCoordinates, IAnnotationManager, InterpolationViewportData, ImageInterpolationData, GroupSpecificAnnotations, AnnotationState, AnnotationStyle, ToolSpecificAnnotationTypes, JumpToSliceOptions, AnnotationGroupSelector, AnnotationRenderContext, PlanarBoundingBox, ToolProps, PublicToolProps, ToolConfiguration, EventTypes, IPoints, ITouchPoints, IDistance, IToolBinding, SetToolBindingsType, ToolOptionsType, InteractionTypes, ToolAction, IToolGroup, IToolClassReference, ISynchronizerEventHandler, ToolHandle, AnnotationHandle, TextBoxHandle, Segmentation, SegmentationState, SegmentationRepresentationData, SegmentationRepresentationConfig, RepresentationConfig, ToolGroupSpecificRepresentationState, ToolGroupSpecificContourRepresentation, ToolGroupSpecificLabelmapRepresentation, ToolGroupSpecificRepresentation, RepresentationPublicInput, LabelmapTypes, SVGCursorDescriptor, SVGPoint, ScrollOptions, CINETypes, BoundsIJK, SVGDrawingHelper, FloodFillResult, FloodFillGetter, FloodFillOptions, ContourSegmentationData, ISculptToolShape, Statistics, NamedStatistics, LabelmapToolOperationData, LabelmapToolOperationDataStack, LabelmapToolOperationDataVolume, CardinalSplineProps, ClosestControlPoint, ClosestPoint, ClosestSplinePoint, ControlPointInfo, ISpline, SplineCurveSegment, SplineLineSegment, SplineProps, PolySegConversionOptions, };
+export type { Annotation, Annotations, ContourAnnotationData, ContourAnnotation, ContourSegmentationAnnotationData, ContourSegmentationAnnotation, BidirectionalData, CanvasCoordinates, IAnnotationManager, InterpolationViewportData, ImageInterpolationData, GroupSpecificAnnotations, AnnotationState, AnnotationStyle, ToolSpecificAnnotationTypes, JumpToSliceOptions, AnnotationGroupSelector, AnnotationRenderContext, PlanarBoundingBox, ToolProps, PublicToolProps, ToolConfiguration, EventTypes, IPoints, ITouchPoints, IDistance, IToolBinding, SetToolBindingsType, ToolOptionsType, InteractionTypes, ToolAction, IToolGroup, IToolClassReference, ISynchronizerEventHandler, ToolHandle, AnnotationHandle, TextBoxHandle, Segmentation, SegmentationState, SegmentationRepresentationData, SegmentationRepresentationConfig, RepresentationConfig, RepresentationPublicInput, LabelmapTypes, SVGCursorDescriptor, SVGPoint, ScrollOptions, CINETypes, BoundsIJK, SVGDrawingHelper, FloodFillResult, FloodFillGetter, FloodFillOptions, ContourSegmentationData, ISculptToolShape, Statistics, NamedStatistics, LabelmapToolOperationData, LabelmapToolOperationDataStack, LabelmapToolOperationDataVolume, CardinalSplineProps, ClosestControlPoint, ClosestPoint, ClosestSplinePoint, ControlPointInfo, ISpline, SplineCurveSegment, SplineLineSegment, SplineProps, PolySegConversionOptions, };

package/dist/esm/utilities/segmentation/getSegmentIndexAtLabelmapBorder.d.ts

@@ -0,0 +1,7 @@
+import type { Types } from '@cornerstonejs/core';
+type Options = {
+    viewport?: Types.IViewport;
+    searchRadius?: number;
+};
+export declare function getSegmentIndexAtLabelmapBorder(segmentationId: string, worldPoint: Types.Point3, { viewport, searchRadius }: Options): number;
+export {};

package/dist/esm/utilities/segmentation/{getSegmentAtLabelmapBorder.js → getSegmentIndexAtLabelmapBorder.js}

@@ -1,7 +1,7 @@
 import { cache, utilities } from '@cornerstonejs/core';
-import { getSegmentation, getSegmentationIdRepresentations, } from '../../stateManagement/segmentation/segmentationState';
+import { getSegmentation, getRepresentationsBySegmentationId, } from '../../stateManagement/segmentation/segmentationState';
 import { isVolumeSegmentation } from '../../tools/segmentation/strategies/utils/stackVolumeCheck';
-export function getSegmentAtLabelmapBorder(segmentationId, worldPoint, { viewport, searchRadius }) {
+export function getSegmentIndexAtLabelmapBorder(segmentationId, worldPoint, { viewport, searchRadius }) {
     const segmentation = getSegmentation(segmentationId);
     const labelmapData = segmentation.representationData.LABELMAP;
     if (isVolumeSegmentation(labelmapData)) {
@@ -23,7 +23,7 @@ export function getSegmentAtLabelmapBorder(segmentationId, worldPoint, { viewpor
     if (!image) {
         return;
     }
-    const segmentationRepresentations = getSegmentationIdRepresentations(segmentation.segmentationId);
+    const segmentationRepresentations = getRepresentationsBySegmentationId(segmentation.segmentationId);
     const { segmentationRepresentationUID } = segmentationRepresentations[0];
     const segmentationActor = viewport.getActor(segmentationRepresentationUID);
     const imageData = segmentationActor?.actor.getMapper().getInputData();

package/dist/esm/utilities/segmentation/getSegmentIndexAtWorldPoint.d.ts

@@ -0,0 +1,11 @@
+import type { Types } from '@cornerstonejs/core';
+import { SegmentationRepresentations } from '../../enums';
+import { Segmentation } from '../../types';
+type Options = {
+    representationType?: SegmentationRepresentations;
+    viewport?: Types.IViewport;
+};
+export declare function getSegmentIndexAtWorldPoint(segmentationId: string, worldPoint: Types.Point3, options?: Options): number;
+export declare function getSegmentIndexAtWorldForLabelmap(segmentation: Segmentation, worldPoint: Types.Point3, { viewport }: Options): number | undefined;
+export declare function getSegmentIndexAtWorldForContour(segmentation: Segmentation, worldPoint: Types.Point3, { viewport }: Options): number;
+export {};

package/dist/esm/utilities/segmentation/{getSegmentAtWorldPoint.js → getSegmentIndexAtWorldPoint.js}

@@ -1,10 +1,10 @@
 import { cache, utilities } from '@cornerstonejs/core';
 import { SegmentationRepresentations } from '../../enums';
-import { getSegmentation, getSegmentationIdRepresentations, } from '../../stateManagement/segmentation/segmentationState';
+import { getSegmentation, getRepresentationsBySegmentationId, } from '../../stateManagement/segmentation/segmentationState';
 import { isVolumeSegmentation } from '../../tools/segmentation/strategies/utils/stackVolumeCheck';
 import { getAnnotation } from '../../stateManagement';
 import { isPointInsidePolyline3D } from '../math/polyline';
-export function getSegmentAtWorldPoint(segmentationId, worldPoint, options = {}) {
+export function getSegmentIndexAtWorldPoint(segmentationId, worldPoint, options = {}) {
     const segmentation = getSegmentation(segmentationId);
     const representationData = segmentation.representationData;
     const desiredRepresentation = options?.representationType ?? Object.keys(representationData)[0];
@@ -13,14 +13,14 @@ export function getSegmentAtWorldPoint(segmentationId, worldPoint, options = {})
     }
     switch (desiredRepresentation) {
         case SegmentationRepresentations.Labelmap:
-            return getSegmentAtWorldForLabelmap(segmentation, worldPoint, options);
+            return getSegmentIndexAtWorldForLabelmap(segmentation, worldPoint, options);
         case SegmentationRepresentations.Contour:
-            return getSegmentAtWorldForContour(segmentation, worldPoint, options);
+            return getSegmentIndexAtWorldForContour(segmentation, worldPoint, options);
         default:
             return;
     }
 }
-export function getSegmentAtWorldForLabelmap(segmentation, worldPoint, { viewport }) {
+export function getSegmentIndexAtWorldForLabelmap(segmentation, worldPoint, { viewport }) {
     const labelmapData = segmentation.representationData.LABELMAP;
     if (isVolumeSegmentation(labelmapData)) {
         const { volumeId } = labelmapData;
@@ -38,7 +38,7 @@ export function getSegmentAtWorldForLabelmap(segmentation, worldPoint, { viewpor
     if (!image) {
         return;
     }
-    const segmentationRepresentations = getSegmentationIdRepresentations(segmentation.segmentationId);
+    const segmentationRepresentations = getRepresentationsBySegmentationId(segmentation.segmentationId);
     const { segmentationRepresentationUID } = segmentationRepresentations[0];
     const segmentationActor = viewport.getActor(segmentationRepresentationUID);
     const imageData = segmentationActor?.actor.getMapper().getInputData();
@@ -49,7 +49,7 @@ export function getSegmentAtWorldForLabelmap(segmentation, worldPoint, { viewpor
     const segmentIndex = voxelManager.getAtIJKPoint(indexIJK);
     return segmentIndex;
 }
-export function getSegmentAtWorldForContour(segmentation, worldPoint, { viewport }) {
+export function getSegmentIndexAtWorldForContour(segmentation, worldPoint, { viewport }) {
     const contourData = segmentation.representationData.CONTOUR;
     const segmentIndices = Array.from(contourData.annotationUIDsMap.keys());
     const { viewPlaneNormal } = viewport.getCamera();

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

@@ -15,8 +15,8 @@ import createBidirectionalToolData from './createBidirectionalToolData';
 import segmentContourAction from './segmentContourAction';
 import { invalidateBrushCursor } from './invalidateBrushCursor';
 import { getUniqueSegmentIndices } from './getUniqueSegmentIndices';
-import { getSegmentAtWorldPoint } from './getSegmentAtWorldPoint';
-import { getSegmentAtLabelmapBorder } from './getSegmentAtLabelmapBorder';
+import { getSegmentIndexAtWorldPoint } from './getSegmentIndexAtWorldPoint';
+import { getSegmentIndexAtLabelmapBorder } from './getSegmentIndexAtLabelmapBorder';
 import { getHoveredContourSegmentationAnnotation } from './getHoveredContourSegmentationAnnotation';
 import { getBrushToolInstances } from './utilities';
-export { thresholdVolumeByRange, createMergedLabelmapForIndex, isValidRepresentationConfig, getDefaultRepresentationConfig, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, thresholdSegmentationByRange, createImageIdReferenceMap, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentAtWorldPoint, getSegmentAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, };
+export { thresholdVolumeByRange, createMergedLabelmapForIndex, isValidRepresentationConfig, getDefaultRepresentationConfig, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, thresholdSegmentationByRange, createImageIdReferenceMap, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, };

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

@@ -15,8 +15,8 @@ import createBidirectionalToolData from './createBidirectionalToolData';
 import segmentContourAction from './segmentContourAction';
 import { invalidateBrushCursor } from './invalidateBrushCursor';
 import { getUniqueSegmentIndices } from './getUniqueSegmentIndices';
-import { getSegmentAtWorldPoint } from './getSegmentAtWorldPoint';
-import { getSegmentAtLabelmapBorder } from './getSegmentAtLabelmapBorder';
+import { getSegmentIndexAtWorldPoint } from './getSegmentIndexAtWorldPoint';
+import { getSegmentIndexAtLabelmapBorder } from './getSegmentIndexAtLabelmapBorder';
 import { getHoveredContourSegmentationAnnotation } from './getHoveredContourSegmentationAnnotation';
 import { getBrushToolInstances } from './utilities';
-export { thresholdVolumeByRange, createMergedLabelmapForIndex, isValidRepresentationConfig, getDefaultRepresentationConfig, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, thresholdSegmentationByRange, createImageIdReferenceMap, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentAtWorldPoint, getSegmentAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, };
+export { thresholdVolumeByRange, createMergedLabelmapForIndex, isValidRepresentationConfig, getDefaultRepresentationConfig, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, thresholdSegmentationByRange, createImageIdReferenceMap, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, };