@cornerstonejs/tools 4.22.13 → 5.0.0

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);
@@ -552,8 +555,8 @@ class EllipticalROITool extends AnnotationTool {
                     const { areaUnit } = calibrate;
                     const aspect = getCalibratedAspect(image);
                     const indexHandles = points.map((p) => imageData.worldToIndex(p));
-                    const width = EllipticalROITool.calculateLengthInIndex(calibrate, indexHandles.slice(2, 4));
-                    const height = EllipticalROITool.calculateLengthInIndex(calibrate, indexHandles.slice(0, 2));
+                    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),
@@ -604,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);
@@ -659,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;

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

@@ -17,7 +17,6 @@ import ContourSegmentationBaseTool from '../base/ContourSegmentationBaseTool';
 import { getCalibratedLengthUnitsAndScale, throttle } from '../../utilities';
 const CLICK_CLOSE_CURVE_SQR_DIST = 10 ** 2;
 class LivewireContourTool extends ContourSegmentationBaseTool {
-    static { this.toolName = 'LivewireContour'; }
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -637,6 +636,7 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
         });
     }
 }
+LivewireContourTool.toolName = 'LivewireContour';
 export default LivewireContourTool;
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];

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

@@ -1,9 +1,9 @@
+var _a;
 import { utilities } from '@cornerstonejs/core';
 import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
 import PlanarFreehandROITool from './PlanarFreehandROITool';
 import AnnotationToPointData from '../../utilities/contours/AnnotationToPointData';
 export class PlanarFreehandContourSegmentationTool extends PlanarFreehandROITool {
-    static { this.toolName = 'PlanarFreehandContourSegmentationTool'; }
     constructor(toolProps) {
         const initialProps = utilities.deepMerge({
             configuration: {
@@ -13,9 +13,6 @@ export class PlanarFreehandContourSegmentationTool extends PlanarFreehandROITool
         }, toolProps);
         super(initialProps);
     }
-    static {
-        AnnotationToPointData.register(this);
-    }
     isContourSegmentationTool() {
         return true;
     }
@@ -30,4 +27,9 @@ export class PlanarFreehandContourSegmentationTool extends PlanarFreehandROITool
         return renderResult;
     }
 }
+_a = PlanarFreehandContourSegmentationTool;
+PlanarFreehandContourSegmentationTool.toolName = 'PlanarFreehandContourSegmentationTool';
+(() => {
+    AnnotationToPointData.register(_a);
+})();
 export default PlanarFreehandContourSegmentationTool;

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

@@ -24,7 +24,6 @@ const { pointCanProjectOnLine } = polyline;
 const { EPSILON } = CONSTANTS;
 const PARALLEL_THRESHOLD = 1 - EPSILON;
 class PlanarFreehandROITool extends ContourSegmentationBaseTool {
-    static { this.toolName = 'PlanarFreehandROI'; }
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -529,6 +528,7 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
         };
     }
 }
+PlanarFreehandROITool.toolName = 'PlanarFreehandROI';
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
     const { area, mean, stdDev, length, perimeter, max, min, isEmptyArea, unit, areaUnit, modalityUnit, } = cachedVolumeStats || {};

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

@@ -1,3 +1,4 @@
+var _a;
 import { vec2, vec3 } from 'gl-matrix';
 import { getEnabledElement, VolumeViewport, utilities as csUtils, getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import { AnnotationTool } from '../base';
@@ -13,25 +14,12 @@ import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCur
 import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { getPixelValueUnits } from '../../utilities/getPixelValueUnits';
+import { viewportSupportsImageSlices } from '../../utilities/viewportCapabilities';
 import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
 const { transformWorldToIndex } = csUtils;
 class ProbeTool extends AnnotationTool {
-    static { this.toolName = 'Probe'; }
-    static { this.probeDefaults = {
-        supportedInteractionTypes: ['Mouse', 'Touch'],
-        configuration: {
-            shadow: true,
-            preventHandleOutsideImage: false,
-            getTextLines: defaultGetTextLines,
-            handleRadius: '6',
-            textCanvasOffset: {
-                x: 6,
-                y: -6,
-            },
-        },
-    }; }
     constructor(toolProps = {}, defaultToolProps) {
-        super(toolProps, AnnotationTool.mergeDefaultProps(ProbeTool.probeDefaults, defaultToolProps));
+        super(toolProps, AnnotationTool.mergeDefaultProps(_a.probeDefaults, defaultToolProps));
         this.addNewAnnotation = (evt) => {
             const eventDetail = evt.detail;
             const { currentPoints, element } = eventDetail;
@@ -179,7 +167,9 @@ class ProbeTool extends AnnotationTool {
                         if (referencedImageId) {
                             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 currentImageId = vp.getCurrentImageId();
                                         if (!currentImageId)
@@ -230,36 +220,6 @@ class ProbeTool extends AnnotationTool {
         return vec2.distance(canvasCoords, annotationCanvasCoordinate) < proximity;
     }
     toolSelectedCallback() { }
-    static { this.hydrate = (viewportId, points, options) => {
-        const enabledElement = getEnabledElementByViewportId(viewportId);
-        if (!enabledElement) {
-            return;
-        }
-        const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, viewUp, instance, viewport, } = this.hydrateBase(ProbeTool, 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]);
-    }; }
     getHandleNearImagePoint(element, annotation, canvasCoords, proximity) {
         const enabledElement = getEnabledElement(element);
         const { viewport } = enabledElement;
@@ -363,6 +323,51 @@ class ProbeTool extends AnnotationTool {
         return cachedStats;
     }
 }
+_a = ProbeTool;
+ProbeTool.toolName = 'Probe';
+ProbeTool.probeDefaults = {
+    supportedInteractionTypes: ['Mouse', 'Touch'],
+    configuration: {
+        shadow: true,
+        preventHandleOutsideImage: false,
+        getTextLines: defaultGetTextLines,
+        handleRadius: '6',
+        textCanvasOffset: {
+            x: 6,
+            y: -6,
+        },
+    },
+};
+ProbeTool.hydrate = (viewportId, points, options) => {
+    const enabledElement = getEnabledElementByViewportId(viewportId);
+    if (!enabledElement) {
+        return;
+    }
+    const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, viewUp, 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 { index, value, modalityUnit } = cachedVolumeStats;