@ohif/app 3.9.1 → 3.9.3

package/dist/{5717.bundle.848e13f256818475f57f.js → 5717.bundle.9218cb67ad1994cd1a99.js}

@@ -3489,6 +3489,15 @@ const imageRetrieveMetadataProvider = {
     add: (key, payload) => {
         retrieveConfigurationState.set(key, payload);
     },
+    clone: () => {
+        return new Map(retrieveConfigurationState);
+    },
+    restore: (state) => {
+        retrieveConfigurationState.clear();
+        state.forEach((value, key) => {
+            retrieveConfigurationState.set(key, value);
+        });
+    },
     get: (type, ...queries) => {
         if (type === IMAGE_RETRIEVE_CONFIGURATION) {
             return queries
@@ -4414,7 +4423,10 @@ function calculateViewportsSpatialRegistration(viewport1, viewport2) {
 
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/getViewportImageCornersInWorld.js
 function getViewportImageCornersInWorld(viewport) {
-    const { imageData, dimensions } = viewport.getImageData();
+    const { imageData, dimensions } = viewport.getImageData() || {};
+    if (!imageData || !dimensions) {
+        return [];
+    }
     const { canvas } = viewport;
     const ratio = window.devicePixelRatio;
     const topLeftCanvas = [0, 0];
@@ -7891,6 +7903,24 @@ var Events;
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Events);
 
 
+/***/ }),
+
+/***/ 18682:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+var SegmentationRepresentations;
+(function (SegmentationRepresentations) {
+    SegmentationRepresentations["Labelmap"] = "Labelmap";
+    SegmentationRepresentations["Contour"] = "Contour";
+    SegmentationRepresentations["Surface"] = "Surface";
+})(SegmentationRepresentations || (SegmentationRepresentations = {}));
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (SegmentationRepresentations);
+
+
 /***/ }),
 
 /***/ 84093:
@@ -7917,6 +7947,46 @@ var StrategyCallbacks;
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (StrategyCallbacks);
 
 
+/***/ }),
+
+/***/ 66452:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   i: () => (/* binding */ MouseBindings),
+/* harmony export */   q: () => (/* binding */ KeyboardBindings)
+/* harmony export */ });
+var MouseBindings;
+(function (MouseBindings) {
+    MouseBindings[MouseBindings["Primary"] = 1] = "Primary";
+    MouseBindings[MouseBindings["Secondary"] = 2] = "Secondary";
+    MouseBindings[MouseBindings["Primary_And_Secondary"] = 3] = "Primary_And_Secondary";
+    MouseBindings[MouseBindings["Auxiliary"] = 4] = "Auxiliary";
+    MouseBindings[MouseBindings["Primary_And_Auxiliary"] = 5] = "Primary_And_Auxiliary";
+    MouseBindings[MouseBindings["Secondary_And_Auxiliary"] = 6] = "Secondary_And_Auxiliary";
+    MouseBindings[MouseBindings["Primary_And_Secondary_And_Auxiliary"] = 7] = "Primary_And_Secondary_And_Auxiliary";
+    MouseBindings[MouseBindings["Fourth_Button"] = 8] = "Fourth_Button";
+    MouseBindings[MouseBindings["Fifth_Button"] = 16] = "Fifth_Button";
+    MouseBindings[MouseBindings["Wheel"] = 524288] = "Wheel";
+    MouseBindings[MouseBindings["Wheel_Primary"] = 524289] = "Wheel_Primary";
+})(MouseBindings || (MouseBindings = {}));
+var KeyboardBindings;
+(function (KeyboardBindings) {
+    KeyboardBindings[KeyboardBindings["Shift"] = 16] = "Shift";
+    KeyboardBindings[KeyboardBindings["Ctrl"] = 17] = "Ctrl";
+    KeyboardBindings[KeyboardBindings["Alt"] = 18] = "Alt";
+    KeyboardBindings[KeyboardBindings["Meta"] = 91] = "Meta";
+    KeyboardBindings[KeyboardBindings["ShiftCtrl"] = 1617] = "ShiftCtrl";
+    KeyboardBindings[KeyboardBindings["ShiftAlt"] = 1618] = "ShiftAlt";
+    KeyboardBindings[KeyboardBindings["ShiftMeta"] = 1691] = "ShiftMeta";
+    KeyboardBindings[KeyboardBindings["CtrlAlt"] = 1718] = "CtrlAlt";
+    KeyboardBindings[KeyboardBindings["CtrlMeta"] = 1791] = "CtrlMeta";
+    KeyboardBindings[KeyboardBindings["AltMeta"] = 1891] = "AltMeta";
+})(KeyboardBindings || (KeyboardBindings = {}));
+
+
+
 /***/ }),
 
 /***/ 49892:
@@ -9322,6 +9392,9 @@ class Synchronizer_Synchronizer {
         };
         viewports.forEach((vp) => {
             const eventSource = this.getEventSource(vp);
+            if (!eventSource) {
+                return;
+            }
             eventSource.removeEventListener(Enums.Events.ELEMENT_DISABLED, disableHandler);
             eventSource.addEventListener(Enums.Events.ELEMENT_DISABLED, disableHandler);
         });
@@ -9335,9 +9408,13 @@ class Synchronizer_Synchronizer {
         const { renderingEngineId, viewportId } = viewportInfo;
         const renderingEngine = getRenderingEngine(renderingEngineId);
         if (!renderingEngine) {
-            throw new Error(`No RenderingEngine for Id: ${renderingEngineId}`);
+            return null;
+        }
+        const viewport = renderingEngine.getViewport(viewportId);
+        if (!viewport) {
+            return null;
         }
-        return renderingEngine.getViewport(viewportId).element;
+        return viewport.element;
     }
 }
 function _getUniqueViewports(vp1, vp2) {
@@ -11710,16 +11787,10 @@ class CrosshairsTool extends base/* AnnotationTool */.EC {
             return otherViewportsAnnotationsWithUniqueCameras;
         };
         this._checkIfViewportsRenderingSameScene = (viewport, otherViewport) => {
-            const actors = viewport.getActors();
-            const otherViewportActors = otherViewport.getActors();
-            let sameScene = true;
-            actors.forEach((actor) => {
-                if (actors.length !== otherViewportActors.length ||
-                    otherViewportActors.find(({ uid }) => uid === actor.uid) === undefined) {
-                    sameScene = false;
-                }
-            });
-            return sameScene;
+            const volumeIds = viewport.getAllVolumeIds();
+            const otherVolumeIds = otherViewport.getAllVolumeIds();
+            return (volumeIds.length === otherVolumeIds.length &&
+                volumeIds.every((id) => otherVolumeIds.includes(id)));
         };
         this._jump = (enabledElement, jumpWorld) => {
             store_state/* state */.wk.isInteractingWithTool = true;
@@ -14368,7 +14439,7 @@ class ScaleOverlayTool extends AnnotationDisplayTool/* default */.A {
             }
             const { viewUp, viewPlaneNormal } = viewport.getCamera();
             const viewportCanvasCornersInWorld = esm.utilities.getViewportImageCornersInWorld(viewport);
-            let annotation = this.editData.annotation;
+            let annotation = this.editData?.annotation;
             const annotations = (0,annotationState.getAnnotations)(this.getToolName(), viewport.element);
             if (annotations.length) {
                 annotation = annotations.filter((thisAnnotation) => thisAnnotation.data.viewportId == viewport.id)[0];
@@ -14396,7 +14467,7 @@ class ScaleOverlayTool extends AnnotationDisplayTool/* default */.A {
                     annotation = newAnnotation;
                 }
             });
-            if (this.editData.annotation &&
+            if (this.editData?.annotation &&
                 this.editData.annotation.data.viewportId == viewport.id) {
                 this.editData.annotation.data.handles.points =
                     viewportCanvasCornersInWorld;
@@ -14611,7 +14682,7 @@ class ScaleOverlayTool extends AnnotationDisplayTool/* default */.A {
         };
     }
     renderAnnotation(enabledElement, svgDrawingHelper) {
-        if (!this.editData.viewport) {
+        if (!this.editData || !this.editData.viewport) {
             return;
         }
         const location = this.configuration.scaleLocation;
@@ -15117,7 +15188,7 @@ class LengthTool 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;
             (0,elementCursor.hideElementCursor)(element);
             this.isDrawing = true;
             const { viewPlaneNormal, viewUp, position: cameraPosition, } = viewport.getCamera();
@@ -15432,6 +15503,39 @@ class LengthTool extends base/* AnnotationTool */.EC {
         };
         this._throttledCalculateCachedStats = (0,throttle/* default */.A)(this._calculateCachedStats, 100, { trailing: true });
     }
+    static { this.hydrate = (viewportId, points, options) => {
+        const enabledElement = (0,esm.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, points[0], viewPlaneNormal, viewUp);
+        const annotation = {
+            annotationUID: options?.annotationUID || esm.utilities.uuidv4(),
+            data: {
+                handles: {
+                    points,
+                },
+            },
+            highlighted: false,
+            autoGenerated: false,
+            invalidated: false,
+            isLocked: false,
+            isVisible: true,
+            metadata: {
+                toolName: instance.getToolName(),
+                viewPlaneNormal,
+                FrameOfReferenceUID,
+                referencedImageId,
+                ...options,
+            },
+        };
+        (0,annotationState.addAnnotation)(annotation, viewport.element);
+        (0,triggerAnnotationRenderForViewportIds/* default */.A)([viewport.id]);
+    }; }
     handleSelectedCallback(evt, annotation, handle) {
         const eventDetail = evt.detail;
         const { element } = eventDetail;
@@ -16176,6 +16280,39 @@ class ProbeTool extends base/* AnnotationTool */.EC {
         return false;
     }
     toolSelectedCallback() { }
+    static { this.hydrate = (viewportId, points, options) => {
+        const enabledElement = (0,esm.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, points[0], viewPlaneNormal, viewUp);
+        const annotation = {
+            annotationUID: options?.annotationUID || esm.utilities.uuidv4(),
+            data: {
+                handles: {
+                    points,
+                },
+            },
+            highlighted: false,
+            autoGenerated: false,
+            invalidated: false,
+            isLocked: false,
+            isVisible: true,
+            metadata: {
+                toolName: instance.getToolName(),
+                viewPlaneNormal,
+                FrameOfReferenceUID,
+                referencedImageId,
+                ...options,
+            },
+        };
+        (0,annotationState.addAnnotation)(annotation, viewport.element);
+        (0,triggerAnnotationRenderForViewportIds/* default */.A)([viewport.id]);
+    }; }
     getHandleNearImagePoint(element, annotation, canvasCoords, proximity) {
         const enabledElement = (0,esm.getEnabledElement)(element);
         const { viewport } = enabledElement;
@@ -17665,6 +17802,52 @@ class CircleROITool extends base/* AnnotationTool */.EC {
         };
         this._throttledCalculateCachedStats = (0,throttle/* default */.A)(this._calculateCachedStats, 100, { trailing: true });
     }
+    static { this.hydrate = (viewportId, points, options) => {
+        const enabledElement = (0,esm.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, points[0], viewPlaneNormal, viewUp);
+        const annotation = {
+            annotationUID: options?.annotationUID || esm.utilities.uuidv4(),
+            data: {
+                handles: {
+                    points,
+                    textBox: {
+                        hasMoved: false,
+                        worldPosition: [0, 0, 0],
+                        worldBoundingBox: {
+                            topLeft: [0, 0, 0],
+                            topRight: [0, 0, 0],
+                            bottomLeft: [0, 0, 0],
+                            bottomRight: [0, 0, 0],
+                        },
+                    },
+                    activeHandleIndex: null,
+                },
+                label: '',
+                cachedStats: {},
+            },
+            highlighted: false,
+            autoGenerated: false,
+            invalidated: false,
+            isLocked: false,
+            isVisible: true,
+            metadata: {
+                toolName: instance.getToolName(),
+                viewPlaneNormal,
+                FrameOfReferenceUID,
+                referencedImageId,
+                ...options,
+            },
+        };
+        (0,annotationState.addAnnotation)(annotation, viewport.element);
+        (0,triggerAnnotationRenderForViewportIds/* default */.A)([viewport.id]);
+    }; }
 }
 function CircleROITool_defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
@@ -18185,8 +18368,6 @@ class SplineROITool extends ContourSegmentationBaseTool/* default */.A {
                 viewportIdsToRender,
                 movingTextBox: false,
             };
-            const enabledElement = (0,esm.getEnabledElement)(element);
-            const { renderingEngine } = enabledElement;
             this._activateModify(element);
             (0,esm_utilities.triggerAnnotationRenderForViewportIds)(viewportIdsToRender);
             evt.preventDefault();
@@ -18780,6 +18961,61 @@ class SplineROITool extends ContourSegmentationBaseTool/* default */.A {
         }
         return spline;
     }
+    static { this.hydrate = (viewportId, points, options) => {
+        const enabledElement = (0,esm.getEnabledElementByViewportId)(viewportId);
+        if (!enabledElement) {
+            return;
+        }
+        if (points.length < SPLINE_MIN_POINTS) {
+            console.warn('Spline requires at least 3 control points');
+            return;
+        }
+        const { viewport } = enabledElement;
+        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+        const { viewPlaneNormal, viewUp } = viewport.getCamera();
+        const instance = new this();
+        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+        const splineType = options?.splineType || SplineTypesEnum.CatmullRom;
+        const splineConfig = instance._getSplineConfig(splineType);
+        const SplineClass = splineConfig.Class;
+        const splineInstance = new SplineClass();
+        const canvasPoints = points.map((point) => viewport.worldToCanvas(point));
+        splineInstance.setControlPoints(canvasPoints);
+        const splinePolylineCanvas = splineInstance.getPolylinePoints();
+        const splinePolylineWorld = splinePolylineCanvas.map((point) => viewport.canvasToWorld(point));
+        const annotation = {
+            annotationUID: options?.annotationUID || esm.utilities.uuidv4(),
+            data: {
+                handles: {
+                    points,
+                },
+                label: '',
+                cachedStats: {},
+                spline: {
+                    type: splineType,
+                    instance: splineInstance,
+                },
+                contour: {
+                    closed: true,
+                    polyline: splinePolylineWorld,
+                },
+            },
+            highlighted: false,
+            autoGenerated: false,
+            invalidated: true,
+            isLocked: false,
+            isVisible: true,
+            metadata: {
+                toolName: instance.getToolName(),
+                viewPlaneNormal,
+                FrameOfReferenceUID,
+                referencedImageId,
+                ...options,
+            },
+        };
+        (0,annotationState.addAnnotation)(annotation, viewport.element);
+        (0,esm_utilities.triggerAnnotationRenderForViewportIds)([viewport.id]);
+    }; }
 }
 function SplineROITool_defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
@@ -25768,7 +26004,7 @@ class SegmentationStateManager {
             type,
             active: true,
             visible: true,
-            colorLUTIndex: 0,
+            colorLUTIndex: renderingConfig?.colorLUTIndex || 0,
             segments: segmentReps,
             config: {
                 ...getDefaultRenderingConfig(type),
@@ -26491,17 +26727,20 @@ function internalAddSegmentationRepresentation(viewportId, representationInput)
 }
 function getColorLUTIndex(config) {
     const { colorLUTOrIndex } = config || {};
-    const isIndexProvided = typeof colorLUTOrIndex === 'number';
-    const selectedColorLUT = isIndexProvided
-        ? (0,getColorLUT/* getColorLUT */.B)(colorLUTOrIndex)
-        : COLOR_LUT/* default */.A;
-    const colorLUTIndex = isIndexProvided
-        ? colorLUTOrIndex
-        : (0,getNextColorLUTIndex/* getNextColorLUTIndex */.u)();
-    if (!isIndexProvided) {
-        (0,addColorLUT/* addColorLUT */.u)(selectedColorLUT, colorLUTIndex);
+    if (colorLUTOrIndex === undefined) {
+        const index = (0,addColorLUT/* addColorLUT */.u)(JSON.parse(JSON.stringify(COLOR_LUT/* default */.A)));
+        return index;
+    }
+    if (typeof colorLUTOrIndex === 'number') {
+        return colorLUTOrIndex;
     }
-    return colorLUTIndex;
+    if (Array.isArray(colorLUTOrIndex) &&
+        colorLUTOrIndex.every((item) => Array.isArray(item) && item.length === 4)) {
+        const index = (0,addColorLUT/* addColorLUT */.u)(colorLUTOrIndex);
+        return index;
+    }
+    const index = (0,addColorLUT/* addColorLUT */.u)(JSON.parse(JSON.stringify(COLOR_LUT/* default */.A)));
+    return index;
 }
 
 
@@ -26796,23 +27035,6 @@ function getActiveSegmentation(viewportId) {
 }
 
 
-/***/ }),
-
-/***/ 50409:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-"use strict";
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   B: () => (/* binding */ getColorLUT)
-/* harmony export */ });
-/* harmony import */ var _SegmentationStateManager__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(59475);
-
-function getColorLUT(index) {
-    const segmentationStateManager = _SegmentationStateManager__WEBPACK_IMPORTED_MODULE_0__/* .defaultSegmentationStateManager */ ._6;
-    return segmentationStateManager.getColorLUT(index);
-}
-
-
 /***/ }),
 
 /***/ 97577:
@@ -26830,23 +27052,6 @@ function getCurrentLabelmapImageIdForViewport(viewportId, segmentationId) {
 }
 
 
-/***/ }),
-
-/***/ 70906:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-"use strict";
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   u: () => (/* binding */ getNextColorLUTIndex)
-/* harmony export */ });
-/* harmony import */ var _SegmentationStateManager__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(59475);
-
-function getNextColorLUTIndex() {
-    const segmentationStateManager = _SegmentationStateManager__WEBPACK_IMPORTED_MODULE_0__/* .defaultSegmentationStateManager */ ._6;
-    return segmentationStateManager.getNextColorLUTIndex();
-}
-
-
 /***/ }),
 
 /***/ 93210:
@@ -30844,6 +31049,42 @@ class RectangleROITool extends _base__WEBPACK_IMPORTED_MODULE_0__/* .AnnotationT
         };
         this._throttledCalculateCachedStats = (0,_utilities_throttle__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A)(this._calculateCachedStats, 100, { trailing: true });
     }
+    static { this.hydrate = (viewportId, points, options) => {
+        const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.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, points[0], viewPlaneNormal, viewUp);
+        const annotation = {
+            annotationUID: options?.annotationUID || _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.utilities.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,
+                ...options,
+            },
+        };
+        (0,_stateManagement__WEBPACK_IMPORTED_MODULE_4__/* .addAnnotation */ .lC)(annotation, viewport.element);
+        (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_16__/* ["default"] */ .A)([viewport.id]);
+    }; }
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];