@cornerstonejs/tools 4.22.13 → 5.0.0

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;
@@ -466,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.js

@@ -1,3 +1,4 @@
+var _a;
 import { AnnotationTool, BaseTool } from '../base';
 import { vec2, vec3 } from 'gl-matrix';
 import { getEnabledElement, VolumeViewport, utilities as csUtils, getEnabledElementByViewportId, EPSILON, } from '@cornerstonejs/core';
@@ -14,6 +15,7 @@ import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters'
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { getPixelValueUnits } from '../../utilities/getPixelValueUnits';
+import { viewportSupportsImageSlices } from '../../utilities/viewportCapabilities';
 import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
 import { getCanvasCircleCorners, getCanvasCircleRadius, } from '../../utilities/math/circle';
 import { getCanvasEllipseCorners, pointInEllipse, } from '../../utilities/math/ellipse';
@@ -22,7 +24,6 @@ import { getStyleProperty } from '../../stateManagement/annotation/config/helper
 import getEllipseWorldCoordinates from '../../utilities/getEllipseWorldCoordinates';
 const { transformWorldToIndex } = csUtils;
 class CircleROITool extends AnnotationTool {
-    static { this.toolName = 'CircleROI'; }
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -394,7 +395,9 @@ class CircleROITool extends AnnotationTool {
                         const { referencedImageId } = annotation.metadata;
                         for (const targetId in data.cachedStats) {
                             if (targetId.startsWith('imageId')) {
-                                const viewports = renderingEngine.getStackViewports();
+                                const viewports = renderingEngine
+                                    .getViewports()
+                                    .filter(viewportSupportsImageSlices);
                                 const invalidatedStack = viewports.find((vp) => {
                                     const referencedImageURI = csUtils.imageIdToURI(referencedImageId);
                                     const hasImageURI = vp.hasImageURI(referencedImageURI);
@@ -500,7 +503,7 @@ class CircleROITool extends AnnotationTool {
                 const { dimensions, imageData, metadata, voxelManager } = image;
                 const handles = points.map((point) => imageData.worldToIndex(point));
                 const calibrate = getCalibratedLengthUnitsAndScale(image, handles);
-                const radius = CircleROITool.calculateLengthInIndex(calibrate, handles.slice(0, 2));
+                const radius = _a.calculateLengthInIndex(calibrate, handles.slice(0, 2));
                 const area = Math.PI * radius * radius;
                 const perimeter = 2 * Math.PI * radius;
                 const isEmptyArea = radius === 0;
@@ -611,50 +614,52 @@ class CircleROITool extends AnnotationTool {
             1.0;
         return inEllipse;
     }
-    static { this.hydrate = (viewportId, points, options) => {
-        const enabledElement = getEnabledElementByViewportId(viewportId);
-        if (!enabledElement) {
-            return;
-        }
-        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, viewport, } = this.hydrateBase(CircleROITool, enabledElement, points, options);
-        const { toolInstance, ...serializableOptions } = options || {};
-        const annotation = {
-            annotationUID: options?.annotationUID || csUtils.uuidv4(),
-            data: {
-                handles: {
-                    points,
-                    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 = CircleROITool;
+CircleROITool.toolName = 'CircleROI';
+CircleROITool.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,
+                textBox: {
+                    hasMoved: false,
+                    worldPosition: [0, 0, 0],
+                    worldBoundingBox: {
+                        topLeft: [0, 0, 0],
+                        topRight: [0, 0, 0],
+                        bottomLeft: [0, 0, 0],
+                        bottomRight: [0, 0, 0],
                     },
-                    activeHandleIndex: null,
                 },
-                label: '',
-                cachedStats: {},
-            },
-            highlighted: false,
-            autoGenerated: false,
-            invalidated: false,
-            isLocked: false,
-            isVisible: true,
-            metadata: {
-                toolName: instance.getToolName(),
-                viewPlaneNormal,
-                FrameOfReferenceUID,
-                referencedImageId,
-                ...serializableOptions,
+                activeHandleIndex: null,
             },
-        };
-        addAnnotation(annotation, viewport.element);
-        triggerAnnotationRenderForViewportIds([viewport.id]);
-    }; }
-}
+            label: '',
+            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]);
+};
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
     const { radius, radiusUnit, area, mean, stdDev, max, min, isEmptyArea, areaUnit, modalityUnit, } = cachedVolumeStats;

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

@@ -17,7 +17,6 @@ import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCur
 import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
 import { getStyleProperty } from '../../stateManagement/annotation/config/helpers';
 class CobbAngleTool extends AnnotationTool {
-    static { this.toolName = 'CobbAngle'; }
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -650,6 +649,7 @@ class CobbAngleTool extends AnnotationTool {
         return cachedStats;
     }
 }
+CobbAngleTool.toolName = 'CobbAngle';
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
     const { angle } = cachedVolumeStats;

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

@@ -5,7 +5,6 @@ import { hideElementCursor } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import ProbeTool from './ProbeTool';
 class DragProbeTool extends ProbeTool {
-    static { this.toolName = 'DragProbe'; }
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -116,6 +115,7 @@ class DragProbeTool extends ProbeTool {
         };
     }
 }
+DragProbeTool.toolName = 'DragProbe';
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
     const { index, value, modalityUnit } = cachedVolumeStats;

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

@@ -13,7 +13,6 @@ import { getCanvasCircleRadius } from '../../utilities/math/circle';
 import { vec3 } from 'gl-matrix';
 const CROSSHAIR_SIZE = 5;
 class ETDRSGridTool extends AnnotationTool {
-    static { this.toolName = 'ETDRSGrid'; }
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -351,4 +350,5 @@ class ETDRSGridTool extends AnnotationTool {
         return distance;
     }
 }
+ETDRSGridTool.toolName = 'ETDRSGrid';
 export default ETDRSGridTool;