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

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

@@ -5,7 +5,6 @@ import WindowLevelTool from './WindowLevelTool';
 import WindowLevelRegionTool from './WindowLevelRegionTool';
 import StackScrollTool from './StackScrollTool';
 import PlanarRotateTool from './PlanarRotateTool';
-import StackScrollMouseWheelTool from './StackScrollToolMouseWheelTool';
 import ZoomTool from './ZoomTool';
 import VolumeRotateMouseWheelTool from './VolumeRotateMouseWheelTool';
 import MIPJumpToClickTool from './MIPJumpToClickTool';
@@ -16,7 +15,6 @@ import ReferenceLinesTool from './ReferenceLinesTool';
 import OverlayGridTool from './OverlayGridTool';
 import SegmentationIntersectionTool from './SegmentationIntersectionTool';
 import ReferenceCursors from './ReferenceCursors';
-import ReferenceLines from './ReferenceLinesTool';
 import ScaleOverlayTool from './ScaleOverlayTool';
 import SculptorTool from './SculptorTool';
 import BidirectionalTool from './annotation/BidirectionalTool';
@@ -49,4 +47,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, HeightTool, 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, };
+export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LengthTool, HeightTool, 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, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, };

package/dist/esm/tools/index.js

@@ -5,7 +5,6 @@ import WindowLevelTool from './WindowLevelTool';
 import WindowLevelRegionTool from './WindowLevelRegionTool';
 import StackScrollTool from './StackScrollTool';
 import PlanarRotateTool from './PlanarRotateTool';
-import StackScrollMouseWheelTool from './StackScrollToolMouseWheelTool';
 import ZoomTool from './ZoomTool';
 import VolumeRotateMouseWheelTool from './VolumeRotateMouseWheelTool';
 import MIPJumpToClickTool from './MIPJumpToClickTool';
@@ -16,7 +15,6 @@ import ReferenceLinesTool from './ReferenceLinesTool';
 import OverlayGridTool from './OverlayGridTool';
 import SegmentationIntersectionTool from './SegmentationIntersectionTool';
 import ReferenceCursors from './ReferenceCursors';
-import ReferenceLines from './ReferenceLinesTool';
 import ScaleOverlayTool from './ScaleOverlayTool';
 import SculptorTool from './SculptorTool';
 import BidirectionalTool from './annotation/BidirectionalTool';
@@ -49,4 +47,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, HeightTool, 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, };
+export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, VolumeRotateMouseWheelTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LengthTool, HeightTool, 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, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, };

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

@@ -9,9 +9,11 @@ import { Events, ToolModes, SegmentationRepresentations, StrategyCallbacks, } fr
 import { drawCircle as drawCircleSvg } from '../../drawingSvg';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportUIDs from '../../utilities/triggerAnnotationRenderForViewportIds';
-import { config as segmentationConfig, segmentLocking, segmentIndex as segmentIndexController, state as segmentationState, activeSegmentation, } from '../../stateManagement/segmentation';
 import { isVolumeSegmentation } from './strategies/utils/stackVolumeCheck';
-import { getCurrentLabelmapImageIdForViewport } from '../../stateManagement/segmentation/segmentationState';
+import { getActiveSegmentationRepresentation, getCurrentLabelmapImageIdForViewport, getSegmentation, } from '../../stateManagement/segmentation/segmentationState';
+import { getLockedSegmentIndices } from '../../stateManagement/segmentation/segmentLocking';
+import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getActiveSegmentIndex';
+import { getSegmentIndexColor } from '../../stateManagement/segmentation/config/segmentationColor';
 class BrushTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -192,7 +194,7 @@ class BrushTool extends BaseTool {
     createEditData(element) {
         const enabledElement = getEnabledElement(element);
         const { viewport } = enabledElement;
-        const activeRepresentation = activeSegmentation.getActiveSegmentationRepresentation(viewport.id);
+        const activeRepresentation = getActiveSegmentationRepresentation(viewport.id);
         if (!activeRepresentation) {
             throw new Error('No active segmentation detected, create a segmentation representation before using the brush tool');
         }
@@ -200,8 +202,8 @@ class BrushTool extends BaseTool {
         if (type === SegmentationRepresentations.Contour) {
             throw new Error('Not implemented yet');
         }
-        const segmentsLocked = segmentLocking.getLockedSegmentIndices(segmentationId);
-        const { representationData } = segmentationState.getSegmentation(segmentationId);
+        const segmentsLocked = getLockedSegmentIndices(segmentationId);
+        const { representationData } = getSegmentation(segmentationId);
         const labelmapData = representationData[SegmentationRepresentations.Labelmap];
         if (isVolumeSegmentation(labelmapData, viewport)) {
             const { volumeId } = representationData[type];
@@ -272,14 +274,14 @@ class BrushTool extends BaseTool {
     }
     getActiveSegmentationData(viewport) {
         const viewportId = viewport.id;
-        const activeRepresentation = activeSegmentation.getActiveSegmentationRepresentation(viewportId);
+        const activeRepresentation = getActiveSegmentationRepresentation(viewportId);
         if (!activeRepresentation) {
             console.warn('No active segmentation detected, create one before using the brush tool');
             return;
         }
         const { segmentationId, segmentationRepresentationUID } = activeRepresentation;
-        const segmentIndex = segmentIndexController.getActiveSegmentIndex(segmentationId);
-        const segmentColor = segmentationConfig.color.getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
+        const segmentIndex = getActiveSegmentIndex(segmentationId);
+        const segmentColor = getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
         return {
             segmentIndex,
             segmentationId,

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

@@ -16,7 +16,6 @@ import { getCanvasCircleCorners, getCanvasCircleRadius, } from '../../utilities/
 import { getCalibratedLengthUnitsAndScale, getCalibratedAspect, } from '../../utilities/getCalibratedUnits';
 import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
 import { pointInEllipse } from '../../utilities/math/ellipse';
-import { roundNumber } from '../../utilities';
 import { BasicStatsCalculator } from '../../utilities/math/basic';
 import cloneDeep from 'lodash.clonedeep';
 import { filterAnnotationsWithinSamePlane } from '../../utilities/planar';
@@ -346,7 +345,7 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
             isPreScaled: isViewportPreScaled(viewport, targetId),
             isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
         };
-        const pixelValueUnits = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, modalityUnitOptions);
+        const modalityUnit = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, modalityUnitOptions);
         for (let i = 0; i < projectionPoints.length; i++) {
             if (!imageVolume) {
                 continue;
@@ -410,8 +409,8 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
             stdDev: stats.stdDev?.value,
             max: stats.max?.value,
             statsArray: stats.array,
-            areaUnits: measureInfo.areaUnits,
-            pixelValueUnits,
+            areaUnit: measureInfo.areaUnit,
+            modalityUnit,
         };
     }
     _calculateCachedStatsTool(annotation, enabledElement) {
@@ -457,15 +456,15 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
 }
 function defaultGetTextLines(data) {
     const cachedVolumeStats = data.cachedStats.statistics;
-    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;
 }
 CircleROIStartEndThresholdTool.toolName = 'CircleROIStartEndThreshold';

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

@@ -1,5 +1,4 @@
 import { getEnabledElement, cache, StackViewport, utilities as csUtils, } from '@cornerstonejs/core';
-import { utilities as coreUtils } from '@cornerstonejs/core';
 import { getCalibratedLengthUnitsAndScale } from '../../utilities/getCalibratedUnits';
 import { vec3 } from 'gl-matrix';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateManagement';
@@ -14,7 +13,6 @@ import { hideElementCursor, resetElementCursor, } from '../../cursors/elementCur
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { triggerAnnotationCompleted, triggerAnnotationModified, } from '../../stateManagement/annotation/helpers/state';
 import RectangleROITool from '../annotation/RectangleROITool';
-import { roundNumber } from '../../utilities/';
 import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
 import { BasicStatsCalculator } from '../../utilities/math/basic';
 import { filterAnnotationsWithinSamePlane } from '../../utilities/planar';
@@ -178,10 +176,10 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
                 if (Array.isArray(endCoordinate)) {
                     endCoord = this._getCoordinateForViewplaneNormal(endCoord, viewplaneNormal);
                 }
-                const roundedStartCoord = coreUtils.roundToPrecision(startCoord);
-                const roundedEndCoord = coreUtils.roundToPrecision(endCoord);
+                const roundedStartCoord = csUtils.roundToPrecision(startCoord);
+                const roundedEndCoord = csUtils.roundToPrecision(endCoord);
                 const coord = this._getCoordinateForViewplaneNormal(focalPoint, viewplaneNormal);
-                const roundedCoord = coreUtils.roundToPrecision(coord);
+                const roundedCoord = csUtils.roundToPrecision(coord);
                 if (roundedCoord < Math.min(roundedStartCoord, roundedEndCoord) ||
                     roundedCoord > Math.max(roundedStartCoord, roundedEndCoord)) {
                     continue;
@@ -318,7 +316,7 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
             isPreScaled: isViewportPreScaled(viewport, targetId),
             isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
         };
-        const pixelValueUnits = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, modalityUnitOptions);
+        const modalityUnit = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, modalityUnitOptions);
         for (let i = 0; i < projectionPoints.length; i++) {
             if (!imageVolume) {
                 continue;
@@ -369,8 +367,8 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
             stdDev: stats.stdDev?.value,
             max: stats.max?.value,
             statsArray: stats.array,
-            areaUnits: measureInfo.areaUnits,
-            pixelValueUnits,
+            areaUnit: measureInfo.areaUnit,
+            modalityUnit,
         };
     }
     _calculateCachedStatsTool(annotation, enabledElement) {
@@ -412,15 +410,15 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
 }
 function defaultGetTextLines(data) {
     const cachedVolumeStats = data.cachedStats.statistics;
-    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;
 }
 RectangleROIStartEndThresholdTool.toolName = 'RectangleROIStartEndThreshold';

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

@@ -6,7 +6,7 @@ import { getActiveSegmentationRepresentation } from '../../stateManagement/segme
 import RepresentationTypes from '../../enums/SegmentationRepresentations';
 import { setActiveSegmentIndex } from '../../stateManagement/segmentation/segmentIndex';
 import { getHoveredContourSegmentationAnnotation, getSegmentIndexAtLabelmapBorder, getSegmentIndexAtWorldPoint, } from '../../utilities/segmentation';
-import { state } from '../../store';
+import { state } from '../../store/state';
 import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
 class SegmentSelectTool extends BaseTool {
     static { this.SelectMode = {

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

@@ -1,6 +1,6 @@
-import { triggerSegmentationDataModified } from '../../../../stateManagement/segmentation/triggerSegmentationEvents';
-import { config as segmentationConfig } from '../../../../stateManagement/segmentation';
+import { triggerSegmentationDataModified } from '../../../../stateManagement/segmentation/events/triggerSegmentationDataModified';
 import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+import { getSegmentIndexColor, setSegmentIndexColor, } from '../../../../stateManagement/segmentation/config/segmentationColor';
 function lightenColor(r, g, b, a, factor = 0.4) {
     return [
         Math.round(r + (255 - r) * factor),
@@ -42,12 +42,12 @@ export default {
             return;
         }
         const configColor = previewColors?.[segmentIndex];
-        const segmentColor = segmentationConfig.color.getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
+        const segmentColor = getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
         if (!configColor && !segmentColor) {
             return;
         }
         const previewColor = configColor || lightenColor(...segmentColor);
-        segmentationConfig.color.setSegmentIndexColor(segmentationRepresentationUID, previewSegmentIndex, previewColor);
+        setSegmentIndexColor(segmentationRepresentationUID, previewSegmentIndex, previewColor);
     },
     [StrategyCallbacks.AcceptPreview]: (operationData) => {
         const { segmentationVoxelManager, previewVoxelManager: previewVoxelManager, previewSegmentIndex, preview, } = operationData || {};

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

@@ -7,7 +7,7 @@ export interface ROICachedStats {
     [targetId: string]: {
         Modality: string;
         area: number;
-        areaUnits: string;
+        areaUnit: string;
         max: number;
         mean: number;
         stdDev: number;
@@ -130,7 +130,7 @@ export type SplineROIAnnotation = ContourAnnotation & {
             [targetId: string]: {
                 Modality: string;
                 area: number;
-                areaUnits: string;
+                areaUnit: string;
             };
         };
     };

package/dist/esm/utilities/annotationHydration.js

@@ -1,5 +1,5 @@
 import { utilities, BaseVolumeViewport, StackViewport, cache, metaData, } from '@cornerstonejs/core';
-import { addAnnotation } from '../stateManagement';
+import { addAnnotation } from '../stateManagement/annotation/annotationState';
 import { vec3 } from 'gl-matrix';
 function annotationHydration(viewport, toolName, worldPoints, options) {
     const viewReference = viewport.getViewReference();

package/dist/esm/utilities/contourSegmentation/addContourSegmentationAnnotation.js

@@ -1,4 +1,4 @@
-import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
+import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
 export function addContourSegmentationAnnotation(annotation) {
     if (annotation.parentAnnotationUID) {
         return;

package/dist/esm/utilities/contourSegmentation/removeContourSegmentationAnnotation.js

@@ -1,10 +1,10 @@
-import { state } from '../../stateManagement/segmentation';
+import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
 export function removeContourSegmentationAnnotation(annotation) {
     if (!annotation.data.segmentation) {
         throw new Error('removeContourSegmentationAnnotation: annotation does not have a segmentation data');
     }
     const { segmentationId, segmentIndex } = annotation.data.segmentation;
-    const segmentation = state.getSegmentation(segmentationId);
+    const segmentation = getSegmentation(segmentationId);
     const { annotationUIDsMap } = segmentation?.representationData.CONTOUR || {};
     const annotationsUIDsSet = annotationUIDsMap?.get(segmentIndex);
     if (!annotationsUIDsSet) {

package/dist/esm/utilities/contours/generateContourSetsFromLabelmap.js

@@ -2,7 +2,7 @@ import { cache as cornerstoneCache } from '@cornerstonejs/core';
 import vtkImageMarchingSquares from '@kitware/vtk.js/Filters/General/ImageMarchingSquares';
 import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
 import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
-import { getDeduplicatedVTKPolyDataPoints } from '../contours';
+import { getDeduplicatedVTKPolyDataPoints } from './getDeduplicatedVTKPolyDataPoints';
 import { findContoursFromReducedSet } from './contourFinder';
 import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
 const { Labelmap } = SegmentationRepresentations;

package/dist/esm/utilities/contours/getContourHolesDataWorld.js

@@ -1,4 +1,4 @@
-import { getAnnotation } from '../../stateManagement';
+import { getAnnotation } from '../../stateManagement/annotation/annotationState';
 export default function getContourHolesDataWorld(annotation) {
     const childAnnotationUIDs = annotation.childAnnotationUIDs ?? [];
     return childAnnotationUIDs.map((uid) => getAnnotation(uid).data.contour.polyline);

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

@@ -8,7 +8,6 @@ import getContourHolesDataWorld from './getContourHolesDataWorld';
 import getContourHolesDataCanvas from './getContourHolesDataCanvas';
 import updateContourPolyline from './updateContourPolyline';
 import acceptAutogeneratedInterpolations from './interpolation/acceptAutogeneratedInterpolations';
-import * as interpolation from './interpolation';
 import findHandlePolylineIndex from './findHandlePolylineIndex';
 import calculatePerimeter from './calculatePerimeter';
-export { areCoplanarContours, contourFinder, getDeduplicatedVTKPolyDataPoints, detectContourHoles, generateContourSetsFromLabelmap, AnnotationToPointData, getContourHolesDataWorld, getContourHolesDataCanvas, updateContourPolyline, interpolation, acceptAutogeneratedInterpolations, findHandlePolylineIndex, calculatePerimeter, };
+export { areCoplanarContours, contourFinder, getDeduplicatedVTKPolyDataPoints, detectContourHoles, generateContourSetsFromLabelmap, AnnotationToPointData, getContourHolesDataWorld, getContourHolesDataCanvas, updateContourPolyline, acceptAutogeneratedInterpolations, findHandlePolylineIndex, calculatePerimeter, };

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

@@ -8,7 +8,6 @@ import getContourHolesDataWorld from './getContourHolesDataWorld';
 import getContourHolesDataCanvas from './getContourHolesDataCanvas';
 import updateContourPolyline from './updateContourPolyline';
 import acceptAutogeneratedInterpolations from './interpolation/acceptAutogeneratedInterpolations';
-import * as interpolation from './interpolation';
 import findHandlePolylineIndex from './findHandlePolylineIndex';
 import calculatePerimeter from './calculatePerimeter';
-export { areCoplanarContours, contourFinder, getDeduplicatedVTKPolyDataPoints, detectContourHoles, generateContourSetsFromLabelmap, AnnotationToPointData, getContourHolesDataWorld, getContourHolesDataCanvas, updateContourPolyline, interpolation, acceptAutogeneratedInterpolations, findHandlePolylineIndex, calculatePerimeter, };
+export { areCoplanarContours, contourFinder, getDeduplicatedVTKPolyDataPoints, detectContourHoles, generateContourSetsFromLabelmap, AnnotationToPointData, getContourHolesDataWorld, getContourHolesDataCanvas, updateContourPolyline, acceptAutogeneratedInterpolations, findHandlePolylineIndex, calculatePerimeter, };

package/dist/esm/utilities/contours/updateContourPolyline.js

@@ -1,6 +1,6 @@
 import { utilities as csUtils } from '@cornerstonejs/core';
 import * as math from '../math';
-import { getParentAnnotation, invalidateAnnotation, } from '../../stateManagement';
+import { getParentAnnotation, invalidateAnnotation, } from '../../stateManagement/annotation/annotationState';
 export default function updateContourPolyline(annotation, polylineData, transforms, options) {
     const { canvasToWorld, worldToCanvas } = transforms;
     const { data } = annotation;

package/dist/esm/utilities/getCalibratedUnits.d.ts

@@ -1,6 +1,6 @@
 declare const getCalibratedLengthUnitsAndScale: (image: any, handles: any) => {
-    lengthUnits: string;
-    areaUnits: string;
+    unit: string;
+    areaUnit: string;
     scale: number;
 };
 declare const getCalibratedProbeUnitsAndValue: (image: any, handles: any) => {

package/dist/esm/utilities/getCalibratedUnits.js

@@ -27,16 +27,16 @@ const EPS = 1e-3;
 const SQUARE = '\xb2';
 const getCalibratedLengthUnitsAndScale = (image, handles) => {
     const { calibration, hasPixelSpacing } = image;
-    let lengthUnits = hasPixelSpacing ? 'mm' : PIXEL_UNITS;
-    let areaUnits = lengthUnits + SQUARE;
+    let unit = hasPixelSpacing ? 'mm' : PIXEL_UNITS;
+    let areaUnit = unit + SQUARE;
     let scale = 1;
     let calibrationType = '';
     if (!calibration ||
         (!calibration.type && !calibration.sequenceOfUltrasoundRegions)) {
-        return { lengthUnits, areaUnits, scale };
+        return { unit, areaUnit, scale };
     }
     if (calibration.type === CalibrationTypes.UNCALIBRATED) {
-        return { lengthUnits: PIXEL_UNITS, areaUnits: PIXEL_UNITS + SQUARE, scale };
+        return { unit: PIXEL_UNITS, areaUnit: PIXEL_UNITS + SQUARE, scale };
     }
     if (calibration.sequenceOfUltrasoundRegions) {
         let imageIndex1, imageIndex2;
@@ -57,14 +57,14 @@ const getCalibratedLengthUnitsAndScale = (image, handles) => {
             imageIndex2[1] >= region.regionLocationMinY0 &&
             imageIndex2[1] <= region.regionLocationMaxY1);
         if (!regions?.length) {
-            return { lengthUnits, areaUnits, scale };
+            return { unit, areaUnit, scale };
         }
         regions = regions.filter((region) => SUPPORTED_REGION_DATA_TYPES.includes(region.regionDataType) &&
             SUPPORTED_LENGTH_VARIANT.includes(`${region.physicalUnitsXDirection},${region.physicalUnitsYDirection}`));
         if (!regions.length) {
             return {
-                lengthUnits: PIXEL_UNITS,
-                areaUnits: PIXEL_UNITS + SQUARE,
+                unit: PIXEL_UNITS,
+                areaUnit: PIXEL_UNITS + SQUARE,
                 scale,
             };
         }
@@ -75,13 +75,13 @@ const getCalibratedLengthUnitsAndScale = (image, handles) => {
         if (isSamePhysicalDelta) {
             scale = 1 / physicalDeltaX;
             calibrationType = 'US Region';
-            lengthUnits = UNIT_MAPPING[region.physicalUnitsXDirection] || 'unknown';
-            areaUnits = lengthUnits + SQUARE;
+            unit = UNIT_MAPPING[region.physicalUnitsXDirection] || 'unknown';
+            areaUnit = unit + SQUARE;
         }
         else {
             return {
-                lengthUnits: PIXEL_UNITS,
-                areaUnits: PIXEL_UNITS + SQUARE,
+                unit: PIXEL_UNITS,
+                areaUnit: PIXEL_UNITS + SQUARE,
                 scale,
             };
         }
@@ -99,8 +99,8 @@ const getCalibratedLengthUnitsAndScale = (image, handles) => {
         calibrationType = calibration.type;
     }
     return {
-        lengthUnits: lengthUnits + (calibrationType ? ` ${calibrationType}` : ''),
-        areaUnits: areaUnits + (calibrationType ? ` ${calibrationType}` : ''),
+        unit: unit + (calibrationType ? ` ${calibrationType}` : ''),
+        areaUnit: areaUnit + (calibrationType ? ` ${calibrationType}` : ''),
         scale,
     };
 };

package/dist/esm/utilities/getToolsWithModesForElement.js

@@ -1,9 +1,9 @@
-import { ToolGroupManager } from '../store';
 import { getEnabledElement } from '@cornerstonejs/core';
+import { getToolGroupForViewport } from '../store/ToolGroupManager';
 export default function getToolsWithModesForElement(element, modesFilter) {
     const enabledElement = getEnabledElement(element);
     const { renderingEngineId, viewportId } = enabledElement;
-    const toolGroup = ToolGroupManager.getToolGroupForViewport(viewportId, renderingEngineId);
+    const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
     if (!toolGroup) {
         return [];
     }

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

@@ -1,4 +1,4 @@
-import { utilities } from '@cornerstonejs/core';
+import { utilities, triggerEvent } from '@cornerstonejs/core';
 import { getAnnotationNearPoint, getAnnotationNearPointOnEnabledElement } from './getAnnotationNearPoint';
 import debounce from './debounce';
 import throttle from './throttle';
@@ -35,5 +35,4 @@ import * as polyDataUtils from './polyData/utils';
 import * as voi from './voi';
 import * as contourSegmentation from './contourSegmentation';
 declare const roundNumber: typeof utilities.roundNumber;
-import { triggerEvent } from '@cornerstonejs/core';
 export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, jumpToSlice, viewport, cine, clip, boundingBox, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, scroll, roundNumber, pointToString, polyDataUtils, voi, annotationFrameRange, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, };

package/dist/esm/utilities/index.js

@@ -1,4 +1,4 @@
-import { utilities } from '@cornerstonejs/core';
+import { utilities, triggerEvent } from '@cornerstonejs/core';
 import { getAnnotationNearPoint, getAnnotationNearPointOnEnabledElement, } from './getAnnotationNearPoint';
 import debounce from './debounce';
 import throttle from './throttle';
@@ -35,5 +35,4 @@ import * as polyDataUtils from './polyData/utils';
 import * as voi from './voi';
 import * as contourSegmentation from './contourSegmentation';
 const roundNumber = utilities.roundNumber;
-import { triggerEvent } from '@cornerstonejs/core';
 export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, jumpToSlice, viewport, cine, clip, boundingBox, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, scroll, roundNumber, pointToString, polyDataUtils, voi, annotationFrameRange, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, };

package/dist/esm/utilities/math/line/distanceToPointSquaredInfo.js

@@ -1,7 +1,7 @@
-import * as math from '../';
+import { distanceToPointSquared } from '../point';
 export default function distanceToPointSquaredInfo(lineStart, lineEnd, point) {
     let closestPoint;
-    const distanceSquared = math.point.distanceToPointSquared(lineStart, lineEnd);
+    const distanceSquared = distanceToPointSquared(lineStart, lineEnd);
     if (lineStart[0] === lineEnd[0] && lineStart[1] === lineEnd[1]) {
         closestPoint = lineStart;
     }
@@ -24,6 +24,6 @@ export default function distanceToPointSquaredInfo(lineStart, lineEnd, point) {
     }
     return {
         point: [...closestPoint],
-        distanceSquared: math.point.distanceToPointSquared(point, closestPoint),
+        distanceSquared: distanceToPointSquared(point, closestPoint),
     };
 }

package/dist/esm/utilities/math/polyline/isClosed.js

@@ -1,5 +1,5 @@
 import { glMatrix } from 'gl-matrix';
-import * as math from '..';
+import { distanceToPointSquared } from '../point';
 export default function isClosed(polyline) {
     if (polyline.length < 3) {
         return false;
@@ -7,6 +7,6 @@ export default function isClosed(polyline) {
     const numPolylinePoints = polyline.length;
     const firstPoint = polyline[0];
     const lastPoint = polyline[numPolylinePoints - 1];
-    const distFirstToLastPoints = math.point.distanceToPointSquared(firstPoint, lastPoint);
+    const distFirstToLastPoints = distanceToPointSquared(firstPoint, lastPoint);
     return glMatrix.equals(0, distFirstToLastPoints);
 }

package/dist/esm/utilities/planarFreehandROITool/smoothAnnotation.js

@@ -1,6 +1,6 @@
-import { PlanarFreehandROITool } from '../../tools';
-import { ToolGroupManager } from '../../store';
+import PlanarFreehandROITool from '../../tools/annotation/PlanarFreehandROITool';
 import interpolateSegmentPoints from './interpolation/interpolateSegmentPoints';
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
 function shouldPreventInterpolation(enabledElement, annotation, knotsRatioPercentage) {
     if (!annotation?.data?.polyline || knotsRatioPercentage <= 0) {
         return true;
@@ -9,7 +9,7 @@ function shouldPreventInterpolation(enabledElement, annotation, knotsRatioPercen
         return true;
     }
     const { renderingEngineId, viewportId, FrameOfReferenceUID } = enabledElement;
-    const toolGroup = ToolGroupManager.getToolGroupForViewport(viewportId, renderingEngineId);
+    const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
     if (annotation.metadata.FrameOfReferenceUID !== FrameOfReferenceUID) {
         return true;
     }

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

@@ -1,7 +1,7 @@
 import { getToolGroup } from '../../store/ToolGroupManager';
 import triggerAnnotationRenderForViewportIds from '../triggerAnnotationRenderForViewportIds';
 import { getRenderingEngine } from '@cornerstonejs/core';
-import { getBrushToolInstances } from './utilities';
+import { getBrushToolInstances } from './getBrushToolInstances';
 export function setBrushSizeForToolGroup(toolGroupId, brushSize, toolName) {
     const toolGroup = getToolGroup(toolGroupId);
     if (toolGroup === undefined) {

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

@@ -1,7 +1,7 @@
 import { getToolGroup } from '../../store/ToolGroupManager';
 import triggerAnnotationRenderForViewportIds from '../triggerAnnotationRenderForViewportIds';
 import { getRenderingEngine } from '@cornerstonejs/core';
-import { getBrushToolInstances } from './utilities';
+import { getBrushToolInstances } from './getBrushToolInstances';
 export function setBrushThresholdForToolGroup(toolGroupId, threshold, otherArgs = { isDynamic: false }) {
     const toolGroup = getToolGroup(toolGroupId);
     if (toolGroup === undefined) {

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

@@ -0,0 +1 @@
+export declare function getBrushToolInstances(toolGroupId: string, toolName?: string): any[];

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

@@ -0,0 +1,17 @@
+import { getToolGroup } from '../../store/ToolGroupManager';
+import BrushTool from '../../tools/segmentation/BrushTool';
+export function getBrushToolInstances(toolGroupId, toolName) {
+    const toolGroup = getToolGroup(toolGroupId);
+    if (toolGroup === undefined) {
+        return;
+    }
+    const toolInstances = toolGroup._toolInstances;
+    if (!Object.keys(toolInstances).length) {
+        return;
+    }
+    if (toolName && toolInstances[toolName]) {
+        return [toolInstances[toolName]];
+    }
+    const brushBasedToolInstances = Object.values(toolInstances).filter((toolInstance) => toolInstance instanceof BrushTool);
+    return brushBasedToolInstances;
+}

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

@@ -1,4 +1,2 @@
-export declare const setSegmentationDirty: (segmentationId: string) => void;
-export declare const setSegmentationClean: (segmentationId: string) => void;
 declare function getUniqueSegmentIndices(segmentationId: any): any;
 export { getUniqueSegmentIndices };

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

@@ -1,27 +1,8 @@
 import { cache } from '@cornerstonejs/core';
-import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
 import { isVolumeSegmentation } from '../../tools/segmentation/strategies/utils/stackVolumeCheck';
 import { SegmentationRepresentations } from '../../enums';
-const segmentIndicesCache = new Map();
-export const setSegmentationDirty = (segmentationId) => {
-    const cached = segmentIndicesCache.get(segmentationId);
-    if (cached) {
-        cached.isDirty = true;
-    }
-};
-export const setSegmentationClean = (segmentationId) => {
-    const cached = segmentIndicesCache.get(segmentationId);
-    if (cached) {
-        cached.isDirty = false;
-    }
-};
-function getCachedSegmentIndices(segmentationId) {
-    const cached = segmentIndicesCache.get(segmentationId);
-    if (cached && !cached.isDirty) {
-        return cached.indices;
-    }
-    return null;
-}
+import { getCachedSegmentIndices, setCachedSegmentIndices } from './utilities';
+import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
 function getUniqueSegmentIndices(segmentationId) {
     const cachedResult = getCachedSegmentIndices(segmentationId);
     if (cachedResult) {
@@ -45,7 +26,7 @@ function getUniqueSegmentIndices(segmentationId) {
         default:
             throw new Error(`Unsupported segmentation type: ${segmentation.type}`);
     }
-    segmentIndicesCache.set(segmentationId, { indices, isDirty: false });
+    setCachedSegmentIndices(segmentationId, indices);
     return indices;
 }
 function handleLabelmapSegmentation(segmentation, segmentationId) {