@ohif/app 3.9.0-beta.98 → 3.9.0-beta.99

package/dist/{7360.bundle.70420db3a8b2396a74ca.js → 4566.bundle.ec9936198e788f67bd79.js}

@@ -1,17 +1,28 @@
 "use strict";
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[7360],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[4566],{
 
-/***/ 91851:
+/***/ 44736:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   Z: () => (/* binding */ CodeNameCodeSequenceValues)
+/* harmony export */   Ql: () => (/* binding */ CodingSchemeDesignators),
+/* harmony export */   ZP: () => (__WEBPACK_DEFAULT_EXPORT__),
+/* harmony export */   oQ: () => (/* binding */ SCOORDTypes),
+/* harmony export */   zg: () => (/* binding */ CodeNameCodeSequenceValues)
 /* harmony export */ });
+/* unused harmony export RelationshipType */
 /* harmony import */ var _cornerstonejs_adapters__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(91202);
 
 const {
   CodeScheme: Cornerstone3DCodeScheme
 } = _cornerstonejs_adapters__WEBPACK_IMPORTED_MODULE_0__.adaptersSR.Cornerstone3D;
+const SCOORDTypes = {
+  POINT: 'POINT',
+  MULTIPOINT: 'MULTIPOINT',
+  POLYLINE: 'POLYLINE',
+  CIRCLE: 'CIRCLE',
+  ELLIPSE: 'ELLIPSE'
+};
 const CodeNameCodeSequenceValues = {
   ImagingMeasurementReport: '126000',
   ImageLibrary: '111028',
@@ -23,13 +34,28 @@ const CodeNameCodeSequenceValues = {
   Finding: '121071',
   FindingSite: 'G-C0E3',
   // SRT
-  CornerstoneFreeText: Cornerstone3DCodeScheme.codeValues.CORNERSTONEFREETEXT
+  FindingSiteSCT: '363698007' // SCT
 };
-
+const CodingSchemeDesignators = {
+  SRT: 'SRT',
+  SCT: 'SCT',
+  CornerstoneCodeSchemes: [Cornerstone3DCodeScheme.CodingSchemeDesignator, 'CST4']
+};
+const RelationshipType = {
+  INFERRED_FROM: 'INFERRED FROM',
+  CONTAINS: 'CONTAINS'
+};
+const enums = {
+  CodeNameCodeSequenceValues,
+  CodingSchemeDesignators,
+  RelationshipType,
+  SCOORDTypes
+};
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (enums);
 
 /***/ }),
 
-/***/ 97360:
+/***/ 84566:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 // ESM COMPAT FLAG
@@ -37,482 +63,250 @@ __webpack_require__.r(__webpack_exports__);
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
+  Enums: () => (/* reexport */ enums/* default */.ZP),
   createReferencedImageDisplaySet: () => (/* reexport */ createReferencedImageDisplaySet/* default */.Z),
   "default": () => (/* binding */ cornerstone_dicom_sr_src),
   hydrateStructuredReport: () => (/* reexport */ hydrateStructuredReport/* default */.Z),
-  srProtocol: () => (/* reexport */ srProtocol)
+  srProtocol: () => (/* reexport */ srProtocol),
+  toolNames: () => (/* reexport */ tools_toolNames)
 });
 
 // EXTERNAL MODULE: ../../../node_modules/react/index.js
 var react = __webpack_require__(43001);
-;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-sr/package.json
-const package_namespaceObject = JSON.parse('{"u2":"@ohif/extension-cornerstone-dicom-sr"}');
-;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-sr/src/id.js
-
-const id = package_namespaceObject.u2;
-const SOPClassHandlerName = 'dicom-sr';
-const SOPClassHandlerId = `${id}.sopClassHandlerModule.${SOPClassHandlerName}`;
-
 // EXTERNAL MODULE: ../../core/src/index.ts + 74 modules
 var src = __webpack_require__(84793);
-// EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js + 1 modules
-var esm = __webpack_require__(72076);
+// EXTERNAL MODULE: ../../../extensions/cornerstone/src/index.tsx + 96 modules
+var cornerstone_src = __webpack_require__(83846);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/adapters/dist/adapters.es.js
+var adapters_es = __webpack_require__(91202);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/index.js
-var dist_esm = __webpack_require__(93725);
+var esm = __webpack_require__(93725);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
-var core_dist_esm = __webpack_require__(12651);
-// EXTERNAL MODULE: ../../../extensions/cornerstone-dicom-sr/src/tools/modules/dicomSRModule.js
-var dicomSRModule = __webpack_require__(75449);
-;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-sr/src/constants/scoordTypes.js
-/* harmony default export */ const scoordTypes = ({
-  POINT: 'POINT',
-  MULTIPOINT: 'MULTIPOINT',
-  POLYLINE: 'POLYLINE',
-  CIRCLE: 'CIRCLE',
-  ELLIPSE: 'ELLIPSE'
-});
-;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-sr/src/tools/DICOMSRDisplayTool.ts
+var dist_esm = __webpack_require__(12651);
+// EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js + 1 modules
+var gl_matrix_esm = __webpack_require__(72076);
+// EXTERNAL MODULE: ../../../extensions/cornerstone-dicom-sr/src/enums.ts
+var enums = __webpack_require__(44736);
+;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-sr/src/utils/getRenderableData.ts
 
 
 
+const EPSILON = 1e-4;
+const getRenderableCoords = ({
+  GraphicData,
+  ValueType,
+  imageId
+}) => {
+  const renderableData = [];
+  if (ValueType === 'SCOORD3D') {
+    for (let i = 0; i < GraphicData.length; i += 3) {
+      renderableData.push([GraphicData[i], GraphicData[i + 1], GraphicData[i + 2]]);
+    }
+  } else {
+    for (let i = 0; i < GraphicData.length; i += 2) {
+      const worldPos = dist_esm.utilities.imageToWorldCoords(imageId, [GraphicData[i], GraphicData[i + 1]]);
+      renderableData.push(worldPos);
+    }
+  }
+  return renderableData;
+};
+function getRenderableData({
+  GraphicType,
+  GraphicData,
+  ValueType,
+  imageId
+}) {
+  let renderableData = [];
+  switch (GraphicType) {
+    case enums/* SCOORDTypes */.oQ.POINT:
+    case enums/* SCOORDTypes */.oQ.MULTIPOINT:
+    case enums/* SCOORDTypes */.oQ.POLYLINE:
+      {
+        renderableData = getRenderableCoords({
+          GraphicData,
+          ValueType,
+          imageId
+        });
+        break;
+      }
+    case enums/* SCOORDTypes */.oQ.CIRCLE:
+      {
+        const pointsWorld = getRenderableCoords({
+          GraphicData,
+          ValueType,
+          imageId
+        });
+        // We do not have an explicit draw circle svg helper in Cornerstone3D at
+        // this time, but we can use the ellipse svg helper to draw a circle, so
+        // here we reshape the data for that purpose.
+        const center = pointsWorld[0];
+        const onPerimeter = pointsWorld[1];
+        const radius = gl_matrix_esm/* vec3.distance */.R3.distance(center, onPerimeter);
+        const imagePlaneModule = dist_esm.metaData.get('imagePlaneModule', imageId);
+        if (!imagePlaneModule) {
+          throw new Error('No imagePlaneModule found');
+        }
+        const {
+          columnCosines,
+          rowCosines
+        } = imagePlaneModule;
 
-class DICOMSRDisplayTool extends dist_esm.AnnotationTool {
-  constructor(toolProps = {}, defaultToolProps = {
-    configuration: {}
-  }) {
-    super(toolProps, defaultToolProps);
-    // This tool should not inherit from AnnotationTool and we should not need
-    // to add the following lines.
-    this.isPointNearTool = () => null;
-    this.getHandleNearImagePoint = () => null;
-    this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
-      const {
-        viewport
-      } = enabledElement;
-      const {
-        element
-      } = viewport;
-      let annotations = dist_esm.annotation.state.getAnnotations(this.getToolName(), element);
+        // we need to get major/minor axis (which are both the same size major = minor)
 
-      // Todo: We don't need this anymore, filtering happens in triggerAnnotationRender
-      if (!annotations?.length) {
-        return;
-      }
-      annotations = this.filterInteractableAnnotationsForElement(element, annotations);
-      if (!annotations?.length) {
-        return;
+        const firstAxisStart = gl_matrix_esm/* vec3.create */.R3.create();
+        gl_matrix_esm/* vec3.scaleAndAdd */.R3.scaleAndAdd(firstAxisStart, center, columnCosines, radius);
+        const firstAxisEnd = gl_matrix_esm/* vec3.create */.R3.create();
+        gl_matrix_esm/* vec3.scaleAndAdd */.R3.scaleAndAdd(firstAxisEnd, center, columnCosines, -radius);
+        const secondAxisStart = gl_matrix_esm/* vec3.create */.R3.create();
+        gl_matrix_esm/* vec3.scaleAndAdd */.R3.scaleAndAdd(secondAxisStart, center, rowCosines, radius);
+        const secondAxisEnd = gl_matrix_esm/* vec3.create */.R3.create();
+        gl_matrix_esm/* vec3.scaleAndAdd */.R3.scaleAndAdd(secondAxisEnd, center, rowCosines, -radius);
+        renderableData = [firstAxisStart, firstAxisEnd, secondAxisStart, secondAxisEnd];
+        break;
       }
-      const trackingUniqueIdentifiersForElement = (0,dicomSRModule/* getTrackingUniqueIdentifiersForElement */.yR)(element);
-      const {
-        activeIndex,
-        trackingUniqueIdentifiers
-      } = trackingUniqueIdentifiersForElement;
-      const activeTrackingUniqueIdentifier = trackingUniqueIdentifiers[activeIndex];
+    case enums/* SCOORDTypes */.oQ.ELLIPSE:
+      {
+        // GraphicData is ordered as [majorAxisStartX, majorAxisStartY, majorAxisEndX, majorAxisEndY, minorAxisStartX, minorAxisStartY, minorAxisEndX, minorAxisEndY]
+        // But Cornerstone3D points are ordered as top, bottom, left, right for the
+        // ellipse so we need to identify if the majorAxis is horizontal or vertical
+        // and then choose the correct points to use for the ellipse.
+        const pointsWorld = getRenderableCoords({
+          GraphicData,
+          ValueType,
+          imageId
+        });
+        const majorAxisStart = gl_matrix_esm/* vec3.fromValues */.R3.fromValues(...pointsWorld[0]);
+        const majorAxisEnd = gl_matrix_esm/* vec3.fromValues */.R3.fromValues(...pointsWorld[1]);
+        const minorAxisStart = gl_matrix_esm/* vec3.fromValues */.R3.fromValues(...pointsWorld[2]);
+        const minorAxisEnd = gl_matrix_esm/* vec3.fromValues */.R3.fromValues(...pointsWorld[3]);
+        const majorAxisVec = gl_matrix_esm/* vec3.create */.R3.create();
+        gl_matrix_esm/* vec3.sub */.R3.sub(majorAxisVec, majorAxisEnd, majorAxisStart);
 
-      // Filter toolData to only render the data for the active SR.
-      const filteredAnnotations = annotations.filter(annotation => trackingUniqueIdentifiers.includes(annotation.data?.TrackingUniqueIdentifier));
-      if (!viewport._actors?.size) {
-        return;
-      }
-      const styleSpecifier = {
-        toolGroupId: this.toolGroupId,
-        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;
-        const {
-          renderableData,
-          TrackingUniqueIdentifier
-        } = annotation.data;
+        // normalize majorAxisVec to avoid scaling issues
+        gl_matrix_esm/* vec3.normalize */.R3.normalize(majorAxisVec, majorAxisVec);
+        const minorAxisVec = gl_matrix_esm/* vec3.create */.R3.create();
+        gl_matrix_esm/* vec3.sub */.R3.sub(minorAxisVec, minorAxisEnd, minorAxisStart);
+        gl_matrix_esm/* vec3.normalize */.R3.normalize(minorAxisVec, minorAxisVec);
+        const imagePlaneModule = dist_esm.metaData.get('imagePlaneModule', imageId);
+        if (!imagePlaneModule) {
+          throw new Error('imageId does not have imagePlaneModule metadata');
+        }
         const {
-          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 = TrackingUniqueIdentifier === activeTrackingUniqueIdentifier ? 'rgb(0, 255, 0)' : this.getStyle('color', styleSpecifier, annotation);
-        const options = {
-          color,
-          lineDash,
-          lineWidth,
-          ...groupStyle
-        };
-        Object.keys(renderableData).forEach(GraphicType => {
-          const renderableDataForGraphicType = renderableData[GraphicType];
-          let renderMethod;
-          let canvasCoordinatesAdapter;
-          switch (GraphicType) {
-            case scoordTypes.POINT:
-              renderMethod = this.renderPoint;
-              break;
-            case scoordTypes.MULTIPOINT:
-              renderMethod = this.renderMultipoint;
-              break;
-            case scoordTypes.POLYLINE:
-              renderMethod = this.renderPolyLine;
-              break;
-            case scoordTypes.CIRCLE:
-              renderMethod = this.renderEllipse;
-              break;
-            case scoordTypes.ELLIPSE:
-              renderMethod = this.renderEllipse;
-              canvasCoordinatesAdapter = dist_esm.utilities.math.ellipse.getCanvasEllipseCorners;
-              break;
-            default:
-              throw new Error(`Unsupported GraphicType: ${GraphicType}`);
-          }
-          const canvasCoordinates = renderMethod(svgDrawingHelper, viewport, renderableDataForGraphicType, annotationUID, referencedImageId, options);
-          this.renderTextBox(svgDrawingHelper, viewport, canvasCoordinates, canvasCoordinatesAdapter, annotation, styleSpecifier, options);
-        });
-      }
-    };
-  }
-  _getTextBoxLinesFromLabels(labels) {
-    // TODO -> max 5 for now (label + shortAxis + longAxis), need a generic solution for this!
+          columnCosines
+        } = imagePlaneModule;
 
-    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}`);
-    }
-    return lines;
-  }
-  renderPolyLine(svgDrawingHelper, viewport, renderableData, annotationUID, referencedImageId, options) {
-    const drawingOptions = {
-      color: options.color,
-      width: options.lineWidth,
-      lineDash: options.lineDash
-    };
-    let allCanvasCoordinates = [];
-    renderableData.map((data, index) => {
-      const canvasCoordinates = data.map(p => viewport.worldToCanvas(p));
-      const lineUID = `${index}`;
-      if (canvasCoordinates.length === 2) {
-        dist_esm.drawing.drawLine(svgDrawingHelper, annotationUID, lineUID, canvasCoordinates[0], canvasCoordinates[1], drawingOptions);
-      } else {
-        dist_esm.drawing.drawPolyline(svgDrawingHelper, annotationUID, lineUID, canvasCoordinates, drawingOptions);
+        // find which axis is parallel to the columnCosines
+        const columnCosinesVec = gl_matrix_esm/* vec3.fromValues */.R3.fromValues(...columnCosines);
+        const projectedMajorAxisOnColVec = Math.abs(gl_matrix_esm/* vec3.dot */.R3.dot(columnCosinesVec, majorAxisVec));
+        const projectedMinorAxisOnColVec = Math.abs(gl_matrix_esm/* vec3.dot */.R3.dot(columnCosinesVec, minorAxisVec));
+        const absoluteOfMajorDotProduct = Math.abs(projectedMajorAxisOnColVec);
+        const absoluteOfMinorDotProduct = Math.abs(projectedMinorAxisOnColVec);
+        renderableData = [];
+        if (Math.abs(absoluteOfMajorDotProduct - 1) < EPSILON) {
+          renderableData = [pointsWorld[0], pointsWorld[1], pointsWorld[2], pointsWorld[3]];
+        } else if (Math.abs(absoluteOfMinorDotProduct - 1) < EPSILON) {
+          renderableData = [pointsWorld[2], pointsWorld[3], pointsWorld[0], pointsWorld[1]];
+        } else {
+          console.warn('OBLIQUE ELLIPSE NOT YET SUPPORTED');
+        }
+        break;
       }
-      allCanvasCoordinates = allCanvasCoordinates.concat(canvasCoordinates);
-    });
-    return allCanvasCoordinates; // used for drawing textBox
-  }
-  renderMultipoint(svgDrawingHelper, viewport, renderableData, annotationUID, referencedImageId, options) {
-    let canvasCoordinates;
-    renderableData.map((data, index) => {
-      canvasCoordinates = data.map(p => viewport.worldToCanvas(p));
-      const handleGroupUID = '0';
-      dist_esm.drawing.drawHandles(svgDrawingHelper, annotationUID, handleGroupUID, canvasCoordinates, {
-        color: options.color
-      });
-    });
+    default:
+      console.warn('Unsupported GraphicType:', GraphicType);
   }
-  renderPoint(svgDrawingHelper, viewport, renderableData, annotationUID, referencedImageId, options) {
-    const canvasCoordinates = [];
-    renderableData.map((data, index) => {
-      const point = data[0];
-      // This gives us one point for arrow
-      canvasCoordinates.push(viewport.worldToCanvas(point));
+  return renderableData;
+}
+/* harmony default export */ const utils_getRenderableData = (getRenderableData);
+;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-sr/src/tools/toolNames.ts
+const toolNames = {
+  DICOMSRDisplay: 'DICOMSRDisplay',
+  SRLength: 'SRLength',
+  SRBidirectional: 'SRBidirectional',
+  SREllipticalROI: 'SREllipticalROI',
+  SRCircleROI: 'SRCircleROI',
+  SRArrowAnnotate: 'SRArrowAnnotate',
+  SRAngle: 'SRAngle',
+  SRCobbAngle: 'SRCobbAngle',
+  SRRectangleROI: 'SRRectangleROI',
+  SRPlanarFreehandROI: 'SRPlanarFreehandROI',
+  SRSCOORD3DPoint: 'SRSCOORD3DPoint'
+};
+/* harmony default export */ const tools_toolNames = (toolNames);
+;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-sr/src/utils/addSRAnnotation.ts
 
-      // We get the other point for the arrow by using the image size
-      const imagePixelModule = core_dist_esm.metaData.get('imagePixelModule', referencedImageId);
-      let xOffset = 10;
-      let yOffset = 10;
-      if (imagePixelModule) {
-        const {
-          columns,
-          rows
-        } = imagePixelModule;
-        xOffset = columns / 10;
-        yOffset = rows / 10;
-      }
-      const imagePoint = core_dist_esm.utilities.worldToImageCoords(referencedImageId, point);
-      const arrowEnd = core_dist_esm.utilities.imageToWorldCoords(referencedImageId, [imagePoint[0] + xOffset, imagePoint[1] + yOffset]);
-      canvasCoordinates.push(viewport.worldToCanvas(arrowEnd));
-      const arrowUID = `${index}`;
 
-      // Todo: handle drawing probe as probe, currently we are drawing it as an arrow
-      dist_esm.drawing.drawArrow(svgDrawingHelper, annotationUID, arrowUID, canvasCoordinates[1], canvasCoordinates[0], {
-        color: options.color,
-        width: options.lineWidth
-      });
-    });
-    return canvasCoordinates; // used for drawing textBox
+
+
+function addSRAnnotation(measurement, imageId, frameNumber) {
+  let toolName = tools_toolNames.DICOMSRDisplay;
+  const renderableData = measurement.coords.reduce((acc, coordProps) => {
+    acc[coordProps.GraphicType] = acc[coordProps.GraphicType] || [];
+    acc[coordProps.GraphicType].push(utils_getRenderableData({
+      ...coordProps,
+      imageId
+    }));
+    return acc;
+  }, {});
+  const {
+    TrackingUniqueIdentifier
+  } = measurement;
+  const {
+    ValueType: valueType,
+    GraphicType: graphicType
+  } = measurement.coords[0];
+  const graphicTypePoints = renderableData[graphicType];
+
+  /** TODO: Read the tool name from the DICOM SR identification type in the future. */
+  let frameOfReferenceUID = null;
+  if (imageId) {
+    const imagePlaneModule = dist_esm.metaData.get('imagePlaneModule', imageId);
+    frameOfReferenceUID = imagePlaneModule?.frameOfReferenceUID;
   }
-  renderEllipse(svgDrawingHelper, viewport, renderableData, annotationUID, referencedImageId, options) {
-    let canvasCoordinates;
-    renderableData.map((data, index) => {
-      if (data.length === 0) {
-        // since oblique ellipse is not supported for hydration right now
-        // we just return
-        return;
-      }
-      const ellipsePointsWorld = data;
-      const rotation = viewport.getRotation();
-      canvasCoordinates = ellipsePointsWorld.map(p => viewport.worldToCanvas(p));
-      let canvasCorners;
-      if (rotation == 90 || rotation == 270) {
-        canvasCorners = dist_esm.utilities.math.ellipse.getCanvasEllipseCorners([canvasCoordinates[2], canvasCoordinates[3], canvasCoordinates[0], canvasCoordinates[1]]);
-      } else {
-        canvasCorners = dist_esm.utilities.math.ellipse.getCanvasEllipseCorners(canvasCoordinates);
-      }
-      const lineUID = `${index}`;
-      dist_esm.drawing.drawEllipse(svgDrawingHelper, annotationUID, lineUID, canvasCorners[0], canvasCorners[1], {
-        color: options.color,
-        width: options.lineWidth,
-        lineDash: options.lineDash
-      });
-    });
-    return canvasCoordinates;
-  }
-  renderTextBox(svgDrawingHelper, viewport, canvasCoordinates, canvasCoordinatesAdapter, annotation, styleSpecifier, options = {}) {
-    if (!canvasCoordinates || !annotation) {
-      return;
-    }
-    const {
-      annotationUID,
-      data = {}
-    } = annotation;
-    const {
-      label
-    } = data;
-    const {
-      color
-    } = options;
-    let adaptedCanvasCoordinates = canvasCoordinates;
-    // adapt coordinates if there is an adapter
-    if (typeof canvasCoordinatesAdapter === 'function') {
-      adaptedCanvasCoordinates = canvasCoordinatesAdapter(canvasCoordinates);
-    }
-    const textLines = this._getTextBoxLinesFromLabels(label);
-    const canvasTextBoxCoords = dist_esm.utilities.drawing.getTextBoxCoordsCanvas(adaptedCanvasCoordinates);
-    if (!annotation.data?.handles?.textBox?.worldPosition) {
-      annotation.data.handles.textBox.worldPosition = viewport.canvasToWorld(canvasTextBoxCoords);
-    }
-    const textBoxPosition = viewport.worldToCanvas(annotation.data.handles.textBox.worldPosition);
-    const textBoxUID = '1';
-    const textBoxOptions = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
-    const boundingBox = dist_esm.drawing.drawLinkedTextBox(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, {
-      ...textBoxOptions,
-      color
-    });
-    const {
-      x: left,
-      y: top,
-      width,
-      height
-    } = boundingBox;
-    annotation.data.handles.textBox.worldBoundingBox = {
-      topLeft: viewport.canvasToWorld([left, top]),
-      topRight: viewport.canvasToWorld([left + width, top]),
-      bottomLeft: viewport.canvasToWorld([left, top + height]),
-      bottomRight: viewport.canvasToWorld([left + width, top + height])
-    };
-  }
-}
-DICOMSRDisplayTool.toolName = 'DICOMSRDisplay';
-const SHORT_HAND_MAP = {
-  'Short Axis': 'W: ',
-  'Long Axis': 'L: ',
-  AREA: 'Area: ',
-  Length: '',
-  CORNERSTONEFREETEXT: ''
-};
-function _labelToShorthand(label) {
-  const shortHand = SHORT_HAND_MAP[label];
-  if (shortHand !== undefined) {
-    return shortHand;
-  }
-  return label;
-}
-;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-sr/src/tools/toolNames.ts
-
-const toolNames = {
-  DICOMSRDisplay: DICOMSRDisplayTool.toolName,
-  SRLength: 'SRLength',
-  SRBidirectional: 'SRBidirectional',
-  SREllipticalROI: 'SREllipticalROI',
-  SRCircleROI: 'SRCircleROI',
-  SRArrowAnnotate: 'SRArrowAnnotate',
-  SRAngle: 'SRAngle',
-  SRCobbAngle: 'SRCobbAngle',
-  SRRectangleROI: 'SRRectangleROI',
-  SRPlanarFreehandROI: 'SRPlanarFreehandROI'
-};
-/* harmony default export */ const tools_toolNames = (toolNames);
-;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-sr/src/utils/addDICOMSRDisplayAnnotation.ts
-
-
-
-
-
-const EPSILON = 1e-4;
-function addDICOMSRDisplayAnnotation(measurement, imageId, frameNumber) {
-  const toolName = tools_toolNames.DICOMSRDisplay;
-  const measurementData = {
-    TrackingUniqueIdentifier: measurement.TrackingUniqueIdentifier,
-    renderableData: {},
-    labels: measurement.labels,
-    imageId
-  };
-  measurement.coords.forEach(coord => {
-    const {
-      GraphicType,
-      GraphicData
-    } = coord;
-    if (measurementData.renderableData[GraphicType] === undefined) {
-      measurementData.renderableData[GraphicType] = [];
-    }
-    measurementData.renderableData[GraphicType].push(_getRenderableData(GraphicType, GraphicData, imageId));
-  });
-  const imagePlaneModule = core_dist_esm.metaData.get('imagePlaneModule', imageId);
+  if (valueType === 'SCOORD3D') {
+    toolName = tools_toolNames.SRSCOORD3DPoint;
 
-  /**
-   * 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.
-   */
+    // get the ReferencedFrameOfReferenceUID from the measurement
+    frameOfReferenceUID = measurement.coords[0].ReferencedFrameOfReferenceSequence;
+  }
   const SRAnnotation = {
-    annotationUID: measurement.TrackingUniqueIdentifier,
+    annotationUID: TrackingUniqueIdentifier,
     highlighted: false,
     isLocked: false,
     invalidated: false,
     metadata: {
-      toolName: toolName,
-      FrameOfReferenceUID: imagePlaneModule.frameOfReferenceUID,
+      toolName,
+      valueType,
+      graphicType,
+      FrameOfReferenceUID: frameOfReferenceUID,
       referencedImageId: imageId
     },
     data: {
-      label: measurement.labels,
+      label: measurement.labels?.[0]?.value || undefined,
+      displayText: measurement.displayText || undefined,
       handles: {
-        textBox: measurement.textBox ?? {}
+        textBox: measurement.textBox ?? {},
+        points: graphicTypePoints[0]
       },
       cachedStats: {},
-      TrackingUniqueIdentifier: measurementData.TrackingUniqueIdentifier,
-      renderableData: measurementData.renderableData,
-      frameNumber
+      frameNumber,
+      renderableData,
+      TrackingUniqueIdentifier,
+      labels: measurement.labels
     }
   };
-  const annotationManager = dist_esm.annotation.state.getAnnotationManager();
-  annotationManager.addAnnotation(SRAnnotation);
-}
-function _getRenderableData(GraphicType, GraphicData, imageId) {
-  let renderableData;
-  switch (GraphicType) {
-    case scoordTypes.POINT:
-    case scoordTypes.MULTIPOINT:
-    case scoordTypes.POLYLINE:
-      renderableData = [];
-      for (let i = 0; i < GraphicData.length; i += 2) {
-        const worldPos = core_dist_esm.utilities.imageToWorldCoords(imageId, [GraphicData[i], GraphicData[i + 1]]);
-        renderableData.push(worldPos);
-      }
-      break;
-    case scoordTypes.CIRCLE:
-      {
-        const pointsWorld = [];
-        for (let i = 0; i < GraphicData.length; i += 2) {
-          const worldPos = core_dist_esm.utilities.imageToWorldCoords(imageId, [GraphicData[i], GraphicData[i + 1]]);
-          pointsWorld.push(worldPos);
-        }
-
-        // We do not have an explicit draw circle svg helper in Cornerstone3D at
-        // this time, but we can use the ellipse svg helper to draw a circle, so
-        // here we reshape the data for that purpose.
-        const center = pointsWorld[0];
-        const onPerimeter = pointsWorld[1];
-        const radius = esm/* vec3.distance */.R3.distance(center, onPerimeter);
-        const imagePlaneModule = core_dist_esm.metaData.get('imagePlaneModule', imageId);
-        if (!imagePlaneModule) {
-          throw new Error('No imagePlaneModule found');
-        }
-        const {
-          columnCosines,
-          rowCosines
-        } = imagePlaneModule;
-
-        // we need to get major/minor axis (which are both the same size major = minor)
-
-        // first axisStart
-        const firstAxisStart = esm/* vec3.create */.R3.create();
-        esm/* vec3.scaleAndAdd */.R3.scaleAndAdd(firstAxisStart, center, columnCosines, radius);
-        const firstAxisEnd = esm/* vec3.create */.R3.create();
-        esm/* vec3.scaleAndAdd */.R3.scaleAndAdd(firstAxisEnd, center, columnCosines, -radius);
-
-        // second axisStart
-        const secondAxisStart = esm/* vec3.create */.R3.create();
-        esm/* vec3.scaleAndAdd */.R3.scaleAndAdd(secondAxisStart, center, rowCosines, radius);
-        const secondAxisEnd = esm/* vec3.create */.R3.create();
-        esm/* vec3.scaleAndAdd */.R3.scaleAndAdd(secondAxisEnd, center, rowCosines, -radius);
-        renderableData = [firstAxisStart, firstAxisEnd, secondAxisStart, secondAxisEnd];
-        break;
-      }
-    case scoordTypes.ELLIPSE:
-      {
-        // GraphicData is ordered as [majorAxisStartX, majorAxisStartY, majorAxisEndX, majorAxisEndY, minorAxisStartX, minorAxisStartY, minorAxisEndX, minorAxisEndY]
-        // But Cornerstone3D points are ordered as top, bottom, left, right for the
-        // ellipse so we need to identify if the majorAxis is horizontal or vertical
-        // and then choose the correct points to use for the ellipse.
-
-        const pointsWorld = [];
-        for (let i = 0; i < GraphicData.length; i += 2) {
-          const worldPos = core_dist_esm.utilities.imageToWorldCoords(imageId, [GraphicData[i], GraphicData[i + 1]]);
-          pointsWorld.push(worldPos);
-        }
-        const majorAxisStart = esm/* vec3.fromValues */.R3.fromValues(...pointsWorld[0]);
-        const majorAxisEnd = esm/* vec3.fromValues */.R3.fromValues(...pointsWorld[1]);
-        const minorAxisStart = esm/* vec3.fromValues */.R3.fromValues(...pointsWorld[2]);
-        const minorAxisEnd = esm/* vec3.fromValues */.R3.fromValues(...pointsWorld[3]);
-        const majorAxisVec = esm/* vec3.create */.R3.create();
-        esm/* vec3.sub */.R3.sub(majorAxisVec, majorAxisEnd, majorAxisStart);
-
-        // normalize majorAxisVec to avoid scaling issues
-        esm/* vec3.normalize */.R3.normalize(majorAxisVec, majorAxisVec);
-        const minorAxisVec = esm/* vec3.create */.R3.create();
-        esm/* vec3.sub */.R3.sub(minorAxisVec, minorAxisEnd, minorAxisStart);
-        esm/* vec3.normalize */.R3.normalize(minorAxisVec, minorAxisVec);
-        const imagePlaneModule = core_dist_esm.metaData.get('imagePlaneModule', imageId);
-        if (!imagePlaneModule) {
-          throw new Error('imageId does not have imagePlaneModule metadata');
-        }
-        const {
-          columnCosines
-        } = imagePlaneModule;
 
-        // find which axis is parallel to the columnCosines
-        const columnCosinesVec = esm/* vec3.fromValues */.R3.fromValues(...columnCosines);
-        const projectedMajorAxisOnColVec = Math.abs(esm/* vec3.dot */.R3.dot(columnCosinesVec, majorAxisVec));
-        const projectedMinorAxisOnColVec = Math.abs(esm/* vec3.dot */.R3.dot(columnCosinesVec, minorAxisVec));
-        const absoluteOfMajorDotProduct = Math.abs(projectedMajorAxisOnColVec);
-        const absoluteOfMinorDotProduct = Math.abs(projectedMinorAxisOnColVec);
-        renderableData = [];
-        if (Math.abs(absoluteOfMajorDotProduct - 1) < EPSILON) {
-          renderableData = [pointsWorld[0], pointsWorld[1], pointsWorld[2], pointsWorld[3]];
-        } else if (Math.abs(absoluteOfMinorDotProduct - 1) < EPSILON) {
-          renderableData = [pointsWorld[2], pointsWorld[3], pointsWorld[0], pointsWorld[1]];
-        } else {
-          console.warn('OBLIQUE ELLIPSE NOT YET SUPPORTED');
-        }
-        break;
-      }
-    default:
-      console.warn('Unsupported GraphicType:', GraphicType);
-  }
-  return renderableData;
+  /**
+   * const annotationManager = annotation.annotationState.getAnnotationManager();
+   * was not triggering annotation_added events.
+   */
+  esm.annotation.state.addAnnotation(SRAnnotation);
+  console.debug('Adding SR annotation:', SRAnnotation);
 }
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/adapters/dist/adapters.es.js
-var adapters_es = __webpack_require__(91202);
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-sr/src/utils/isRehydratable.js
 
 const cornerstoneAdapters = adapters_es.adaptersSR.Cornerstone3D.MeasurementReport.CORNERSTONE_TOOL_CLASSES_BY_UTILITY_TYPE;
 const supportedLegacyCornerstoneTags = ['cornerstoneTools@^4.0.0'];
-const CORNERSTONE_3D_TAG = cornerstoneAdapters.CORNERSTONE_3D_TAG;
+const CORNERSTONE_3D_TAG = adapters_es.adaptersSR.Cornerstone3D.CORNERSTONE_3D_TAG;
 
 /**
  * Checks if the given `displaySet`can be rehydrated into the `measurementService`.
@@ -558,8 +352,16 @@ function isRehydratable(displaySet, mappings) {
   console.log('No measurements found which were rehydratable');
   return false;
 }
-// EXTERNAL MODULE: ../../../extensions/cornerstone-dicom-sr/src/constants/CodeNameCodeSequenceValues.ts
-var CodeNameCodeSequenceValues = __webpack_require__(91851);
+;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-sr/package.json
+const package_namespaceObject = JSON.parse('{"u2":"@ohif/extension-cornerstone-dicom-sr"}');
+;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-sr/src/id.js
+
+const id = package_namespaceObject.u2;
+const SOPClassHandlerName = 'dicom-sr';
+const SOPClassHandlerId = `${id}.sopClassHandlerModule.${SOPClassHandlerName}`;
+const SOPClassHandlerName3D = 'dicom-sr-3d';
+const SOPClassHandlerId3D = `${id}.sopClassHandlerModule.${SOPClassHandlerName3D}`;
+
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-sr/src/getSopClassHandlerModule.ts
 
 
@@ -567,30 +369,29 @@ var CodeNameCodeSequenceValues = __webpack_require__(91851);
 
 
 
+
 const {
-  CodeScheme: Cornerstone3DCodeScheme
-} = adapters_es.adaptersSR.Cornerstone3D;
+  sopClassDictionary
+} = src.utils;
+const {
+  CORNERSTONE_3D_TOOLS_SOURCE_NAME,
+  CORNERSTONE_3D_TOOLS_SOURCE_VERSION
+} = cornerstone_src.Enums;
 const {
   ImageSet,
   MetadataProvider: metadataProvider
 } = src.classes;
+const {
+  CodeScheme: Cornerstone3DCodeScheme
+} = adapters_es.adaptersSR.Cornerstone3D;
+/**
+ * TODO
+ * - [ ] Add SR thumbnail
+ * - [ ] Make viewport
+ * - [ ] Get stacks from referenced displayInstanceUID and load into wrapped CornerStone viewport
+ */
 
-// TODO ->
-// Add SR thumbnail
-// Make viewport
-// Get stacks from referenced displayInstanceUID and load into wrapped CornerStone viewport.
-
-const sopClassUids = ['1.2.840.10008.5.1.4.1.1.88.11',
-// BASIC TEXT SR
-'1.2.840.10008.5.1.4.1.1.88.22',
-// ENHANCED SR
-'1.2.840.10008.5.1.4.1.1.88.33',
-// COMPREHENSIVE SR
-'1.2.840.10008.5.1.4.1.1.88.34' // Comprehensive 3D SR
-// '1.2.840.10008.5.1.4.1.1.88.50', // Mammography CAD SR
-];
-const CORNERSTONE_3D_TOOLS_SOURCE_NAME = 'Cornerstone3DTools';
-const CORNERSTONE_3D_TOOLS_SOURCE_VERSION = '0.1';
+const sopClassUids = [sopClassDictionary.BasicTextSR, sopClassDictionary.EnhancedSR, sopClassDictionary.ComprehensiveSR];
 const validateSameStudyUID = (uid, instances) => {
   instances.forEach(it => {
     if (it.StudyInstanceUID !== uid) {
@@ -599,15 +400,6 @@ const validateSameStudyUID = (uid, instances) => {
     }
   });
 };
-const CodingSchemeDesignators = {
-  SRT: 'SRT',
-  CornerstoneCodeSchemes: [Cornerstone3DCodeScheme.CodingSchemeDesignator, 'CST4']
-};
-const RELATIONSHIP_TYPE = {
-  INFERRED_FROM: 'INFERRED FROM',
-  CONTAINS: 'CONTAINS'
-};
-const CORNERSTONE_FREETEXT_CODE_VALUE = 'CORNERSTONEFREETEXT';
 
 /**
  * Adds instances to the DICOM SR series, rather than creating a new
@@ -656,7 +448,8 @@ function _getDisplaySetsFromSeries(instances, servicesManager, extensionManager)
     SOPClassUID
   } = instance;
   validateSameStudyUID(instance.StudyInstanceUID, instances);
-  const isImagingMeasurementReport = ConceptNameCodeSequence?.CodeValue === CodeNameCodeSequenceValues/* default */.Z.ImagingMeasurementReport;
+  const is3DSR = SOPClassUID === sopClassDictionary.Comprehensive3DSR;
+  const isImagingMeasurementReport = ConceptNameCodeSequence?.CodeValue === enums/* CodeNameCodeSequenceValues */.zg.ImagingMeasurementReport;
   const displaySet = {
     Modality: 'SR',
     displaySetInstanceUID: src.utils.guid(),
@@ -666,7 +459,7 @@ function _getDisplaySetsFromSeries(instances, servicesManager, extensionManager)
     SOPInstanceUID,
     SeriesInstanceUID,
     StudyInstanceUID,
-    SOPClassHandlerId: SOPClassHandlerId,
+    SOPClassHandlerId: is3DSR ? SOPClassHandlerId3D : SOPClassHandlerId,
     SOPClassUID,
     instances,
     referencedImages: null,
@@ -681,7 +474,14 @@ function _getDisplaySetsFromSeries(instances, servicesManager, extensionManager)
   displaySet.load = () => _load(displaySet, servicesManager, extensionManager);
   return [displaySet];
 }
-async function _load(displaySet, servicesManager, extensionManager) {
+
+/**
+ * Loads the display set with the given services and extension manager.
+ * @param srDisplaySet - The display set to load.
+ * @param servicesManager - The services manager containing displaySetService and measurementService.
+ * @param extensionManager - The extension manager containing data sources.
+ */
+async function _load(srDisplaySet, servicesManager, extensionManager) {
   const {
     displaySetService,
     measurementService
@@ -690,7 +490,7 @@ async function _load(displaySet, servicesManager, extensionManager) {
   const dataSource = dataSources[0];
   const {
     ContentSequence
-  } = displaySet.instance;
+  } = srDisplaySet.instance;
   async function retrieveBulkData(obj, parentObj = null, key = null) {
     for (const prop in obj) {
       if (typeof obj[prop] === 'object' && obj[prop] !== null) {
@@ -700,9 +500,9 @@ async function _load(displaySet, servicesManager, extensionManager) {
       } 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
+          StudyInstanceUID: srDisplaySet.instance.StudyInstanceUID,
+          SeriesInstanceUID: srDisplaySet.instance.SeriesInstanceUID,
+          SOPInstanceUID: srDisplaySet.instance.SOPInstanceUID
         });
         if (parentObj && key) {
           parentObj[key] = new Float32Array(value);
@@ -710,123 +510,134 @@ async function _load(displaySet, servicesManager, extensionManager) {
       }
     }
   }
-  if (displaySet.isLoaded !== true) {
+  if (srDisplaySet.isLoaded !== true) {
     await retrieveBulkData(ContentSequence);
   }
-  if (displaySet.isImagingMeasurementReport) {
-    displaySet.referencedImages = _getReferencedImagesList(ContentSequence);
-    displaySet.measurements = _getMeasurements(ContentSequence);
+  if (srDisplaySet.isImagingMeasurementReport) {
+    srDisplaySet.referencedImages = _getReferencedImagesList(ContentSequence);
+    srDisplaySet.measurements = _getMeasurements(ContentSequence);
   } else {
-    displaySet.referencedImages = [];
-    displaySet.measurements = [];
+    srDisplaySet.referencedImages = [];
+    srDisplaySet.measurements = [];
   }
   const mappings = measurementService.getSourceMappings(CORNERSTONE_3D_TOOLS_SOURCE_NAME, CORNERSTONE_3D_TOOLS_SOURCE_VERSION);
-  displaySet.isHydrated = false;
-  displaySet.isRehydratable = isRehydratable(displaySet, mappings);
-  displaySet.isLoaded = true;
+  srDisplaySet.isHydrated = false;
+  srDisplaySet.isRehydratable = isRehydratable(srDisplaySet, mappings);
+  srDisplaySet.isLoaded = true;
 
-  // Check currently added displaySets and add measurements if the sources exist.
+  /** Check currently added displaySets and add measurements if the sources exist */
   displaySetService.activeDisplaySets.forEach(activeDisplaySet => {
-    _checkIfCanAddMeasurementsToDisplaySet(displaySet, activeDisplaySet, dataSource, servicesManager);
+    _checkIfCanAddMeasurementsToDisplaySet(srDisplaySet, activeDisplaySet, dataSource, servicesManager);
   });
 
-  // Subscribe to new displaySets as the source may come in after.
+  /** Subscribe to new displaySets as the source may come in after */
   displaySetService.subscribe(displaySetService.EVENTS.DISPLAY_SETS_ADDED, data => {
     const {
       displaySetsAdded
     } = data;
-    // If there are still some measurements that have not yet been loaded into cornerstone,
-    // See if we can load them onto any of the new displaySets.
+    /**
+     * If there are still some measurements that have not yet been loaded into cornerstone,
+     * See if we can load them onto any of the new displaySets.
+     */
     displaySetsAdded.forEach(newDisplaySet => {
-      _checkIfCanAddMeasurementsToDisplaySet(displaySet, newDisplaySet, dataSource, servicesManager);
+      _checkIfCanAddMeasurementsToDisplaySet(srDisplaySet, newDisplaySet, dataSource, servicesManager);
     });
   });
 }
+
+/**
+ * Checks if measurements can be added to a display set.
+ *
+ * @param srDisplaySet - The source display set containing measurements.
+ * @param newDisplaySet - The new display set to check if measurements can be added.
+ * @param dataSource - The data source used to retrieve image IDs.
+ * @param servicesManager - The services manager.
+ */
 function _checkIfCanAddMeasurementsToDisplaySet(srDisplaySet, newDisplaySet, dataSource, servicesManager) {
   const {
     customizationService
   } = servicesManager.services;
-  let unloadedMeasurements = srDisplaySet.measurements.filter(measurement => measurement.loaded === false);
-  if (unloadedMeasurements.length === 0) {
-    // All already loaded!
+  const unloadedMeasurements = srDisplaySet.measurements.filter(measurement => measurement.loaded === false);
+  if (unloadedMeasurements.length === 0 || !(newDisplaySet instanceof ImageSet) || newDisplaySet.unsupported) {
     return;
   }
-  if (!newDisplaySet instanceof ImageSet) {
-    // This also filters out _this_ displaySet, as it is not an ImageSet.
-    return;
+
+  // const { sopClassUids } = newDisplaySet;
+  // Create a Set for faster lookups
+  // const sopClassUidSet = new Set(sopClassUids);
+
+  // Create a Map to efficiently look up ImageIds by SOPInstanceUID and frame number
+  const imageIdMap = new Map();
+  const imageIds = dataSource.getImageIdsForDisplaySet(newDisplaySet);
+  for (const imageId of imageIds) {
+    const {
+      SOPInstanceUID,
+      frameNumber
+    } = metadataProvider.getUIDsFromImageID(imageId);
+    const key = `${SOPInstanceUID}:${frameNumber || 1}`;
+    imageIdMap.set(key, imageId);
   }
-  if (newDisplaySet.unsupported) {
+  if (!unloadedMeasurements?.length) {
     return;
   }
-  const {
-    sopClassUids
-  } = newDisplaySet;
+  const is3DSR = srDisplaySet.SOPClassUID === sopClassDictionary.Comprehensive3DSR;
+  for (let j = unloadedMeasurements.length - 1; j >= 0; j--) {
+    let measurement = unloadedMeasurements[j];
+    const onBeforeSRAddMeasurement = customizationService.getModeCustomization('onBeforeSRAddMeasurement')?.value;
+    if (typeof onBeforeSRAddMeasurement === 'function') {
+      measurement = onBeforeSRAddMeasurement({
+        measurement,
+        StudyInstanceUID: srDisplaySet.StudyInstanceUID,
+        SeriesInstanceUID: srDisplaySet.SeriesInstanceUID
+      });
+    }
 
-  // Check if any have the newDisplaySet is the correct SOPClass.
-  unloadedMeasurements = unloadedMeasurements.filter(measurement => measurement.coords.some(coord => sopClassUids.includes(coord.ReferencedSOPSequence.ReferencedSOPClassUID)));
-  if (unloadedMeasurements.length === 0) {
-    // New displaySet isn't the correct SOPClass, so can't contain the referenced images.
-    return;
-  }
-  const SOPInstanceUIDs = [];
-  unloadedMeasurements.forEach(measurement => {
-    const {
-      coords
-    } = measurement;
-    coords.forEach(coord => {
-      const SOPInstanceUID = coord.ReferencedSOPSequence.ReferencedSOPInstanceUID;
-      if (!SOPInstanceUIDs.includes(SOPInstanceUID)) {
-        SOPInstanceUIDs.push(SOPInstanceUID);
-      }
-    });
-  });
-  const imageIdsForDisplaySet = dataSource.getImageIdsForDisplaySet(newDisplaySet);
-  for (const imageId of imageIdsForDisplaySet) {
-    if (!unloadedMeasurements.length) {
-      // All measurements loaded.
-      return;
+    // if it is 3d SR we can just add the SR annotation
+    if (is3DSR) {
+      addSRAnnotation(measurement, null, null);
+      measurement.loaded = true;
+      continue;
+    }
+    const referencedSOPSequence = measurement.coords[0].ReferencedSOPSequence;
+    if (!referencedSOPSequence) {
+      continue;
     }
     const {
-      SOPInstanceUID,
-      frameNumber
-    } = metadataProvider.getUIDsFromImageID(imageId);
-    if (SOPInstanceUIDs.includes(SOPInstanceUID)) {
-      for (let j = unloadedMeasurements.length - 1; j >= 0; j--) {
-        let measurement = unloadedMeasurements[j];
-        const onBeforeSRAddMeasurement = customizationService.getModeCustomization('onBeforeSRAddMeasurement')?.value;
-        if (typeof onBeforeSRAddMeasurement === 'function') {
-          measurement = onBeforeSRAddMeasurement({
-            measurement,
-            StudyInstanceUID: srDisplaySet.StudyInstanceUID,
-            SeriesInstanceUID: srDisplaySet.SeriesInstanceUID
-          });
-        }
-        if (_measurementReferencesSOPInstanceUID(measurement, SOPInstanceUID, frameNumber)) {
-          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);
-        }
-      }
+      ReferencedSOPInstanceUID
+    } = referencedSOPSequence;
+    const frame = referencedSOPSequence.ReferencedFrameNumber || 1;
+    const key = `${ReferencedSOPInstanceUID}:${frame}`;
+    const imageId = imageIdMap.get(key);
+    if (imageId && _measurementReferencesSOPInstanceUID(measurement, ReferencedSOPInstanceUID, frame)) {
+      addSRAnnotation(measurement, imageId, frame);
+
+      // Update measurement properties
+      measurement.loaded = true;
+      measurement.imageId = imageId;
+      measurement.displaySetInstanceUID = newDisplaySet.displaySetInstanceUID;
+      measurement.ReferencedSOPInstanceUID = ReferencedSOPInstanceUID;
+      measurement.frameNumber = frame;
+      unloadedMeasurements.splice(j, 1);
     }
   }
 }
+
+/**
+ * Checks if a measurement references a specific SOP Instance UID.
+ * @param measurement - The measurement object.
+ * @param SOPInstanceUID - The SOP Instance UID to check against.
+ * @param frameNumber - The frame number to check against (optional).
+ * @returns True if the measurement references the specified SOP Instance UID, false otherwise.
+ */
 function _measurementReferencesSOPInstanceUID(measurement, SOPInstanceUID, frameNumber) {
   const {
     coords
   } = measurement;
 
-  // NOTE: The ReferencedFrameNumber can be multiple values according to the DICOM
-  //  Standard. But for now, we will support only one ReferenceFrameNumber.
+  /**
+   * 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?.ReferencedFrameNumber || 1;
   if (frameNumber && Number(frameNumber) !== Number(ReferencedFrameNumber)) {
     return false;
@@ -840,7 +651,17 @@ function _measurementReferencesSOPInstanceUID(measurement, SOPInstanceUID, frame
       return true;
     }
   }
+  return false;
 }
+
+/**
+ * Retrieves the SOP class handler module.
+ *
+ * @param {Object} options - The options for retrieving the SOP class handler module.
+ * @param {Object} options.servicesManager - The services manager.
+ * @param {Object} options.extensionManager - The extension manager.
+ * @returns {Array} An array containing the SOP class handler module.
+ */
 function getSopClassHandlerModule({
   servicesManager,
   extensionManager
@@ -852,14 +673,25 @@ function getSopClassHandlerModule({
     name: SOPClassHandlerName,
     sopClassUids,
     getDisplaySetsFromSeries
+  }, {
+    name: SOPClassHandlerName3D,
+    sopClassUids: [sopClassDictionary.Comprehensive3DSR],
+    getDisplaySetsFromSeries
   }];
 }
+
+/**
+ * Retrieves the measurements from the ImagingMeasurementReportContentSequence.
+ *
+ * @param {Array} ImagingMeasurementReportContentSequence - The ImagingMeasurementReportContentSequence array.
+ * @returns {Array} - The array of measurements.
+ */
 function _getMeasurements(ImagingMeasurementReportContentSequence) {
-  const ImagingMeasurements = ImagingMeasurementReportContentSequence.find(item => item.ConceptNameCodeSequence.CodeValue === CodeNameCodeSequenceValues/* default */.Z.ImagingMeasurements);
+  const ImagingMeasurements = ImagingMeasurementReportContentSequence.find(item => item.ConceptNameCodeSequence.CodeValue === enums/* CodeNameCodeSequenceValues */.zg.ImagingMeasurements);
   if (!ImagingMeasurements) {
     return [];
   }
-  const MeasurementGroups = _getSequenceAsArray(ImagingMeasurements.ContentSequence).filter(item => item.ConceptNameCodeSequence.CodeValue === CodeNameCodeSequenceValues/* default */.Z.MeasurementGroup);
+  const MeasurementGroups = _getSequenceAsArray(ImagingMeasurements.ContentSequence).filter(item => item.ConceptNameCodeSequence.CodeValue === enums/* CodeNameCodeSequenceValues */.zg.MeasurementGroup);
   const mergedContentSequencesByTrackingUniqueIdentifiers = _getMergedContentSequencesByTrackingUniqueIdentifiers(MeasurementGroups);
   const measurements = [];
   Object.keys(mergedContentSequencesByTrackingUniqueIdentifiers).forEach(trackingUniqueIdentifier => {
@@ -871,11 +703,18 @@ function _getMeasurements(ImagingMeasurementReportContentSequence) {
   });
   return measurements;
 }
+
+/**
+ * Retrieves merged content sequences by tracking unique identifiers.
+ *
+ * @param {Array} MeasurementGroups - The measurement groups.
+ * @returns {Object} - The merged content sequences by tracking unique identifiers.
+ */
 function _getMergedContentSequencesByTrackingUniqueIdentifiers(MeasurementGroups) {
   const mergedContentSequencesByTrackingUniqueIdentifiers = {};
   MeasurementGroups.forEach(MeasurementGroup => {
     const ContentSequence = _getSequenceAsArray(MeasurementGroup.ContentSequence);
-    const TrackingUniqueIdentifierItem = ContentSequence.find(item => item.ConceptNameCodeSequence.CodeValue === CodeNameCodeSequenceValues/* default */.Z.TrackingUniqueIdentifier);
+    const TrackingUniqueIdentifierItem = ContentSequence.find(item => item.ConceptNameCodeSequence.CodeValue === enums/* CodeNameCodeSequenceValues */.zg.TrackingUniqueIdentifier);
     if (!TrackingUniqueIdentifierItem) {
       console.warn('No Tracking Unique Identifier, skipping ambiguous measurement.');
     }
@@ -887,7 +726,7 @@ function _getMergedContentSequencesByTrackingUniqueIdentifiers(MeasurementGroups
       // Add the ContentSequence minus the tracking identifier, as we have this
       // Information in the merged ContentSequence anyway.
       ContentSequence.forEach(item => {
-        if (item.ConceptNameCodeSequence.CodeValue !== CodeNameCodeSequenceValues/* default */.Z.TrackingUniqueIdentifier) {
+        if (item.ConceptNameCodeSequence.CodeValue !== enums/* CodeNameCodeSequenceValues */.zg.TrackingUniqueIdentifier) {
           mergedContentSequencesByTrackingUniqueIdentifiers[trackingUniqueIdentifier].push(item);
         }
       });
@@ -895,19 +734,38 @@ function _getMergedContentSequencesByTrackingUniqueIdentifiers(MeasurementGroups
   });
   return mergedContentSequencesByTrackingUniqueIdentifiers;
 }
+
+/**
+ * Processes the measurement based on the merged content sequence.
+ * If the merged content sequence contains SCOORD or SCOORD3D value types,
+ * it calls the _processTID1410Measurement function.
+ * Otherwise, it calls the _processNonGeometricallyDefinedMeasurement function.
+ *
+ * @param {Array<Object>} mergedContentSequence - The merged content sequence to process.
+ * @returns {any} - The processed measurement result.
+ */
 function _processMeasurement(mergedContentSequence) {
   if (mergedContentSequence.some(group => group.ValueType === 'SCOORD' || group.ValueType === 'SCOORD3D')) {
     return _processTID1410Measurement(mergedContentSequence);
   }
   return _processNonGeometricallyDefinedMeasurement(mergedContentSequence);
 }
+
+/**
+ * Processes TID 1410 style measurements from the mergedContentSequence.
+ * TID 1410 style measurements have a SCOORD or SCOORD3D at the top level,
+ * and non-geometric representations where each NUM has "INFERRED FROM" SCOORD/SCOORD3D.
+ *
+ * @param mergedContentSequence - The merged content sequence containing the measurements.
+ * @returns The measurement object containing the loaded status, labels, coordinates, tracking unique identifier, and tracking identifier.
+ */
 function _processTID1410Measurement(mergedContentSequence) {
   // Need to deal with TID 1410 style measurements, which will have a SCOORD or SCOORD3D at the top level,
   // And non-geometric representations where each NUM has "INFERRED FROM" SCOORD/SCOORD3D
 
-  const graphicItem = mergedContentSequence.find(group => group.ValueType === 'SCOORD');
+  const graphicItem = mergedContentSequence.find(group => group.ValueType === 'SCOORD' || group.ValueType === 'SCOORD3D');
   const UIDREFContentItem = mergedContentSequence.find(group => group.ValueType === 'UIDREF');
-  const TrackingIdentifierContentItem = mergedContentSequence.find(item => item.ConceptNameCodeSequence.CodeValue === CodeNameCodeSequenceValues/* default */.Z.TrackingIdentifier);
+  const TrackingIdentifierContentItem = mergedContentSequence.find(item => item.ConceptNameCodeSequence.CodeValue === enums/* CodeNameCodeSequenceValues */.zg.TrackingIdentifier);
   if (!graphicItem) {
     console.warn(`graphic ValueType ${graphicItem.ValueType} not currently supported, skipping annotation.`);
     return;
@@ -929,14 +787,28 @@ function _processTID1410Measurement(mergedContentSequence) {
       measurement.labels.push(_getLabelFromMeasuredValueSequence(ConceptNameCodeSequence, MeasuredValueSequence));
     }
   });
+  const findingSites = mergedContentSequence.filter(item => item.ConceptNameCodeSequence.CodingSchemeDesignator === enums/* CodingSchemeDesignators */.Ql.SCT && item.ConceptNameCodeSequence.CodeValue === enums/* CodeNameCodeSequenceValues */.zg.FindingSiteSCT);
+  if (findingSites.length) {
+    measurement.labels.push({
+      label: enums/* CodeNameCodeSequenceValues */.zg.FindingSiteSCT,
+      value: findingSites[0].ConceptCodeSequence.CodeMeaning
+    });
+  }
   return measurement;
 }
+
+/**
+ * Processes the non-geometrically defined measurement from the merged content sequence.
+ *
+ * @param mergedContentSequence The merged content sequence containing the measurement data.
+ * @returns The processed measurement object.
+ */
 function _processNonGeometricallyDefinedMeasurement(mergedContentSequence) {
   const NUMContentItems = mergedContentSequence.filter(group => group.ValueType === 'NUM');
   const UIDREFContentItem = mergedContentSequence.find(group => group.ValueType === 'UIDREF');
-  const TrackingIdentifierContentItem = mergedContentSequence.find(item => item.ConceptNameCodeSequence.CodeValue === CodeNameCodeSequenceValues/* default */.Z.TrackingIdentifier);
-  const finding = mergedContentSequence.find(item => item.ConceptNameCodeSequence.CodeValue === CodeNameCodeSequenceValues/* default */.Z.Finding);
-  const findingSites = mergedContentSequence.filter(item => item.ConceptNameCodeSequence.CodingSchemeDesignator === CodingSchemeDesignators.SRT && item.ConceptNameCodeSequence.CodeValue === CodeNameCodeSequenceValues/* default */.Z.FindingSite);
+  const TrackingIdentifierContentItem = mergedContentSequence.find(item => item.ConceptNameCodeSequence.CodeValue === enums/* CodeNameCodeSequenceValues */.zg.TrackingIdentifier);
+  const finding = mergedContentSequence.find(item => item.ConceptNameCodeSequence.CodeValue === enums/* CodeNameCodeSequenceValues */.zg.Finding);
+  const findingSites = mergedContentSequence.filter(item => item.ConceptNameCodeSequence.CodingSchemeDesignator === enums/* CodingSchemeDesignators */.Ql.SRT && item.ConceptNameCodeSequence.CodeValue === enums/* CodeNameCodeSequenceValues */.zg.FindingSite);
   const measurement = {
     loaded: false,
     labels: [],
@@ -944,19 +816,19 @@ function _processNonGeometricallyDefinedMeasurement(mergedContentSequence) {
     TrackingUniqueIdentifier: UIDREFContentItem.UID,
     TrackingIdentifier: TrackingIdentifierContentItem.TextValue
   };
-  if (finding && CodingSchemeDesignators.CornerstoneCodeSchemes.includes(finding.ConceptCodeSequence.CodingSchemeDesignator) && finding.ConceptCodeSequence.CodeValue === CodeNameCodeSequenceValues/* default */.Z.CornerstoneFreeText) {
+  if (finding && enums/* CodingSchemeDesignators */.Ql.CornerstoneCodeSchemes.includes(finding.ConceptCodeSequence.CodingSchemeDesignator) && finding.ConceptCodeSequence.CodeValue === Cornerstone3DCodeScheme.codeValues.CORNERSTONEFREETEXT) {
     measurement.labels.push({
-      label: CORNERSTONE_FREETEXT_CODE_VALUE,
+      label: Cornerstone3DCodeScheme.codeValues.CORNERSTONEFREETEXT,
       value: finding.ConceptCodeSequence.CodeMeaning
     });
   }
 
   // TODO -> Eventually hopefully support SNOMED or some proper code library, just free text for now.
   if (findingSites.length) {
-    const cornerstoneFreeTextFindingSite = findingSites.find(FindingSite => CodingSchemeDesignators.CornerstoneCodeSchemes.includes(FindingSite.ConceptCodeSequence.CodingSchemeDesignator) && FindingSite.ConceptCodeSequence.CodeValue === CodeNameCodeSequenceValues/* default */.Z.CornerstoneFreeText);
+    const cornerstoneFreeTextFindingSite = findingSites.find(FindingSite => enums/* CodingSchemeDesignators */.Ql.CornerstoneCodeSchemes.includes(FindingSite.ConceptCodeSequence.CodingSchemeDesignator) && FindingSite.ConceptCodeSequence.CodeValue === Cornerstone3DCodeScheme.codeValues.CORNERSTONEFREETEXT);
     if (cornerstoneFreeTextFindingSite) {
       measurement.labels.push({
-        label: CORNERSTONE_FREETEXT_CODE_VALUE,
+        label: Cornerstone3DCodeScheme.codeValues.CORNERSTONEFREETEXT,
         value: cornerstoneFreeTextFindingSite.ConceptCodeSequence.CodeMeaning
       });
     }
@@ -984,37 +856,37 @@ function _processNonGeometricallyDefinedMeasurement(mergedContentSequence) {
   });
   return measurement;
 }
-function _getCoordsFromSCOORDOrSCOORD3D(item) {
+
+/**
+ * Extracts coordinates from a graphic item of type SCOORD or SCOORD3D.
+ * @param {object} graphicItem - The graphic item containing the coordinates.
+ * @returns {object} - The extracted coordinates.
+ */
+const _getCoordsFromSCOORDOrSCOORD3D = graphicItem => {
   const {
     ValueType,
-    RelationshipType,
     GraphicType,
     GraphicData
-  } = item;
-  if (!(RelationshipType == RELATIONSHIP_TYPE.INFERRED_FROM || RelationshipType == RELATIONSHIP_TYPE.CONTAINS)) {
-    console.warn(`Relationshiptype === ${RelationshipType}. Cannot deal with NON TID-1400 SCOORD group with RelationshipType !== "INFERRED FROM" or "CONTAINS"`);
-    return;
-  }
+  } = graphicItem;
   const coords = {
     ValueType,
     GraphicType,
     GraphicData
   };
-
-  // ContentSequence has length of 1 as RelationshipType === 'INFERRED FROM'
-  if (ValueType === 'SCOORD') {
-    const {
-      ReferencedSOPSequence
-    } = item.ContentSequence;
-    coords.ReferencedSOPSequence = ReferencedSOPSequence;
-  } else if (ValueType === 'SCOORD3D') {
-    const {
-      ReferencedFrameOfReferenceSequence
-    } = item.ContentSequence;
-    coords.ReferencedFrameOfReferenceSequence = ReferencedFrameOfReferenceSequence;
-  }
+  coords.ReferencedSOPSequence = graphicItem.ContentSequence?.ReferencedSOPSequence;
+  coords.ReferencedFrameOfReferenceSequence = graphicItem.ReferencedFrameOfReferenceUID || graphicItem.ContentSequence?.ReferencedFrameOfReferenceSequence;
   return coords;
-}
+};
+
+/**
+ * Retrieves the label and value from the provided ConceptNameCodeSequence and MeasuredValueSequence.
+ * @param {Object} ConceptNameCodeSequence - The ConceptNameCodeSequence object.
+ * @param {Object} MeasuredValueSequence - The MeasuredValueSequence object.
+ * @returns {Object} - An object containing the label and value.
+ *                    The label represents the CodeMeaning from the ConceptNameCodeSequence.
+ *                    The value represents the formatted NumericValue and CodeValue from the MeasuredValueSequence.
+ *                    Example: { label: 'Long Axis', value: '31.00 mm' }
+ */
 function _getLabelFromMeasuredValueSequence(ConceptNameCodeSequence, MeasuredValueSequence) {
   const {
     CodeMeaning
@@ -1032,12 +904,22 @@ function _getLabelFromMeasuredValueSequence(ConceptNameCodeSequence, MeasuredVal
     value: `${formatedNumericValue} ${CodeValue}`
   }; // E.g. Long Axis: 31.0 mm
 }
+
+/**
+ * Retrieves a list of referenced images from the Imaging Measurement Report Content Sequence.
+ *
+ * @param {Array} ImagingMeasurementReportContentSequence - The Imaging Measurement Report Content Sequence.
+ * @returns {Array} - The list of referenced images.
+ */
 function _getReferencedImagesList(ImagingMeasurementReportContentSequence) {
-  const ImageLibrary = ImagingMeasurementReportContentSequence.find(item => item.ConceptNameCodeSequence.CodeValue === CodeNameCodeSequenceValues/* default */.Z.ImageLibrary);
+  const ImageLibrary = ImagingMeasurementReportContentSequence.find(item => item.ConceptNameCodeSequence.CodeValue === enums/* CodeNameCodeSequenceValues */.zg.ImageLibrary);
   if (!ImageLibrary) {
     return [];
   }
-  const ImageLibraryGroup = _getSequenceAsArray(ImageLibrary.ContentSequence).find(item => item.ConceptNameCodeSequence.CodeValue === CodeNameCodeSequenceValues/* default */.Z.ImageLibraryGroup);
+  const ImageLibraryGroup = _getSequenceAsArray(ImageLibrary.ContentSequence).find(item => item.ConceptNameCodeSequence.CodeValue === enums/* CodeNameCodeSequenceValues */.zg.ImageLibraryGroup);
+  if (!ImageLibraryGroup) {
+    return [];
+  }
   const referencedImages = [];
   _getSequenceAsArray(ImageLibraryGroup.ContentSequence).forEach(item => {
     const {
@@ -1061,6 +943,16 @@ function _getReferencedImagesList(ImagingMeasurementReportContentSequence) {
   });
   return referencedImages;
 }
+
+/**
+ * Converts a DICOM sequence to an array.
+ * If the sequence is null or undefined, an empty array is returned.
+ * If the sequence is already an array, it is returned as is.
+ * Otherwise, the sequence is wrapped in an array and returned.
+ *
+ * @param {any} sequence - The DICOM sequence to convert.
+ * @returns {any[]} - The converted array.
+ */
 function _getSequenceAsArray(sequence) {
   if (!sequence) {
     return [];
@@ -1141,7 +1033,7 @@ function onModeEnter({
     displaySetService
   } = servicesManager.services;
   const displaySetCache = displaySetService.getDisplaySetCache();
-  const srDisplaySets = [...displaySetCache.values()].filter(ds => ds.SOPClassHandlerId === SOPClassHandlerId);
+  const srDisplaySets = [...displaySetCache.values()].filter(ds => ds.SOPClassHandlerId === SOPClassHandlerId || ds.SOPClassHandlerId === SOPClassHandlerId3D);
   srDisplaySets.forEach(ds => {
     // New mode route, allow SRs to be hydrated again
     ds.isHydrated = false;
@@ -1196,188 +1088,675 @@ function getFilteredCornerstoneToolState(measurementData, additionalFindingTypes
         });
       }
     }
-    if (measurementDataI.findingSites) {
-      findingSites.push(...measurementDataI.findingSites);
+    if (measurementDataI.findingSites) {
+      findingSites.push(...measurementDataI.findingSites);
+    }
+    const measurement = Object.assign({}, annotation, {
+      finding,
+      findingSites
+    });
+    toolData.push(measurement);
+  }
+  const uidFilter = measurementData.map(md => md.uid);
+  const uids = uidFilter.slice();
+  const annotationManager = esm.annotation.state.getAnnotationManager();
+  const framesOfReference = annotationManager.getFramesOfReference();
+  for (let i = 0; i < framesOfReference.length; i++) {
+    const frameOfReference = framesOfReference[i];
+    const frameOfReferenceAnnotations = annotationManager.getAnnotations(frameOfReference);
+    const toolTypes = Object.keys(frameOfReferenceAnnotations);
+    for (let j = 0; j < toolTypes.length; j++) {
+      const toolType = toolTypes[j];
+      const annotations = frameOfReferenceAnnotations[toolType];
+      if (annotations) {
+        for (let k = 0; k < annotations.length; k++) {
+          const annotation = annotations[k];
+          const uidIndex = uids.findIndex(uid => uid === annotation.annotationUID);
+          if (uidIndex !== -1) {
+            addToFilteredToolState(annotation, toolType);
+            uids.splice(uidIndex, 1);
+            if (!uids.length) {
+              return filteredToolState;
+            }
+          }
+        }
+      }
+    }
+  }
+  return filteredToolState;
+}
+/* harmony default export */ const utils_getFilteredCornerstoneToolState = (getFilteredCornerstoneToolState);
+;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-sr/src/commandsModule.ts
+
+
+
+
+
+const {
+  MeasurementReport
+} = adapters_es.adaptersSR.Cornerstone3D;
+const {
+  log: commandsModule_log
+} = src["default"];
+
+/**
+ *
+ * @param measurementData An array of measurements from the measurements service
+ * that you wish to serialize.
+ * @param additionalFindingTypes toolTypes that should be stored with labels as Findings
+ * @param options Naturalized DICOM JSON headers to merge into the displaySet.
+ *
+ */
+const _generateReport = (measurementData, additionalFindingTypes, options = {}) => {
+  const filteredToolState = utils_getFilteredCornerstoneToolState(measurementData, additionalFindingTypes);
+  const report = MeasurementReport.generateReport(filteredToolState, dist_esm.metaData, dist_esm.utilities.worldToImageCoords, options);
+  const {
+    dataset
+  } = report;
+
+  // Set the default character set as UTF-8
+  // https://dicom.innolitics.com/ciods/nm-image/sop-common/00080005
+  if (typeof dataset.SpecificCharacterSet === 'undefined') {
+    dataset.SpecificCharacterSet = 'ISO_IR 192';
+  }
+  return dataset;
+};
+const commandsModule = props => {
+  const {
+    servicesManager
+  } = props;
+  const {
+    customizationService
+  } = servicesManager.services;
+  const actions = {
+    /**
+     *
+     * @param measurementData An array of measurements from the measurements service
+     * @param additionalFindingTypes toolTypes that should be stored with labels as Findings
+     * @param options Naturalized DICOM JSON headers to merge into the displaySet.
+     * as opposed to Finding Sites.
+     * that you wish to serialize.
+     */
+    downloadReport: ({
+      measurementData,
+      additionalFindingTypes,
+      options = {}
+    }) => {
+      const srDataset = actions.generateReport(measurementData, additionalFindingTypes, options);
+      const reportBlob = dcmjs_es["default"].data.datasetToBlob(srDataset);
+
+      //Create a URL for the binary.
+      const objectUrl = URL.createObjectURL(reportBlob);
+      window.location.assign(objectUrl);
+    },
+    /**
+     *
+     * @param measurementData An array of measurements from the measurements service
+     * that you wish to serialize.
+     * @param dataSource The dataSource that you wish to use to persist the data.
+     * @param additionalFindingTypes toolTypes that should be stored with labels as Findings
+     * @param options Naturalized DICOM JSON headers to merge into the displaySet.
+     * @return The naturalized report
+     */
+    storeMeasurements: async ({
+      measurementData,
+      dataSource,
+      additionalFindingTypes,
+      options = {}
+    }) => {
+      // Use the @cornerstonejs adapter for converting to/from DICOM
+      // But it is good enough for now whilst we only have cornerstone as a datasource.
+      commandsModule_log.info('[DICOMSR] storeMeasurements');
+      if (!dataSource || !dataSource.store || !dataSource.store.dicom) {
+        commandsModule_log.error('[DICOMSR] datasource has no dataSource.store.dicom endpoint!');
+        return Promise.reject({});
+      }
+      try {
+        const naturalizedReport = _generateReport(measurementData, additionalFindingTypes, options);
+        const {
+          StudyInstanceUID,
+          ContentSequence
+        } = naturalizedReport;
+        // The content sequence has 5 or more elements, of which
+        // the `[4]` element contains the annotation data, so this is
+        // checking that there is some annotation data present.
+        if (!ContentSequence?.[4].ContentSequence?.length) {
+          console.log('naturalizedReport missing imaging content', naturalizedReport);
+          throw new Error('Invalid report, no content');
+        }
+        const onBeforeDicomStore = customizationService.getModeCustomization('onBeforeDicomStore')?.value;
+        let dicomDict;
+        if (typeof onBeforeDicomStore === 'function') {
+          dicomDict = onBeforeDicomStore({
+            measurementData,
+            naturalizedReport
+          });
+        }
+        await dataSource.store.dicom(naturalizedReport, null, dicomDict);
+        if (StudyInstanceUID) {
+          dataSource.deleteStudyMetadataPromise(StudyInstanceUID);
+        }
+
+        // The "Mode" route listens for DicomMetadataStore changes
+        // When a new instance is added, it listens and
+        // automatically calls makeDisplaySets
+        src.DicomMetadataStore.addInstances([naturalizedReport], true);
+        return naturalizedReport;
+      } catch (error) {
+        console.warn(error);
+        commandsModule_log.error(`[DICOMSR] Error while saving the measurements: ${error.message}`);
+        throw new Error(error.message || 'Error while saving the measurements.');
+      }
+    }
+  };
+  const definitions = {
+    downloadReport: {
+      commandFn: actions.downloadReport
+    },
+    storeMeasurements: {
+      commandFn: actions.storeMeasurements
+    }
+  };
+  return {
+    actions,
+    definitions,
+    defaultContext: 'CORNERSTONE_STRUCTURED_REPORT'
+  };
+};
+/* harmony default export */ const src_commandsModule = (commandsModule);
+// EXTERNAL MODULE: ../../../extensions/cornerstone-dicom-sr/src/tools/modules/dicomSRModule.js
+var dicomSRModule = __webpack_require__(75449);
+;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-sr/src/tools/DICOMSRDisplayTool.ts
+
+
+
+
+
+class DICOMSRDisplayTool extends esm.AnnotationTool {
+  constructor(toolProps = {}, defaultToolProps = {
+    configuration: {}
+  }) {
+    super(toolProps, defaultToolProps);
+    // This tool should not inherit from AnnotationTool and we should not need
+    // to add the following lines.
+    this.isPointNearTool = () => null;
+    this.getHandleNearImagePoint = () => null;
+    this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
+      const {
+        viewport
+      } = enabledElement;
+      const {
+        element
+      } = viewport;
+      let annotations = esm.annotation.state.getAnnotations(this.getToolName(), element);
+
+      // Todo: We don't need this anymore, filtering happens in triggerAnnotationRender
+      if (!annotations?.length) {
+        return;
+      }
+      annotations = this.filterInteractableAnnotationsForElement(element, annotations);
+      if (!annotations?.length) {
+        return;
+      }
+      const trackingUniqueIdentifiersForElement = (0,dicomSRModule/* getTrackingUniqueIdentifiersForElement */.yR)(element);
+      const {
+        activeIndex,
+        trackingUniqueIdentifiers
+      } = trackingUniqueIdentifiersForElement;
+      const activeTrackingUniqueIdentifier = trackingUniqueIdentifiers[activeIndex];
+
+      // Filter toolData to only render the data for the active SR.
+      const filteredAnnotations = annotations.filter(annotation => trackingUniqueIdentifiers.includes(annotation.data?.TrackingUniqueIdentifier));
+      if (!viewport._actors?.size) {
+        return;
+      }
+      const styleSpecifier = {
+        toolGroupId: this.toolGroupId,
+        toolName: this.getToolName(),
+        viewportId: enabledElement.viewport.id
+      };
+      const {
+        style: annotationStyle
+      } = esm.annotation.config;
+      for (let i = 0; i < filteredAnnotations.length; i++) {
+        const annotation = filteredAnnotations[i];
+        const annotationUID = annotation.annotationUID;
+        const {
+          renderableData,
+          TrackingUniqueIdentifier
+        } = annotation.data;
+        const {
+          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 = TrackingUniqueIdentifier === activeTrackingUniqueIdentifier ? 'rgb(0, 255, 0)' : this.getStyle('color', styleSpecifier, annotation);
+        const options = {
+          color,
+          lineDash,
+          lineWidth,
+          ...groupStyle
+        };
+        Object.keys(renderableData).forEach(GraphicType => {
+          const renderableDataForGraphicType = renderableData[GraphicType];
+          let renderMethod;
+          let canvasCoordinatesAdapter;
+          switch (GraphicType) {
+            case enums/* SCOORDTypes */.oQ.POINT:
+              renderMethod = this.renderPoint;
+              break;
+            case enums/* SCOORDTypes */.oQ.MULTIPOINT:
+              renderMethod = this.renderMultipoint;
+              break;
+            case enums/* SCOORDTypes */.oQ.POLYLINE:
+              renderMethod = this.renderPolyLine;
+              break;
+            case enums/* SCOORDTypes */.oQ.CIRCLE:
+              renderMethod = this.renderEllipse;
+              break;
+            case enums/* SCOORDTypes */.oQ.ELLIPSE:
+              renderMethod = this.renderEllipse;
+              canvasCoordinatesAdapter = esm.utilities.math.ellipse.getCanvasEllipseCorners;
+              break;
+            default:
+              throw new Error(`Unsupported GraphicType: ${GraphicType}`);
+          }
+          const canvasCoordinates = renderMethod(svgDrawingHelper, viewport, renderableDataForGraphicType, annotationUID, referencedImageId, options);
+          this.renderTextBox(svgDrawingHelper, viewport, canvasCoordinates, canvasCoordinatesAdapter, annotation, styleSpecifier, options);
+        });
+      }
+    };
+  }
+  _getTextBoxLinesFromLabels(labels) {
+    // TODO -> max 5 for now (label + shortAxis + longAxis), need a generic solution for this!
+
+    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}`);
+    }
+    return lines;
+  }
+  renderPolyLine(svgDrawingHelper, viewport, renderableData, annotationUID, referencedImageId, options) {
+    const drawingOptions = {
+      color: options.color,
+      width: options.lineWidth,
+      lineDash: options.lineDash
+    };
+    let allCanvasCoordinates = [];
+    renderableData.map((data, index) => {
+      const canvasCoordinates = data.map(p => viewport.worldToCanvas(p));
+      const lineUID = `${index}`;
+      if (canvasCoordinates.length === 2) {
+        esm.drawing.drawLine(svgDrawingHelper, annotationUID, lineUID, canvasCoordinates[0], canvasCoordinates[1], drawingOptions);
+      } else {
+        esm.drawing.drawPolyline(svgDrawingHelper, annotationUID, lineUID, canvasCoordinates, drawingOptions);
+      }
+      allCanvasCoordinates = allCanvasCoordinates.concat(canvasCoordinates);
+    });
+    return allCanvasCoordinates; // used for drawing textBox
+  }
+  renderMultipoint(svgDrawingHelper, viewport, renderableData, annotationUID, referencedImageId, options) {
+    let canvasCoordinates;
+    renderableData.map((data, index) => {
+      canvasCoordinates = data.map(p => viewport.worldToCanvas(p));
+      const handleGroupUID = '0';
+      esm.drawing.drawHandles(svgDrawingHelper, annotationUID, handleGroupUID, canvasCoordinates, {
+        color: options.color
+      });
+    });
+  }
+  renderPoint(svgDrawingHelper, viewport, renderableData, annotationUID, referencedImageId, options) {
+    const canvasCoordinates = [];
+    renderableData.map((data, index) => {
+      const point = data[0];
+      // This gives us one point for arrow
+      canvasCoordinates.push(viewport.worldToCanvas(point));
+      if (data[1] !== undefined) {
+        canvasCoordinates.push(viewport.worldToCanvas(data[1]));
+      } else {
+        // We get the other point for the arrow by using the image size
+        const imagePixelModule = dist_esm.metaData.get('imagePixelModule', referencedImageId);
+        let xOffset = 10;
+        let yOffset = 10;
+        if (imagePixelModule) {
+          const {
+            columns,
+            rows
+          } = imagePixelModule;
+          xOffset = columns / 10;
+          yOffset = rows / 10;
+        }
+        const imagePoint = dist_esm.utilities.worldToImageCoords(referencedImageId, point);
+        const arrowEnd = dist_esm.utilities.imageToWorldCoords(referencedImageId, [imagePoint[0] + xOffset, imagePoint[1] + yOffset]);
+        canvasCoordinates.push(viewport.worldToCanvas(arrowEnd));
+      }
+      const arrowUID = `${index}`;
+
+      // Todo: handle drawing probe as probe, currently we are drawing it as an arrow
+      esm.drawing.drawArrow(svgDrawingHelper, annotationUID, arrowUID, canvasCoordinates[1], canvasCoordinates[0], {
+        color: options.color,
+        width: options.lineWidth
+      });
+    });
+    return canvasCoordinates; // used for drawing textBox
+  }
+  renderEllipse(svgDrawingHelper, viewport, renderableData, annotationUID, referencedImageId, options) {
+    let canvasCoordinates;
+    renderableData.map((data, index) => {
+      if (data.length === 0) {
+        // since oblique ellipse is not supported for hydration right now
+        // we just return
+        return;
+      }
+      const ellipsePointsWorld = data;
+      const rotation = viewport.getRotation();
+      canvasCoordinates = ellipsePointsWorld.map(p => viewport.worldToCanvas(p));
+      let canvasCorners;
+      if (rotation == 90 || rotation == 270) {
+        canvasCorners = esm.utilities.math.ellipse.getCanvasEllipseCorners([canvasCoordinates[2], canvasCoordinates[3], canvasCoordinates[0], canvasCoordinates[1]]);
+      } else {
+        canvasCorners = esm.utilities.math.ellipse.getCanvasEllipseCorners(canvasCoordinates);
+      }
+      const lineUID = `${index}`;
+      esm.drawing.drawEllipse(svgDrawingHelper, annotationUID, lineUID, canvasCorners[0], canvasCorners[1], {
+        color: options.color,
+        width: options.lineWidth,
+        lineDash: options.lineDash
+      });
+    });
+    return canvasCoordinates;
+  }
+  renderTextBox(svgDrawingHelper, viewport, canvasCoordinates, canvasCoordinatesAdapter, annotation, styleSpecifier, options = {}) {
+    if (!canvasCoordinates || !annotation) {
+      return;
+    }
+    const {
+      annotationUID,
+      data = {}
+    } = annotation;
+    const {
+      labels
+    } = data;
+    const {
+      color
+    } = options;
+    let adaptedCanvasCoordinates = canvasCoordinates;
+    // adapt coordinates if there is an adapter
+    if (typeof canvasCoordinatesAdapter === 'function') {
+      adaptedCanvasCoordinates = canvasCoordinatesAdapter(canvasCoordinates);
+    }
+    const textLines = this._getTextBoxLinesFromLabels(labels);
+    const canvasTextBoxCoords = esm.utilities.drawing.getTextBoxCoordsCanvas(adaptedCanvasCoordinates);
+    if (!annotation.data?.handles?.textBox?.worldPosition) {
+      annotation.data.handles.textBox.worldPosition = viewport.canvasToWorld(canvasTextBoxCoords);
+    }
+    const textBoxPosition = viewport.worldToCanvas(annotation.data.handles.textBox.worldPosition);
+    const textBoxUID = '1';
+    const textBoxOptions = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+    const boundingBox = esm.drawing.drawLinkedTextBox(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, {
+      ...textBoxOptions,
+      color
+    });
+    const {
+      x: left,
+      y: top,
+      width,
+      height
+    } = boundingBox;
+    annotation.data.handles.textBox.worldBoundingBox = {
+      topLeft: viewport.canvasToWorld([left, top]),
+      topRight: viewport.canvasToWorld([left + width, top]),
+      bottomLeft: viewport.canvasToWorld([left, top + height]),
+      bottomRight: viewport.canvasToWorld([left + width, top + height])
+    };
+  }
+}
+DICOMSRDisplayTool.toolName = tools_toolNames.DICOMSRDisplay;
+const SHORT_HAND_MAP = {
+  'Short Axis': 'W: ',
+  'Long Axis': 'L: ',
+  AREA: 'Area: ',
+  Length: '',
+  CORNERSTONEFREETEXT: ''
+};
+function _labelToShorthand(label) {
+  const shortHand = SHORT_HAND_MAP[label];
+  if (shortHand !== undefined) {
+    return shortHand;
+  }
+  return label;
+}
+;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-sr/src/tools/SCOORD3DPointTool.ts
+
+
+class SCOORD3DPointTool extends esm.AnnotationDisplayTool {
+  constructor(toolProps = {}, defaultToolProps = {
+    configuration: {}
+  }) {
+    super(toolProps, defaultToolProps);
+    // This tool should not inherit from AnnotationTool and we should not need
+    // to add the following lines.
+    this.isPointNearTool = () => null;
+    this.getHandleNearImagePoint = () => null;
+    this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
+      const {
+        viewport
+      } = enabledElement;
+      const {
+        element
+      } = viewport;
+      const annotations = esm.annotation.state.getAnnotations(this.getToolName(), element);
+
+      // Todo: We don't need this anymore, filtering happens in triggerAnnotationRender
+      if (!annotations?.length) {
+        return;
+      }
+
+      // Filter toolData to only render the data for the active SR.
+      const filteredAnnotations = annotations;
+      if (!viewport._actors?.size) {
+        return;
+      }
+      const styleSpecifier = {
+        toolGroupId: this.toolGroupId,
+        toolName: this.getToolName(),
+        viewportId: enabledElement.viewport.id
+      };
+      for (let i = 0; i < filteredAnnotations.length; i++) {
+        const annotation = filteredAnnotations[i];
+        const annotationUID = annotation.annotationUID;
+        const {
+          renderableData
+        } = annotation.data;
+        const {
+          POINT: points
+        } = renderableData;
+        styleSpecifier.annotationUID = annotationUID;
+        const lineWidth = this.getStyle('lineWidth', styleSpecifier, annotation);
+        const lineDash = this.getStyle('lineDash', styleSpecifier, annotation);
+        const color = this.getStyle('color', styleSpecifier, annotation);
+        const options = {
+          color,
+          lineDash,
+          lineWidth
+        };
+        const point = points[0][0];
+
+        // check if viewport can render it
+        const viewable = viewport.isReferenceViewable({
+          FrameOfReferenceUID: annotation.metadata.FrameOfReferenceUID,
+          cameraFocalPoint: point
+        }, {
+          asNearbyProjection: true
+        });
+        if (!viewable) {
+          continue;
+        }
+
+        // render the point
+        const arrowPointCanvas = viewport.worldToCanvas(point);
+        // Todo: configure this
+        const arrowEndCanvas = [arrowPointCanvas[0] + 20, arrowPointCanvas[1] + 20];
+        const canvasCoordinates = [arrowPointCanvas, arrowEndCanvas];
+        esm.drawing.drawArrow(svgDrawingHelper, annotationUID, '1', canvasCoordinates[1], canvasCoordinates[0], {
+          color: options.color,
+          width: options.lineWidth
+        });
+        this.renderTextBox(svgDrawingHelper, viewport, canvasCoordinates, annotation, styleSpecifier, options);
+      }
+    };
+  }
+  _getTextBoxLinesFromLabels(labels) {
+    // TODO -> max 5 for now (label + shortAxis + longAxis), need a generic solution for this!
+
+    const labelLength = Math.min(labels.length, 5);
+    const lines = [];
+    return lines;
+  }
+  renderTextBox(svgDrawingHelper, viewport, canvasCoordinates, annotation, styleSpecifier, options = {}) {
+    if (!canvasCoordinates || !annotation) {
+      return;
+    }
+    const {
+      annotationUID,
+      data = {}
+    } = annotation;
+    const {
+      labels
+    } = data;
+    const textLines = [];
+    for (const label of labels) {
+      // make this generic
+      // fix this
+      if (label.label === '363698007') {
+        textLines.push(`Finding Site: ${label.value}`);
+      }
     }
-    const measurement = Object.assign({}, annotation, {
-      finding,
-      findingSites
+    const {
+      color
+    } = options;
+    const adaptedCanvasCoordinates = canvasCoordinates;
+    // adapt coordinates if there is an adapter
+    const canvasTextBoxCoords = esm.utilities.drawing.getTextBoxCoordsCanvas(adaptedCanvasCoordinates);
+    if (!annotation.data?.handles?.textBox?.worldPosition) {
+      annotation.data.handles.textBox.worldPosition = viewport.canvasToWorld(canvasTextBoxCoords);
+    }
+    const textBoxPosition = viewport.worldToCanvas(annotation.data.handles.textBox.worldPosition);
+    const textBoxUID = '1';
+    const textBoxOptions = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+    const boundingBox = esm.drawing.drawLinkedTextBox(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, {
+      ...textBoxOptions,
+      color
     });
-    toolData.push(measurement);
+    const {
+      x: left,
+      y: top,
+      width,
+      height
+    } = boundingBox;
+    annotation.data.handles.textBox.worldBoundingBox = {
+      topLeft: viewport.canvasToWorld([left, top]),
+      topRight: viewport.canvasToWorld([left + width, top]),
+      bottomLeft: viewport.canvasToWorld([left, top + height]),
+      bottomRight: viewport.canvasToWorld([left + width, top + height])
+    };
   }
-  const uidFilter = measurementData.map(md => md.uid);
-  const uids = uidFilter.slice();
-  const annotationManager = dist_esm.annotation.state.getAnnotationManager();
-  const framesOfReference = annotationManager.getFramesOfReference();
-  for (let i = 0; i < framesOfReference.length; i++) {
-    const frameOfReference = framesOfReference[i];
-    const frameOfReferenceAnnotations = annotationManager.getAnnotations(frameOfReference);
-    const toolTypes = Object.keys(frameOfReferenceAnnotations);
-    for (let j = 0; j < toolTypes.length; j++) {
-      const toolType = toolTypes[j];
-      const annotations = frameOfReferenceAnnotations[toolType];
-      if (annotations) {
-        for (let k = 0; k < annotations.length; k++) {
-          const annotation = annotations[k];
-          const uidIndex = uids.findIndex(uid => uid === annotation.annotationUID);
-          if (uidIndex !== -1) {
-            addToFilteredToolState(annotation, toolType);
-            uids.splice(uidIndex, 1);
-            if (!uids.length) {
-              return filteredToolState;
-            }
-          }
-        }
-      }
-    }
+  getLinkedTextBoxStyle(specifications, annotation) {
+    // Todo: this function can be used to set different styles for different toolMode
+    // for the textBox.
+
+    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),
+      shadow: this.getStyle('textBoxShadow', specifications, annotation),
+      background: this.getStyle('textBoxBackground', specifications, annotation),
+      lineWidth: this.getStyle('textBoxLinkLineWidth', specifications, annotation),
+      lineDash: this.getStyle('textBoxLinkLineDash', specifications, annotation)
+    };
   }
-  return filteredToolState;
 }
-/* harmony default export */ const utils_getFilteredCornerstoneToolState = (getFilteredCornerstoneToolState);
-;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-sr/src/commandsModule.ts
-
-
-
-
-
-const {
-  MeasurementReport
-} = adapters_es.adaptersSR.Cornerstone3D;
-const {
-  log: commandsModule_log
-} = src["default"];
-
-/**
- *
- * @param measurementData An array of measurements from the measurements service
- * that you wish to serialize.
- * @param additionalFindingTypes toolTypes that should be stored with labels as Findings
- * @param options Naturalized DICOM JSON headers to merge into the displaySet.
- *
- */
-const _generateReport = (measurementData, additionalFindingTypes, options = {}) => {
-  const filteredToolState = utils_getFilteredCornerstoneToolState(measurementData, additionalFindingTypes);
-  const report = MeasurementReport.generateReport(filteredToolState, core_dist_esm.metaData, core_dist_esm.utilities.worldToImageCoords, options);
-  const {
-    dataset
-  } = report;
-
-  // Set the default character set as UTF-8
-  // https://dicom.innolitics.com/ciods/nm-image/sop-common/00080005
-  if (typeof dataset.SpecificCharacterSet === 'undefined') {
-    dataset.SpecificCharacterSet = 'ISO_IR 192';
+SCOORD3DPointTool.toolName = tools_toolNames.SRSCOORD3DPoint;
+;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-sr/src/utils/SRSCOOR3DProbeMapper.ts
+const SRSCOOR3DProbe = {
+  toAnnotation: measurement => {},
+  /**
+   * Maps cornerstone annotation event data to measurement service format.
+   *
+   * @param {Object} cornerstone Cornerstone event data
+   * @return {Measurement} Measurement instance
+   */
+  toMeasurement: (csToolsEventDetail, displaySetService, CornerstoneViewportService, getValueTypeFromToolType, customizationService) => {
+    const {
+      annotation
+    } = csToolsEventDetail;
+    const {
+      metadata,
+      data,
+      annotationUID
+    } = annotation;
+    if (!metadata || !data) {
+      console.warn('Probe tool: Missing metadata or data');
+      return null;
+    }
+    const {
+      toolName
+    } = metadata;
+    const {
+      points
+    } = data.handles;
+    const displayText = getDisplayText(annotation);
+    return {
+      uid: annotationUID,
+      points,
+      metadata,
+      toolName: metadata.toolName,
+      label: data.label,
+      displayText: displayText,
+      data: data.cachedStats,
+      type: getValueTypeFromToolType?.(toolName) ?? null
+    };
   }
-  return dataset;
 };
-const commandsModule = props => {
+function getDisplayText(annotation) {
   const {
-    servicesManager
-  } = props;
+    data
+  } = annotation;
+  if (!data) {
+    return [''];
+  }
   const {
-    customizationService
-  } = servicesManager.services;
-  const actions = {
-    /**
-     *
-     * @param measurementData An array of measurements from the measurements service
-     * @param additionalFindingTypes toolTypes that should be stored with labels as Findings
-     * @param options Naturalized DICOM JSON headers to merge into the displaySet.
-     * as opposed to Finding Sites.
-     * that you wish to serialize.
-     */
-    downloadReport: ({
-      measurementData,
-      additionalFindingTypes,
-      options = {}
-    }) => {
-      const srDataset = actions.generateReport(measurementData, additionalFindingTypes, options);
-      const reportBlob = dcmjs_es["default"].data.datasetToBlob(srDataset);
-
-      //Create a URL for the binary.
-      const objectUrl = URL.createObjectURL(reportBlob);
-      window.location.assign(objectUrl);
-    },
-    /**
-     *
-     * @param measurementData An array of measurements from the measurements service
-     * that you wish to serialize.
-     * @param dataSource The dataSource that you wish to use to persist the data.
-     * @param additionalFindingTypes toolTypes that should be stored with labels as Findings
-     * @param options Naturalized DICOM JSON headers to merge into the displaySet.
-     * @return The naturalized report
-     */
-    storeMeasurements: async ({
-      measurementData,
-      dataSource,
-      additionalFindingTypes,
-      options = {}
-    }) => {
-      // Use the @cornerstonejs adapter for converting to/from DICOM
-      // But it is good enough for now whilst we only have cornerstone as a datasource.
-      commandsModule_log.info('[DICOMSR] storeMeasurements');
-      if (!dataSource || !dataSource.store || !dataSource.store.dicom) {
-        commandsModule_log.error('[DICOMSR] datasource has no dataSource.store.dicom endpoint!');
-        return Promise.reject({});
-      }
-      try {
-        const naturalizedReport = _generateReport(measurementData, additionalFindingTypes, options);
-        const {
-          StudyInstanceUID,
-          ContentSequence
-        } = naturalizedReport;
-        // The content sequence has 5 or more elements, of which
-        // the `[4]` element contains the annotation data, so this is
-        // checking that there is some annotation data present.
-        if (!ContentSequence?.[4].ContentSequence?.length) {
-          console.log('naturalizedReport missing imaging content', naturalizedReport);
-          throw new Error('Invalid report, no content');
-        }
-        const onBeforeDicomStore = customizationService.getModeCustomization('onBeforeDicomStore')?.value;
-        let dicomDict;
-        if (typeof onBeforeDicomStore === 'function') {
-          dicomDict = onBeforeDicomStore({
-            measurementData,
-            naturalizedReport
-          });
-        }
-        await dataSource.store.dicom(naturalizedReport, null, dicomDict);
-        if (StudyInstanceUID) {
-          dataSource.deleteStudyMetadataPromise(StudyInstanceUID);
-        }
-
-        // The "Mode" route listens for DicomMetadataStore changes
-        // When a new instance is added, it listens and
-        // automatically calls makeDisplaySets
-        src.DicomMetadataStore.addInstances([naturalizedReport], true);
-        return naturalizedReport;
-      } catch (error) {
-        console.warn(error);
-        commandsModule_log.error(`[DICOMSR] Error while saving the measurements: ${error.message}`);
-        throw new Error(error.message || 'Error while saving the measurements.');
-      }
-    }
-  };
-  const definitions = {
-    downloadReport: {
-      commandFn: actions.downloadReport
-    },
-    storeMeasurements: {
-      commandFn: actions.storeMeasurements
+    labels
+  } = data;
+  const displayText = [];
+  for (const label of labels) {
+    // make this generic
+    if (label.label === '33636980076') {
+      displayText.push(`Finding Site: ${label.value}`);
     }
-  };
-  return {
-    actions,
-    definitions,
-    defaultContext: 'CORNERSTONE_STRUCTURED_REPORT'
-  };
-};
-/* harmony default export */ const src_commandsModule = (commandsModule);
+  }
+  return displayText;
+}
+/* harmony default export */ const SRSCOOR3DProbeMapper = (SRSCOOR3DProbe);
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-sr/src/utils/addToolInstance.ts
 
-function addToolInstance(name, toolClass, configuration) {
-  class InstanceClass extends toolClass {}
+function addToolInstance(name, toolClass, configuration = {}) {
+  class InstanceClass extends toolClass {
+    constructor(toolProps, defaultToolProps) {
+      toolProps.configuration = toolProps.configuration ? {
+        ...toolProps.configuration,
+        ...configuration
+      } : configuration;
+      super(toolProps, defaultToolProps);
+    }
+  }
   InstanceClass.toolName = name;
-  (0,dist_esm.addTool)(InstanceClass);
+  (0,esm.addTool)(InstanceClass);
 }
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-sr/src/init.ts
 
@@ -1385,30 +1764,49 @@ function addToolInstance(name, toolClass, configuration) {
 
 
 
+
+
+
+const {
+  CORNERSTONE_3D_TOOLS_SOURCE_NAME: init_CORNERSTONE_3D_TOOLS_SOURCE_NAME,
+  CORNERSTONE_3D_TOOLS_SOURCE_VERSION: init_CORNERSTONE_3D_TOOLS_SOURCE_VERSION
+} = cornerstone_src.Enums;
+
 /**
  * @param {object} configuration
  */
 function init({
-  configuration = {}
+  configuration = {},
+  servicesManager
 }) {
+  const {
+    measurementService,
+    cornerstoneViewportService
+  } = servicesManager.services;
   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);
+  addToolInstance(tools_toolNames.SRLength, esm.LengthTool);
+  addToolInstance(tools_toolNames.SRBidirectional, esm.BidirectionalTool);
+  addToolInstance(tools_toolNames.SREllipticalROI, esm.EllipticalROITool);
+  addToolInstance(tools_toolNames.SRCircleROI, esm.CircleROITool);
+  addToolInstance(tools_toolNames.SRArrowAnnotate, esm.ArrowAnnotateTool);
+  addToolInstance(tools_toolNames.SRAngle, esm.AngleTool);
+  addToolInstance(tools_toolNames.SRPlanarFreehandROI, esm.PlanarFreehandROITool);
+  addToolInstance(tools_toolNames.SRRectangleROI, esm.RectangleROITool);
+  addToolInstance(tools_toolNames.SRSCOORD3DPoint, SCOORD3DPointTool);
 
   // TODO - fix the SR display of Cobb Angle, as it joins the two lines
-  addToolInstance(tools_toolNames.SRCobbAngle, dist_esm.CobbAngleTool);
+  addToolInstance(tools_toolNames.SRCobbAngle, esm.CobbAngleTool);
+  const csTools3DVer1MeasurementSource = measurementService.getSource(init_CORNERSTONE_3D_TOOLS_SOURCE_NAME, init_CORNERSTONE_3D_TOOLS_SOURCE_VERSION);
+  const {
+    POINT
+  } = measurementService.VALUE_TYPES;
+  measurementService.addMapping(csTools3DVer1MeasurementSource, 'SRSCOORD3DPoint', POINT, SRSCOOR3DProbeMapper.toAnnotation, SRSCOOR3DProbeMapper.toMeasurement);
 
   // Modify annotation tools to use dashed lines on SR
   const dashedLine = {
     lineDash: '4,4'
   };
-  dist_esm.annotation.config.style.setToolGroupToolStyles('SRToolGroup', {
+  esm.annotation.config.style.setToolGroupToolStyles('SRToolGroup', {
     [tools_toolNames.DICOMSRDisplay]: dashedLine,
     SRLength: dashedLine,
     SRBidirectional: dashedLine,
@@ -1421,6 +1819,28 @@ function init({
     SRRectangleROI: dashedLine,
     global: {}
   });
+  measurementService.subscribe(src.MeasurementService.EVENTS.JUMP_TO_MEASUREMENT_LAYOUT, ({
+    viewportId,
+    measurement,
+    isConsumed
+  }) => {
+    if (isConsumed) {
+      return;
+    }
+    try {
+      const currentViewport = cornerstoneViewportService.getCornerstoneViewport(viewportId);
+      const {
+        viewPlaneNormal
+      } = currentViewport.getCamera();
+      const referencedImageId = esm.utilities.getClosestImageIdForStackViewport(currentViewport, measurement.points[0], viewPlaneNormal);
+      const imageIndex = currentViewport.getImageIds().indexOf(referencedImageId);
+      esm.utilities.jumpToSlice(currentViewport.element, {
+        imageIndex
+      });
+    } catch (error) {
+      console.warn('Unable to jump to image based on measurement coordinate', error);
+    }
+  });
 }
 // EXTERNAL MODULE: ../../../extensions/cornerstone-dicom-sr/src/utils/hydrateStructuredReport.ts + 1 modules
 var hydrateStructuredReport = __webpack_require__(83330);
@@ -1438,6 +1858,7 @@ function _extends() { return _extends = Object.assign ? Object.assign.bind() : f
 
 
 
+
 const Component = /*#__PURE__*/react.lazy(() => {
   return __webpack_require__.e(/* import() */ 8714).then(__webpack_require__.bind(__webpack_require__, 78714));
 });
@@ -1565,6 +1986,9 @@ const createReferencedImageDisplaySet = (displaySetService, displaySet) => {
   };
   const imageSet = new ImageSet(instances);
   const instance = instances[0];
+  if (!instance) {
+    return;
+  }
   imageSet.setAttributes({
     displaySetInstanceUID: imageSet.uid,
     // create a local alias for the imageSet UID
@@ -1606,7 +2030,14 @@ __webpack_require__.d(__webpack_exports__, {
 var esm = __webpack_require__(12651);
 // EXTERNAL MODULE: ../../core/src/index.ts + 74 modules
 var src = __webpack_require__(84793);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/adapters/dist/adapters.es.js
+var adapters_es = __webpack_require__(91202);
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-sr/src/utils/getLabelFromDCMJSImportedToolData.js
+
+const {
+  CodeScheme: Cornerstone3DCodeScheme
+} = adapters_es.adaptersSR.Cornerstone3D;
+
 /**
  * Extracts the label from the toolData imported from dcmjs. We need to do this
  * as dcmjs does not depeend on OHIF/the measurementService, it just produces data for cornestoneTools.
@@ -1620,24 +2051,25 @@ function getLabelFromDCMJSImportedToolData(toolData) {
     findingSites = [],
     finding
   } = toolData;
-  let freeTextLabel = findingSites.find(fs => fs.CodeValue === 'CORNERSTONEFREETEXT');
+  let freeTextLabel = findingSites.find(fs => fs.CodeValue === Cornerstone3DCodeScheme.codeValues.CORNERSTONEFREETEXT);
   if (freeTextLabel) {
     return freeTextLabel.CodeMeaning;
   }
-  if (finding && finding.CodeValue === 'CORNERSTONEFREETEXT') {
+  if (finding && finding.CodeValue === Cornerstone3DCodeScheme.codeValues.CORNERSTONEFREETEXT) {
     return finding.CodeMeaning;
   }
 }
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/adapters/dist/adapters.es.js
-var adapters_es = __webpack_require__(91202);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/index.js
 var dist_esm = __webpack_require__(93725);
+// EXTERNAL MODULE: ../../../extensions/cornerstone/src/index.tsx + 96 modules
+var cornerstone_src = __webpack_require__(83846);
 ;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-sr/src/utils/hydrateStructuredReport.ts
 
 
 
 
 
+
 const {
   locking
 } = dist_esm.annotation;
@@ -1648,8 +2080,10 @@ const {
   MeasurementReport,
   CORNERSTONE_3D_TAG
 } = adapters_es.adaptersSR.Cornerstone3D;
-const CORNERSTONE_3D_TOOLS_SOURCE_NAME = 'Cornerstone3DTools';
-const CORNERSTONE_3D_TOOLS_SOURCE_VERSION = '0.1';
+const {
+  CORNERSTONE_3D_TOOLS_SOURCE_NAME,
+  CORNERSTONE_3D_TOOLS_SOURCE_VERSION
+} = cornerstone_src.Enums;
 const supportedLegacyCornerstoneTags = ['cornerstoneTools@^4.0.0'];
 const convertCode = (codingValues, code) => {
   if (!code || code.CodingSchemeDesignator === 'CORNERSTONEJS') {