@cornerstonejs/tools 5.5.0 → 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,7 +21,8 @@ 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';
-const { transformWorldToIndex } = csUtils;
+import { defaultAreaGetTextLines } from '../../utilities/defaultGetTextLines.js';
+const { transformWorldToIndex, transformWorldToIndexContinuous } = csUtils;
 class RectangleROITool extends AnnotationTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -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);
@@ -442,11 +439,12 @@ class RectangleROITool extends AnnotationTool {
                     continue;
                 }
                 const { dimensions, imageData, metadata, voxelManager } = image;
-                const indexHandles = worldHandles.map((worldHandle) => transformWorldToIndex(imageData, worldHandle));
-                const pos1Index = indexHandles[0].map(Math.floor);
-                const pos2Index = indexHandles[3].map(Math.floor);
-                if (this._isInsideVolume(pos1Index, pos2Index, dimensions)) {
-                    this.isHandleOutsideImage = false;
+                const continuousIndexHandles = worldHandles.map((worldHandle) => transformWorldToIndexContinuous(imageData, worldHandle));
+                const pos1Index = transformWorldToIndex(imageData, worldHandles[0]);
+                const pos2Index = transformWorldToIndex(imageData, worldHandles[3]);
+                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]);
@@ -461,12 +459,12 @@ class RectangleROITool extends AnnotationTool {
                     const handles = [pos1Index, pos2Index];
                     const calibrate = getCalibratedLengthUnitsAndScale(image, handles);
                     const width = _a.calculateLengthInIndex(calibrate, [
-                        indexHandles[0],
-                        indexHandles[1],
+                        continuousIndexHandles[0],
+                        continuousIndexHandles[1],
                     ]);
                     const height = _a.calculateLengthInIndex(calibrate, [
-                        indexHandles[0],
-                        indexHandles[2],
+                        continuousIndexHandles[0],
+                        continuousIndexHandles[2],
                     ]);
                     const area = Math.abs(width * height);
                     const { areaUnit } = calibrate;
@@ -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/annotation/UltrasoundDirectionalTool.js

@@ -12,7 +12,7 @@ import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnota
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor.js';
 import { getCalibratedProbeUnitsAndValue } from '../../utilities/getCalibratedUnits.js';
 import { lineSegment } from '../../utilities/math/index.js';
-const { transformWorldToIndex } = csUtils;
+const { transformWorldToIndexContinuous } = csUtils;
 class UltrasoundDirectionalTool extends AnnotationTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -375,8 +375,8 @@ class UltrasoundDirectionalTool extends AnnotationTool {
             const { imageData } = image;
             const worldPos1 = data.handles.points[0];
             const worldPos2 = data.handles.points[1];
-            const imageIndex1 = transformWorldToIndex(imageData, worldPos1);
-            const imageIndex2 = transformWorldToIndex(imageData, worldPos2);
+            const imageIndex1 = transformWorldToIndexContinuous(imageData, worldPos1);
+            const imageIndex2 = transformWorldToIndexContinuous(imageData, worldPos2);
             const { values: values1, units: units1 } = getCalibratedProbeUnitsAndValue(image, [imageIndex1]);
             const { values: values2, units: units2 } = getCalibratedProbeUnitsAndValue(image, [imageIndex2]);
             let xValues, yValues, units, isHorizontal;

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): {