@cornerstonejs/tools 5.5.1 → 5.6.0

package/dist/esm/index.d.ts

@@ -12,7 +12,7 @@ import * as Types from './types/index.js';
 import * as annotation from './stateManagement/annotation/index.js';
 import * as segmentation from './stateManagement/segmentation/index.js';
 import * as splines from './tools/annotation/splines/index.js';
-import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, SegmentBidirectionalTool, PlanarRotateTool, MIPJumpToClickTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, WorldCrosshairTool, SliceIntersectionTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OrientationControllerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, ClickSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentLabelTool, LabelMapEditWithContourTool } from './tools/index.js';
+import { BaseTool, AnnotationTool, AnnotationDisplayTool, measurementTargetFilters, PanTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, SegmentBidirectionalTool, PlanarRotateTool, MIPJumpToClickTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, WorldCrosshairTool, SliceIntersectionTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OrientationControllerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, ClickSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentLabelTool, LabelMapEditWithContourTool } from './tools/index.js';
 import VideoRedactionTool from './tools/annotation/VideoRedactionTool.js';
 import * as Enums from './enums/index.js';
-export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, SegmentBidirectionalTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LabelTool, LengthTool, HeightTool, CrosshairsTool, WorldCrosshairTool, SliceIntersectionTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, OrientationControllerTool, SegmentSelectTool, SegmentLabelTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, store, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, ClickSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, LabelMapEditWithContourTool, splines, version, };
+export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, measurementTargetFilters, PanTool, SegmentBidirectionalTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LabelTool, LengthTool, HeightTool, CrosshairsTool, WorldCrosshairTool, SliceIntersectionTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, OrientationControllerTool, SegmentSelectTool, SegmentLabelTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, store, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, ClickSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, LabelMapEditWithContourTool, splines, version, };

package/dist/esm/index.js

@@ -12,7 +12,7 @@ import * as Types from './types/index.js';
 import * as annotation from './stateManagement/annotation/index.js';
 import * as segmentation from './stateManagement/segmentation/index.js';
 import * as splines from './tools/annotation/splines/index.js';
-import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, SegmentBidirectionalTool, PlanarRotateTool, MIPJumpToClickTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, WorldCrosshairTool, SliceIntersectionTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OrientationControllerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, ClickSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentLabelTool, LabelMapEditWithContourTool, } from './tools/index.js';
+import { BaseTool, AnnotationTool, AnnotationDisplayTool, measurementTargetFilters, PanTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, SegmentBidirectionalTool, PlanarRotateTool, MIPJumpToClickTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, WorldCrosshairTool, SliceIntersectionTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OrientationControllerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, ClickSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentLabelTool, LabelMapEditWithContourTool, } from './tools/index.js';
 import VideoRedactionTool from './tools/annotation/VideoRedactionTool.js';
 import * as Enums from './enums/index.js';
-export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, SegmentBidirectionalTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LabelTool, LengthTool, HeightTool, CrosshairsTool, WorldCrosshairTool, SliceIntersectionTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, OrientationControllerTool, SegmentSelectTool, SegmentLabelTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, store, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, ClickSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, LabelMapEditWithContourTool, splines, version, };
+export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, measurementTargetFilters, PanTool, SegmentBidirectionalTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LabelTool, LengthTool, HeightTool, CrosshairsTool, WorldCrosshairTool, SliceIntersectionTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, OrientationControllerTool, SegmentSelectTool, SegmentLabelTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, store, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, ClickSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, LabelMapEditWithContourTool, splines, version, };

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

@@ -16,7 +16,6 @@ import * as lineSegment from '../../utilities/math/line/index.js';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor.js';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds.js';
 import { getStyleProperty } from '../../stateManagement/annotation/config/helpers.js';
-const { transformWorldToIndex } = csUtils;
 class BidirectionalTool extends AnnotationTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],

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

@@ -2,6 +2,7 @@ import { AnnotationTool } from '../base/index.js';
 import type { Types } from '@cornerstonejs/core';
 import type { EventTypes, ToolHandle, PublicToolProps, ToolProps, SVGDrawingHelper, Annotation } from '../../types/index.js';
 import type { CircleROIAnnotation } from '../../types/ToolSpecificAnnotationTypes.js';
+import { type MetricDefinition } from '../../utilities/defaultGetTextLines.js';
 declare class CircleROITool extends AnnotationTool {
     static toolName: string;
     _throttledCalculateCachedStats: Function;
@@ -16,7 +17,7 @@ declare class CircleROITool extends AnnotationTool {
     isDrawing: boolean;
     isHandleOutsideImage: boolean;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
-    addNewAnnotation: (evt: EventTypes.InteractionEventType) => CircleROIAnnotation;
+    addNewAnnotation: (evt: EventTypes.InteractionEventType) => Annotation;
     isPointNearTool: (element: HTMLDivElement, annotation: CircleROIAnnotation, canvasCoords: Types.Point2, proximity: number) => boolean;
     _pointInEllipseCanvas(ellipse: any, location: Types.Point2): boolean;
     toolSelectedCallback: (evt: EventTypes.InteractionEventType, annotation: CircleROIAnnotation) => void;
@@ -39,5 +40,7 @@ declare class CircleROITool extends AnnotationTool {
         viewplaneNormal?: Types.Point3;
         viewUp?: Types.Point3;
     }) => CircleROIAnnotation;
+    static readonly CIRCLE_ROI_METRICS: MetricDefinition[];
+    static getTextLines: (data: any, targetId: string | string[]) => string[];
 }
 export default CircleROITool;

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

@@ -1,5 +1,5 @@
 var _a;
-import { AnnotationTool, BaseTool } from '../base/index.js';
+import { AnnotationTool, BaseTool, measurementTargetFilters } from '../base/index.js';
 import { vec2, vec3 } from 'gl-matrix';
 import { getEnabledElement, VolumeViewport, utilities as csUtils, getEnabledElementByViewportId, EPSILON, } from '@cornerstonejs/core';
 import { getCalibratedLengthUnitsAndScale } from '../../utilities/getCalibratedUnits.js';
@@ -21,6 +21,7 @@ import { getCanvasCircleCorners, getCanvasCircleRadius, } from '../../utilities/
 import { getCanvasEllipseCorners, pointInEllipse, } from '../../utilities/math/ellipse/index.js';
 import { BasicStatsCalculator } from '../../utilities/math/basic/index.js';
 import { getStyleProperty } from '../../stateManagement/annotation/config/helpers.js';
+import { createGetTextLines, } from '../../utilities/defaultGetTextLines.js';
 import getEllipseWorldCoordinates from '../../utilities/getEllipseWorldCoordinates.js';
 const { transformWorldToIndex } = csUtils;
 class CircleROITool extends AnnotationTool {
@@ -35,6 +36,7 @@ class CircleROITool extends AnnotationTool {
             getTextLines: defaultGetTextLines,
             statsCalculator: BasicStatsCalculator,
             simplified: true,
+            targetsFilter: measurementTargetFilters.allPixelData,
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -360,7 +362,7 @@ class CircleROITool extends AnnotationTool {
                 const { annotationUID, data } = annotation;
                 const { handles } = data;
                 const { points, activeHandleIndex } = handles;
-                const targetId = this.getTargetId(viewport, data);
+                const targetIds = this.getMeasurementTargets(viewport, data);
                 styleSpecifier.annotationUID = annotationUID;
                 const { color, lineWidth, lineDash } = this.getAnnotationStyle({
                     annotation,
@@ -374,19 +376,7 @@ class CircleROITool extends AnnotationTool {
                     canvasCoordinates[1],
                 ]);
                 const { centerPointRadius } = this.configuration;
-                if (!data.cachedStats[targetId] ||
-                    data.cachedStats[targetId].areaUnit == null) {
-                    data.cachedStats[targetId] = {
-                        Modality: null,
-                        area: null,
-                        max: null,
-                        mean: null,
-                        stdDev: null,
-                        areaUnit: null,
-                        radius: null,
-                        radiusUnit: null,
-                        perimeter: null,
-                    };
+                if (this.ensureCachedStatsTargets(data, targetIds, (stats) => stats.areaUnit == null)) {
                     this._calculateCachedStats(annotation, viewport, renderingEngine, enabledElement);
                 }
                 else if (annotation.invalidated) {
@@ -456,7 +446,7 @@ class CircleROITool extends AnnotationTool {
                 }
                 renderStatus = true;
                 if (this.configuration.calculateStats) {
-                    const textLines = this.configuration.getTextLines(data, targetId);
+                    const textLines = this.configuration.getTextLines(data, targetIds);
                     if (!textLines || textLines.length === 0) {
                         continue;
                     }
@@ -491,13 +481,19 @@ class CircleROITool extends AnnotationTool {
             const topLeftWorld = viewport.canvasToWorld(topLeftCanvas);
             const bottomRightWorld = viewport.canvasToWorld(bottomRightCanvas);
             const { cachedStats } = data;
+            if (wasInvalidated) {
+                const currentTargets = this.getMeasurementTargets(viewport, data);
+                for (const key of Object.keys(cachedStats)) {
+                    delete cachedStats[key];
+                }
+                this.ensureCachedStatsTargets(data, currentTargets);
+            }
             const targetIds = Object.keys(cachedStats);
+            let isHandleOutsideAnyTarget = false;
             for (let i = 0; i < targetIds.length; i++) {
                 const targetId = targetIds[i];
                 const image = this.getTargetImageData(targetId);
                 if (!image) {
-                    console.warn('image not found for stats:', targetId);
-                    delete cachedStats[targetId];
                     continue;
                 }
                 const { dimensions, imageData, metadata, voxelManager } = image;
@@ -539,11 +535,12 @@ class CircleROITool extends AnnotationTool {
                 };
                 const pos1Index = transformWorldToIndex(imageData, topLeftWorld);
                 const pos2Index = transformWorldToIndex(imageData, bottomRightWorld);
-                this.isHandleOutsideImage = !BaseTool.isInsideVolume(dimensions, [
+                const isHandleOutsideTarget = !BaseTool.isInsideVolume(dimensions, [
                     pos1Index,
                     pos2Index,
                 ]);
-                if (!this.isHandleOutsideImage) {
+                isHandleOutsideAnyTarget ||= isHandleOutsideTarget;
+                if (!isHandleOutsideTarget) {
                     const iMin = Math.min(pos1Index[0], pos2Index[0]);
                     const iMax = Math.max(pos1Index[0], pos2Index[0]);
                     const jMin = Math.min(pos1Index[1], pos2Index[1]);
@@ -593,6 +590,7 @@ class CircleROITool extends AnnotationTool {
                     };
                 }
             }
+            this.isHandleOutsideImage = isHandleOutsideAnyTarget;
             annotation.invalidated = false;
             if (wasInvalidated) {
                 triggerAnnotationModified(annotation, element, ChangeTypes.StatsUpdated);
@@ -660,10 +658,20 @@ CircleROITool.hydrate = (viewportId, points, options) => {
     addAnnotation(annotation, viewport.element);
     triggerAnnotationRenderForViewportIds([viewport.id]);
 };
-function defaultGetTextLines(data, targetId) {
-    const cachedVolumeStats = data.cachedStats[targetId];
-    const { radius, radiusUnit, area, mean, stdDev, max, min, isEmptyArea, areaUnit, modalityUnit, } = cachedVolumeStats;
+CircleROITool.CIRCLE_ROI_METRICS = [
+    { name: 'Mean', attribute: 'mean', unitAttribute: 'modalityUnit' },
+    { name: 'Max', attribute: 'max', unitAttribute: 'modalityUnit' },
+    { name: 'Min', attribute: 'min', unitAttribute: 'modalityUnit' },
+    { name: 'Std Dev', attribute: 'stdDev', unitAttribute: 'modalityUnit' },
+];
+CircleROITool.getTextLines = createGetTextLines(_a.CIRCLE_ROI_METRICS);
+function defaultGetTextLines(data, targetIds) {
+    const cachedVolumeStats = data.cachedStats[targetIds[0]];
     const textLines = [];
+    if (!cachedVolumeStats) {
+        return textLines;
+    }
+    const { radius, radiusUnit, area, isEmptyArea, areaUnit } = cachedVolumeStats;
     if (csUtils.isNumber(radius)) {
         const radiusLine = isEmptyArea
             ? `Radius: Oblique not supported`
@@ -676,17 +684,9 @@ function defaultGetTextLines(data, targetId) {
             : `Area: ${csUtils.roundNumber(area)} ${areaUnit}`;
         textLines.push(areaLine);
     }
-    if (csUtils.isNumber(mean)) {
-        textLines.push(`Mean: ${csUtils.roundNumber(mean)} ${modalityUnit}`);
-    }
-    if (csUtils.isNumber(max)) {
-        textLines.push(`Max: ${csUtils.roundNumber(max)} ${modalityUnit}`);
-    }
-    if (csUtils.isNumber(min)) {
-        textLines.push(`Min: ${csUtils.roundNumber(min)} ${modalityUnit}`);
-    }
-    if (csUtils.isNumber(stdDev)) {
-        textLines.push(`Std Dev: ${csUtils.roundNumber(stdDev)} ${modalityUnit}`);
+    const standardTextLines = CircleROITool.getTextLines(data, targetIds);
+    if (standardTextLines) {
+        textLines.push(...standardTextLines);
     }
     return textLines;
 }

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

@@ -20,7 +20,7 @@ class DragProbeTool extends ProbeTool {
             const { currentPoints, element } = eventDetail;
             const worldPos = currentPoints.world;
             const enabledElement = getEnabledElement(element);
-            const { viewport, renderingEngine } = enabledElement;
+            const { viewport } = enabledElement;
             this.isDrawing = true;
             const camera = getViewportICamera(viewport);
             const { viewPlaneNormal, viewUp } = camera;

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

@@ -16,7 +16,7 @@ declare class RectangleROITool extends AnnotationTool {
     isDrawing: boolean;
     isHandleOutsideImage: boolean;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
-    addNewAnnotation: (evt: EventTypes.InteractionEventType) => RectangleROIAnnotation;
+    addNewAnnotation: (evt: EventTypes.InteractionEventType) => Annotation;
     isPointNearTool: (element: HTMLDivElement, annotation: RectangleROIAnnotation, canvasCoords: Types.Point2, proximity: number) => boolean;
     toolSelectedCallback: (evt: EventTypes.InteractionEventType, annotation: RectangleROIAnnotation) => void;
     handleSelectedCallback: (evt: EventTypes.InteractionEventType, annotation: RectangleROIAnnotation, handle: ToolHandle) => void;
@@ -34,7 +34,7 @@ declare class RectangleROITool extends AnnotationTool {
         width: number;
         height: number;
     };
-    _calculateCachedStats: (annotation: any, viewPlaneNormal: any, viewUp: any, renderingEngine: any, enabledElement: any) => any;
+    _calculateCachedStats: (annotation: any, viewPlaneNormal: any, viewUp: any, enabledElement: any) => any;
     _isInsideVolume: (index1: any, index2: any, dimensions: any) => boolean;
     static hydrate: (viewportId: string, points: Types.Point3[], options?: {
         annotationUID?: string;

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

@@ -1,5 +1,5 @@
 var _a;
-import { AnnotationTool } from '../base/index.js';
+import { AnnotationTool, measurementTargetFilters } from '../base/index.js';
 import { getEnabledElement, VolumeViewport, utilities as csUtils, getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import { vec3 } from 'gl-matrix';
 import { getCalibratedLengthUnitsAndScale } from '../../utilities/getCalibratedUnits.js';
@@ -21,6 +21,7 @@ import { viewportSupportsImageSlices } from '../../utilities/viewportCapabilitie
 import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled.js';
 import { BasicStatsCalculator } from '../../utilities/math/basic/index.js';
 import { getStyleProperty } from '../../stateManagement/annotation/config/helpers.js';
+import { defaultAreaGetTextLines } from '../../utilities/defaultGetTextLines.js';
 const { transformWorldToIndex, transformWorldToIndexContinuous } = csUtils;
 class RectangleROITool extends AnnotationTool {
     constructor(toolProps = {}, defaultToolProps = {
@@ -30,8 +31,9 @@ class RectangleROITool extends AnnotationTool {
             shadow: true,
             preventHandleOutsideImage: false,
             calculateStats: true,
-            getTextLines: defaultGetTextLines,
+            getTextLines: defaultAreaGetTextLines,
             statsCalculator: BasicStatsCalculator,
+            targetsFilter: measurementTargetFilters.allPixelData,
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -112,8 +114,6 @@ class RectangleROITool extends AnnotationTool {
             };
             this._activateModify(element);
             hideElementCursor(element);
-            const enabledElement = getEnabledElement(element);
-            const { renderingEngine } = enabledElement;
             triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             evt.preventDefault();
         };
@@ -139,8 +139,6 @@ class RectangleROITool extends AnnotationTool {
             };
             this._activateModify(element);
             hideElementCursor(element);
-            const enabledElement = getEnabledElement(element);
-            const { renderingEngine } = enabledElement;
             triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             evt.preventDefault();
         };
@@ -329,27 +327,18 @@ class RectangleROITool extends AnnotationTool {
                 const { annotationUID, data } = annotation;
                 const { points, activeHandleIndex } = data.handles;
                 const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
-                const targetId = this.getTargetId(viewport, data);
+                const targetIds = this.getMeasurementTargets(viewport, data);
                 styleSpecifier.annotationUID = annotationUID;
                 const { color, lineWidth, lineDash } = this.getAnnotationStyle({
                     annotation,
                     styleSpecifier,
                 });
                 const { viewPlaneNormal, viewUp } = getViewportICamera(viewport);
-                if (!data.cachedStats[targetId] ||
-                    data.cachedStats[targetId].areaUnit == null) {
-                    data.cachedStats[targetId] = {
-                        Modality: null,
-                        area: null,
-                        max: null,
-                        mean: null,
-                        stdDev: null,
-                        areaUnit: null,
-                    };
-                    this._calculateCachedStats(annotation, viewPlaneNormal, viewUp, renderingEngine, enabledElement);
+                if (this.ensureCachedStatsTargets(data, targetIds, (stats) => stats.areaUnit == null)) {
+                    this._calculateCachedStats(annotation, viewPlaneNormal, viewUp, enabledElement);
                 }
                 else if (annotation.invalidated) {
-                    this._throttledCalculateCachedStats(annotation, viewPlaneNormal, viewUp, renderingEngine, enabledElement);
+                    this._throttledCalculateCachedStats(annotation, viewPlaneNormal, viewUp, enabledElement);
                     if (viewport instanceof VolumeViewport) {
                         const { referencedImageId } = annotation.metadata;
                         for (const targetId in data.cachedStats) {
@@ -399,8 +388,8 @@ class RectangleROITool extends AnnotationTool {
                     lineWidth,
                 }, dataId);
                 renderStatus = true;
-                const textLines = this.configuration.getTextLines(data, targetId);
-                if (!textLines || textLines.length === 0) {
+                const textLines = this.configuration.getTextLines(data, targetIds);
+                if (!textLines?.length) {
                     continue;
                 }
                 if (!this.renderLinkedTextBoxAnnotation({
@@ -425,7 +414,7 @@ class RectangleROITool extends AnnotationTool {
                 height: Math.abs(point0[1] - point1[1]),
             };
         };
-        this._calculateCachedStats = (annotation, viewPlaneNormal, viewUp, renderingEngine, enabledElement) => {
+        this._calculateCachedStats = (annotation, viewPlaneNormal, viewUp, enabledElement) => {
             if (!this.configuration.calculateStats) {
                 return;
             }
@@ -434,7 +423,15 @@ class RectangleROITool extends AnnotationTool {
             const { element } = viewport;
             const worldHandles = data.handles.points;
             const { cachedStats } = data;
+            if (annotation.invalidated) {
+                const currentTargets = this.getMeasurementTargets(viewport, data);
+                for (const key of Object.keys(cachedStats)) {
+                    delete cachedStats[key];
+                }
+                this.ensureCachedStatsTargets(data, currentTargets);
+            }
             const targetIds = Object.keys(cachedStats);
+            let isHandleOutsideAnyTarget = false;
             for (let i = 0; i < targetIds.length; i++) {
                 const targetId = targetIds[i];
                 const image = this.getTargetImageData(targetId);
@@ -445,8 +442,9 @@ class RectangleROITool extends AnnotationTool {
                 const continuousIndexHandles = worldHandles.map((worldHandle) => transformWorldToIndexContinuous(imageData, worldHandle));
                 const pos1Index = transformWorldToIndex(imageData, worldHandles[0]);
                 const pos2Index = transformWorldToIndex(imageData, worldHandles[3]);
-                if (this._isInsideVolume(pos1Index, pos2Index, dimensions)) {
-                    this.isHandleOutsideImage = false;
+                const isHandleOutsideTarget = !this._isInsideVolume(pos1Index, pos2Index, dimensions);
+                isHandleOutsideAnyTarget ||= isHandleOutsideTarget;
+                if (!isHandleOutsideTarget) {
                     const iMin = Math.min(pos1Index[0], pos2Index[0]);
                     const iMax = Math.max(pos1Index[0], pos2Index[0]);
                     const jMin = Math.min(pos1Index[1], pos2Index[1]);
@@ -498,12 +496,12 @@ class RectangleROITool extends AnnotationTool {
                     };
                 }
                 else {
-                    this.isHandleOutsideImage = true;
                     cachedStats[targetId] = {
                         Modality: metadata.Modality,
                     };
                 }
             }
+            this.isHandleOutsideImage = isHandleOutsideAnyTarget;
             const invalidated = annotation.invalidated;
             annotation.invalidated = false;
             if (invalidated) {
@@ -553,28 +551,4 @@ RectangleROITool.hydrate = (viewportId, points, options) => {
     addAnnotation(annotation, viewport.element);
     triggerAnnotationRenderForViewportIds([viewport.id]);
 };
-function defaultGetTextLines(data, targetId) {
-    const cachedVolumeStats = data.cachedStats[targetId];
-    const { area, mean, max, stdDev, areaUnit, modalityUnit, min } = cachedVolumeStats;
-    if (mean === undefined || mean === null) {
-        return;
-    }
-    const textLines = [];
-    if (csUtils.isNumber(area)) {
-        textLines.push(`Area: ${csUtils.roundNumber(area)} ${areaUnit}`);
-    }
-    if (csUtils.isNumber(mean)) {
-        textLines.push(`Mean: ${csUtils.roundNumber(mean)} ${modalityUnit}`);
-    }
-    if (csUtils.isNumber(max)) {
-        textLines.push(`Max: ${csUtils.roundNumber(max)} ${modalityUnit}`);
-    }
-    if (csUtils.isNumber(min)) {
-        textLines.push(`Min: ${csUtils.roundNumber(min)} ${modalityUnit}`);
-    }
-    if (csUtils.isNumber(stdDev)) {
-        textLines.push(`Std Dev: ${csUtils.roundNumber(stdDev)} ${modalityUnit}`);
-    }
-    return textLines;
-}
 export default RectangleROITool;

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

@@ -17,7 +17,9 @@ import getViewportICamera from '../../utilities/getViewportICamera.js';
 const { DefaultHistoryMemo } = csUtils.HistoryMemo;
 class AnnotationTool extends AnnotationDisplayTool {
     static createAnnotationForViewport(viewport, ...annotationBaseData) {
-        return this.createAnnotation({ metadata: viewport.getViewReference() }, ...annotationBaseData);
+        const metadata = viewport.getViewReference();
+        delete metadata.volumeId;
+        return this.createAnnotation({ metadata }, ...annotationBaseData);
     }
     static createAndAddAnnotation(viewport, ...annotationBaseData) {
         const annotation = this.createAnnotationForViewport(viewport, ...annotationBaseData);
@@ -184,9 +186,9 @@ class AnnotationTool extends AnnotationDisplayTool {
         return true;
     }
     static isSuvScaled(viewport, targetId, imageId) {
-        if (viewport instanceof BaseVolumeViewport) {
-            const volumeId = csUtils.getVolumeId(targetId);
-            const volume = cache.getVolume(volumeId);
+        const volumeId = csUtils.getVolumeId(targetId);
+        const volume = cache.getVolume(volumeId);
+        if (volume) {
             return volume?.scaling?.PT !== undefined;
         }
         const scalingModule = imageId && metaData.get('scalingModule', imageId);

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

@@ -2,7 +2,7 @@ import { utilities as csUtils } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 import ToolModes from '../../enums/ToolModes.js';
 import type StrategyCallbacks from '../../enums/StrategyCallbacks.js';
-import type { InteractionTypes, ToolProps, PublicToolProps, ToolConfiguration } from '../../types/index.js';
+import type { InteractionTypes, ToolProps, PublicToolProps, ToolConfiguration, AnnotationData, MeasurementTargetCandidate } from '../../types/index.js';
 declare abstract class BaseTool {
     static toolName: any;
     static activeCursorTool: any;
@@ -33,9 +33,20 @@ declare abstract class BaseTool {
     setConfiguration(newConfiguration: Record<string, any>): void;
     setActiveStrategy(strategyName: string): void;
     protected getTargetImageData(targetId: string): Types.IImageData | Types.CPUIImageData;
-    protected getTargetId(viewport: Types.IViewport, data?: unknown & {
-        cachedStats?: Record<string, unknown>;
-    }): string | undefined;
+    protected getTargetId(viewport: Types.IViewport, data?: AnnotationData): string | undefined;
+    protected getMeasurementTargets(viewport: Types.IViewport, data?: AnnotationData): string[];
+    protected getMeasurementTargetCandidates(viewport: Types.IViewport, data?: AnnotationData): MeasurementTargetCandidate[];
+    protected static getViewportDisplaySets(viewport: Types.IViewport): Array<{
+        displaySetUID: string;
+        displaySet?: unknown;
+        instance?: Record<string, unknown>;
+        imageIds?: string[];
+        volumeId?: string;
+        modality?: string;
+    }>;
+    protected static getExemplarInstance(imageIds?: string[]): Record<string, unknown> | undefined;
+    protected static findCachedStatsTargetId(data: AnnotationData | undefined, referencedId: string): string | undefined;
+    protected ensureCachedStatsTargets(data: AnnotationData, targetIds: string[], needsUpdate?: (stats: any) => boolean): boolean;
     undo(): void;
     redo(): void;
     static createZoomPanMemo(viewport: any): {

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

@@ -1,5 +1,6 @@
-import { utilities as csUtils, viewportHasPan, viewportHasZoom, } from '@cornerstonejs/core';
+import { cache, metaData, utilities as csUtils, viewportHasPan, viewportHasZoom, } from '@cornerstonejs/core';
 import ToolModes from '../../enums/ToolModes.js';
+import measurementTargetFilters from './measurementTargetFilters.js';
 const { DefaultHistoryMemo } = csUtils.HistoryMemo;
 class BaseTool {
     get configurationTyped() {
@@ -71,7 +72,7 @@ class BaseTool {
             if (!viewports || !viewports.length) {
                 return;
             }
-            return viewports[0].getImageData();
+            return viewports[0].getImageData(volumeId);
         }
         else if (targetId.startsWith('videoId:')) {
             const imageURI = csUtils.imageIdToURI(targetId);
@@ -86,19 +87,139 @@ class BaseTool {
         }
     }
     getTargetId(viewport, data) {
-        const { isPreferredTargetId } = this.configurationTyped;
+        return this.getMeasurementTargets(viewport, data)[0];
+    }
+    getMeasurementTargets(viewport, data) {
+        const { targetsFilter, isPreferredTargetId } = this.configurationTyped;
         if (isPreferredTargetId && data?.cachedStats) {
             for (const [targetId, cachedStat] of Object.entries(data.cachedStats)) {
                 if (isPreferredTargetId(viewport, { targetId, cachedStat })) {
-                    return targetId;
+                    return [targetId];
                 }
             }
         }
+        if (targetsFilter) {
+            const candidates = this.getMeasurementTargetCandidates(viewport, data);
+            const options = {
+                viewport,
+                configuration: this.configurationTyped,
+                data,
+            };
+            return targetsFilter(candidates, options).map((candidate) => candidate.targetId);
+        }
         const defaultTargetId = viewport.getViewReferenceId?.();
         if (defaultTargetId) {
-            return defaultTargetId;
+            return [defaultTargetId];
+        }
+        throw new Error('getMeasurementTargets: viewport must have a getViewReferenceId method');
+    }
+    getMeasurementTargetCandidates(viewport, data) {
+        const candidates = [];
+        const displaySets = BaseTool.getViewportDisplaySets(viewport);
+        const actors = viewport.getActors?.() || [];
+        for (let index = 0; index < actors.length; index++) {
+            const { referencedId, representationUID } = actors[index];
+            if (!referencedId) {
+                continue;
+            }
+            const volume = cache.getVolume(referencedId);
+            if (!volume) {
+                continue;
+            }
+            const targetId = BaseTool.findCachedStatsTargetId(data, referencedId) ||
+                viewport.getViewReferenceId?.({ volumeId: referencedId });
+            if (!targetId) {
+                continue;
+            }
+            const displaySetInfo = displaySets.find((displaySet) => displaySet.volumeId === referencedId);
+            const imageIds = displaySetInfo?.imageIds ??
+                (volume.imageIds?.length ? volume.imageIds : undefined);
+            const instance = displaySetInfo?.instance ?? BaseTool.getExemplarInstance(imageIds);
+            candidates.push({
+                targetId,
+                referencedId,
+                representationUID: representationUID,
+                displaySet: displaySetInfo?.displaySet,
+                displaySetUID: displaySetInfo?.displaySetUID,
+                instance,
+                modality: instance?.Modality ?? volume.metadata?.Modality,
+                imageIds,
+                index,
+            });
+        }
+        if (!candidates.length) {
+            const targetId = viewport.getViewReferenceId?.();
+            if (targetId) {
+                const displaySetInfo = displaySets[0];
+                candidates.push({
+                    targetId,
+                    index: 0,
+                    displaySet: displaySetInfo?.displaySet,
+                    displaySetUID: displaySetInfo?.displaySetUID,
+                    instance: displaySetInfo?.instance,
+                    modality: displaySetInfo?.modality,
+                    imageIds: displaySetInfo?.imageIds,
+                });
+            }
+        }
+        return candidates;
+    }
+    static getViewportDisplaySets(viewport) {
+        const displaySets = viewport.getDisplaySets?.();
+        if (!displaySets?.length) {
+            return [];
+        }
+        const provider = csUtils.genericViewportDisplaySetMetadataProvider;
+        return displaySets.map(({ displaySetId }) => {
+            const genericRegistration = provider.get(provider.VIEWPORT_V2_DISPLAY_SET, displaySetId);
+            const registeredImageIds = Array.isArray(genericRegistration)
+                ? genericRegistration
+                : genericRegistration?.imageIds;
+            const typedDisplaySet = registeredImageIds
+                ?.map((imageId) => metaData.get('displaySetModule', imageId))
+                .find((displaySet) => displaySet !== undefined);
+            const imageIds = typedDisplaySet?.imageIds?.length
+                ? Array.from(typedDisplaySet.imageIds)
+                : registeredImageIds;
+            const registered = typedDisplaySet ?? genericRegistration;
+            const instance = typedDisplaySet?.instances?.[0] ??
+                BaseTool.getExemplarInstance(imageIds);
+            return {
+                displaySetUID: typedDisplaySet?.displaySetId ?? displaySetId,
+                displaySet: registered,
+                instance,
+                imageIds,
+                volumeId: genericRegistration?.volumeId,
+                modality: instance?.Modality ??
+                    (imageIds?.length
+                        ? metaData.get('generalSeriesModule', imageIds[0])?.modality
+                        : undefined),
+            };
+        });
+    }
+    static getExemplarInstance(imageIds) {
+        if (!imageIds?.length) {
+            return;
+        }
+        return metaData.get('instance', imageIds[0]);
+    }
+    static findCachedStatsTargetId(data, referencedId) {
+        if (!data?.cachedStats) {
+            return;
+        }
+        return Object.keys(data.cachedStats).find((key) => key.startsWith('volumeId:') && csUtils.getVolumeId(key) === referencedId);
+    }
+    ensureCachedStatsTargets(data, targetIds, needsUpdate) {
+        let missing = false;
+        const cachedStats = (data.cachedStats ??= {});
+        for (const targetId of targetIds) {
+            const stats = cachedStats[targetId];
+            if (!stats || needsUpdate?.(stats)) {
+                cachedStats[targetId] = {};
+                missing = true;
+            }
         }
-        throw new Error('getTargetId: viewport must have a getViewReferenceId method');
+        return missing;
     }
     undo() {
         this.doneEditMemo();

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

@@ -1,4 +1,6 @@
 import BaseTool from './BaseTool.js';
 import AnnotationTool from './AnnotationTool.js';
 import AnnotationDisplayTool from './AnnotationDisplayTool.js';
-export { BaseTool, AnnotationTool, AnnotationDisplayTool };
+import measurementTargetFilters from './measurementTargetFilters.js';
+export { BaseTool, AnnotationTool, AnnotationDisplayTool, measurementTargetFilters, };
+export * from './measurementTargetFilters.js';