@cornerstonejs/tools 2.0.0-beta.1 → 2.0.0-beta.10

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

@@ -1,14 +1,15 @@
 import { vec3 } from 'gl-matrix';
 import { Events } from '../../enums';
-import { getEnabledElement, triggerEvent, eventTarget, } from '@cornerstonejs/core';
+import { getEnabledElement } from '@cornerstonejs/core';
 import { AnnotationTool } from '../base';
 import throttle from '../../utilities/throttle';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
+import { triggerAnnotationCompleted, triggerAnnotationModified, } from '../../stateManagement/annotation/helpers/state';
 import * as lineSegment from '../../utilities/math/line';
 import angleBetweenLines from '../../utilities/math/angle/angleBetweenLines';
 import { midPoint2 } from '../../utilities/math/midPoint';
-import { drawHandles as drawHandlesSvg, drawLine as drawLineSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, } from '../../drawingSvg';
+import { drawHandles as drawHandlesSvg, drawLine as drawLineSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, drawTextBox as drawTextBoxSvg, } from '../../drawingSvg';
 import { state } from '../../store';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
@@ -20,6 +21,8 @@ class CobbAngleTool extends AnnotationTool {
         configuration: {
             shadow: true,
             preventHandleOutsideImage: false,
+            getTextLines: defaultGetTextLines,
+            showArcLines: false,
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -48,6 +51,7 @@ class CobbAngleTool extends AnnotationTool {
                     viewUp: [...viewUp],
                     FrameOfReferenceUID,
                     referencedImageId,
+                    ...viewport.getViewReference({ points: [worldPos] }),
                 },
                 data: {
                     handles: {
@@ -87,52 +91,39 @@ class CobbAngleTool extends AnnotationTool {
             const enabledElement = getEnabledElement(element);
             const { viewport } = enabledElement;
             const { data } = annotation;
-            const [point1, point2, point3, point4] = data.handles.points;
-            const canvasPoint1 = viewport.worldToCanvas(point1);
-            const canvasPoint2 = viewport.worldToCanvas(point2);
-            const canvasPoint3 = viewport.worldToCanvas(point3);
-            const canvasPoint4 = viewport.worldToCanvas(point4);
-            const line1 = {
-                start: {
-                    x: canvasPoint1[0],
-                    y: canvasPoint1[1],
-                },
-                end: {
-                    x: canvasPoint2[0],
-                    y: canvasPoint2[1],
-                },
-            };
-            const line2 = {
-                start: {
-                    x: canvasPoint3[0],
-                    y: canvasPoint3[1],
-                },
-                end: {
-                    x: canvasPoint4[0],
-                    y: canvasPoint4[1],
-                },
-            };
-            const distanceToPoint = lineSegment.distanceToPoint([line1.start.x, line1.start.y], [line1.end.x, line1.end.y], [canvasCoords[0], canvasCoords[1]]);
-            const distanceToPoint2 = lineSegment.distanceToPoint([line2.start.x, line2.start.y], [line2.end.x, line2.end.y], [canvasCoords[0], canvasCoords[1]]);
+            const { distanceToPoint, distanceToPoint2 } = this.distanceToLines({
+                viewport,
+                points: data.handles.points,
+                canvasCoords,
+                proximity,
+            });
             if (distanceToPoint <= proximity || distanceToPoint2 <= proximity) {
                 return true;
             }
             return false;
         };
-        this.toolSelectedCallback = (evt, annotation, interactionType) => {
+        this.toolSelectedCallback = (evt, annotation, interactionType, canvasCoords, proximity = 6) => {
             const eventDetail = evt.detail;
             const { element } = eventDetail;
             annotation.highlighted = true;
             const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName());
+            const enabledElement = getEnabledElement(element);
+            const { renderingEngine, viewport } = enabledElement;
+            const { isNearFirstLine, isNearSecondLine } = this.distanceToLines({
+                viewport,
+                points: annotation.data.handles.points,
+                canvasCoords,
+                proximity,
+            });
             this.editData = {
                 annotation,
                 viewportIdsToRender,
                 movingTextBox: false,
+                isNearFirstLine,
+                isNearSecondLine,
             };
             this._activateModify(element);
             hideElementCursor(element);
-            const enabledElement = getEnabledElement(element);
-            const { renderingEngine } = enabledElement;
             triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
             evt.preventDefault();
         };
@@ -162,11 +153,7 @@ class CobbAngleTool extends AnnotationTool {
             }
             triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
             if (newAnnotation) {
-                const eventType = Events.ANNOTATION_COMPLETED;
-                const eventDetail = {
-                    annotation,
-                };
-                triggerEvent(eventTarget, eventType, eventDetail);
+                triggerAnnotationCompleted(annotation);
             }
             this.editData = null;
             this.isDrawing = false;
@@ -201,7 +188,7 @@ class CobbAngleTool extends AnnotationTool {
             this.isDrawing = true;
             const eventDetail = evt.detail;
             const { element } = eventDetail;
-            const { annotation, viewportIdsToRender, handleIndex, movingTextBox } = this.editData;
+            const { annotation, viewportIdsToRender, handleIndex, movingTextBox, isNearFirstLine, isNearSecondLine, } = this.editData;
             const { data } = annotation;
             if (movingTextBox) {
                 const { deltaPoints } = eventDetail;
@@ -213,15 +200,27 @@ class CobbAngleTool extends AnnotationTool {
                 worldPosition[2] += worldPosDelta[2];
                 textBox.hasMoved = true;
             }
-            else if (handleIndex === undefined) {
+            else if (handleIndex === undefined &&
+                (isNearFirstLine || isNearSecondLine)) {
                 const { deltaPoints } = eventDetail;
                 const worldPosDelta = deltaPoints.world;
                 const points = data.handles.points;
-                points.forEach((point) => {
-                    point[0] += worldPosDelta[0];
-                    point[1] += worldPosDelta[1];
-                    point[2] += worldPosDelta[2];
-                });
+                if (isNearFirstLine) {
+                    const firstLinePoints = [points[0], points[1]];
+                    firstLinePoints.forEach((point) => {
+                        point[0] += worldPosDelta[0];
+                        point[1] += worldPosDelta[1];
+                        point[2] += worldPosDelta[2];
+                    });
+                }
+                else if (isNearSecondLine) {
+                    const secondLinePoints = [points[2], points[3]];
+                    secondLinePoints.forEach((point) => {
+                        point[0] += worldPosDelta[0];
+                        point[1] += worldPosDelta[1];
+                        point[2] += worldPosDelta[2];
+                    });
+                }
                 annotation.invalidated = true;
             }
             else {
@@ -236,29 +235,29 @@ class CobbAngleTool extends AnnotationTool {
             triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
         };
         this.cancel = (element) => {
-            if (this.isDrawing) {
-                this.isDrawing = false;
-                this._deactivateDraw(element);
-                this._deactivateModify(element);
-                resetElementCursor(element);
-                const { annotation, viewportIdsToRender, newAnnotation } = this.editData;
-                const { data } = annotation;
-                annotation.highlighted = false;
-                data.handles.activeHandleIndex = null;
-                const enabledElement = getEnabledElement(element);
-                const { renderingEngine } = enabledElement;
-                triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
-                if (newAnnotation) {
-                    const eventType = Events.ANNOTATION_COMPLETED;
-                    const eventDetail = {
-                        annotation,
-                    };
-                    triggerEvent(eventTarget, eventType, eventDetail);
-                }
-                this.editData = null;
-                this.angleStartedNotYetCompleted = false;
-                return annotation.annotationUID;
+            if (!this.isDrawing) {
+                return;
             }
+            this.isDrawing = false;
+            this._deactivateDraw(element);
+            this._deactivateModify(element);
+            resetElementCursor(element);
+            const { annotation, viewportIdsToRender, newAnnotation } = this.editData;
+            const { data } = annotation;
+            if (data.handles.points.length < 4) {
+                removeAnnotation(annotation.annotationUID);
+            }
+            annotation.highlighted = false;
+            data.handles.activeHandleIndex = null;
+            const enabledElement = getEnabledElement(element);
+            const { renderingEngine } = enabledElement;
+            triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            if (newAnnotation) {
+                triggerAnnotationCompleted(annotation);
+            }
+            this.editData = null;
+            this.angleStartedNotYetCompleted = false;
+            return annotation.annotationUID;
         };
         this._activateModify = (element) => {
             state.isInteractingWithTool = true;
@@ -312,13 +311,35 @@ class CobbAngleTool extends AnnotationTool {
                 const { annotationUID, data } = annotation;
                 const { points, activeHandleIndex } = data.handles;
                 styleSpecifier.annotationUID = annotationUID;
-                const lineWidth = this.getStyle('lineWidth', styleSpecifier, annotation);
-                const lineDash = this.getStyle('lineDash', styleSpecifier, annotation);
-                const color = this.getStyle('color', styleSpecifier, annotation);
+                const { color, lineWidth, lineDash } = this.getAnnotationStyle({
+                    annotation,
+                    styleSpecifier,
+                });
                 const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
-                if (!data.cachedStats[targetId]) {
+                if (!data.cachedStats[targetId] ||
+                    data.cachedStats[targetId].angle == null) {
                     data.cachedStats[targetId] = {
                         angle: null,
+                        arc1Angle: null,
+                        arc2Angle: null,
+                        points: {
+                            world: {
+                                arc1Start: null,
+                                arc1End: null,
+                                arc2Start: null,
+                                arc2End: null,
+                                arc1Angle: null,
+                                arc2Angle: null,
+                            },
+                            canvas: {
+                                arc1Start: null,
+                                arc1End: null,
+                                arc2Start: null,
+                                arc2End: null,
+                                arc1Angle: null,
+                                arc2Angle: null,
+                            },
+                        },
                     };
                     this._calculateCachedStats(annotation, renderingEngine, enabledElement);
                 }
@@ -343,8 +364,10 @@ class CobbAngleTool extends AnnotationTool {
                         lineWidth,
                     });
                 }
-                let lineUID = '1';
-                drawLineSvg(svgDrawingHelper, annotationUID, lineUID, canvasCoordinates[0], canvasCoordinates[1], {
+                const firstLine = [canvasCoordinates[0], canvasCoordinates[1]];
+                const secondLine = [canvasCoordinates[2], canvasCoordinates[3]];
+                let lineUID = 'line1';
+                drawLineSvg(svgDrawingHelper, annotationUID, lineUID, firstLine[0], firstLine[1], {
                     color,
                     width: lineWidth,
                     lineDash,
@@ -353,32 +376,60 @@ class CobbAngleTool extends AnnotationTool {
                 if (canvasCoordinates.length < 4) {
                     return renderStatus;
                 }
-                lineUID = '2';
-                drawLineSvg(svgDrawingHelper, annotationUID, lineUID, canvasCoordinates[2], canvasCoordinates[3], {
+                lineUID = 'line2';
+                drawLineSvg(svgDrawingHelper, annotationUID, lineUID, secondLine[0], secondLine[1], {
                     color,
                     width: lineWidth,
                     lineDash,
                 });
-                lineUID = '3';
-                const mid1 = midPoint2(canvasCoordinates[0], canvasCoordinates[1]);
-                const mid2 = midPoint2(canvasCoordinates[2], canvasCoordinates[3]);
+                lineUID = 'linkLine';
+                const mid1 = midPoint2(firstLine[0], firstLine[1]);
+                const mid2 = midPoint2(secondLine[0], secondLine[1]);
                 drawLineSvg(svgDrawingHelper, annotationUID, lineUID, mid1, mid2, {
                     color,
                     lineWidth: '1',
                     lineDash: '1,4',
                 });
+                const { arc1Start, arc1End, arc2End, arc2Start } = data.cachedStats[targetId].points.canvas;
+                const { arc1Angle, arc2Angle } = data.cachedStats[targetId];
+                if (this.configuration.showArcLines) {
+                    lineUID = 'arc1';
+                    drawLineSvg(svgDrawingHelper, annotationUID, lineUID, arc1Start, arc1End, {
+                        color,
+                        lineWidth: '1',
+                    });
+                    lineUID = 'arc2';
+                    drawLineSvg(svgDrawingHelper, annotationUID, lineUID, arc2Start, arc2End, {
+                        color,
+                        lineWidth: '1',
+                    });
+                }
                 if (!data.cachedStats[targetId]?.angle) {
                     continue;
                 }
-                const textLines = this._getTextLines(data, targetId);
+                const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+                if (!options.visibility) {
+                    data.handles.textBox = {
+                        hasMoved: false,
+                        worldPosition: [0, 0, 0],
+                        worldBoundingBox: {
+                            topLeft: [0, 0, 0],
+                            topRight: [0, 0, 0],
+                            bottomLeft: [0, 0, 0],
+                            bottomRight: [0, 0, 0],
+                        },
+                    };
+                    continue;
+                }
+                const textLines = this.configuration.getTextLines(data, targetId);
                 if (!data.handles.textBox.hasMoved) {
                     const canvasTextBoxCoords = getTextBoxCoordsCanvas(canvasCoordinates);
                     data.handles.textBox.worldPosition =
                         viewport.canvasToWorld(canvasTextBoxCoords);
                 }
                 const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
-                const textBoxUID = '1';
-                const boundingBox = drawLinkedTextBoxSvg(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, this.getLinkedTextBoxStyle(styleSpecifier, annotation));
+                const textBoxUID = 'cobbAngleText';
+                const boundingBox = drawLinkedTextBoxSvg(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, options);
                 const { x: left, y: top, width, height } = boundingBox;
                 data.handles.textBox.worldBoundingBox = {
                     topLeft: viewport.canvasToWorld([left, top]),
@@ -386,10 +437,150 @@ class CobbAngleTool extends AnnotationTool {
                     bottomLeft: viewport.canvasToWorld([left, top + height]),
                     bottomRight: viewport.canvasToWorld([left + width, top + height]),
                 };
+                if (this.configuration.showArcLines) {
+                    const arc1TextBoxUID = 'arcAngle1';
+                    const arc1TextLine = [
+                        `${arc1Angle.toFixed(2)} ${String.fromCharCode(176)}`,
+                    ];
+                    const arch1TextPosCanvas = midPoint2(arc1Start, arc1End);
+                    drawTextBoxSvg(svgDrawingHelper, annotationUID, arc1TextBoxUID, arc1TextLine, arch1TextPosCanvas, {
+                        ...options,
+                        padding: 3,
+                    });
+                    const arc2TextBoxUID = 'arcAngle2';
+                    const arc2TextLine = [
+                        `${arc2Angle.toFixed(2)} ${String.fromCharCode(176)}`,
+                    ];
+                    const arch2TextPosCanvas = midPoint2(arc2Start, arc2End);
+                    drawTextBoxSvg(svgDrawingHelper, annotationUID, arc2TextBoxUID, arc2TextLine, arch2TextPosCanvas, {
+                        ...options,
+                        padding: 3,
+                    });
+                }
             }
             return renderStatus;
         };
-        this._throttledCalculateCachedStats = throttle(this._calculateCachedStats, 100, { trailing: true });
+        this.distanceToLines = ({ viewport, points, canvasCoords, proximity }) => {
+            const [point1, point2, point3, point4] = points;
+            const canvasPoint1 = viewport.worldToCanvas(point1);
+            const canvasPoint2 = viewport.worldToCanvas(point2);
+            const canvasPoint3 = viewport.worldToCanvas(point3);
+            const canvasPoint4 = viewport.worldToCanvas(point4);
+            const line1 = {
+                start: {
+                    x: canvasPoint1[0],
+                    y: canvasPoint1[1],
+                },
+                end: {
+                    x: canvasPoint2[0],
+                    y: canvasPoint2[1],
+                },
+            };
+            const line2 = {
+                start: {
+                    x: canvasPoint3[0],
+                    y: canvasPoint3[1],
+                },
+                end: {
+                    x: canvasPoint4[0],
+                    y: canvasPoint4[1],
+                },
+            };
+            const distanceToPoint = lineSegment.distanceToPoint([line1.start.x, line1.start.y], [line1.end.x, line1.end.y], [canvasCoords[0], canvasCoords[1]]);
+            const distanceToPoint2 = lineSegment.distanceToPoint([line2.start.x, line2.start.y], [line2.end.x, line2.end.y], [canvasCoords[0], canvasCoords[1]]);
+            let isNearFirstLine = false;
+            let isNearSecondLine = false;
+            if (distanceToPoint <= proximity) {
+                isNearFirstLine = true;
+            }
+            else if (distanceToPoint2 <= proximity) {
+                isNearSecondLine = true;
+            }
+            return {
+                distanceToPoint,
+                distanceToPoint2,
+                isNearFirstLine,
+                isNearSecondLine,
+            };
+        };
+        this.getArcsStartEndPoints = ({ firstLine, secondLine, mid1, mid2, }) => {
+            const linkLine = [mid1, mid2];
+            const arc1Angle = angleBetweenLines(firstLine, linkLine);
+            const arc2Angle = angleBetweenLines(secondLine, linkLine);
+            const arc1Side = arc1Angle > 90 ? 1 : 0;
+            const arc2Side = arc2Angle > 90 ? 0 : 1;
+            const midLinkLine = midPoint2(linkLine[0], linkLine[1]);
+            const linkLineLength = Math.sqrt((linkLine[1][0] - linkLine[0][0]) ** 2 +
+                (linkLine[1][1] - linkLine[0][1]) ** 2);
+            const ratio = 0.1;
+            const midFirstLine = midPoint2(firstLine[0], firstLine[1]);
+            const midSecondLine = midPoint2(secondLine[0], secondLine[1]);
+            const directionVectorStartArc1 = [
+                firstLine[arc1Side][0] - midFirstLine[0],
+                firstLine[arc1Side][1] - midFirstLine[1],
+            ];
+            const magnitudeStartArc1 = Math.sqrt(directionVectorStartArc1[0] ** 2 + directionVectorStartArc1[1] ** 2);
+            const normalizedDirectionStartArc1 = [
+                directionVectorStartArc1[0] / magnitudeStartArc1,
+                directionVectorStartArc1[1] / magnitudeStartArc1,
+            ];
+            const arc1Start = [
+                midFirstLine[0] +
+                    normalizedDirectionStartArc1[0] * linkLineLength * ratio,
+                midFirstLine[1] +
+                    normalizedDirectionStartArc1[1] * linkLineLength * ratio,
+            ];
+            const directionVectorEndArc1 = [
+                midLinkLine[0] - mid1[0],
+                midLinkLine[1] - mid1[1],
+            ];
+            const magnitudeEndArc1 = Math.sqrt(directionVectorEndArc1[0] ** 2 + directionVectorEndArc1[1] ** 2);
+            const normalizedDirectionEndArc1 = [
+                directionVectorEndArc1[0] / magnitudeEndArc1,
+                directionVectorEndArc1[1] / magnitudeEndArc1,
+            ];
+            const arc1End = [
+                mid1[0] + normalizedDirectionEndArc1[0] * linkLineLength * ratio,
+                mid1[1] + normalizedDirectionEndArc1[1] * linkLineLength * ratio,
+            ];
+            const directionVectorStartArc2 = [
+                secondLine[arc2Side][0] - midSecondLine[0],
+                secondLine[arc2Side][1] - midSecondLine[1],
+            ];
+            const magnitudeStartArc2 = Math.sqrt(directionVectorStartArc2[0] ** 2 + directionVectorStartArc2[1] ** 2);
+            const normalizedDirectionStartArc2 = [
+                directionVectorStartArc2[0] / magnitudeStartArc2,
+                directionVectorStartArc2[1] / magnitudeStartArc2,
+            ];
+            const arc2Start = [
+                midSecondLine[0] +
+                    normalizedDirectionStartArc2[0] * linkLineLength * ratio,
+                midSecondLine[1] +
+                    normalizedDirectionStartArc2[1] * linkLineLength * ratio,
+            ];
+            const directionVectorEndArc2 = [
+                midLinkLine[0] - mid2[0],
+                midLinkLine[1] - mid2[1],
+            ];
+            const magnitudeEndArc2 = Math.sqrt(directionVectorEndArc2[0] ** 2 + directionVectorEndArc2[1] ** 2);
+            const normalizedDirectionEndArc2 = [
+                directionVectorEndArc2[0] / magnitudeEndArc2,
+                directionVectorEndArc2[1] / magnitudeEndArc2,
+            ];
+            const arc2End = [
+                mid2[0] + normalizedDirectionEndArc2[0] * linkLineLength * ratio,
+                mid2[1] + normalizedDirectionEndArc2[1] * linkLineLength * ratio,
+            ];
+            return {
+                arc1Start,
+                arc1End,
+                arc2Start,
+                arc2End,
+                arc1Angle: arc1Angle > 90 ? 180 - arc1Angle : arc1Angle,
+                arc2Angle: arc2Angle > 90 ? 180 - arc2Angle : arc2Angle,
+            };
+        };
+        this._throttledCalculateCachedStats = throttle(this._calculateCachedStats, 25, { trailing: true });
     }
     handleSelectedCallback(evt, annotation, handle, interactionType = 'mouse') {
         const eventDetail = evt.detail;
@@ -418,18 +609,8 @@ class CobbAngleTool extends AnnotationTool {
         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;
         if (data.handles.points.length !== 4) {
             return;
         }
@@ -448,26 +629,57 @@ class CobbAngleTool extends AnnotationTool {
                 }
             }
         }
+        const { viewport } = enabledElement;
+        const { element } = viewport;
+        const canvasPoints = data.handles.points.map((p) => viewport.worldToCanvas(p));
+        const firstLine = [canvasPoints[0], canvasPoints[1]];
+        const secondLine = [canvasPoints[2], canvasPoints[3]];
+        const mid1 = midPoint2(firstLine[0], firstLine[1]);
+        const mid2 = midPoint2(secondLine[0], secondLine[1]);
+        const { arc1Start, arc1End, arc2End, arc2Start, arc1Angle, arc2Angle } = this.getArcsStartEndPoints({
+            firstLine,
+            secondLine,
+            mid1,
+            mid2,
+        });
         const { cachedStats } = data;
         const targetIds = Object.keys(cachedStats);
         for (let i = 0; i < targetIds.length; i++) {
             const targetId = targetIds[i];
-            const angle = angleBetweenLines(seg1, seg2);
             cachedStats[targetId] = {
-                angle,
+                angle: angleBetweenLines(seg1, seg2),
+                arc1Angle,
+                arc2Angle,
+                points: {
+                    canvas: {
+                        arc1Start,
+                        arc1End,
+                        arc2End,
+                        arc2Start,
+                    },
+                    world: {
+                        arc1Start: viewport.canvasToWorld(arc1Start),
+                        arc1End: viewport.canvasToWorld(arc1End),
+                        arc2End: viewport.canvasToWorld(arc2End),
+                        arc2Start: viewport.canvasToWorld(arc2Start),
+                    },
+                },
             };
         }
         annotation.invalidated = false;
-        const eventType = Events.ANNOTATION_MODIFIED;
-        const eventDetail = {
-            annotation,
-            viewportId,
-            renderingEngineId,
-        };
-        triggerEvent(eventTarget, eventType, eventDetail);
+        triggerAnnotationModified(annotation, element);
         return cachedStats;
     }
 }
+function 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';
 export default CobbAngleTool;
 //# sourceMappingURL=CobbAngleTool.js.map