@cornerstonejs/tools 1.43.7 → 1.44.1

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

@@ -0,0 +1,23 @@
+"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 SplineROITool_1 = __importDefault(require("./SplineROITool"));
+class SplineContourSegmentationTool extends SplineROITool_1.default {
+    constructor(toolProps) {
+        const initialProps = core_1.utilities.deepMerge({
+            configuration: {
+                calculateStats: false,
+            },
+        }, toolProps);
+        super(initialProps);
+    }
+    isContourSegmentationTool() {
+        return true;
+    }
+}
+SplineContourSegmentationTool.toolName = 'SplineContourSegmentationTool';
+exports.default = SplineContourSegmentationTool;
+//# sourceMappingURL=SplineContourSegmentationTool.js.map

package/dist/cjs/tools/annotation/SplineContourSegmentationTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SplineContourSegmentationTool.js","sourceRoot":"","sources":["../../../../src/tools/annotation/SplineContourSegmentationTool.ts"],"names":[],"mappings":";;;;;AAAA,8CAAgD;AAEhD,oEAA4C;AAE5C,MAAM,6BAA8B,SAAQ,uBAAa;IAGvD,YAAY,SAA0B;QACpC,MAAM,YAAY,GAAG,gBAAS,CAAC,SAAS,CACtC;YACE,aAAa,EAAE;gBACb,cAAc,EAAE,KAAK;aACtB;SACF,EACD,SAAS,CACV,CAAC;QAEF,KAAK,CAAC,YAAY,CAAC,CAAC;IACtB,CAAC;IAES,yBAAyB;QAEjC,OAAO,IAAI,CAAC;IACd,CAAC;CACF;AAED,6BAA6B,CAAC,QAAQ,GAAG,+BAA+B,CAAC;AACzE,kBAAe,6BAA6B,CAAC"}

package/dist/cjs/tools/annotation/SplineROITool.d.ts

@@ -1,7 +1,7 @@
-import { AnnotationTool } from '../base';
 import type { Types } from '@cornerstonejs/core';
-import { EventTypes, ToolHandle, PublicToolProps, ToolProps, SVGDrawingHelper } from '../../types';
+import { Annotation, EventTypes, ToolHandle, PublicToolProps, ToolProps, SVGDrawingHelper } from '../../types';
 import { SplineROIAnnotation } from '../../types/ToolSpecificAnnotationTypes';
+import ContourSegmentationBaseTool from '../base/ContourSegmentationBaseTool';
 declare enum SplineTypesEnum {
     Cardinal = "CARDINAL",
     Linear = "LINEAR",
@@ -12,7 +12,7 @@ declare enum SplineToolActions {
     AddControlPoint = "addControlPoint",
     DeleteControlPoint = "deleteControlPoint"
 }
-declare class SplineROITool extends AnnotationTool {
+declare class SplineROITool extends ContourSegmentationBaseTool {
     static toolName: any;
     static SplineTypes: typeof SplineTypesEnum;
     static Actions: typeof SplineToolActions;
@@ -31,7 +31,7 @@ declare class SplineROITool extends AnnotationTool {
     isDrawing: boolean;
     isHandleOutsideImage: boolean;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
-    addNewAnnotation: (evt: EventTypes.InteractionEventType) => SplineROIAnnotation;
+    addNewAnnotation(evt: EventTypes.InteractionEventType): SplineROIAnnotation;
     isPointNearTool: (element: HTMLDivElement, annotation: SplineROIAnnotation, canvasCoords: Types.Point2, proximity: number) => boolean;
     toolSelectedCallback: (evt: EventTypes.InteractionEventType, annotation: SplineROIAnnotation) => void;
     handleSelectedCallback: (evt: EventTypes.InteractionEventType, annotation: SplineROIAnnotation, handle: ToolHandle) => void;
@@ -40,19 +40,26 @@ declare class SplineROITool extends AnnotationTool {
     private _mouseMoveCallback;
     private _mouseDownCallback;
     private _dragCallback;
-    cancel: (element: HTMLDivElement) => string;
+    cancel(element: HTMLDivElement): string;
     triggerAnnotationModified: (annotation: SplineROIAnnotation, enabledElement: Types.IEnabledElement) => void;
     private _activateModify;
     private _deactivateModify;
     private _activateDraw;
     private _deactivateDraw;
-    renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
-    _renderStats: (annotation: any, viewport: any, enabledElement: any, svgDrawingHelper: any) => void;
+    protected isContourSegmentationTool(): boolean;
+    protected renderAnnotationInstance(renderContext: {
+        enabledElement: Types.IEnabledElement;
+        targetId: string;
+        annotation: Annotation;
+        annotationStyle: Record<string, any>;
+        svgDrawingHelper: SVGDrawingHelper;
+    }): boolean;
+    protected createAnnotation(evt: EventTypes.InteractionEventType): Annotation;
+    private _renderStats;
     addControlPointCallback: (evt: EventTypes.InteractionEventType, annotation: SplineROIAnnotation) => void;
     private _deleteControlPointByIndex;
     deleteControlPointCallback: (evt: EventTypes.InteractionEventType, annotation: SplineROIAnnotation) => void;
     private _getSplineConfig;
-    private _updateSplineScale;
     private _updateSplineInstance;
     private _calculateCachedStats;
 }

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

@@ -1,11 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const base_1 = require("../base");
 const core_1 = require("@cornerstonejs/core");
+const core_2 = require("@cornerstonejs/core");
 const gl_matrix_1 = require("gl-matrix");
 const annotationState_1 = require("../../stateManagement/annotation/annotationState");
-const annotationLocking_1 = require("../../stateManagement/annotation/annotationLocking");
-const annotationVisibility_1 = require("../../stateManagement/annotation/annotationVisibility");
 const drawingSvg_1 = require("../../drawingSvg");
 const store_1 = require("../../store");
 const enums_1 = require("../../enums");
@@ -17,6 +18,7 @@ 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 = {
@@ -39,7 +41,7 @@ var SplineToolActions;
     SplineToolActions["AddControlPoint"] = "addControlPoint";
     SplineToolActions["DeleteControlPoint"] = "deleteControlPoint";
 })(SplineToolActions || (SplineToolActions = {}));
-class SplineROITool extends base_1.AnnotationTool {
+class SplineROITool extends ContourSegmentationBaseTool_1.default {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -93,70 +95,6 @@ class SplineROITool extends base_1.AnnotationTool {
     }) {
         super(toolProps, defaultToolProps);
         this.isHandleOutsideImage = false;
-        this.addNewAnnotation = (evt) => {
-            const eventDetail = evt.detail;
-            const { currentPoints, element } = eventDetail;
-            const { world: worldPos, canvas: canvasPos } = currentPoints;
-            const enabledElement = (0, core_1.getEnabledElement)(element);
-            const { viewport, renderingEngine } = enabledElement;
-            this.isDrawing = true;
-            const camera = viewport.getCamera();
-            const { viewPlaneNormal, viewUp } = camera;
-            const { type: splineType } = this.configuration.spline;
-            const splineConfig = this._getSplineConfig(splineType);
-            const spline = new splineConfig.Class();
-            const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
-            const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-            const annotation = {
-                highlighted: true,
-                invalidated: true,
-                metadata: {
-                    toolName: this.getToolName(),
-                    viewPlaneNormal: [...viewPlaneNormal],
-                    viewUp: [...viewUp],
-                    FrameOfReferenceUID,
-                    referencedImageId,
-                },
-                data: {
-                    handles: {
-                        textBox: {
-                            hasMoved: false,
-                            worldPosition: [0, 0, 0],
-                            worldBoundingBox: {
-                                topLeft: [0, 0, 0],
-                                topRight: [0, 0, 0],
-                                bottomLeft: [0, 0, 0],
-                                bottomRight: [0, 0, 0],
-                            },
-                        },
-                        points: [[...worldPos]],
-                        activeHandleIndex: null,
-                    },
-                    spline: {
-                        type: splineConfig.type,
-                        instance: spline,
-                        resolution: splineConfig.resolution,
-                        closed: false,
-                        polyline: [],
-                    },
-                    cachedStats: {},
-                },
-            };
-            (0, annotationState_1.addAnnotation)(annotation, element);
-            const viewportIdsToRender = (0, viewportFilters_1.getViewportIdsWithToolToRender)(element, this.getToolName());
-            this.editData = {
-                annotation,
-                viewportIdsToRender,
-                movingTextBox: false,
-                newAnnotation: true,
-                hasMoved: false,
-                lastCanvasPoint: canvasPos,
-            };
-            this._activateDraw(element);
-            evt.preventDefault();
-            (0, utilities_1.triggerAnnotationRenderForViewportIds)(renderingEngine, viewportIdsToRender);
-            return annotation;
-        };
         this.isPointNearTool = (element, annotation, canvasCoords, proximity) => {
             const { instance: spline } = annotation.data.spline;
             return spline.isPointNearCurve(canvasCoords, proximity);
@@ -171,7 +109,7 @@ class SplineROITool extends base_1.AnnotationTool {
                 viewportIdsToRender,
                 movingTextBox: false,
             };
-            const enabledElement = (0, core_1.getEnabledElement)(element);
+            const enabledElement = (0, core_2.getEnabledElement)(element);
             const { renderingEngine } = enabledElement;
             this._activateModify(element);
             (0, utilities_1.triggerAnnotationRenderForViewportIds)(renderingEngine, viewportIdsToRender);
@@ -199,7 +137,7 @@ class SplineROITool extends base_1.AnnotationTool {
                 movingTextBox,
             };
             this._activateModify(element);
-            const enabledElement = (0, core_1.getEnabledElement)(element);
+            const enabledElement = (0, core_2.getEnabledElement)(element);
             const { renderingEngine } = enabledElement;
             (0, utilities_1.triggerAnnotationRenderForViewportIds)(renderingEngine, viewportIdsToRender);
             evt.preventDefault();
@@ -213,7 +151,7 @@ class SplineROITool extends base_1.AnnotationTool {
             this._deactivateModify(element);
             this._deactivateDraw(element);
             (0, elementCursor_1.resetElementCursor)(element);
-            const enabledElement = (0, core_1.getEnabledElement)(element);
+            const enabledElement = (0, core_2.getEnabledElement)(element);
             const { renderingEngine } = enabledElement;
             if (this.isHandleOutsideImage &&
                 this.configuration.preventHandleOutsideImage) {
@@ -225,7 +163,7 @@ class SplineROITool extends base_1.AnnotationTool {
                 const eventDetail = {
                     annotation,
                 };
-                (0, core_1.triggerEvent)(core_1.eventTarget, eventType, eventDetail);
+                (0, core_2.triggerEvent)(core_2.eventTarget, eventType, eventDetail);
             }
             this.editData = null;
             this.isDrawing = false;
@@ -258,7 +196,7 @@ class SplineROITool extends base_1.AnnotationTool {
                 return;
             }
             const { element } = evt.detail;
-            const { renderingEngine } = (0, core_1.getEnabledElement)(element);
+            const { renderingEngine } = (0, core_2.getEnabledElement)(element);
             const viewportIdsToRender = (0, viewportFilters_1.getViewportIdsWithToolToRender)(element, this.getToolName());
             this.editData.lastCanvasPoint = evt.detail.currentPoints.canvas;
             (0, utilities_1.triggerAnnotationRenderForViewportIds)(renderingEngine, viewportIdsToRender);
@@ -268,32 +206,32 @@ class SplineROITool extends base_1.AnnotationTool {
             const doubleClick = evt.type === enums_1.Events.MOUSE_DOUBLE_CLICK;
             const { annotation, viewportIdsToRender } = this.editData;
             const { data } = annotation;
-            if (data.spline.closed) {
+            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 enabledElement = (0, core_2.getEnabledElement)(element);
             const { renderingEngine } = enabledElement;
-            let closeSpline = data.handles.points.length >= 2 && doubleClick;
+            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;
-                    closeSpline = true;
+                    closeContour = true;
                 }
             }
             if (addNewPoint) {
                 data.handles.points.push(worldPoint);
             }
-            data.spline.closed = data.spline.closed || closeSpline;
+            data.contour.closed = data.contour.closed || closeContour;
             annotation.invalidated = true;
             (0, utilities_1.triggerAnnotationRenderForViewportIds)(renderingEngine, viewportIdsToRender);
-            if (data.spline.closed) {
+            if (data.contour.closed) {
                 this._endCallback(evt);
             }
             evt.preventDefault();
@@ -332,27 +270,9 @@ class SplineROITool extends base_1.AnnotationTool {
                 annotation.invalidated = true;
             }
             this.editData.hasMoved = true;
-            const enabledElement = (0, core_1.getEnabledElement)(element);
-            const { renderingEngine } = enabledElement;
-            (0, utilities_1.triggerAnnotationRenderForViewportIds)(renderingEngine, viewportIdsToRender);
-        };
-        this.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);
-            }
-            const enabledElement = (0, core_1.getEnabledElement)(element);
+            const enabledElement = (0, core_2.getEnabledElement)(element);
             const { renderingEngine } = enabledElement;
             (0, utilities_1.triggerAnnotationRenderForViewportIds)(renderingEngine, viewportIdsToRender);
-            this.editData = null;
-            return annotation.annotationUID;
         };
         this.triggerAnnotationModified = (annotation, enabledElement) => {
             const { viewportId, renderingEngineId } = enabledElement;
@@ -362,7 +282,7 @@ class SplineROITool extends base_1.AnnotationTool {
                 viewportId,
                 renderingEngineId,
             };
-            (0, core_1.triggerEvent)(core_1.eventTarget, eventType, eventDetail);
+            (0, core_2.triggerEvent)(core_2.eventTarget, eventType, eventDetail);
         };
         this._activateModify = (element) => {
             store_1.state.isInteractingWithTool = true;
@@ -398,129 +318,11 @@ class SplineROITool extends base_1.AnnotationTool {
             element.removeEventListener(enums_1.Events.MOUSE_DOUBLE_CLICK, this._mouseDownCallback);
             element.removeEventListener(enums_1.Events.TOUCH_TAP, this._mouseDownCallback);
         };
-        this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
-            var _a, _b;
-            let renderStatus = false;
-            const { viewport } = enabledElement;
-            const { worldToCanvas } = viewport;
-            const { element } = viewport;
-            if (!viewport.getRenderingEngine()) {
-                console.warn('Rendering Engine has been destroyed');
-                return renderStatus;
-            }
-            let annotations = (0, annotationState_1.getAnnotations)(this.getToolName(), element);
-            if (!(annotations === null || annotations === void 0 ? void 0 : annotations.length)) {
-                return renderStatus;
-            }
-            annotations = this.filterInteractableAnnotationsForElement(element, annotations);
-            if (!(annotations === null || annotations === void 0 ? void 0 : annotations.length)) {
-                return renderStatus;
-            }
-            const targetId = this.getTargetId(viewport);
-            const newAnnotation = (_a = this.editData) === null || _a === void 0 ? void 0 : _a.newAnnotation;
-            const styleSpecifier = {
-                toolGroupId: this.toolGroupId,
-                toolName: this.getToolName(),
-                viewportId: enabledElement.viewport.id,
-            };
-            for (let i = 0; i < annotations.length; i++) {
-                const annotation = annotations[i];
-                const { annotationUID, data, highlighted } = annotation;
-                const { handles } = data;
-                const { points: controlPoints, activeHandleIndex } = handles;
-                styleSpecifier.annotationUID = annotationUID;
-                const lineWidth = this.getStyle('lineWidth', styleSpecifier, annotation);
-                const lineDash = this.getStyle('lineDash', styleSpecifier, annotation);
-                const color = this.getStyle('color', styleSpecifier, annotation);
-                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 = this._updateSplineInstance(element, annotation);
-                const splinePolylineCanvas = spline.getPolylinePoints();
-                const splinePolylineWorld = [];
-                for (let i = 0, len = splinePolylineCanvas.length; i < len; i++) {
-                    splinePolylineWorld.push(viewport.canvasToWorld(splinePolylineCanvas[i]));
-                }
-                data.spline.polyline = splinePolylineWorld;
-                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 (!(0, annotationVisibility_1.isAnnotationVisible)(annotationUID)) {
-                    continue;
-                }
-                if (!(0, annotationLocking_1.isAnnotationLocked)(annotation) &&
-                    !this.editData &&
-                    activeHandleIndex !== null) {
-                    activeHandleCanvasCoords = [canvasCoordinates[activeHandleIndex]];
-                }
-                if (activeHandleCanvasCoords || newAnnotation || highlighted) {
-                    const handleGroupUID = '0';
-                    (0, drawingSvg_1.drawHandles)(svgDrawingHelper, annotationUID, handleGroupUID, canvasCoordinates, {
-                        color,
-                        lineDash,
-                        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,
-                    });
-                }
-                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)',
-                        lineDash,
-                        lineWidth,
-                    });
-                }
-                (0, drawingSvg_1.drawPolyline)(svgDrawingHelper, annotationUID, 'lineSegments', splinePolylineCanvas, {
-                    color,
-                    lineDash,
-                    lineWidth,
-                });
-                this._renderStats(annotation, viewport, enabledElement, svgDrawingHelper);
-                renderStatus = true;
-                annotation.invalidated = false;
-            }
-            return renderStatus;
-        };
-        this._renderStats = (annotation, viewport, enabledElement, svgDrawingHelper) => {
+        this._renderStats = (annotation, viewport, svgDrawingHelper, textboxStyle) => {
             var _a;
             const data = annotation.data;
             const targetId = this.getTargetId(viewport);
-            if (!data.spline.closed) {
-                return;
-            }
-            const styleSpecifier = {
-                toolGroupId: this.toolGroupId,
-                toolName: this.getToolName(),
-                viewportId: enabledElement.viewport.id,
-            };
-            const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
-            if (!options.visibility) {
+            if (!data.spline.closed || !textboxStyle.visibility) {
                 return;
             }
             const textLines = this.configuration.getTextLines(data, targetId);
@@ -535,7 +337,7 @@ class SplineROITool extends base_1.AnnotationTool {
             }
             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, {}, options);
+            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]),
@@ -554,7 +356,7 @@ class SplineROITool extends base_1.AnnotationTool {
             }
             const eventDetail = evt.detail;
             const { element } = eventDetail;
-            const enabledElement = (0, core_1.getEnabledElement)(element);
+            const enabledElement = (0, core_2.getEnabledElement)(element);
             const { renderingEngine, viewport } = enabledElement;
             const { canvasToWorld } = viewport;
             const { instance: spline } = data.spline;
@@ -591,13 +393,13 @@ class SplineROITool extends base_1.AnnotationTool {
                 return;
             }
             const data = annotation.data;
-            if (!data.spline.closed) {
+            if (!data.contour.closed) {
                 return;
             }
-            const enabledElement = (0, core_1.getEnabledElement)(element);
+            const enabledElement = (0, core_2.getEnabledElement)(element);
             const { viewport, renderingEngine } = enabledElement;
             const { cachedStats } = data;
-            const { polyline: points } = data.spline;
+            const { polyline: points } = data.contour;
             const targetIds = Object.keys(cachedStats);
             for (let i = 0; i < targetIds.length; i++) {
                 const targetId = targetIds[i];
@@ -633,8 +435,147 @@ class SplineROITool extends base_1.AnnotationTool {
         };
         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 enabledElement = (0, core_2.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,
+        };
+        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_2.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;
+        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 = this._updateSplineInstance(element, annotation);
+        const splinePolylineCanvas = spline.getPolylinePoints();
+        const splinePolylineWorld = [];
+        for (let i = 0, len = splinePolylineCanvas.length; i < len; i++) {
+            splinePolylineWorld.push(viewport.canvasToWorld(splinePolylineCanvas[i]));
+        }
+        data.contour.polyline = splinePolylineWorld;
+        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);
+        annotation.invalidated = false;
+        return true;
+    }
+    createAnnotation(evt) {
+        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();
+        return core_1.utilities.deepMerge(contourAnnotation, {
+            data: {
+                handles: {
+                    points: [[...worldPos]],
+                },
+                spline: {
+                    type: splineConfig.type,
+                    instance: spline,
+                    resolution: splineConfig.resolution,
+                },
+                cachedStats: {},
+            },
+        });
+    }
     _deleteControlPointByIndex(element, annotation, controlPointIndex) {
-        const enabledElement = (0, core_1.getEnabledElement)(element);
+        const enabledElement = (0, core_2.getEnabledElement)(element);
         const { points: controlPoints } = annotation.data.handles;
         if (controlPoints.length === 3) {
             (0, annotationState_1.removeAnnotation)(annotation.annotationUID);
@@ -652,21 +593,8 @@ class SplineROITool extends base_1.AnnotationTool {
         const splineConfigs = config.spline.configuration;
         return Object.assign({ type }, DEFAULT_SPLINE_CONFIG, splineConfigs[type]);
     }
-    _updateSplineScale(spline, annotation) {
-        const splineType = annotation.data.spline.type;
-        const splineConfig = this._getSplineConfig(splineType);
-        if (!(spline instanceof CardinalSpline_1.CardinalSpline) ||
-            spline.fixedScale ||
-            splineConfig.scale === undefined ||
-            spline.scale === splineConfig.scale) {
-            return;
-        }
-        spline.scale = splineConfig.scale;
-        annotation.invalidated = true;
-    }
     _updateSplineInstance(element, annotation) {
-        var _a;
-        const enabledElement = (0, core_1.getEnabledElement)(element);
+        const enabledElement = (0, core_2.getEnabledElement)(element);
         const { viewport } = enabledElement;
         const { worldToCanvas } = viewport;
         const { data } = annotation;
@@ -675,7 +603,7 @@ class SplineROITool extends base_1.AnnotationTool {
         const worldPoints = data.handles.points;
         const canvasPoints = worldPoints.map(worldToCanvas);
         spline.setControlPoints(canvasPoints);
-        spline.closed = !!((_a = data.spline) === null || _a === void 0 ? void 0 : _a.closed);
+        spline.closed = !!data.contour.closed;
         if (spline.resolution !== splineConfig.resolution) {
             spline.resolution = parseInt(splineConfig.resolution);
             annotation.invalidated = true;