@cornerstonejs/tools 5.0.0-beta.1 → 5.0.0

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';
@@ -7,21 +8,22 @@ import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateMan
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
 import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
 import { triggerAnnotationCompleted, triggerAnnotationModified, } from '../../stateManagement/annotation/helpers/state';
-import { drawCircle as drawCircleSvg, drawHandles as drawHandlesSvg, } from '../../drawingSvg';
+import { drawCircle as drawCircleSvg, drawHandles as drawHandlesSvg, drawEllipseByCoordinates, } from '../../drawingSvg';
 import { state } from '../../store/state';
 import { ChangeTypes, Events, MeasurementType } from '../../enums';
 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 { pointInEllipse } from '../../utilities/math/ellipse';
+import { getCanvasEllipseCorners, pointInEllipse, } from '../../utilities/math/ellipse';
 import { BasicStatsCalculator } from '../../utilities/math/basic';
 import { getStyleProperty } from '../../stateManagement/annotation/config/helpers';
+import getEllipseWorldCoordinates from '../../utilities/getEllipseWorldCoordinates';
 const { transformWorldToIndex } = csUtils;
 class CircleROITool extends AnnotationTool {
-    static { this.toolName = 'CircleROI'; }
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -74,11 +76,28 @@ class CircleROITool extends AnnotationTool {
             const enabledElement = getEnabledElement(element);
             const { viewport } = enabledElement;
             const { points } = annotation.data.handles;
-            const canvasHandles = points.map((p) => viewport.worldToCanvas(p));
-            const canvasCenter = canvasHandles[0];
-            const radius = getCanvasCircleRadius([canvasCenter, canvasHandles[1]]);
-            const radiusPoint = getCanvasCircleRadius([canvasCenter, canvasCoords]);
-            return Math.abs(radiusPoint - radius) < proximity / 2;
+            const ellipseWorldCoordinates = getEllipseWorldCoordinates(points.slice(0, 2), viewport);
+            const ellipseCanvasCoordinates = ellipseWorldCoordinates.map((p) => viewport.worldToCanvas(p));
+            const canvasCorners = getCanvasEllipseCorners(ellipseCanvasCoordinates);
+            const [canvasPoint1, canvasPoint2] = canvasCorners;
+            const minorEllipse = {
+                left: Math.min(canvasPoint1[0], canvasPoint2[0]) + proximity / 2,
+                top: Math.min(canvasPoint1[1], canvasPoint2[1]) + proximity / 2,
+                width: Math.abs(canvasPoint1[0] - canvasPoint2[0]) - proximity,
+                height: Math.abs(canvasPoint1[1] - canvasPoint2[1]) - proximity,
+            };
+            const majorEllipse = {
+                left: Math.min(canvasPoint1[0], canvasPoint2[0]) - proximity / 2,
+                top: Math.min(canvasPoint1[1], canvasPoint2[1]) - proximity / 2,
+                width: Math.abs(canvasPoint1[0] - canvasPoint2[0]) + proximity,
+                height: Math.abs(canvasPoint1[1] - canvasPoint2[1]) + proximity,
+            };
+            const pointInMinorEllipse = this._pointInEllipseCanvas(minorEllipse, canvasCoords);
+            const pointInMajorEllipse = this._pointInEllipseCanvas(majorEllipse, canvasCoords);
+            if (pointInMajorEllipse && !pointInMinorEllipse) {
+                return true;
+            }
+            return false;
         };
         this.toolSelectedCallback = (evt, annotation) => {
             const eventDetail = evt.detail;
@@ -376,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);
@@ -417,7 +438,9 @@ class CircleROITool extends AnnotationTool {
                 }
                 const dataId = `${annotationUID}-circle`;
                 const circleUID = '0';
-                drawCircleSvg(svgDrawingHelper, annotationUID, circleUID, center, radius, {
+                const ellipseWorldCoordinates = getEllipseWorldCoordinates([points[0], points[1]], viewport);
+                const ellipseCanvasCoordinates = ellipseWorldCoordinates.map((p) => viewport.worldToCanvas(p));
+                drawEllipseByCoordinates(svgDrawingHelper, annotationUID, circleUID, ellipseCanvasCoordinates, {
                     color,
                     lineDash,
                     lineWidth,
@@ -480,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;
@@ -578,50 +601,65 @@ class CircleROITool extends AnnotationTool {
         };
         this._throttledCalculateCachedStats = throttle(this._calculateCachedStats, 100, { trailing: true });
     }
-    static { this.hydrate = (viewportId, points, options) => {
-        const enabledElement = getEnabledElementByViewportId(viewportId);
-        if (!enabledElement) {
-            return;
+    _pointInEllipseCanvas(ellipse, location) {
+        const xRadius = ellipse.width / 2;
+        const yRadius = ellipse.height / 2;
+        if (xRadius <= 0.0 || yRadius <= 0.0) {
+            return false;
         }
-        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],
-                        },
+        const center = [ellipse.left + xRadius, ellipse.top + yRadius];
+        const normalized = [location[0] - center[0], location[1] - center[1]];
+        const inEllipse = (normalized[0] * normalized[0]) / (xRadius * xRadius) +
+            (normalized[1] * normalized[1]) / (yRadius * yRadius) <=
+            1.0;
+        return inEllipse;
+    }
+}
+_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: {},
+                activeHandleIndex: null,
             },
-            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]);
-    }; }
-}
+            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;

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

@@ -1,3 +1,4 @@
+var _a;
 import { AnnotationTool } from '../base';
 import { getEnabledElement, VolumeViewport, utilities as csUtils, getEnabledElementByViewportId, EPSILON, } from '@cornerstonejs/core';
 import { getCalibratedAspect, getCalibratedLengthUnitsAndScale, } from '../../utilities/getCalibratedUnits';
@@ -15,13 +16,13 @@ import { pointInEllipse, getCanvasEllipseCorners, } from '../../utilities/math/e
 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 { BasicStatsCalculator } from '../../utilities/math/basic';
 import { vec2 } from 'gl-matrix';
 import { getStyleProperty } from '../../stateManagement/annotation/config/helpers';
 const { transformWorldToIndex } = csUtils;
 class EllipticalROITool extends AnnotationTool {
-    static { this.toolName = 'EllipticalROI'; }
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -417,7 +418,9 @@ class EllipticalROITool 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);
@@ -548,11 +551,13 @@ class EllipticalROITool extends AnnotationTool {
                     const { worldWidth, worldHeight } = getWorldWidthAndHeightFromTwoPoints(viewPlaneNormal, viewUp, worldPos1, worldPos2);
                     const isEmptyArea = worldWidth === 0 && worldHeight === 0;
                     const handles = [pos1Index, pos2Index];
-                    const { scale, areaUnit } = getCalibratedLengthUnitsAndScale(image, handles);
+                    const calibrate = getCalibratedLengthUnitsAndScale(image, handles);
+                    const { areaUnit } = calibrate;
                     const aspect = getCalibratedAspect(image);
-                    const area = Math.abs(Math.PI *
-                        (worldWidth / scale / 2) *
-                        (worldHeight / aspect / scale / 2));
+                    const indexHandles = points.map((p) => imageData.worldToIndex(p));
+                    const width = _a.calculateLengthInIndex(calibrate, indexHandles.slice(2, 4));
+                    const height = _a.calculateLengthInIndex(calibrate, indexHandles.slice(0, 2));
+                    const area = Math.abs(Math.PI * (width / 2) * (height / aspect / 2));
                     const pixelUnitsOptions = {
                         isPreScaled: isViewportPreScaled(viewport, targetId),
                         isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
@@ -602,39 +607,6 @@ class EllipticalROITool 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(EllipticalROITool, enabledElement, points, options);
-        const { toolInstance, ...serializableOptions } = options || {};
-        const annotation = {
-            annotationUID: options?.annotationUID || csUtils.uuidv4(),
-            data: {
-                handles: {
-                    points,
-                    activeHandleIndex: null,
-                },
-                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]);
-    }; }
     _pointInEllipseCanvas(ellipse, location) {
         const { xRadius, yRadius, center, angle } = ellipse;
         const rotLocation = vec2.rotate(vec2.create(), location, center, -angle);
@@ -657,6 +629,41 @@ class EllipticalROITool extends AnnotationTool {
         ];
     }
 }
+_a = EllipticalROITool;
+EllipticalROITool.toolName = 'EllipticalROI';
+EllipticalROITool.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,
+                activeHandleIndex: null,
+            },
+            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 { area, mean, stdDev, max, isEmptyArea, areaUnit, modalityUnit, min } = cachedVolumeStats;

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

@@ -16,7 +16,6 @@ import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCur
 import { getStyleProperty } from '../../stateManagement/annotation/config/helpers';
 const { transformWorldToIndex } = csUtils;
 class HeightTool extends AnnotationTool {
-    static { this.toolName = 'Height'; }
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -380,6 +379,7 @@ class HeightTool extends AnnotationTool {
             csUtils.indexWithinDimensions(index2, dimensions));
     }
 }
+HeightTool.toolName = 'Height';
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
     const { height, unit } = cachedVolumeStats;

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

@@ -9,17 +9,6 @@ import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters'
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 class KeyImageTool extends AnnotationTool {
-    static { this.toolName = 'KeyImage'; }
-    static { this.dataSeries = {
-        data: {
-            seriesLevel: true,
-        },
-    }; }
-    static { this.dataPoint = {
-        data: {
-            isPoint: true,
-        },
-    }; }
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -260,6 +249,17 @@ class KeyImageTool extends AnnotationTool {
             csUtils.indexWithinDimensions(index2, dimensions));
     }
 }
+KeyImageTool.toolName = 'KeyImage';
+KeyImageTool.dataSeries = {
+    data: {
+        seriesLevel: true,
+    },
+};
+KeyImageTool.dataPoint = {
+    data: {
+        isPoint: true,
+    },
+};
 function getTextCallback(doneChangingTextCallback) {
     return doneChangingTextCallback(prompt('Enter your annotation:'));
 }

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

@@ -1,3 +1,4 @@
+var _a;
 import { vec2 } from 'gl-matrix';
 import { ChangeTypes, Events } from '../../enums';
 import { getEnabledElement, utilities as csUtils, getEnabledElementByViewportId, } from '@cornerstonejs/core';
@@ -11,7 +12,6 @@ import { triggerAnnotationCompleted, triggerAnnotationModified, } from '../../st
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
 class LabelTool extends AnnotationTool {
-    static { this.toolName = 'Label'; }
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -257,40 +257,6 @@ class LabelTool extends AnnotationTool {
             return renderStatus;
         };
     }
-    static { this.hydrate = (viewportId, position, label, options) => {
-        const enabledElement = getEnabledElementByViewportId(viewportId);
-        if (!enabledElement) {
-            return;
-        }
-        const { viewport } = enabledElement;
-        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-        const { viewPlaneNormal, viewUp } = viewport.getCamera();
-        const instance = new this();
-        const referencedImageId = instance.getReferencedImageId(viewport, position, viewPlaneNormal, viewUp);
-        const annotation = {
-            annotationUID: options?.annotationUID || csUtils.uuidv4(),
-            data: {
-                label,
-                handles: {
-                    points: [position],
-                },
-            },
-            highlighted: false,
-            autoGenerated: false,
-            invalidated: false,
-            isLocked: false,
-            isVisible: true,
-            metadata: {
-                toolName: instance.getToolName(),
-                viewPlaneNormal,
-                FrameOfReferenceUID,
-                referencedImageId,
-                ...options,
-            },
-        };
-        addAnnotation(annotation, viewport.element);
-        triggerAnnotationRenderForViewportIds([viewport.id]);
-    }; }
     handleSelectedCallback(_evt, _annotation, _handle, _interactionType) { }
     _doneChangingTextCallback(element, annotation, updatedLabel) {
         annotation.data.label = updatedLabel;
@@ -303,6 +269,42 @@ class LabelTool extends AnnotationTool {
             csUtils.indexWithinDimensions(index2, dimensions));
     }
 }
+_a = LabelTool;
+LabelTool.toolName = 'Label';
+LabelTool.hydrate = (viewportId, position, label, options) => {
+    const enabledElement = getEnabledElementByViewportId(viewportId);
+    if (!enabledElement) {
+        return;
+    }
+    const { viewport } = enabledElement;
+    const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+    const { viewPlaneNormal, viewUp } = viewport.getCamera();
+    const instance = new _a();
+    const referencedImageId = instance.getReferencedImageId(viewport, position, viewPlaneNormal, viewUp);
+    const annotation = {
+        annotationUID: options?.annotationUID || csUtils.uuidv4(),
+        data: {
+            label,
+            handles: {
+                points: [position],
+            },
+        },
+        highlighted: false,
+        autoGenerated: false,
+        invalidated: false,
+        isLocked: false,
+        isVisible: true,
+        metadata: {
+            toolName: instance.getToolName(),
+            viewPlaneNormal,
+            FrameOfReferenceUID,
+            referencedImageId,
+            ...options,
+        },
+    };
+    addAnnotation(annotation, viewport.element);
+    triggerAnnotationRenderForViewportIds([viewport.id]);
+};
 function getTextCallback(doneChangingTextCallback) {
     return doneChangingTextCallback(prompt('Enter your annotation:'));
 }

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

@@ -1,3 +1,4 @@
+var _a;
 import { Events, ChangeTypes, MeasurementType } from '../../enums';
 import { getEnabledElement, utilities as csUtils, utilities, getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import { getCalibratedLengthUnitsAndScale } from '../../utilities/getCalibratedUnits';
@@ -15,7 +16,6 @@ import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnota
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import { getStyleProperty } from '../../stateManagement/annotation/config/helpers';
 class LengthTool extends AnnotationTool {
-    static { this.toolName = 'Length'; }
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -308,36 +308,6 @@ class LengthTool 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(LengthTool, enabledElement, points, options);
-        const { toolInstance, ...serializableOptions } = options || {};
-        const annotation = {
-            annotationUID: options?.annotationUID || utilities.uuidv4(),
-            data: {
-                handles: {
-                    points,
-                },
-            },
-            highlighted: false,
-            autoGenerated: false,
-            invalidated: false,
-            isLocked: false,
-            isVisible: true,
-            metadata: {
-                toolName: instance.getToolName(),
-                viewPlaneNormal,
-                FrameOfReferenceUID,
-                referencedImageId,
-                ...serializableOptions,
-            },
-        };
-        addAnnotation(annotation, viewport.element);
-        triggerAnnotationRenderForViewportIds([viewport.id]);
-    }; }
     handleSelectedCallback(evt, annotation, handle) {
         const eventDetail = evt.detail;
         const { element } = eventDetail;
@@ -378,8 +348,8 @@ class LengthTool extends AnnotationTool {
             const handles = data.handles.points.map((point) => imageData.worldToIndex(point));
             const calibrate = getCalibratedLengthUnitsAndScale(image, handles);
             const { unit } = calibrate;
-            const length = LengthTool.calculateLengthInIndex(calibrate, handles);
-            this.isHandleOutsideImage = !LengthTool.isInsideVolume(dimensions, handles);
+            const length = _a.calculateLengthInIndex(calibrate, handles);
+            this.isHandleOutsideImage = !_a.isInsideVolume(dimensions, handles);
             const namedLength = {
                 name: 'length',
                 value: length,
@@ -400,6 +370,38 @@ class LengthTool extends AnnotationTool {
         return cachedStats;
     }
 }
+_a = LengthTool;
+LengthTool.toolName = 'Length';
+LengthTool.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 || utilities.uuidv4(),
+        data: {
+            handles: {
+                points,
+            },
+        },
+        highlighted: false,
+        autoGenerated: false,
+        invalidated: false,
+        isLocked: false,
+        isVisible: true,
+        metadata: {
+            toolName: instance.getToolName(),
+            viewPlaneNormal,
+            FrameOfReferenceUID,
+            referencedImageId,
+            ...serializableOptions,
+        },
+    };
+    addAnnotation(annotation, viewport.element);
+    triggerAnnotationRenderForViewportIds([viewport.id]);
+};
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
     const { length, unit } = cachedVolumeStats;

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

@@ -1,3 +1,4 @@
+var _a;
 import { utilities as csUtils } from '@cornerstonejs/core';
 import LivewireContourTool from './LivewireContourTool';
 import { LivewirePath } from '../../utilities/livewire/LiveWirePath';
@@ -6,7 +7,6 @@ import { ChangeTypes } from '../../enums';
 import { drawPolyline as drawPolylineSvg } from '../../drawingSvg';
 import AnnotationToPointData from '../../utilities/contours/AnnotationToPointData';
 class LivewireContourSegmentationTool extends LivewireContourTool {
-    static { this.toolName = 'LivewireContourSegmentationTool'; }
     updateInterpolatedAnnotation(annotation, enabledElement) {
         if (this.editData ||
             !annotation.invalidated ||
@@ -86,8 +86,10 @@ class LivewireContourSegmentationTool extends LivewireContourTool {
     isContourSegmentationTool() {
         return true;
     }
-    static {
-        AnnotationToPointData.register(this);
-    }
 }
+_a = LivewireContourSegmentationTool;
+LivewireContourSegmentationTool.toolName = 'LivewireContourSegmentationTool';
+(() => {
+    AnnotationToPointData.register(_a);
+})();
 export default LivewireContourSegmentationTool;