@cornerstonejs/tools 2.0.0-beta.21 → 2.0.0-beta.23

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

@@ -1,14 +1,13 @@
 import { AnnotationTool } from '../base';
 import { getEnabledElement, VolumeViewport, utilities as csUtils, } from '@cornerstonejs/core';
 import { getCalibratedLengthUnitsAndScale } from '../../utilities/getCalibratedUnits';
-import { roundNumber } from '../../utilities';
 import throttle from '../../utilities/throttle';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateManagement';
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
 import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
 import { triggerAnnotationCompleted, triggerAnnotationModified, } from '../../stateManagement/annotation/helpers/state';
 import { drawHandles as drawHandlesSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, drawRectByCoordinates as drawRectSvg, } 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';
@@ -347,14 +346,14 @@ class RectangleROITool extends AnnotationTool {
                 });
                 const { viewPlaneNormal, viewUp } = viewport.getCamera();
                 if (!data.cachedStats[targetId] ||
-                    data.cachedStats[targetId].areaUnits == null) {
+                    data.cachedStats[targetId].areaUnit == null) {
                     data.cachedStats[targetId] = {
                         Modality: null,
                         area: null,
                         max: null,
                         mean: null,
                         stdDev: null,
-                        areaUnits: null,
+                        areaUnit: null,
                     };
                     this._calculateCachedStats(annotation, viewPlaneNormal, viewUp, renderingEngine, enabledElement);
                 }
@@ -488,13 +487,13 @@ class RectangleROITool extends AnnotationTool {
                     ];
                     const { worldWidth, worldHeight } = getWorldWidthAndHeightFromCorners(viewPlaneNormal, viewUp, worldPos1, worldPos2);
                     const handles = [pos1Index, pos2Index];
-                    const { scale, areaUnits } = getCalibratedLengthUnitsAndScale(image, handles);
+                    const { scale, areaUnit } = getCalibratedLengthUnitsAndScale(image, handles);
                     const area = Math.abs(worldWidth * worldHeight) / (scale * scale);
                     const pixelUnitsOptions = {
                         isPreScaled: isViewportPreScaled(viewport, targetId),
                         isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
                     };
-                    const pixelValueUnits = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
+                    const modalityUnit = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
                     const pointsInShape = voxelManager.forEach(this.configuration.statsCalculator.statsCallback, {
                         boundsIJK,
                         imageData,
@@ -509,8 +508,8 @@ class RectangleROITool extends AnnotationTool {
                         max: stats.max?.value,
                         statsArray: stats.array,
                         pointsInShape: pointsInShape,
-                        areaUnits,
-                        pixelValueUnits,
+                        areaUnit,
+                        modalityUnit,
                     };
                 }
                 else {
@@ -533,15 +532,15 @@ class RectangleROITool extends AnnotationTool {
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { area, mean, max, stdDev, areaUnits, pixelValueUnits } = cachedVolumeStats;
+    const { area, mean, max, stdDev, areaUnit, modalityUnit } = cachedVolumeStats;
     if (mean === undefined) {
         return;
     }
     const textLines = [];
-    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}`);
+    textLines.push(`Area: ${csUtils.roundNumber(area)} ${areaUnit}`);
+    textLines.push(`Mean: ${csUtils.roundNumber(mean)} ${modalityUnit}`);
+    textLines.push(`Max: ${csUtils.roundNumber(max)} ${modalityUnit}`);
+    textLines.push(`Std Dev: ${csUtils.roundNumber(stdDev)} ${modalityUnit}`);
     return textLines;
 }
 RectangleROITool.toolName = 'RectangleROI';

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

@@ -2,19 +2,22 @@ import { getEnabledElement, eventTarget, triggerEvent, utilities, } from '@corne
 import { vec3 } from 'gl-matrix';
 import { getChildAnnotations, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
 import { drawHandles as drawHandlesSvg, drawPolyline as drawPolylineSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, } from '../../drawingSvg';
-import { state } from '../../store';
+import { state } from '../../store/state';
 import { Events, MouseBindings, KeyboardBindings, ChangeTypes, } from '../../enums';
 import { resetElementCursor } from '../../cursors/elementCursor';
-import { math, throttle, roundNumber, triggerAnnotationRenderForViewportIds, getCalibratedLengthUnitsAndScale, } from '../../utilities';
-import getMouseModifierKey from '../../eventDispatchers/shared/getMouseModifier';
+import * as math from '../../utilities/math';
+import throttle from '../../utilities/throttle';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
+import { getCalibratedLengthUnitsAndScale } from '../../utilities/getCalibratedUnits';
+import getMouseModifierKey from '../../eventDispatchers/shared/getMouseModifier';
 import { ContourWindingDirection } from '../../types/ContourAnnotation';
 import { CardinalSpline } from './splines/CardinalSpline';
 import { LinearSpline } from './splines/LinearSpline';
 import { CatmullRomSpline } from './splines/CatmullRomSpline';
 import { BSpline } from './splines/BSpline';
 import ContourSegmentationBaseTool from '../base/ContourSegmentationBaseTool';
+import { triggerAnnotationRenderForViewportIds } from '../../utilities';
 const SPLINE_MIN_POINTS = 3;
 const SPLINE_CLICK_CLOSE_CURVE_DIST = 10;
 const DEFAULT_SPLINE_CONFIG = {
@@ -449,7 +452,7 @@ class SplineROITool extends ContourSegmentationBaseTool {
                 const deltaInX = vec3.distance(originalWorldPoint, deltaXPoint);
                 const deltaInY = vec3.distance(originalWorldPoint, deltaYPoint);
                 const { imageData } = image;
-                const { scale, areaUnits } = getCalibratedLengthUnitsAndScale(image, () => {
+                const { scale, areaUnit } = getCalibratedLengthUnitsAndScale(image, () => {
                     const { maxX: canvasMaxX, maxY: canvasMaxY, minX: canvasMinX, minY: canvasMinY, } = math.polyline.getAABB(canvasCoordinates);
                     const topLeftBBWorld = viewport.canvasToWorld([
                         canvasMinX,
@@ -468,7 +471,7 @@ class SplineROITool extends ContourSegmentationBaseTool {
                 cachedStats[targetId] = {
                     Modality: metadata.Modality,
                     area,
-                    areaUnits,
+                    areaUnit,
                 };
             }
             this.triggerAnnotationModified(annotation, enabledElement, ChangeTypes.StatsUpdated);
@@ -557,11 +560,11 @@ class SplineROITool extends ContourSegmentationBaseTool {
         });
         super.renderAnnotationInstance(renderContext);
         if (!data.cachedStats[targetId] ||
-            data.cachedStats[targetId].areaUnits == null) {
+            data.cachedStats[targetId].areaUnit == null) {
             data.cachedStats[targetId] = {
                 Modality: null,
                 area: null,
-                areaUnits: null,
+                areaUnit: null,
             };
             this._calculateCachedStats(annotation, element);
         }
@@ -712,12 +715,12 @@ class SplineROITool extends ContourSegmentationBaseTool {
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { area, isEmptyArea, areaUnits } = cachedVolumeStats;
+    const { area, isEmptyArea, areaUnit } = cachedVolumeStats;
     const textLines = [];
     if (area) {
         const areaLine = isEmptyArea
             ? `Area: Oblique not supported`
-            : `Area: ${roundNumber(area)} ${areaUnits}`;
+            : `Area: ${utilities.roundNumber(area)} ${areaUnit}`;
         textLines.push(areaLine);
     }
     return textLines;

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.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/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/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);

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 { getActiveSegmentationRepresentation, getSegmentationRepresentationsForSegmentation, getSegmentationRepresentations, getViewportIdsWithSegmentation, } 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.getActiveSegmentationRepresentation(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: {
@@ -90,7 +99,7 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
     _getContourSegmentationStyle(context) {
         const annotation = context.annotation;
         const { segmentationId, segmentIndex } = annotation.data.segmentation;
-        const segmentation = segmentationState.getSegmentation(segmentationId);
+        const segmentation = getSegmentation(segmentationId);
         const segmentationRepresentations = getSegmentationRepresentationsForSegmentation(segmentationId);
         if (!segmentationRepresentations?.length) {
             return {};
@@ -107,19 +116,19 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
         }
         const { segmentationRepresentationUID } = segmentationRepresentation;
         const { autoGenerated } = annotation;
-        const segmentsLocked = segmentLocking.getLockedSegmentIndices(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.getSegmentationRepresentationVisibility(viewportId, segmentationRepresentationUID);
-        const globalConfig = segmentationConfig.getGlobalConfig();
-        const getSegmentationRepresentationConfig = segmentationConfig.getSegmentationRepresentationConfig(segmentationRepresentationUID);
-        const segmentConfig = segmentationConfig.getSegmentIndexConfig(segmentationRepresentationUID, segmentIndex);
-        const segmentVisible = segmentationConfig.visibility.getSegmentIndexVisibility(viewportId, segmentationRepresentationUID, segmentIndex);
+        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 ?? {}, getSegmentationRepresentationConfig?.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/contourDisplay.js

@@ -1,10 +1,11 @@
-import { getEnabledElementByIds, getEnabledElementByViewportId, } from '@cornerstonejs/core';
+import { getEnabledElementByViewportId } from '@cornerstonejs/core';
 import Representations from '../../../enums/SegmentationRepresentations';
-import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
-import removeContourFromElement from './removeContourFromElement';
 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);
@@ -12,7 +13,7 @@ function removeRepresentation(viewportId, segmentationRepresentationUID, renderI
         return;
     }
     const { viewport } = enabledElement;
-    SegmentationState.removeRepresentation(segmentationRepresentationUID);
+    _removeRepresentation(segmentationRepresentationUID);
     deleteConfigCache(segmentationRepresentationUID);
     if (!renderImmediate) {
         return;
@@ -21,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.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, getPerSegmentConfig, } from '../../../../stateManagement/segmentation/segmentationState';
+import { getGlobalConfig } from '../../../../stateManagement/segmentation/getGlobalConfig';
 import { getHiddenSegmentIndices } from '../../../../stateManagement/segmentation/config/segmentationVisibility';
-import { getSegmentIndexConfig } from '../../../../stateManagement/segmentation/config';
+import { getSegmentIndexConfig } from '../../../../stateManagement/segmentation/config/segmentationConfig';
 function handleContourSegmentation(viewport, geometryIds, annotationUIDsMap, contourRepresentation) {
     const addOrUpdateFn = annotationUIDsMap.size
         ? updateContourSets

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 { getCurrentLabelmapImageIdForViewport, getSegmentationRepresentation, } 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;

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

@@ -1,17 +1,10 @@
-import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
-import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
 import type { Types } from '@cornerstonejs/core';
 import type { LabelmapRepresentation } from '../../../types/SegmentationStateTypes';
-declare function getSegmentationRepresentationRenderingConfig(): {
-    ofun: vtkPiecewiseFunction;
-    cfun: vtkColorTransferFunction;
-};
 declare function removeRepresentation(viewportId: string, segmentationRepresentationUID: string, renderImmediate?: boolean): void;
 declare function render(viewport: Types.IStackViewport | Types.IVolumeViewport, representation: LabelmapRepresentation): Promise<void>;
 declare const _default: {
-    getSegmentationRepresentationRenderingConfig: typeof getSegmentationRepresentationRenderingConfig;
     render: typeof render;
     removeRepresentation: typeof removeRepresentation;
 };
 export default _default;
-export { getSegmentationRepresentationRenderingConfig, render, removeRepresentation, };
+export { render, removeRepresentation };

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

@@ -1,24 +1,19 @@
-import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunction';
-import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
 import { cache, getEnabledElementByViewportId, StackViewport, VolumeViewport, } from '@cornerstonejs/core';
 import Representations from '../../../enums/SegmentationRepresentations';
-import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
 import addLabelmapToElement from './addLabelmapToElement';
 import removeLabelmapFromElement from './removeLabelmapFromElement';
 import { isVolumeSegmentation } from '../../segmentation/strategies/utils/stackVolumeCheck';
-import { polySeg } from '../../../stateManagement/segmentation';
 import { getHiddenSegmentIndices } from '../../../stateManagement/segmentation/config/segmentationVisibility';
+import { removeRepresentation as _removeRepresentation } from '../../../stateManagement/segmentation/removeRepresentation';
+import { getActiveSegmentationRepresentation } from '../../../stateManagement/segmentation/getActiveSegmentationRepresentation';
+import { getColorLUT } from '../../../stateManagement/segmentation/getColorLUT';
+import { getCurrentLabelmapImageIdForViewport } from '../../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
+import { getGlobalConfig } from '../../../stateManagement/segmentation/getGlobalConfig';
+import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
+import { canComputeRequestedRepresentation } from '../../../stateManagement/segmentation/polySeg/canComputeRequestedRepresentation';
+import { computeAndAddLabelmapRepresentation } from '../../../stateManagement/segmentation/polySeg/Labelmap/computeAndAddLabelmapRepresentation';
 const MAX_NUMBER_COLORS = 255;
 const labelMapConfigCache = new Map();
-function getSegmentationRepresentationRenderingConfig() {
-    const cfun = vtkColorTransferFunction.newInstance();
-    const ofun = vtkPiecewiseFunction.newInstance();
-    ofun.addPoint(0, 0);
-    return {
-        ofun,
-        cfun,
-    };
-}
 let polySegConversionInProgress = false;
 function removeRepresentation(viewportId, segmentationRepresentationUID, renderImmediate = false) {
     const enabledElement = getEnabledElementByViewportId(viewportId);
@@ -27,7 +22,7 @@ function removeRepresentation(viewportId, segmentationRepresentationUID, renderI
     }
     const { viewport } = enabledElement;
     removeLabelmapFromElement(viewport.element, segmentationRepresentationUID);
-    SegmentationState.removeRepresentation(segmentationRepresentationUID);
+    _removeRepresentation(segmentationRepresentationUID);
     if (!renderImmediate) {
         return;
     }
@@ -55,7 +50,7 @@ function isSameFrameOfReference(viewport, referencedVolumeId) {
 }
 async function render(viewport, representation) {
     const { segmentationId, segmentationRepresentationUID } = representation;
-    const segmentation = SegmentationState.getSegmentation(segmentationId);
+    const segmentation = getSegmentation(segmentationId);
     if (!segmentation) {
         console.warn('No segmentation found for segmentationId: ', segmentationId);
         return;
@@ -63,10 +58,10 @@ async function render(viewport, representation) {
     let labelmapData = segmentation.representationData[Representations.Labelmap];
     let actorEntry = viewport.getActor(segmentationRepresentationUID);
     if (!labelmapData &&
-        polySeg.canComputeRequestedRepresentation(segmentationRepresentationUID) &&
+        canComputeRequestedRepresentation(segmentationRepresentationUID) &&
         !polySegConversionInProgress) {
         polySegConversionInProgress = true;
-        labelmapData = await polySeg.computeAndAddLabelmapRepresentation(segmentationId, {
+        labelmapData = await computeAndAddLabelmapRepresentation(segmentationId, {
             segmentationRepresentationUID,
             viewport,
         });
@@ -99,7 +94,7 @@ async function render(viewport, representation) {
         if (viewport instanceof VolumeViewport) {
             return;
         }
-        const labelmapImageId = SegmentationState.getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
+        const labelmapImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
         if (!labelmapImageId) {
             return;
         }
@@ -115,19 +110,19 @@ async function render(viewport, representation) {
 }
 function _setLabelmapColorAndOpacity(viewportId, actorEntry, segmentationRepresentation) {
     const { rendering, config, colorLUTIndex } = segmentationRepresentation;
-    const activeSegRep = SegmentationState.getActiveSegmentationRepresentation(viewportId);
+    const activeSegRep = getActiveSegmentationRepresentation(viewportId);
     const isActiveLabelmap = activeSegRep === segmentationRepresentation;
     const { cfun, ofun } = rendering;
     const { allSegments, perSegment } = config;
-    const globalLabelmapConfig = SegmentationState.getGlobalConfig().representations[Representations.Labelmap];
-    const globalConfig = SegmentationState.getGlobalConfig();
+    const globalLabelmapConfig = getGlobalConfig().representations[Representations.Labelmap];
+    const globalConfig = getGlobalConfig();
     const renderInactiveRepresentations = globalConfig.renderInactiveRepresentations;
     const configToUse = {
         ...globalLabelmapConfig,
         ...allSegments[Representations.Labelmap],
     };
     const labelmapConfig = configToUse;
-    const colorLUT = SegmentationState.getColorLUT(colorLUTIndex);
+    const colorLUT = getColorLUT(colorLUTIndex);
     const numColors = Math.min(256, colorLUT.length);
     const { uid: actorUID } = actorEntry;
     const { outlineWidth, renderOutline, outlineOpacity, activeSegmentOutlineWidthDelta, } = _getLabelmapConfig(labelmapConfig, isActiveLabelmap);
@@ -167,7 +162,7 @@ function _setLabelmapColorAndOpacity(viewportId, actorEntry, segmentationReprese
     actor.getProperty().setInterpolationTypeToNearest();
     actor.getProperty().setUseLabelOutline(renderOutline);
     actor.getProperty().setLabelOutlineOpacity(outlineOpacity);
-    const { activeSegmentIndex } = SegmentationState.getSegmentation(segmentationRepresentation.segmentationId);
+    const { activeSegmentIndex } = getSegmentation(segmentationRepresentation.segmentationId);
     const outlineWidths = new Array(numColors - 1);
     for (let i = 1; i < numColors; i++) {
         const isHidden = segmentsHidden.has(i);
@@ -256,8 +251,7 @@ async function _addLabelmapToViewport(viewport, labelmapData, segmentationRepres
     await addLabelmapToElement(viewport.element, labelmapData, segmentationRepresentationUID);
 }
 export default {
-    getSegmentationRepresentationRenderingConfig,
     render,
     removeRepresentation,
 };
-export { getSegmentationRepresentationRenderingConfig, render, removeRepresentation, };
+export { render, removeRepresentation };

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

@@ -1,9 +1,12 @@
 import { cache, getEnabledElementByViewportId, VolumeViewport3D, } from '@cornerstonejs/core';
-import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
 import Representations from '../../../enums/SegmentationRepresentations';
+import { removeRepresentation as _removeRepresentation } from '../../../stateManagement/segmentation/removeRepresentation';
 import removeSurfaceFromElement from './removeSurfaceFromElement';
 import addOrUpdateSurfaceToElement from './addOrUpdateSurfaceToElement';
-import { polySeg } from '../../../stateManagement/segmentation';
+import { getSegmentation } from '../../../stateManagement/segmentation/getSegmentation';
+import { getColorLUT } from '../../../stateManagement/segmentation/getColorLUT';
+import { canComputeRequestedRepresentation } from '../../../stateManagement/segmentation/polySeg/canComputeRequestedRepresentation';
+import { computeAndAddSurfaceRepresentation } from '../../../stateManagement/segmentation/polySeg';
 function removeRepresentation(viewportId, segmentationRepresentationUID, renderImmediate = false) {
     const enabledElement = getEnabledElementByViewportId(viewportId);
     if (!enabledElement) {
@@ -11,7 +14,7 @@ function removeRepresentation(viewportId, segmentationRepresentationUID, renderI
     }
     const { viewport } = enabledElement;
     removeSurfaceFromElement(viewport.element, segmentationRepresentationUID);
-    SegmentationState.removeRepresentation(segmentationRepresentationUID);
+    _removeRepresentation(segmentationRepresentationUID);
     if (!renderImmediate) {
         return;
     }
@@ -19,7 +22,7 @@ function removeRepresentation(viewportId, segmentationRepresentationUID, renderI
 }
 async function render(viewport, representation) {
     const { colorLUTIndex, segmentationId, segmentationRepresentationUID } = representation;
-    const segmentation = SegmentationState.getSegmentation(segmentationId);
+    const segmentation = getSegmentation(segmentationId);
     if (!segmentation) {
         return;
     }
@@ -28,8 +31,8 @@ async function render(viewport, representation) {
     }
     let SurfaceData = segmentation.representationData[Representations.Surface];
     if (!SurfaceData &&
-        polySeg.canComputeRequestedRepresentation(segmentationRepresentationUID)) {
-        SurfaceData = await polySeg.computeAndAddSurfaceRepresentation(segmentationId, {
+        canComputeRequestedRepresentation(segmentationRepresentationUID)) {
+        SurfaceData = await computeAndAddSurfaceRepresentation(segmentationId, {
             segmentationRepresentationUID,
         });
         if (!SurfaceData) {
@@ -40,7 +43,7 @@ async function render(viewport, representation) {
     if (!geometryIds?.size) {
         console.warn(`No Surfaces found for segmentationId ${segmentationId}. Skipping render.`);
     }
-    const colorLUT = SegmentationState.getColorLUT(colorLUTIndex);
+    const colorLUT = getColorLUT(colorLUTIndex);
     const surfaces = [];
     geometryIds.forEach((geometryId, segmentIndex) => {
         const geometry = cache.getGeometry(geometryId);