@cornerstonejs/tools 4.12.3 → 4.12.5

package/dist/esm/tools/SculptorTool.js

@@ -1,6 +1,7 @@
-import { getEnabledElement } from '@cornerstonejs/core';
+import { getEnabledElement, utilities } from '@cornerstonejs/core';
+import { vec3 } from 'gl-matrix';
 import { BaseTool } from './base';
-import { getAnnotations } from '../stateManagement';
+import { getAnnotations, getAnnotation } from '../stateManagement';
 import { point } from '../utilities/math';
 import { Events, ToolModes, AnnotationStyleStates, ChangeTypes, } from '../enums';
 import { triggerAnnotationRenderForViewportIds } from '../utilities/triggerAnnotationRenderForViewportIds';
@@ -10,6 +11,8 @@ import { triggerAnnotationModified } from '../stateManagement/annotation/helpers
 import CircleSculptCursor from './SculptorTool/CircleSculptCursor';
 import { distancePointToContour } from './distancePointToContour';
 import { getToolGroupForViewport } from '../store/ToolGroupManager';
+import { getSignedArea, containsPoint } from '../utilities/math/polyline';
+const { isEqual } = utilities;
 class SculptorTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -21,7 +24,6 @@ class SculptorTool extends BaseTool {
             ],
             toolShape: 'circle',
             referencedToolName: 'PlanarFreehandROI',
-            updateCursorSize: 'dynamic',
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -32,10 +34,12 @@ class SculptorTool extends BaseTool {
             viewportIdsToRender: [],
             isEditingOpenContour: false,
             canvasLocation: undefined,
+            external: true,
+            closed: false,
         };
         this.preMouseDownCallback = (evt) => {
             const eventData = evt.detail;
-            const element = eventData.element;
+            const { element } = eventData;
             this.configureToolSize(evt);
             this.selectFreehandTool(eventData);
             if (this.commonData.activeAnnotationUID === null) {
@@ -58,14 +62,11 @@ class SculptorTool extends BaseTool {
         this.endCallback = (evt) => {
             const eventData = evt.detail;
             const { element } = eventData;
-            const config = this.configuration;
-            const enabledElement = getEnabledElement(element);
             this.isActive = false;
             this.deactivateModify(element);
             resetElementCursor(element);
-            const { renderingEngineId, viewportId } = enabledElement;
-            const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
-            const toolInstance = toolGroup.getToolInstance(config.referencedToolName);
+            const toolInstance = this.getToolInstance(element);
+            toolInstance.doneEditMemo?.();
             const annotations = this.filterSculptableAnnotationsForElement(element);
             const activeAnnotation = annotations.find((annotation) => annotation.annotationUID === this.commonData.activeAnnotationUID);
             if (toolInstance.configuration.calculateStats) {
@@ -101,15 +102,209 @@ class SculptorTool extends BaseTool {
         this.sculptData = {
             mousePoint: eventData.currentPoints.world,
             mouseCanvasPoint: eventData.currentPoints.canvas,
-            deltaWorld: eventData.deltaPoints.world,
             points,
             maxSpacing: cursorShape.getMaxSpacing(config.minSpacing),
             element: element,
+            contours: [
+                {
+                    annotationUID: this.commonData.activeAnnotationUID,
+                    points,
+                },
+            ],
         };
-        const pushedHandles = cursorShape.pushHandles(viewport, this.sculptData);
-        if (pushedHandles.first !== undefined) {
-            this.insertNewHandles(pushedHandles);
+        const intersections = this.intersect(viewport, cursorShape);
+        if (!intersections.length) {
+            return;
+        }
+        const contourSelections = this.getContourSelections(intersections, points.length);
+        const { closed } = this.commonData;
+        for (const contour of contourSelections) {
+            const newPoints = new Array();
+            const lastExit = contour[contour.length - 1];
+            let lastIndex = closed ? lastExit.relIndex : 0;
+            let lastEnter;
+            for (const intersection of contour) {
+                if (intersection.isEnter) {
+                    pushArr(newPoints, points, lastIndex, intersection.index);
+                    lastEnter = intersection;
+                }
+                else {
+                    this.interpolatePoints(viewport, lastEnter, intersection, points, newPoints);
+                }
+                lastIndex = intersection.index;
+            }
+            if (contourSelections.length > 1) {
+                const signedArea = getSignedArea(newPoints.map(viewport.worldToCanvas));
+                if (signedArea < 0) {
+                    console.warn('Skipping internal area');
+                    continue;
+                }
+            }
+            if (!closed && lastIndex < points.length - 1) {
+                pushArr(newPoints, points, lastIndex);
+            }
+            points.splice(0, points.length);
+            pushArr(points, newPoints);
+            return;
+        }
+    }
+    intersect(viewport, cursorShape) {
+        const { contours, mousePoint, mouseCanvasPoint } = this.sculptData;
+        const { closed } = this.commonData;
+        cursorShape.computeWorldRadius(viewport);
+        const result = new Array();
+        for (const contour of contours) {
+            const { annotationUID, points } = contour;
+            let lastIn = false;
+            let anyIn = false;
+            let anyOut = false;
+            const { length } = points;
+            for (let i = 0; i <= length; i++) {
+                const index = i % length;
+                const point = points[index];
+                const inCursor = cursorShape.isInCursor(point, mousePoint);
+                anyIn ||= inCursor;
+                anyOut ||= !inCursor;
+                if (i === 0) {
+                    lastIn = inCursor;
+                    if (!closed && inCursor) {
+                        const edge = cursorShape.getEdge(viewport, point, null, mouseCanvasPoint);
+                        result.push({
+                            annotationUID,
+                            isEnter: inCursor,
+                            index: i,
+                            point: edge.point,
+                            angle: edge.angle,
+                        });
+                    }
+                    continue;
+                }
+                if (index === 0 && !closed) {
+                    if (lastIn) {
+                        const edge = cursorShape.getEdge(viewport, points[length - 1], null, mouseCanvasPoint);
+                        result.push({
+                            annotationUID,
+                            isEnter: false,
+                            index: length - 1,
+                            point: edge.point,
+                            angle: edge.angle,
+                        });
+                    }
+                    continue;
+                }
+                if (lastIn === inCursor) {
+                    continue;
+                }
+                lastIn = inCursor;
+                const edge = cursorShape.getEdge(viewport, point, points[i - 1], mouseCanvasPoint);
+                result.push({
+                    annotationUID,
+                    isEnter: inCursor,
+                    index: i,
+                    point: edge.point,
+                    angle: edge.angle,
+                });
+            }
+        }
+        return result;
+    }
+    interpolatePoints(viewport, enter, exit, existing, newPoints) {
+        const { external, closed } = this.commonData;
+        const p0 = existing[enter.index % existing.length];
+        const p1 = existing[exit.index % existing.length];
+        const v = vec3.sub(vec3.create(), p1, p0);
+        if (isEqual(vec3.length(v), 0)) {
+            return;
+        }
+        const cursorShape = this.registeredShapes.get(this.selectedShape);
+        const a0 = (enter.angle + 2 * Math.PI) % (Math.PI * 2);
+        const a1 = (exit.angle + 2 * Math.PI) % (Math.PI * 2);
+        let ae = a1 < a0 ? a1 + 2 * Math.PI : a1;
+        const aeAlt = a1 > a0 ? a1 - 2 * Math.PI : a1;
+        if ((external && !closed && Math.abs(aeAlt - a0) < Math.abs(ae - a0)) ||
+            (external && closed)) {
+            ae = aeAlt;
+        }
+        const count = Math.ceil(Math.abs(a0 - ae) / 0.25);
+        for (let i = 0; i <= count; i++) {
+            const a = (a0 * (count - i) + i * ae) / count;
+            newPoints.push(cursorShape.interpolatePoint(viewport, a, this.sculptData.mouseCanvasPoint));
+        }
+    }
+    getContourSelections(intersections, pointLength) {
+        const result = new Array();
+        const enterLength = intersections.length / 2;
+        if (!enterLength || intersections.length % 2) {
+            return result;
+        }
+        let lastAngle = Number.NEGATIVE_INFINITY;
+        for (let enterCount = 0; enterCount < enterLength; enterCount++) {
+            const enter = this.findNext(intersections, lastAngle);
+            if (!enter) {
+                console.error("Couldnt' find an entry");
+                continue;
+            }
+            const exit = this.findNext(intersections, enter.angle, false);
+            if (!exit) {
+                console.error("Couldn't find an exit for", enter);
+                continue;
+            }
+            exit.relIndex ||=
+                exit.index < enter.index ? exit.index + pointLength : exit.index;
+            result.push([enter, exit]);
+        }
+        result.sort((a, b) => a[0].index - b[0].index);
+        for (let i = 0; i < result.length - 1;) {
+            const testIntersection = result[i];
+            const mergeableResult = this.findMergeable(result, testIntersection, i);
+            if (mergeableResult) {
+                testIntersection.push(...mergeableResult);
+            }
+            else {
+                i++;
+            }
+        }
+        if (result.length > 1) {
+            console.warn('************* More than 1 result', result);
         }
+        return result;
+    }
+    findMergeable(contours, testIntersection, currentIndex) {
+        const end = testIntersection[testIntersection.length - 1];
+        for (let i = currentIndex + 1; i < contours.length; i++) {
+            const [enter] = contours[i];
+            if (enter.index >= end.relIndex) {
+                const contour = contours[i];
+                contours.splice(i, 1);
+                return contour;
+            }
+        }
+    }
+    findNext(intersections, lastAngle, isEnter = true) {
+        if (intersections.length === 1) {
+            const [intersection] = intersections;
+            intersections.splice(0, 1);
+            return intersection;
+        }
+        let foundItem;
+        let testAngle;
+        for (let i = 0; i < intersections.length; i++) {
+            const intersection = intersections[i];
+            if (intersection.isEnter == isEnter) {
+                const relativeAngle = (intersection.angle - lastAngle + 2 * Math.PI) % (2 * Math.PI);
+                if (!foundItem || relativeAngle < testAngle) {
+                    foundItem = { i, intersection };
+                    testAngle = relativeAngle;
+                }
+            }
+        }
+        if (!foundItem) {
+            console.warn("Couldn't find an exit point for entry", JSON.stringify(intersections));
+            return;
+        }
+        intersections.splice(foundItem.i, 1);
+        const { intersection } = foundItem;
+        return intersection;
     }
     interpolatePointsWithinMaxSpacing(i, points, indicesToInsertAfter, maxSpacing) {
         const { element } = this.sculptData;
@@ -127,7 +322,7 @@ class SculptorTool extends BaseTool {
         const eventData = evt.detail;
         const element = eventData.element;
         const enabledElement = getEnabledElement(element);
-        const { renderingEngine, viewport } = enabledElement;
+        const { viewport } = enabledElement;
         this.commonData.viewportIdsToRender = [viewport.id];
         const annotations = this.filterSculptableAnnotationsForElement(element);
         if (!annotations?.length) {
@@ -141,20 +336,22 @@ class SculptorTool extends BaseTool {
         else {
             const cursorShape = this.registeredShapes.get(this.selectedShape);
             const canvasCoords = eventData.currentPoints.canvas;
-            if (this.configuration.updateCursorSize === 'dynamic') {
-                cursorShape.updateToolSize(canvasCoords, viewport, activeAnnotation);
-            }
+            cursorShape.updateToolSize(canvasCoords, viewport, activeAnnotation);
         }
         triggerAnnotationRenderForViewportIds(this.commonData.viewportIdsToRender);
     }
-    filterSculptableAnnotationsForElement(element) {
-        const config = this.configuration;
+    getToolInstance(element) {
         const enabledElement = getEnabledElement(element);
         const { renderingEngineId, viewportId } = enabledElement;
-        const sculptableAnnotations = [];
         const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
-        const toolInstance = toolGroup.getToolInstance(config.referencedToolName);
-        config.referencedToolNames.forEach((referencedToolName) => {
+        const toolInstance = toolGroup.getToolInstance(this.configuration.referencedToolName);
+        return toolInstance;
+    }
+    filterSculptableAnnotationsForElement(element) {
+        const { configuration } = this;
+        const sculptableAnnotations = [];
+        const toolInstance = this.getToolInstance(element);
+        configuration.referencedToolNames.forEach((referencedToolName) => {
             const annotations = getAnnotations(referencedToolName, element);
             if (annotations) {
                 sculptableAnnotations.push(...annotations);
@@ -166,42 +363,25 @@ class SculptorTool extends BaseTool {
         const cursorShape = this.registeredShapes.get(this.selectedShape);
         cursorShape.configureToolSize(evt);
     }
-    insertNewHandles(pushedHandles) {
-        const indicesToInsertAfter = this.findNewHandleIndices(pushedHandles);
-        let newIndexModifier = 0;
-        for (let i = 0; i < indicesToInsertAfter?.length; i++) {
-            const insertIndex = indicesToInsertAfter[i] + 1 + newIndexModifier;
-            this.insertHandleRadially(insertIndex);
-            newIndexModifier++;
-        }
-    }
-    findNewHandleIndices(pushedHandles) {
-        const { points, maxSpacing } = this.sculptData;
-        const indicesToInsertAfter = [];
-        for (let i = pushedHandles.first; i <= pushedHandles.last; i++) {
-            this.interpolatePointsWithinMaxSpacing(i, points, indicesToInsertAfter, maxSpacing);
-        }
-        return indicesToInsertAfter;
-    }
-    insertHandleRadially(insertIndex) {
-        const { points } = this.sculptData;
-        if (insertIndex > points.length - 1 &&
-            this.commonData.isEditingOpenContour) {
-            return;
-        }
-        const cursorShape = this.registeredShapes.get(this.selectedShape);
-        const previousIndex = insertIndex - 1;
-        const nextIndex = contourIndex(insertIndex, points.length);
-        const insertPosition = cursorShape.getInsertPosition(previousIndex, nextIndex, this.sculptData);
-        const handleData = insertPosition;
-        points.splice(insertIndex, 0, handleData);
-    }
     selectFreehandTool(eventData) {
         const closestAnnotationUID = this.getClosestFreehandToolOnElement(eventData);
         if (closestAnnotationUID === undefined) {
             return;
         }
+        const annotation = getAnnotation(closestAnnotationUID);
         this.commonData.activeAnnotationUID = closestAnnotationUID;
+        this.commonData.closed = annotation.data.contour.closed;
+        this.commonData.external = true;
+        if (this.commonData.closed) {
+            const { element } = eventData;
+            const enabledElement = getEnabledElement(element);
+            const { viewport } = enabledElement;
+            const polyline = annotation.data.contour.polyline.map((p) => viewport.worldToCanvas(p));
+            const canvasPoint = eventData.currentPoints.canvas;
+            this.commonData.external = !containsPoint(polyline, canvasPoint, {
+                closed: true,
+            });
+        }
     }
     getClosestFreehandToolOnElement(eventData) {
         const { element } = eventData;
@@ -239,6 +419,9 @@ class SculptorTool extends BaseTool {
         return closest.annotationUID;
     }
     activateModify(element) {
+        const annotation = getAnnotation(this.commonData.activeAnnotationUID);
+        const instance = this.getToolInstance(element);
+        instance.createMemo?.(element, annotation);
         element.addEventListener(Events.MOUSE_UP, this.endCallback);
         element.addEventListener(Events.MOUSE_CLICK, this.endCallback);
         element.addEventListener(Events.MOUSE_DRAG, this.dragCallback);
@@ -286,6 +469,14 @@ class SculptorTool extends BaseTool {
         });
     }
 }
+function pushArr(dest, src, start = 0, end = src.length) {
+    if (end < start) {
+        end = end + src.length;
+    }
+    for (let i = start; i < end; i++) {
+        dest.push(src[i % src.length]);
+    }
+}
 export const contourIndex = (i, length) => {
     return (i + length) % length;
 };

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

@@ -39,9 +39,7 @@ declare class BidirectionalTool extends AnnotationTool {
     _deactivateModify: (element: any) => void;
     renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
     _movingLongAxisWouldPutItThroughShortAxis: (firstLineSegment: any, secondLineSegment: any) => boolean;
-    _calculateLength(pos1: any, pos2: any): number;
     _calculateCachedStats: (annotation: any, renderingEngine: any, enabledElement: any) => any;
-    _isInsideVolume: (index1: any, index2: any, index3: any, index4: any, dimensions: any) => boolean;
     _getSignedAngle: (vector1: any, vector2: any) => number;
 }
 export default BidirectionalTool;

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

@@ -9,7 +9,7 @@ import { isAnnotationVisible } from '../../stateManagement/annotation/annotation
 import { triggerAnnotationCompleted, triggerAnnotationModified, } from '../../stateManagement/annotation/helpers/state';
 import { drawLine as drawLineSvg, drawHandles as drawHandlesSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, } from '../../drawingSvg';
 import { state } from '../../store/state';
-import { ChangeTypes, Events } from '../../enums';
+import { ChangeTypes, Events, MeasurementType } from '../../enums';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import * as lineSegment from '../../utilities/math/line';
 import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
@@ -610,28 +610,36 @@ class BidirectionalTool extends AnnotationTool {
                     continue;
                 }
                 const { imageData, dimensions } = image;
-                const index1 = transformWorldToIndex(imageData, worldPos1);
-                const index2 = transformWorldToIndex(imageData, worldPos2);
-                const index3 = transformWorldToIndex(imageData, worldPos3);
-                const index4 = transformWorldToIndex(imageData, worldPos4);
-                const handles1 = [index1, index2];
-                const handles2 = [index3, index4];
-                const { scale: scale1, unit: units1 } = getCalibratedLengthUnitsAndScale(image, handles1);
-                const { scale: scale2, unit: units2 } = getCalibratedLengthUnitsAndScale(image, handles2);
-                const dist1 = this._calculateLength(worldPos1, worldPos2) / scale1;
-                const dist2 = this._calculateLength(worldPos3, worldPos4) / scale2;
+                const handles = data.handles.points.map((point) => imageData.worldToIndex(point));
+                const handles1 = handles.slice(0, 2);
+                const handles2 = handles.slice(2, 4);
+                const calibrate = getCalibratedLengthUnitsAndScale(image, handles);
+                const dist1 = BidirectionalTool.calculateLengthInIndex(calibrate, handles1);
+                const dist2 = BidirectionalTool.calculateLengthInIndex(calibrate, handles2);
+                const { unit } = calibrate;
                 const length = dist1 > dist2 ? dist1 : dist2;
                 const width = dist1 > dist2 ? dist2 : dist1;
-                const unit = dist1 > dist2 ? units1 : units2;
-                const widthUnit = dist1 > dist2 ? units2 : units1;
-                this._isInsideVolume(index1, index2, index3, index4, dimensions)
-                    ? (this.isHandleOutsideImage = false)
-                    : (this.isHandleOutsideImage = true);
+                const widthUnit = unit;
+                this.isHandleOutsideImage = !BidirectionalTool.isInsideVolume(dimensions, handles);
                 cachedStats[targetId] = {
                     length,
                     width,
                     unit,
                     widthUnit,
+                    statsArray: [
+                        {
+                            value: length,
+                            name: 'height',
+                            unit,
+                            type: MeasurementType.Linear,
+                        },
+                        {
+                            value: width,
+                            name: 'width',
+                            unit,
+                            type: MeasurementType.Linear,
+                        },
+                    ],
                 };
             }
             const invalidated = annotation.invalidated;
@@ -641,12 +649,6 @@ class BidirectionalTool extends AnnotationTool {
             }
             return cachedStats;
         };
-        this._isInsideVolume = (index1, index2, index3, index4, dimensions) => {
-            return (csUtils.indexWithinDimensions(index1, dimensions) &&
-                csUtils.indexWithinDimensions(index2, dimensions) &&
-                csUtils.indexWithinDimensions(index3, dimensions) &&
-                csUtils.indexWithinDimensions(index4, dimensions));
-        };
         this._getSignedAngle = (vector1, vector2) => {
             return Math.atan2(vector1[0] * vector2[1] - vector1[1] * vector2[0], vector1[0] * vector2[0] + vector1[1] * vector2[1]);
         };
@@ -726,12 +728,6 @@ class BidirectionalTool extends AnnotationTool {
         triggerAnnotationRenderForViewportIds([viewport.id]);
         return annotation;
     }; }
-    _calculateLength(pos1, pos2) {
-        const dx = pos1[0] - pos2[0];
-        const dy = pos1[1] - pos2[1];
-        const dz = pos1[2] - pos2[2];
-        return Math.sqrt(dx * dx + dy * dy + dz * dz);
-    }
 }
 function defaultGetTextLines(data, targetId) {
     const { cachedStats, label } = data;

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

@@ -30,8 +30,7 @@ declare class CircleROITool extends AnnotationTool {
     _activateDraw: (element: any) => void;
     _deactivateDraw: (element: any) => void;
     renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
-    _calculateCachedStats: (annotation: any, viewport: any, renderingEngine: any, enabledElement: any) => any;
-    _isInsideVolume: (index1: any, index2: any, dimensions: any) => boolean;
+    _calculateCachedStats: (annotation: any, viewport: any, _renderingEngine: any, _enabledElement: any) => any;
     static hydrate: (viewportId: string, points: Types.Point3[], options?: {
         annotationUID?: string;
         toolInstance?: CircleROITool;

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

@@ -1,6 +1,7 @@
-import { AnnotationTool } from '../base';
+import { AnnotationTool, BaseTool } from '../base';
+import { vec2, vec3 } from 'gl-matrix';
 import { getEnabledElement, VolumeViewport, utilities as csUtils, getEnabledElementByViewportId, EPSILON, } from '@cornerstonejs/core';
-import { getCalibratedAspect, getCalibratedLengthUnitsAndScale, } from '../../utilities/getCalibratedUnits';
+import { getCalibratedLengthUnitsAndScale } from '../../utilities/getCalibratedUnits';
 import throttle from '../../utilities/throttle';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
@@ -8,10 +9,9 @@ import { isAnnotationVisible } from '../../stateManagement/annotation/annotation
 import { triggerAnnotationCompleted, triggerAnnotationModified, } from '../../stateManagement/annotation/helpers/state';
 import { drawCircle as drawCircleSvg, drawHandles as drawHandlesSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, } from '../../drawingSvg';
 import { state } from '../../store/state';
-import { ChangeTypes, Events } from '../../enums';
+import { ChangeTypes, Events, MeasurementType } from '../../enums';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
-import getWorldWidthAndHeightFromTwoPoints from '../../utilities/planar/getWorldWidthAndHeightFromTwoPoints';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { getPixelValueUnits } from '../../utilities/getPixelValueUnits';
@@ -19,7 +19,6 @@ import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScale
 import { getCanvasCircleCorners, getCanvasCircleRadius, } from '../../utilities/math/circle';
 import { pointInEllipse } from '../../utilities/math/ellipse';
 import { BasicStatsCalculator } from '../../utilities/math/basic';
-import { vec2, vec3 } from 'gl-matrix';
 import { getStyleProperty } from '../../stateManagement/annotation/config/helpers';
 const { transformWorldToIndex } = csUtils;
 class CircleROITool extends AnnotationTool {
@@ -473,25 +472,22 @@ class CircleROITool extends AnnotationTool {
             }
             return renderStatus;
         };
-        this._calculateCachedStats = (annotation, viewport, renderingEngine, enabledElement) => {
+        this._calculateCachedStats = (annotation, viewport, _renderingEngine, _enabledElement) => {
             if (!this.configuration.calculateStats) {
                 return;
             }
-            const data = annotation.data;
+            const { data } = annotation;
             const { element } = viewport;
             const wasInvalidated = annotation.invalidated;
             const { points } = data.handles;
             const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
             const canvasCenter = canvasCoordinates[0];
             const canvasTop = canvasCoordinates[1];
-            const { viewPlaneNormal, viewUp } = viewport.getCamera();
             const [topLeftCanvas, bottomRightCanvas] = (getCanvasCircleCorners([canvasCenter, canvasTop]));
             const topLeftWorld = viewport.canvasToWorld(topLeftCanvas);
             const bottomRightWorld = viewport.canvasToWorld(bottomRightCanvas);
             const { cachedStats } = data;
             const targetIds = Object.keys(cachedStats);
-            const worldPos1 = topLeftWorld;
-            const worldPos2 = bottomRightWorld;
             for (let i = 0; i < targetIds.length; i++) {
                 const targetId = targetIds[i];
                 const image = this.getTargetImageData(targetId);
@@ -499,15 +495,49 @@ class CircleROITool extends AnnotationTool {
                     continue;
                 }
                 const { dimensions, imageData, metadata, voxelManager } = image;
-                const pos1Index = transformWorldToIndex(imageData, worldPos1);
-                pos1Index[0] = Math.floor(pos1Index[0]);
-                pos1Index[1] = Math.floor(pos1Index[1]);
-                pos1Index[2] = Math.floor(pos1Index[2]);
-                const pos2Index = transformWorldToIndex(imageData, worldPos2);
-                pos2Index[0] = Math.floor(pos2Index[0]);
-                pos2Index[1] = Math.floor(pos2Index[1]);
-                pos2Index[2] = Math.floor(pos2Index[2]);
-                if (this._isInsideVolume(pos1Index, pos2Index, dimensions)) {
+                const handles = points.map((point) => imageData.worldToIndex(point));
+                const calibrate = getCalibratedLengthUnitsAndScale(image, handles);
+                const radius = CircleROITool.calculateLengthInIndex(calibrate, handles);
+                const area = Math.PI * radius * radius;
+                const perimeter = 2 * Math.PI * radius;
+                const isEmptyArea = radius === 0;
+                const { unit, areaUnit } = calibrate;
+                const namedArea = {
+                    name: 'area',
+                    value: area,
+                    unit: areaUnit,
+                    type: MeasurementType.Area,
+                };
+                const namedCircumference = {
+                    name: 'circumference',
+                    value: perimeter,
+                    unit,
+                    type: MeasurementType.Linear,
+                };
+                const namedRadius = {
+                    name: 'radius',
+                    value: radius,
+                    unit,
+                    type: MeasurementType.Linear,
+                };
+                const statsArray = [namedArea, namedRadius, namedCircumference];
+                cachedStats[targetId] = {
+                    Modality: metadata.Modality,
+                    area,
+                    isEmptyArea,
+                    areaUnit,
+                    radius,
+                    radiusUnit: unit,
+                    perimeter,
+                    statsArray,
+                };
+                const pos1Index = transformWorldToIndex(imageData, topLeftWorld);
+                const pos2Index = transformWorldToIndex(imageData, bottomRightWorld);
+                this.isHandleOutsideImage = !BaseTool.isInsideVolume(dimensions, [
+                    pos1Index,
+                    pos2Index,
+                ]);
+                if (!this.isHandleOutsideImage) {
                     const iMin = Math.min(pos1Index[0], pos2Index[0]);
                     const iMax = Math.max(pos1Index[0], pos2Index[0]);
                     const jMin = Math.min(pos1Index[1], pos2Index[1]);
@@ -529,14 +559,6 @@ class CircleROITool extends AnnotationTool {
                         yRadius: yRadius < EPSILON / 2 ? 0 : yRadius,
                         zRadius: zRadius < EPSILON / 2 ? 0 : zRadius,
                     };
-                    const { worldWidth, worldHeight } = getWorldWidthAndHeightFromTwoPoints(viewPlaneNormal, viewUp, worldPos1, worldPos2);
-                    const isEmptyArea = worldWidth === 0 && worldHeight === 0;
-                    const handles = [pos1Index, pos2Index];
-                    const { scale, unit, areaUnit } = getCalibratedLengthUnitsAndScale(image, handles);
-                    const aspect = getCalibratedAspect(image);
-                    const area = Math.abs(Math.PI *
-                        (worldWidth / scale / 2) *
-                        (worldHeight / aspect / scale / 2));
                     const pixelUnitsOptions = {
                         isPreScaled: isViewportPreScaled(viewport, targetId),
                         isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
@@ -553,26 +575,15 @@ class CircleROITool extends AnnotationTool {
                     }
                     const stats = this.configuration.statsCalculator.getStatistics();
                     cachedStats[targetId] = {
+                        ...cachedStats[targetId],
                         Modality: metadata.Modality,
-                        area,
                         mean: stats.mean?.value,
                         max: stats.max?.value,
                         min: stats.min?.value,
                         pointsInShape,
                         stdDev: stats.stdDev?.value,
-                        statsArray: stats.array,
-                        isEmptyArea,
-                        areaUnit,
-                        radius: worldWidth / 2 / scale,
-                        radiusUnit: unit,
-                        perimeter: (2 * Math.PI * (worldWidth / 2)) / scale,
                         modalityUnit,
-                    };
-                }
-                else {
-                    this.isHandleOutsideImage = true;
-                    cachedStats[targetId] = {
-                        Modality: metadata.Modality,
+                        statsArray: [...statsArray, ...stats.array],
                     };
                 }
             }
@@ -582,10 +593,6 @@ class CircleROITool extends AnnotationTool {
             }
             return cachedStats;
         };
-        this._isInsideVolume = (index1, index2, dimensions) => {
-            return (csUtils.indexWithinDimensions(index1, dimensions) &&
-                csUtils.indexWithinDimensions(index2, dimensions));
-        };
         this._throttledCalculateCachedStats = throttle(this._calculateCachedStats, 100, { trailing: true });
     }
     static { this.hydrate = (viewportId, points, options) => {