@cornerstonejs/tools 0.1.1

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

@@ -0,0 +1,681 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const gl_matrix_1 = require("gl-matrix");
+const core_1 = require("@cornerstonejs/core");
+const base_1 = require("../base");
+const throttle_1 = __importDefault(require("../../utilities/throttle"));
+const annotationState_1 = require("../../stateManagement/annotation/annotationState");
+const annotationLocking_1 = require("../../stateManagement/annotation/annotationLocking");
+const drawingSvg_1 = require("../../drawingSvg");
+const store_1 = require("../../store");
+const enums_1 = require("../../enums");
+const viewportFilters_1 = require("../../utilities/viewportFilters");
+const line_1 = __importDefault(require("../../utilities/math/line"));
+const drawing_1 = require("../../utilities/drawing");
+const transformPhysicalToIndex_1 = __importDefault(require("../../utilities/transformPhysicalToIndex"));
+const elementCursor_1 = require("../../cursors/elementCursor");
+const triggerAnnotationRenderForViewportUIDs_1 = __importDefault(require("../../utilities/triggerAnnotationRenderForViewportUIDs"));
+class BidirectionalTool extends base_1.AnnotationTool {
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
+        configuration: {
+            shadow: true,
+            preventHandleOutsideImage: false,
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this.isPointNearTool = (element, annotation, canvasCoords, proximity) => {
+            const enabledElement = (0, core_1.getEnabledElement)(element);
+            const { viewport } = enabledElement;
+            const { data } = annotation;
+            const { points } = data.handles;
+            let canvasPoint1 = viewport.worldToCanvas(points[0]);
+            let canvasPoint2 = viewport.worldToCanvas(points[1]);
+            let line = {
+                start: {
+                    x: canvasPoint1[0],
+                    y: canvasPoint1[1],
+                },
+                end: {
+                    x: canvasPoint2[0],
+                    y: canvasPoint2[1],
+                },
+            };
+            let distanceToPoint = line_1.default.distanceToPoint([line.start.x, line.start.y], [line.end.x, line.end.y], [canvasCoords[0], canvasCoords[1]]);
+            if (distanceToPoint <= proximity) {
+                return true;
+            }
+            canvasPoint1 = viewport.worldToCanvas(points[2]);
+            canvasPoint2 = viewport.worldToCanvas(points[3]);
+            line = {
+                start: {
+                    x: canvasPoint1[0],
+                    y: canvasPoint1[1],
+                },
+                end: {
+                    x: canvasPoint2[0],
+                    y: canvasPoint2[1],
+                },
+            };
+            distanceToPoint = line_1.default.distanceToPoint([line.start.x, line.start.y], [line.end.x, line.end.y], [canvasCoords[0], canvasCoords[1]]);
+            if (distanceToPoint <= proximity) {
+                return true;
+            }
+            return false;
+        };
+        this.toolSelectedCallback = (evt, annotation, interactionType) => {
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            annotation.highlighted = true;
+            const viewportUIDsToRender = (0, viewportFilters_1.getViewportUIDsWithToolToRender)(element, BidirectionalTool.toolName);
+            this.editData = {
+                annotation,
+                viewportUIDsToRender,
+                movingTextBox: false,
+            };
+            this._activateModify(element);
+            const enabledElement = (0, core_1.getEnabledElement)(element);
+            const { renderingEngine } = enabledElement;
+            (0, triggerAnnotationRenderForViewportUIDs_1.default)(renderingEngine, viewportUIDsToRender);
+            (0, elementCursor_1.hideElementCursor)(element);
+            evt.preventDefault();
+        };
+        this.handleSelectedCallback = (evt, annotation, handle, interactionType = 'mouse') => {
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const data = annotation.data;
+            annotation.highlighted = true;
+            let movingTextBox = false;
+            let handleIndex;
+            if (handle.worldPosition) {
+                movingTextBox = true;
+            }
+            else {
+                handleIndex = data.handles.points.findIndex((p) => p === handle);
+            }
+            const viewportUIDsToRender = (0, viewportFilters_1.getViewportUIDsWithToolToRender)(element, BidirectionalTool.toolName);
+            (0, elementCursor_1.hideElementCursor)(element);
+            this.editData = {
+                annotation,
+                viewportUIDsToRender,
+                handleIndex,
+                movingTextBox,
+            };
+            this._activateModify(element);
+            const enabledElement = (0, core_1.getEnabledElement)(element);
+            const { renderingEngine } = enabledElement;
+            (0, triggerAnnotationRenderForViewportUIDs_1.default)(renderingEngine, viewportUIDsToRender);
+            evt.preventDefault();
+        };
+        this._mouseUpCallback = (evt) => {
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const { annotation, viewportUIDsToRender, newAnnotation, hasMoved } = this.editData;
+            const { data } = annotation;
+            if (newAnnotation && !hasMoved) {
+                return;
+            }
+            annotation.highlighted = false;
+            data.handles.activeHandleIndex = null;
+            this._deactivateModify(element);
+            this._deactivateDraw(element);
+            (0, elementCursor_1.resetElementCursor)(element);
+            const enabledElement = (0, core_1.getEnabledElement)(element);
+            const { renderingEngine } = enabledElement;
+            if (this.editData.handleIndex !== undefined) {
+                const { points } = data.handles;
+                const firstLineSegmentLength = gl_matrix_1.vec3.distance(points[0], points[1]);
+                const secondLineSegmentLength = gl_matrix_1.vec3.distance(points[2], points[3]);
+                if (secondLineSegmentLength > firstLineSegmentLength) {
+                    const longAxis = [[...points[2]], [...points[3]]];
+                    const shortAxisPoint0 = [...points[0]];
+                    const shortAxisPoint1 = [...points[1]];
+                    const longAxisVector = gl_matrix_1.vec2.create();
+                    gl_matrix_1.vec2.set(longAxisVector, longAxis[1][0] - longAxis[0][0], longAxis[1][1] - longAxis[1][0]);
+                    const counterClockWisePerpendicularToLongAxis = gl_matrix_1.vec2.create();
+                    gl_matrix_1.vec2.set(counterClockWisePerpendicularToLongAxis, -longAxisVector[1], longAxisVector[0]);
+                    const currentShortAxisVector = gl_matrix_1.vec2.create();
+                    gl_matrix_1.vec2.set(currentShortAxisVector, shortAxisPoint1[0] - shortAxisPoint0[0], shortAxisPoint1[1] - shortAxisPoint0[0]);
+                    let shortAxis;
+                    if (gl_matrix_1.vec2.dot(currentShortAxisVector, counterClockWisePerpendicularToLongAxis) > 0) {
+                        shortAxis = [shortAxisPoint0, shortAxisPoint1];
+                    }
+                    else {
+                        shortAxis = [shortAxisPoint1, shortAxisPoint0];
+                    }
+                    data.handles.points = [
+                        longAxis[0],
+                        longAxis[1],
+                        shortAxis[0],
+                        shortAxis[1],
+                    ];
+                }
+            }
+            if (this.isHandleOutsideImage &&
+                this.configuration.preventHandleOutsideImage) {
+                (0, annotationState_1.removeAnnotation)(element, annotation.annotationUID);
+            }
+            (0, triggerAnnotationRenderForViewportUIDs_1.default)(renderingEngine, viewportUIDsToRender);
+            this.editData = null;
+            this.isDrawing = false;
+        };
+        this._mouseDragDrawCallback = (evt) => {
+            this.isDrawing = true;
+            const eventDetail = evt.detail;
+            const { currentPoints, element } = eventDetail;
+            const enabledElement = (0, core_1.getEnabledElement)(element);
+            const { renderingEngine, viewport } = enabledElement;
+            const { worldToCanvas } = viewport;
+            const { annotation, viewportUIDsToRender, handleIndex } = this.editData;
+            const { data } = annotation;
+            const worldPos = currentPoints.world;
+            data.handles.points[handleIndex] = [...worldPos];
+            const canvasCoordPoints = data.handles.points.map(worldToCanvas);
+            const canvasCoords = {
+                longLineSegment: {
+                    start: {
+                        x: canvasCoordPoints[0][0],
+                        y: canvasCoordPoints[0][1],
+                    },
+                    end: {
+                        x: canvasCoordPoints[1][0],
+                        y: canvasCoordPoints[1][1],
+                    },
+                },
+                shortLineSegment: {
+                    start: {
+                        x: canvasCoordPoints[2][0],
+                        y: canvasCoordPoints[2][1],
+                    },
+                    end: {
+                        x: canvasCoordPoints[3][0],
+                        y: canvasCoordPoints[3][1],
+                    },
+                },
+            };
+            const dist = gl_matrix_1.vec2.distance(canvasCoordPoints[0], canvasCoordPoints[1]);
+            const shortAxisDistFromCenter = dist / 3;
+            const dx = canvasCoords.longLineSegment.start.x - canvasCoords.longLineSegment.end.x;
+            const dy = canvasCoords.longLineSegment.start.y - canvasCoords.longLineSegment.end.y;
+            const length = Math.sqrt(dx * dx + dy * dy);
+            const vectorX = dx / length;
+            const vectorY = dy / length;
+            const xMid = (canvasCoords.longLineSegment.start.x +
+                canvasCoords.longLineSegment.end.x) /
+                2;
+            const yMid = (canvasCoords.longLineSegment.start.y +
+                canvasCoords.longLineSegment.end.y) /
+                2;
+            const startX = xMid + shortAxisDistFromCenter * vectorY;
+            const startY = yMid - shortAxisDistFromCenter * vectorX;
+            const endX = xMid - shortAxisDistFromCenter * vectorY;
+            const endY = yMid + shortAxisDistFromCenter * vectorX;
+            data.handles.points[2] = viewport.canvasToWorld([startX, startY]);
+            data.handles.points[3] = viewport.canvasToWorld([endX, endY]);
+            annotation.invalidated = true;
+            (0, triggerAnnotationRenderForViewportUIDs_1.default)(renderingEngine, viewportUIDsToRender);
+            this.editData.hasMoved = true;
+        };
+        this._mouseDragModifyCallback = (evt) => {
+            this.isDrawing = true;
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const enabledElement = (0, core_1.getEnabledElement)(element);
+            const { renderingEngine } = enabledElement;
+            const { annotation, viewportUIDsToRender, handleIndex, movingTextBox } = this.editData;
+            const { data } = annotation;
+            if (movingTextBox) {
+                const { deltaPoints } = eventDetail;
+                const worldPosDelta = deltaPoints.world;
+                const { textBox } = data.handles;
+                const { worldPosition } = textBox;
+                worldPosition[0] += worldPosDelta[0];
+                worldPosition[1] += worldPosDelta[1];
+                worldPosition[2] += worldPosDelta[2];
+                textBox.hasMoved = true;
+            }
+            else if (handleIndex === undefined) {
+                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];
+                });
+                annotation.invalidated = true;
+            }
+            else {
+                this._mouseDragModifyHandle(evt);
+                annotation.invalidated = true;
+            }
+            (0, triggerAnnotationRenderForViewportUIDs_1.default)(renderingEngine, viewportUIDsToRender);
+        };
+        this._mouseDragModifyHandle = (evt) => {
+            const eventDetail = evt.detail;
+            const { currentPoints, element } = eventDetail;
+            const enabledElement = (0, core_1.getEnabledElement)(element);
+            const { viewport } = enabledElement;
+            const { annotation, handleIndex } = this.editData;
+            const { data } = annotation;
+            const worldPos = currentPoints.world;
+            const canvasCoordHandlesCurrent = [
+                viewport.worldToCanvas(data.handles.points[0]),
+                viewport.worldToCanvas(data.handles.points[1]),
+                viewport.worldToCanvas(data.handles.points[2]),
+                viewport.worldToCanvas(data.handles.points[3]),
+            ];
+            const firstLineSegment = {
+                start: {
+                    x: canvasCoordHandlesCurrent[0][0],
+                    y: canvasCoordHandlesCurrent[0][1],
+                },
+                end: {
+                    x: canvasCoordHandlesCurrent[1][0],
+                    y: canvasCoordHandlesCurrent[1][1],
+                },
+            };
+            const secondLineSegment = {
+                start: {
+                    x: canvasCoordHandlesCurrent[2][0],
+                    y: canvasCoordHandlesCurrent[2][1],
+                },
+                end: {
+                    x: canvasCoordHandlesCurrent[3][0],
+                    y: canvasCoordHandlesCurrent[3][1],
+                },
+            };
+            const proposedPoint = [...worldPos];
+            const proposedCanvasCoord = viewport.worldToCanvas(proposedPoint);
+            if (handleIndex === 0 || handleIndex === 1) {
+                const fixedHandleIndex = handleIndex === 0 ? 1 : 0;
+                const fixedCanvasCoord = canvasCoordHandlesCurrent[fixedHandleIndex];
+                const proposedFirstLineSegment = {
+                    start: {
+                        x: fixedCanvasCoord[0],
+                        y: fixedCanvasCoord[1],
+                    },
+                    end: {
+                        x: proposedCanvasCoord[0],
+                        y: proposedCanvasCoord[1],
+                    },
+                };
+                if (this._movingLongAxisWouldPutItThroughShortAxis(proposedFirstLineSegment, secondLineSegment)) {
+                    return;
+                }
+                const intersectionPoint = line_1.default.intersectLine([secondLineSegment.start.x, secondLineSegment.start.y], [secondLineSegment.end.x, secondLineSegment.end.y], [firstLineSegment.start.x, firstLineSegment.start.y], [firstLineSegment.end.x, firstLineSegment.end.y]);
+                const intersectionCoord = gl_matrix_1.vec2.create();
+                gl_matrix_1.vec2.set(intersectionCoord, intersectionPoint[0], intersectionPoint[1]);
+                const distFromLeftHandle = gl_matrix_1.vec2.distance(canvasCoordHandlesCurrent[2], intersectionCoord);
+                const distFromRightHandle = gl_matrix_1.vec2.distance(canvasCoordHandlesCurrent[3], intersectionCoord);
+                const distIntersectAndFixedPoint = Math.abs(gl_matrix_1.vec2.distance(fixedCanvasCoord, intersectionCoord));
+                const dx = fixedCanvasCoord[0] - proposedCanvasCoord[0];
+                const dy = fixedCanvasCoord[1] - proposedCanvasCoord[1];
+                const length = Math.sqrt(dx * dx + dy * dy);
+                const vectorX = dx / length;
+                const vectorY = dy / length;
+                const intersectX = fixedCanvasCoord[0] - distIntersectAndFixedPoint * vectorX;
+                const intersectY = fixedCanvasCoord[1] - distIntersectAndFixedPoint * vectorY;
+                const mod = handleIndex === 0 ? -1 : 1;
+                const leftX = intersectX + distFromLeftHandle * vectorY * mod;
+                const leftY = intersectY - distFromLeftHandle * vectorX * mod;
+                const rightX = intersectX - distFromRightHandle * vectorY * mod;
+                const rightY = intersectY + distFromRightHandle * vectorX * mod;
+                data.handles.points[handleIndex] = proposedPoint;
+                data.handles.points[2] = viewport.canvasToWorld([leftX, leftY]);
+                data.handles.points[3] = viewport.canvasToWorld([rightX, rightY]);
+            }
+            else {
+                const translateHandleIndex = handleIndex === 2 ? 3 : 2;
+                const proposedCanvasCoordPoint = {
+                    x: proposedCanvasCoord[0],
+                    y: proposedCanvasCoord[1],
+                };
+                const canvasCoordsCurrent = {
+                    longLineSegment: {
+                        start: firstLineSegment.start,
+                        end: firstLineSegment.end,
+                    },
+                    shortLineSegment: {
+                        start: secondLineSegment.start,
+                        end: secondLineSegment.end,
+                    },
+                };
+                const dx = canvasCoordsCurrent.longLineSegment.start.x -
+                    canvasCoordsCurrent.longLineSegment.end.x;
+                const dy = canvasCoordsCurrent.longLineSegment.start.y -
+                    canvasCoordsCurrent.longLineSegment.end.y;
+                const length = Math.sqrt(dx * dx + dy * dy);
+                const vectorX = dx / length;
+                const vectorY = dy / length;
+                const highNumber = Number.MAX_SAFE_INTEGER;
+                const mod = handleIndex === 0 || handleIndex === 3 ? 1 : -1;
+                const multiplier = mod * highNumber;
+                const helperLine = {
+                    start: proposedCanvasCoordPoint,
+                    end: {
+                        x: proposedCanvasCoordPoint.x + vectorY * multiplier,
+                        y: proposedCanvasCoordPoint.y + vectorX * multiplier * -1,
+                    },
+                };
+                const newIntersectionPoint = line_1.default.intersectLine([
+                    canvasCoordsCurrent.longLineSegment.start.x,
+                    canvasCoordsCurrent.longLineSegment.start.y,
+                ], [
+                    canvasCoordsCurrent.longLineSegment.end.x,
+                    canvasCoordsCurrent.longLineSegment.end.y,
+                ], [helperLine.start.x, helperLine.start.y], [helperLine.end.x, helperLine.end.y]);
+                if (newIntersectionPoint === undefined) {
+                    return;
+                }
+                const distFromTranslateHandle = gl_matrix_1.vec2.distance(canvasCoordHandlesCurrent[translateHandleIndex], [newIntersectionPoint[0], newIntersectionPoint[1]]);
+                const shortLineSegment = {
+                    start: {
+                        x: newIntersectionPoint[0] + vectorY * distFromTranslateHandle,
+                        y: newIntersectionPoint[1] + vectorX * distFromTranslateHandle * -1,
+                    },
+                    end: {
+                        x: newIntersectionPoint[0] + vectorY * distFromTranslateHandle * -1,
+                        y: newIntersectionPoint[1] + vectorX * distFromTranslateHandle,
+                    },
+                };
+                const translatedHandleCoords = translateHandleIndex === 2
+                    ? shortLineSegment.start
+                    : shortLineSegment.end;
+                data.handles.points[translateHandleIndex] = viewport.canvasToWorld([
+                    translatedHandleCoords.x,
+                    translatedHandleCoords.y,
+                ]);
+                data.handles.points[handleIndex] = proposedPoint;
+            }
+        };
+        this.cancel = (element) => {
+            if (this.isDrawing) {
+                this.isDrawing = false;
+                this._deactivateDraw(element);
+                this._deactivateModify(element);
+                (0, elementCursor_1.resetElementCursor)(element);
+                const { annotation, viewportUIDsToRender } = this.editData;
+                const { data } = annotation;
+                annotation.highlighted = false;
+                data.handles.activeHandleIndex = null;
+                const enabledElement = (0, core_1.getEnabledElement)(element);
+                const { renderingEngine } = enabledElement;
+                (0, triggerAnnotationRenderForViewportUIDs_1.default)(renderingEngine, viewportUIDsToRender);
+                this.editData = null;
+                return annotation.annotationUID;
+            }
+        };
+        this._activateDraw = (element) => {
+            store_1.state.isInteractingWithTool = true;
+            element.addEventListener(enums_1.Events.MOUSE_UP, this._mouseUpCallback);
+            element.addEventListener(enums_1.Events.MOUSE_DRAG, this._mouseDragDrawCallback);
+            element.addEventListener(enums_1.Events.MOUSE_MOVE, this._mouseDragDrawCallback);
+            element.addEventListener(enums_1.Events.MOUSE_CLICK, this._mouseUpCallback);
+        };
+        this._deactivateDraw = (element) => {
+            store_1.state.isInteractingWithTool = false;
+            element.removeEventListener(enums_1.Events.MOUSE_UP, this._mouseUpCallback);
+            element.removeEventListener(enums_1.Events.MOUSE_DRAG, this._mouseDragDrawCallback);
+            element.removeEventListener(enums_1.Events.MOUSE_MOVE, this._mouseDragDrawCallback);
+            element.removeEventListener(enums_1.Events.MOUSE_CLICK, this._mouseUpCallback);
+        };
+        this._activateModify = (element) => {
+            store_1.state.isInteractingWithTool = true;
+            element.addEventListener(enums_1.Events.MOUSE_UP, this._mouseUpCallback);
+            element.addEventListener(enums_1.Events.MOUSE_DRAG, this._mouseDragModifyCallback);
+            element.addEventListener(enums_1.Events.MOUSE_CLICK, this._mouseUpCallback);
+        };
+        this._deactivateModify = (element) => {
+            store_1.state.isInteractingWithTool = false;
+            element.removeEventListener(enums_1.Events.MOUSE_UP, this._mouseUpCallback);
+            element.removeEventListener(enums_1.Events.MOUSE_DRAG, this._mouseDragModifyCallback);
+            element.removeEventListener(enums_1.Events.MOUSE_CLICK, this._mouseUpCallback);
+        };
+        this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
+            const { viewport } = enabledElement;
+            const { element } = viewport;
+            let annotations = (0, annotationState_1.getAnnotations)(viewport.element, BidirectionalTool.toolName);
+            if (!(annotations === null || annotations === void 0 ? void 0 : annotations.length)) {
+                return;
+            }
+            annotations = this.filterInteractableAnnotationsForElement(element, annotations);
+            if (!(annotations === null || annotations === void 0 ? void 0 : annotations.length)) {
+                return;
+            }
+            const targetUID = this.getTargetUID(viewport);
+            const renderingEngine = viewport.getRenderingEngine();
+            for (let i = 0; i < annotations.length; i++) {
+                const annotation = annotations[i];
+                const settings = core_1.Settings.getObjectSettings(annotation, BidirectionalTool);
+                const annotationUID = annotation.annotationUID;
+                const data = annotation.data;
+                const { points, activeHandleIndex } = data.handles;
+                const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
+                const lineWidth = this.getStyle(settings, 'lineWidth', annotation);
+                const lineDash = this.getStyle(settings, 'lineDash', annotation);
+                const color = this.getStyle(settings, 'color', annotation);
+                if (!data.cachedStats[targetUID]) {
+                    data.cachedStats[targetUID] = {
+                        length: null,
+                        width: null,
+                    };
+                    this._calculateCachedStats(annotation, renderingEngine, enabledElement);
+                }
+                else if (annotation.invalidated) {
+                    this._throttledCalculateCachedStats(annotation, renderingEngine, enabledElement);
+                }
+                if (!viewport.getRenderingEngine()) {
+                    console.warn('Rendering Engine has been destroyed');
+                    return;
+                }
+                let activeHandleCanvasCoords;
+                if (!(0, annotationLocking_1.isAnnotationLocked)(annotation) &&
+                    !this.editData &&
+                    activeHandleIndex !== null) {
+                    activeHandleCanvasCoords = [canvasCoordinates[activeHandleIndex]];
+                }
+                if (activeHandleCanvasCoords) {
+                    const handleGroupUID = '0';
+                    (0, drawingSvg_1.drawHandles)(svgDrawingHelper, BidirectionalTool.toolName, annotationUID, handleGroupUID, activeHandleCanvasCoords, {
+                        color,
+                    });
+                }
+                const lineUID = '0';
+                (0, drawingSvg_1.drawLine)(svgDrawingHelper, BidirectionalTool.toolName, annotationUID, lineUID, canvasCoordinates[0], canvasCoordinates[1], {
+                    color,
+                    lineDash,
+                    lineWidth,
+                });
+                const secondLineUID = '1';
+                (0, drawingSvg_1.drawLine)(svgDrawingHelper, BidirectionalTool.toolName, annotationUID, secondLineUID, canvasCoordinates[2], canvasCoordinates[3], {
+                    color,
+                    lineDash,
+                    lineWidth,
+                });
+                const textLines = this._getTextLines(data, targetUID);
+                if (!textLines || textLines.length === 0) {
+                    continue;
+                }
+                let canvasTextBoxCoords;
+                if (!data.handles.textBox.hasMoved) {
+                    canvasTextBoxCoords = (0, drawing_1.getTextBoxCoordsCanvas)(canvasCoordinates);
+                    data.handles.textBox.worldPosition =
+                        viewport.canvasToWorld(canvasTextBoxCoords);
+                }
+                const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
+                const textBoxUID = '1';
+                const boundingBox = (0, drawingSvg_1.drawLinkedTextBox)(svgDrawingHelper, BidirectionalTool.toolName, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, this.getLinkedTextBoxStyle(settings, annotation));
+                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._movingLongAxisWouldPutItThroughShortAxis = (proposedFirstLineSegment, secondLineSegment) => {
+            const vectorInSecondLineDirection = gl_matrix_1.vec2.create();
+            gl_matrix_1.vec2.set(vectorInSecondLineDirection, secondLineSegment.end.x - secondLineSegment.start.x, secondLineSegment.end.y - secondLineSegment.start.y);
+            gl_matrix_1.vec2.normalize(vectorInSecondLineDirection, vectorInSecondLineDirection);
+            const extendedSecondLineSegment = {
+                start: {
+                    x: secondLineSegment.start.x - vectorInSecondLineDirection[0] * 10,
+                    y: secondLineSegment.start.y - vectorInSecondLineDirection[1] * 10,
+                },
+                end: {
+                    x: secondLineSegment.end.x + vectorInSecondLineDirection[0] * 10,
+                    y: secondLineSegment.end.y + vectorInSecondLineDirection[1] * 10,
+                },
+            };
+            const proposedIntersectionPoint = line_1.default.intersectLine([extendedSecondLineSegment.start.x, extendedSecondLineSegment.start.y], [extendedSecondLineSegment.end.x, extendedSecondLineSegment.end.y], [proposedFirstLineSegment.start.x, proposedFirstLineSegment.start.y], [proposedFirstLineSegment.end.x, proposedFirstLineSegment.end.y]);
+            const wouldPutThroughShortAxis = !proposedIntersectionPoint;
+            return wouldPutThroughShortAxis;
+        };
+        this._getTextLines = (data, targetUID) => {
+            const { cachedStats } = data;
+            const { length, width } = cachedStats[targetUID];
+            if (length === undefined) {
+                return;
+            }
+            const textLines = [
+                `L: ${length.toFixed(2)} mm`,
+                `W: ${width.toFixed(2)} mm`,
+            ];
+            return textLines;
+        };
+        this._calculateCachedStats = (annotation, renderingEngine, enabledElement) => {
+            const { data } = annotation;
+            const { viewportUID, renderingEngineUID } = enabledElement;
+            const worldPos1 = data.handles.points[0];
+            const worldPos2 = data.handles.points[1];
+            const worldPos3 = data.handles.points[2];
+            const worldPos4 = data.handles.points[3];
+            const { cachedStats } = data;
+            const targetUIDs = Object.keys(cachedStats);
+            for (let i = 0; i < targetUIDs.length; i++) {
+                const targetUID = targetUIDs[i];
+                const { image } = this.getTargetUIDViewportAndImage(targetUID, renderingEngine);
+                const { imageData, dimensions } = image;
+                const dist1 = this._calculateLength(worldPos1, worldPos2);
+                const dist2 = this._calculateLength(worldPos3, worldPos4);
+                const length = dist1 > dist2 ? dist1 : dist2;
+                const width = dist1 > dist2 ? dist2 : dist1;
+                const index1 = (0, transformPhysicalToIndex_1.default)(imageData, worldPos1);
+                const index2 = (0, transformPhysicalToIndex_1.default)(imageData, worldPos2);
+                const index3 = (0, transformPhysicalToIndex_1.default)(imageData, worldPos3);
+                const index4 = (0, transformPhysicalToIndex_1.default)(imageData, worldPos4);
+                this._isInsideVolume(index1, index2, index3, index4, dimensions)
+                    ? (this.isHandleOutsideImage = false)
+                    : (this.isHandleOutsideImage = true);
+                cachedStats[targetUID] = {
+                    length,
+                    width,
+                };
+            }
+            annotation.invalidated = false;
+            const eventType = enums_1.Events.ANNOTATION_MODIFIED;
+            const eventDetail = {
+                annotation,
+                viewportUID,
+                renderingEngineUID,
+            };
+            (0, core_1.triggerEvent)(core_1.eventTarget, eventType, eventDetail);
+            return cachedStats;
+        };
+        this._isInsideVolume = (index1, index2, index3, index4, dimensions) => {
+            return (core_1.utilities.indexWithinDimensions(index1, dimensions) &&
+                core_1.utilities.indexWithinDimensions(index2, dimensions) &&
+                core_1.utilities.indexWithinDimensions(index3, dimensions) &&
+                core_1.utilities.indexWithinDimensions(index4, dimensions));
+        };
+        this._throttledCalculateCachedStats = (0, throttle_1.default)(this._calculateCachedStats, 100, { trailing: true });
+    }
+    addNewAnnotation(evt) {
+        const eventDetail = evt.detail;
+        const { currentPoints, element } = eventDetail;
+        const worldPos = currentPoints.world;
+        const enabledElement = (0, core_1.getEnabledElement)(element);
+        const { viewport, renderingEngine } = enabledElement;
+        this.isDrawing = true;
+        const camera = viewport.getCamera();
+        const { viewPlaneNormal, viewUp } = camera;
+        let referencedImageId;
+        if (viewport instanceof core_1.StackViewport) {
+            referencedImageId =
+                viewport.getCurrentImageId && viewport.getCurrentImageId();
+        }
+        else {
+            const volumeUID = this.getTargetUID(viewport);
+            const imageVolume = core_1.cache.getVolume(volumeUID);
+            referencedImageId = core_1.utilities.getClosestImageId(imageVolume, worldPos, viewPlaneNormal, viewUp);
+        }
+        if (referencedImageId) {
+            const colonIndex = referencedImageId.indexOf(':');
+            referencedImageId = referencedImageId.substring(colonIndex + 1);
+        }
+        const annotation = {
+            highlighted: true,
+            invalidated: true,
+            metadata: {
+                viewPlaneNormal: [...viewPlaneNormal],
+                viewUp: [...viewUp],
+                FrameOfReferenceUID: viewport.getFrameOfReferenceUID(),
+                toolName: BidirectionalTool.toolName,
+                referencedImageId,
+            },
+            data: {
+                handles: {
+                    points: [
+                        [...worldPos],
+                        [...worldPos],
+                        [...worldPos],
+                        [...worldPos],
+                    ],
+                    textBox: {
+                        hasMoved: false,
+                        worldPosition: [0, 0, 0],
+                        worldBoundingBox: {
+                            topLeft: [0, 0, 0],
+                            topRight: [0, 0, 0],
+                            bottomLeft: [0, 0, 0],
+                            bottomRight: [0, 0, 0],
+                        },
+                    },
+                    activeHandleIndex: null,
+                },
+                label: '',
+                cachedStats: {},
+            },
+        };
+        core_1.Settings.getObjectSettings(annotation, BidirectionalTool);
+        (0, annotationState_1.addAnnotation)(element, annotation);
+        const viewportUIDsToRender = (0, viewportFilters_1.getViewportUIDsWithToolToRender)(element, BidirectionalTool.toolName);
+        this.editData = {
+            annotation,
+            viewportUIDsToRender,
+            handleIndex: 1,
+            movingTextBox: false,
+            newAnnotation: true,
+            hasMoved: false,
+        };
+        this._activateDraw(element);
+        (0, elementCursor_1.hideElementCursor)(element);
+        evt.preventDefault();
+        (0, triggerAnnotationRenderForViewportUIDs_1.default)(renderingEngine, viewportUIDsToRender);
+        return annotation;
+    }
+    _calculateLength(pos1, pos2) {
+        const dx = pos1[0] - pos2[0];
+        const dy = pos1[1] - pos2[1];
+        const dz = pos1[2] - pos2[2];
+        return Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+}
+exports.default = BidirectionalTool;
+BidirectionalTool.toolName = 'Bidirectional';
+//# sourceMappingURL=BidirectionalTool.js.map