@ohif/app 3.7.0-beta.63 → 3.7.0-beta.65

package/dist/{925.bundle.5e929605d3235ebcdebf.js → 116.bundle.422d1a76d8daccfed61d.js}

@@ -1,6 +1,6 @@
-(self["webpackChunk"] = self["webpackChunk"] || []).push([[925],{
+(self["webpackChunk"] = self["webpackChunk"] || []).push([[116],{
 
-/***/ 26925:
+/***/ 99116:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -10,6 +10,7 @@ __webpack_require__.r(__webpack_exports__);
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
   AngleTool: () => (/* reexport */ annotation_AngleTool),
+  AnnotationDisplayTool: () => (/* reexport */ base_AnnotationDisplayTool),
   AnnotationTool: () => (/* reexport */ base_AnnotationTool),
   ArrowAnnotateTool: () => (/* reexport */ annotation_ArrowAnnotateTool),
   BaseTool: () => (/* reexport */ base_BaseTool),
@@ -256,7 +257,9 @@ __webpack_require__.d(drawingSvg_namespaceObject, {
   drawLinkedTextBox: () => (drawingSvg_drawLinkedTextBox),
   drawPolyline: () => (drawPolyline),
   drawRect: () => (drawRect),
-  drawTextBox: () => (drawingSvg_drawTextBox)
+  drawTextBox: () => (drawingSvg_drawTextBox),
+  setAttributesIfNecessary: () => (drawingSvg_setAttributesIfNecessary),
+  setNewAttributesIfValid: () => (drawingSvg_setNewAttributesIfValid)
 });
 
 // NAMESPACE OBJECT: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/annotation/config/index.js
@@ -364,6 +367,14 @@ __webpack_require__.d(rectangle_namespaceObject, {
   distanceToPoint: () => (rectangle_distanceToPoint_distanceToPoint)
 });
 
+// NAMESPACE OBJECT: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/basic/index.js
+var basic_namespaceObject = {};
+__webpack_require__.r(basic_namespaceObject);
+__webpack_require__.d(basic_namespaceObject, {
+  BasicStatsCalculator: () => (BasicStatsCalculator),
+  Calculator: () => (basic_Calculator)
+});
+
 // NAMESPACE OBJECT: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/point/index.js
 var point_namespaceObject = {};
 __webpack_require__.r(point_namespaceObject);
@@ -396,6 +407,7 @@ __webpack_require__.d(polyline_namespaceObject, {
 var math_namespaceObject = {};
 __webpack_require__.r(math_namespaceObject);
 __webpack_require__.d(math_namespaceObject, {
+  BasicStatsCalculator: () => (basic_namespaceObject),
   ellipse: () => (ellipse_namespaceObject),
   lineSegment: () => (line_namespaceObject),
   point: () => (point_namespaceObject),
@@ -2250,8 +2262,15 @@ function keyListener(evt) {
     };
     (0,esm.triggerEvent)(eventDetail.element, enums_Events.KEY_DOWN, eventDetail);
     document.addEventListener('keyup', _onKeyUp);
+    document.addEventListener('visibilitychange', _onVisibilityChange);
     keyDownListener_state.element.removeEventListener('keydown', keyListener);
 }
+function _onVisibilityChange() {
+    document.removeEventListener('visibilitychange', _onVisibilityChange);
+    if (document.visibilityState === 'hidden') {
+        resetModifierKey();
+    }
+}
 function _onKeyUp(evt) {
     const eventDetail = {
         renderingEngineId: keyDownListener_state.renderingEngineId,
@@ -2261,6 +2280,7 @@ function _onKeyUp(evt) {
         keyCode: keyDownListener_state.keyCode,
     };
     document.removeEventListener('keyup', _onKeyUp);
+    document.removeEventListener('visibilitychange', _onVisibilityChange);
     keyDownListener_state.element.addEventListener('keydown', keyListener);
     keyDownListener_state = lodash_clonedeep_default()(keyDownListener_defaultState);
     (0,esm.triggerEvent)(eventDetail.element, enums_Events.KEY_UP, eventDetail);
@@ -4460,8 +4480,8 @@ function _getHash(annotationUID, drawingElementType, nodeUID) {
 }
 /* harmony default export */ const drawingSvg_getHash = (_getHash);
 
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/drawingSvg/_setAttributesIfNecessary.js
-function _setAttributesIfNecessary(attributes, svgNode) {
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/drawingSvg/setAttributesIfNecessary.js
+function setAttributesIfNecessary(attributes, svgNode) {
     Object.keys(attributes).forEach((key) => {
         const currentValue = svgNode.getAttribute(key);
         const newValue = attributes[key];
@@ -4473,10 +4493,10 @@ function _setAttributesIfNecessary(attributes, svgNode) {
         }
     });
 }
-/* harmony default export */ const drawingSvg_setAttributesIfNecessary = (_setAttributesIfNecessary);
+/* harmony default export */ const drawingSvg_setAttributesIfNecessary = (setAttributesIfNecessary);
 
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/drawingSvg/_setNewAttributesIfValid.js
-function _setNewAttributesIfValid(attributes, svgNode) {
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/drawingSvg/setNewAttributesIfValid.js
+function setNewAttributesIfValid(attributes, svgNode) {
     Object.keys(attributes).forEach((key) => {
         const newValue = attributes[key];
         if (newValue !== undefined && newValue !== '') {
@@ -4484,7 +4504,7 @@ function _setNewAttributesIfValid(attributes, svgNode) {
         }
     });
 }
-/* harmony default export */ const drawingSvg_setNewAttributesIfValid = (_setNewAttributesIfValid);
+/* harmony default export */ const drawingSvg_setNewAttributesIfValid = (setNewAttributesIfValid);
 
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/drawingSvg/drawCircle.js
 
@@ -5016,6 +5036,8 @@ function drawArrow(svgDrawingHelper, annotationUID, arrowUID, start, end, option
 
 
 
+
+
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/getToolsWithModesForElement.js
 
 
@@ -5491,8 +5513,8 @@ AnnotationDisplayTool.toolName = 'AnnotationDisplayTool';
 
 
 class AnnotationTool extends base_AnnotationDisplayTool {
-    constructor() {
-        super(...arguments);
+    constructor(toolProps, defaultToolProps) {
+        super(toolProps, defaultToolProps);
         this.mouseMoveCallback = (evt, filteredAnnotations) => {
             if (!filteredAnnotations) {
                 return false;
@@ -5523,6 +5545,13 @@ class AnnotationTool extends base_AnnotationDisplayTool {
             }
             return annotationsNeedToBeRedrawn;
         };
+        if (toolProps.configuration?.getTextLines) {
+            this.configuration.getTextLines = toolProps.configuration.getTextLines;
+        }
+        if (toolProps.configuration?.statsCalculator) {
+            this.configuration.statsCalculator =
+                toolProps.configuration.statsCalculator;
+        }
     }
     getHandleNearImagePoint(element, annotation, canvasCoords, proximity) {
         const enabledElement = (0,esm.getEnabledElement)(element);
@@ -5600,6 +5629,7 @@ AnnotationTool.toolName = 'AnnotationTool';
 
 
 
+
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/SegmentationDisplayTool.js
 
 
@@ -6232,6 +6262,7 @@ function pointInShapeCallback(imageData, pointInShapeFn, callback, boundsIJK) {
     const scanAxisStep = gl_matrix_esm/* vec3.fromValues */.R3.fromValues(scanAxisNormal[0] * scanAxisSpacing, scanAxisNormal[1] * scanAxisSpacing, scanAxisNormal[2] * scanAxisSpacing);
     const yMultiple = dimensions[0];
     const zMultiple = dimensions[0] * dimensions[1];
+    const pointsInShape = [];
     for (let k = kMin; k <= kMax; k++) {
         for (let j = jMin; j <= jMax; j++) {
             for (let i = iMin; i <= iMax; i++) {
@@ -6257,11 +6288,15 @@ function pointInShapeCallback(imageData, pointInShapeFn, callback, boundsIJK) {
                 if (pointInShapeFn(pointLPS, pointIJK)) {
                     const index = k * zMultiple + j * yMultiple + i;
                     const value = scalarData[index];
-                    callback({ value, index, pointIJK, pointLPS });
+                    pointsInShape.push({ value, index, pointIJK, pointLPS });
+                    if (callback !== null) {
+                        callback({ value, index, pointIJK, pointLPS });
+                    }
                 }
             }
         }
     }
+    return pointsInShape;
 }
 
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/sphere/pointInSphere.js
@@ -10625,6 +10660,7 @@ class BidirectionalTool extends base_AnnotationTool {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
             preventHandleOutsideImage: false,
+            getTextLines: defaultGetTextLines,
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -11145,7 +11181,7 @@ class BidirectionalTool extends base_AnnotationTool {
                     shadow,
                 }, dataId2);
                 renderStatus = true;
-                const textLines = this._getTextLines(data, targetId);
+                const textLines = this.configuration.getTextLines(data, targetId);
                 if (!textLines || textLines.length === 0) {
                     continue;
                 }
@@ -11186,18 +11222,6 @@ class BidirectionalTool extends base_AnnotationTool {
             const wouldPutThroughShortAxis = !proposedIntersectionPoint;
             return wouldPutThroughShortAxis;
         };
-        this._getTextLines = (data, targetId) => {
-            const { cachedStats } = data;
-            const { length, width, unit } = cachedStats[targetId];
-            if (length === undefined) {
-                return;
-            }
-            const textLines = [
-                `L: ${utilities_roundNumber(length)} ${unit}`,
-                `W: ${utilities_roundNumber(width)} ${unit}`,
-            ];
-            return textLines;
-        };
         this._calculateCachedStats = (annotation, renderingEngine, enabledElement) => {
             const { data } = annotation;
             const { viewportId, renderingEngineId } = enabledElement;
@@ -11321,6 +11345,18 @@ class BidirectionalTool extends base_AnnotationTool {
         return Math.sqrt(dx * dx + dy * dy + dz * dz);
     }
 }
+function defaultGetTextLines(data, targetId) {
+    const { cachedStats } = data;
+    const { length, width, unit } = cachedStats[targetId];
+    if (length === undefined) {
+        return;
+    }
+    const textLines = [
+        `L: ${utilities_roundNumber(length)} ${unit}`,
+        `W: ${utilities_roundNumber(width)} ${unit}`,
+    ];
+    return textLines;
+}
 BidirectionalTool.toolName = 'Bidirectional';
 /* harmony default export */ const annotation_BidirectionalTool = (BidirectionalTool);
 
@@ -11347,6 +11383,7 @@ class LengthTool extends base_AnnotationTool {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
             preventHandleOutsideImage: false,
+            getTextLines: LengthTool_defaultGetTextLines,
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -11645,7 +11682,7 @@ class LengthTool extends base_AnnotationTool {
                     console.warn('Rendering Engine has been destroyed');
                     return renderStatus;
                 }
-                const textLines = this._getTextLines(data, targetId);
+                const textLines = this.configuration.getTextLines(data, targetId);
                 if (!data.handles.textBox.hasMoved) {
                     const canvasTextBoxCoords = getTextBoxCoordsCanvas(canvasCoordinates);
                     data.handles.textBox.worldPosition =
@@ -11693,15 +11730,6 @@ class LengthTool extends base_AnnotationTool {
         utilities_triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
         evt.preventDefault();
     }
-    _getTextLines(data, targetId) {
-        const cachedVolumeStats = data.cachedStats[targetId];
-        const { length, unit } = cachedVolumeStats;
-        if (length === undefined || length === null || isNaN(length)) {
-            return;
-        }
-        const textLines = [`${utilities_roundNumber(length)} ${unit}`];
-        return textLines;
-    }
     _calculateLength(pos1, pos2) {
         const dx = pos1[0] - pos2[0];
         const dy = pos1[1] - pos2[1];
@@ -11749,6 +11777,15 @@ class LengthTool extends base_AnnotationTool {
             esm.utilities.indexWithinDimensions(index2, dimensions));
     }
 }
+function LengthTool_defaultGetTextLines(data, targetId) {
+    const cachedVolumeStats = data.cachedStats[targetId];
+    const { length, unit } = cachedVolumeStats;
+    if (length === undefined || length === null || isNaN(length)) {
+        return;
+    }
+    const textLines = [`${utilities_roundNumber(length)} ${unit}`];
+    return textLines;
+}
 LengthTool.toolName = 'Length';
 /* harmony default export */ const annotation_LengthTool = (LengthTool);
 
@@ -11815,6 +11852,7 @@ class ProbeTool extends base_AnnotationTool {
         configuration: {
             shadow: true,
             preventHandleOutsideImage: false,
+            getTextLines: ProbeTool_defaultGetTextLines,
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -12006,7 +12044,7 @@ class ProbeTool extends base_AnnotationTool {
                 const handleGroupUID = '0';
                 drawingSvg_drawHandles(svgDrawingHelper, annotationUID, handleGroupUID, [canvasCoordinates], { color });
                 renderStatus = true;
-                const textLines = this._getTextLines(data, targetId);
+                const textLines = this.configuration.getTextLines(data, targetId);
                 if (textLines) {
                     const textCanvasCoordinates = [
                         canvasCoordinates[0] + 6,
@@ -12050,17 +12088,6 @@ class ProbeTool extends base_AnnotationTool {
         utilities_triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
         evt.preventDefault();
     }
-    _getTextLines(data, targetId) {
-        const cachedVolumeStats = data.cachedStats[targetId];
-        const { index, value, modalityUnit } = cachedVolumeStats;
-        if (value === undefined) {
-            return;
-        }
-        const textLines = [];
-        textLines.push(`(${index[0]}, ${index[1]}, ${index[2]})`);
-        textLines.push(`${value.toFixed(2)} ${modalityUnit}`);
-        return textLines;
-    }
     _calculateCachedStats(annotation, renderingEngine, enabledElement, modalityUnitOptions) {
         const data = annotation.data;
         const { viewportId, renderingEngineId } = enabledElement;
@@ -12119,6 +12146,17 @@ class ProbeTool extends base_AnnotationTool {
         return cachedStats;
     }
 }
+function ProbeTool_defaultGetTextLines(data, targetId) {
+    const cachedVolumeStats = data.cachedStats[targetId];
+    const { index, value, modalityUnit } = cachedVolumeStats;
+    if (value === undefined) {
+        return;
+    }
+    const textLines = [];
+    textLines.push(`(${index[0]}, ${index[1]}, ${index[2]})`);
+    textLines.push(`${value.toFixed(2)} ${modalityUnit}`);
+    return textLines;
+}
 ProbeTool.toolName = 'Probe';
 /* harmony default export */ const annotation_ProbeTool = (ProbeTool);
 
@@ -12136,6 +12174,7 @@ class DragProbeTool extends annotation_ProbeTool {
         configuration: {
             shadow: true,
             preventHandleOutsideImage: false,
+            getTextLines: DragProbeTool_defaultGetTextLines,
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -12227,7 +12266,7 @@ class DragProbeTool extends annotation_ProbeTool {
             const handleGroupUID = '0';
             drawingSvg_drawHandles(svgDrawingHelper, annotationUID, handleGroupUID, [canvasCoordinates], { color });
             renderStatus = true;
-            const textLines = this._getTextLines(data, targetId);
+            const textLines = this.configuration.getTextLines(data, targetId);
             if (textLines) {
                 const textCanvasCoordinates = [
                     canvasCoordinates[0] + 6,
@@ -12240,6 +12279,17 @@ class DragProbeTool extends annotation_ProbeTool {
         };
     }
 }
+function DragProbeTool_defaultGetTextLines(data, targetId) {
+    const cachedVolumeStats = data.cachedStats[targetId];
+    const { index, value, modalityUnit } = cachedVolumeStats;
+    if (value === undefined) {
+        return;
+    }
+    const textLines = [];
+    textLines.push(`(${index[0]}, ${index[1]}, ${index[2]})`);
+    textLines.push(`${value.toFixed(2)} ${modalityUnit}`);
+    return textLines;
+}
 DragProbeTool.toolName = 'DragProbe';
 /* harmony default export */ const annotation_DragProbeTool = (DragProbeTool);
 
@@ -12291,6 +12341,53 @@ function rectangle_distanceToPoint_distanceToPoint(rect, point) {
 
 
 
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/basic/Calculator.js
+class Calculator {
+}
+/* harmony default export */ const basic_Calculator = (Calculator);
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/basic/BasicStatsCalculator.js
+
+class BasicStatsCalculator extends basic_Calculator {
+    static { this.max = -Infinity; }
+    static { this.currentMax = 0; }
+    static { this.sum = 0; }
+    static { this.sumSquares = 0; }
+    static { this.squaredDiffSum = 0; }
+    static { this.count = 0; }
+    static { this.statsCallback = ({ value: newValue }) => {
+        if (newValue > this.max) {
+            this.max = newValue;
+            this.currentMax = newValue;
+        }
+        this.count += 1;
+        this.sum += newValue;
+        this.sumSquares += newValue ** 2;
+        this.squaredDiffSum += Math.pow(newValue - this.sum / this.count, 2);
+    }; }
+    static { this.getStatistics = () => {
+        const mean = this.sum / this.count;
+        const stdDev = Math.sqrt(this.squaredDiffSum / this.count);
+        const stdDevWithSumSquare = Math.sqrt(this.sumSquares / this.count - mean ** 2);
+        this.max = -Infinity;
+        this.sum = 0;
+        this.sumSquares = 0;
+        this.squaredDiffSum = 0;
+        this.count = 0;
+        return [
+            { name: 'max', value: this.currentMax, unit: null },
+            { name: 'mean', value: mean, unit: null },
+            { name: 'stdDev', value: stdDev, unit: null },
+            { name: 'stdDevWithSumSquare', value: stdDevWithSumSquare, unit: null },
+        ];
+    }; }
+}
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/basic/index.js
+
+
+
+
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/annotation/RectangleROITool.js
 
 
@@ -12310,6 +12407,8 @@ function rectangle_distanceToPoint_distanceToPoint(rect, point) {
 
 
 
+
+
 
 const { transformWorldToIndex: RectangleROITool_transformWorldToIndex } = esm.utilities;
 class RectangleROITool extends base_AnnotationTool {
@@ -12318,6 +12417,8 @@ class RectangleROITool extends base_AnnotationTool {
         configuration: {
             shadow: true,
             preventHandleOutsideImage: false,
+            getTextLines: RectangleROITool_defaultGetTextLines,
+            statsCalculator: BasicStatsCalculator,
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -12707,7 +12808,7 @@ class RectangleROITool extends base_AnnotationTool {
                     lineWidth,
                 }, dataId);
                 renderStatus = true;
-                const textLines = this._getTextLines(data, targetId);
+                const textLines = this.configuration.getTextLines(data, targetId);
                 if (!textLines || textLines.length === 0) {
                     continue;
                 }
@@ -12738,19 +12839,6 @@ class RectangleROITool extends base_AnnotationTool {
                 height: Math.abs(point0[1] - point1[1]),
             };
         };
-        this._getTextLines = (data, targetId) => {
-            const cachedVolumeStats = data.cachedStats[targetId];
-            const { area, mean, max, stdDev, areaUnit, modalityUnit } = cachedVolumeStats;
-            if (mean === undefined) {
-                return;
-            }
-            const textLines = [];
-            textLines.push(`Area: ${utilities_roundNumber(area)} ${areaUnit}`);
-            textLines.push(`Mean: ${utilities_roundNumber(mean)} ${modalityUnit}`);
-            textLines.push(`Max: ${utilities_roundNumber(max)} ${modalityUnit}`);
-            textLines.push(`Std Dev: ${utilities_roundNumber(stdDev)} ${modalityUnit}`);
-            return textLines;
-        };
         this._calculateCachedStats = (annotation, viewPlaneNormal, viewUp, renderingEngine, enabledElement, modalityUnitOptions) => {
             const { data } = annotation;
             const { viewportId, renderingEngineId } = enabledElement;
@@ -12782,46 +12870,25 @@ class RectangleROITool extends base_AnnotationTool {
                     const jMax = Math.max(worldPos1Index[1], worldPos2Index[1]);
                     const kMin = Math.min(worldPos1Index[2], worldPos2Index[2]);
                     const kMax = Math.max(worldPos1Index[2], worldPos2Index[2]);
+                    const boundsIJK = [
+                        [iMin, iMax],
+                        [jMin, jMax],
+                        [kMin, kMax],
+                    ];
                     const { worldWidth, worldHeight } = getWorldWidthAndHeightFromCorners(viewPlaneNormal, viewUp, worldPos1, worldPos2);
                     const scale = getCalibratedScale(image);
                     const area = Math.abs(worldWidth * worldHeight) / (scale * scale);
-                    let count = 0;
-                    let mean = 0;
-                    let stdDev = 0;
-                    let max = -Infinity;
-                    const yMultiple = dimensions[0];
-                    const zMultiple = dimensions[0] * dimensions[1];
-                    for (let k = kMin; k <= kMax; k++) {
-                        for (let j = jMin; j <= jMax; j++) {
-                            for (let i = iMin; i <= iMax; i++) {
-                                const value = scalarData[k * zMultiple + j * yMultiple + i];
-                                if (value > max) {
-                                    max = value;
-                                }
-                                count++;
-                                mean += value;
-                            }
-                        }
-                    }
-                    mean /= count;
-                    for (let k = kMin; k <= kMax; k++) {
-                        for (let j = jMin; j <= jMax; j++) {
-                            for (let i = iMin; i <= iMax; i++) {
-                                const value = scalarData[k * zMultiple + j * yMultiple + i];
-                                const valueMinusMean = value - mean;
-                                stdDev += valueMinusMean * valueMinusMean;
-                            }
-                        }
-                    }
-                    stdDev /= count;
-                    stdDev = Math.sqrt(stdDev);
                     const modalityUnit = getModalityUnit(metadata.Modality, annotation.metadata.referencedImageId, modalityUnitOptions);
+                    const pointsInShape = pointInShapeCallback(imageData, () => true, this.configuration.statsCalculator.statsCallback, boundsIJK);
+                    const stats = this.configuration.statsCalculator.getStatistics();
                     cachedStats[targetId] = {
                         Modality: metadata.Modality,
                         area,
-                        mean,
-                        stdDev,
-                        max,
+                        mean: stats[1]?.value,
+                        stdDev: stats[2]?.value,
+                        max: stats[0]?.value,
+                        statsArray: stats,
+                        pointsInShape: pointsInShape,
                         areaUnit: getCalibratedAreaUnits(null, image),
                         modalityUnit,
                     };
@@ -12850,6 +12917,19 @@ class RectangleROITool extends base_AnnotationTool {
         this._throttledCalculateCachedStats = utilities_throttle(this._calculateCachedStats, 100, { trailing: true });
     }
 }
+function RectangleROITool_defaultGetTextLines(data, targetId) {
+    const cachedVolumeStats = data.cachedStats[targetId];
+    const { area, mean, max, stdDev, areaUnit, modalityUnit } = cachedVolumeStats;
+    if (mean === undefined) {
+        return;
+    }
+    const textLines = [];
+    textLines.push(`Area: ${utilities_roundNumber(area)} ${areaUnit}`);
+    textLines.push(`Mean: ${utilities_roundNumber(mean)} ${modalityUnit}`);
+    textLines.push(`Max: ${utilities_roundNumber(max)} ${modalityUnit}`);
+    textLines.push(`Std Dev: ${utilities_roundNumber(stdDev)} ${modalityUnit}`);
+    return textLines;
+}
 RectangleROITool.toolName = 'RectangleROI';
 /* harmony default export */ const annotation_RectangleROITool = (RectangleROITool);
 
@@ -12893,6 +12973,7 @@ function getWorldWidthAndHeightFromTwoPoints(viewPlaneNormal, viewUp, worldPos1,
 
 
 
+
 
 const { transformWorldToIndex: EllipticalROITool_transformWorldToIndex } = esm.utilities;
 class EllipticalROITool extends base_AnnotationTool {
@@ -12902,6 +12983,8 @@ class EllipticalROITool extends base_AnnotationTool {
             shadow: true,
             preventHandleOutsideImage: false,
             centerPointRadius: 0,
+            getTextLines: EllipticalROITool_defaultGetTextLines,
+            statsCalculator: BasicStatsCalculator,
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -13390,7 +13473,7 @@ class EllipticalROITool extends base_AnnotationTool {
                     }
                 }
                 renderStatus = true;
-                const textLines = this._getTextLines(data, targetId);
+                const textLines = this.configuration.getTextLines(data, targetId);
                 if (!textLines || textLines.length === 0) {
                     continue;
                 }
@@ -13413,27 +13496,6 @@ class EllipticalROITool extends base_AnnotationTool {
             }
             return renderStatus;
         };
-        this._getTextLines = (data, targetId) => {
-            const cachedVolumeStats = data.cachedStats[targetId];
-            const { area, mean, stdDev, max, isEmptyArea, areaUnit, modalityUnit } = cachedVolumeStats;
-            const textLines = [];
-            if (area) {
-                const areaLine = isEmptyArea
-                    ? `Area: Oblique not supported`
-                    : `Area: ${utilities_roundNumber(area)} ${areaUnit}`;
-                textLines.push(areaLine);
-            }
-            if (mean) {
-                textLines.push(`Mean: ${utilities_roundNumber(mean)} ${modalityUnit}`);
-            }
-            if (max) {
-                textLines.push(`Max: ${utilities_roundNumber(max)} ${modalityUnit}`);
-            }
-            if (stdDev) {
-                textLines.push(`Std Dev: ${utilities_roundNumber(stdDev)} ${modalityUnit}`);
-            }
-            return textLines;
-        };
         this._calculateCachedStats = (annotation, viewport, renderingEngine, enabledElement, modalityUnitOptions) => {
             const data = annotation.data;
             const { viewportId, renderingEngineId } = enabledElement;
@@ -13491,33 +13553,17 @@ class EllipticalROITool extends base_AnnotationTool {
                     const area = Math.abs(Math.PI * (worldWidth / 2) * (worldHeight / 2)) /
                         scale /
                         scale;
-                    let count = 0;
-                    let mean = 0;
-                    let stdDev = 0;
-                    let max = -Infinity;
-                    const meanMaxCalculator = ({ value: newValue }) => {
-                        if (newValue > max) {
-                            max = newValue;
-                        }
-                        mean += newValue;
-                        count += 1;
-                    };
-                    pointInShapeCallback(imageData, (pointLPS, pointIJK) => pointInEllipse(ellipseObj, pointLPS), meanMaxCalculator, boundsIJK);
-                    mean /= count;
-                    const stdCalculator = ({ value }) => {
-                        const valueMinusMean = value - mean;
-                        stdDev += valueMinusMean * valueMinusMean;
-                    };
-                    pointInShapeCallback(imageData, (pointLPS, pointIJK) => pointInEllipse(ellipseObj, pointLPS), stdCalculator, boundsIJK);
-                    stdDev /= count;
-                    stdDev = Math.sqrt(stdDev);
                     const modalityUnit = getModalityUnit(metadata.Modality, annotation.metadata.referencedImageId, modalityUnitOptions);
+                    const pointsInShape = pointInShapeCallback(imageData, (pointLPS, pointIJK) => pointInEllipse(ellipseObj, pointLPS), this.configuration.statsCalculator.statsCallback, boundsIJK);
+                    const stats = this.configuration.statsCalculator.getStatistics();
                     cachedStats[targetId] = {
                         Modality: metadata.Modality,
                         area,
-                        mean,
-                        max,
-                        stdDev,
+                        mean: stats[1]?.value,
+                        max: stats[0]?.value,
+                        stdDev: stats[2]?.value,
+                        statsArray: stats,
+                        pointsInShape: pointsInShape,
                         isEmptyArea,
                         areaUnit: getCalibratedAreaUnits(null, image),
                         modalityUnit,
@@ -13569,6 +13615,27 @@ class EllipticalROITool extends base_AnnotationTool {
         ];
     }
 }
+function EllipticalROITool_defaultGetTextLines(data, targetId) {
+    const cachedVolumeStats = data.cachedStats[targetId];
+    const { area, mean, stdDev, max, isEmptyArea, areaUnit, modalityUnit } = cachedVolumeStats;
+    const textLines = [];
+    if (area) {
+        const areaLine = isEmptyArea
+            ? `Area: Oblique not supported`
+            : `Area: ${utilities_roundNumber(area)} ${areaUnit}`;
+        textLines.push(areaLine);
+    }
+    if (mean) {
+        textLines.push(`Mean: ${utilities_roundNumber(mean)} ${modalityUnit}`);
+    }
+    if (max) {
+        textLines.push(`Max: ${utilities_roundNumber(max)} ${modalityUnit}`);
+    }
+    if (stdDev) {
+        textLines.push(`Std Dev: ${utilities_roundNumber(stdDev)} ${modalityUnit}`);
+    }
+    return textLines;
+}
 EllipticalROITool.toolName = 'EllipticalROI';
 /* harmony default export */ const annotation_EllipticalROITool = (EllipticalROITool);
 
@@ -13628,6 +13695,7 @@ function getCanvasCircleCorners(circleCanvasPoints) {
 
 
 
+
 
 
 const { transformWorldToIndex: CircleROITool_transformWorldToIndex } = esm.utilities;
@@ -13638,6 +13706,8 @@ class CircleROITool extends base_AnnotationTool {
             shadow: true,
             preventHandleOutsideImage: false,
             centerPointRadius: 0,
+            getTextLines: CircleROITool_defaultGetTextLines,
+            statsCalculator: BasicStatsCalculator,
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -14038,7 +14108,7 @@ class CircleROITool extends base_AnnotationTool {
                     }
                 }
                 renderStatus = true;
-                const textLines = this._getTextLines(data, targetId);
+                const textLines = this.configuration.getTextLines(data, targetId);
                 if (!textLines || textLines.length === 0) {
                     continue;
                 }
@@ -14061,33 +14131,6 @@ class CircleROITool extends base_AnnotationTool {
             }
             return renderStatus;
         };
-        this._getTextLines = (data, targetId) => {
-            const cachedVolumeStats = data.cachedStats[targetId];
-            const { radius, radiusUnit, area, mean, stdDev, max, isEmptyArea, Modality, areaUnit, modalityUnit, } = cachedVolumeStats;
-            const textLines = [];
-            if (radius) {
-                const radiusLine = isEmptyArea
-                    ? `Radius: Oblique not supported`
-                    : `Radius: ${utilities_roundNumber(radius)} ${radiusUnit}`;
-                textLines.push(radiusLine);
-            }
-            if (area) {
-                const areaLine = isEmptyArea
-                    ? `Area: Oblique not supported`
-                    : `Area: ${utilities_roundNumber(area)} ${areaUnit}`;
-                textLines.push(areaLine);
-            }
-            if (mean) {
-                textLines.push(`Mean: ${utilities_roundNumber(mean)} ${modalityUnit}`);
-            }
-            if (max) {
-                textLines.push(`Max: ${utilities_roundNumber(max)} ${modalityUnit}`);
-            }
-            if (stdDev) {
-                textLines.push(`Std Dev: ${utilities_roundNumber(stdDev)} ${modalityUnit}`);
-            }
-            return textLines;
-        };
         this._calculateCachedStats = (annotation, viewport, renderingEngine, enabledElement, modalityUnitOptions) => {
             const data = annotation.data;
             const { viewportId, renderingEngineId } = enabledElement;
@@ -14146,33 +14189,17 @@ class CircleROITool extends base_AnnotationTool {
                     const area = Math.abs(Math.PI *
                         (worldWidth / scale / 2) *
                         (worldHeight / aspect / scale / 2));
-                    let count = 0;
-                    let mean = 0;
-                    let stdDev = 0;
-                    let max = -Infinity;
-                    const meanMaxCalculator = ({ value: newValue }) => {
-                        if (newValue > max) {
-                            max = newValue;
-                        }
-                        mean += newValue;
-                        count += 1;
-                    };
-                    pointInShapeCallback(imageData, (pointLPS, pointIJK) => pointInEllipse(ellipseObj, pointLPS), meanMaxCalculator, boundsIJK);
-                    mean /= count;
-                    const stdCalculator = ({ value }) => {
-                        const valueMinusMean = value - mean;
-                        stdDev += valueMinusMean * valueMinusMean;
-                    };
-                    pointInShapeCallback(imageData, (pointLPS, pointIJK) => pointInEllipse(ellipseObj, pointLPS), stdCalculator, boundsIJK);
-                    stdDev /= count;
-                    stdDev = Math.sqrt(stdDev);
                     const modalityUnit = getModalityUnit(metadata.Modality, annotation.metadata.referencedImageId, modalityUnitOptions);
+                    const pointsInShape = pointInShapeCallback(imageData, (pointLPS, pointIJK) => pointInEllipse(ellipseObj, pointLPS), this.configuration.statsCalculator.statsCallback, boundsIJK);
+                    const stats = this.configuration.statsCalculator.getStatistics();
                     cachedStats[targetId] = {
                         Modality: metadata.Modality,
                         area,
-                        mean,
-                        max,
-                        stdDev,
+                        mean: stats[1]?.value,
+                        max: stats[0]?.value,
+                        stdDev: stats[2]?.value,
+                        statsArray: stats,
+                        pointsInShape: pointsInShape,
                         isEmptyArea,
                         areaUnit: getCalibratedAreaUnits(null, image),
                         radius: worldWidth / 2 / scale,
@@ -14205,6 +14232,33 @@ class CircleROITool extends base_AnnotationTool {
         this._throttledCalculateCachedStats = utilities_throttle(this._calculateCachedStats, 100, { trailing: true });
     }
 }
+function CircleROITool_defaultGetTextLines(data, targetId) {
+    const cachedVolumeStats = data.cachedStats[targetId];
+    const { radius, radiusUnit, area, mean, stdDev, max, isEmptyArea, Modality, areaUnit, modalityUnit, } = cachedVolumeStats;
+    const textLines = [];
+    if (radius) {
+        const radiusLine = isEmptyArea
+            ? `Radius: Oblique not supported`
+            : `Radius: ${utilities_roundNumber(radius)} ${radiusUnit}`;
+        textLines.push(radiusLine);
+    }
+    if (area) {
+        const areaLine = isEmptyArea
+            ? `Area: Oblique not supported`
+            : `Area: ${utilities_roundNumber(area)} ${areaUnit}`;
+        textLines.push(areaLine);
+    }
+    if (mean) {
+        textLines.push(`Mean: ${utilities_roundNumber(mean)} ${modalityUnit}`);
+    }
+    if (max) {
+        textLines.push(`Max: ${utilities_roundNumber(max)} ${modalityUnit}`);
+    }
+    if (stdDev) {
+        textLines.push(`Std Dev: ${utilities_roundNumber(stdDev)} ${modalityUnit}`);
+    }
+    return textLines;
+}
 CircleROITool.toolName = 'CircleROI';
 /* harmony default export */ const annotation_CircleROITool = (CircleROITool);
 
@@ -14545,6 +14599,7 @@ function calculateAreaOfPoints(points) {
 
 
 
+
 // EXTERNAL MODULE: ../../../node_modules/d3-interpolate/src/index.js + 31 modules
 var src = __webpack_require__(22791);
 // EXTERNAL MODULE: ../../../node_modules/d3-array/src/index.js + 61 modules
@@ -15947,6 +16002,7 @@ function registerRenderMethods(toolInstance) {
 
 
 
+
 
 
 const { pointCanProjectOnLine: PlanarFreehandROITool_pointCanProjectOnLine } = polyline_namespaceObject;
@@ -15973,6 +16029,8 @@ class PlanarFreehandROITool extends base_AnnotationTool {
                 knotsRatioPercentageOnEdit: 40,
             },
             calculateStats: false,
+            getTextLines: PlanarFreehandROITool_defaultGetTextLines,
+            statsCalculator: BasicStatsCalculator,
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -16230,22 +16288,10 @@ class PlanarFreehandROITool extends base_AnnotationTool {
                 ];
                 const worldPosEnd = imageData.indexToWorld([iMax, jMax, kMax]);
                 const canvasPosEnd = viewport.worldToCanvas(worldPosEnd);
-                let count = 0;
-                let sum = 0;
-                let sumSquares = 0;
-                let max = -Infinity;
-                const statCalculator = ({ value: newValue }) => {
-                    if (newValue > max) {
-                        max = newValue;
-                    }
-                    sum += newValue;
-                    sumSquares += newValue ** 2;
-                    count += 1;
-                };
                 let curRow = 0;
                 let intersections = [];
                 let intersectionCounter = 0;
-                pointInShapeCallback(imageData, (pointLPS, pointIJK) => {
+                const pointsInShape = pointInShapeCallback(imageData, (pointLPS, pointIJK) => {
                     let result = true;
                     const point = viewport.worldToCanvas(pointLPS);
                     if (point[1] != curRow) {
@@ -16270,17 +16316,17 @@ class PlanarFreehandROITool extends base_AnnotationTool {
                         result = false;
                     }
                     return result;
-                }, statCalculator, boundsIJK);
-                const mean = sum / count;
-                let stdDev = sumSquares / count - mean ** 2;
-                stdDev = Math.sqrt(stdDev);
+                }, this.configuration.statsCalculator.statsCallback, boundsIJK);
                 const modalityUnit = getModalityUnit(metadata.Modality, annotation.metadata.referencedImageId, modalityUnitOptions);
+                const stats = this.configuration.statsCalculator.getStatistics();
                 cachedStats[targetId] = {
                     Modality: metadata.Modality,
                     area,
-                    mean,
-                    max,
-                    stdDev,
+                    mean: stats[1]?.value,
+                    max: stats[0]?.value,
+                    stdDev: stats[3]?.value,
+                    statsArray: stats,
+                    pointsInShape: pointsInShape,
                     areaUnit: getCalibratedAreaUnits(null, image),
                     modalityUnit,
                 };
@@ -16292,7 +16338,7 @@ class PlanarFreehandROITool extends base_AnnotationTool {
         this._renderStats = (annotation, viewport, enabledElement, svgDrawingHelper) => {
             const data = annotation.data;
             const targetId = this.getTargetId(viewport);
-            const textLines = this._getTextLines(data, targetId);
+            const textLines = this.configuration.getTextLines(data, targetId);
             if (!textLines || textLines.length === 0) {
                 return;
             }
@@ -16318,27 +16364,6 @@ class PlanarFreehandROITool extends base_AnnotationTool {
                 bottomRight: viewport.canvasToWorld([left + width, top + height]),
             };
         };
-        this._getTextLines = (data, targetId) => {
-            const cachedVolumeStats = data.cachedStats[targetId];
-            const { area, mean, stdDev, max, isEmptyArea, areaUnit, modalityUnit } = cachedVolumeStats;
-            const textLines = [];
-            if (area) {
-                const areaLine = isEmptyArea
-                    ? `Area: Oblique not supported`
-                    : `Area: ${utilities_roundNumber(area)} ${areaUnit}`;
-                textLines.push(areaLine);
-            }
-            if (mean) {
-                textLines.push(`Mean: ${utilities_roundNumber(mean)} ${modalityUnit}`);
-            }
-            if (max) {
-                textLines.push(`Max: ${utilities_roundNumber(max)} ${modalityUnit}`);
-            }
-            if (stdDev) {
-                textLines.push(`Std Dev: ${utilities_roundNumber(stdDev)} ${modalityUnit}`);
-            }
-            return textLines;
-        };
         drawLoop(this);
         editLoopCommon(this);
         closedContourEditLoop(this);
@@ -16397,6 +16422,27 @@ class PlanarFreehandROITool extends base_AnnotationTool {
         return annotationsWithinSlice;
     }
 }
+function PlanarFreehandROITool_defaultGetTextLines(data, targetId) {
+    const cachedVolumeStats = data.cachedStats[targetId];
+    const { area, mean, stdDev, max, isEmptyArea, areaUnit, modalityUnit } = cachedVolumeStats;
+    const textLines = [];
+    if (area) {
+        const areaLine = isEmptyArea
+            ? `Area: Oblique not supported`
+            : `Area: ${utilities_roundNumber(area)} ${areaUnit}`;
+        textLines.push(areaLine);
+    }
+    if (mean) {
+        textLines.push(`Mean: ${utilities_roundNumber(mean)} ${modalityUnit}`);
+    }
+    if (max) {
+        textLines.push(`Max: ${utilities_roundNumber(max)} ${modalityUnit}`);
+    }
+    if (stdDev) {
+        textLines.push(`Std Dev: ${utilities_roundNumber(stdDev)} ${modalityUnit}`);
+    }
+    return textLines;
+}
 PlanarFreehandROITool.toolName = 'PlanarFreehandROI';
 /* harmony default export */ const annotation_PlanarFreehandROITool = (PlanarFreehandROITool);
 
@@ -16850,6 +16896,7 @@ class AngleTool extends base_AnnotationTool {
         configuration: {
             shadow: true,
             preventHandleOutsideImage: false,
+            getTextLines: AngleTool_defaultGetTextLines,
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -17180,7 +17227,7 @@ class AngleTool extends base_AnnotationTool {
                 if (!data.cachedStats[targetId]?.angle) {
                     continue;
                 }
-                const textLines = this._getTextLines(data, targetId);
+                const textLines = this.configuration.getTextLines(data, targetId);
                 if (!data.handles.textBox.hasMoved) {
                     const canvasTextBoxCoords = canvasCoordinates[1];
                     data.handles.textBox.worldPosition =
@@ -17228,15 +17275,6 @@ class AngleTool extends base_AnnotationTool {
         utilities_triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
         evt.preventDefault();
     }
-    _getTextLines(data, targetId) {
-        const cachedVolumeStats = data.cachedStats[targetId];
-        const { angle } = cachedVolumeStats;
-        if (angle === undefined) {
-            return;
-        }
-        const textLines = [`${utilities_roundNumber(angle)} ${String.fromCharCode(176)}`];
-        return textLines;
-    }
     _calculateCachedStats(annotation, renderingEngine, enabledElement) {
         const data = annotation.data;
         const { viewportId, renderingEngineId } = enabledElement;
@@ -17266,6 +17304,15 @@ class AngleTool extends base_AnnotationTool {
         return cachedStats;
     }
 }
+function AngleTool_defaultGetTextLines(data, targetId) {
+    const cachedVolumeStats = data.cachedStats[targetId];
+    const { angle } = cachedVolumeStats;
+    if (angle === undefined) {
+        return;
+    }
+    const textLines = [`${utilities_roundNumber(angle)} ${String.fromCharCode(176)}`];
+    return textLines;
+}
 AngleTool.toolName = 'Angle';
 /* harmony default export */ const annotation_AngleTool = (AngleTool);
 
@@ -17309,6 +17356,7 @@ class CobbAngleTool extends base_AnnotationTool {
         configuration: {
             shadow: true,
             preventHandleOutsideImage: false,
+            getTextLines: CobbAngleTool_defaultGetTextLines,
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -17659,7 +17707,7 @@ class CobbAngleTool extends base_AnnotationTool {
                 if (!data.cachedStats[targetId]?.angle) {
                     continue;
                 }
-                const textLines = this._getTextLines(data, targetId);
+                const textLines = this.configuration.getTextLines(data, targetId);
                 if (!data.handles.textBox.hasMoved) {
                     const canvasTextBoxCoords = getTextBoxCoordsCanvas(canvasCoordinates);
                     data.handles.textBox.worldPosition =
@@ -17707,15 +17755,6 @@ class CobbAngleTool extends base_AnnotationTool {
         utilities_triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
         evt.preventDefault();
     }
-    _getTextLines(data, targetId) {
-        const cachedVolumeStats = data.cachedStats[targetId];
-        const { angle } = cachedVolumeStats;
-        if (angle === undefined) {
-            return;
-        }
-        const textLines = [`${angle.toFixed(2)} ${String.fromCharCode(176)}`];
-        return textLines;
-    }
     _calculateCachedStats(annotation, renderingEngine, enabledElement) {
         const data = annotation.data;
         const { viewportId, renderingEngineId } = enabledElement;
@@ -17757,6 +17796,15 @@ class CobbAngleTool extends base_AnnotationTool {
         return cachedStats;
     }
 }
+function CobbAngleTool_defaultGetTextLines(data, targetId) {
+    const cachedVolumeStats = data.cachedStats[targetId];
+    const { angle } = cachedVolumeStats;
+    if (angle === undefined) {
+        return;
+    }
+    const textLines = [`${angle.toFixed(2)} ${String.fromCharCode(176)}`];
+    return textLines;
+}
 CobbAngleTool.toolName = 'CobbAngle';
 /* harmony default export */ const annotation_CobbAngleTool = (CobbAngleTool);