@cornerstonejs/tools 1.78.1 → 2.0.0-beta.10

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

@@ -1,739 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@cornerstonejs/core");
-const gl_matrix_1 = require("gl-matrix");
-const annotationState_1 = require("../../stateManagement/annotation/annotationState");
-const drawingSvg_1 = require("../../drawingSvg");
-const store_1 = require("../../store");
-const enums_1 = require("../../enums");
-const elementCursor_1 = require("../../cursors/elementCursor");
-const utilities_1 = require("../../utilities");
-const getMouseModifier_1 = __importDefault(require("../../eventDispatchers/shared/getMouseModifier"));
-const viewportFilters_1 = require("../../utilities/viewportFilters");
-const drawing_1 = require("../../utilities/drawing");
-const ContourAnnotation_1 = require("../../types/ContourAnnotation");
-const CardinalSpline_1 = require("./splines/CardinalSpline");
-const LinearSpline_1 = require("./splines/LinearSpline");
-const CatmullRomSpline_1 = require("./splines/CatmullRomSpline");
-const BSpline_1 = require("./splines/BSpline");
-const ContourSegmentationBaseTool_1 = __importDefault(require("../base/ContourSegmentationBaseTool"));
-const SPLINE_MIN_POINTS = 3;
-const SPLINE_CLICK_CLOSE_CURVE_DIST = 10;
-const DEFAULT_SPLINE_CONFIG = {
-    resolution: 20,
-    controlPointAdditionDistance: 6,
-    controlPointDeletionDistance: 6,
-    showControlPointsConnectors: false,
-    controlPointAdditionEnabled: true,
-    controlPointDeletionEnabled: true,
-};
-var SplineTypesEnum;
-(function (SplineTypesEnum) {
-    SplineTypesEnum["Cardinal"] = "CARDINAL";
-    SplineTypesEnum["Linear"] = "LINEAR";
-    SplineTypesEnum["CatmullRom"] = "CATMULLROM";
-    SplineTypesEnum["BSpline"] = "BSPLINE";
-})(SplineTypesEnum || (SplineTypesEnum = {}));
-var SplineToolActions;
-(function (SplineToolActions) {
-    SplineToolActions["AddControlPoint"] = "addControlPoint";
-    SplineToolActions["DeleteControlPoint"] = "deleteControlPoint";
-})(SplineToolActions || (SplineToolActions = {}));
-class SplineROITool extends ContourSegmentationBaseTool_1.default {
-    constructor(toolProps = {}, defaultToolProps = {
-        supportedInteractionTypes: ['Mouse', 'Touch'],
-        configuration: {
-            preventHandleOutsideImage: false,
-            calculateStats: true,
-            getTextLines: defaultGetTextLines,
-            contourHoleAdditionModifierKey: enums_1.KeyboardBindings.Shift,
-            decimate: {
-                enabled: false,
-                epsilon: 0.1,
-            },
-            spline: {
-                configuration: {
-                    [SplineTypesEnum.Cardinal]: {
-                        Class: CardinalSpline_1.CardinalSpline,
-                        scale: 0.5,
-                    },
-                    [SplineTypesEnum.CatmullRom]: {
-                        Class: CatmullRomSpline_1.CatmullRomSpline,
-                    },
-                    [SplineTypesEnum.Linear]: {
-                        Class: LinearSpline_1.LinearSpline,
-                    },
-                    [SplineTypesEnum.BSpline]: {
-                        Class: BSpline_1.BSpline,
-                        controlPointAdditionEnabled: false,
-                        controlPointDeletionEnabled: false,
-                        showControlPointsConnectors: true,
-                    },
-                },
-                type: SplineTypesEnum.CatmullRom,
-                drawPreviewEnabled: true,
-                lastControlPointDeletionKeys: ['Backspace', 'Delete'],
-            },
-            actions: {
-                [SplineToolActions.AddControlPoint]: {
-                    method: 'addControlPointCallback',
-                    bindings: [
-                        {
-                            mouseButton: enums_1.MouseBindings.Primary,
-                            modifierKey: enums_1.KeyboardBindings.Shift,
-                        },
-                    ],
-                },
-                [SplineToolActions.DeleteControlPoint]: {
-                    method: 'deleteControlPointCallback',
-                    bindings: [
-                        {
-                            mouseButton: enums_1.MouseBindings.Primary,
-                            modifierKey: enums_1.KeyboardBindings.Ctrl,
-                        },
-                    ],
-                },
-            },
-        },
-    }) {
-        super(toolProps, defaultToolProps);
-        this.isHandleOutsideImage = false;
-        this.fireChangeOnUpdate = null;
-        this.isPointNearTool = (element, annotation, canvasCoords, proximity) => {
-            const { instance: spline } = annotation.data.spline;
-            return spline.isPointNearCurve(canvasCoords, proximity);
-        };
-        this.toolSelectedCallback = (evt, annotation) => {
-            const eventDetail = evt.detail;
-            const { element } = eventDetail;
-            annotation.highlighted = true;
-            const viewportIdsToRender = (0, viewportFilters_1.getViewportIdsWithToolToRender)(element, this.getToolName());
-            this.editData = {
-                annotation,
-                viewportIdsToRender,
-                movingTextBox: false,
-            };
-            const enabledElement = (0, core_1.getEnabledElement)(element);
-            const { renderingEngine } = enabledElement;
-            this._activateModify(element);
-            (0, utilities_1.triggerAnnotationRenderForViewportIds)(renderingEngine, viewportIdsToRender);
-            evt.preventDefault();
-        };
-        this.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 {
-                const { points } = data.handles;
-                handleIndex = points.findIndex((p) => p === handle);
-            }
-            const viewportIdsToRender = (0, viewportFilters_1.getViewportIdsWithToolToRender)(element, this.getToolName());
-            this.editData = {
-                annotation,
-                viewportIdsToRender,
-                handleIndex,
-                movingTextBox,
-            };
-            this._activateModify(element);
-            const enabledElement = (0, core_1.getEnabledElement)(element);
-            const { renderingEngine } = enabledElement;
-            (0, utilities_1.triggerAnnotationRenderForViewportIds)(renderingEngine, viewportIdsToRender);
-            evt.preventDefault();
-        };
-        this._endCallback = (evt) => {
-            const eventDetail = evt.detail;
-            const { element } = eventDetail;
-            const { annotation, viewportIdsToRender, newAnnotation, contourHoleProcessingEnabled, } = this.editData;
-            const { data } = annotation;
-            annotation.autoGenerated = 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;
-            const image = this.getTargetIdImage(this.getTargetId(enabledElement.viewport), enabledElement.renderingEngine);
-            const { imageData, dimensions } = image;
-            this.isHandleOutsideImage = data.handles.points
-                .map((p) => core_1.utilities.transformWorldToIndex(imageData, p))
-                .some((index) => !core_1.utilities.indexWithinDimensions(index, dimensions));
-            if (this.isHandleOutsideImage &&
-                this.configuration.preventHandleOutsideImage) {
-                (0, annotationState_1.removeAnnotation)(annotation.annotationUID);
-            }
-            const changeType = newAnnotation
-                ? enums_1.ChangeTypes.Completed
-                : enums_1.ChangeTypes.HandlesUpdated;
-            if (!this.fireChangeOnUpdate) {
-                this.fireChangeOnUpdate = {
-                    annotationUID: annotation.annotationUID,
-                    changeType,
-                    contourHoleProcessingEnabled,
-                };
-            }
-            else {
-                this.fireChangeOnUpdate.annotationUID = annotation.annotationUID;
-                this.fireChangeOnUpdate.changeType = changeType;
-            }
-            (0, utilities_1.triggerAnnotationRenderForViewportIds)(renderingEngine, viewportIdsToRender);
-            this.editData = null;
-            this.isDrawing = false;
-        };
-        this._keyDownCallback = (evt) => {
-            var _a;
-            const eventDetail = evt.detail;
-            const { element } = eventDetail;
-            const key = (_a = eventDetail.key) !== null && _a !== void 0 ? _a : '';
-            const { lastControlPointDeletionKeys } = this.configuration.spline;
-            const deleteLastPoint = lastControlPointDeletionKeys.includes(key);
-            if (!deleteLastPoint) {
-                return;
-            }
-            const { annotation } = this.editData;
-            const { data } = annotation;
-            if (data.handles.points.length === SPLINE_MIN_POINTS) {
-                this.cancel(element);
-                return;
-            }
-            else {
-                const controlPointIndex = data.handles.points.length - 1;
-                this._deleteControlPointByIndex(element, annotation, controlPointIndex);
-            }
-            evt.preventDefault();
-        };
-        this._mouseMoveCallback = (evt) => {
-            const { drawPreviewEnabled } = this.configuration.spline;
-            if (!drawPreviewEnabled) {
-                return;
-            }
-            const { element } = evt.detail;
-            const { renderingEngine } = (0, core_1.getEnabledElement)(element);
-            const viewportIdsToRender = (0, viewportFilters_1.getViewportIdsWithToolToRender)(element, this.getToolName());
-            this.editData.lastCanvasPoint = evt.detail.currentPoints.canvas;
-            (0, utilities_1.triggerAnnotationRenderForViewportIds)(renderingEngine, viewportIdsToRender);
-            evt.preventDefault();
-        };
-        this._mouseDownCallback = (evt) => {
-            const doubleClick = evt.type === enums_1.Events.MOUSE_DOUBLE_CLICK;
-            const { annotation, viewportIdsToRender } = this.editData;
-            const { data } = annotation;
-            if (data.contour.closed) {
-                return;
-            }
-            const eventDetail = evt.detail;
-            const { element } = eventDetail;
-            const { currentPoints } = eventDetail;
-            const { canvas: canvasPoint, world: worldPoint } = currentPoints;
-            const enabledElement = (0, core_1.getEnabledElement)(element);
-            const { renderingEngine } = enabledElement;
-            let closeContour = data.handles.points.length >= 2 && doubleClick;
-            let addNewPoint = true;
-            if (data.handles.points.length >= 3) {
-                const { instance: spline } = data.spline;
-                const closestControlPoint = spline.getClosestControlPointWithinDistance(canvasPoint, SPLINE_CLICK_CLOSE_CURVE_DIST);
-                if ((closestControlPoint === null || closestControlPoint === void 0 ? void 0 : closestControlPoint.index) === 0) {
-                    addNewPoint = false;
-                    closeContour = true;
-                }
-            }
-            if (addNewPoint) {
-                data.handles.points.push(worldPoint);
-            }
-            data.contour.closed = data.contour.closed || closeContour;
-            annotation.invalidated = true;
-            (0, utilities_1.triggerAnnotationRenderForViewportIds)(renderingEngine, viewportIdsToRender);
-            if (data.contour.closed) {
-                this._endCallback(evt);
-            }
-            evt.preventDefault();
-        };
-        this._dragCallback = (evt) => {
-            this.isDrawing = true;
-            const eventDetail = evt.detail;
-            const { element } = eventDetail;
-            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) {
-                const { deltaPoints } = eventDetail;
-                const worldPosDelta = deltaPoints.world;
-                this.moveAnnotation(annotation, worldPosDelta);
-            }
-            else {
-                const { currentPoints } = eventDetail;
-                const worldPos = currentPoints.world;
-                data.handles.points[handleIndex] = [...worldPos];
-                annotation.invalidated = true;
-            }
-            this.editData.hasMoved = true;
-            const enabledElement = (0, core_1.getEnabledElement)(element);
-            const { renderingEngine } = enabledElement;
-            (0, utilities_1.triggerAnnotationRenderForViewportIds)(renderingEngine, viewportIdsToRender);
-        };
-        this.triggerAnnotationCompleted = (annotation, contourHoleProcessingEnabled) => {
-            const eventType = enums_1.Events.ANNOTATION_COMPLETED;
-            const eventDetail = {
-                annotation,
-                changeType: enums_1.ChangeTypes.Completed,
-                contourHoleProcessingEnabled,
-            };
-            (0, core_1.triggerEvent)(core_1.eventTarget, eventType, eventDetail);
-        };
-        this.triggerAnnotationModified = (annotation, enabledElement, changeType = enums_1.ChangeTypes.StatsUpdated) => {
-            const { viewportId, renderingEngineId } = enabledElement;
-            const eventType = enums_1.Events.ANNOTATION_MODIFIED;
-            const eventDetail = {
-                annotation,
-                viewportId,
-                renderingEngineId,
-                changeType,
-            };
-            (0, core_1.triggerEvent)(core_1.eventTarget, eventType, eventDetail);
-        };
-        this.triggerChangeEvent = (annotation, enabledElement, changeType = enums_1.ChangeTypes.StatsUpdated, contourHoleProcessingEnabled) => {
-            if (changeType === enums_1.ChangeTypes.Completed) {
-                this.triggerAnnotationCompleted(annotation, contourHoleProcessingEnabled);
-            }
-            else {
-                this.triggerAnnotationModified(annotation, enabledElement, changeType);
-            }
-        };
-        this._activateModify = (element) => {
-            store_1.state.isInteractingWithTool = true;
-            element.addEventListener(enums_1.Events.MOUSE_UP, this._endCallback);
-            element.addEventListener(enums_1.Events.MOUSE_DRAG, this._dragCallback);
-            element.addEventListener(enums_1.Events.MOUSE_CLICK, this._endCallback);
-            element.addEventListener(enums_1.Events.TOUCH_END, this._endCallback);
-            element.addEventListener(enums_1.Events.TOUCH_DRAG, this._dragCallback);
-            element.addEventListener(enums_1.Events.TOUCH_TAP, this._endCallback);
-        };
-        this._deactivateModify = (element) => {
-            store_1.state.isInteractingWithTool = false;
-            element.removeEventListener(enums_1.Events.MOUSE_UP, this._endCallback);
-            element.removeEventListener(enums_1.Events.MOUSE_DRAG, this._dragCallback);
-            element.removeEventListener(enums_1.Events.MOUSE_CLICK, this._endCallback);
-            element.removeEventListener(enums_1.Events.TOUCH_END, this._endCallback);
-            element.removeEventListener(enums_1.Events.TOUCH_DRAG, this._dragCallback);
-            element.removeEventListener(enums_1.Events.TOUCH_TAP, this._endCallback);
-        };
-        this._activateDraw = (element) => {
-            store_1.state.isInteractingWithTool = true;
-            element.addEventListener(enums_1.Events.KEY_DOWN, this._keyDownCallback);
-            element.addEventListener(enums_1.Events.MOUSE_MOVE, this._mouseMoveCallback);
-            element.addEventListener(enums_1.Events.MOUSE_DOWN, this._mouseDownCallback);
-            element.addEventListener(enums_1.Events.MOUSE_DOUBLE_CLICK, this._mouseDownCallback);
-            element.addEventListener(enums_1.Events.TOUCH_TAP, this._mouseDownCallback);
-        };
-        this._deactivateDraw = (element) => {
-            store_1.state.isInteractingWithTool = false;
-            element.removeEventListener(enums_1.Events.KEY_DOWN, this._keyDownCallback);
-            element.removeEventListener(enums_1.Events.MOUSE_MOVE, this._mouseMoveCallback);
-            element.removeEventListener(enums_1.Events.MOUSE_DOWN, this._mouseDownCallback);
-            element.removeEventListener(enums_1.Events.MOUSE_DOUBLE_CLICK, this._mouseDownCallback);
-            element.removeEventListener(enums_1.Events.TOUCH_TAP, this._mouseDownCallback);
-        };
-        this._renderStats = (annotation, viewport, svgDrawingHelper, textboxStyle) => {
-            var _a;
-            const data = annotation.data;
-            const targetId = this.getTargetId(viewport);
-            if (!data.spline.instance.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, drawing_1.getTextBoxCoordsCanvas)(canvasCoordinates);
-                data.handles.textBox.worldPosition =
-                    viewport.canvasToWorld(canvasTextBoxCoords);
-            }
-            const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
-            const textBoxUID = 'textBox';
-            const boundingBox = (0, drawingSvg_1.drawLinkedTextBox)(svgDrawingHelper, (_a = annotation.annotationUID) !== null && _a !== void 0 ? _a : '', 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.addControlPointCallback = (evt, annotation) => {
-            const { data } = annotation;
-            const splineType = data.spline.type;
-            const splineConfig = this._getSplineConfig(splineType);
-            const maxDist = splineConfig.controlPointAdditionDistance;
-            if (splineConfig.controlPointAdditionEnabled === false) {
-                return;
-            }
-            const eventDetail = evt.detail;
-            const { element } = eventDetail;
-            const enabledElement = (0, core_1.getEnabledElement)(element);
-            const { renderingEngine, viewport } = enabledElement;
-            const { canvasToWorld } = viewport;
-            const { instance: spline } = data.spline;
-            const canvasPos = evt.detail.currentPoints.canvas;
-            const closestPointInfo = spline.getClosestPoint(canvasPos);
-            if (closestPointInfo.distance > maxDist) {
-                return;
-            }
-            const { index, point: canvasPoint } = spline.addControlPointAtU(closestPointInfo.uValue);
-            data.handles.points.splice(index, 0, canvasToWorld(canvasPoint));
-            annotation.invalidated = true;
-            const viewportIdsToRender = (0, viewportFilters_1.getViewportIdsWithToolToRender)(element, this.getToolName());
-            (0, utilities_1.triggerAnnotationRenderForViewportIds)(renderingEngine, viewportIdsToRender);
-        };
-        this.deleteControlPointCallback = (evt, annotation) => {
-            const splineType = annotation.data.spline.type;
-            const splineConfig = this._getSplineConfig(splineType);
-            const maxDist = splineConfig.controlPointDeletionDistance;
-            if (splineConfig.controlPointDeletionEnabled === false) {
-                return;
-            }
-            const eventDetail = evt.detail;
-            const { element, currentPoints } = eventDetail;
-            const { canvas: canvasPos } = currentPoints;
-            const { instance: spline } = annotation.data.spline;
-            const closestControlPoint = spline.getClosestControlPointWithinDistance(canvasPos, maxDist);
-            if (!closestControlPoint) {
-                return;
-            }
-            this._deleteControlPointByIndex(element, annotation, closestControlPoint.index);
-        };
-        this._calculateCachedStats = (annotation, element) => {
-            if (!this.configuration.calculateStats) {
-                return;
-            }
-            const data = annotation.data;
-            if (!data.contour.closed) {
-                return;
-            }
-            const enabledElement = (0, core_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_1.vec3.distance(originalWorldPoint, deltaXPoint);
-                const deltaInY = gl_matrix_1.vec3.distance(originalWorldPoint, deltaYPoint);
-                const { imageData } = image;
-                const { scale, areaUnits } = (0, utilities_1.getCalibratedLengthUnitsAndScale)(image, () => {
-                    const { maxX: canvasMaxX, maxY: canvasMaxY, minX: canvasMinX, minY: canvasMinY, } = utilities_1.math.polyline.getAABB(canvasCoordinates);
-                    const topLeftBBWorld = viewport.canvasToWorld([
-                        canvasMinX,
-                        canvasMinY,
-                    ]);
-                    const topLeftBBIndex = core_1.utilities.transformWorldToIndex(imageData, topLeftBBWorld);
-                    const bottomRightBBWorld = viewport.canvasToWorld([
-                        canvasMaxX,
-                        canvasMaxY,
-                    ]);
-                    const bottomRightBBIndex = core_1.utilities.transformWorldToIndex(imageData, bottomRightBBWorld);
-                    return [topLeftBBIndex, bottomRightBBIndex];
-                });
-                let area = utilities_1.math.polyline.getArea(canvasCoordinates) / scale / scale;
-                area *= deltaInX * deltaInY;
-                cachedStats[targetId] = {
-                    Modality: metadata.Modality,
-                    area,
-                    areaUnit: areaUnits,
-                };
-            }
-            this.triggerAnnotationModified(annotation, enabledElement, enums_1.ChangeTypes.StatsUpdated);
-            return cachedStats;
-        };
-        this._throttledCalculateCachedStats = (0, utilities_1.throttle)(this._calculateCachedStats, 100, { trailing: true });
-    }
-    addNewAnnotation(evt) {
-        const eventDetail = evt.detail;
-        const { currentPoints, element } = eventDetail;
-        const { canvas: canvasPos } = currentPoints;
-        const contourHoleProcessingEnabled = (0, getMouseModifier_1.default)(evt.detail.event) ===
-            this.configuration.contourHoleAdditionModifierKey;
-        const enabledElement = (0, core_1.getEnabledElement)(element);
-        const { renderingEngine } = enabledElement;
-        const annotation = this.createAnnotation(evt);
-        this.isDrawing = true;
-        this.addAnnotation(annotation, element);
-        const viewportIdsToRender = (0, viewportFilters_1.getViewportIdsWithToolToRender)(element, this.getToolName());
-        this.editData = {
-            annotation,
-            viewportIdsToRender,
-            movingTextBox: false,
-            newAnnotation: true,
-            hasMoved: false,
-            lastCanvasPoint: canvasPos,
-            contourHoleProcessingEnabled,
-        };
-        this._activateDraw(element);
-        evt.preventDefault();
-        (0, utilities_1.triggerAnnotationRenderForViewportIds)(renderingEngine, viewportIdsToRender);
-        return annotation;
-    }
-    cancel(element) {
-        if (!this.isDrawing) {
-            return;
-        }
-        this.isDrawing = false;
-        this._deactivateDraw(element);
-        this._deactivateModify(element);
-        (0, elementCursor_1.resetElementCursor)(element);
-        const { annotation, viewportIdsToRender, newAnnotation } = this.editData;
-        if (newAnnotation) {
-            (0, annotationState_1.removeAnnotation)(annotation.annotationUID);
-        }
-        super.cancelAnnotation(annotation);
-        const enabledElement = (0, core_1.getEnabledElement)(element);
-        const { renderingEngine } = enabledElement;
-        (0, utilities_1.triggerAnnotationRenderForViewportIds)(renderingEngine, viewportIdsToRender);
-        this.editData = null;
-        return annotation.annotationUID;
-    }
-    isContourSegmentationTool() {
-        return false;
-    }
-    renderAnnotationInstance(renderContext) {
-        var _a, _b, _c;
-        const { enabledElement, targetId, svgDrawingHelper, annotationStyle } = renderContext;
-        const { viewport } = enabledElement;
-        const { worldToCanvas } = viewport;
-        const { element } = viewport;
-        const annotation = renderContext.annotation;
-        const { annotationUID, data, highlighted } = annotation;
-        const { handles } = data;
-        const { points: controlPoints, activeHandleIndex } = handles;
-        const newAnnotation = (_a = this.editData) === null || _a === void 0 ? void 0 : _a.newAnnotation;
-        const { lineWidth, lineDash, color, locked: annotationLocked, } = annotationStyle;
-        const canvasCoordinates = controlPoints.map((p) => worldToCanvas(p));
-        const { drawPreviewEnabled } = this.configuration.spline;
-        const splineType = annotation.data.spline.type;
-        const splineConfig = this._getSplineConfig(splineType);
-        const spline = annotation.data.spline.instance;
-        const childAnnotations = (0, annotationState_1.getChildAnnotations)(annotation);
-        const missingAnnotation = childAnnotations.findIndex((it) => !it);
-        if (missingAnnotation !== -1) {
-            throw new Error(`Can't find annotation for child ${annotation.childAnnotationUIDs.join()}`);
-        }
-        const splineAnnotationsGroup = [annotation, ...childAnnotations].filter((annotation) => this._isSplineROIAnnotation(annotation));
-        splineAnnotationsGroup.forEach((annotation) => {
-            const spline = this._updateSplineInstance(element, annotation);
-            const splinePolylineCanvas = spline.getPolylinePoints();
-            this.updateContourPolyline(annotation, {
-                points: splinePolylineCanvas,
-                closed: data.contour.closed,
-                targetWindingDirection: ContourAnnotation_1.ContourWindingDirection.Clockwise,
-            }, viewport);
-        });
-        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);
-        }
-        let activeHandleCanvasCoords;
-        if (!annotationLocked && !this.editData && activeHandleIndex !== null) {
-            activeHandleCanvasCoords = [canvasCoordinates[activeHandleIndex]];
-        }
-        if (activeHandleCanvasCoords || newAnnotation || highlighted) {
-            const handleGroupUID = '0';
-            (0, drawingSvg_1.drawHandles)(svgDrawingHelper, annotationUID, handleGroupUID, canvasCoordinates, {
-                color,
-                lineWidth: Math.max(1, lineWidth),
-                handleRadius: '3',
-            });
-        }
-        if (drawPreviewEnabled &&
-            spline.numControlPoints > 1 &&
-            ((_b = this.editData) === null || _b === void 0 ? void 0 : _b.lastCanvasPoint) &&
-            !spline.closed) {
-            const { lastCanvasPoint } = this.editData;
-            const previewPolylinePoints = spline.getPreviewPolylinePoints(lastCanvasPoint, SPLINE_CLICK_CLOSE_CURVE_DIST);
-            (0, drawingSvg_1.drawPolyline)(svgDrawingHelper, annotationUID, 'previewSplineChange', previewPolylinePoints, {
-                color: '#9EA0CA',
-                lineDash,
-                lineWidth: 1,
-            });
-        }
-        if (splineConfig.showControlPointsConnectors) {
-            const controlPointsConnectors = [...canvasCoordinates];
-            if (spline.closed) {
-                controlPointsConnectors.push(canvasCoordinates[0]);
-            }
-            (0, drawingSvg_1.drawPolyline)(svgDrawingHelper, annotationUID, 'controlPointsConnectors', controlPointsConnectors, {
-                color: 'rgba(255, 255, 255, 0.5)',
-                lineWidth: 1,
-            });
-        }
-        this._renderStats(annotation, viewport, svgDrawingHelper, annotationStyle.textbox);
-        if (((_c = this.fireChangeOnUpdate) === null || _c === void 0 ? void 0 : _c.annotationUID) === annotationUID) {
-            this.triggerChangeEvent(annotation, enabledElement, this.fireChangeOnUpdate.changeType, this.fireChangeOnUpdate.contourHoleProcessingEnabled);
-            this.fireChangeOnUpdate = null;
-        }
-        annotation.invalidated = false;
-        return true;
-    }
-    createInterpolatedSplineControl(annotation) {
-        var _a;
-        if ((_a = annotation.data.handles.points) === null || _a === void 0 ? void 0 : _a.length) {
-            return;
-        }
-        const { polyline } = annotation.data.contour;
-        if (!polyline || !polyline.length) {
-            return;
-        }
-        annotation.data.handles.points = [];
-        const { points } = annotation.data.handles;
-        const increment = Math.max(10, Math.floor(polyline.length / 20));
-        for (let i = 0; i < polyline.length - increment; i += increment) {
-            points.push(polyline[i]);
-        }
-        points.push(polyline[polyline.length - 1]);
-    }
-    createAnnotation(evt) {
-        var _a;
-        const contourAnnotation = super.createAnnotation(evt);
-        const { world: worldPos } = evt.detail.currentPoints;
-        const { type: splineType } = this.configuration.spline;
-        const splineConfig = this._getSplineConfig(splineType);
-        const spline = new splineConfig.Class();
-        const createSpline = () => ({
-            type: splineConfig.type,
-            instance: spline,
-            resolution: splineConfig.resolution,
-        });
-        let onInterpolationComplete;
-        if ((_a = this.configuration.interpolation) === null || _a === void 0 ? void 0 : _a.enabled) {
-            onInterpolationComplete = (annotation) => {
-                var _a;
-                (_a = annotation.data).spline || (_a.spline = createSpline());
-                this.createInterpolatedSplineControl(annotation);
-            };
-        }
-        return core_1.utilities.deepMerge(contourAnnotation, {
-            data: {
-                handles: {
-                    points: [[...worldPos]],
-                },
-                spline: createSpline(),
-                cachedStats: {},
-            },
-            onInterpolationComplete,
-        });
-    }
-    _deleteControlPointByIndex(element, annotation, controlPointIndex) {
-        const enabledElement = (0, core_1.getEnabledElement)(element);
-        const { points: controlPoints } = annotation.data.handles;
-        if (controlPoints.length === 3) {
-            (0, annotationState_1.removeAnnotation)(annotation.annotationUID);
-        }
-        else {
-            controlPoints.splice(controlPointIndex, 1);
-        }
-        const { renderingEngine } = enabledElement;
-        const viewportIdsToRender = (0, viewportFilters_1.getViewportIdsWithToolToRender)(element, this.getToolName());
-        annotation.invalidated = true;
-        (0, utilities_1.triggerAnnotationRenderForViewportIds)(renderingEngine, viewportIdsToRender);
-    }
-    _isSplineROIAnnotation(annotation) {
-        var _a;
-        return !!((_a = annotation.data) === null || _a === void 0 ? void 0 : _a.spline);
-    }
-    _getSplineConfig(type) {
-        const { configuration: config } = this;
-        const splineConfigs = config.spline.configuration;
-        return Object.assign({ type }, DEFAULT_SPLINE_CONFIG, splineConfigs[type]);
-    }
-    _updateSplineInstance(element, annotation) {
-        const enabledElement = (0, core_1.getEnabledElement)(element);
-        const { viewport } = enabledElement;
-        const { worldToCanvas } = viewport;
-        const { data } = annotation;
-        const { type: splineType, instance: spline } = annotation.data.spline;
-        const splineConfig = this._getSplineConfig(splineType);
-        const worldPoints = data.handles.points;
-        const canvasPoints = worldPoints.map(worldToCanvas);
-        const resolution = splineConfig.resolution !== undefined
-            ? parseInt(splineConfig.resolution)
-            : undefined;
-        const scale = splineConfig.scale !== undefined
-            ? parseFloat(splineConfig.scale)
-            : undefined;
-        spline.setControlPoints(canvasPoints);
-        spline.closed = !!data.contour.closed;
-        if (!spline.fixedResolution &&
-            resolution !== undefined &&
-            spline.resolution !== resolution) {
-            spline.resolution = resolution;
-            annotation.invalidated = true;
-        }
-        if (spline instanceof CardinalSpline_1.CardinalSpline &&
-            !spline.fixedScale &&
-            scale !== undefined &&
-            spline.scale !== scale) {
-            spline.scale = scale;
-            annotation.invalidated = true;
-        }
-        return spline;
-    }
-}
-SplineROITool.SplineTypes = SplineTypesEnum;
-SplineROITool.Actions = SplineToolActions;
-function defaultGetTextLines(data, targetId) {
-    const cachedVolumeStats = data.cachedStats[targetId];
-    const { area, isEmptyArea, areaUnit } = cachedVolumeStats;
-    const textLines = [];
-    if (area) {
-        const areaLine = isEmptyArea
-            ? `Area: Oblique not supported`
-            : `Area: ${(0, utilities_1.roundNumber)(area)} ${areaUnit}`;
-        textLines.push(areaLine);
-    }
-    return textLines;
-}
-SplineROITool.toolName = 'SplineROI';
-exports.default = SplineROITool;
-//# sourceMappingURL=SplineROITool.js.map