@cornerstonejs/tools 3.15.5 → 3.16.0

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

@@ -0,0 +1,752 @@
+import { Events, ChangeTypes } from '../../../enums';
+import { getEnabledElement, utilities, metaData, getEnabledElementByViewportId, } from '@cornerstonejs/core';
+import { AnnotationTool } from '../../base';
+import { addAnnotation, getAnnotations, removeAnnotation, } from '../../../stateManagement/annotation/annotationState';
+import { isAnnotationLocked } from '../../../stateManagement/annotation/annotationLocking';
+import { isAnnotationVisible } from '../../../stateManagement/annotation/annotationVisibility';
+import { triggerAnnotationCompleted, triggerAnnotationModified, } from '../../../stateManagement/annotation/helpers/state';
+import * as lineSegment from '../../../utilities/math/line';
+import { drawHandles as drawHandlesSvg, drawLine as drawLineSvg, drawFan as drawFanSvg, } from '../../../drawingSvg';
+import { state } from '../../../store/state';
+import { getViewportIdsWithToolToRender } from '../../../utilities/viewportFilters';
+import triggerAnnotationRenderForViewportIds from '../../../utilities/triggerAnnotationRenderForViewportIds';
+import { resetElementCursor, hideElementCursor, } from '../../../cursors/elementCursor';
+import { angleFromCenter, calculateInnerFanPercentage, clipInterval, intervalFromPoints, mergeIntervals, subtractIntervals, } from '../../../utilities/math/fan/fanUtils';
+import { calculateFanGeometry } from './utils/fanExtraction';
+const { transformIndexToWorld } = utilities;
+class UltrasoundPleuraBLineTool extends AnnotationTool {
+    static { this.toolName = 'UltrasoundPleuraBLineTool'; }
+    static { this.USPleuraBLineAnnotationType = {
+        BLINE: 'bLine',
+        PLEURA: 'pleura',
+    }; }
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
+        configuration: {
+            preventHandleOutsideImage: false,
+            getTextLines: defaultGetTextLines,
+            center: null,
+            innerRadius: null,
+            outerRadius: null,
+            startAngle: null,
+            endAngle: null,
+            bLineColor: 'rgb(60, 255, 60)',
+            pleuraColor: 'rgb(0, 4, 255)',
+            drawDepthGuide: true,
+            depth_ratio: 0.5,
+            depthGuideColor: 'rgb(0, 255, 255)',
+            depthGuideThickness: 4,
+            depthGuideDashLength: 20,
+            depthGuideDashGap: 16,
+            depthGuideOpacity: 0.2,
+            fanOpacity: 0.1,
+            showFanAnnotations: true,
+            updatePercentageCallback: null,
+            actions: {
+                undo: {
+                    method: 'undo',
+                    bindings: [{ key: 'z' }],
+                },
+                redo: {
+                    method: 'redo',
+                    bindings: [{ key: 'y' }],
+                },
+            },
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this.pleuraAnnotations = [];
+        this.bLineAnnotations = [];
+        this.addNewAnnotation = (evt) => {
+            const eventDetail = evt.detail;
+            const { currentPoints, element } = eventDetail;
+            const worldPos = currentPoints.world;
+            const enabledElement = getEnabledElement(element);
+            const { viewport } = enabledElement;
+            hideElementCursor(element);
+            this.isDrawing = true;
+            const { viewPlaneNormal, viewUp, position: cameraPosition, } = viewport.getCamera();
+            const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
+            const annotation = {
+                highlighted: true,
+                invalidated: true,
+                metadata: {
+                    ...viewport.getViewReference({ points: [worldPos] }),
+                    toolName: this.getToolName(),
+                    referencedImageId,
+                    viewUp,
+                    cameraPosition,
+                },
+                data: {
+                    handles: {
+                        points: [[...worldPos], [...worldPos]],
+                        activeHandleIndex: null,
+                    },
+                    annotationType: this.getActiveAnnotationType(),
+                    label: '',
+                },
+            };
+            addAnnotation(annotation, element);
+            const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName());
+            this.editData = {
+                annotation,
+                viewportIdsToRender,
+                handleIndex: 1,
+                movingTextBox: false,
+                newAnnotation: true,
+                hasMoved: false,
+            };
+            this._activateDraw(element);
+            evt.preventDefault();
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+            return annotation;
+        };
+        this.isPointNearTool = (element, annotation, canvasCoords, proximity) => {
+            const enabledElement = getEnabledElement(element);
+            const { viewport } = enabledElement;
+            const { data } = annotation;
+            const [point1, point2] = data.handles.points;
+            const canvasPoint1 = viewport.worldToCanvas(point1);
+            const canvasPoint2 = viewport.worldToCanvas(point2);
+            const line = {
+                start: {
+                    x: canvasPoint1[0],
+                    y: canvasPoint1[1],
+                },
+                end: {
+                    x: canvasPoint2[0],
+                    y: canvasPoint2[1],
+                },
+            };
+            const distanceToPoint = lineSegment.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) => {
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            annotation.highlighted = true;
+            const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName());
+            this.editData = {
+                annotation,
+                viewportIdsToRender,
+                movingTextBox: false,
+            };
+            this._activateModify(element);
+            hideElementCursor(element);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+            evt.preventDefault();
+        };
+        this._endCallback = (evt) => {
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const { annotation, viewportIdsToRender, newAnnotation, hasMoved } = this.editData;
+            const { data } = annotation;
+            if (newAnnotation && !hasMoved) {
+                return;
+            }
+            data.handles.activeHandleIndex = null;
+            this._deactivateModify(element);
+            this._deactivateDraw(element);
+            resetElementCursor(element);
+            if (this.isHandleOutsideImage &&
+                this.configuration.preventHandleOutsideImage) {
+                removeAnnotation(annotation.annotationUID);
+            }
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+            this.doneEditMemo();
+            if (newAnnotation) {
+                triggerAnnotationCompleted(annotation);
+            }
+            this.editData = null;
+            this.isDrawing = false;
+        };
+        this._dragCallback = (evt) => {
+            this.isDrawing = true;
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const { viewport } = getEnabledElement(element) || {};
+            if (!viewport) {
+                return;
+            }
+            const { annotation, viewportIdsToRender, handleIndex, movingTextBox, newAnnotation, } = this.editData;
+            const { data } = annotation;
+            this.createMemo(element, annotation, { newAnnotation });
+            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;
+                const allPointsInsideShape = points.every((point) => {
+                    const newPoint = [
+                        point[0] + worldPosDelta[0],
+                        point[1] + worldPosDelta[1],
+                        point[2] + worldPosDelta[2],
+                    ];
+                    return this.isInsideFanShape(viewport, newPoint);
+                });
+                if (allPointsInsideShape) {
+                    points.forEach((point) => {
+                        point[0] += worldPosDelta[0];
+                        point[1] += worldPosDelta[1];
+                        point[2] += worldPosDelta[2];
+                    });
+                    annotation.invalidated = true;
+                }
+            }
+            else {
+                const { currentPoints } = eventDetail;
+                const worldPos = currentPoints.world;
+                if (this.isInsideFanShape(viewport, worldPos)) {
+                    data.handles.points[handleIndex] = [...worldPos];
+                    annotation.invalidated = true;
+                }
+            }
+            this.editData.hasMoved = true;
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+            if (annotation.invalidated) {
+                triggerAnnotationModified(annotation, element, ChangeTypes.HandlesUpdated);
+            }
+        };
+        this.cancel = (element) => {
+            if (this.isDrawing) {
+                this.isDrawing = false;
+                this._deactivateDraw(element);
+                this._deactivateModify(element);
+                resetElementCursor(element);
+                const { annotation, viewportIdsToRender, newAnnotation } = this.editData;
+                const { data } = annotation;
+                annotation.highlighted = false;
+                data.handles.activeHandleIndex = null;
+                triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+                if (newAnnotation) {
+                    triggerAnnotationCompleted(annotation);
+                }
+                this.editData = null;
+                return annotation.annotationUID;
+            }
+        };
+        this._activateModify = (element) => {
+            state.isInteractingWithTool = true;
+            element.addEventListener(Events.MOUSE_UP, this._endCallback);
+            element.addEventListener(Events.MOUSE_DRAG, this._dragCallback);
+            element.addEventListener(Events.MOUSE_CLICK, this._endCallback);
+            element.addEventListener(Events.TOUCH_END, this._endCallback);
+            element.addEventListener(Events.TOUCH_DRAG, this._dragCallback);
+            element.addEventListener(Events.TOUCH_TAP, this._endCallback);
+        };
+        this._deactivateModify = (element) => {
+            state.isInteractingWithTool = false;
+            element.removeEventListener(Events.MOUSE_UP, this._endCallback);
+            element.removeEventListener(Events.MOUSE_DRAG, this._dragCallback);
+            element.removeEventListener(Events.MOUSE_CLICK, this._endCallback);
+            element.removeEventListener(Events.TOUCH_END, this._endCallback);
+            element.removeEventListener(Events.TOUCH_DRAG, this._dragCallback);
+            element.removeEventListener(Events.TOUCH_TAP, this._endCallback);
+        };
+        this._activateDraw = (element) => {
+            state.isInteractingWithTool = true;
+            element.addEventListener(Events.MOUSE_UP, this._endCallback);
+            element.addEventListener(Events.MOUSE_DRAG, this._dragCallback);
+            element.addEventListener(Events.MOUSE_MOVE, this._dragCallback);
+            element.addEventListener(Events.MOUSE_CLICK, this._endCallback);
+            element.addEventListener(Events.TOUCH_END, this._endCallback);
+            element.addEventListener(Events.TOUCH_DRAG, this._dragCallback);
+            element.addEventListener(Events.TOUCH_TAP, this._endCallback);
+        };
+        this._deactivateDraw = (element) => {
+            state.isInteractingWithTool = false;
+            element.removeEventListener(Events.MOUSE_UP, this._endCallback);
+            element.removeEventListener(Events.MOUSE_DRAG, this._dragCallback);
+            element.removeEventListener(Events.MOUSE_MOVE, this._dragCallback);
+            element.removeEventListener(Events.MOUSE_CLICK, this._endCallback);
+            element.removeEventListener(Events.TOUCH_END, this._endCallback);
+            element.removeEventListener(Events.TOUCH_DRAG, this._dragCallback);
+            element.removeEventListener(Events.TOUCH_TAP, this._endCallback);
+        };
+        this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
+            let renderStatus = false;
+            const { viewport } = enabledElement;
+            const { element } = viewport;
+            if (!this.getFanShapeGeometryParameters(viewport)) {
+                return;
+            }
+            const { imageData } = viewport.getImageData() || {};
+            if (!imageData) {
+                return renderStatus;
+            }
+            if (this.configuration.drawDepthGuide) {
+                this.drawDepthGuide(svgDrawingHelper, viewport);
+            }
+            let annotations = getAnnotations(this.getToolName(), element);
+            if (!annotations?.length) {
+                return renderStatus;
+            }
+            annotations = this.filterInteractableAnnotationsForElement(element, annotations);
+            if (!annotations?.length) {
+                return renderStatus;
+            }
+            const targetId = this.getTargetId(viewport);
+            const renderingEngine = viewport.getRenderingEngine();
+            const styleSpecifier = {
+                toolGroupId: this.toolGroupId,
+                toolName: this.getToolName(),
+                viewportId: enabledElement.viewport.id,
+            };
+            const fanCenter = viewport.worldToCanvas(transformIndexToWorld(imageData, this.configuration.center));
+            const indexToCanvasRatio = this.getIndexToCanvasRatio(viewport);
+            const innerRadius = this.configuration.innerRadius * indexToCanvasRatio;
+            const outerRadius = this.configuration.outerRadius * indexToCanvasRatio;
+            const currentImageId = viewport.getCurrentImageId();
+            const unMergedPleuraIntervals = annotations
+                .filter((annotation) => annotation.data.annotationType ===
+                UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.PLEURA &&
+                annotation.metadata.referencedImageId === currentImageId)
+                .map((annotation) => {
+                const canvasCoordinates = annotation.data.handles.points.map((p) => viewport.worldToCanvas(p));
+                const interval = intervalFromPoints(fanCenter, canvasCoordinates);
+                return interval;
+            });
+            const mergedPleuraIntervals = mergeIntervals(unMergedPleuraIntervals);
+            const pleuraIntervalsDisplayed = [];
+            const bLineIntervalsDisplayed = [];
+            const drawAnnotation = (annotation) => {
+                const { annotationUID, data } = annotation;
+                const { points, activeHandleIndex } = data.handles;
+                styleSpecifier.annotationUID = annotationUID;
+                const { color, lineWidth, lineDash, shadow } = this.getAnnotationStyle({
+                    annotation,
+                    styleSpecifier,
+                });
+                const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
+                if (!viewport.getRenderingEngine()) {
+                    console.warn('Rendering Engine has been destroyed');
+                    return renderStatus;
+                }
+                let activeHandleCanvasCoords;
+                if (!isAnnotationVisible(annotationUID)) {
+                    return;
+                }
+                if (!isAnnotationLocked(annotationUID) &&
+                    !this.editData &&
+                    activeHandleIndex !== null) {
+                    activeHandleCanvasCoords = [canvasCoordinates[activeHandleIndex]];
+                }
+                if (activeHandleCanvasCoords) {
+                    const handleGroupUID = '0';
+                    drawHandlesSvg(svgDrawingHelper, annotationUID, handleGroupUID, canvasCoordinates, {
+                        color: this.getColorForLineType(annotation),
+                        fill: this.getColorForLineType(annotation),
+                        lineDash,
+                        lineWidth,
+                    });
+                }
+                const dataId = `${annotationUID}-line`;
+                const lineUID = '1';
+                drawLineSvg(svgDrawingHelper, annotationUID, lineUID, canvasCoordinates[0], canvasCoordinates[1], {
+                    color: this.getColorForLineType(annotation),
+                    width: lineWidth,
+                    lineDash,
+                    shadow,
+                }, dataId);
+                if (this.configuration.showFanAnnotations) {
+                    const lineInterval = intervalFromPoints(fanCenter, canvasCoordinates);
+                    let fanNumber = 0;
+                    if (annotation.data.annotationType ===
+                        UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.BLINE) {
+                        const uncoveredIntervals = subtractIntervals(bLineIntervalsDisplayed, lineInterval);
+                        uncoveredIntervals.forEach((interval) => {
+                            const clippedIntervals = clipInterval(interval, mergedPleuraIntervals);
+                            clippedIntervals.forEach((clippedInterval) => {
+                                fanNumber++;
+                                const fanIndex = fanNumber;
+                                const fanDataId = `${annotationUID}-fan-${fanIndex}`;
+                                const fanUID = `2-${fanIndex}`;
+                                drawFanSvg(svgDrawingHelper, annotationUID, fanUID, fanCenter, innerRadius, outerRadius, clippedInterval[0], clippedInterval[1], {
+                                    color: 'transparent',
+                                    fill: this.getColorForLineType(annotation),
+                                    fillOpacity: this.configuration.fanOpacity,
+                                    width: lineWidth,
+                                    lineDash,
+                                    shadow,
+                                }, fanDataId, 10);
+                                bLineIntervalsDisplayed.push(clippedInterval);
+                            });
+                        });
+                    }
+                    else if (annotation.data.annotationType ===
+                        UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.PLEURA) {
+                        const uncoveredIntervals = subtractIntervals(pleuraIntervalsDisplayed, lineInterval);
+                        uncoveredIntervals.forEach((interval, index) => {
+                            fanNumber++;
+                            const fanIndex = fanNumber;
+                            const fanDataId = `${annotationUID}-fan-${fanIndex}`;
+                            const fanUID = `2-${fanIndex}`;
+                            drawFanSvg(svgDrawingHelper, annotationUID, fanUID, fanCenter, innerRadius, outerRadius, interval[0], interval[1], {
+                                color: 'transparent',
+                                fill: this.getColorForLineType(annotation),
+                                fillOpacity: this.configuration.fanOpacity,
+                                width: lineWidth,
+                                lineDash,
+                                shadow,
+                            }, fanDataId, 5);
+                            pleuraIntervalsDisplayed.push(interval);
+                        });
+                    }
+                }
+            };
+            const pleuraAnnotationsToDraw = annotations.filter((annotation) => annotation.data.annotationType ===
+                UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.PLEURA &&
+                annotation.metadata.referencedImageId === currentImageId);
+            pleuraAnnotationsToDraw.forEach((annotation) => {
+                if (!viewport.getRenderingEngine()) {
+                    console.warn('Rendering Engine has been destroyed');
+                    return renderStatus;
+                }
+                drawAnnotation(annotation);
+            });
+            const bLineAnnotationsToDraw = annotations.filter((annotation) => annotation.data.annotationType ===
+                UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.BLINE &&
+                annotation.metadata.referencedImageId === currentImageId);
+            bLineAnnotationsToDraw.forEach((annotation) => {
+                if (!viewport.getRenderingEngine()) {
+                    console.warn('Rendering Engine has been destroyed');
+                    return renderStatus;
+                }
+                drawAnnotation(annotation);
+            });
+            renderStatus = true;
+            if (this.configuration.updatePercentageCallback && viewport) {
+                this.configuration.updatePercentageCallback(this.calculateBLinePleuraPercentage(viewport));
+            }
+            return renderStatus;
+        };
+        this.activeAnnotationType =
+            UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.BLINE;
+    }
+    static filterAnnotations(element, filterFunction = () => true) {
+        const annotations = getAnnotations(UltrasoundPleuraBLineTool.toolName, element);
+        if (!annotations?.length) {
+            return [];
+        }
+        const filteredAnnotations = annotations.filter((annotation) => {
+            const currentImageId = annotation.metadata.referencedImageId;
+            return filterFunction(currentImageId);
+        });
+        return filteredAnnotations;
+    }
+    static countAnnotations(element, filterFunction = () => true) {
+        const annotations = getAnnotations(UltrasoundPleuraBLineTool.toolName, element);
+        const { viewport } = getEnabledElement(element);
+        const imageIds = viewport.getImageIds();
+        const getImageIdIndex = (imageId) => {
+            const index = imageIds.findIndex((id) => id === imageId);
+            if (index === -1) {
+                return 0;
+            }
+            return index;
+        };
+        if (!annotations?.length) {
+            return;
+        }
+        const annotationMapping = new Map();
+        annotations.forEach((annotation) => {
+            const currentImageId = annotation.metadata.referencedImageId;
+            if (!filterFunction(currentImageId)) {
+                return;
+            }
+            const { annotationType } = annotation.data;
+            let counts;
+            if (annotationMapping.has(currentImageId)) {
+                counts = annotationMapping.get(currentImageId);
+            }
+            else {
+                counts = {
+                    frame: getImageIdIndex(currentImageId),
+                    bLine: 0,
+                    pleura: 0,
+                };
+            }
+            if (annotationType ===
+                UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.PLEURA) {
+                counts.pleura++;
+            }
+            else if (annotationType ===
+                UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.BLINE) {
+                counts.bLine++;
+            }
+            annotationMapping.set(currentImageId, counts);
+        });
+        return annotationMapping;
+    }
+    static deleteAnnotations(element, filterFunction = () => false) {
+        const annotations = getAnnotations(UltrasoundPleuraBLineTool.toolName, element);
+        if (!annotations?.length) {
+            return;
+        }
+        annotations.forEach((annotation) => {
+            if (!filterFunction(annotation.metadata.referencedImageId)) {
+                return;
+            }
+            removeAnnotation(annotation.annotationUID);
+        });
+    }
+    setActiveAnnotationType(type) {
+        this.activeAnnotationType = type;
+    }
+    getActiveAnnotationType() {
+        return this.activeAnnotationType;
+    }
+    deleteLastAnnotationType(element, type) {
+        let annotationList;
+        const annotations = getAnnotations(UltrasoundPleuraBLineTool.toolName, element);
+        if (type === UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.PLEURA) {
+            annotationList = annotations.filter((annotation) => annotation.data.annotationType ===
+                UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.PLEURA);
+        }
+        else if (type === UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.BLINE) {
+            annotationList = annotations.filter((annotation) => annotation.data.annotationType ===
+                UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.BLINE);
+        }
+        if (annotationList?.length > 0) {
+            const annotation = annotationList.pop();
+            removeAnnotation(annotation.annotationUID);
+        }
+    }
+    static { this.hydrate = (viewportId, points, options) => {
+        const enabledElement = getEnabledElementByViewportId(viewportId);
+        if (!enabledElement) {
+            return;
+        }
+        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, viewport, } = this.hydrateBase(UltrasoundPleuraBLineTool, enabledElement, points, options);
+        const { toolInstance, ...serializableOptions } = options || {};
+        const annotation = {
+            annotationUID: options?.annotationUID || utilities.uuidv4(),
+            data: {
+                handles: {
+                    points,
+                },
+            },
+            highlighted: false,
+            autoGenerated: false,
+            invalidated: false,
+            isLocked: false,
+            isVisible: true,
+            metadata: {
+                toolName: instance.getToolName(),
+                viewPlaneNormal,
+                FrameOfReferenceUID,
+                referencedImageId,
+                ...serializableOptions,
+            },
+        };
+        addAnnotation(annotation, viewport.element);
+        triggerAnnotationRenderForViewportIds([viewport.id]);
+    }; }
+    handleSelectedCallback(evt, annotation, handle) {
+        const eventDetail = evt.detail;
+        const { element } = eventDetail;
+        const { data } = annotation;
+        annotation.highlighted = true;
+        let movingTextBox = false;
+        let handleIndex;
+        if (handle.worldPosition) {
+            movingTextBox = true;
+        }
+        else {
+            handleIndex = data.handles.points.findIndex((p) => p === handle);
+        }
+        const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName());
+        this.editData = {
+            annotation,
+            viewportIdsToRender,
+            handleIndex,
+            movingTextBox,
+        };
+        this._activateModify(element);
+        hideElementCursor(element);
+        triggerAnnotationRenderForViewportIds(viewportIdsToRender);
+        evt.preventDefault();
+    }
+    isInsideFanShape(viewport, point) {
+        if (!this.getFanShapeGeometryParameters(viewport)) {
+            return false;
+        }
+        const { imageData } = viewport.getImageData() || {};
+        if (imageData) {
+            const fanCenter = viewport.worldToCanvas(imageData.indexToWorld(this.configuration.center));
+            const canvasCoordinates = viewport.worldToCanvas(point);
+            const angle = angleFromCenter(fanCenter, canvasCoordinates);
+            return (angle >= this.configuration.startAngle &&
+                angle <= this.configuration.endAngle);
+        }
+    }
+    updateFanGeometryConfiguration(fanGeometry) {
+        if (!fanGeometry) {
+            return;
+        }
+        if (this.isFanShapeGeometryParametersValid(fanGeometry)) {
+            this.configuration.center = [
+                fanGeometry.center[0],
+                fanGeometry.center[1],
+                0,
+            ];
+        }
+        this.configuration.innerRadius = fanGeometry.innerRadius;
+        this.configuration.outerRadius = fanGeometry.outerRadius;
+        this.configuration.startAngle = fanGeometry.startAngle;
+        this.configuration.endAngle = fanGeometry.endAngle;
+    }
+    deriveFanGeometryFromViewport(viewport) {
+        const imageId = viewport.getCurrentImageId();
+        const { fanGeometry } = calculateFanGeometry(imageId) || {};
+        if (fanGeometry) {
+            this.updateFanGeometryConfiguration(fanGeometry);
+        }
+    }
+    isFanShapeGeometryParametersValid(fanGeometry) {
+        if (!fanGeometry) {
+            fanGeometry = this.configuration;
+        }
+        return (fanGeometry?.center &&
+            fanGeometry?.innerRadius > 0 &&
+            fanGeometry?.outerRadius &&
+            fanGeometry?.startAngle > 0 &&
+            fanGeometry?.startAngle < 360 &&
+            fanGeometry?.endAngle > 0 &&
+            fanGeometry?.endAngle < 360);
+    }
+    getFanShapeGeometryParameters(viewport) {
+        if (this.isFanShapeGeometryParametersValid()) {
+            return true;
+        }
+        if (!this.isFanShapeGeometryParametersValid()) {
+            const imageId = viewport.getCurrentImageId();
+            const fanGeometry = metaData.get('ultrasoundFanShapeGeometry', imageId);
+            this.updateFanGeometryConfiguration(fanGeometry);
+        }
+        if (!this.isFanShapeGeometryParametersValid()) {
+            this.deriveFanGeometryFromViewport(viewport);
+        }
+        return this.isFanShapeGeometryParametersValid();
+    }
+    calculateBLinePleuraPercentage(viewport) {
+        if (!this.getFanShapeGeometryParameters(viewport)) {
+            return;
+        }
+        const { imageData } = viewport.getImageData() || {};
+        if (!imageData) {
+            return;
+        }
+        const { element } = viewport;
+        const fanCenter = viewport.worldToCanvas(imageData.indexToWorld(this.configuration.center));
+        const currentImageId = viewport.getCurrentImageId();
+        const annotations = getAnnotations(this.getToolName(), element) || [];
+        const pleuraIntervals = annotations
+            .filter((annotation) => annotation.data.annotationType ===
+            UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.PLEURA &&
+            annotation.metadata.referencedImageId === currentImageId)
+            .map((annotation) => {
+            const canvasCoordinates = annotation.data.handles.points.map((p) => viewport.worldToCanvas(p));
+            return canvasCoordinates;
+        });
+        const bLineIntervals = annotations
+            .filter((annotation) => annotation.data.annotationType ===
+            UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.BLINE &&
+            annotation.metadata.referencedImageId === currentImageId)
+            .map((annotation) => {
+            const canvasCoordinates = annotation.data.handles.points.map((p) => viewport.worldToCanvas(p));
+            return canvasCoordinates;
+        });
+        return calculateInnerFanPercentage(fanCenter, pleuraIntervals, bLineIntervals);
+    }
+    getColorForLineType(annotation) {
+        const { annotationType } = annotation.data;
+        const { bLineColor, pleuraColor } = this.configuration;
+        if (annotationType ===
+            UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.BLINE) {
+            return bLineColor;
+        }
+        if (annotationType ===
+            UltrasoundPleuraBLineTool.USPleuraBLineAnnotationType.PLEURA) {
+            return pleuraColor;
+        }
+        return bLineColor;
+    }
+    getIndexToCanvasRatio(viewport) {
+        const { imageData } = viewport.getImageData() || {};
+        const v1 = viewport.worldToCanvas(imageData.indexToWorld([1, 0, 0]));
+        const v2 = viewport.worldToCanvas(imageData.indexToWorld([2, 0, 0]));
+        const diffVector = [v2[0] - v1[0], v2[1] - v1[1]];
+        const vectorSize = Math.sqrt(diffVector[0] * diffVector[0] + diffVector[1] * diffVector[1]);
+        return vectorSize;
+    }
+    drawDepthGuide(svgDrawingHelper, viewport) {
+        if (!this.getFanShapeGeometryParameters(viewport)) {
+            return;
+        }
+        const { imageData } = viewport.getImageData() || {};
+        if (!imageData) {
+            return;
+        }
+        const radToDegree = (rad) => (rad * 180) / Math.PI;
+        const degreeToRad = (degree) => (degree * Math.PI) / 180;
+        const indexToCanvas = (point) => {
+            return viewport.worldToCanvas(transformIndexToWorld(imageData, point));
+        };
+        const depth_radius = this.configuration.innerRadius +
+            this.configuration.depth_ratio *
+                (this.configuration.outerRadius - this.configuration.innerRadius);
+        const theta_start = this.configuration.startAngle;
+        const theta_end = this.configuration.endAngle;
+        const theta_range = theta_end - theta_start;
+        const arc_length = degreeToRad(theta_range) * depth_radius;
+        let num_dashes = Math.round(arc_length /
+            (this.configuration.depthGuideDashLength +
+                this.configuration.depthGuideDashGap));
+        if (num_dashes <= 0) {
+            num_dashes = Math.max(15, Math.round(theta_range / 5));
+        }
+        const theta_step = theta_range / num_dashes;
+        for (let i = 0; i < num_dashes; i++) {
+            const theta1 = degreeToRad(theta_start + i * theta_step);
+            const theta2 = degreeToRad(theta_start +
+                i * theta_step +
+                radToDegree(this.configuration.depthGuideDashLength) / depth_radius);
+            const start_point = [
+                this.configuration.center[0] + depth_radius * Math.cos(theta1),
+                this.configuration.center[1] + depth_radius * Math.sin(theta1),
+                0,
+            ];
+            const end_point = [
+                this.configuration.center[0] + depth_radius * Math.cos(theta2),
+                this.configuration.center[1] + depth_radius * Math.sin(theta2),
+                0,
+            ];
+            drawLineSvg(svgDrawingHelper, viewport.id, `depthGuide-${i}`, indexToCanvas(start_point), indexToCanvas(end_point), {
+                color: this.configuration.depthGuideColor,
+                lineWidth: this.configuration.depthGuideThickness,
+                strokeOpacity: this.configuration.depthGuideOpacity,
+            });
+        }
+    }
+    _isInsideVolume(index1, index2, dimensions) {
+        return (utilities.indexWithinDimensions(index1, dimensions) &&
+            utilities.indexWithinDimensions(index2, dimensions));
+    }
+}
+function defaultGetTextLines(data, targetId) {
+    return [''];
+}
+export default UltrasoundPleuraBLineTool;