@ohif/app 3.9.0-beta.97 → 3.9.0-beta.99

package/dist/{8993.bundle.23cd5f8560800a97d798.js → 8993.bundle.fc59969a3dfc25255a3a.js}

@@ -11227,27 +11227,30 @@ class ScaleOverlayTool extends _base_AnnotationDisplayTool__WEBPACK_IMPORTED_MOD
             if (annotations.length) {
                 annotation = annotations.filter((thisAnnotation) => thisAnnotation.data.viewportId == viewport.id)[0];
             }
-            if (!viewportsWithAnnotations.includes(viewport.id)) {
-                const newAnnotation = {
-                    metadata: {
-                        toolName: this.getToolName(),
-                        viewPlaneNormal: [...viewPlaneNormal],
-                        viewUp: [...viewUp],
-                        FrameOfReferenceUID,
-                        referencedImageId: null,
-                    },
-                    data: {
-                        handles: {
-                            points: viewportCanvasCornersInWorld,
+            enabledElements.forEach((element) => {
+                const { viewport } = element;
+                if (!viewportsWithAnnotations.includes(viewport.id)) {
+                    const newAnnotation = {
+                        metadata: {
+                            toolName: this.getToolName(),
+                            viewPlaneNormal: [...viewPlaneNormal],
+                            viewUp: [...viewUp],
+                            FrameOfReferenceUID,
+                            referencedImageId: null,
                         },
-                        viewportId: viewport.id,
-                    },
-                };
-                viewportsWithAnnotations.push(viewport.id);
-                (0,_stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_3__.addAnnotation)(newAnnotation, viewport.element);
-                annotation = newAnnotation;
-            }
-            else if (this.editData.annotation &&
+                        data: {
+                            handles: {
+                                points: _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_2__.utilities.getViewportImageCornersInWorld(viewport),
+                            },
+                            viewportId: viewport.id,
+                        },
+                    };
+                    viewportsWithAnnotations.push(viewport.id);
+                    (0,_stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_3__.addAnnotation)(newAnnotation, viewport.element);
+                    annotation = newAnnotation;
+                }
+            });
+            if (this.editData.annotation &&
                 this.editData.annotation.data.viewportId == viewport.id) {
                 this.editData.annotation.data.handles.points =
                     viewportCanvasCornersInWorld;
@@ -18208,6 +18211,8 @@ LivewireContourSegmentationTool.toolName = 'LivewireContourSegmentationTool';
 /* harmony import */ var _utilities_livewire_LiveWirePath__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(27479);
 /* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(46966);
 /* harmony import */ var _base_ContourSegmentationBaseTool__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(22955);
+/* harmony import */ var _utilities_drawing__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(20724);
+
 
 
 
@@ -18229,6 +18234,8 @@ class LivewireContourTool extends _base_ContourSegmentationBaseTool__WEBPACK_IMP
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
+            getTextLines: defaultGetTextLines,
+            calculateStats: true,
             preventHandleOutsideImage: false,
             contourHoleAdditionModifierKey: _enums__WEBPACK_IMPORTED_MODULE_5__.KeyboardBindings.Shift,
             snapHandleNearby: 2,
@@ -18279,6 +18286,7 @@ class LivewireContourTool extends _base_ContourSegmentationBaseTool__WEBPACK_IMP
             this.editData = {
                 annotation,
                 viewportIdsToRender,
+                movingTextBox: false,
             };
             const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.getEnabledElement)(element);
             const { renderingEngine } = enabledElement;
@@ -18291,13 +18299,21 @@ class LivewireContourTool extends _base_ContourSegmentationBaseTool__WEBPACK_IMP
             const { element } = eventDetail;
             const { data } = annotation;
             annotation.highlighted = true;
-            const { points } = data.handles;
-            const handleIndex = points.findIndex((p) => p === handle);
+            let movingTextBox = false;
+            let handleIndex;
+            if (handle.worldPosition) {
+                movingTextBox = true;
+            }
+            else {
+                const { points } = data.handles;
+                handleIndex = points.findIndex((p) => p === handle);
+            }
             const viewportIdsToRender = (0,_utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_14__.getViewportIdsWithToolToRender)(element, this.getToolName());
             this.editData = {
                 annotation,
                 viewportIdsToRender,
                 handleIndex,
+                movingTextBox,
             };
             this._activateModify(element);
             const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.getEnabledElement)(element);
@@ -18425,15 +18441,27 @@ class LivewireContourTool extends _base_ContourSegmentationBaseTool__WEBPACK_IMP
             this.isDrawing = true;
             const eventDetail = evt.detail;
             const { element } = eventDetail;
-            const { annotation, viewportIdsToRender, handleIndex } = this.editData;
-            if (handleIndex === undefined) {
-                console.warn('No drag implemented for livewire');
+            const { annotation, viewportIdsToRender, 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) {
+                console.warn('Drag annotation not implemented');
             }
             else {
                 const { currentPoints } = eventDetail;
                 const worldPos = currentPoints.world;
                 this.editHandle(worldPos, element, annotation, handleIndex);
             }
+            this.editData.hasMoved = true;
             const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.getEnabledElement)(element);
             const { renderingEngine } = enabledElement;
             (0,_utilities__WEBPACK_IMPORTED_MODULE_8__.triggerAnnotationRenderForViewportIds)(renderingEngine, viewportIdsToRender);
@@ -18489,6 +18517,104 @@ class LivewireContourTool extends _base_ContourSegmentationBaseTool__WEBPACK_IMP
             element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_5__.Events.MOUSE_DOUBLE_CLICK, this._mouseDownCallback);
             element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_5__.Events.TOUCH_TAP, this._mouseDownCallback);
         };
+        this._calculateCachedStats = (annotation, element) => {
+            if (!this.configuration.calculateStats) {
+                return;
+            }
+            const data = annotation.data;
+            if (!data.contour.closed) {
+                return;
+            }
+            const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.getEnabledElement)(element);
+            const { viewport, renderingEngine } = enabledElement;
+            const { cachedStats } = data;
+            const { polyline: points } = data.contour;
+            const targetIds = Object.keys(cachedStats);
+            for (let i = 0; i < targetIds.length; i++) {
+                const targetId = targetIds[i];
+                const image = this.getTargetIdImage(targetId, renderingEngine);
+                if (!image) {
+                    continue;
+                }
+                const { metadata } = image;
+                const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
+                const canvasPoint = canvasCoordinates[0];
+                const originalWorldPoint = viewport.canvasToWorld(canvasPoint);
+                const deltaXPoint = viewport.canvasToWorld([
+                    canvasPoint[0] + 1,
+                    canvasPoint[1],
+                ]);
+                const deltaYPoint = viewport.canvasToWorld([
+                    canvasPoint[0],
+                    canvasPoint[1] + 1,
+                ]);
+                const deltaInX = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.distance */ .R3.distance(originalWorldPoint, deltaXPoint);
+                const deltaInY = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.distance */ .R3.distance(originalWorldPoint, deltaYPoint);
+                const { imageData } = image;
+                const { scale, areaUnits } = (0,_utilities__WEBPACK_IMPORTED_MODULE_8__.getCalibratedLengthUnitsAndScale)(image, () => {
+                    const { maxX: canvasMaxX, maxY: canvasMaxY, minX: canvasMinX, minY: canvasMinY, } = _utilities__WEBPACK_IMPORTED_MODULE_8__.math.polyline.getAABB(canvasCoordinates);
+                    const topLeftBBWorld = viewport.canvasToWorld([
+                        canvasMinX,
+                        canvasMinY,
+                    ]);
+                    const topLeftBBIndex = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.utilities.transformWorldToIndex(imageData, topLeftBBWorld);
+                    const bottomRightBBWorld = viewport.canvasToWorld([
+                        canvasMaxX,
+                        canvasMaxY,
+                    ]);
+                    const bottomRightBBIndex = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.utilities.transformWorldToIndex(imageData, bottomRightBBWorld);
+                    return [topLeftBBIndex, bottomRightBBIndex];
+                });
+                let area = _utilities__WEBPACK_IMPORTED_MODULE_8__.math.polyline.getArea(canvasCoordinates) / scale / scale;
+                area *= deltaInX * deltaInY;
+                cachedStats[targetId] = {
+                    Modality: metadata.Modality,
+                    area,
+                    areaUnit: areaUnits,
+                };
+            }
+            this.triggerAnnotationModified(annotation, enabledElement, _enums__WEBPACK_IMPORTED_MODULE_5__.ChangeTypes.StatsUpdated);
+            return cachedStats;
+        };
+        this._renderStats = (annotation, viewport, svgDrawingHelper, textboxStyle) => {
+            const data = annotation.data;
+            const targetId = this.getTargetId(viewport);
+            if (!data.contour.closed || !textboxStyle.visibility) {
+                return;
+            }
+            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 = (0,_utilities_drawing__WEBPACK_IMPORTED_MODULE_16__.getTextBoxCoordsCanvas)(canvasCoordinates);
+                data.handles.textBox.worldPosition =
+                    viewport.canvasToWorld(canvasTextBoxCoords);
+            }
+            const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
+            const textBoxUID = 'textBox';
+            const boundingBox = (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_3__.drawLinkedTextBox)(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.triggerAnnotationModified = (annotation, enabledElement, changeType = _enums__WEBPACK_IMPORTED_MODULE_5__.ChangeTypes.StatsUpdated) => {
+            const { viewportId, renderingEngineId } = enabledElement;
+            const eventType = _enums__WEBPACK_IMPORTED_MODULE_5__.Events.ANNOTATION_MODIFIED;
+            const eventDetail = {
+                annotation,
+                viewportId,
+                renderingEngineId,
+                changeType,
+            };
+            (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.triggerEvent)(_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.eventTarget, eventType, eventDetail);
+        };
+        this._throttledCalculateCachedStats = (0,_utilities__WEBPACK_IMPORTED_MODULE_8__.throttle)(this._calculateCachedStats, 100, { trailing: true });
     }
     setupBaseEditData(worldPos, element, annotation, nextPos, contourHoleProcessingEnabled) {
         const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.getEnabledElement)(element);
@@ -18642,6 +18768,7 @@ class LivewireContourTool extends _base_ContourSegmentationBaseTool__WEBPACK_IMP
         editData.currentPath = currentPath;
         annotation.invalidated = true;
         editData.hasMoved = true;
+        editData.closed = true;
     }
     renderAnnotation(enabledElement, svgDrawingHelper) {
         this.updateAnnotation(this.editData?.currentPath);
@@ -18669,8 +18796,9 @@ class LivewireContourTool extends _base_ContourSegmentationBaseTool__WEBPACK_IMP
         this._endCallback(evt, true);
     }
     renderAnnotationInstance(renderContext) {
-        const { annotation, enabledElement, svgDrawingHelper, annotationStyle } = renderContext;
+        const { annotation, enabledElement, svgDrawingHelper, annotationStyle, targetId, } = renderContext;
         const { viewport } = enabledElement;
+        const { element } = viewport;
         const { worldToCanvas } = viewport;
         const { annotationUID, data, highlighted } = annotation;
         const { handles } = data;
@@ -18688,6 +18816,19 @@ class LivewireContourTool extends _base_ContourSegmentationBaseTool__WEBPACK_IMP
             });
         }
         super.renderAnnotationInstance(renderContext);
+        if (!data.cachedStats[targetId] ||
+            data.cachedStats[targetId].areaUnit == null) {
+            data.cachedStats[targetId] = {
+                Modality: null,
+                area: null,
+                areaUnit: null,
+            };
+            this._calculateCachedStats(annotation, element);
+        }
+        else if (annotation.invalidated) {
+            this._throttledCalculateCachedStats(annotation, element);
+        }
+        this._renderStats(annotation, viewport, svgDrawingHelper, annotationStyle.textbox);
         return true;
     }
     updateAnnotation(livewirePath) {
@@ -18712,6 +18853,16 @@ class LivewireContourTool extends _base_ContourSegmentationBaseTool__WEBPACK_IMP
 }
 LivewireContourTool.toolName = 'LivewireContour';
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (LivewireContourTool);
+function defaultGetTextLines(data, targetId) {
+    const cachedVolumeStats = data.cachedStats[targetId];
+    const { area, areaUnit } = cachedVolumeStats;
+    const textLines = [];
+    if (area) {
+        const areaLine = `Area: ${(0,_utilities__WEBPACK_IMPORTED_MODULE_8__.roundNumber)(area)} ${areaUnit}`;
+        textLines.push(areaLine);
+    }
+    return textLines;
+}
 
 
 /***/ }),
@@ -18757,6 +18908,564 @@ PlanarFreehandContourSegmentationTool.toolName =
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (PlanarFreehandContourSegmentationTool);
 
 
+/***/ }),
+
+/***/ 22455:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Z: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12651);
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(72076);
+/* harmony import */ var _utilities_getCalibratedUnits__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(39661);
+/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(42975);
+/* harmony import */ var _utilities_math__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(79390);
+/* harmony import */ var _utilities_planar__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(44037);
+/* harmony import */ var _utilities_throttle__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(90685);
+/* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(46966);
+/* harmony import */ var _utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(66878);
+/* harmony import */ var _planarFreehandROITool_drawLoop__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(75698);
+/* harmony import */ var _planarFreehandROITool_editLoopCommon__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(89026);
+/* harmony import */ var _planarFreehandROITool_closedContourEditLoop__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(58391);
+/* harmony import */ var _planarFreehandROITool_openContourEditLoop__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(21879);
+/* harmony import */ var _planarFreehandROITool_openContourEndEditLoop__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(82571);
+/* harmony import */ var _planarFreehandROITool_renderMethods__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(54435);
+/* harmony import */ var _stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(36705);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(25876);
+/* harmony import */ var _utilities_drawing__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(20724);
+/* harmony import */ var _utilities_math_polyline__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(42744);
+/* harmony import */ var _utilities_pointInShapeCallback__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(31955);
+/* harmony import */ var _utilities_viewport_isViewportPreScaled__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(20752);
+/* harmony import */ var _utilities_getModalityUnit__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(15607);
+/* harmony import */ var _utilities_math_basic__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__(51053);
+/* harmony import */ var _utilities_contours_calculatePerimeter__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__(3042);
+/* harmony import */ var _base_ContourSegmentationBaseTool__WEBPACK_IMPORTED_MODULE_24__ = __webpack_require__(22955);
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_25__ = __webpack_require__(68096);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const { pointCanProjectOnLine } = _utilities_math__WEBPACK_IMPORTED_MODULE_4__.polyline;
+const { EPSILON } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.CONSTANTS;
+const PARALLEL_THRESHOLD = 1 - EPSILON;
+class PlanarFreehandROITool extends _base_ContourSegmentationBaseTool__WEBPACK_IMPORTED_MODULE_24__/* ["default"] */ .Z {
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
+        configuration: {
+            shadow: true,
+            preventHandleOutsideImage: false,
+            contourHoleAdditionModifierKey: _enums__WEBPACK_IMPORTED_MODULE_25__.KeyboardBindings.Shift,
+            alwaysRenderOpenContourHandles: {
+                enabled: false,
+                radius: 2,
+            },
+            allowOpenContours: true,
+            closeContourProximity: 10,
+            checkCanvasEditFallbackProximity: 6,
+            makeClockWise: true,
+            subPixelResolution: 4,
+            smoothing: {
+                smoothOnAdd: false,
+                smoothOnEdit: false,
+                knotsRatioPercentageOnAdd: 40,
+                knotsRatioPercentageOnEdit: 40,
+            },
+            interpolation: {
+                enabled: false,
+                onInterpolationComplete: null,
+            },
+            decimate: {
+                enabled: false,
+                epsilon: 0.1,
+            },
+            displayOnePointAsCrosshairs: false,
+            calculateStats: true,
+            getTextLines: defaultGetTextLines,
+            statsCalculator: _utilities_math_basic__WEBPACK_IMPORTED_MODULE_22__.BasicStatsCalculator,
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this.isDrawing = false;
+        this.isEditingClosed = false;
+        this.isEditingOpen = false;
+        this.addNewAnnotation = (evt) => {
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(element);
+            const { renderingEngine } = enabledElement;
+            const annotation = this.createAnnotation(evt);
+            this.addAnnotation(annotation, element);
+            const viewportIdsToRender = (0,_utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_7__.getViewportIdsWithToolToRender)(element, this.getToolName());
+            this.activateDraw(evt, annotation, viewportIdsToRender);
+            evt.preventDefault();
+            (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .Z)(renderingEngine, viewportIdsToRender);
+            return annotation;
+        };
+        this.handleSelectedCallback = (evt, annotation, handle) => {
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const viewportIdsToRender = (0,_utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_7__.getViewportIdsWithToolToRender)(element, this.getToolName());
+            this.activateOpenContourEndEdit(evt, annotation, viewportIdsToRender, handle);
+        };
+        this.toolSelectedCallback = (evt, annotation) => {
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const viewportIdsToRender = (0,_utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_7__.getViewportIdsWithToolToRender)(element, this.getToolName());
+            if (annotation.data.contour.closed) {
+                this.activateClosedContourEdit(evt, annotation, viewportIdsToRender);
+            }
+            else {
+                this.activateOpenContourEdit(evt, annotation, viewportIdsToRender);
+            }
+            evt.preventDefault();
+        };
+        this.isPointNearTool = (element, annotation, canvasCoords, proximity) => {
+            const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(element);
+            const { viewport } = enabledElement;
+            const { polyline: points } = annotation.data.contour;
+            let previousPoint = viewport.worldToCanvas(points[0]);
+            for (let i = 1; i < points.length; i++) {
+                const p1 = previousPoint;
+                const p2 = viewport.worldToCanvas(points[i]);
+                const canProject = pointCanProjectOnLine(canvasCoords, p1, p2, proximity);
+                if (canProject) {
+                    return true;
+                }
+                previousPoint = p2;
+            }
+            if (!annotation.data.contour.closed) {
+                return false;
+            }
+            const pStart = viewport.worldToCanvas(points[0]);
+            const pEnd = viewport.worldToCanvas(points[points.length - 1]);
+            return pointCanProjectOnLine(canvasCoords, pStart, pEnd, proximity);
+        };
+        this.cancel = (element) => {
+            const isDrawing = this.isDrawing;
+            const isEditingOpen = this.isEditingOpen;
+            const isEditingClosed = this.isEditingClosed;
+            if (isDrawing) {
+                this.cancelDrawing(element);
+            }
+            else if (isEditingOpen) {
+                this.cancelOpenContourEdit(element);
+            }
+            else if (isEditingClosed) {
+                this.cancelClosedContourEdit(element);
+            }
+        };
+        this._calculateCachedStats = (annotation, viewport, renderingEngine, enabledElement) => {
+            const { data } = annotation;
+            const { cachedStats } = data;
+            const { polyline: points, closed } = data.contour;
+            const targetIds = Object.keys(cachedStats);
+            for (let i = 0; i < targetIds.length; i++) {
+                const targetId = targetIds[i];
+                const image = this.getTargetIdImage(targetId, renderingEngine);
+                if (!image) {
+                    continue;
+                }
+                const { imageData, metadata } = image;
+                const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
+                const modalityUnitOptions = {
+                    isPreScaled: (0,_utilities_viewport_isViewportPreScaled__WEBPACK_IMPORTED_MODULE_20__/* .isViewportPreScaled */ .P)(viewport, targetId),
+                    isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
+                };
+                const modalityUnit = (0,_utilities_getModalityUnit__WEBPACK_IMPORTED_MODULE_21__/* .getModalityUnit */ .F)(metadata.Modality, annotation.metadata.referencedImageId, modalityUnitOptions);
+                const calibratedScale = (0,_utilities_getCalibratedUnits__WEBPACK_IMPORTED_MODULE_2__/* .getCalibratedLengthUnitsAndScale */ .mh)(image, () => {
+                    const polyline = data.contour.polyline;
+                    const numPoints = polyline.length;
+                    const projectedPolyline = new Array(numPoints);
+                    for (let i = 0; i < numPoints; i++) {
+                        projectedPolyline[i] = viewport.worldToCanvas(polyline[i]);
+                    }
+                    const { maxX: canvasMaxX, maxY: canvasMaxY, minX: canvasMinX, minY: canvasMinY, } = _utilities__WEBPACK_IMPORTED_MODULE_3__.math.polyline.getAABB(projectedPolyline);
+                    const topLeftBBWorld = viewport.canvasToWorld([canvasMinX, canvasMinY]);
+                    const topLeftBBIndex = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.transformWorldToIndex(imageData, topLeftBBWorld);
+                    const bottomRightBBWorld = viewport.canvasToWorld([
+                        canvasMaxX,
+                        canvasMaxY,
+                    ]);
+                    const bottomRightBBIndex = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.transformWorldToIndex(imageData, bottomRightBBWorld);
+                    return [topLeftBBIndex, bottomRightBBIndex];
+                });
+                if (closed) {
+                    this.updateClosedCachedStats({
+                        targetId,
+                        viewport,
+                        canvasCoordinates,
+                        points,
+                        imageData,
+                        metadata,
+                        cachedStats,
+                        modalityUnit,
+                        calibratedScale,
+                    });
+                }
+                else {
+                    this.updateOpenCachedStats({
+                        metadata,
+                        canvasCoordinates,
+                        targetId,
+                        cachedStats,
+                        modalityUnit,
+                        calibratedScale,
+                    });
+                }
+            }
+            (0,_stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_15__/* .triggerAnnotationModified */ .hg)(annotation, enabledElement.viewport.element, _enums__WEBPACK_IMPORTED_MODULE_25__.ChangeTypes.StatsUpdated);
+            annotation.invalidated = false;
+            return cachedStats;
+        };
+        this._renderStats = (annotation, viewport, enabledElement, svgDrawingHelper) => {
+            const { data } = annotation;
+            const targetId = this.getTargetId(viewport);
+            const styleSpecifier = {
+                toolGroupId: this.toolGroupId,
+                toolName: this.getToolName(),
+                viewportId: enabledElement.viewport.id,
+            };
+            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 = (0,_utilities_drawing__WEBPACK_IMPORTED_MODULE_17__.getTextBoxCoordsCanvas)(canvasCoordinates);
+                data.handles.textBox.worldPosition =
+                    viewport.canvasToWorld(canvasTextBoxCoords);
+            }
+            const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
+            const textBoxUID = '1';
+            const boundingBox = (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_16__.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]),
+            };
+        };
+        (0,_planarFreehandROITool_drawLoop__WEBPACK_IMPORTED_MODULE_9__/* ["default"] */ .Z)(this);
+        (0,_planarFreehandROITool_editLoopCommon__WEBPACK_IMPORTED_MODULE_10__/* ["default"] */ .Z)(this);
+        (0,_planarFreehandROITool_closedContourEditLoop__WEBPACK_IMPORTED_MODULE_11__/* ["default"] */ .Z)(this);
+        (0,_planarFreehandROITool_openContourEditLoop__WEBPACK_IMPORTED_MODULE_12__/* ["default"] */ .Z)(this);
+        (0,_planarFreehandROITool_openContourEndEditLoop__WEBPACK_IMPORTED_MODULE_13__/* ["default"] */ .Z)(this);
+        (0,_planarFreehandROITool_renderMethods__WEBPACK_IMPORTED_MODULE_14__/* ["default"] */ .Z)(this);
+        this._throttledCalculateCachedStats = (0,_utilities_throttle__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .Z)(this._calculateCachedStats, 100, { trailing: true });
+    }
+    filterInteractableAnnotationsForElement(element, annotations) {
+        if (!annotations || !annotations.length) {
+            return;
+        }
+        const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(element);
+        const { viewport } = enabledElement;
+        let annotationsToDisplay;
+        if (viewport instanceof _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.VolumeViewport) {
+            const camera = viewport.getCamera();
+            const { spacingInNormalDirection } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.getTargetVolumeAndSpacingInNormalDir(viewport, camera);
+            annotationsToDisplay = this.filterAnnotationsWithinSlice(annotations, camera, spacingInNormalDirection);
+        }
+        else {
+            annotationsToDisplay = (0,_utilities_planar__WEBPACK_IMPORTED_MODULE_5__.filterAnnotationsForDisplay)(viewport, annotations);
+        }
+        return annotationsToDisplay;
+    }
+    filterAnnotationsWithinSlice(annotations, camera, spacingInNormalDirection) {
+        const { viewPlaneNormal } = camera;
+        const annotationsWithParallelNormals = annotations.filter((td) => {
+            const annotationViewPlaneNormal = td.metadata.viewPlaneNormal;
+            const isParallel = Math.abs(gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.dot */ .R3.dot(viewPlaneNormal, annotationViewPlaneNormal)) >
+                PARALLEL_THRESHOLD;
+            return annotationViewPlaneNormal && isParallel;
+        });
+        if (!annotationsWithParallelNormals.length) {
+            return [];
+        }
+        const halfSpacingInNormalDirection = spacingInNormalDirection / 2;
+        const { focalPoint } = camera;
+        const annotationsWithinSlice = [];
+        for (const annotation of annotationsWithParallelNormals) {
+            const data = annotation.data;
+            const point = data.contour.polyline[0];
+            if (!annotation.isVisible) {
+                continue;
+            }
+            const dir = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.create */ .R3.create();
+            gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.sub */ .R3.sub(dir, focalPoint, point);
+            const dot = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.dot */ .R3.dot(dir, viewPlaneNormal);
+            if (Math.abs(dot) < halfSpacingInNormalDirection) {
+                annotationsWithinSlice.push(annotation);
+            }
+        }
+        return annotationsWithinSlice;
+    }
+    isContourSegmentationTool() {
+        return false;
+    }
+    createAnnotation(evt) {
+        const worldPos = evt.detail.currentPoints.world;
+        const contourAnnotation = super.createAnnotation(evt);
+        const onInterpolationComplete = (annotation) => {
+            annotation.data.handles.points.length = 0;
+        };
+        const annotation = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.deepMerge(contourAnnotation, {
+            data: {
+                contour: {
+                    polyline: [[...worldPos]],
+                },
+                label: '',
+                cachedStats: {},
+            },
+            onInterpolationComplete,
+        });
+        return annotation;
+    }
+    getAnnotationStyle(context) {
+        return super.getAnnotationStyle(context);
+    }
+    renderAnnotationInstance(renderContext) {
+        const { enabledElement, targetId, svgDrawingHelper } = renderContext;
+        const annotation = renderContext.annotation;
+        let renderStatus = false;
+        const { viewport, renderingEngine } = enabledElement;
+        const isDrawing = this.isDrawing;
+        const isEditingOpen = this.isEditingOpen;
+        const isEditingClosed = this.isEditingClosed;
+        if (!(isDrawing || isEditingOpen || isEditingClosed)) {
+            if (this.configuration.displayOnePointAsCrosshairs &&
+                annotation.data.contour.polyline.length === 1) {
+                this.renderPointContourWithMarker(enabledElement, svgDrawingHelper, annotation);
+            }
+            else {
+                this.renderContour(enabledElement, svgDrawingHelper, annotation);
+            }
+        }
+        else {
+            const activeAnnotationUID = this.commonData.annotation.annotationUID;
+            if (annotation.annotationUID === activeAnnotationUID) {
+                if (isDrawing) {
+                    this.renderContourBeingDrawn(enabledElement, svgDrawingHelper, annotation);
+                }
+                else if (isEditingClosed) {
+                    this.renderClosedContourBeingEdited(enabledElement, svgDrawingHelper, annotation);
+                }
+                else if (isEditingOpen) {
+                    this.renderOpenContourBeingEdited(enabledElement, svgDrawingHelper, annotation);
+                }
+                else {
+                    throw new Error(`Unknown ${this.getToolName()} annotation rendering state`);
+                }
+            }
+            else {
+                if (this.configuration.displayOnePointAsCrosshairs &&
+                    annotation.data.contour.polyline.length === 1) {
+                    this.renderPointContourWithMarker(enabledElement, svgDrawingHelper, annotation);
+                }
+                else {
+                    this.renderContour(enabledElement, svgDrawingHelper, annotation);
+                }
+            }
+            renderStatus = true;
+        }
+        if (!this.configuration.calculateStats) {
+            return;
+        }
+        this._calculateStatsIfActive(annotation, targetId, viewport, renderingEngine, enabledElement);
+        this._renderStats(annotation, viewport, enabledElement, svgDrawingHelper);
+        return renderStatus;
+    }
+    _calculateStatsIfActive(annotation, targetId, viewport, renderingEngine, enabledElement) {
+        const activeAnnotationUID = this.commonData?.annotation.annotationUID;
+        if (annotation.annotationUID === activeAnnotationUID &&
+            !this.commonData?.movingTextBox) {
+            return;
+        }
+        if (!this.commonData?.movingTextBox) {
+            const { data } = annotation;
+            if (!data.cachedStats[targetId] ||
+                data.cachedStats[targetId].areaUnit == null) {
+                data.cachedStats[targetId] = {
+                    Modality: null,
+                    area: null,
+                    max: null,
+                    mean: null,
+                    stdDev: null,
+                    areaUnit: null,
+                };
+                this._calculateCachedStats(annotation, viewport, renderingEngine, enabledElement);
+            }
+            else if (annotation.invalidated) {
+                this._throttledCalculateCachedStats(annotation, viewport, renderingEngine, enabledElement);
+            }
+        }
+    }
+    updateClosedCachedStats({ viewport, points, imageData, metadata, cachedStats, targetId, modalityUnit, canvasCoordinates, calibratedScale, }) {
+        const { scale, areaUnits, units } = calibratedScale;
+        const canvasPoint = canvasCoordinates[0];
+        const originalWorldPoint = viewport.canvasToWorld(canvasPoint);
+        const deltaXPoint = viewport.canvasToWorld([
+            canvasPoint[0] + 1,
+            canvasPoint[1],
+        ]);
+        const deltaYPoint = viewport.canvasToWorld([
+            canvasPoint[0],
+            canvasPoint[1] + 1,
+        ]);
+        const deltaInX = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.distance */ .R3.distance(originalWorldPoint, deltaXPoint);
+        const deltaInY = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.distance */ .R3.distance(originalWorldPoint, deltaYPoint);
+        const worldPosIndex = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.transformWorldToIndex(imageData, points[0]);
+        worldPosIndex[0] = Math.floor(worldPosIndex[0]);
+        worldPosIndex[1] = Math.floor(worldPosIndex[1]);
+        worldPosIndex[2] = Math.floor(worldPosIndex[2]);
+        let iMin = worldPosIndex[0];
+        let iMax = worldPosIndex[0];
+        let jMin = worldPosIndex[1];
+        let jMax = worldPosIndex[1];
+        let kMin = worldPosIndex[2];
+        let kMax = worldPosIndex[2];
+        for (let j = 1; j < points.length; j++) {
+            const worldPosIndex = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.transformWorldToIndex(imageData, points[j]);
+            worldPosIndex[0] = Math.floor(worldPosIndex[0]);
+            worldPosIndex[1] = Math.floor(worldPosIndex[1]);
+            worldPosIndex[2] = Math.floor(worldPosIndex[2]);
+            iMin = Math.min(iMin, worldPosIndex[0]);
+            iMax = Math.max(iMax, worldPosIndex[0]);
+            jMin = Math.min(jMin, worldPosIndex[1]);
+            jMax = Math.max(jMax, worldPosIndex[1]);
+            kMin = Math.min(kMin, worldPosIndex[2]);
+            kMax = Math.max(kMax, worldPosIndex[2]);
+        }
+        const worldPosIndex2 = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.transformWorldToIndex(imageData, points[1]);
+        worldPosIndex2[0] = Math.floor(worldPosIndex2[0]);
+        worldPosIndex2[1] = Math.floor(worldPosIndex2[1]);
+        worldPosIndex2[2] = Math.floor(worldPosIndex2[2]);
+        let area = _utilities_math__WEBPACK_IMPORTED_MODULE_4__.polyline.getArea(canvasCoordinates) / scale / scale;
+        area *= deltaInX * deltaInY;
+        const iDelta = 0.01 * (iMax - iMin);
+        const jDelta = 0.01 * (jMax - jMin);
+        const kDelta = 0.01 * (kMax - kMin);
+        iMin = Math.floor(iMin - iDelta);
+        iMax = Math.ceil(iMax + iDelta);
+        jMin = Math.floor(jMin - jDelta);
+        jMax = Math.ceil(jMax + jDelta);
+        kMin = Math.floor(kMin - kDelta);
+        kMax = Math.ceil(kMax + kDelta);
+        const boundsIJK = [
+            [iMin, iMax],
+            [jMin, jMax],
+            [kMin, kMax],
+        ];
+        const worldPosEnd = imageData.indexToWorld([iMax, jMax, kMax]);
+        const canvasPosEnd = viewport.worldToCanvas(worldPosEnd);
+        let curRow = 0;
+        let intersections = [];
+        let intersectionCounter = 0;
+        const pointsInShape = (0,_utilities_pointInShapeCallback__WEBPACK_IMPORTED_MODULE_19__/* ["default"] */ .Z)(imageData, (pointLPS, _pointIJK) => {
+            let result = true;
+            const point = viewport.worldToCanvas(pointLPS);
+            if (point[1] != curRow) {
+                intersectionCounter = 0;
+                curRow = point[1];
+                intersections = (0,_utilities_math_polyline__WEBPACK_IMPORTED_MODULE_18__.getLineSegmentIntersectionsCoordinates)(canvasCoordinates, point, [canvasPosEnd[0], point[1]]);
+                intersections.sort((function (index) {
+                    return function (a, b) {
+                        return a[index] === b[index] ? 0 : a[index] < b[index] ? -1 : 1;
+                    };
+                })(0));
+            }
+            if (intersections.length && point[0] > intersections[0][0]) {
+                intersections.shift();
+                intersectionCounter++;
+            }
+            if (intersectionCounter % 2 === 0) {
+                result = false;
+            }
+            return result;
+        }, this.configuration.statsCalculator.statsCallback, boundsIJK);
+        const stats = this.configuration.statsCalculator.getStatistics();
+        cachedStats[targetId] = {
+            Modality: metadata.Modality,
+            area,
+            perimeter: (0,_utilities_contours_calculatePerimeter__WEBPACK_IMPORTED_MODULE_23__/* ["default"] */ .Z)(canvasCoordinates, closed) / scale,
+            mean: stats.mean?.value,
+            max: stats.max?.value,
+            stdDev: stats.stdDev?.value,
+            statsArray: stats.array,
+            pointsInShape: pointsInShape,
+            areaUnit: areaUnits,
+            modalityUnit,
+            unit: units,
+        };
+    }
+    updateOpenCachedStats({ targetId, metadata, canvasCoordinates, cachedStats, modalityUnit, calibratedScale, }) {
+        const { scale, units } = calibratedScale;
+        cachedStats[targetId] = {
+            Modality: metadata.Modality,
+            length: (0,_utilities_contours_calculatePerimeter__WEBPACK_IMPORTED_MODULE_23__/* ["default"] */ .Z)(canvasCoordinates, false) / scale,
+            modalityUnit,
+            unit: units,
+        };
+    }
+}
+function defaultGetTextLines(data, targetId) {
+    const cachedVolumeStats = data.cachedStats[targetId];
+    const { area, mean, stdDev, length, perimeter, max, isEmptyArea, areaUnit, modalityUnit, unit, } = cachedVolumeStats || {};
+    const textLines = [];
+    if (area) {
+        const areaLine = isEmptyArea
+            ? `Area: Oblique not supported`
+            : `Area: ${(0,_utilities__WEBPACK_IMPORTED_MODULE_3__.roundNumber)(area)} ${areaUnit}`;
+        textLines.push(areaLine);
+    }
+    if (mean) {
+        textLines.push(`Mean: ${(0,_utilities__WEBPACK_IMPORTED_MODULE_3__.roundNumber)(mean)} ${modalityUnit}`);
+    }
+    if (Number.isFinite(max)) {
+        textLines.push(`Max: ${(0,_utilities__WEBPACK_IMPORTED_MODULE_3__.roundNumber)(max)} ${modalityUnit}`);
+    }
+    if (stdDev) {
+        textLines.push(`Std Dev: ${(0,_utilities__WEBPACK_IMPORTED_MODULE_3__.roundNumber)(stdDev)} ${modalityUnit}`);
+    }
+    if (perimeter) {
+        textLines.push(`Perimeter: ${(0,_utilities__WEBPACK_IMPORTED_MODULE_3__.roundNumber)(perimeter)} ${unit}`);
+    }
+    if (length) {
+        textLines.push(`${(0,_utilities__WEBPACK_IMPORTED_MODULE_3__.roundNumber)(length)} ${unit}`);
+    }
+    return textLines;
+}
+PlanarFreehandROITool.toolName = 'PlanarFreehandROI';
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (PlanarFreehandROITool);
+
+
 /***/ }),
 
 /***/ 86479: