@ohif/app 3.12.0-beta.17 → 3.12.0-beta.19

package/dist/{9892.bundle.74e04e0d8f1c92e98456.js → 9892.bundle.eb768b852ed006b855ae.js}

@@ -7229,48 +7229,13 @@ class BidirectionalTool extends _base__WEBPACK_IMPORTED_MODULE_3__/* .Annotation
         const eventDetail = evt.detail;
         const { currentPoints, element } = eventDetail;
         const worldPos = currentPoints.world;
-        const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.getEnabledElement)(element);
-        const { viewport, renderingEngine } = enabledElement;
         this.isDrawing = true;
-        const camera = viewport.getCamera();
-        const { viewPlaneNormal, viewUp } = camera;
-        const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
-        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-        const annotation = {
-            highlighted: true,
-            invalidated: true,
-            metadata: {
-                toolName: this.getToolName(),
-                viewPlaneNormal: [...viewPlaneNormal],
-                viewUp: [...viewUp],
-                FrameOfReferenceUID,
-                referencedImageId,
-                ...viewport.getViewReference({ points: [worldPos] }),
-            },
-            data: {
-                handles: {
-                    points: [
-                        [...worldPos],
-                        [...worldPos],
-                        [...worldPos],
-                        [...worldPos],
-                    ],
-                    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: {},
-            },
-        };
+        const annotation = this.createAnnotation(evt, [
+            [...worldPos],
+            [...worldPos],
+            [...worldPos],
+            [...worldPos],
+        ]);
         (0,_stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_5__.addAnnotation)(annotation, element);
         const viewportIdsToRender = (0,_utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_12__.getViewportIdsWithToolToRender)(element, this.getToolName());
         this.editData = {
@@ -19545,7 +19510,7 @@ var COLOR_LUT = __webpack_require__(93952);
 
 
 ;// ../../../node_modules/@cornerstonejs/tools/dist/esm/version.js
-const version = '3.32.12';
+const version = '4.0.0';
 
 ;// ../../../node_modules/@cornerstonejs/tools/dist/esm/synchronizers/callbacks/cameraSyncCallback.js
 
@@ -20665,7 +20630,8 @@ let stackContextPrefetch_configuration = {
 };
 let stackContextPrefetch_resetPrefetchTimeout;
 const stackContextPrefetch_resetPrefetchDelay = 5;
-const stackContextPrefetch_enable = (element) => {
+const priorities = {};
+const stackContextPrefetch_enable = (element, priority = 0) => {
     const stack = (0,stackPrefetchUtils/* getStackData */.bV)(element);
     if (!stack) {
         return;
@@ -20675,14 +20641,15 @@ const stackContextPrefetch_enable = (element) => {
         return;
     }
     updateToolState(element);
-    stackContextPrefetch_prefetch(element);
+    priorities[element] = priority;
+    stackContextPrefetch_prefetch(element, priority);
     element.removeEventListener(esm.Enums.Events.STACK_NEW_IMAGE, stackContextPrefetch_onImageUpdated);
     element.addEventListener(esm.Enums.Events.STACK_NEW_IMAGE, stackContextPrefetch_onImageUpdated);
     const promiseRemovedHandler = (0,stackPrefetchUtils/* getPromiseRemovedHandler */.m0)(element);
     esm.eventTarget.removeEventListener(esm.Enums.Events.IMAGE_CACHE_IMAGE_REMOVED, promiseRemovedHandler);
     esm.eventTarget.addEventListener(esm.Enums.Events.IMAGE_CACHE_IMAGE_REMOVED, promiseRemovedHandler);
 };
-function stackContextPrefetch_prefetch(element) {
+function stackContextPrefetch_prefetch(element, priority = 0) {
     const stack = (0,stackPrefetchUtils/* getStackData */.bV)(element);
     if (!stack) {
         return;
@@ -20748,7 +20715,7 @@ function stackContextPrefetch_prefetch(element) {
                     stats.initialTime = Date.now() - stats.start;
                     stats.initialSize = stats.imageIds.size;
                     updateToolState(element, usage);
-                    stackContextPrefetch_prefetch(element);
+                    stackContextPrefetch_prefetch(element, priority);
                 }
                 else if (stats.imageIds.size) {
                     stats.fillTime = Date.now() - stats.start;
@@ -20774,7 +20741,7 @@ function stackContextPrefetch_prefetch(element) {
         };
         esm.imageLoadPoolManager.addRequest(requestFn.bind(null, imageId, options), stackPrefetchUtils/* requestType */.y9, {
             imageId,
-        }, stackPrefetchUtils/* priority */.Lr);
+        }, priority);
     });
 }
 function stackContextPrefetch_onImageUpdated(e) {
@@ -20783,7 +20750,7 @@ function stackContextPrefetch_onImageUpdated(e) {
         const element = e.target;
         try {
             updateToolState(element);
-            stackContextPrefetch_prefetch(element);
+            stackContextPrefetch_prefetch(element, priorities[element]);
         }
         catch (error) {
             return;
@@ -30717,34 +30684,12 @@ class LabelTool extends base/* AnnotationTool */.EC {
             const eventDetail = evt.detail;
             const { currentPoints, element } = eventDetail;
             const worldPos = currentPoints.world;
-            const enabledElement = (0,esm.getEnabledElement)(element);
-            const { viewport } = enabledElement;
             (0,elementCursor.hideElementCursor)(element);
             this.isDrawing = true;
-            const camera = viewport.getCamera();
-            const { viewPlaneNormal, viewUp } = camera;
-            const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
-            const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-            const annotation = {
-                annotationUID: null,
-                highlighted: true,
-                invalidated: true,
-                metadata: {
-                    toolName: this.getToolName(),
-                    viewPlaneNormal: [...viewPlaneNormal],
-                    viewUp: [...viewUp],
-                    FrameOfReferenceUID,
-                    referencedImageId,
-                    ...viewport.getViewReference({ points: [worldPos] }),
-                },
-                data: {
-                    text: '',
-                    handles: {
-                        points: [[...worldPos], [...worldPos]],
-                    },
-                    label: '',
-                },
-            };
+            const annotation = (this.createAnnotation(evt, [
+                [...worldPos],
+                [...worldPos],
+            ]));
             (0,annotationState.addAnnotation)(annotation, element);
             const viewportIdsToRender = (0,viewportFilters.getViewportIdsWithToolToRender)(element, this.getToolName());
             this.editData = {
@@ -30755,15 +30700,15 @@ class LabelTool extends base/* AnnotationTool */.EC {
             };
             evt.preventDefault();
             (0,triggerAnnotationRenderForViewportIds/* default */.A)(viewportIdsToRender);
-            this.configuration.getTextCallback((text) => {
-                if (!text) {
+            this.configuration.getTextCallback((label) => {
+                if (!label) {
                     (0,annotationState.removeAnnotation)(annotation.annotationUID);
                     (0,triggerAnnotationRenderForViewportIds/* default */.A)(viewportIdsToRender);
                     this.isDrawing = false;
                     return;
                 }
                 (0,elementCursor.resetElementCursor)(element);
-                annotation.data.text = text;
+                annotation.data.label = label;
                 (0,helpers_state.triggerAnnotationCompleted)(annotation);
                 (0,triggerAnnotationRenderForViewportIds/* default */.A)(viewportIdsToRender);
             });
@@ -30919,12 +30864,12 @@ class LabelTool extends base/* AnnotationTool */.EC {
                 if (!(0,annotationVisibility.isAnnotationVisible)(annotationUID)) {
                     continue;
                 }
-                if (!data.text) {
+                if (!data.label) {
                     continue;
                 }
                 const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
                 const textBoxUID = '1';
-                (0,drawingSvg.drawTextBox)(svgDrawingHelper, annotationUID, textBoxUID, [data.text], canvasCoordinates, {
+                (0,drawingSvg.drawTextBox)(svgDrawingHelper, annotationUID, textBoxUID, [data.label], canvasCoordinates, {
                     ...options,
                     padding: 0,
                 });
@@ -30932,7 +30877,7 @@ class LabelTool extends base/* AnnotationTool */.EC {
             return renderStatus;
         };
     }
-    static { this.hydrate = (viewportId, position, text, options) => {
+    static { this.hydrate = (viewportId, position, label, options) => {
         const enabledElement = (0,esm.getEnabledElementByViewportId)(viewportId);
         if (!enabledElement) {
             return;
@@ -30945,7 +30890,7 @@ class LabelTool extends base/* AnnotationTool */.EC {
         const annotation = {
             annotationUID: options?.annotationUID || esm.utilities.uuidv4(),
             data: {
-                text,
+                label,
                 handles: {
                     points: [position],
                 },
@@ -30966,9 +30911,9 @@ class LabelTool extends base/* AnnotationTool */.EC {
         (0,annotationState.addAnnotation)(annotation, viewport.element);
         (0,triggerAnnotationRenderForViewportIds/* default */.A)([viewport.id]);
     }; }
-    handleSelectedCallback(evt, annotation, handle, interactionType) { }
-    _doneChangingTextCallback(element, annotation, updatedText) {
-        annotation.data.text = updatedText;
+    handleSelectedCallback(_evt, _annotation, _handle, _interactionType) { }
+    _doneChangingTextCallback(element, annotation, updatedLabel) {
+        annotation.data.label = updatedLabel;
         const viewportIdsToRender = (0,viewportFilters.getViewportIdsWithToolToRender)(element, this.getToolName());
         (0,triggerAnnotationRenderForViewportIds/* default */.A)(viewportIdsToRender);
         (0,helpers_state.triggerAnnotationModified)(annotation, element);
@@ -31029,41 +30974,12 @@ class LengthTool extends base/* AnnotationTool */.EC {
             const eventDetail = evt.detail;
             const { currentPoints, element } = eventDetail;
             const worldPos = currentPoints.world;
-            const enabledElement = (0,esm.getEnabledElement)(element);
-            const { viewport } = enabledElement;
             (0,elementCursor.hideElementCursor)(element);
             this.isDrawing = true;
-            const { viewPlaneNormal, viewUp, position: cameraPosition, } = viewport.getCamera();
-            const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
-            const annotation = {
-                highlighted: true,
-                invalidated: true,
-                metadata: {
-                    ...viewport.getViewReference({ points: [worldPos] }),
-                    toolName: this.getToolName(),
-                    referencedImageId,
-                    viewUp,
-                    cameraPosition,
-                },
-                data: {
-                    handles: {
-                        points: [[...worldPos], [...worldPos]],
-                        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],
-                            },
-                        },
-                    },
-                    label: '',
-                    cachedStats: {},
-                },
-            };
+            const annotation = (this.createAnnotation(evt, [
+                [...worldPos],
+                [...worldPos],
+            ]));
             (0,annotationState.addAnnotation)(annotation, element);
             const viewportIdsToRender = (0,viewportFilters.getViewportIdsWithToolToRender)(element, this.getToolName());
             this.editData = {
@@ -31492,41 +31408,12 @@ class HeightTool extends base/* AnnotationTool */.EC {
             const eventDetail = evt.detail;
             const { currentPoints, element } = eventDetail;
             const worldPos = currentPoints.world;
-            const enabledElement = (0,esm.getEnabledElement)(element);
-            const { viewport, renderingEngine } = enabledElement;
             (0,elementCursor.hideElementCursor)(element);
             this.isDrawing = true;
-            const { viewPlaneNormal, viewUp, position: cameraPosition, } = viewport.getCamera();
-            const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
-            const annotation = {
-                highlighted: true,
-                invalidated: true,
-                metadata: {
-                    ...viewport.getViewReference({ points: [worldPos] }),
-                    toolName: this.getToolName(),
-                    referencedImageId,
-                    viewUp,
-                    cameraPosition,
-                },
-                data: {
-                    handles: {
-                        points: [[...worldPos], [...worldPos]],
-                        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],
-                            },
-                        },
-                    },
-                    label: '',
-                    cachedStats: {},
-                },
-            };
+            const annotation = (this.createAnnotation(evt, [
+                [...worldPos],
+                [...worldPos],
+            ]));
             (0,annotationState.addAnnotation)(annotation, element);
             const viewportIdsToRender = (0,viewportFilters.getViewportIdsWithToolToRender)(element, this.getToolName());
             this.editData = {
@@ -32458,50 +32345,13 @@ class EllipticalROITool extends base/* AnnotationTool */.EC {
             const eventDetail = evt.detail;
             const { currentPoints, element } = eventDetail;
             const worldPos = currentPoints.world;
-            const canvasPos = currentPoints.canvas;
-            const enabledElement = (0,esm.getEnabledElement)(element);
-            const { viewport, renderingEngine } = enabledElement;
             this.isDrawing = true;
-            const camera = viewport.getCamera();
-            const { viewPlaneNormal, viewUp } = camera;
-            const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
-            const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-            const annotation = {
-                highlighted: true,
-                invalidated: true,
-                metadata: {
-                    toolName: this.getToolName(),
-                    viewPlaneNormal: [...viewPlaneNormal],
-                    viewUp: [...viewUp],
-                    FrameOfReferenceUID,
-                    referencedImageId,
-                    ...viewport.getViewReference({ points: [worldPos] }),
-                },
-                data: {
-                    label: '',
-                    handles: {
-                        textBox: {
-                            hasMoved: false,
-                            worldPosition: [0, 0, 0],
-                            worldBoundingBox: {
-                                topLeft: [0, 0, 0],
-                                topRight: [0, 0, 0],
-                                bottomLeft: [0, 0, 0],
-                                bottomRight: [0, 0, 0],
-                            },
-                        },
-                        points: [
-                            [...worldPos],
-                            [...worldPos],
-                            [...worldPos],
-                            [...worldPos],
-                        ],
-                        activeHandleIndex: null,
-                    },
-                    cachedStats: {},
-                    initialRotation: viewport.getRotation(),
-                },
-            };
+            const annotation = (this.createAnnotation(evt, [
+                [...worldPos],
+                [...worldPos],
+                [...worldPos],
+                [...worldPos],
+            ]));
             (0,annotationState.addAnnotation)(annotation, element);
             const viewportIdsToRender = (0,viewportFilters.getViewportIdsWithToolToRender)(element, this.getToolName());
             this.editData = {
@@ -33190,13 +33040,7 @@ class CircleROITool extends base/* AnnotationTool */.EC {
             const eventDetail = evt.detail;
             const { currentPoints, element } = eventDetail;
             const worldPos = currentPoints.world;
-            const enabledElement = (0,esm.getEnabledElement)(element);
-            const { viewport } = enabledElement;
             this.isDrawing = true;
-            const camera = viewport.getCamera();
-            const { viewPlaneNormal, viewUp } = camera;
-            const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
-            const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
             let points;
             if (this.configuration.simplified) {
                 points = [[...worldPos], [...worldPos]];
@@ -33210,36 +33054,7 @@ class CircleROITool extends base/* AnnotationTool */.EC {
                     [...worldPos],
                 ];
             }
-            const annotation = {
-                highlighted: true,
-                invalidated: true,
-                metadata: {
-                    toolName: this.getToolName(),
-                    viewPlaneNormal: [...viewPlaneNormal],
-                    viewUp: [...viewUp],
-                    FrameOfReferenceUID,
-                    referencedImageId,
-                    ...viewport.getViewReference({ points: [worldPos] }),
-                },
-                data: {
-                    label: '',
-                    handles: {
-                        textBox: {
-                            hasMoved: false,
-                            worldPosition: [0, 0, 0],
-                            worldBoundingBox: {
-                                topLeft: [0, 0, 0],
-                                topRight: [0, 0, 0],
-                                bottomLeft: [0, 0, 0],
-                                bottomRight: [0, 0, 0],
-                            },
-                        },
-                        points,
-                        activeHandleIndex: null,
-                    },
-                    cachedStats: {},
-                },
-            };
+            const annotation = this.createAnnotation(evt, points);
             (0,annotationState.addAnnotation)(annotation, element);
             const viewportIdsToRender = (0,viewportFilters.getViewportIdsWithToolToRender)(element, this.getToolName());
             this.editData = {
@@ -34744,8 +34559,6 @@ class SplineROITool extends ContourSegmentationBaseTool/* default */.A {
         const { canvas: canvasPos } = currentPoints;
         const contourHoleProcessingEnabled = (0,getMouseModifier/* default */.A)(evt.detail.event) ===
             this.configuration.contourHoleAdditionModifierKey;
-        const enabledElement = (0,esm.getEnabledElement)(element);
-        const { renderingEngine } = enabledElement;
         const annotation = this.createAnnotation(evt);
         this.isDrawing = true;
         this.addAnnotation(annotation, element);
@@ -35891,46 +35704,16 @@ class ArrowAnnotateTool extends base/* AnnotationTool */.EC {
             const eventDetail = evt.detail;
             const { currentPoints, element } = eventDetail;
             const worldPos = currentPoints.world;
-            const enabledElement = (0,esm.getEnabledElement)(element);
-            const { viewport, renderingEngine } = enabledElement;
             (0,elementCursor.hideElementCursor)(element);
             this.isDrawing = true;
-            const camera = viewport.getCamera();
-            const { viewPlaneNormal, viewUp } = camera;
-            const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
             const { arrowFirst } = this.configuration;
-            const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-            const annotation = {
-                highlighted: true,
-                invalidated: true,
-                metadata: {
-                    toolName: this.getToolName(),
-                    viewPlaneNormal: [...viewPlaneNormal],
-                    viewUp: [...viewUp],
-                    FrameOfReferenceUID,
-                    referencedImageId,
-                    ...viewport.getViewReference({ points: [worldPos] }),
-                },
+            const annotation = this.createAnnotation(evt, [[...worldPos], [...worldPos]], {
                 data: {
-                    text: '',
                     handles: {
-                        points: [[...worldPos], [...worldPos]],
-                        activeHandleIndex: null,
                         arrowFirst,
-                        textBox: {
-                            hasMoved: false,
-                            worldPosition: [0, 0, 0],
-                            worldBoundingBox: {
-                                topLeft: [0, 0, 0],
-                                topRight: [0, 0, 0],
-                                bottomLeft: [0, 0, 0],
-                                bottomRight: [0, 0, 0],
-                            },
-                        },
                     },
-                    label: '',
                 },
-            };
+            });
             (0,annotationState.addAnnotation)(annotation, element);
             const viewportIdsToRender = (0,viewportFilters.getViewportIdsWithToolToRender)(element, this.getToolName());
             this.editData = {
@@ -36003,19 +35786,19 @@ class ArrowAnnotateTool extends base/* AnnotationTool */.EC {
                 (0,annotationState.removeAnnotation)(annotation.annotationUID);
             }
             if (newAnnotation) {
-                this.configuration.getTextCallback((text) => {
-                    if (!text) {
+                this.configuration.getTextCallback((label) => {
+                    if (!label) {
                         (0,annotationState.removeAnnotation)(annotation.annotationUID);
                         (0,triggerAnnotationRenderForViewportIds/* default */.A)(viewportIdsToRender);
                         this.editData = null;
                         this.isDrawing = false;
                         return;
                     }
-                    annotation.data.text = text;
+                    annotation.data.label = label;
                     (0,helpers_state.triggerAnnotationModified)(annotation, element, enums.ChangeTypes.HandlesUpdated);
                     (0,helpers_state.triggerAnnotationCompleted)(annotation);
                     this.createMemo(element, annotation, { newAnnotation: !!this.memo });
-                    setAnnotationLabel(annotation, element, text);
+                    setAnnotationLabel(annotation, element, label);
                     (0,triggerAnnotationRenderForViewportIds/* default */.A)(viewportIdsToRender);
                 });
             }
@@ -36166,7 +35949,7 @@ class ArrowAnnotateTool extends base/* AnnotationTool */.EC {
             for (let i = 0; i < annotations.length; i++) {
                 const annotation = annotations[i];
                 const { annotationUID, data } = annotation;
-                const { handles, text } = data;
+                const { handles, label } = data;
                 const { points, activeHandleIndex } = handles;
                 styleSpecifier.annotationUID = annotationUID;
                 const { color, lineWidth, lineDash, markerSize } = this.getAnnotationStyle({
@@ -36214,7 +35997,7 @@ class ArrowAnnotateTool extends base/* AnnotationTool */.EC {
                     });
                 }
                 renderStatus = true;
-                if (!text) {
+                if (!label) {
                     continue;
                 }
                 const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
@@ -36238,7 +36021,7 @@ class ArrowAnnotateTool extends base/* AnnotationTool */.EC {
                 }
                 const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
                 const textBoxUID = '1';
-                const boundingBox = (0,drawingSvg.drawLinkedTextBox)(svgDrawingHelper, annotationUID, textBoxUID, [text], textBoxPosition, canvasCoordinates, {}, options);
+                const boundingBox = (0,drawingSvg.drawLinkedTextBox)(svgDrawingHelper, annotationUID, textBoxUID, [label], textBoxPosition, canvasCoordinates, {}, options);
                 const { x: left, y: top, width, height } = boundingBox;
                 data.handles.textBox.worldBoundingBox = {
                     topLeft: viewport.canvasToWorld([left, top]),
@@ -36250,26 +36033,22 @@ class ArrowAnnotateTool extends base/* AnnotationTool */.EC {
             return renderStatus;
         };
     }
-    static { this.hydrate = (viewportId, points, text, options) => {
+    static { this.hydrate = (viewportId, points, label, options) => {
         const enabledElement = (0,esm.getEnabledElementByViewportId)(viewportId);
         if (!enabledElement) {
             return;
         }
         const { FrameOfReferenceUID, referencedImageId, viewPlaneNormal, instance, viewport, } = this.hydrateBase(ArrowAnnotateTool, enabledElement, points, options);
         const { toolInstance, ...serializableOptions } = options || {};
-        const annotation = {
+        const annotation = this.createAnnotation({
             annotationUID: options?.annotationUID || esm.utilities.uuidv4(),
             data: {
-                text: text || '',
+                label: label || '',
                 handles: {
                     points,
                 },
             },
-            highlighted: false,
             autoGenerated: false,
-            invalidated: false,
-            isLocked: false,
-            isVisible: true,
             metadata: {
                 toolName: instance.getToolName(),
                 viewPlaneNormal,
@@ -36277,7 +36056,7 @@ class ArrowAnnotateTool extends base/* AnnotationTool */.EC {
                 referencedImageId,
                 ...serializableOptions,
             },
-        };
+        });
         (0,annotationState.addAnnotation)(annotation, viewport.element);
         (0,triggerAnnotationRenderForViewportIds/* default */.A)([viewport.id]);
     }; }
@@ -36308,9 +36087,8 @@ class ArrowAnnotateTool extends base/* AnnotationTool */.EC {
         (0,triggerAnnotationRenderForViewportIds/* default */.A)(viewportIdsToRender);
         evt.preventDefault();
     }
-    _doneChangingTextCallback(element, annotation, updatedText) {
-        annotation.data.text = updatedText;
-        const enabledElement = (0,esm.getEnabledElement)(element);
+    _doneChangingTextCallback(element, annotation, updatedLabel) {
+        annotation.data.label = updatedLabel;
         const viewportIdsToRender = (0,viewportFilters.getViewportIdsWithToolToRender)(element, this.getToolName());
         (0,triggerAnnotationRenderForViewportIds/* default */.A)(viewportIdsToRender);
         (0,helpers_state.triggerAnnotationModified)(annotation, element);
@@ -36365,44 +36143,12 @@ class AngleTool extends base/* AnnotationTool */.EC {
             const eventDetail = evt.detail;
             const { currentPoints, element } = eventDetail;
             const worldPos = currentPoints.world;
-            const enabledElement = (0,esm.getEnabledElement)(element);
-            const { viewport, renderingEngine } = enabledElement;
             (0,elementCursor.hideElementCursor)(element);
             this.isDrawing = true;
-            const camera = viewport.getCamera();
-            const { viewPlaneNormal, viewUp } = camera;
-            const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
-            const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-            const annotation = {
-                highlighted: true,
-                invalidated: true,
-                metadata: {
-                    toolName: this.getToolName(),
-                    viewPlaneNormal: [...viewPlaneNormal],
-                    viewUp: [...viewUp],
-                    FrameOfReferenceUID,
-                    referencedImageId,
-                    ...viewport.getViewReference({ points: [worldPos] }),
-                },
-                data: {
-                    handles: {
-                        points: [[...worldPos], [...worldPos]],
-                        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],
-                            },
-                        },
-                    },
-                    label: '',
-                    cachedStats: {},
-                },
-            };
+            const annotation = (this.createAnnotation(evt, [
+                [...worldPos],
+                [...worldPos],
+            ]));
             (0,annotationState.addAnnotation)(annotation, element);
             const viewportIdsToRender = (0,viewportFilters.getViewportIdsWithToolToRender)(element, this.getToolName());
             this.editData = {
@@ -36894,44 +36640,12 @@ class CobbAngleTool extends base/* AnnotationTool */.EC {
             const eventDetail = evt.detail;
             const { currentPoints, element } = eventDetail;
             const worldPos = currentPoints.world;
-            const enabledElement = (0,esm.getEnabledElement)(element);
-            const { viewport, renderingEngine } = enabledElement;
             (0,elementCursor.hideElementCursor)(element);
             this.isDrawing = true;
-            const camera = viewport.getCamera();
-            const { viewPlaneNormal, viewUp } = camera;
-            const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
-            const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-            const annotation = {
-                highlighted: true,
-                invalidated: true,
-                metadata: {
-                    toolName: this.getToolName(),
-                    viewPlaneNormal: [...viewPlaneNormal],
-                    viewUp: [...viewUp],
-                    FrameOfReferenceUID,
-                    referencedImageId,
-                    ...viewport.getViewReference({ points: [worldPos] }),
-                },
-                data: {
-                    handles: {
-                        points: [[...worldPos], [...worldPos]],
-                        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],
-                            },
-                        },
-                    },
-                    label: '',
-                    cachedStats: {},
-                },
-            };
+            const annotation = (this.createAnnotation(evt, [
+                [...worldPos],
+                [...worldPos],
+            ]));
             (0,annotationState.addAnnotation)(annotation, element);
             const viewportIdsToRender = (0,viewportFilters.getViewportIdsWithToolToRender)(element, this.getToolName());
             this.editData = {
@@ -37604,45 +37318,16 @@ class UltrasoundDirectionalTool extends base/* AnnotationTool */.EC {
             const { currentPoints, element } = eventDetail;
             const worldPos = currentPoints.world;
             const enabledElement = (0,esm.getEnabledElement)(element);
-            const { viewport, renderingEngine } = enabledElement;
+            const { viewport } = enabledElement;
             if (!(viewport instanceof esm.StackViewport)) {
                 throw new Error('UltrasoundDirectionalTool can only be used on a StackViewport');
             }
             (0,elementCursor.hideElementCursor)(element);
             this.isDrawing = true;
-            const camera = viewport.getCamera();
-            const { viewPlaneNormal, viewUp } = camera;
-            const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
-            const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-            const annotation = {
-                highlighted: true,
-                invalidated: true,
-                metadata: {
-                    toolName: this.getToolName(),
-                    viewPlaneNormal: [...viewPlaneNormal],
-                    viewUp: [...viewUp],
-                    FrameOfReferenceUID,
-                    referencedImageId,
-                },
-                data: {
-                    handles: {
-                        points: [[...worldPos], [...worldPos]],
-                        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],
-                            },
-                        },
-                    },
-                    label: '',
-                    cachedStats: {},
-                },
-            };
+            const annotation = (this.createAnnotation(evt, [
+                [...worldPos],
+                [...worldPos],
+            ]));
             (0,annotationState.addAnnotation)(annotation, element);
             const viewportIdsToRender = (0,viewportFilters.getViewportIdsWithToolToRender)(element, this.getToolName());
             this.editData = {
@@ -38863,14 +38548,14 @@ class KeyImageTool extends base/* AnnotationTool */.EC {
             const viewportIdsToRender = (0,viewportFilters.getViewportIdsWithToolToRender)(element, this.getToolName());
             evt.preventDefault();
             (0,triggerAnnotationRenderForViewportIds/* default */.A)(viewportIdsToRender);
-            this.configuration.getTextCallback((text) => {
-                if (!text) {
+            this.configuration.getTextCallback((label) => {
+                if (!label) {
                     (0,annotationState.removeAnnotation)(annotation.annotationUID);
                     (0,triggerAnnotationRenderForViewportIds/* default */.A)(viewportIdsToRender);
                     this.isDrawing = false;
                     return;
                 }
-                annotation.data.text = text;
+                annotation.data.label = label;
                 (0,helpers_state.triggerAnnotationCompleted)(annotation);
                 (0,triggerAnnotationRenderForViewportIds/* default */.A)(viewportIdsToRender);
             });
@@ -39046,7 +38731,7 @@ class KeyImageTool extends base/* AnnotationTool */.EC {
         (0,helpers_state.triggerAnnotationModified)(annotation, element);
     }
     _doneChangingTextCallback(element, annotation, updatedText) {
-        annotation.data.text = updatedText;
+        annotation.data.label = updatedText;
         const viewportIdsToRender = (0,viewportFilters.getViewportIdsWithToolToRender)(element, this.getToolName());
         (0,triggerAnnotationRenderForViewportIds/* default */.A)(viewportIdsToRender);
         (0,helpers_state.triggerAnnotationModified)(annotation, element);
@@ -40462,7 +40147,8 @@ class CircleROIStartEndThresholdTool extends annotation_CircleROITool {
             this._deactivateModify(element);
             this._deactivateDraw(element);
             (0,elementCursor.resetElementCursor)(element);
-            const enabledElement = (0,esm.getEnabledElement)(element);
+            const { metadata } = annotation;
+            const { enabledElement } = metadata;
             this.editData = null;
             this.isDrawing = false;
             if (this.isHandleOutsideImage &&
@@ -40498,6 +40184,7 @@ class CircleROIStartEndThresholdTool extends annotation_CircleROITool {
                 const { annotationUID, data, metadata } = annotation;
                 const { startCoordinate, endCoordinate } = data;
                 const { points, activeHandleIndex } = data.handles;
+                const { enabledElement: annotationEnabledElement } = metadata;
                 styleSpecifier.annotationUID = annotationUID;
                 const lineWidth = this.getStyle('lineWidth', styleSpecifier, annotation);
                 const lineDash = this.getStyle('lineDash', styleSpecifier, annotation);
@@ -40541,8 +40228,12 @@ class CircleROIStartEndThresholdTool extends annotation_CircleROITool {
                     isMiddleSlice = true;
                 }
                 data.handles.points[0][this._getIndexOfCoordinatesForViewplaneNormal(viewplaneNormal)] = middleCoordinate;
-                if (annotation.invalidated) {
-                    this._throttledCalculateCachedStats(annotation, enabledElement);
+                const iteratorVolumeIDs = annotationEnabledElement.viewport?.volumeIds.values();
+                for (const volumeId of iteratorVolumeIDs) {
+                    if (annotation.invalidated &&
+                        annotation.metadata.volumeId === volumeId) {
+                        this._throttledCalculateCachedStats(annotation, annotationEnabledElement);
+                    }
                 }
                 if (!viewport.getRenderingEngine()) {
                     console.warn('Rendering Engine has been destroyed');
@@ -40645,24 +40336,32 @@ class CircleROIStartEndThresholdTool extends annotation_CircleROITool {
         const { viewPlaneNormal, spacingInNormal } = metadata;
         const { startCoordinate, endCoordinate } = data;
         const { points } = data.handles;
-        const handlesToStart = esm.utilities.deepClone(points);
+        const projectionAxisIndex = this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal);
         const startWorld = gl_matrix_esm/* vec3.clone */.eR.clone(points[0]);
+        startWorld[projectionAxisIndex] = startCoordinate;
         const endWorld = gl_matrix_esm/* vec3.clone */.eR.clone(points[0]);
-        const indexOfNormal = this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal);
-        startWorld[indexOfNormal] = startCoordinate;
-        endWorld[indexOfNormal] = endCoordinate;
-        handlesToStart.forEach((handlePoint) => {
-            handlePoint[indexOfNormal] = startCoordinate;
-        });
-        const distance = gl_matrix_esm/* vec3.distance */.eR.distance(startWorld, endWorld);
-        const newProjectionPoints = [];
-        if (distance >= 0) {
-            newProjectionPoints.push(handlesToStart.map((p) => Array.from(p)));
+        endWorld[projectionAxisIndex] = endCoordinate;
+        const direction = gl_matrix_esm/* vec3.create */.eR.create();
+        gl_matrix_esm/* vec3.subtract */.eR.subtract(direction, endWorld, startWorld);
+        const distance = gl_matrix_esm/* vec3.length */.eR.length(direction);
+        if (distance === 0) {
+            const handlesOnStartPlane = points.map((p) => {
+                const newPoint = gl_matrix_esm/* vec3.clone */.eR.clone(p);
+                newPoint[projectionAxisIndex] = startCoordinate;
+                return Array.from(newPoint);
+            });
+            data.cachedStats.projectionPoints = [handlesOnStartPlane];
+            return;
         }
-        for (let dist = spacingInNormal; dist <= distance; dist += spacingInNormal) {
+        gl_matrix_esm/* vec3.normalize */.eR.normalize(direction, direction);
+        const handlesToStart = esm.utilities.deepClone(points);
+        handlesToStart[0][projectionAxisIndex] = startCoordinate;
+        handlesToStart[1][projectionAxisIndex] = startCoordinate;
+        const newProjectionPoints = [];
+        for (let dist = 0; dist <= distance + 1e-6; dist += spacingInNormal) {
             newProjectionPoints.push(handlesToStart.map((point) => {
                 const newPoint = gl_matrix_esm/* vec3.create */.eR.create();
-                gl_matrix_esm/* vec3.scaleAndAdd */.eR.scaleAndAdd(newPoint, point, viewPlaneNormal, dist);
+                gl_matrix_esm/* vec3.scaleAndAdd */.eR.scaleAndAdd(newPoint, point, direction, dist);
                 return Array.from(newPoint);
             }));
         }