@ohif/app 3.7.0-beta.76 → 3.7.0-beta.79

package/dist/{116.bundle.422d1a76d8daccfed61d.js → 777.bundle.82a7cc23a7b6a8bd12fa.js}

@@ -1,6 +1,6 @@
-(self["webpackChunk"] = self["webpackChunk"] || []).push([[116],{
+(self["webpackChunk"] = self["webpackChunk"] || []).push([[777],{
 
-/***/ 99116:
+/***/ 99777:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -3112,6 +3112,9 @@ async function addLabelmapToElement(element, volumeId, segmentationRepresentatio
 function removeLabelmapFromElement(element, segmentationRepresentationUID, removeFromCache = false) {
     const enabledElement = (0,esm.getEnabledElement)(element);
     const { viewport } = enabledElement;
+    if (viewport instanceof esm.StackViewport) {
+        return;
+    }
     viewport.removeVolumeActors([
         segmentationRepresentationUID,
     ]);
@@ -4511,12 +4514,14 @@ function setNewAttributesIfValid(attributes, svgNode) {
 
 
 function drawCircle(svgDrawingHelper, annotationUID, circleUID, center, radius, options = {}, dataId = '') {
-    const { color, fill, width, lineWidth, lineDash } = Object.assign({
+    const { color, fill, width, lineWidth, lineDash, fillOpacity, strokeOpacity, } = Object.assign({
         color: 'dodgerblue',
         fill: 'transparent',
         width: '2',
         lineDash: undefined,
         lineWidth: undefined,
+        strokeOpacity: 1,
+        fillOpacity: 1,
     }, options);
     const strokeWidth = lineWidth || width;
     const svgns = 'http://www.w3.org/2000/svg';
@@ -4530,6 +4535,8 @@ function drawCircle(svgDrawingHelper, annotationUID, circleUID, center, radius,
         fill,
         'stroke-width': strokeWidth,
         'stroke-dasharray': lineDash,
+        'fill-opacity': fillOpacity,
+        'stroke-opacity': strokeOpacity,
     };
     if (existingCircleElement) {
         drawingSvg_setAttributesIfNecessary(attributes, existingCircleElement);
@@ -5268,6 +5275,7 @@ class ToolStyle {
             lineWidth: '1',
             lineDash: '',
             shadow: true,
+            textBoxVisibility: true,
             textBoxFontFamily: 'Helvetica Neue, Helvetica, Arial, sans-serif',
             textBoxFontSize: '14px',
             textBoxColor: 'rgb(255, 255, 0)',
@@ -5558,20 +5566,22 @@ class AnnotationTool extends base_AnnotationDisplayTool {
         const { viewport } = enabledElement;
         const { data } = annotation;
         const { points, textBox } = data.handles;
-        const { worldBoundingBox } = textBox;
-        if (worldBoundingBox) {
-            const canvasBoundingBox = {
-                topLeft: viewport.worldToCanvas(worldBoundingBox.topLeft),
-                topRight: viewport.worldToCanvas(worldBoundingBox.topRight),
-                bottomLeft: viewport.worldToCanvas(worldBoundingBox.bottomLeft),
-                bottomRight: viewport.worldToCanvas(worldBoundingBox.bottomRight),
-            };
-            if (canvasCoords[0] >= canvasBoundingBox.topLeft[0] &&
-                canvasCoords[0] <= canvasBoundingBox.bottomRight[0] &&
-                canvasCoords[1] >= canvasBoundingBox.topLeft[1] &&
-                canvasCoords[1] <= canvasBoundingBox.bottomRight[1]) {
-                data.handles.activeHandleIndex = null;
-                return textBox;
+        if (textBox) {
+            const { worldBoundingBox } = textBox;
+            if (worldBoundingBox) {
+                const canvasBoundingBox = {
+                    topLeft: viewport.worldToCanvas(worldBoundingBox.topLeft),
+                    topRight: viewport.worldToCanvas(worldBoundingBox.topRight),
+                    bottomLeft: viewport.worldToCanvas(worldBoundingBox.bottomLeft),
+                    bottomRight: viewport.worldToCanvas(worldBoundingBox.bottomRight),
+                };
+                if (canvasCoords[0] >= canvasBoundingBox.topLeft[0] &&
+                    canvasCoords[0] <= canvasBoundingBox.bottomRight[0] &&
+                    canvasCoords[1] >= canvasBoundingBox.topLeft[1] &&
+                    canvasCoords[1] <= canvasBoundingBox.bottomRight[1]) {
+                    data.handles.activeHandleIndex = null;
+                    return textBox;
+                }
             }
         }
         for (let i = 0; i < points.length; i++) {
@@ -5587,6 +5597,7 @@ class AnnotationTool extends base_AnnotationDisplayTool {
     }
     getLinkedTextBoxStyle(specifications, annotation) {
         return {
+            visibility: this.getStyle('textBoxVisibility', specifications, annotation),
             fontFamily: this.getStyle('textBoxFontFamily', specifications, annotation),
             fontSize: this.getStyle('textBoxFontSize', specifications, annotation),
             color: this.getStyle('textBoxColor', specifications, annotation),
@@ -5664,13 +5675,12 @@ class SegmentationDisplayTool extends base_BaseTool {
             const segmentationRenderList = toolGroupSegmentationRepresentations.map((representation) => {
                 const config = this._getMergedRepresentationsConfig(toolGroupId);
                 const viewportsRenderList = [];
+                const display = representation.type === enums_SegmentationRepresentations.Labelmap
+                    ? labelmapDisplay
+                    : contourDisplay;
                 for (const viewport of toolGroupViewports) {
-                    if (representation.type == enums_SegmentationRepresentations.Labelmap) {
-                        viewportsRenderList.push(labelmapDisplay.render(viewport, representation, config));
-                    }
-                    else if (representation.type == enums_SegmentationRepresentations.Contour) {
-                        viewportsRenderList.push(contourDisplay.render(viewport, representation, config));
-                    }
+                    const renderedViewport = display.render(viewport, representation, config);
+                    viewportsRenderList.push(renderedViewport);
                 }
                 return viewportsRenderList;
             });
@@ -6459,22 +6469,47 @@ function roundNumber(value, precision = 2) {
 }
 /* harmony default export */ const utilities_roundNumber = (roundNumber);
 
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/utils/isWithinThreshold.js
+function isWithinThreshold(index, imageVolume, strategySpecificConfiguration) {
+    const { THRESHOLD_INSIDE_CIRCLE } = strategySpecificConfiguration;
+    const voxelValue = imageVolume.getScalarData()[index];
+    const { threshold } = THRESHOLD_INSIDE_CIRCLE;
+    return threshold[0] <= voxelValue && voxelValue <= threshold[1];
+}
+/* harmony default export */ const utils_isWithinThreshold = (isWithinThreshold);
+
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/fillSphere.js
 
 
-function fillSphere(enabledElement, operationData, _inside = true) {
+
+
+function fillSphere(enabledElement, operationData, _inside = true, threshold = false) {
     const { viewport } = enabledElement;
-    const { volume: segmentation, segmentsLocked, segmentIndex, segmentationId, points, } = operationData;
+    const { volume: segmentation, segmentsLocked, segmentIndex, imageVolume, strategySpecificConfiguration, segmentationId, points, } = operationData;
     const { imageData, dimensions } = segmentation;
     const scalarData = segmentation.getScalarData();
     const scalarIndex = [];
-    const callback = ({ index, value }) => {
-        if (segmentsLocked.includes(value)) {
-            return;
-        }
-        scalarData[index] = segmentIndex;
-        scalarIndex.push(index);
-    };
+    let callback;
+    if (threshold) {
+        callback = ({ value, index, pointIJK }) => {
+            if (segmentsLocked.includes(value)) {
+                return;
+            }
+            if (utils_isWithinThreshold(index, imageVolume, strategySpecificConfiguration)) {
+                scalarData[index] = segmentIndex;
+                scalarIndex.push(index);
+            }
+        };
+    }
+    else {
+        callback = ({ index, value }) => {
+            if (segmentsLocked.includes(value)) {
+                return;
+            }
+            scalarData[index] = segmentIndex;
+            scalarIndex.push(index);
+        };
+    }
     pointInSurroundingSphereCallback(imageData, [points[0], points[1]], callback, viewport);
     const zMultiple = dimensions[0] * dimensions[1];
     const minSlice = Math.floor(scalarIndex[0] / zMultiple);
@@ -6485,6 +6520,14 @@ function fillSphere(enabledElement, operationData, _inside = true) {
 function fillInsideSphere(enabledElement, operationData) {
     fillSphere(enabledElement, operationData, true);
 }
+function thresholdInsideSphere(enabledElement, operationData) {
+    const { volume, imageVolume } = operationData;
+    if (!esm.utilities.isEqual(volume.dimensions, imageVolume.dimensions) ||
+        !esm.utilities.isEqual(volume.direction, imageVolume.direction)) {
+        throw new Error('Only source data the same dimensions/size/orientation as the segmentation currently supported.');
+    }
+    fillSphere(enabledElement, operationData, true, true);
+}
 function fillOutsideSphere(enabledElement, operationData) {
     fillSphere(enabledElement, operationData, false);
 }
@@ -6536,6 +6579,7 @@ function getCanvasEllipseCorners(ellipseCanvasPoints) {
 
 
 
+
 const { transformWorldToIndex: fillCircle_transformWorldToIndex } = esm.utilities;
 function fillCircle(enabledElement, operationData, threshold = false) {
     const { volume: segmentationVolume, imageVolume, points, segmentsLocked, segmentIndex, segmentationId, strategySpecificConfiguration, } = operationData;
@@ -6569,7 +6613,7 @@ function fillCircle(enabledElement, operationData, threshold = false) {
             if (segmentsLocked.includes(value)) {
                 return;
             }
-            if (isWithinThreshold(index, imageVolume, strategySpecificConfiguration)) {
+            if (utils_isWithinThreshold(index, imageVolume, strategySpecificConfiguration)) {
                 scalarData[index] = segmentIndex;
                 modifiedSlicesToUse.add(pointIJK[2]);
             }
@@ -6588,12 +6632,6 @@ function fillCircle(enabledElement, operationData, threshold = false) {
     const arrayOfSlices = Array.from(modifiedSlicesToUse);
     triggerSegmentationDataModified(segmentationId, arrayOfSlices);
 }
-function isWithinThreshold(index, imageVolume, strategySpecificConfiguration) {
-    const { THRESHOLD_INSIDE_CIRCLE } = strategySpecificConfiguration;
-    const voxelValue = imageVolume.getScalarData()[index];
-    const { threshold } = THRESHOLD_INSIDE_CIRCLE;
-    return threshold[0] <= voxelValue && voxelValue <= threshold[1];
-}
 function fillInsideCircle(enabledElement, operationData) {
     fillCircle(enabledElement, operationData, false);
 }
@@ -7281,16 +7319,18 @@ function _getElementCursors(element) {
 
 
 
+
 class BrushTool extends base_BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
             strategies: {
                 FILL_INSIDE_CIRCLE: fillInsideCircle,
-                THRESHOLD_INSIDE_CIRCLE: thresholdInsideCircle,
                 ERASE_INSIDE_CIRCLE: eraseInsideCircle,
                 FILL_INSIDE_SPHERE: fillInsideSphere,
                 ERASE_INSIDE_SPHERE: eraseInsideSphere,
+                THRESHOLD_INSIDE_CIRCLE: thresholdInsideCircle,
+                THRESHOLD_INSIDE_SPHERE: thresholdInsideSphere,
             },
             strategySpecificConfiguration: {
                 THRESHOLD_INSIDE_CIRCLE: {
@@ -7467,31 +7507,36 @@ class BrushTool extends base_BaseTool {
         const enabledElement = (0,esm.getEnabledElement)(element);
         const { viewport } = enabledElement;
         const { canvasToWorld } = viewport;
+        const camera = viewport.getCamera();
         const { brushSize } = this.configuration;
-        const radius = brushSize;
-        const bottomCanvas = [
+        const viewUp = gl_matrix_esm/* vec3.fromValues */.R3.fromValues(camera.viewUp[0], camera.viewUp[1], camera.viewUp[2]);
+        const viewPlaneNormal = gl_matrix_esm/* vec3.fromValues */.R3.fromValues(camera.viewPlaneNormal[0], camera.viewPlaneNormal[1], camera.viewPlaneNormal[2]);
+        const viewRight = gl_matrix_esm/* vec3.create */.R3.create();
+        gl_matrix_esm/* vec3.cross */.R3.cross(viewRight, viewUp, viewPlaneNormal);
+        const centerCursorInWorld = canvasToWorld([
             centerCanvas[0],
-            centerCanvas[1] + radius,
-        ];
-        const topCanvas = [centerCanvas[0], centerCanvas[1] - radius];
-        const leftCanvas = [
-            centerCanvas[0] - radius,
-            centerCanvas[1],
-        ];
-        const rightCanvas = [
-            centerCanvas[0] + radius,
             centerCanvas[1],
-        ];
+        ]);
+        const bottomCursorInWorld = gl_matrix_esm/* vec3.create */.R3.create();
+        const topCursorInWorld = gl_matrix_esm/* vec3.create */.R3.create();
+        const leftCursorInWorld = gl_matrix_esm/* vec3.create */.R3.create();
+        const rightCursorInWorld = gl_matrix_esm/* vec3.create */.R3.create();
+        for (let i = 0; i <= 2; i++) {
+            bottomCursorInWorld[i] = centerCursorInWorld[i] - viewUp[i] * brushSize;
+            topCursorInWorld[i] = centerCursorInWorld[i] + viewUp[i] * brushSize;
+            leftCursorInWorld[i] = centerCursorInWorld[i] - viewRight[i] * brushSize;
+            rightCursorInWorld[i] = centerCursorInWorld[i] + viewRight[i] * brushSize;
+        }
         const { brushCursor } = this._hoverData;
         const { data } = brushCursor;
         if (data.handles === undefined) {
             data.handles = {};
         }
         data.handles.points = [
-            canvasToWorld(bottomCanvas),
-            canvasToWorld(topCanvas),
-            canvasToWorld(leftCanvas),
-            canvasToWorld(rightCanvas),
+            bottomCursorInWorld,
+            topCursorInWorld,
+            leftCursorInWorld,
+            rightCursorInWorld,
         ];
         data.invalidated = false;
     }
@@ -7547,7 +7592,7 @@ BrushTool.toolName = 'Brush';
 
 
 
-function getBrushToolInstances(toolGroupId) {
+function getBrushToolInstances(toolGroupId, toolName) {
     const toolGroup = ToolGroupManager_getToolGroup(toolGroupId);
     if (toolGroup === undefined) {
         return;
@@ -7556,6 +7601,9 @@ function getBrushToolInstances(toolGroupId) {
     if (!Object.keys(toolInstances).length) {
         return;
     }
+    if (toolName && toolInstances[toolName]) {
+        return [toolInstances[toolName]];
+    }
     const brushBasedToolInstances = Object.values(toolInstances).filter((toolInstance) => toolInstance instanceof segmentation_BrushTool);
     return brushBasedToolInstances;
 }
@@ -11181,6 +11229,20 @@ class BidirectionalTool extends base_AnnotationTool {
                     shadow,
                 }, dataId2);
                 renderStatus = true;
+                const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+                if (!options.visibility) {
+                    data.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],
+                        },
+                    };
+                    continue;
+                }
                 const textLines = this.configuration.getTextLines(data, targetId);
                 if (!textLines || textLines.length === 0) {
                     continue;
@@ -11193,7 +11255,7 @@ class BidirectionalTool extends base_AnnotationTool {
                 }
                 const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
                 const textBoxUID = '1';
-                const boundingBox = drawingSvg_drawLinkedTextBox(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, this.getLinkedTextBoxStyle(styleSpecifier, annotation));
+                const boundingBox = drawingSvg_drawLinkedTextBox(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, options);
                 const { x: left, y: top, width, height } = boundingBox;
                 data.handles.textBox.worldBoundingBox = {
                     topLeft: viewport.canvasToWorld([left, top]),
@@ -11682,6 +11744,20 @@ class LengthTool extends base_AnnotationTool {
                     console.warn('Rendering Engine has been destroyed');
                     return renderStatus;
                 }
+                const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+                if (!options.visibility) {
+                    data.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],
+                        },
+                    };
+                    continue;
+                }
                 const textLines = this.configuration.getTextLines(data, targetId);
                 if (!data.handles.textBox.hasMoved) {
                     const canvasTextBoxCoords = getTextBoxCoordsCanvas(canvasCoordinates);
@@ -11690,7 +11766,7 @@ class LengthTool extends base_AnnotationTool {
                 }
                 const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
                 const textBoxUID = '1';
-                const boundingBox = drawingSvg_drawLinkedTextBox(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, this.getLinkedTextBoxStyle(styleSpecifier, annotation));
+                const boundingBox = drawingSvg_drawLinkedTextBox(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, options);
                 const { x: left, y: top, width, height } = boundingBox;
                 data.handles.textBox.worldBoundingBox = {
                     topLeft: viewport.canvasToWorld([left, top]),
@@ -12044,6 +12120,10 @@ class ProbeTool extends base_AnnotationTool {
                 const handleGroupUID = '0';
                 drawingSvg_drawHandles(svgDrawingHelper, annotationUID, handleGroupUID, [canvasCoordinates], { color });
                 renderStatus = true;
+                const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+                if (!options.visibility) {
+                    continue;
+                }
                 const textLines = this.configuration.getTextLines(data, targetId);
                 if (textLines) {
                     const textCanvasCoordinates = [
@@ -12051,7 +12131,7 @@ class ProbeTool extends base_AnnotationTool {
                         canvasCoordinates[1] - 6,
                     ];
                     const textUID = '0';
-                    drawingSvg_drawTextBox(svgDrawingHelper, annotationUID, textUID, textLines, [textCanvasCoordinates[0], textCanvasCoordinates[1]], this.getLinkedTextBoxStyle(styleSpecifier, annotation));
+                    drawingSvg_drawTextBox(svgDrawingHelper, annotationUID, textUID, textLines, [textCanvasCoordinates[0], textCanvasCoordinates[1]], options);
                 }
             }
             return renderStatus;
@@ -12808,6 +12888,20 @@ class RectangleROITool extends base_AnnotationTool {
                     lineWidth,
                 }, dataId);
                 renderStatus = true;
+                const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+                if (!options.visibility) {
+                    data.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],
+                        },
+                    };
+                    continue;
+                }
                 const textLines = this.configuration.getTextLines(data, targetId);
                 if (!textLines || textLines.length === 0) {
                     continue;
@@ -12819,7 +12913,7 @@ class RectangleROITool extends base_AnnotationTool {
                 }
                 const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
                 const textBoxUID = '1';
-                const boundingBox = drawingSvg_drawLinkedTextBox(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, this.getLinkedTextBoxStyle(styleSpecifier, annotation));
+                const boundingBox = drawingSvg_drawLinkedTextBox(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, options);
                 const { x: left, y: top, width, height } = boundingBox;
                 data.handles.textBox.worldBoundingBox = {
                     topLeft: viewport.canvasToWorld([left, top]),
@@ -13473,6 +13567,20 @@ class EllipticalROITool extends base_AnnotationTool {
                     }
                 }
                 renderStatus = true;
+                const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+                if (!options.visibility) {
+                    data.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],
+                        },
+                    };
+                    continue;
+                }
                 const textLines = this.configuration.getTextLines(data, targetId);
                 if (!textLines || textLines.length === 0) {
                     continue;
@@ -13485,7 +13593,7 @@ class EllipticalROITool extends base_AnnotationTool {
                 }
                 const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
                 const textBoxUID = '1';
-                const boundingBox = drawingSvg_drawLinkedTextBox(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, this.getLinkedTextBoxStyle(styleSpecifier, annotation));
+                const boundingBox = drawingSvg_drawLinkedTextBox(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, options);
                 const { x: left, y: top, width, height } = boundingBox;
                 data.handles.textBox.worldBoundingBox = {
                     topLeft: viewport.canvasToWorld([left, top]),
@@ -14108,6 +14216,20 @@ class CircleROITool extends base_AnnotationTool {
                     }
                 }
                 renderStatus = true;
+                const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+                if (!options.visibility) {
+                    data.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],
+                        },
+                    };
+                    continue;
+                }
                 const textLines = this.configuration.getTextLines(data, targetId);
                 if (!textLines || textLines.length === 0) {
                     continue;
@@ -14120,7 +14242,7 @@ class CircleROITool extends base_AnnotationTool {
                 }
                 const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
                 const textBoxUID = '1';
-                const boundingBox = drawingSvg_drawLinkedTextBox(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, this.getLinkedTextBoxStyle(styleSpecifier, annotation));
+                const boundingBox = drawingSvg_drawLinkedTextBox(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, options);
                 const { x: left, y: top, width, height } = boundingBox;
                 data.handles.textBox.worldBoundingBox = {
                     topLeft: viewport.canvasToWorld([left, top]),
@@ -16338,6 +16460,15 @@ class PlanarFreehandROITool extends base_AnnotationTool {
         this._renderStats = (annotation, viewport, enabledElement, svgDrawingHelper) => {
             const data = annotation.data;
             const targetId = this.getTargetId(viewport);
+            const styleSpecifier = {
+                toolGroupId: this.toolGroupId,
+                toolName: this.getToolName(),
+                viewportId: enabledElement.viewport.id,
+            };
+            const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+            if (!options.visibility) {
+                return;
+            }
             const textLines = this.configuration.getTextLines(data, targetId);
             if (!textLines || textLines.length === 0) {
                 return;
@@ -16349,13 +16480,8 @@ class PlanarFreehandROITool extends base_AnnotationTool {
                     viewport.canvasToWorld(canvasTextBoxCoords);
             }
             const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
-            const styleSpecifier = {
-                toolGroupId: this.toolGroupId,
-                toolName: this.getToolName(),
-                viewportId: enabledElement.viewport.id,
-            };
             const textBoxUID = '1';
-            const boundingBox = drawingSvg_drawLinkedTextBox(svgDrawingHelper, annotation.annotationUID ?? '', textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, this.getLinkedTextBoxStyle(styleSpecifier, annotation));
+            const boundingBox = drawingSvg_drawLinkedTextBox(svgDrawingHelper, annotation.annotationUID ?? '', textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, options);
             const { x: left, y: top, width, height } = boundingBox;
             data.handles.textBox.worldBoundingBox = {
                 topLeft: viewport.canvasToWorld([left, top]),
@@ -16803,6 +16929,20 @@ class ArrowAnnotateTool extends base_AnnotationTool {
                 if (!text) {
                     continue;
                 }
+                const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+                if (!options.visibility) {
+                    data.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],
+                        },
+                    };
+                    continue;
+                }
                 if (!data.handles.textBox.hasMoved) {
                     const canvasTextBoxCoords = canvasCoordinates[1];
                     data.handles.textBox.worldPosition =
@@ -16810,7 +16950,7 @@ class ArrowAnnotateTool extends base_AnnotationTool {
                 }
                 const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
                 const textBoxUID = '1';
-                const boundingBox = drawingSvg_drawLinkedTextBox(svgDrawingHelper, annotationUID, textBoxUID, [text], textBoxPosition, canvasCoordinates, {}, this.getLinkedTextBoxStyle(styleSpecifier, annotation));
+                const boundingBox = drawingSvg_drawLinkedTextBox(svgDrawingHelper, annotationUID, textBoxUID, [text], textBoxPosition, canvasCoordinates, {}, options);
                 const { x: left, y: top, width, height } = boundingBox;
                 data.handles.textBox.worldBoundingBox = {
                     topLeft: viewport.canvasToWorld([left, top]),
@@ -17227,6 +17367,20 @@ class AngleTool extends base_AnnotationTool {
                 if (!data.cachedStats[targetId]?.angle) {
                     continue;
                 }
+                const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+                if (!options.visibility) {
+                    data.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],
+                        },
+                    };
+                    continue;
+                }
                 const textLines = this.configuration.getTextLines(data, targetId);
                 if (!data.handles.textBox.hasMoved) {
                     const canvasTextBoxCoords = canvasCoordinates[1];
@@ -17235,7 +17389,7 @@ class AngleTool extends base_AnnotationTool {
                 }
                 const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
                 const textBoxUID = '1';
-                const boundingBox = drawingSvg_drawLinkedTextBox(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, this.getLinkedTextBoxStyle(styleSpecifier, annotation));
+                const boundingBox = drawingSvg_drawLinkedTextBox(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, options);
                 const { x: left, y: top, width, height } = boundingBox;
                 data.handles.textBox.worldBoundingBox = {
                     topLeft: viewport.canvasToWorld([left, top]),
@@ -17290,7 +17444,7 @@ class AngleTool extends base_AnnotationTool {
             const targetId = targetIds[i];
             const angle = angleBetweenLines([worldPos1, worldPos2], [worldPos2, worldPos3]);
             cachedStats[targetId] = {
-                angle,
+                angle: isNaN(angle) ? 'Incomplete Angle' : angle,
             };
         }
         annotation.invalidated = false;
@@ -17707,6 +17861,20 @@ class CobbAngleTool extends base_AnnotationTool {
                 if (!data.cachedStats[targetId]?.angle) {
                     continue;
                 }
+                const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+                if (!options.visibility) {
+                    data.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],
+                        },
+                    };
+                    continue;
+                }
                 const textLines = this.configuration.getTextLines(data, targetId);
                 if (!data.handles.textBox.hasMoved) {
                     const canvasTextBoxCoords = getTextBoxCoordsCanvas(canvasCoordinates);
@@ -17715,7 +17883,7 @@ class CobbAngleTool extends base_AnnotationTool {
                 }
                 const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
                 const textBoxUID = '1';
-                const boundingBox = drawingSvg_drawLinkedTextBox(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, this.getLinkedTextBoxStyle(styleSpecifier, annotation));
+                const boundingBox = drawingSvg_drawLinkedTextBox(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, options);
                 const { x: left, y: top, width, height } = boundingBox;
                 data.handles.textBox.worldBoundingBox = {
                     topLeft: viewport.canvasToWorld([left, top]),
@@ -20173,12 +20341,12 @@ async function createLabelmapVolumeForViewport(input) {
 
 
 
-function setBrushSizeForToolGroup(toolGroupId, brushSize) {
+function setBrushSizeForToolGroup(toolGroupId, brushSize, toolName) {
     const toolGroup = ToolGroupManager_getToolGroup(toolGroupId);
     if (toolGroup === undefined) {
         return;
     }
-    const brushBasedToolInstances = getBrushToolInstances(toolGroupId);
+    const brushBasedToolInstances = getBrushToolInstances(toolGroupId, toolName);
     brushBasedToolInstances.forEach((tool) => {
         tool.configuration.brushSize = brushSize;
         tool.invalidateBrushCursor();
@@ -20193,7 +20361,7 @@ function setBrushSizeForToolGroup(toolGroupId, brushSize) {
     const renderingEngine = (0,esm.getRenderingEngine)(renderingEngineId);
     utilities_triggerAnnotationRenderForViewportIds(renderingEngine, viewportIds);
 }
-function getBrushSizeForToolGroup(toolGroupId) {
+function getBrushSizeForToolGroup(toolGroupId, toolName) {
     const toolGroup = ToolGroupManager_getToolGroup(toolGroupId);
     if (toolGroup === undefined) {
         return;
@@ -20202,7 +20370,7 @@ function getBrushSizeForToolGroup(toolGroupId) {
     if (!Object.keys(toolInstances).length) {
         return;
     }
-    const brushBasedToolInstances = getBrushToolInstances(toolGroupId);
+    const brushBasedToolInstances = getBrushToolInstances(toolGroupId, toolName);
     const brushToolInstance = brushBasedToolInstances[0];
     if (!brushToolInstance) {
         return;
@@ -20408,6 +20576,7 @@ function getToolState(element) {
 
 
 
+const { ViewportStatus } = esm.Enums;
 const { triggerEvent } = esm.utilities;
 const debounced = true;
 const loop = true;
@@ -20590,7 +20759,7 @@ function _getVolumeFromViewport(viewport) {
     const dynamicVolume = volumes.find((volume) => volume.isDynamicVolume());
     return dynamicVolume ?? volumes[0];
 }
-function _createStackViewportCinePlayContext(viewport) {
+function _createStackViewportCinePlayContext(viewport, waitForRendered) {
     const imageIds = viewport.getImageIds();
     return {
         get numScrollSteps() {
@@ -20602,7 +20771,14 @@ function _createStackViewportCinePlayContext(viewport) {
         get frameTimeVectorEnabled() {
             return true;
         },
+        waitForRenderedCount: 0,
         scroll(delta) {
+            if (this.waitForRenderedCount <= waitForRendered &&
+                viewport.viewportStatus !== ViewportStatus.RENDERED) {
+                this.waitForRenderedCount++;
+                return;
+            }
+            this.waitForRenderedCount = 0;
             scroll_scroll(viewport, { delta, debounceLoading: debounced });
         },
     };
@@ -20663,7 +20839,7 @@ function _createDynamicVolumeViewportCinePlayContext(volume) {
 }
 function _createCinePlayContext(viewport, playClipOptions) {
     if (viewport instanceof esm.StackViewport) {
-        return _createStackViewportCinePlayContext(viewport);
+        return _createStackViewportCinePlayContext(viewport, playClipOptions.waitForRendered ?? 30);
     }
     if (viewport instanceof esm.VolumeViewport) {
         const volume = _getVolumeFromViewport(viewport);
@@ -20757,7 +20933,7 @@ const priority = 0;
 const addToBeginning = true;
 let configuration = {
     maxImagesToPrefetch: Infinity,
-    preserveExistingPool: false,
+    preserveExistingPool: true,
 };
 let resetPrefetchTimeout;
 const resetPrefetchDelay = 10;
@@ -22277,6 +22453,7 @@ class Synchronizer {
             return;
         }
         this._ignoreFiredEvents = true;
+        const promises = [];
         try {
             for (let i = 0; i < this._targetViewports.length; i++) {
                 const targetViewport = this._targetViewports[i];
@@ -22284,14 +22461,21 @@ class Synchronizer {
                 if (targetIsSource) {
                     continue;
                 }
-                this._eventHandler(this, sourceViewport, targetViewport, sourceEvent, this._options);
+                promises.push(this._eventHandler(this, sourceViewport, targetViewport, sourceEvent, this._options));
             }
         }
         catch (ex) {
             console.warn(`Synchronizer, for: ${this._eventName}`, ex);
         }
         finally {
-            this._ignoreFiredEvents = false;
+            if (promises.length) {
+                Promise.allSettled(promises).then(() => {
+                    this._ignoreFiredEvents = false;
+                });
+            }
+            else {
+                this._ignoreFiredEvents = false;
+            }
         }
     }
     _hasSourceElements() {
@@ -22732,7 +22916,7 @@ class ToolGroup {
             _configuration = configuration;
         }
         else {
-            _configuration = esm.utilities.deepMerge(this._toolInstances[toolName].configuration, configuration);
+            _configuration = Object.assign(this._toolInstances[toolName].configuration, configuration);
         }
         this._toolInstances[toolName].configuration = _configuration;
         this._renderViewports();
@@ -23069,7 +23253,7 @@ function voiSyncCallback(synchronizerInstance, sourceViewport, targetViewport, v
     const tProperties = {
         voiRange: range,
     };
-    if (options.syncInvertState && invertStateChanged) {
+    if (options?.syncInvertState && invertStateChanged) {
         tProperties.invert = invert;
     }
     if (tViewport instanceof esm.BaseVolumeViewport) {
@@ -23138,15 +23322,18 @@ function areViewportsCoplanar(viewport1, viewport2) {
 
 
 
+const getSpatialRegistration = (targetId, sourceId) => esm.utilities.spatialRegistrationMetadataProvider.get('spatialRegistrationModule', [targetId, sourceId]);
 async function stackImageSyncCallback(synchronizerInstance, sourceViewport, targetViewport) {
     const renderingEngine = (0,esm.getRenderingEngine)(targetViewport.renderingEngineId);
     if (!renderingEngine) {
         throw new Error(`No RenderingEngine for Id: ${targetViewport.renderingEngineId}`);
     }
     const sViewport = renderingEngine.getViewport(sourceViewport.viewportId);
+    const options = synchronizerInstance.getOptions(targetViewport.viewportId);
+    if (options?.disabled) {
+        return;
+    }
     const tViewport = renderingEngine.getViewport(targetViewport.viewportId);
-    const frameOfReferenceUID1 = sViewport.getFrameOfReferenceUID();
-    const frameOfReferenceUID2 = tViewport.getFrameOfReferenceUID();
     const imageId1 = sViewport.getCurrentImageId();
     const imagePlaneModule1 = esm.metaData.get('imagePlaneModule', imageId1);
     const sourceImagePositionPatient = imagePlaneModule1.imagePositionPatient;
@@ -23154,30 +23341,30 @@ async function stackImageSyncCallback(synchronizerInstance, sourceViewport, targ
     if (!areViewportsCoplanar(sViewport, tViewport)) {
         return;
     }
-    if (frameOfReferenceUID1 === frameOfReferenceUID2) {
-        const closestImageIdIndex = _getClosestImageIdIndex(sourceImagePositionPatient, targetImageIds);
-        if (closestImageIdIndex.index !== -1 &&
-            tViewport.getCurrentImageIdIndex() !== closestImageIdIndex.index) {
-            await viewport_jumpToSlice(tViewport.element, {
-                imageIndex: closestImageIdIndex.index,
-            });
-            return;
+    let registrationMatrixMat4 = getSpatialRegistration(targetViewport.viewportId, sourceViewport.viewportId);
+    if (!registrationMatrixMat4) {
+        const frameOfReferenceUID1 = sViewport.getFrameOfReferenceUID();
+        const frameOfReferenceUID2 = tViewport.getFrameOfReferenceUID();
+        if (frameOfReferenceUID1 === frameOfReferenceUID2 &&
+            options.useInitialPosition !== false) {
+            registrationMatrixMat4 = gl_matrix_esm/* mat4.identity */._E.identity(gl_matrix_esm/* mat4.create */._E.create());
+        }
+        else {
+            esm.utilities.calculateViewportsSpatialRegistration(sViewport, tViewport);
+            registrationMatrixMat4 = getSpatialRegistration(targetViewport.viewportId, sourceViewport.viewportId);
         }
-    }
-    else {
-        const registrationMatrixMat4 = esm.utilities.spatialRegistrationMetadataProvider.get('spatialRegistrationModule', [targetViewport.viewportId, sourceViewport.viewportId]);
         if (!registrationMatrixMat4) {
-            throw new Error(`No registration matrix found for sourceViewport: ${sourceViewport.viewportId} and targetViewport: ${targetViewport.viewportId}, viewports with different frameOfReferenceUIDs must have a registration matrix in the registrationMetadataProvider. Use calculateViewportsRegistrationMatrix to calculate the matrix.`);
-        }
-        const targetImagePositionPatientWithRegistrationMatrix = gl_matrix_esm/* vec3.transformMat4 */.R3.transformMat4(gl_matrix_esm/* vec3.create */.R3.create(), sourceImagePositionPatient, registrationMatrixMat4);
-        const closestImageIdIndex2 = _getClosestImageIdIndex(targetImagePositionPatientWithRegistrationMatrix, targetImageIds);
-        if (closestImageIdIndex2.index !== -1 &&
-            tViewport.getCurrentImageIdIndex() !== closestImageIdIndex2.index) {
-            await viewport_jumpToSlice(tViewport.element, {
-                imageIndex: closestImageIdIndex2.index,
-            });
+            return;
         }
     }
+    const targetImagePositionPatientWithRegistrationMatrix = gl_matrix_esm/* vec3.transformMat4 */.R3.transformMat4(gl_matrix_esm/* vec3.create */.R3.create(), sourceImagePositionPatient, registrationMatrixMat4);
+    const closestImageIdIndex2 = _getClosestImageIdIndex(targetImagePositionPatientWithRegistrationMatrix, targetImageIds);
+    if (closestImageIdIndex2.index !== -1 &&
+        tViewport.getCurrentImageIdIndex() !== closestImageIdIndex2.index) {
+        await viewport_jumpToSlice(tViewport.element, {
+            imageIndex: closestImageIdIndex2.index,
+        });
+    }
 }
 function _getClosestImageIdIndex(targetPoint, imageIds) {
     return imageIds.reduce((closestImageIdIndex, imageId, index) => {