@ohif/app 3.8.0-beta.71 → 3.8.0-beta.72

package/dist/{504.bundle.5ccd6d4269fa77a0a7e7.js → 433.bundle.6f2308ab10593784778c.js}

@@ -1,4 +1,4 @@
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[504],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[433],{
 
 /***/ 79697:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
@@ -4592,6 +4592,8 @@ var isViewportPreScaled = __webpack_require__(97022);
 var getModalityUnit = __webpack_require__(73801);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/basic/index.js + 2 modules
 var basic = __webpack_require__(83112);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/contours/calculatePerimeter.js
+var calculatePerimeter = __webpack_require__(53891);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/base/ContourSegmentationBaseTool.js + 1 modules
 var ContourSegmentationBaseTool = __webpack_require__(76840);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/annotation/PlanarFreehandROITool.js
@@ -4618,6 +4620,7 @@ var ContourSegmentationBaseTool = __webpack_require__(76840);
 
 
 
+
 
 
 const { pointCanProjectOnLine } = math.polyline;
@@ -4653,7 +4656,7 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool/* default */.A {
                 enabled: false,
                 epsilon: 0.1,
             },
-            calculateStats: false,
+            calculateStats: true,
             getTextLines: defaultGetTextLines,
             statsCalculator: basic.BasicStatsCalculator,
         },
@@ -4691,6 +4694,7 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool/* default */.A {
             else {
                 this.activateOpenContourEdit(evt, annotation, viewportIdsToRender);
             }
+            evt.preventDefault();
         };
         this.isPointNearTool = (element, annotation, canvasCoords, proximity) => {
             const enabledElement = (0,esm.getEnabledElement)(element);
@@ -4730,7 +4734,7 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool/* default */.A {
         this._calculateCachedStats = (annotation, viewport, renderingEngine, enabledElement) => {
             const { data } = annotation;
             const { cachedStats } = data;
-            const { polyline: points } = data.contour;
+            const { polyline: points, closed } = data.contour;
             const targetIds = Object.keys(cachedStats);
             for (let i = 0; i < targetIds.length; i++) {
                 const targetId = targetIds[i];
@@ -4831,6 +4835,7 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool/* default */.A {
                 cachedStats[targetId] = {
                     Modality: metadata.Modality,
                     area,
+                    perimeter: (0,calculatePerimeter/* default */.A)(canvasCoordinates, closed),
                     mean: stats.mean?.value,
                     max: stats.max?.value,
                     stdDev: stats.stdDev?.value,
@@ -4940,7 +4945,7 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool/* default */.A {
         const onInterpolationComplete = (annotation) => {
             annotation.data.handles.points.length = 0;
         };
-        return esm.utilities.deepMerge(contourAnnotation, {
+        const annotation = esm.utilities.deepMerge(contourAnnotation, {
             data: {
                 contour: {
                     polyline: [[...worldPos]],
@@ -4950,6 +4955,7 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool/* default */.A {
             },
             onInterpolationComplete,
         });
+        return annotation;
     }
     getAnnotationStyle(context) {
         return super.getAnnotationStyle(context);
@@ -5021,7 +5027,7 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool/* default */.A {
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { area, mean, stdDev, max, isEmptyArea, areaUnit, modalityUnit } = cachedVolumeStats || {};
+    const { area, mean, stdDev, perimeter, max, isEmptyArea, areaUnit, modalityUnit, } = cachedVolumeStats || {};
     const textLines = [];
     if (area) {
         const areaLine = isEmptyArea
@@ -5038,6 +5044,9 @@ function defaultGetTextLines(data, targetId) {
     if (stdDev) {
         textLines.push(`Std Dev: ${(0,utilities.roundNumber)(stdDev)} ${modalityUnit}`);
     }
+    if (perimeter) {
+        textLines.push(`Perimeter: ${(0,utilities.roundNumber)(perimeter)} ${modalityUnit}`);
+    }
     return textLines;
 }
 PlanarFreehandROITool.toolName = 'PlanarFreehandROI';
@@ -6580,24 +6589,30 @@ function validate(segmentationRepresentationData) {
 
 /***/ }),
 
-/***/ 57313:
+/***/ 33944:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
-  u: () => (/* reexport */ surfaceDisplay)
+  A: () => (/* binding */ displayTools_SegmentationDisplayTool)
 });
 
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 383 modules
 var esm = __webpack_require__(50719);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/segmentationState.js + 2 modules
-var segmentationState = __webpack_require__(30322);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/enums/SegmentationRepresentations.js
 var SegmentationRepresentations = __webpack_require__(83946);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/index.js + 31 modules
+var stateManagement_segmentation = __webpack_require__(63421);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/config/segmentationVisibility.js
+var segmentationVisibility = __webpack_require__(23308);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/segmentationState.js + 2 modules
+var segmentationState = __webpack_require__(30322);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/store/ToolGroupManager/index.js
 var ToolGroupManager = __webpack_require__(52610);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/base/index.js
+var base = __webpack_require__(96214);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Surface/removeSurfaceFromElement.js
 
 function removeContourFromElement(element, segmentationRepresentationUID, removeFromCache = false) {
@@ -6686,8 +6701,6 @@ function addOrUpdateSurfaceToElement(element, surface, segmentationRepresentatio
 }
 /* harmony default export */ const Surface_addOrUpdateSurfaceToElement = (addOrUpdateSurfaceToElement);
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/index.js + 31 modules
-var stateManagement_segmentation = __webpack_require__(63421);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Surface/surfaceDisplay.js
 
 
@@ -6768,6 +6781,117 @@ function _removeSurfaceFromToolGroupViewports(toolGroupId, segmentationRepresent
 
 
 
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Contour/index.js
+var Contour = __webpack_require__(2884);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Labelmap/index.js
+var Labelmap = __webpack_require__(94318);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/store/index.js + 4 modules
+var store = __webpack_require__(61738);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/annotation/PlanarFreehandContourSegmentationTool.js
+var PlanarFreehandContourSegmentationTool = __webpack_require__(20070);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/SegmentationDisplayTool.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+const planarContourToolName = PlanarFreehandContourSegmentationTool/* default */.A.toolName;
+class SegmentationDisplayTool extends base/* BaseTool */.oS {
+    constructor(toolProps = {}, defaultToolProps = {
+        configuration: {},
+    }) {
+        super(toolProps, defaultToolProps);
+        this.renderSegmentation = (toolGroupId) => {
+            const toolGroup = (0,ToolGroupManager.getToolGroup)(toolGroupId);
+            if (!toolGroup) {
+                return;
+            }
+            const toolGroupSegmentationRepresentations = (0,segmentationState.getSegmentationRepresentations)(toolGroupId);
+            if (!toolGroupSegmentationRepresentations ||
+                toolGroupSegmentationRepresentations.length === 0) {
+                return;
+            }
+            const toolGroupViewports = toolGroup.viewportsInfo.map(({ renderingEngineId, viewportId }) => {
+                const enabledElement = (0,esm.getEnabledElementByIds)(viewportId, renderingEngineId);
+                if (enabledElement) {
+                    return enabledElement.viewport;
+                }
+            });
+            const segmentationRenderList = toolGroupSegmentationRepresentations.map((representation) => {
+                const config = this._getMergedRepresentationsConfig(toolGroupId);
+                const viewportsRenderList = [];
+                const renderers = {
+                    [SegmentationRepresentations/* default */.A.Labelmap]: Labelmap/* labelmapDisplay */.Zy,
+                    [SegmentationRepresentations/* default */.A.Contour]: Contour/* contourDisplay */.T,
+                    [SegmentationRepresentations/* default */.A.Surface]: surfaceDisplay,
+                };
+                if (representation.type === SegmentationRepresentations/* default */.A.Contour) {
+                    this.addPlanarFreeHandToolIfAbsent(toolGroupId);
+                }
+                const display = renderers[representation.type];
+                for (const viewport of toolGroupViewports) {
+                    const renderedViewport = display.render(viewport, representation, config);
+                    viewportsRenderList.push(renderedViewport);
+                }
+                return viewportsRenderList;
+            });
+            Promise.allSettled(segmentationRenderList).then(() => {
+                toolGroupViewports.forEach((viewport) => {
+                    viewport.render();
+                });
+            });
+        };
+    }
+    onSetToolEnabled() {
+        const toolGroupId = this.toolGroupId;
+        const toolGroupSegmentationRepresentations = (0,segmentationState.getSegmentationRepresentations)(toolGroupId);
+        if (!toolGroupSegmentationRepresentations ||
+            toolGroupSegmentationRepresentations.length === 0) {
+            return;
+        }
+        toolGroupSegmentationRepresentations.forEach((segmentationRepresentation) => {
+            (0,segmentationVisibility.setSegmentationVisibility)(toolGroupId, segmentationRepresentation.segmentationRepresentationUID, true);
+        });
+    }
+    onSetToolDisabled() {
+        const toolGroupId = this.toolGroupId;
+        const toolGroupSegmentationRepresentations = (0,segmentationState.getSegmentationRepresentations)(toolGroupId);
+        if (!toolGroupSegmentationRepresentations ||
+            toolGroupSegmentationRepresentations.length === 0) {
+            return;
+        }
+        toolGroupSegmentationRepresentations.forEach((segmentationRepresentation) => {
+            (0,segmentationVisibility.setSegmentationVisibility)(toolGroupId, segmentationRepresentation.segmentationRepresentationUID, false);
+        });
+    }
+    addPlanarFreeHandToolIfAbsent(toolGroupId) {
+        if (!(planarContourToolName in store/* state */.wk.tools)) {
+            (0,store/* addTool */.Gx)(PlanarFreehandContourSegmentationTool/* default */.A);
+        }
+        const toolGroup = (0,ToolGroupManager.getToolGroup)(toolGroupId);
+        if (!toolGroup.hasTool(planarContourToolName)) {
+            toolGroup.addTool(planarContourToolName);
+            toolGroup.setToolPassive(planarContourToolName);
+        }
+    }
+    _getMergedRepresentationsConfig(toolGroupId) {
+        const toolGroupConfig = stateManagement_segmentation.config.getToolGroupSpecificConfig(toolGroupId);
+        const globalConfig = stateManagement_segmentation.config.getGlobalConfig();
+        const mergedConfig = esm.utilities.deepMerge(globalConfig, toolGroupConfig);
+        return mergedConfig;
+    }
+}
+SegmentationDisplayTool.toolName = 'SegmentationDisplay';
+/* harmony default export */ const displayTools_SegmentationDisplayTool = (SegmentationDisplayTool);
+
 
 /***/ }),
 

package/dist/{530.bundle.566bfd08dccb4cf6d98b.js → 530.bundle.f4b7966fb33eafb8cd5d.js}

@@ -134,6 +134,11 @@ function OHIFCornerstoneSRViewport(props) {
       // not throwing an error?
       console.warn('More than one SOPClassUID in the same series is not yet supported.');
     }
+
+    // if (!srDisplaySet.measurements || !srDisplaySet.measurements.length) {
+    //   return;
+    // }
+
     _getViewportReferencedDisplaySetData(srDisplaySet, newMeasurementSelected, displaySetService).then(({
       referencedDisplaySet,
       referencedDisplaySetMetadata
@@ -238,12 +243,16 @@ function OHIFCornerstoneSRViewport(props) {
    * if it is hydrated we don't even use the SR viewport.
    */
   (0,react__WEBPACK_IMPORTED_MODULE_1__.useEffect)(() => {
-    if (!srDisplaySet.isLoaded) {
-      srDisplaySet.load();
-    }
-    const numMeasurements = srDisplaySet.measurements.length;
-    setMeasurementCount(numMeasurements);
-  }, [srDisplaySet]);
+    const loadSR = async () => {
+      if (!srDisplaySet.isLoaded) {
+        await srDisplaySet.load();
+      }
+      const numMeasurements = srDisplaySet.measurements.length;
+      setMeasurementCount(numMeasurements);
+      updateViewport(measurementSelected);
+    };
+    loadSR();
+  }, [dataSource, srDisplaySet]);
 
   /**
    * Hook to update the tracking identifiers when the selected measurement changes or
@@ -260,18 +269,10 @@ function OHIFCornerstoneSRViewport(props) {
    * Todo: what is this, not sure what it does regarding the react aspect,
    * it is updating a local variable? which is not state.
    */
-  let isLocked = trackedMeasurements?.context?.trackedSeries?.length > 0;
+  const [isLocked, setIsLocked] = (0,react__WEBPACK_IMPORTED_MODULE_1__.useState)(trackedMeasurements?.context?.trackedSeries?.length > 0);
   (0,react__WEBPACK_IMPORTED_MODULE_1__.useEffect)(() => {
-    isLocked = trackedMeasurements?.context?.trackedSeries?.length > 0;
+    setIsLocked(trackedMeasurements?.context?.trackedSeries?.length > 0);
   }, [trackedMeasurements]);
-
-  /**
-   * Data fetching for the SR displaySet, which updates the measurements and
-   * also gets the referenced image displaySet that SR is based on.
-   */
-  (0,react__WEBPACK_IMPORTED_MODULE_1__.useEffect)(() => {
-    updateViewport(measurementSelected);
-  }, [dataSource, srDisplaySet]);
   (0,react__WEBPACK_IMPORTED_MODULE_1__.useEffect)(() => {
     viewportActionCornersService.setComponents([{
       viewportId,

package/dist/{559.bundle.fb8ac10c41eb734e2f3d.js → 540.bundle.792745c8d390c3fc83cf.js}

@@ -1,7 +1,7 @@
 "use strict";
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[559],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[540],{
 
-/***/ 89559:
+/***/ 53540:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 // ESM COMPAT FLAG
@@ -91,6 +91,9 @@ class DICOMSRDisplayTool extends dist_esm.AnnotationTool {
         toolName: this.getToolName(),
         viewportId: enabledElement.viewport.id
       };
+      const {
+        style: annotationStyle
+      } = dist_esm.annotation.config;
       for (let i = 0; i < filteredAnnotations.length; i++) {
         const annotation = filteredAnnotations[i];
         const annotationUID = annotation.annotationUID;
@@ -104,13 +107,15 @@ class DICOMSRDisplayTool extends dist_esm.AnnotationTool {
           referencedImageId
         } = annotation.metadata;
         styleSpecifier.annotationUID = annotationUID;
+        const groupStyle = annotationStyle.getToolGroupToolStyles(this.toolGroupId)[this.getToolName()];
         const lineWidth = this.getStyle('lineWidth', styleSpecifier, annotation);
         const lineDash = this.getStyle('lineDash', styleSpecifier, annotation);
         const color = cachedStats.TrackingUniqueIdentifier === activeTrackingUniqueIdentifier ? 'rgb(0, 255, 0)' : this.getStyle('color', styleSpecifier, annotation);
         const options = {
           color,
           lineDash,
-          lineWidth
+          lineWidth,
+          ...groupStyle
         };
         Object.keys(renderableData).forEach(GraphicType => {
           const renderableDataForGraphicType = renderableData[GraphicType];
@@ -143,20 +148,21 @@ class DICOMSRDisplayTool extends dist_esm.AnnotationTool {
     };
   }
   _getTextBoxLinesFromLabels(labels) {
-    // TODO -> max 3 for now (label + shortAxis + longAxis), need a generic solution for this!
+    // TODO -> max 5 for now (label + shortAxis + longAxis), need a generic solution for this!
 
-    const labelLength = Math.min(labels.length, 3);
+    const labelLength = Math.min(labels.length, 5);
     const lines = [];
     for (let i = 0; i < labelLength; i++) {
       const labelEntry = labels[i];
-      lines.push(`${_labelToShorthand(labelEntry.label)}${labelEntry.value}`);
+      lines.push(`${_labelToShorthand(labelEntry.label)}: ${labelEntry.value}`);
     }
     return lines;
   }
   renderPolyLine(svgDrawingHelper, viewport, renderableData, annotationUID, referencedImageId, options) {
     const drawingOptions = {
       color: options.color,
-      width: options.lineWidth
+      width: options.lineWidth,
+      lineDash: options.lineDash
     };
     let allCanvasCoordinates = [];
     renderableData.map((data, index) => {
@@ -233,7 +239,8 @@ class DICOMSRDisplayTool extends dist_esm.AnnotationTool {
       const lineUID = `${index}`;
       dist_esm.drawing.drawEllipse(svgDrawingHelper, annotationUID, lineUID, canvasCorners[0], canvasCorners[1], {
         color: options.color,
-        width: options.lineWidth
+        width: options.lineWidth,
+        lineDash: options.lineDash
       });
     });
     return canvasCoordinates;
@@ -313,16 +320,14 @@ const toolNames = {
   SRPlanarFreehandROI: 'SRPlanarFreehandROI'
 };
 /* harmony default export */ const tools_toolNames = (toolNames);
-;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-sr/src/utils/addMeasurement.ts
+;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-sr/src/utils/addDICOMSRDisplayAnnotation.ts
 
 
 
 
 
 const EPSILON = 1e-4;
-const supportedLegacyCornerstoneTags = (/* unused pure expression or super */ null && (['cornerstoneTools@^4.0.0']));
-function addMeasurement(measurement, imageId, displaySetInstanceUID) {
-  // TODO -> Render rotated ellipse .
+function addDICOMSRDisplayAnnotation(measurement, imageId, frameNumber) {
   const toolName = tools_toolNames.DICOMSRDisplay;
   const measurementData = {
     TrackingUniqueIdentifier: measurement.TrackingUniqueIdentifier,
@@ -338,20 +343,23 @@ function addMeasurement(measurement, imageId, displaySetInstanceUID) {
     if (measurementData.renderableData[GraphicType] === undefined) {
       measurementData.renderableData[GraphicType] = [];
     }
-    measurementData.renderableData[GraphicType].push(_getRenderableData(GraphicType, GraphicData, imageId, measurement.TrackingIdentifier));
+    measurementData.renderableData[GraphicType].push(_getRenderableData(GraphicType, GraphicData, imageId));
   });
-
-  // Use the metadata provider to grab its imagePlaneModule metadata
   const imagePlaneModule = core_dist_esm.metaData.get('imagePlaneModule', imageId);
-  const annotationManager = dist_esm.annotation.state.getAnnotationManager();
 
-  // Create Cornerstone3D Annotation from measurement
-  const frameNumber = measurement.coords[0].ReferencedSOPSequence && measurement.coords[0].ReferencedSOPSequence[0]?.ReferencedFrameNumber || 1;
+  /**
+   * This annotation (DICOMSRDisplay) is only used by the SR viewport.
+   * This is used before the annotation is hydrated. If hydrated the measurement will be added
+   * to the measurement service and will be available for the other viewports.
+   */
   const SRAnnotation = {
     annotationUID: measurement.TrackingUniqueIdentifier,
+    highlighted: false,
+    isLocked: false,
+    invalidated: false,
     metadata: {
-      FrameOfReferenceUID: imagePlaneModule.frameOfReferenceUID,
       toolName: toolName,
+      FrameOfReferenceUID: imagePlaneModule.frameOfReferenceUID,
       referencedImageId: imageId
     },
     data: {
@@ -363,23 +371,13 @@ function addMeasurement(measurement, imageId, displaySetInstanceUID) {
         TrackingUniqueIdentifier: measurementData.TrackingUniqueIdentifier,
         renderableData: measurementData.renderableData
       },
-      frameNumber: frameNumber
+      frameNumber
     }
   };
+  const annotationManager = dist_esm.annotation.state.getAnnotationManager();
   annotationManager.addAnnotation(SRAnnotation);
-  measurement.loaded = true;
-  measurement.imageId = imageId;
-  measurement.displaySetInstanceUID = displaySetInstanceUID;
-
-  // Remove the unneeded coord now its processed, but keep the SOPInstanceUID.
-  // NOTE: We assume that each SCOORD in the MeasurementGroup maps onto one frame,
-  // It'd be super weird if it didn't anyway as a SCOORD.
-  measurement.ReferencedSOPInstanceUID = measurement.coords[0].ReferencedSOPSequence.ReferencedSOPInstanceUID;
-  measurement.frameNumber = frameNumber;
-  delete measurement.coords;
 }
-function _getRenderableData(GraphicType, GraphicData, imageId, TrackingIdentifier) {
-  const [cornerstoneTag, toolName] = TrackingIdentifier.split(':');
+function _getRenderableData(GraphicType, GraphicData, imageId) {
   let renderableData;
   switch (GraphicType) {
     case scoordTypes.POINT:
@@ -488,7 +486,7 @@ var adapters_es = __webpack_require__(83342);
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-sr/src/utils/isRehydratable.js
 
 const cornerstoneAdapters = adapters_es/* adaptersSR */.QX.Cornerstone3D.MeasurementReport.CORNERSTONE_TOOL_CLASSES_BY_UTILITY_TYPE;
-const isRehydratable_supportedLegacyCornerstoneTags = ['cornerstoneTools@^4.0.0'];
+const supportedLegacyCornerstoneTags = ['cornerstoneTools@^4.0.0'];
 const CORNERSTONE_3D_TAG = cornerstoneAdapters.CORNERSTONE_3D_TAG;
 
 /**
@@ -521,7 +519,7 @@ function isRehydratable(displaySet, mappings) {
     } = measurements[i] || {};
     const hydratable = adapters.some(adapter => {
       let [cornerstoneTag, toolName] = TrackingIdentifier.split(':');
-      if (isRehydratable_supportedLegacyCornerstoneTags.includes(cornerstoneTag)) {
+      if (supportedLegacyCornerstoneTags.includes(cornerstoneTag)) {
         cornerstoneTag = CORNERSTONE_3D_TAG;
       }
       const mappedTrackingIdentifier = `${cornerstoneTag}:${toolName}`;
@@ -675,7 +673,7 @@ function _getDisplaySetsFromSeries(instances, servicesManager, extensionManager)
   displaySet.load = () => _load(displaySet, servicesManager, extensionManager);
   return [displaySet];
 }
-function _load(displaySet, servicesManager, extensionManager) {
+async function _load(displaySet, servicesManager, extensionManager) {
   const {
     displaySetService,
     measurementService
@@ -685,6 +683,28 @@ function _load(displaySet, servicesManager, extensionManager) {
   const {
     ContentSequence
   } = displaySet.instance;
+  async function retrieveBulkData(obj, parentObj = null, key = null) {
+    for (const prop in obj) {
+      if (typeof obj[prop] === 'object' && obj[prop] !== null) {
+        await retrieveBulkData(obj[prop], obj, prop);
+      } else if (Array.isArray(obj[prop])) {
+        await Promise.all(obj[prop].map(item => retrieveBulkData(item, obj, prop)));
+      } else if (prop === 'BulkDataURI') {
+        const value = await dataSource.retrieve.bulkDataURI({
+          BulkDataURI: obj[prop],
+          StudyInstanceUID: displaySet.instance.StudyInstanceUID,
+          SeriesInstanceUID: displaySet.instance.SeriesInstanceUID,
+          SOPInstanceUID: displaySet.instance.SOPInstanceUID
+        });
+        if (parentObj && key) {
+          parentObj[key] = new Float32Array(value);
+        }
+      }
+    }
+  }
+  if (displaySet.isLoaded !== true) {
+    await retrieveBulkData(ContentSequence);
+  }
   displaySet.referencedImages = _getReferencedImagesList(ContentSequence);
   displaySet.measurements = _getMeasurements(ContentSequence);
   const mappings = measurementService.getSourceMappings(CORNERSTONE_3D_TOOLS_SOURCE_NAME, CORNERSTONE_3D_TOOLS_SOURCE_VERSION);
@@ -769,7 +789,18 @@ function _checkIfCanAddMeasurementsToDisplaySet(srDisplaySet, newDisplaySet, dat
           });
         }
         if (_measurementReferencesSOPInstanceUID(measurement, SOPInstanceUID, frameNumber)) {
-          addMeasurement(measurement, imageId, newDisplaySet.displaySetInstanceUID);
+          const frame = measurement.coords[0].ReferencedSOPSequence && measurement.coords[0].ReferencedSOPSequence?.ReferencedFrameNumber || 1;
+
+          /** Add DICOMSRDisplay annotation for the SR viewport (only) */
+          addDICOMSRDisplayAnnotation(measurement, imageId, frame);
+
+          /** Update measurement properties */
+          measurement.loaded = true;
+          measurement.imageId = imageId;
+          measurement.displaySetInstanceUID = newDisplaySet.displaySetInstanceUID;
+          measurement.ReferencedSOPInstanceUID = measurement.coords[0].ReferencedSOPSequence.ReferencedSOPInstanceUID;
+          measurement.frameNumber = frame;
+          delete measurement.coords;
           unloadedMeasurements.splice(j, 1);
         }
       }
@@ -783,7 +814,7 @@ function _measurementReferencesSOPInstanceUID(measurement, SOPInstanceUID, frame
 
   // NOTE: The ReferencedFrameNumber can be multiple values according to the DICOM
   //  Standard. But for now, we will support only one ReferenceFrameNumber.
-  const ReferencedFrameNumber = measurement.coords[0].ReferencedSOPSequence && measurement.coords[0].ReferencedSOPSequence[0]?.ReferencedFrameNumber || 1;
+  const ReferencedFrameNumber = measurement.coords[0].ReferencedSOPSequence && measurement.coords[0].ReferencedSOPSequence?.ReferencedFrameNumber || 1;
   if (frameNumber && Number(frameNumber) !== Number(ReferencedFrameNumber)) {
     return false;
   }
@@ -1341,24 +1372,25 @@ function addToolInstance(name, toolClass, configuration) {
 function init({
   configuration = {}
 }) {
-  (0,dist_esm.addTool)(DICOMSRDisplayTool);
-  addToolInstance(tools_toolNames.SRLength, dist_esm.LengthTool, {});
+  addToolInstance(tools_toolNames.DICOMSRDisplay, DICOMSRDisplayTool);
+  addToolInstance(tools_toolNames.SRLength, dist_esm.LengthTool);
   addToolInstance(tools_toolNames.SRBidirectional, dist_esm.BidirectionalTool);
   addToolInstance(tools_toolNames.SREllipticalROI, dist_esm.EllipticalROITool);
   addToolInstance(tools_toolNames.SRCircleROI, dist_esm.CircleROITool);
   addToolInstance(tools_toolNames.SRArrowAnnotate, dist_esm.ArrowAnnotateTool);
   addToolInstance(tools_toolNames.SRAngle, dist_esm.AngleTool);
+  addToolInstance(tools_toolNames.SRPlanarFreehandROI, dist_esm.PlanarFreehandROITool);
+  addToolInstance(tools_toolNames.SRRectangleROI, dist_esm.RectangleROITool);
+
   // TODO - fix the SR display of Cobb Angle, as it joins the two lines
   addToolInstance(tools_toolNames.SRCobbAngle, dist_esm.CobbAngleTool);
-  // TODO - fix the rehydration of Freehand, as it throws an exception
-  // on a missing polyline. The fix is probably in CS3D
-  addToolInstance(tools_toolNames.SRPlanarFreehandROI, dist_esm.PlanarFreehandROITool);
 
   // Modify annotation tools to use dashed lines on SR
   const dashedLine = {
     lineDash: '4,4'
   };
   dist_esm.annotation.config.style.setToolGroupToolStyles('SRToolGroup', {
+    [tools_toolNames.DICOMSRDisplay]: dashedLine,
     SRLength: dashedLine,
     SRBidirectional: dashedLine,
     SREllipticalROI: dashedLine,
@@ -1367,6 +1399,7 @@ function init({
     SRCobbAngle: dashedLine,
     SRAngle: dashedLine,
     SRPlanarFreehandROI: dashedLine,
+    SRRectangleROI: dashedLine,
     global: {}
   });
 }