@cornerstonejs/tools 2.0.0-beta.20 → 2.0.0-beta.22

package/dist/esm/tools/annotation/UltrasoundDirectionalTool.d.ts

@@ -1,15 +1,13 @@
 import type { Types } from '@cornerstonejs/core';
 import { AnnotationTool } from '../base';
-import { UltrasoundDirectionalAnnotation } from '../../types/ToolSpecificAnnotationTypes';
-import { EventTypes, ToolHandle, PublicToolProps, ToolProps, SVGDrawingHelper, Annotation, InteractionTypes } from '../../types';
+import type { UltrasoundDirectionalAnnotation } from '../../types/ToolSpecificAnnotationTypes';
+import type { EventTypes, ToolHandle, PublicToolProps, ToolProps, SVGDrawingHelper, Annotation, InteractionTypes } from '../../types';
 declare class UltrasoundDirectionalTool extends AnnotationTool {
     static toolName: any;
-    touchDragCallback: any;
-    mouseDragCallback: any;
     startedDrawing: boolean;
-    _throttledCalculateCachedStats: any;
+    _throttledCalculateCachedStats: Function;
     editData: {
-        annotation: any;
+        annotation: Annotation;
         viewportIdsToRender: string[];
         handleIndex?: number;
         movingTextBox?: boolean;
@@ -25,7 +23,7 @@ declare class UltrasoundDirectionalTool extends AnnotationTool {
     handleSelectedCallback(evt: EventTypes.InteractionEventType, annotation: UltrasoundDirectionalAnnotation, handle: ToolHandle): void;
     _endCallback: (evt: EventTypes.InteractionEventType) => void;
     _dragCallback: (evt: EventTypes.InteractionEventType) => void;
-    cancel: (element: HTMLDivElement) => any;
+    cancel: (element: HTMLDivElement) => string;
     _activateModify: (element: HTMLDivElement) => void;
     _deactivateModify: (element: HTMLDivElement) => void;
     _activateDraw: (element: HTMLDivElement) => void;

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

@@ -5,9 +5,8 @@ import throttle from '../../utilities/throttle';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
 import { triggerAnnotationCompleted, triggerAnnotationModified, } from '../../stateManagement/annotation/helpers/state';
 import { drawHandle as drawHandleSvg, drawLine as drawLineSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, } from '../../drawingSvg';
-import { state } from '../../store';
+import { state } from '../../store/state';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
-import { roundNumber } from '../../utilities';
 import { distanceToPoint } from '../../utilities/math/point';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
@@ -439,23 +438,23 @@ function defaultGetTextLines(data, targetId, configuration) {
     const cachedStats = data.cachedStats[targetId];
     const { xValues, yValues, units, isUnitless, isHorizontal } = cachedStats;
     if (isUnitless) {
-        return [`${roundNumber(xValues[0])} px`];
+        return [`${csUtils.roundNumber(xValues[0])} px`];
     }
     if (configuration.displayBothAxesDistances) {
         const dist1 = Math.abs(xValues[1] - xValues[0]);
         const dist2 = Math.abs(yValues[1] - yValues[0]);
         return [
-            `${roundNumber(dist1)} ${units[0]}`,
-            `${roundNumber(dist2)} ${units[1]}`,
+            `${csUtils.roundNumber(dist1)} ${units[0]}`,
+            `${csUtils.roundNumber(dist2)} ${units[1]}`,
         ];
     }
     if (isHorizontal) {
         const dist = Math.abs(xValues[1] - xValues[0]);
-        return [`${roundNumber(dist)} ${units[0]}`];
+        return [`${csUtils.roundNumber(dist)} ${units[0]}`];
     }
     else {
         const dist = Math.abs(yValues[1] - yValues[0]);
-        return [`${roundNumber(dist)} ${units[1]}`];
+        return [`${csUtils.roundNumber(dist)} ${units[1]}`];
     }
 }
 UltrasoundDirectionalTool.toolName = 'UltrasoundDirectionalTool';

package/dist/esm/tools/annotation/VideoRedactionTool.d.ts

@@ -1,17 +1,16 @@
 import type { Types } from '@cornerstonejs/core';
 import { AnnotationTool } from '../base';
-import { EventTypes, SVGDrawingHelper } from '../../types';
-import { VideoRedactionAnnotation } from '../../types/ToolSpecificAnnotationTypes';
+import type { Annotation, EventTypes, SVGDrawingHelper } from '../../types';
+import type { VideoRedactionAnnotation } from '../../types/ToolSpecificAnnotationTypes';
 declare class VideoRedactionTool extends AnnotationTool {
-    _throttledCalculateCachedStats: any;
+    _throttledCalculateCachedStats: Function;
     editData: {
-        annotation: any;
+        annotation: Annotation;
         viewportUIDsToRender: string[];
         handleIndex?: number;
         newAnnotation?: boolean;
         hasMoved?: boolean;
     } | null;
-    _configuration: any;
     isDrawing: boolean;
     isHandleOutsideImage: boolean;
     constructor(toolConfiguration?: {});

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

@@ -4,7 +4,7 @@ import { AnnotationTool } from '../base';
 import throttle from '../../utilities/throttle';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateManagement';
 import { drawHandles as drawHandlesSvg, drawRedactionRect as drawRedactionRectSvg, } from '../../drawingSvg';
-import { state } from '../../store';
+import { state } from '../../store/state';
 import { Events } from '../../enums';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import * as rectangle from '../../utilities/math/rectangle';

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

@@ -1,6 +1,6 @@
 import { vec3, vec2 } from 'gl-matrix';
 import { getEnabledElement } from '@cornerstonejs/core';
-import { state } from '../../../store';
+import { state } from '../../../store/state';
 import { Events } from '../../../enums';
 import { resetElementCursor, hideElementCursor, } from '../../../cursors/elementCursor';
 import { polyline } from '../../../utilities/math';

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

@@ -1,7 +1,7 @@
 import { getEnabledElement, utilities } from '@cornerstonejs/core';
 import { resetElementCursor, hideElementCursor, } from '../../../cursors/elementCursor';
 import { Events } from '../../../enums';
-import { state } from '../../../store';
+import { state } from '../../../store/state';
 import { vec3 } from 'gl-matrix';
 import { shouldSmooth, getInterpolatedPoints, } from '../../../utilities/planarFreehandROITool/smoothPoints';
 import getMouseModifierKey from '../../../eventDispatchers/shared/getMouseModifier';

package/dist/esm/tools/annotation/planarFreehandROITool/findOpenUShapedContourVectorToPeak.d.ts

@@ -1,4 +1,4 @@
 import type { Types } from '@cornerstonejs/core';
-import { PlanarFreehandROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
+import type { PlanarFreehandROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
 export default function findOpenUShapedContourVectorToPeak(canvasPoints: Types.Point2[], viewport: Types.IStackViewport | Types.IVolumeViewport): Types.Point3[];
 export declare function findOpenUShapedContourVectorToPeakOnRender(enabledElement: Types.IEnabledElement, annotation: PlanarFreehandROIAnnotation): Types.Point3[];

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

@@ -1,12 +1,12 @@
 import { vec3, vec2 } from 'gl-matrix';
 import { getEnabledElement } from '@cornerstonejs/core';
-import { state } from '../../../store';
+import { state } from '../../../store/state';
 import { Events } from '../../../enums';
 import { resetElementCursor, hideElementCursor, } from '../../../cursors/elementCursor';
 import { polyline } from '../../../utilities/math';
 import { shouldSmooth, getInterpolatedPoints, } from '../../../utilities/planarFreehandROITool/smoothPoints';
 import triggerAnnotationRenderForViewportIds from '../../../utilities/triggerAnnotationRenderForViewportIds';
-import { updateContourPolyline } from '../../../utilities/contours';
+import updateContourPolyline from '../../../utilities/contours/updateContourPolyline';
 import findOpenUShapedContourVectorToPeak from './findOpenUShapedContourVectorToPeak';
 import { triggerAnnotationModified } from '../../../stateManagement/annotation/helpers/state';
 const { addCanvasPointsToArray, getSubPixelSpacingAndXYDirections } = polyline;

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

@@ -1,5 +1,5 @@
 import { getEnabledElement } from '@cornerstonejs/core';
-import { state } from '../../../store';
+import { state } from '../../../store/state';
 import { Events } from '../../../enums';
 import { hideElementCursor } from '../../../cursors/elementCursor';
 import { polyline } from '../../../utilities/math';

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

@@ -1,7 +1,7 @@
 import { drawHandles as drawHandlesSvg, drawPolyline as drawPolylineSvg, drawPath as drawPathSvg, } from '../../../drawingSvg';
 import { polyline } from '../../../utilities/math';
 import { findOpenUShapedContourVectorToPeakOnRender } from './findOpenUShapedContourVectorToPeak';
-import { getContourHolesDataCanvas } from '../../../utilities/contours';
+import getContourHolesDataCanvas from '../../../utilities/contours/getContourHolesDataCanvas';
 const { pointsAreWithinCloseContourProximity } = polyline;
 function _getRenderingOptions(enabledElement, annotation) {
     const styleSpecifier = {

package/dist/esm/tools/annotation/splines/CardinalSpline.d.ts

@@ -1,5 +1,5 @@
 import { CubicSpline } from './CubicSpline';
-import { CardinalSplineProps } from '../../../types';
+import type { CardinalSplineProps } from '../../../types';
 declare class CardinalSpline extends CubicSpline {
     private _scale;
     private _fixedScale;

package/dist/esm/tools/annotation/splines/CubicSpline.d.ts

@@ -1,4 +1,4 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 import { Spline } from './Spline';
 import type { SplineCurveSegment } from '../../../types';
 declare abstract class CubicSpline extends Spline {

package/dist/esm/tools/annotation/splines/QuadraticSpline.d.ts

@@ -1,4 +1,4 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 import { Spline } from './Spline';
 import type { SplineLineSegment, SplineCurveSegment } from '../../../types/';
 declare abstract class QuadraticSpline extends Spline {

package/dist/esm/tools/annotation/splines/Spline.d.ts

@@ -1,4 +1,4 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 import type { ISpline, SplineProps, ClosestControlPoint, ClosestSplinePoint, ClosestPoint, ControlPointInfo, SplineCurveSegment } from '../../../types';
 declare abstract class Spline implements ISpline {
     private _controlPoints;

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

@@ -1,13 +1,13 @@
 import type { Types } from '@cornerstonejs/core';
 import BaseTool from './BaseTool';
-import { Annotation, Annotations, SVGDrawingHelper } from '../../types';
-import { StyleSpecifier } from '../../types/AnnotationStyle';
+import type { Annotation, Annotations, SVGDrawingHelper } from '../../types';
+import type { StyleSpecifier } from '../../types/AnnotationStyle';
 declare abstract class AnnotationDisplayTool extends BaseTool {
     static toolName: any;
     abstract renderAnnotation(enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper): any;
     filterInteractableAnnotationsForElement(element: HTMLDivElement, annotations: Annotations): Annotations | undefined;
     onImageSpacingCalibrated: (evt: Types.EventTypes.ImageSpacingCalibratedEvent) => void;
-    protected getReferencedImageId(viewport: Types.IViewport, worldPos: Types.Point3, viewPlaneNormal: Types.Point3, viewUp: Types.Point3): string;
+    protected getReferencedImageId(viewport: Types.IViewport, worldPos: Types.Point3, viewPlaneNormal: Types.Point3, viewUp?: Types.Point3): string;
     getStyle(property: string, specifications: StyleSpecifier, annotation?: Annotation): unknown;
 }
 export default AnnotationDisplayTool;

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

@@ -1,4 +1,4 @@
-import { utilities, getEnabledElement, StackViewport, cache, VideoViewport, } from '@cornerstonejs/core';
+import { utilities, getEnabledElement, StackViewport, cache, VideoViewport, BaseVolumeViewport, } from '@cornerstonejs/core';
 import BaseTool from './BaseTool';
 import { getAnnotationManager } from '../../stateManagement/annotation/annotationState';
 import triggerAnnotationRender from '../../utilities/triggerAnnotationRender';
@@ -43,14 +43,8 @@ class AnnotationDisplayTool extends BaseTool {
     }
     getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp) {
         const targetId = this.getTargetId(viewport);
-        let referencedImageId;
-        if (viewport instanceof StackViewport) {
-            referencedImageId = targetId.split('imageId:')[1];
-        }
-        else if (viewport instanceof VideoViewport) {
-            referencedImageId = targetId.split('videoId:')[1];
-        }
-        else {
+        let referencedImageId = targetId.split(/^[a-zA-Z]+:/)[1];
+        if (viewport instanceof BaseVolumeViewport) {
             const volumeId = utilities.getVolumeId(targetId);
             const imageVolume = cache.getVolume(volumeId);
             referencedImageId = utilities.getClosestImageId(imageVolume, worldPos, viewPlaneNormal);

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

@@ -1,7 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
 import AnnotationDisplayTool from './AnnotationDisplayTool';
-import { Annotation, Annotations, EventTypes, ToolHandle, InteractionTypes, ToolProps, PublicToolProps } from '../../types';
-import { StyleSpecifier } from '../../types/AnnotationStyle';
+import type { Annotation, Annotations, EventTypes, ToolHandle, InteractionTypes, ToolProps, PublicToolProps } from '../../types';
+import type { AnnotationStyle, StyleSpecifier } from '../../types/AnnotationStyle';
 declare abstract class AnnotationTool extends AnnotationDisplayTool {
     static createAnnotation(...annotationBaseData: any[]): Annotation;
     static createAnnotationForViewport(viewport: any, ...annotationBaseData: any[]): Annotation;
@@ -20,18 +20,7 @@ declare abstract class AnnotationTool extends AnnotationDisplayTool {
     protected getAnnotationStyle(context: {
         annotation: Annotation;
         styleSpecifier: StyleSpecifier;
-    }): {
-        visibility: boolean;
-        locked: boolean;
-        color: string;
-        lineWidth: number;
-        lineDash: string;
-        lineOpacity: number;
-        fillColor: string;
-        fillOpacity: number;
-        shadow: boolean;
-        textbox: Record<string, unknown>;
-    };
+    }): AnnotationStyle;
     private _imagePointNearToolOrHandle;
 }
 export default AnnotationTool;

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

@@ -1,14 +1,14 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 import ToolModes from '../../enums/ToolModes';
-import StrategyCallbacks from '../../enums/StrategyCallbacks';
-import { InteractionTypes, ToolProps, PublicToolProps } from '../../types';
+import type StrategyCallbacks from '../../enums/StrategyCallbacks';
+import type { InteractionTypes, ToolProps, PublicToolProps } from '../../types';
 export interface IBaseTool {
     toolGroupId: string;
     supportedInteractionTypes: InteractionTypes[];
     mode: ToolModes;
     configuration: {
         preventHandleOutsideImage?: boolean;
-        strategies?: Record<string, any>;
+        strategies?: Record<string, unknown>;
         defaultStrategy?: string;
         activeStrategy?: string;
         strategyOptions?: Record<string, unknown>;
@@ -26,7 +26,7 @@ declare abstract class BaseTool implements IBaseTool {
     applyActiveStrategyCallback(enabledElement: Types.IEnabledElement, operationData: unknown, callbackType: StrategyCallbacks | string): any;
     setConfiguration(newConfiguration: Record<string, any>): void;
     setActiveStrategy(strategyName: string): void;
-    private getTargetVolumeId;
+    protected getTargetVolumeId(viewport: Types.IViewport): string | undefined;
     protected getTargetIdImage(targetId: string, renderingEngine: Types.IRenderingEngine): Types.IImageData | Types.CPUIImageData | Types.IImageVolume;
     protected getTargetId(viewport: Types.IViewport): string | undefined;
 }

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

@@ -89,7 +89,7 @@ class BaseTool {
         if (viewport instanceof BaseVolumeViewport) {
             return `volumeId:${this.getTargetVolumeId(viewport)}`;
         }
-        throw new Error('getTargetId: viewport must have a getTargetId method');
+        throw new Error('getTargetId: viewport must have a getReferenceId method');
     }
 }
 BaseTool.toolName = 'BaseTool';

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

@@ -1,7 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
 import type { Annotation, ContourAnnotation, EventTypes, PublicToolProps, ToolProps, SVGDrawingHelper, AnnotationRenderContext } from '../../types';
 import AnnotationTool from './AnnotationTool';
-import { ContourWindingDirection } from '../../types/ContourAnnotation';
+import type { ContourWindingDirection } from '../../types/ContourAnnotation';
 declare abstract class ContourBaseTool extends AnnotationTool {
     constructor(toolProps: PublicToolProps, defaultToolProps: ToolProps);
     renderAnnotation(enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper): boolean;

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

@@ -2,8 +2,8 @@ import { getEnabledElement } from '@cornerstonejs/core';
 import { addAnnotation, getAnnotations, getChildAnnotations, } from '../../stateManagement/annotation/annotationState';
 import { drawPath as drawPathSvg } from '../../drawingSvg';
 import AnnotationTool from './AnnotationTool';
-import { updateContourPolyline } from '../../utilities/contours/';
-import { getContourHolesDataCanvas } from '../../utilities/contours';
+import updateContourPolyline from '../../utilities/contours/updateContourPolyline';
+import getContourHolesDataCanvas from '../../utilities/contours/getContourHolesDataCanvas';
 class ContourBaseTool extends AnnotationTool {
     constructor(toolProps, defaultToolProps) {
         super(toolProps, defaultToolProps);
@@ -138,11 +138,11 @@ class ContourBaseTool extends AnnotationTool {
         const childContours = getContourHolesDataCanvas(annotation, viewport);
         const allContours = [polylineCanvasPoints, ...childContours];
         drawPathSvg(svgDrawingHelper, annotationUID, 'contourPolyline', allContours, {
-            color,
-            lineDash,
+            color: color,
+            lineDash: lineDash,
             lineWidth: Math.max(0.1, lineWidth),
             fillColor: fillColor,
-            fillOpacity,
+            fillOpacity: fillOpacity,
         });
         return true;
     }

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

@@ -1,13 +1,22 @@
 import { getEnabledElement, utilities } from '@cornerstonejs/core';
-import { config as segmentationConfig, state as segmentationState, segmentLocking, segmentIndex as segmentIndexController, activeSegmentation, } from '../../stateManagement/segmentation';
+import { getGlobalConfig, getSegmentationRepresentationConfig, getSegmentIndexConfig, } from '../../stateManagement/segmentation/config/segmentationConfig';
+import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
 import { SegmentationRepresentations } from '../../enums';
 import ContourBaseTool from './ContourBaseTool';
 import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
-import { InterpolationManager } from '../../utilities/contours/interpolation';
+import InterpolationManager from '../../utilities/segmentation/InterpolationManager/InterpolationManager';
 import { addContourSegmentationAnnotation, removeContourSegmentationAnnotation, } from '../../utilities/contourSegmentation';
-import { triggerAnnotationRenderForToolGroupIds } from '../../utilities';
-import { getActiveRepresentation, getRepresentationsBySegmentationId, getRepresentationsForViewport, getViewportIdsWithSegmentationId, } from '../../stateManagement/segmentation/segmentationState';
+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 { 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';
 class ContourSegmentationBaseTool extends ContourBaseTool {
     constructor(toolProps, defaultToolProps) {
         super(toolProps, defaultToolProps);
@@ -30,7 +39,7 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
         if (!this.isContourSegmentationTool()) {
             return contourAnnotation;
         }
-        const activeSeg = activeSegmentation.getActiveRepresentation(viewport.id);
+        const activeSeg = getActiveSegmentationRepresentation(viewport.id);
         if (!activeSeg) {
             throw new Error('No active segmentation detected, create one before using scissors tool');
         }
@@ -39,7 +48,7 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
             throw new Error(`A contour segmentation must be active`);
         }
         const { segmentationId } = activeSeg;
-        const segmentIndex = segmentIndexController.getActiveSegmentIndex(segmentationId);
+        const segmentIndex = getActiveSegmentIndex(segmentationId);
         return utilities.deepMerge(contourAnnotation, {
             data: {
                 segmentation: {
@@ -78,7 +87,7 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
         if (invalidated && this.isContourSegmentationTool()) {
             const { segmentationId } = (annotation).data.segmentation;
             triggerSegmentationDataModified(segmentationId);
-            const viewportIds = getViewportIdsWithSegmentationId(segmentationId);
+            const viewportIds = getViewportIdsWithSegmentation(segmentationId);
             const toolGroupIds = viewportIds.map((viewportId) => {
                 const toolGroup = getToolGroupForViewport(viewportId);
                 return toolGroup.id;
@@ -90,15 +99,15 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
     _getContourSegmentationStyle(context) {
         const annotation = context.annotation;
         const { segmentationId, segmentIndex } = annotation.data.segmentation;
-        const segmentation = segmentationState.getSegmentation(segmentationId);
-        const segmentationRepresentations = getRepresentationsBySegmentationId(segmentationId);
+        const segmentation = getSegmentation(segmentationId);
+        const segmentationRepresentations = getSegmentationRepresentationsForSegmentation(segmentationId);
         if (!segmentationRepresentations?.length) {
             return {};
         }
         const allUIDs = segmentationRepresentations.map((rep) => rep.segmentationRepresentationUID);
         let segmentationRepresentation;
         if (segmentationRepresentations.length > 1) {
-            const viewportReps = getRepresentationsForViewport(context.styleSpecifier.viewportId);
+            const viewportReps = getSegmentationRepresentations(context.styleSpecifier.viewportId);
             segmentationRepresentation = viewportReps.find((rep) => rep.segmentationId === segmentationId &&
                 allUIDs.includes(rep.segmentationRepresentationUID));
         }
@@ -107,19 +116,19 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
         }
         const { segmentationRepresentationUID } = segmentationRepresentation;
         const { autoGenerated } = annotation;
-        const segmentsLocked = segmentLocking.getLockedSegments(segmentationId);
+        const segmentsLocked = getLockedSegmentIndices(segmentationId);
         const annotationLocked = segmentsLocked.includes(segmentIndex);
-        const segmentColor = segmentationConfig.color.getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
+        const segmentColor = getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
         const viewportId = context.styleSpecifier.viewportId;
-        const segmentationVisible = segmentationConfig.visibility.getRepresentationVisibility(viewportId, segmentationRepresentationUID);
-        const globalConfig = segmentationConfig.getGlobalConfig();
-        const getAllSegmentsConfig = segmentationConfig.getAllSegmentsConfig(segmentationRepresentationUID);
-        const segmentConfig = segmentationConfig.getSegmentIndexConfig(segmentationRepresentationUID, segmentIndex);
-        const segmentVisible = segmentationConfig.visibility.getSegmentIndexVisibility(viewportId, segmentationRepresentationUID, segmentIndex);
-        const activeSegRep = getActiveRepresentation(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 ?? {}, getAllSegmentsConfig?.CONTOUR ?? {}, segmentConfig?.CONTOUR ?? {});
+        const mergedConfig = Object.assign({}, globalConfig?.representations?.CONTOUR ?? {}, segmentationRepresentationConfig?.CONTOUR ?? {}, segmentConfig?.CONTOUR ?? {});
         let lineWidth = 1;
         let lineDash = undefined;
         let lineOpacity = 1;

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

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

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

@@ -1,5 +1,5 @@
-import { StackViewport, Types } from '@cornerstonejs/core';
-import { ContourRepresentation } from '../../../types/SegmentationStateTypes';
+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 render(viewport: StackViewport | Types.IVolumeViewport, contourRepresentation: ContourRepresentation): Promise<void>;
 declare const _default: {

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

@@ -1,9 +1,11 @@
-import { getEnabledElementByViewportId, } from '@cornerstonejs/core';
+import { getEnabledElementByViewportId } from '@cornerstonejs/core';
 import Representations from '../../../enums/SegmentationRepresentations';
-import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
 import { deleteConfigCache } from './contourHandler/contourConfigCache';
-import { polySeg } from '../../../stateManagement/segmentation';
 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';
 let polySegConversionInProgress = false;
 function removeRepresentation(viewportId, segmentationRepresentationUID, renderImmediate = false) {
     const enabledElement = getEnabledElementByViewportId(viewportId);
@@ -11,7 +13,7 @@ function removeRepresentation(viewportId, segmentationRepresentationUID, renderI
         return;
     }
     const { viewport } = enabledElement;
-    SegmentationState.removeRepresentation(segmentationRepresentationUID);
+    _removeRepresentation(segmentationRepresentationUID);
     deleteConfigCache(segmentationRepresentationUID);
     if (!renderImmediate) {
         return;
@@ -20,16 +22,16 @@ function removeRepresentation(viewportId, segmentationRepresentationUID, renderI
 }
 async function render(viewport, contourRepresentation) {
     const { segmentationId } = contourRepresentation;
-    const segmentation = SegmentationState.getSegmentation(segmentationId);
+    const segmentation = getSegmentation(segmentationId);
     if (!segmentation) {
         return;
     }
     let contourData = segmentation.representationData[Representations.Contour];
     if (!contourData &&
-        polySeg.canComputeRequestedRepresentation(contourRepresentation.segmentationRepresentationUID) &&
+        canComputeRequestedRepresentation(contourRepresentation.segmentationRepresentationUID) &&
         !polySegConversionInProgress) {
         polySegConversionInProgress = true;
-        contourData = await polySeg.computeAndAddContourRepresentation(segmentationId, {
+        contourData = await computeAndAddContourRepresentation(segmentationId, {
             segmentationRepresentationUID: contourRepresentation.segmentationRepresentationUID,
             viewport,
         });

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

@@ -1,5 +1,5 @@
-import { Types, StackViewport } from '@cornerstonejs/core';
-import { ContourRepresentation } from '../../../../types/SegmentationStateTypes';
+import type { Types, StackViewport } from '@cornerstonejs/core';
+import type { 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;

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

@@ -1,12 +1,12 @@
-import { addAnnotation } from '../../../../stateManagement';
+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/segmentationState';
-import { getSegmentsHidden } from '../../../../stateManagement/segmentation/config/segmentationVisibility';
-import { getSegmentIndexConfig } from '../../../../stateManagement/segmentation/config';
+import { getGlobalConfig } from '../../../../stateManagement/segmentation/getGlobalConfig';
+import { getHiddenSegmentIndices } from '../../../../stateManagement/segmentation/config/segmentationVisibility';
+import { getSegmentIndexConfig } from '../../../../stateManagement/segmentation/config/segmentationConfig';
 function handleContourSegmentation(viewport, geometryIds, annotationUIDsMap, contourRepresentation) {
     const addOrUpdateFn = annotationUIDsMap.size
         ? updateContourSets
@@ -27,7 +27,7 @@ function updateContourSets(viewport, geometryIds, contourRepresentation) {
     }
     const segmentsToSetToInvisible = [];
     const segmentsToSetToVisible = [];
-    const segmentsHidden = getSegmentsHidden(viewport.id, segmentationRepresentationUID);
+    const segmentsHidden = getHiddenSegmentIndices(viewport.id, segmentationRepresentationUID);
     for (const segmentIndex of segmentsHidden) {
         if (!cachedConfig.segmentsHidden.has(segmentIndex)) {
             segmentsToSetToInvisible.push(segmentIndex);
@@ -116,7 +116,7 @@ function addContourSetsToElement(viewport, geometryIds, contourRepresentation) {
     const globalContourConfig = getGlobalConfig().representations.CONTOUR;
     const newContourConfig = utilities.deepMerge(globalContourConfig, baseConfig);
     const outlineWidthActive = newContourConfig.outlineWidthActive;
-    const segmentsHidden = getSegmentsHidden(viewport.id, segmentationRepresentationUID);
+    const segmentsHidden = getHiddenSegmentIndices(viewport.id, segmentationRepresentationUID);
     setConfigCache(segmentationRepresentationUID, Object.assign({}, getConfigCache(segmentationRepresentationUID), {
         segmentsHidden: new Set(segmentsHidden),
         segmentSpecificMap,

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

@@ -1,4 +1,4 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
 export declare function validateGeometry(geometry: Types.IGeometry): void;
 export declare function getPolyData(contourSet: Types.IContourSet): vtkPolyData;

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

@@ -1,7 +1,7 @@
-import { getRepresentation, getSegmentation, } from '../../../stateManagement/segmentation/segmentationState';
+import { getSegmentationRepresentation, getSegmentation, } from '../../../stateManagement/segmentation/segmentationState';
 import { removeAnnotation } from '../../../stateManagement';
 function removeContourFromElement(element, segmentationRepresentationUID, removeFromCache = false) {
-    const segmentationRepresentation = getRepresentation(segmentationRepresentationUID);
+    const segmentationRepresentation = getSegmentationRepresentation(segmentationRepresentationUID);
     const { segmentationId } = segmentationRepresentation;
     const segmentation = getSegmentation(segmentationId);
     const { annotationUIDsMap } = segmentation.representationData.CONTOUR;

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

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

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

@@ -1,6 +1,7 @@
 import { getEnabledElement, addVolumesToViewports, addImageSlicesToViewports, Enums, } from '@cornerstonejs/core';
 import { isVolumeSegmentation } from '../../segmentation/strategies/utils/stackVolumeCheck';
-import { getLabelmapImageIdsForViewport, getRepresentation, } from '../../../stateManagement/segmentation/segmentationState';
+import { getSegmentationRepresentation } from '../../../stateManagement/segmentation/getSegmentationRepresentation';
+import { getCurrentLabelmapImageIdForViewport } from '../../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
 async function addLabelmapToElement(element, labelMapData, segmentationRepresentationUID) {
     const enabledElement = getEnabledElement(element);
     const { renderingEngine, viewport } = enabledElement;
@@ -20,8 +21,8 @@ async function addLabelmapToElement(element, labelMapData, segmentationRepresent
         await addVolumesToViewports(renderingEngine, volumeInputs, [viewportId], immediateRender, suppressEvents);
     }
     else {
-        const representation = getRepresentation(segmentationRepresentationUID);
-        const segmentationImageId = getLabelmapImageIdsForViewport(viewport.id, representation.segmentationId);
+        const representation = getSegmentationRepresentation(segmentationRepresentationUID);
+        const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, representation.segmentationId);
         const stackInputs = [
             {
                 imageId: segmentationImageId,

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

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