@ohif/app 3.9.0 → 3.9.2

package/dist/{1185.bundle.a6e220f00576d6926fe7.js → 1185.bundle.d328aabb2b43e9ea1f96.js}

@@ -983,8 +983,8 @@ function initWADOImageLoader(userAuthenticationService, appConfig, extensionMana
 function destroy() {
   console.debug('Destroying WADO Image Loader');
 }
-// EXTERNAL MODULE: ../../../extensions/default/src/index.ts + 114 modules
-var default_src = __webpack_require__(71520);
+// EXTERNAL MODULE: ../../../extensions/default/src/index.ts + 115 modules
+var default_src = __webpack_require__(55630);
 // EXTERNAL MODULE: ../../../extensions/cornerstone/src/state.ts
 var state = __webpack_require__(71353);
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/utils/getActiveViewportEnabledElement.ts
@@ -4408,9 +4408,9 @@ const initMeasurementService = (measurementService, displaySetService, cornersto
   /* Mappings */
   measurementService.addMapping(csTools3DVer1MeasurementSource, 'Length', Length.matchingCriteria, Length.toAnnotation, Length.toMeasurement);
   measurementService.addMapping(csTools3DVer1MeasurementSource, 'Crosshairs', Length.matchingCriteria, () => {
-    console.warn('Crosshairs mapping not implemented.');
+    return null;
   }, () => {
-    console.warn('Crosshairs mapping not implemented.');
+    return null;
   });
   measurementService.addMapping(csTools3DVer1MeasurementSource, 'Bidirectional', Bidirectional.matchingCriteria, Bidirectional.toAnnotation, Bidirectional.toMeasurement);
   measurementService.addMapping(csTools3DVer1MeasurementSource, 'EllipticalROI', EllipticalROI.matchingCriteria, EllipticalROI.toAnnotation, EllipticalROI.toMeasurement);
@@ -5278,7 +5278,7 @@ function interleaveTopToBottom({
   const AllRequests = [];
   volumes.forEach(volume => {
     const requests = volume.getImageLoadRequests();
-    if (!requests.length || !requests[0] || !requests[0].imageId) {
+    if (!requests?.[0]?.imageId) {
       return;
     }
 
@@ -5652,6 +5652,8 @@ var useLutPresentationStore = __webpack_require__(10182);
 var usePositionPresentationStore = __webpack_require__(44646);
 // EXTERNAL MODULE: ../../../extensions/cornerstone/src/stores/useSegmentationPresentationStore.ts + 1 modules
 var useSegmentationPresentationStore = __webpack_require__(2847);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/index.js + 40 modules
+var esm_utilities = __webpack_require__(49035);
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone/src/init.tsx
 
 
@@ -5674,6 +5676,7 @@ var useSegmentationPresentationStore = __webpack_require__(2847);
 
 
 
+
 
 
 const {
@@ -5755,9 +5758,18 @@ async function init({
   const metadataProvider = src/* default.classes */.Ay.classes.MetadataProvider;
   esm.volumeLoader.registerVolumeLoader('cornerstoneStreamingImageVolume', loaders/* cornerstoneStreamingImageVolumeLoader */.FC);
   esm.volumeLoader.registerVolumeLoader('cornerstoneStreamingDynamicImageVolume', loaders/* cornerstoneStreamingDynamicImageVolumeLoader */.Mr);
-  hangingProtocolService.registerImageLoadStrategy('interleaveCenter', interleaveCenterLoader);
-  hangingProtocolService.registerImageLoadStrategy('interleaveTopToBottom', interleaveTopToBottom);
-  hangingProtocolService.registerImageLoadStrategy('nth', interleaveNthLoader);
+
+  // Register strategies using the wrapper
+  const imageLoadStrategies = {
+    interleaveCenter: interleaveCenterLoader,
+    interleaveTopToBottom: interleaveTopToBottom,
+    nth: interleaveNthLoader
+  };
+  Object.entries(imageLoadStrategies).forEach(([name, strategyFn]) => {
+    hangingProtocolService.registerImageLoadStrategy(name, createMetadataWrappedStrategy(strategyFn));
+  });
+
+  // ... existing code ...
 
   // add metadata providers
   esm.metaData.addProvider(esm.utilities.calibratedPixelSpacingMetadataProvider.get.bind(esm.utilities.calibratedPixelSpacingMetadataProvider)); // this provider is required for Calibration tool
@@ -5920,6 +5932,27 @@ function initializeWebWorkerProgressHandler(uiNotificationService) {
     }
   });
 }
+
+/**
+ * Creates a wrapped image load strategy with metadata handling
+ * @param strategyFn - The image loading strategy function to wrap
+ * @returns A wrapped strategy function that handles metadata configuration
+ */
+const createMetadataWrappedStrategy = strategyFn => {
+  return args => {
+    const clonedConfig = esm_utilities.imageRetrieveMetadataProvider.clone();
+    esm_utilities.imageRetrieveMetadataProvider.clear();
+    try {
+      const result = strategyFn(args);
+      return result;
+    } finally {
+      // Ensure metadata is always restored, even if there's an error
+      setTimeout(() => {
+        esm_utilities.imageRetrieveMetadataProvider.restore(clonedConfig);
+      }, 10);
+    }
+  };
+};
 function CPUModal() {
   return /*#__PURE__*/react.createElement("div", null, /*#__PURE__*/react.createElement("p", null, "Your computer does not have enough GPU power to support the default GPU rendering mode. OHIF has switched to CPU rendering mode. Please note that CPU rendering does not support all features such as Volume Rendering, Multiplanar Reconstruction, and Segmentation Overlays."));
 }
@@ -13305,6 +13338,20 @@ class CornerstoneViewportService extends src/* PubSubService */.Rc {
    * individual resize observers
    */
   resize(isGridResize = false) {
+    // https://stackoverflow.com/a/26279685
+    // This resize() call, among other things, rerenders the viewports. But when the entire viewer is
+    // display: none'd, it makes the size of all hidden elements 0, including the viewport canvas and its containers.
+    // Even if the viewer is later displayed again, trying to render when the size is 0 permanently "breaks" the
+    // viewport, making it fully black even after the size is normal again. So just ignore resize events when hidden:
+    const areViewportsHidden = Array.from(this.viewportsById.values()).every(viewportInfo => {
+      const element = viewportInfo.getElement();
+      return element.clientWidth === 0 && element.clientHeight === 0;
+    });
+    if (areViewportsHidden) {
+      console.warn('Ignoring resize when viewports have size 0');
+      return;
+    }
+
     // if there is a grid resize happening, it means the viewport grid
     // has been manipulated (e.g., panels closed, added, etc.) and we need
     // to resize all viewports, so we will add a timeout here to make sure
@@ -14140,6 +14187,11 @@ class CornerstoneViewportService extends src/* PubSubService */.Rc {
         id: viewportId
       }) => {
         const presentation = this._getPositionPresentation(viewportId);
+
+        // During a resize, the slice index should remain unchanged. This is a temporary fix for
+        // a larger issue regarding the definition of slice index with slab thickness.
+        // We need to revisit this to make it more robust and understandable.
+        delete presentation.viewReference.sliceIndex;
         this.beforeResizePositionPresentations.set(viewportId, presentation);
       });
 
@@ -14148,7 +14200,7 @@ class CornerstoneViewportService extends src/* PubSubService */.Rc {
       renderingEngine.resize(isImmediate);
       renderingEngine.render();
 
-      // Reset the camera for viewports that should reset their camera on resize,
+      // Reset the camera for all viewports using position presentation to maintain relative size/position
       // which means only those viewports that have a zoom level of 1.
       this.beforeResizePositionPresentations.forEach((positionPresentation, viewportId) => {
         this.setPresentations(viewportId, {
@@ -14905,10 +14957,6 @@ function getDicomMicroscopySopClassHandler({
 function getSopClassHandlerModule(params) {
   return [getDicomMicroscopySopClassHandler(params)];
 }
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/index.js + 40 modules
-var esm_utilities = __webpack_require__(49035);
-// EXTERNAL MODULE: ../../../extensions/default/src/stores/useToggleOneUpViewportGridStore.ts
-var useToggleOneUpViewportGridStore = __webpack_require__(73325);
 // EXTERNAL MODULE: ../../../node_modules/lodash.debounce/index.js
 var lodash_debounce = __webpack_require__(62051);
 var lodash_debounce_default = /*#__PURE__*/__webpack_require__.n(lodash_debounce);
@@ -16738,7 +16786,7 @@ const cornerstoneExtension = {
     useLutPresentationStore/* useLutPresentationStore */.I.getState().clearLutPresentationStore();
     usePositionPresentationStore/* usePositionPresentationStore */.q.getState().clearPositionPresentationStore();
     useSynchronizersStore/* useSynchronizersStore */.U.getState().clearSynchronizersStore();
-    useToggleOneUpViewportGridStore/* useToggleOneUpViewportGridStore */.Y.getState().clearToggleOneUpViewportGridStore();
+    default_src.useToggleOneUpViewportGridStore.getState().clearToggleOneUpViewportGridStore();
     useSegmentationPresentationStore/* useSegmentationPresentationStore */.v.getState().clearSegmentationPresentationStore();
     segmentationService.removeAllSegmentations();
   },

package/dist/{1266.bundle.8fd38b710e91305721e5.js → 1266.bundle.46de27eda2ef1fce1243.js}

@@ -762,6 +762,11 @@ const performCustomizations = customizationService => {
     id: 'PanelSegmentation.disableEditing',
     disableEditing: true
   }
+  // to only show current study in the panel study browser
+  // {
+  //   id: 'PanelStudyBrowser.studyMode',
+  //   mode: 'primary',
+  // },
   // To disable editing in the MeasurementTable
   // {
   //   id: 'PanelMeasurement.disableEditing',

package/dist/{1436.bundle.773756cd51b69e887bac.js → 1436.bundle.27ae9c87e9fc7f52cad3.js}

@@ -4116,6 +4116,9 @@ class Synchronizer {
         };
         viewports.forEach((vp) => {
             const eventSource = this.getEventSource(vp);
+            if (!eventSource) {
+                return;
+            }
             eventSource.removeEventListener(esm.Enums.Events.ELEMENT_DISABLED, disableHandler);
             eventSource.addEventListener(esm.Enums.Events.ELEMENT_DISABLED, disableHandler);
         });
@@ -4129,9 +4132,13 @@ class Synchronizer {
         const { renderingEngineId, viewportId } = viewportInfo;
         const renderingEngine = (0,esm.getRenderingEngine)(renderingEngineId);
         if (!renderingEngine) {
-            throw new Error(`No RenderingEngine for Id: ${renderingEngineId}`);
+            return null;
         }
-        return renderingEngine.getViewport(viewportId).element;
+        const viewport = renderingEngine.getViewport(viewportId);
+        if (!viewport) {
+            return null;
+        }
+        return viewport.element;
     }
 }
 function _getUniqueViewports(vp1, vp2) {
@@ -6504,16 +6511,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) => {
             state/* state */.wk.isInteractingWithTool = true;
@@ -9162,7 +9163,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];
@@ -9190,7 +9191,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;
@@ -9405,7 +9406,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;
@@ -9911,7 +9912,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();
@@ -10226,6 +10227,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;
@@ -10970,6 +11004,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;
@@ -12459,6 +12526,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];
@@ -12979,8 +13092,6 @@ class SplineROITool extends ContourSegmentationBaseTool/* default */.A {
                 viewportIdsToRender,
                 movingTextBox: false,
             };
-            const enabledElement = (0,esm.getEnabledElement)(element);
-            const { renderingEngine } = enabledElement;
             this._activateModify(element);
             (0,utilities.triggerAnnotationRenderForViewportIds)(viewportIdsToRender);
             evt.preventDefault();
@@ -13574,6 +13685,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,utilities.triggerAnnotationRenderForViewportIds)([viewport.id]);
+    }; }
 }
 function SplineROITool_defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
@@ -20578,7 +20744,7 @@ class SegmentationStateManager {
             type,
             active: true,
             visible: true,
-            colorLUTIndex: 0,
+            colorLUTIndex: renderingConfig?.colorLUTIndex || 0,
             segments: segmentReps,
             config: {
                 ...getDefaultRenderingConfig(type),
@@ -21305,17 +21471,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;
+    }
+    if (Array.isArray(colorLUTOrIndex) &&
+        colorLUTOrIndex.every((item) => Array.isArray(item) && item.length === 4)) {
+        const index = (0,addColorLUT/* addColorLUT */.u)(colorLUTOrIndex);
+        return index;
     }
-    return colorLUTIndex;
+    const index = (0,addColorLUT/* addColorLUT */.u)(JSON.parse(JSON.stringify(COLOR_LUT/* default */.A)));
+    return index;
 }
 
 
@@ -21615,23 +21784,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:
@@ -21649,23 +21801,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:
@@ -25762,6 +25897,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];

package/dist/{1927.bundle.49539e3ab5b0aad1399c.js → 1927.bundle.2b2fa0b539d6ac5b0dc3.js}

@@ -172,7 +172,7 @@
 /******/ 		// This function allow to reference async chunks and sibling chunks for the entrypoint
 /******/ 		__webpack_require__.u = (chunkId) => {
 /******/ 			// return url for filenames based on template
-/******/ 			return "" + chunkId + ".bundle." + {"732":"532947c280e1a8f6e020","4571":"3b1691730b3c57bf4d35","8094":"411698eaf81975a7f12d"}[chunkId] + ".js";
+/******/ 			return "" + chunkId + ".bundle." + {"732":"532947c280e1a8f6e020","4571":"a37be49663df2f4a2c8a","8094":"411698eaf81975a7f12d"}[chunkId] + ".js";
 /******/ 		};
 /******/ 	})();
 /******/