@cornerstonejs/tools 4.17.1 → 4.17.3

package/dist/esm/drawingSvg/draw.js

@@ -1,6 +1,10 @@
 import getSvgDrawingHelper from './getSvgDrawingHelper';
+import { clearTextBoxRegistry } from '../utilities/drawing/textBoxOverlapRegistry';
 function draw(element, fn) {
     const svgDrawingHelper = getSvgDrawingHelper(element);
+    if (svgDrawingHelper.svgLayerElement) {
+        clearTextBoxRegistry(svgDrawingHelper.svgLayerElement);
+    }
     fn(svgDrawingHelper);
     svgDrawingHelper.clearUntouched();
 }

package/dist/esm/drawingSvg/drawTextBox.js

@@ -1,5 +1,6 @@
 import _getHash from './_getHash';
 import setAttributesIfNecessary from './setAttributesIfNecessary';
+import { registerTextBox } from '../utilities/drawing/textBoxOverlapRegistry';
 function drawTextBox(svgDrawingHelper, annotationUID, textUID, textLines, position, options = {}) {
     const mergedOptions = Object.assign({
         fontFamily: 'Helvetica, Arial, sans-serif',
@@ -11,6 +12,9 @@ function drawTextBox(svgDrawingHelper, annotationUID, textUID, textLines, positi
         centerY: true,
     }, options);
     const textGroupBoundingBox = _drawTextGroup(svgDrawingHelper, annotationUID, textUID, textLines, position, mergedOptions);
+    if (svgDrawingHelper.svgLayerElement) {
+        registerTextBox(svgDrawingHelper.svgLayerElement, textGroupBoundingBox);
+    }
     return textGroupBoundingBox;
 }
 function _drawTextGroup(svgDrawingHelper, annotationUID, textUID, textLines = [''], position, options) {
@@ -71,10 +75,10 @@ function _drawTextGroup(svgDrawingHelper, annotationUID, textUID, textLines = ['
         textGroupBoundingBox = _drawTextBackground(textGroup, backgroundStyles);
     }
     return Object.assign({}, textGroupBoundingBox, {
-        x,
-        y,
-        height: textGroupBoundingBox.height + padding,
-        width: textGroupBoundingBox.width + padding,
+        x: x + textGroupBoundingBox.x,
+        y: y + textGroupBoundingBox.y,
+        height: textGroupBoundingBox.height,
+        width: textGroupBoundingBox.width,
     });
 }
 function _createTextElement(svgDrawingHelper, options) {

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

@@ -6,7 +6,7 @@ import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateMan
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
 import * as lineSegment from '../../utilities/math/line';
 import angleBetweenLines from '../../utilities/math/angle/angleBetweenLines';
-import { drawHandles as drawHandlesSvg, drawLine as drawLineSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, drawPath as drawPathSvg, } from '../../drawingSvg';
+import { drawHandles as drawHandlesSvg, drawLine as drawLineSvg, drawPath as drawPathSvg, } from '../../drawingSvg';
 import { state } from '../../store/state';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
@@ -354,36 +354,22 @@ class AngleTool extends AnnotationTool {
                 if (!data.cachedStats[targetId]?.angle) {
                     continue;
                 }
-                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 = canvasCoordinates[1];
-                    data.handles.textBox.worldPosition =
-                        viewport.canvasToWorld(canvasTextBoxCoords);
+                const vertexAnchor = [
+                    canvasCoordinates[1],
+                    canvasCoordinates[1],
+                ];
+                if (!this.renderLinkedTextBoxAnnotation({
+                    enabledElement,
+                    svgDrawingHelper,
+                    annotation,
+                    styleSpecifier,
+                    textLines,
+                    canvasCoordinates,
+                    placementPoints: vertexAnchor,
+                })) {
+                    continue;
                 }
-                const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
-                const textBoxUID = '1';
-                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]),
-                    topRight: viewport.canvasToWorld([left + width, top]),
-                    bottomLeft: viewport.canvasToWorld([left, top + height]),
-                    bottomRight: viewport.canvasToWorld([left + width, top + height]),
-                };
             }
             return renderStatus;
         };

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

@@ -4,7 +4,7 @@ import { AnnotationTool } from '../base';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
 import * as lineSegment from '../../utilities/math/line';
-import { drawHandles as drawHandlesSvg, drawArrow as drawArrowSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, } from '../../drawingSvg';
+import { drawHandles as drawHandlesSvg, drawArrow as drawArrowSvg, } from '../../drawingSvg';
 import { state } from '../../store/state';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
@@ -331,35 +331,16 @@ class ArrowAnnotateTool extends AnnotationTool {
                 if (!label) {
                     continue;
                 }
-                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],
-                        },
-                    };
+                if (!this.renderLinkedTextBoxAnnotation({
+                    enabledElement,
+                    svgDrawingHelper,
+                    annotation,
+                    styleSpecifier,
+                    textLines: [label],
+                    canvasCoordinates,
+                })) {
                     continue;
                 }
-                if (!data.handles.textBox.hasMoved) {
-                    const canvasTextBoxCoords = canvasCoordinates[1];
-                    data.handles.textBox.worldPosition =
-                        viewport.canvasToWorld(canvasTextBoxCoords);
-                }
-                const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
-                const textBoxUID = '1';
-                const boundingBox = drawLinkedTextBoxSvg(svgDrawingHelper, annotationUID, textBoxUID, [label], textBoxPosition, canvasCoordinates, {}, options);
-                const { x: left, y: top, width, height } = boundingBox;
-                data.handles.textBox.worldBoundingBox = {
-                    topLeft: viewport.canvasToWorld([left, top]),
-                    topRight: viewport.canvasToWorld([left + width, top]),
-                    bottomLeft: viewport.canvasToWorld([left, top + height]),
-                    bottomRight: viewport.canvasToWorld([left + width, top + height]),
-                };
             }
             return renderStatus;
         };

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

@@ -7,12 +7,11 @@ import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateMan
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
 import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
 import { triggerAnnotationCompleted, triggerAnnotationModified, } from '../../stateManagement/annotation/helpers/state';
-import { drawLine as drawLineSvg, drawHandles as drawHandlesSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, } from '../../drawingSvg';
+import { drawLine as drawLineSvg, drawHandles as drawHandlesSvg, } from '../../drawingSvg';
 import { state } from '../../store/state';
 import { ChangeTypes, Events, MeasurementType } from '../../enums';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import * as lineSegment from '../../utilities/math/line';
-import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { getStyleProperty } from '../../stateManagement/annotation/config/helpers';
@@ -539,40 +538,20 @@ class BidirectionalTool extends AnnotationTool {
                     shadow,
                 }, dataId2);
                 renderStatus = true;
-                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 (!textLines || textLines.length === 0) {
                     continue;
                 }
-                let canvasTextBoxCoords;
-                if (!data.handles.textBox.hasMoved) {
-                    canvasTextBoxCoords = getTextBoxCoordsCanvas(canvasCoordinates);
-                    data.handles.textBox.worldPosition =
-                        viewport.canvasToWorld(canvasTextBoxCoords);
+                if (!this.renderLinkedTextBoxAnnotation({
+                    enabledElement,
+                    svgDrawingHelper,
+                    annotation,
+                    styleSpecifier,
+                    textLines,
+                    canvasCoordinates,
+                })) {
+                    continue;
                 }
-                const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
-                const textBoxUID = '1';
-                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]),
-                    topRight: viewport.canvasToWorld([left + width, top]),
-                    bottomLeft: viewport.canvasToWorld([left, top + height]),
-                    bottomRight: viewport.canvasToWorld([left + width, top + height]),
-                };
             }
             return renderStatus;
         };

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

@@ -7,11 +7,10 @@ import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateMan
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
 import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
 import { triggerAnnotationCompleted, triggerAnnotationModified, } from '../../stateManagement/annotation/helpers/state';
-import { drawCircle as drawCircleSvg, drawHandles as drawHandlesSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, } from '../../drawingSvg';
+import { drawCircle as drawCircleSvg, drawHandles as drawHandlesSvg, } from '../../drawingSvg';
 import { state } from '../../store/state';
 import { ChangeTypes, Events, MeasurementType } from '../../enums';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
-import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { getPixelValueUnits } from '../../utilities/getPixelValueUnits';
@@ -434,40 +433,22 @@ class CircleROITool extends AnnotationTool {
                 }
                 renderStatus = true;
                 if (this.configuration.calculateStats) {
-                    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 (!textLines || textLines.length === 0) {
                         continue;
                     }
-                    let canvasTextBoxCoords;
-                    if (!data.handles.textBox.hasMoved) {
-                        canvasTextBoxCoords = getTextBoxCoordsCanvas(canvasCorners);
-                        data.handles.textBox.worldPosition =
-                            viewport.canvasToWorld(canvasTextBoxCoords);
+                    const linkAnchorPoints = [center, canvasCoordinates[1]];
+                    if (!this.renderLinkedTextBoxAnnotation({
+                        enabledElement,
+                        svgDrawingHelper,
+                        annotation,
+                        styleSpecifier,
+                        textLines,
+                        canvasCoordinates: linkAnchorPoints,
+                        placementPoints: canvasCorners,
+                    })) {
+                        continue;
                     }
-                    const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
-                    const textBoxUID = '1';
-                    const boundingBox = drawLinkedTextBoxSvg(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, [center, canvasCoordinates[1]], {}, options);
-                    const { x: left, y: top, width, height } = boundingBox;
-                    data.handles.textBox.worldBoundingBox = {
-                        topLeft: viewport.canvasToWorld([left, top]),
-                        topRight: viewport.canvasToWorld([left + width, top]),
-                        bottomLeft: viewport.canvasToWorld([left, top + height]),
-                        bottomRight: viewport.canvasToWorld([left + width, top + height]),
-                    };
                 }
             }
             return renderStatus;

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

@@ -9,10 +9,9 @@ import { triggerAnnotationCompleted, triggerAnnotationModified, } from '../../st
 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, drawTextBox as drawTextBoxSvg, } from '../../drawingSvg';
+import { drawHandles as drawHandlesSvg, drawLine as drawLineSvg, drawTextBox as drawTextBoxSvg, } from '../../drawingSvg';
 import { state } from '../../store/state';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
-import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
@@ -403,44 +402,27 @@ class CobbAngleTool extends AnnotationTool {
                 if (!data.cachedStats[targetId]?.angle) {
                     continue;
                 }
-                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);
+                if (!this.renderLinkedTextBoxAnnotation({
+                    enabledElement,
+                    svgDrawingHelper,
+                    annotation,
+                    styleSpecifier,
+                    textLines: textLines ?? [],
+                    canvasCoordinates,
+                    textBoxUID: 'cobbAngleText',
+                })) {
+                    continue;
                 }
-                const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
-                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]),
-                    topRight: viewport.canvasToWorld([left + width, top]),
-                    bottomLeft: viewport.canvasToWorld([left, top + height]),
-                    bottomRight: viewport.canvasToWorld([left + width, top + height]),
-                };
                 if (this.configuration.showArcLines) {
+                    const textBoxStyleOptions = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
                     const arc1TextBoxUID = 'arcAngle1';
                     const arc1TextLine = [
                         `${arc1Angle.toFixed(2)} ${String.fromCharCode(176)}`,
                     ];
                     const arch1TextPosCanvas = midPoint2(arc1Start, arc1End);
                     drawTextBoxSvg(svgDrawingHelper, annotationUID, arc1TextBoxUID, arc1TextLine, arch1TextPosCanvas, {
-                        ...options,
+                        ...textBoxStyleOptions,
                         padding: 3,
                     });
                     const arc2TextBoxUID = 'arcAngle2';
@@ -449,7 +431,7 @@ class CobbAngleTool extends AnnotationTool {
                     ];
                     const arch2TextPosCanvas = midPoint2(arc2Start, arc2End);
                     drawTextBoxSvg(svgDrawingHelper, annotationUID, arc2TextBoxUID, arc2TextLine, arch2TextPosCanvas, {
-                        ...options,
+                        ...textBoxStyleOptions,
                         padding: 3,
                     });
                 }

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

@@ -6,11 +6,10 @@ import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateMan
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
 import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
 import { triggerAnnotationCompleted, triggerAnnotationModified, } from '../../stateManagement/annotation/helpers/state';
-import { drawCircle as drawCircleSvg, drawEllipseByCoordinates as drawEllipseSvg, drawHandles as drawHandlesSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, } from '../../drawingSvg';
+import { drawCircle as drawCircleSvg, drawEllipseByCoordinates as drawEllipseSvg, drawHandles as drawHandlesSvg, } from '../../drawingSvg';
 import { state } from '../../store/state';
 import { ChangeTypes, Events } from '../../enums';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
-import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
 import getWorldWidthAndHeightFromTwoPoints from '../../utilities/planar/getWorldWidthAndHeightFromTwoPoints';
 import { pointInEllipse, getCanvasEllipseCorners, } from '../../utilities/math/ellipse';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
@@ -471,40 +470,21 @@ class EllipticalROITool extends AnnotationTool {
                     }
                 }
                 renderStatus = true;
-                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 (!textLines || textLines.length === 0) {
                     continue;
                 }
-                let canvasTextBoxCoords;
-                if (!data.handles.textBox.hasMoved) {
-                    canvasTextBoxCoords = getTextBoxCoordsCanvas(canvasCorners);
-                    data.handles.textBox.worldPosition =
-                        viewport.canvasToWorld(canvasTextBoxCoords);
+                if (!this.renderLinkedTextBoxAnnotation({
+                    enabledElement,
+                    svgDrawingHelper,
+                    annotation,
+                    styleSpecifier,
+                    textLines,
+                    canvasCoordinates,
+                    placementPoints: canvasCorners,
+                })) {
+                    continue;
                 }
-                const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
-                const textBoxUID = '1';
-                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]),
-                    topRight: viewport.canvasToWorld([left + width, top]),
-                    bottomLeft: viewport.canvasToWorld([left, top + height]),
-                    bottomRight: viewport.canvasToWorld([left + width, top + height]),
-                };
             }
             return renderStatus;
         };

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

@@ -8,10 +8,9 @@ import { isAnnotationLocked } from '../../stateManagement/annotation/annotationL
 import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
 import { triggerAnnotationCompleted, triggerAnnotationModified, } from '../../stateManagement/annotation/helpers/state';
 import * as lineSegment from '../../utilities/math/line';
-import { drawHandles as drawHandlesSvg, drawHeight as drawHeightSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, } from '../../drawingSvg';
+import { drawHandles as drawHandlesSvg, drawHeight as drawHeightSvg, } from '../../drawingSvg';
 import { state } from '../../store/state';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
-import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import { getStyleProperty } from '../../stateManagement/annotation/config/helpers';
@@ -120,7 +119,7 @@ class HeightTool extends AnnotationTool {
             this.isDrawing = true;
             const eventDetail = evt.detail;
             const { element } = eventDetail;
-            const { annotation, viewportIdsToRender, handleIndex, movingTextBox, newAnnotation } = this.editData;
+            const { annotation, viewportIdsToRender, handleIndex, movingTextBox, newAnnotation, } = this.editData;
             const { data } = annotation;
             this.createMemo(element, annotation, { newAnnotation });
             if (movingTextBox) {
@@ -281,36 +280,17 @@ class HeightTool extends AnnotationTool {
                     console.warn('Rendering Engine has been destroyed');
                     return renderStatus;
                 }
-                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);
+                if (!this.renderLinkedTextBoxAnnotation({
+                    enabledElement,
+                    svgDrawingHelper,
+                    annotation,
+                    styleSpecifier,
+                    textLines: textLines ?? [],
+                    canvasCoordinates,
+                })) {
+                    continue;
                 }
-                const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
-                const textBoxUID = '1';
-                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]),
-                    topRight: viewport.canvasToWorld([left + width, top]),
-                    bottomLeft: viewport.canvasToWorld([left, top + height]),
-                    bottomRight: viewport.canvasToWorld([left + width, top + height]),
-                };
             }
             return renderStatus;
         };

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

@@ -8,10 +8,9 @@ import { isAnnotationLocked } from '../../stateManagement/annotation/annotationL
 import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
 import { triggerAnnotationCompleted, triggerAnnotationModified, } from '../../stateManagement/annotation/helpers/state';
 import * as lineSegment from '../../utilities/math/line';
-import { drawHandles as drawHandlesSvg, drawLine as drawLineSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, } from '../../drawingSvg';
+import { drawHandles as drawHandlesSvg, drawLine as drawLineSvg, } from '../../drawingSvg';
 import { state } from '../../store/state';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
-import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import { getStyleProperty } from '../../stateManagement/annotation/config/helpers';
@@ -293,36 +292,17 @@ class LengthTool extends AnnotationTool {
                     console.warn('Rendering Engine has been destroyed');
                     return renderStatus;
                 }
-                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);
+                if (!this.renderLinkedTextBoxAnnotation({
+                    enabledElement,
+                    svgDrawingHelper,
+                    annotation,
+                    styleSpecifier,
+                    textLines: textLines ?? [],
+                    canvasCoordinates,
+                })) {
+                    continue;
                 }
-                const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
-                const textBoxUID = '1';
-                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]),
-                    topRight: viewport.canvasToWorld([left + width, top]),
-                    bottomLeft: viewport.canvasToWorld([left, top + height]),
-                    bottomRight: viewport.canvasToWorld([left + width, top + height]),
-                };
             }
             return renderStatus;
         };

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

@@ -1,7 +1,7 @@
 import { vec3 } from 'gl-matrix';
 import { getEnabledElement, utilities as csUtils, VolumeViewport, utilities, triggerEvent, eventTarget, } from '@cornerstonejs/core';
 import { removeAnnotation } from '../../stateManagement/annotation/annotationState';
-import { drawHandles as drawHandlesSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, } from '../../drawingSvg';
+import { drawHandles as drawHandlesSvg } from '../../drawingSvg';
 import { state } from '../../store/state';
 import { Events, KeyboardBindings, ChangeTypes } from '../../enums';
 import getMouseModifierKey from '../../eventDispatchers/shared/getMouseModifier';
@@ -14,7 +14,6 @@ import { LivewireScissors } from '../../utilities/livewire/LivewireScissors';
 import { LivewirePath } from '../../utilities/livewire/LiveWirePath';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import ContourSegmentationBaseTool from '../base/ContourSegmentationBaseTool';
-import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
 import { getCalibratedLengthUnitsAndScale, throttle } from '../../utilities';
 const CLICK_CLOSE_CURVE_SQR_DIST = 10 ** 2;
 class LivewireContourTool extends ContourSegmentationBaseTool {
@@ -365,32 +364,33 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
             }
             return cachedStats;
         };
-        this._renderStats = (annotation, viewport, svgDrawingHelper, textboxStyle) => {
+        this._renderStats = (annotation, enabledElement, svgDrawingHelper) => {
             const data = annotation.data;
+            const { viewport } = enabledElement;
             const targetId = this.getTargetId(viewport);
-            if (!data.contour.closed || !textboxStyle.visibility) {
+            if (!data.contour.closed) {
                 return;
             }
+            const styleSpecifier = {
+                toolGroupId: this.toolGroupId,
+                toolName: this.getToolName(),
+                viewportId: enabledElement.viewport.id,
+                annotationUID: annotation.annotationUID,
+            };
             const textLines = this.configuration.getTextLines(data, targetId);
             if (!textLines || textLines.length === 0) {
                 return;
             }
             const canvasCoordinates = data.handles.points.map((p) => viewport.worldToCanvas(p));
-            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 = 'textBox';
-            const boundingBox = drawLinkedTextBoxSvg(svgDrawingHelper, annotation.annotationUID ?? '', textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, textboxStyle);
-            const { x: left, y: top, width, height } = boundingBox;
-            data.handles.textBox.worldBoundingBox = {
-                topLeft: viewport.canvasToWorld([left, top]),
-                topRight: viewport.canvasToWorld([left + width, top]),
-                bottomLeft: viewport.canvasToWorld([left, top + height]),
-                bottomRight: viewport.canvasToWorld([left + width, top + height]),
-            };
+            this.renderLinkedTextBoxAnnotation({
+                enabledElement,
+                svgDrawingHelper,
+                annotation,
+                styleSpecifier,
+                textLines,
+                canvasCoordinates,
+                textBoxUID: 'textBox',
+            });
         };
         this.triggerAnnotationModified = (annotation, enabledElement, changeType = ChangeTypes.StatsUpdated) => {
             const { viewportId, renderingEngineId } = enabledElement;
@@ -618,7 +618,7 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
         else if (annotation.invalidated) {
             this._throttledCalculateCachedStats(annotation, element);
         }
-        this._renderStats(annotation, viewport, svgDrawingHelper, annotationStyle.textbox);
+        this._renderStats(annotation, enabledElement, svgDrawingHelper);
         return true;
     }
     updateAnnotation(livewirePath) {