@cornerstonejs/tools 5.0.0-beta.1 → 5.0.0

package/dist/esm/tools/WindowLevelTool.d.ts

@@ -19,12 +19,13 @@ declare class WindowLevelTool extends BaseTool {
         lower: any;
         upper: any;
     };
-    getNewRange({ viewport, deltaPointsCanvas, volumeId, lower, upper }: {
+    getNewRange({ viewport, deltaPointsCanvas, volumeId, lower, upper, voiLutFunction, }: {
         viewport: any;
         deltaPointsCanvas: any;
         volumeId: any;
         lower: any;
         upper: any;
+        voiLutFunction: any;
     }): {
         lower: number;
         upper: number;

package/dist/esm/tools/WindowLevelTool.js

@@ -45,7 +45,10 @@ class WindowLevelTool extends BaseTool {
         const { viewport } = enabledElement;
         let volumeId, lower, upper, modality, newRange, viewportsContainingVolumeUID;
         let isPreScaled = false;
-        const properties = viewport.getProperties();
+        const properties = getViewportVOIProperties(viewport);
+        if (!properties?.voiRange) {
+            throw new Error('Viewport is not a valid type');
+        }
         if (viewport instanceof VolumeViewport) {
             volumeId = viewport.getVolumeId();
             viewportsContainingVolumeUID =
@@ -86,12 +89,13 @@ class WindowLevelTool extends BaseTool {
                 volumeId,
                 lower,
                 upper,
+                voiLutFunction: properties.VOILUTFunction,
             });
         }
         if (newRange.lower >= newRange.upper) {
             return;
         }
-        viewport.setProperties({
+        setViewportVOIProperties(viewport, {
             voiRange: newRange,
         });
         viewport.render();
@@ -120,7 +124,7 @@ class WindowLevelTool extends BaseTool {
         upper = isPreScaled ? Math.max(upper, 0.1) : upper;
         return { lower, upper };
     }
-    getNewRange({ viewport, deltaPointsCanvas, volumeId, lower, upper }) {
+    getNewRange({ viewport, deltaPointsCanvas, volumeId, lower, upper, voiLutFunction, }) {
         const multiplier = this._getMultiplierFromDynamicRange(viewport, volumeId) ||
             DEFAULT_MULTIPLIER;
         const wwDelta = deltaPointsCanvas[0] * multiplier;
@@ -129,7 +133,6 @@ class WindowLevelTool extends BaseTool {
         windowWidth += wwDelta;
         windowCenter += wcDelta;
         windowWidth = Math.max(windowWidth, 1);
-        const voiLutFunction = viewport.getProperties().VOILUTFunction;
         return utilities.windowLevel.toLowHighRange(windowWidth, windowCenter, voiLutFunction);
     }
     _getMultiplierFromDynamicRange(viewport, volumeId) {
@@ -206,3 +209,44 @@ class WindowLevelTool extends BaseTool {
 }
 WindowLevelTool.toolName = 'WindowLevel';
 export default WindowLevelTool;
+function getViewportVOIProperties(viewport) {
+    const legacyViewport = viewport;
+    if (typeof legacyViewport.getProperties === 'function') {
+        return legacyViewport.getProperties();
+    }
+    const target = getDataPresentationTarget(viewport);
+    if (!target) {
+        return;
+    }
+    const dataPresentation = target.viewport.getDisplaySetPresentation?.(target.dataId);
+    const defaultVOIRange = target.viewport.getDefaultVOIRange?.(target.dataId);
+    return {
+        ...(dataPresentation || {}),
+        voiRange: dataPresentation?.voiRange ?? defaultVOIRange,
+    };
+}
+function setViewportVOIProperties(viewport, props) {
+    const legacyViewport = viewport;
+    if (typeof legacyViewport.setProperties === 'function') {
+        legacyViewport.setProperties(props);
+        return;
+    }
+    const target = getDataPresentationTarget(viewport);
+    if (!target) {
+        return;
+    }
+    target.viewport.setDisplaySetPresentation?.(target.dataId, props);
+}
+function getDataPresentationTarget(viewport) {
+    const genericViewport = viewport;
+    const dataId = genericViewport.getSourceDataId?.();
+    if (!dataId ||
+        typeof genericViewport.getDisplaySetPresentation !== 'function' ||
+        typeof genericViewport.setDisplaySetPresentation !== 'function') {
+        return;
+    }
+    return {
+        viewport: genericViewport,
+        dataId,
+    };
+}

package/dist/esm/tools/ZoomTool.d.ts

@@ -17,5 +17,13 @@ declare class ZoomTool extends BaseTool {
     _dragPerspectiveProjection: (evt: EventTypes.InteractionEventType, viewport: Types.IStackViewport | Types.IVolumeViewport, camera: Types.ICamera, pinch?: boolean) => void;
     _zoom(evt: EventTypes.MouseWheelEventType): void;
     _panCallback(evt: EventTypes.InteractionEventType): void;
+    _dragViewportZoom(evt: EventTypes.InteractionEventType, viewport: {
+        getZoom(): number;
+        setZoom(...args: unknown[]): void;
+    }): void;
+    _applyViewportZoomDelta(viewport: {
+        getZoom(): number;
+        setZoom(...args: unknown[]): void;
+    }, element: HTMLDivElement, deltaY: number, canvasPoint?: Types.Point2): void;
 }
 export default ZoomTool;

package/dist/esm/tools/ZoomTool.js

@@ -1,6 +1,6 @@
 import { vec3 } from 'gl-matrix';
 import vtkMath from '@kitware/vtk.js/Common/Core/Math';
-import { getConfiguration } from '@cornerstonejs/core';
+import { getConfiguration, viewportHasPan, viewportHasZoom, } from '@cornerstonejs/core';
 import { Enums, getEnabledElement } from '@cornerstonejs/core';
 import { BaseTool } from './base';
 import { Events } from '../enums';
@@ -22,7 +22,11 @@ class ZoomTool extends BaseTool {
             const { element, currentPoints } = eventData;
             const worldPos = currentPoints.world;
             const enabledElement = getEnabledElement(element);
-            const camera = enabledElement.viewport.getCamera();
+            const viewport = enabledElement.viewport;
+            const camera = getLegacyCamera(viewport);
+            if (!hasLegacyCameraPosition(camera)) {
+                return false;
+            }
             const { focalPoint } = camera;
             this.initialMousePosWorld = worldPos;
             let dirVec = vec3.fromValues(focalPoint[0] - worldPos[0], focalPoint[1] - worldPos[1], focalPoint[2] - worldPos[2]);
@@ -145,17 +149,27 @@ class ZoomTool extends BaseTool {
             const { element, currentPoints } = evt.detail;
             const enabledElement = getEnabledElement(element);
             const { viewport } = enabledElement;
-            const camera = viewport.getCamera();
+            const camera = getLegacyCamera(viewport);
             const worldPos = currentPoints.world;
+            if (!hasLegacyCameraPosition(camera)) {
+                if (viewportHasZoom(viewport)) {
+                    this._dragViewportZoom(evt, viewport);
+                    viewport.render();
+                }
+                if (this.configuration.pan) {
+                    this._panCallback(evt);
+                }
+                return;
+            }
             const { focalPoint } = camera;
             this.initialMousePosWorld = worldPos;
             let dirVec = vec3.fromValues(focalPoint[0] - worldPos[0], focalPoint[1] - worldPos[1], focalPoint[2] - worldPos[2]);
             dirVec = vec3.normalize(vec3.create(), dirVec);
             this.dirVec = dirVec;
-            if (camera.parallelProjection) {
+            if (hasLegacyParallelCamera(camera) && camera.parallelProjection) {
                 this._dragParallelProjection(evt, viewport, camera, true);
             }
-            else {
+            else if (hasLegacyPerspectiveCamera(camera)) {
                 this._dragPerspectiveProjection(evt, viewport, camera, true);
             }
             viewport.render();
@@ -168,8 +182,14 @@ class ZoomTool extends BaseTool {
         const { element } = evt.detail;
         const enabledElement = getEnabledElement(element);
         const { viewport } = enabledElement;
-        const camera = viewport.getCamera();
-        if (camera.parallelProjection) {
+        const camera = getLegacyCamera(viewport);
+        if (!hasLegacyParallelCamera(camera)) {
+            if (!viewportHasZoom(viewport)) {
+                return;
+            }
+            this._dragViewportZoom(evt, viewport);
+        }
+        else if (camera.parallelProjection) {
             this._dragParallelProjection(evt, viewport, camera);
         }
         else {
@@ -181,9 +201,20 @@ class ZoomTool extends BaseTool {
         const { element, points } = evt.detail;
         const enabledElement = getEnabledElement(element);
         const { viewport } = enabledElement;
-        const camera = viewport.getCamera();
+        const camera = getLegacyCamera(viewport);
         const wheelData = evt.detail.wheel;
         const direction = wheelData.direction;
+        if (!hasLegacyParallelCamera(camera)) {
+            if (!viewportHasZoom(viewport)) {
+                return;
+            }
+            const canvasPoint = this.configuration.zoomToCenter
+                ? undefined
+                : points.canvas;
+            this._applyViewportZoomDelta(viewport, element, -direction * 5, canvasPoint);
+            viewport.render();
+            return;
+        }
         const eventDetails = {
             detail: {
                 element,
@@ -211,7 +242,20 @@ class ZoomTool extends BaseTool {
         const { element, deltaPoints } = evt.detail;
         const enabledElement = getEnabledElement(element);
         const deltaPointsWorld = deltaPoints.world;
-        const camera = enabledElement.viewport.getCamera();
+        const viewport = enabledElement.viewport;
+        const camera = getLegacyCamera(viewport);
+        if (!hasLegacyCameraPosition(camera)) {
+            if (!viewportHasPan(viewport)) {
+                return;
+            }
+            const pan = viewport.getPan();
+            viewport.setPan([
+                pan[0] + deltaPoints.canvas[0],
+                pan[1] + deltaPoints.canvas[1],
+            ]);
+            viewport.render();
+            return;
+        }
         const { focalPoint, position } = camera;
         const updatedPosition = [
             position[0] - deltaPointsWorld[0],
@@ -223,12 +267,49 @@ class ZoomTool extends BaseTool {
             focalPoint[1] - deltaPointsWorld[1],
             focalPoint[2] - deltaPointsWorld[2],
         ];
-        enabledElement.viewport.setCamera({
+        viewport.setCamera({
             focalPoint: updatedFocalPoint,
             position: updatedPosition,
         });
-        enabledElement.viewport.render();
+        viewport.render();
+    }
+    _dragViewportZoom(evt, viewport) {
+        const { element, deltaPoints, startPoints } = evt.detail;
+        const canvasPoint = this.configuration.zoomToCenter
+            ? undefined
+            : startPoints?.canvas;
+        this._applyViewportZoomDelta(viewport, element, deltaPoints.canvas[1], canvasPoint);
+    }
+    _applyViewportZoomDelta(viewport, element, deltaY, canvasPoint) {
+        const currentZoom = viewport.getZoom();
+        const zoomScale = 5 / Math.max(element.clientHeight, 1);
+        const k = deltaY * zoomScale * (this.configuration.invert ? -1 : 1);
+        const denominator = Math.max(1 - k, 0.01);
+        const unclampedZoom = currentZoom / denominator;
+        const zoom = Math.min(Math.max(unclampedZoom, this.configuration.minZoomScale), this.configuration.maxZoomScale);
+        viewport.setZoom(zoom, canvasPoint);
     }
 }
+function getLegacyCamera(viewport) {
+    const maybeViewport = viewport;
+    return typeof maybeViewport.getCamera === 'function'
+        ? maybeViewport.getCamera()
+        : undefined;
+}
+function hasLegacyCameraPosition(camera) {
+    return Boolean(camera &&
+        Array.isArray(camera.focalPoint) &&
+        Array.isArray(camera.position));
+}
+function hasLegacyParallelCamera(camera) {
+    return Boolean(hasLegacyCameraPosition(camera) &&
+        typeof camera.parallelProjection === 'boolean' &&
+        typeof camera.parallelScale === 'number' &&
+        Array.isArray(camera.viewPlaneNormal));
+}
+function hasLegacyPerspectiveCamera(camera) {
+    return Boolean(hasLegacyCameraPosition(camera) &&
+        Array.isArray(camera.viewPlaneNormal));
+}
 ZoomTool.toolName = 'Zoom';
 export default ZoomTool;

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

@@ -1,3 +1,4 @@
+var _a;
 import { ChangeTypes, Events } from '../../enums';
 import { getEnabledElement, utilities as csUtils, getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import { AnnotationTool } from '../base';
@@ -15,7 +16,6 @@ import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCur
 import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
 import { getStyleProperty } from '../../stateManagement/annotation/config/helpers';
 class AngleTool extends AnnotationTool {
-    static { this.toolName = 'Angle'; }
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -375,36 +375,6 @@ class AngleTool extends AnnotationTool {
         };
         this._throttledCalculateCachedStats = throttle(this._calculateCachedStats, 100, { trailing: true });
     }
-    static { this.hydrate = (viewportId, points, options) => {
-        const enabledElement = getEnabledElementByViewportId(viewportId);
-        if (!enabledElement) {
-            return;
-        }
-        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, viewport, } = this.hydrateBase(AngleTool, enabledElement, points, options);
-        const { toolInstance, ...serializableOptions } = options || {};
-        const annotation = {
-            annotationUID: options?.annotationUID || csUtils.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;
@@ -446,7 +416,11 @@ class AngleTool extends AnnotationTool {
         for (let i = 0; i < targetIds.length; i++) {
             const targetId = targetIds[i];
             const angle = angleBetweenLines([worldPos1, worldPos2], [worldPos2, worldPos3]);
-            const { dimensions, imageData } = this.getTargetImageData(targetId);
+            const image = this.getTargetImageData(targetId);
+            if (!image) {
+                continue;
+            }
+            const { dimensions, imageData } = image;
             this.isHandleOutsideImage = [worldPos1, worldPos2, worldPos3]
                 .map((worldPos) => csUtils.transformWorldToIndex(imageData, worldPos))
                 .some((index) => !csUtils.indexWithinDimensions(index, dimensions));
@@ -462,6 +436,38 @@ class AngleTool extends AnnotationTool {
         return cachedStats;
     }
 }
+_a = AngleTool;
+AngleTool.toolName = 'Angle';
+AngleTool.hydrate = (viewportId, points, options) => {
+    const enabledElement = getEnabledElementByViewportId(viewportId);
+    if (!enabledElement) {
+        return;
+    }
+    const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, viewport, } = _a.hydrateBase(_a, enabledElement, points, options);
+    const { toolInstance, ...serializableOptions } = options || {};
+    const annotation = {
+        annotationUID: options?.annotationUID || csUtils.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]);
+};
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
     const { angle } = cachedVolumeStats;

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

@@ -1,3 +1,4 @@
+var _a;
 import { ChangeTypes, Events } from '../../enums';
 import { getEnabledElement, utilities as csUtils, getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import { AnnotationTool } from '../base';
@@ -14,7 +15,6 @@ import { isAnnotationVisible } from '../../stateManagement/annotation/annotation
 import { setAnnotationLabel } from '../../utilities';
 import { getStyleProperty } from '../../stateManagement/annotation/config/helpers';
 class ArrowAnnotateTool extends AnnotationTool {
-    static { this.toolName = 'ArrowAnnotate'; }
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -345,33 +345,6 @@ class ArrowAnnotateTool extends AnnotationTool {
             return renderStatus;
         };
     }
-    static { this.hydrate = (viewportId, points, label, options) => {
-        const enabledElement = getEnabledElementByViewportId(viewportId);
-        if (!enabledElement) {
-            return;
-        }
-        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, viewport, } = this.hydrateBase(ArrowAnnotateTool, enabledElement, points, options);
-        const { toolInstance, ...serializableOptions } = options || {};
-        const annotation = this.createAnnotation({
-            annotationUID: options?.annotationUID || csUtils.uuidv4(),
-            data: {
-                label: label || '',
-                handles: {
-                    points,
-                },
-            },
-            autoGenerated: false,
-            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;
@@ -410,6 +383,35 @@ class ArrowAnnotateTool extends AnnotationTool {
             csUtils.indexWithinDimensions(index2, dimensions));
     }
 }
+_a = ArrowAnnotateTool;
+ArrowAnnotateTool.toolName = 'ArrowAnnotate';
+ArrowAnnotateTool.hydrate = (viewportId, points, label, options) => {
+    const enabledElement = getEnabledElementByViewportId(viewportId);
+    if (!enabledElement) {
+        return;
+    }
+    const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, viewport, } = _a.hydrateBase(_a, enabledElement, points, options);
+    const { toolInstance, ...serializableOptions } = options || {};
+    const annotation = _a.createAnnotation({
+        annotationUID: options?.annotationUID || csUtils.uuidv4(),
+        data: {
+            label: label || '',
+            handles: {
+                points,
+            },
+        },
+        autoGenerated: false,
+        metadata: {
+            toolName: instance.getToolName(),
+            viewPlaneNormal,
+            FrameOfReferenceUID,
+            referencedImageId,
+            ...serializableOptions,
+        },
+    });
+    addAnnotation(annotation, viewport.element);
+    triggerAnnotationRenderForViewportIds([viewport.id]);
+};
 function getTextCallback(doneChangingTextCallback) {
     return doneChangingTextCallback(prompt('Enter your annotation:'));
 }

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

@@ -1,3 +1,4 @@
+var _a;
 import { vec2, vec3 } from 'gl-matrix';
 import { getEnabledElement, utilities as csUtils, getEnabledElementByViewportId, utilities, } from '@cornerstonejs/core';
 import { getCalibratedLengthUnitsAndScale } from '../../utilities/getCalibratedUnits';
@@ -17,7 +18,6 @@ import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnota
 import { getStyleProperty } from '../../stateManagement/annotation/config/helpers';
 const { transformWorldToIndex } = csUtils;
 class BidirectionalTool extends AnnotationTool {
-    static { this.toolName = 'Bidirectional'; }
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -593,13 +593,13 @@ class BidirectionalTool extends AnnotationTool {
                 const handles1 = handles.slice(0, 2);
                 const handles2 = handles.slice(2, 4);
                 const calibrate = getCalibratedLengthUnitsAndScale(image, handles);
-                const dist1 = BidirectionalTool.calculateLengthInIndex(calibrate, handles1);
-                const dist2 = BidirectionalTool.calculateLengthInIndex(calibrate, handles2);
+                const dist1 = _a.calculateLengthInIndex(calibrate, handles1);
+                const dist2 = _a.calculateLengthInIndex(calibrate, handles2);
                 const { unit } = calibrate;
                 const length = dist1 > dist2 ? dist1 : dist2;
                 const width = dist1 > dist2 ? dist2 : dist1;
                 const widthUnit = unit;
-                this.isHandleOutsideImage = !BidirectionalTool.isInsideVolume(dimensions, handles);
+                this.isHandleOutsideImage = !_a.isInsideVolume(dimensions, handles);
                 cachedStats[targetId] = {
                     length,
                     width,
@@ -660,54 +660,56 @@ class BidirectionalTool extends AnnotationTool {
         triggerAnnotationRenderForViewportIds(viewportIdsToRender);
         return annotation;
     }
-    static { this.hydrate = (viewportId, axis, options) => {
-        const enabledElement = getEnabledElementByViewportId(viewportId);
-        if (!enabledElement) {
-            return;
-        }
-        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, viewport, } = this.hydrateBase(BidirectionalTool, enabledElement, axis[0], options);
-        const [majorAxis, minorAxis] = axis;
-        const [major0, major1] = majorAxis;
-        const [minor0, minor1] = minorAxis;
-        const points = [major0, major1, minor0, minor1];
-        const { toolInstance, ...serializableOptions } = options || {};
-        const annotation = {
-            annotationUID: options?.annotationUID || utilities.uuidv4(),
-            data: {
-                handles: {
-                    points,
-                    activeHandleIndex: null,
-                    textBox: {
-                        hasMoved: false,
-                        worldPosition: [0, 0, 0],
-                        worldBoundingBox: {
-                            topLeft: [0, 0, 0],
-                            topRight: [0, 0, 0],
-                            bottomLeft: [0, 0, 0],
-                            bottomRight: [0, 0, 0],
-                        },
+}
+_a = BidirectionalTool;
+BidirectionalTool.toolName = 'Bidirectional';
+BidirectionalTool.hydrate = (viewportId, axis, options) => {
+    const enabledElement = getEnabledElementByViewportId(viewportId);
+    if (!enabledElement) {
+        return;
+    }
+    const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, viewport, } = _a.hydrateBase(_a, enabledElement, axis[0], options);
+    const [majorAxis, minorAxis] = axis;
+    const [major0, major1] = majorAxis;
+    const [minor0, minor1] = minorAxis;
+    const points = [major0, major1, minor0, minor1];
+    const { toolInstance, ...serializableOptions } = options || {};
+    const annotation = {
+        annotationUID: options?.annotationUID || utilities.uuidv4(),
+        data: {
+            handles: {
+                points,
+                activeHandleIndex: null,
+                textBox: {
+                    hasMoved: false,
+                    worldPosition: [0, 0, 0],
+                    worldBoundingBox: {
+                        topLeft: [0, 0, 0],
+                        topRight: [0, 0, 0],
+                        bottomLeft: [0, 0, 0],
+                        bottomRight: [0, 0, 0],
                     },
                 },
-                cachedStats: {},
             },
-            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]);
-        return annotation;
-    }; }
-}
+            cachedStats: {},
+        },
+        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]);
+    return annotation;
+};
 function defaultGetTextLines(data, targetId) {
     const { cachedStats, label } = data;
     const { length, width, unit } = cachedStats[targetId];

package/dist/esm/tools/annotation/CircleROITool.d.ts

@@ -18,6 +18,7 @@ declare class CircleROITool extends AnnotationTool {
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
     addNewAnnotation: (evt: EventTypes.InteractionEventType) => CircleROIAnnotation;
     isPointNearTool: (element: HTMLDivElement, annotation: CircleROIAnnotation, canvasCoords: Types.Point2, proximity: number) => boolean;
+    _pointInEllipseCanvas(ellipse: any, location: Types.Point2): boolean;
     toolSelectedCallback: (evt: EventTypes.InteractionEventType, annotation: CircleROIAnnotation) => void;
     handleSelectedCallback: (evt: EventTypes.InteractionEventType, annotation: CircleROIAnnotation, handle: ToolHandle) => void;
     _endCallback: (evt: EventTypes.InteractionEventType) => void;