@cornerstonejs/tools 4.17.1 → 4.17.3

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

@@ -14,8 +14,6 @@ import registerOpenContourEditLoop from './planarFreehandROITool/openContourEdit
 import registerOpenContourEndEditLoop from './planarFreehandROITool/openContourEndEditLoop';
 import registerRenderMethods from './planarFreehandROITool/renderMethods';
 import { triggerAnnotationModified } from '../../stateManagement/annotation/helpers/state';
-import { drawLinkedTextBox } from '../../drawingSvg';
-import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
 import { getLineSegmentIntersectionsCoordinates } from '../../utilities/math/polyline';
 import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
 import { BasicStatsCalculator } from '../../utilities/math/basic';
@@ -213,30 +211,19 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
                 viewportId: enabledElement.viewport.id,
                 annotationUID: annotation.annotationUID,
             };
-            const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
-            if (!options.visibility) {
-                return;
-            }
             const textLines = this.configuration.getTextLines(data, targetId);
             if (!textLines || textLines.length === 0) {
                 return;
             }
             const canvasCoordinates = data.contour.polyline.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 = '1';
-            const boundingBox = drawLinkedTextBox(svgDrawingHelper, annotation.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]),
-            };
+            this.renderLinkedTextBoxAnnotation({
+                enabledElement,
+                svgDrawingHelper,
+                annotation,
+                styleSpecifier,
+                textLines,
+                canvasCoordinates,
+            });
         };
         registerDrawLoop(this);
         registerEditLoopCommon(this);

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

@@ -5,6 +5,7 @@ import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateMan
 import { triggerAnnotationCompleted, triggerAnnotationModified, } from '../../stateManagement/annotation/helpers/state';
 import { getCalibratedProbeUnitsAndValue } from '../../utilities/getCalibratedUnits';
 import { drawHandles as drawHandlesSvg, drawTextBox as drawTextBoxSvg, } from '../../drawingSvg';
+import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
 import { state } from '../../store/state';
 import { ChangeTypes, Events } from '../../enums';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
@@ -207,12 +208,9 @@ class ProbeTool extends AnnotationTool {
                 }
                 const textLines = this.configuration.getTextLines(data, targetId);
                 if (textLines) {
-                    const textCanvasCoordinates = [
-                        canvasCoordinates[0] + this.configuration.textCanvasOffset.x,
-                        canvasCoordinates[1] + this.configuration.textCanvasOffset.y,
-                    ];
+                    const textCanvasCoordinates = getTextBoxCoordsCanvas([canvasCoordinates], element, textLines);
                     const textUID = '0';
-                    drawTextBoxSvg(svgDrawingHelper, annotationUID, textUID, textLines, [textCanvasCoordinates[0], textCanvasCoordinates[1]], options);
+                    drawTextBoxSvg(svgDrawingHelper, annotationUID, textUID, textLines, textCanvasCoordinates, options);
                 }
             }
             return renderStatus;

package/dist/esm/tools/annotation/RectangleROITool.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 { drawHandles as drawHandlesSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, drawRectByCoordinates as drawRectSvg, } from '../../drawingSvg';
+import { drawHandles as drawHandlesSvg, drawRectByCoordinates as drawRectSvg, } from '../../drawingSvg';
 import { state } from '../../store/state';
 import { ChangeTypes, Events } from '../../enums';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import * as rectangle from '../../utilities/math/rectangle';
-import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { getPixelValueUnits } from '../../utilities/getPixelValueUnits';
@@ -396,39 +395,20 @@ class RectangleROITool extends AnnotationTool {
                     lineWidth,
                 }, dataId);
                 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;
                 }
-                if (!data.handles.textBox.hasMoved) {
-                    const 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/SplineROITool.js

@@ -1,13 +1,12 @@
 import { getEnabledElement, eventTarget, triggerEvent, utilities, getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import { vec3 } from 'gl-matrix';
 import { addAnnotation, getChildAnnotations, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
-import { drawHandles as drawHandlesSvg, drawPolyline as drawPolylineSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, } from '../../drawingSvg';
+import { drawHandles as drawHandlesSvg, drawPolyline as drawPolylineSvg, } from '../../drawingSvg';
 import { state } from '../../store/state';
 import { Events, MouseBindings, KeyboardBindings, ChangeTypes, } from '../../enums';
 import * as math from '../../utilities/math';
 import throttle from '../../utilities/throttle';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
-import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
 import { getCalibratedLengthUnitsAndScale } from '../../utilities/getCalibratedUnits';
 import getMouseModifierKey from '../../eventDispatchers/shared/getMouseModifier';
 import { ContourWindingDirection } from '../../types/ContourAnnotation';
@@ -364,32 +363,33 @@ class SplineROITool extends ContourSegmentationBaseTool {
             element.removeEventListener(Events.MOUSE_DOUBLE_CLICK, this._mouseDownCallback);
             element.removeEventListener(Events.TOUCH_TAP, this._mouseDownCallback);
         };
-        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.spline.instance.closed || !textboxStyle.visibility) {
+            if (!data.spline.instance.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.addControlPointCallback = (evt, annotation) => {
             const { data } = annotation;
@@ -661,7 +661,7 @@ class SplineROITool extends ContourSegmentationBaseTool {
                 lineWidth: 1,
             });
         }
-        this._renderStats(annotation, viewport, svgDrawingHelper, annotationStyle.textbox);
+        this._renderStats(annotation, enabledElement, svgDrawingHelper);
         if (this.fireChangeOnUpdate?.annotationUID === annotationUID) {
             this.triggerChangeEvent(annotation, enabledElement, this.fireChangeOnUpdate.changeType, this.fireChangeOnUpdate.contourHoleProcessingEnabled);
             this.fireChangeOnUpdate = null;

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

@@ -4,7 +4,7 @@ import { AnnotationTool } from '../base';
 import throttle from '../../utilities/throttle';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
 import { triggerAnnotationCompleted, triggerAnnotationModified, } from '../../stateManagement/annotation/helpers/state';
-import { drawHandle as drawHandleSvg, drawLine as drawLineSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, } from '../../drawingSvg';
+import { drawHandle as drawHandleSvg, drawLine as drawLineSvg, } from '../../drawingSvg';
 import { state } from '../../store/state';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import { distanceToPoint } from '../../utilities/math/point';
@@ -308,36 +308,22 @@ class UltrasoundDirectionalTool extends AnnotationTool {
                         shadow: this.configuration.shadow,
                     }, dataId);
                 }
-                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, this.configuration);
-                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/base/AnnotationTool.d.ts

@@ -3,6 +3,7 @@ import type { Types } from '@cornerstonejs/core';
 import AnnotationDisplayTool from './AnnotationDisplayTool';
 import type { Annotation, Annotations, EventTypes, ToolHandle, InteractionTypes, ToolProps, PublicToolProps } from '../../types';
 import type { AnnotationStyle, StyleSpecifier } from '../../types/AnnotationStyle';
+import type { SVGDrawingHelper } from '../../types';
 declare abstract class AnnotationTool extends AnnotationDisplayTool {
     protected eventDispatchDetail: {
         viewportId: string;
@@ -30,6 +31,16 @@ declare abstract class AnnotationTool extends AnnotationDisplayTool {
     mouseMoveCallback: (evt: EventTypes.MouseMoveEventType, filteredAnnotations?: Annotations) => boolean;
     getHandleNearImagePoint(element: HTMLDivElement, annotation: Annotation, canvasCoords: Types.Point2, proximity: number): ToolHandle | undefined;
     getLinkedTextBoxStyle(specifications: StyleSpecifier, annotation?: Annotation): Record<string, unknown>;
+    protected renderLinkedTextBoxAnnotation(options: {
+        enabledElement: Types.IEnabledElement;
+        svgDrawingHelper: SVGDrawingHelper;
+        annotation: Annotation;
+        styleSpecifier: StyleSpecifier;
+        textLines: string[];
+        canvasCoordinates: Types.Point2[];
+        textBoxUID?: string;
+        placementPoints?: Types.Point2[];
+    }): boolean;
     static isSuvScaled(viewport: Types.IStackViewport | Types.IVolumeViewport, targetId: string, imageId?: string): boolean;
     isSuvScaled: typeof AnnotationTool.isSuvScaled;
     protected getAnnotationStyle(context: {

package/dist/esm/tools/base/AnnotationTool.js

@@ -5,6 +5,8 @@ import { isAnnotationLocked } from '../../stateManagement/annotation/annotationL
 import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
 import { addAnnotation, removeAnnotation, getAnnotation, } from '../../stateManagement/annotation/annotationState';
 import { triggerAnnotationModified } from '../../stateManagement/annotation/helpers/state';
+import { drawLinkedTextBox } from '../../drawingSvg';
+import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
 import ChangeTypes from '../../enums/ChangeTypes';
 import { setAnnotationSelected } from '../../stateManagement/annotation/annotationSelection';
 import { addContourSegmentationAnnotation } from '../../utilities/contourSegmentation';
@@ -112,6 +114,54 @@ class AnnotationTool extends AnnotationDisplayTool {
             textBoxLinkLineColor: this.getStyle('textBoxLinkLineColor', specifications, annotation),
         };
     }
+    renderLinkedTextBoxAnnotation(options) {
+        const { enabledElement, svgDrawingHelper, annotation, styleSpecifier, textLines, canvasCoordinates, textBoxUID = '1', placementPoints, } = options;
+        const { viewport } = enabledElement;
+        const { element } = viewport;
+        const { annotationUID, data } = annotation;
+        const styleOptions = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+        if (!styleOptions.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],
+                },
+            };
+            return false;
+        }
+        if (!data.handles.textBox) {
+            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],
+                },
+            };
+        }
+        const pointsForPlacement = placementPoints ?? canvasCoordinates;
+        if (!data.handles.textBox.hasMoved) {
+            const canvasTextBoxCoords = getTextBoxCoordsCanvas(pointsForPlacement, element, textLines);
+            data.handles.textBox.worldPosition =
+                viewport.canvasToWorld(canvasTextBoxCoords);
+        }
+        const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
+        const boundingBox = drawLinkedTextBox(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, styleOptions);
+        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 true;
+    }
     static isSuvScaled(viewport, targetId, imageId) {
         if (viewport instanceof BaseVolumeViewport) {
             const volumeId = csUtils.getVolumeId(targetId);

package/dist/esm/tools/segmentation/CircleROIStartEndThresholdTool.js

@@ -2,10 +2,9 @@ import { StackViewport, cache, getEnabledElement, utilities as csUtils, utilitie
 import { vec3 } from 'gl-matrix';
 import { addAnnotation, removeAnnotation, getAnnotations, } from '../../stateManagement/annotation/annotationState';
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
-import { drawCircle as drawCircleSvg, drawHandles as drawHandlesSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, } from '../../drawingSvg';
+import { drawCircle as drawCircleSvg, drawHandles as drawHandlesSvg, } from '../../drawingSvg';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import getWorldWidthAndHeightFromTwoPoints from '../../utilities/planar/getWorldWidthAndHeightFromTwoPoints';
-import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
 import throttle from '../../utilities/throttle';
 import debounce from '../../utilities/debounce';
 import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
@@ -279,40 +278,25 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
                 }
                 renderStatus = true;
                 if (this.configuration.showTextBox) {
-                    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, { metadata });
                     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 = [
+                        canvasCoordinates[0],
+                        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, [canvasCoordinates[0], 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/segmentation/RectangleROIStartEndThresholdTool.js

@@ -3,11 +3,10 @@ import { getCalibratedLengthUnitsAndScale } from '../../utilities/getCalibratedU
 import { vec3 } from 'gl-matrix';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateManagement';
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
-import { drawHandles as drawHandlesSvg, drawRect as drawRectSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, } from '../../drawingSvg';
+import { drawHandles as drawHandlesSvg, drawRect as drawRectSvg, } from '../../drawingSvg';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import throttle from '../../utilities/throttle';
 import debounce from '../../utilities/debounce';
-import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
 import getWorldWidthAndHeightFromCorners from '../../utilities/planar/getWorldWidthAndHeightFromCorners';
 import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
 import { hideElementCursor, resetElementCursor, } from '../../cursors/elementCursor';
@@ -240,39 +239,20 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
                 });
                 renderStatus = true;
                 if (this.configuration.showTextBox) {
-                    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, { metadata });
                     if (!textLines || textLines.length === 0) {
                         continue;
                     }
-                    if (!data.handles.textBox.hasMoved) {
-                        const 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/segmentation/SegmentBidirectionalTool.js

@@ -2,9 +2,8 @@ import { getEnabledElement, utilities as csUtils, getEnabledElementByViewportId,
 import { addAnnotation, getAllAnnotations, getAnnotations, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
 import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
-import { drawLine as drawLineSvg, drawHandles as drawHandlesSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, } from '../../drawingSvg';
+import { drawLine as drawLineSvg, drawHandles as drawHandlesSvg, } from '../../drawingSvg';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
-import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
 import { hideElementCursor } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import BidirectionalTool from '../annotation/BidirectionalTool';
@@ -94,41 +93,20 @@ class SegmentBidirectionalTool extends BidirectionalTool {
                     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;
-                }
-                options.color = color;
                 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/utilities/drawing/getTextBoxCoordsCanvas.d.ts

@@ -1,2 +1,2 @@
 import type { Types } from '@cornerstonejs/core';
-export default function getTextBoxCoordsCanvas(annotationCanvasPoints: Array<Types.Point2>): Types.Point2;
+export default function getTextBoxCoordsCanvas(annotationCanvasPoints: Array<Types.Point2>, element?: HTMLDivElement, textLines?: Array<string>): Types.Point2;