@ohif/app 3.11.0-beta.99 → 3.11.0

package/dist/{1443.bundle.405ff549a88a585906f3.js → 9732.bundle.91cb05748bef4e4f67c2.js}

@@ -1,4 +1,4 @@
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[1443],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[9732],{
 
 /***/ 3293:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
@@ -439,7 +439,121 @@ module.exports = iota
 
 /***/ }),
 
-/***/ 34279:
+/***/ 49892:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+var ToolModes;
+(function (ToolModes) {
+    ToolModes["Active"] = "Active";
+    ToolModes["Passive"] = "Passive";
+    ToolModes["Enabled"] = "Enabled";
+    ToolModes["Disabled"] = "Disabled";
+})(ToolModes || (ToolModes = {}));
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (ToolModes);
+
+
+/***/ }),
+
+/***/ 66452:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   i: () => (/* binding */ MouseBindings),
+/* harmony export */   q: () => (/* binding */ KeyboardBindings)
+/* harmony export */ });
+var MouseBindings;
+(function (MouseBindings) {
+    MouseBindings[MouseBindings["Primary"] = 1] = "Primary";
+    MouseBindings[MouseBindings["Secondary"] = 2] = "Secondary";
+    MouseBindings[MouseBindings["Primary_And_Secondary"] = 3] = "Primary_And_Secondary";
+    MouseBindings[MouseBindings["Auxiliary"] = 4] = "Auxiliary";
+    MouseBindings[MouseBindings["Primary_And_Auxiliary"] = 5] = "Primary_And_Auxiliary";
+    MouseBindings[MouseBindings["Secondary_And_Auxiliary"] = 6] = "Secondary_And_Auxiliary";
+    MouseBindings[MouseBindings["Primary_And_Secondary_And_Auxiliary"] = 7] = "Primary_And_Secondary_And_Auxiliary";
+    MouseBindings[MouseBindings["Fourth_Button"] = 8] = "Fourth_Button";
+    MouseBindings[MouseBindings["Fifth_Button"] = 16] = "Fifth_Button";
+    MouseBindings[MouseBindings["Wheel"] = 524288] = "Wheel";
+    MouseBindings[MouseBindings["Wheel_Primary"] = 524289] = "Wheel_Primary";
+})(MouseBindings || (MouseBindings = {}));
+var KeyboardBindings;
+(function (KeyboardBindings) {
+    KeyboardBindings[KeyboardBindings["Shift"] = 16] = "Shift";
+    KeyboardBindings[KeyboardBindings["Ctrl"] = 17] = "Ctrl";
+    KeyboardBindings[KeyboardBindings["Alt"] = 18] = "Alt";
+    KeyboardBindings[KeyboardBindings["Meta"] = 91] = "Meta";
+    KeyboardBindings[KeyboardBindings["ShiftCtrl"] = 1617] = "ShiftCtrl";
+    KeyboardBindings[KeyboardBindings["ShiftAlt"] = 1618] = "ShiftAlt";
+    KeyboardBindings[KeyboardBindings["ShiftMeta"] = 1691] = "ShiftMeta";
+    KeyboardBindings[KeyboardBindings["CtrlAlt"] = 1718] = "CtrlAlt";
+    KeyboardBindings[KeyboardBindings["CtrlMeta"] = 1791] = "CtrlMeta";
+    KeyboardBindings[KeyboardBindings["AltMeta"] = 1891] = "AltMeta";
+})(KeyboardBindings || (KeyboardBindings = {}));
+
+
+
+/***/ }),
+
+/***/ 75183:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+var ChangeTypes;
+(function (ChangeTypes) {
+    ChangeTypes["Interaction"] = "Interaction";
+    ChangeTypes["HandlesUpdated"] = "HandlesUpdated";
+    ChangeTypes["StatsUpdated"] = "StatsUpdated";
+    ChangeTypes["InitialSetup"] = "InitialSetup";
+    ChangeTypes["Completed"] = "Completed";
+    ChangeTypes["InterpolationUpdated"] = "InterpolationUpdated";
+    ChangeTypes["History"] = "History";
+    ChangeTypes["MetadataReferenceModified"] = "MetadataReferenceModified";
+    ChangeTypes["LabelChange"] = "LabelChange";
+})(ChangeTypes || (ChangeTypes = {}));
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (ChangeTypes);
+
+
+/***/ }),
+
+/***/ 84093:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+var StrategyCallbacks;
+(function (StrategyCallbacks) {
+    StrategyCallbacks["OnInteractionStart"] = "onInteractionStart";
+    StrategyCallbacks["OnInteractionEnd"] = "onInteractionEnd";
+    StrategyCallbacks["Preview"] = "preview";
+    StrategyCallbacks["RejectPreview"] = "rejectPreview";
+    StrategyCallbacks["AcceptPreview"] = "acceptPreview";
+    StrategyCallbacks["Fill"] = "fill";
+    StrategyCallbacks["Interpolate"] = "interpolate";
+    StrategyCallbacks["StrategyFunction"] = "strategyFunction";
+    StrategyCallbacks["CreateIsInThreshold"] = "createIsInThreshold";
+    StrategyCallbacks["Initialize"] = "initialize";
+    StrategyCallbacks["INTERNAL_setValue"] = "setValue";
+    StrategyCallbacks["AddPreview"] = "addPreview";
+    StrategyCallbacks["ComputeInnerCircleRadius"] = "computeInnerCircleRadius";
+    StrategyCallbacks["GetStatistics"] = "getStatistics";
+    StrategyCallbacks["EnsureImageVolumeFor3DManipulation"] = "ensureImageVolumeFor3DManipulation";
+    StrategyCallbacks["EnsureSegmentationVolumeFor3DManipulation"] = "ensureSegmentationVolumeFor3DManipulation";
+})(StrategyCallbacks || (StrategyCallbacks = {}));
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (StrategyCallbacks);
+
+
+/***/ }),
+
+/***/ 92740:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -447,6 +561,7 @@ module.exports = iota
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
   fX: () => (/* reexport */ enums_namespaceObject),
+  W6: () => (/* reexport */ NO_IMAGE_ID),
   X6: () => (/* reexport */ adaptersPMAP),
   f_: () => (/* reexport */ adaptersRT),
   ql: () => (/* reexport */ adaptersSEG),
@@ -454,8 +569,6 @@ __webpack_require__.d(__webpack_exports__, {
   _$: () => (/* reexport */ helpers_namespaceObject)
 });
 
-// UNUSED EXPORTS: NO_IMAGE_ID
-
 // NAMESPACE OBJECT: ../../../node_modules/@cornerstonejs/adapters/dist/esm/adapters/Cornerstone/Segmentation.js
 var Segmentation_namespaceObject = {};
 __webpack_require__.r(Segmentation_namespaceObject);
@@ -508,7 +621,7 @@ __webpack_require__.d(helpers_namespaceObject, {
 // EXTERNAL MODULE: ../../../node_modules/dcmjs/build/dcmjs.es.js
 var dcmjs_es = __webpack_require__(5842);
 ;// ../../../node_modules/@cornerstonejs/adapters/dist/esm/adapters/helpers/toArray.js
-const toArray = x => Array.isArray(x) ? x : [x];
+const toArray = x => Array.isArray(x) ? x : x !== undefined ? [x] : [];
 
 
 
@@ -523,12 +636,15 @@ const codeMeaningEquals = codeMeaningName => {
 
 // EXTERNAL MODULE: ../../../node_modules/buffer/index.js
 var node_modules_buffer = __webpack_require__(81429);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
+var esm = __webpack_require__(15327);
 ;// ../../../node_modules/@cornerstonejs/adapters/dist/esm/adapters/Cornerstone/MeasurementReport.js
 
 
 
 
 
+
 const {
   TID1500,
   addAccessors
@@ -574,8 +690,9 @@ const codeValueMatch = (group, code, oldCode) => {
 function getTID300ContentItem(tool, ReferencedSOPSequence, adapterClass) {
   const args = adapterClass.getTID300RepresentationArguments(tool);
   args.ReferencedSOPSequence = ReferencedSOPSequence;
-  const TID300Measurement = new adapterClass.TID300Representation(args);
-  return TID300Measurement;
+  args.ReferencedFrameOfReferenceUID = args.use3DSpatialCoordinates ? tool.metadata.FrameOfReferenceUID : null;
+  const tid300Measurement = new adapterClass.TID300Representation(args);
+  return tid300Measurement;
 }
 function getMeasurementGroup(toolType, toolData, ReferencedSOPSequence) {
   const toolTypeData = toolData[toolType];
@@ -586,10 +703,10 @@ function getMeasurementGroup(toolType, toolData, ReferencedSOPSequence) {
 
   // Loop through the array of tool instances
   // for this tool
-  const Measurements = toolTypeData.data.map(tool => {
+  const measurements = toolTypeData.data.map(tool => {
     return getTID300ContentItem(tool, ReferencedSOPSequence, toolClass);
   });
-  return new TID1501MeasurementGroup(Measurements);
+  return new TID1501MeasurementGroup(measurements);
 }
 class MeasurementReport {
   static getSetupMeasurementData(MeasurementGroup) {
@@ -687,7 +804,7 @@ class MeasurementReport {
       });
       allMeasurementGroups = allMeasurementGroups.concat(measurementGroups);
     });
-    const MeasurementReport = new TID1500MeasurementReport({
+    const tid1500MeasurementReport = new TID1500MeasurementReport({
       TID1501MeasurementGroups: allMeasurementGroups
     }, options);
 
@@ -729,7 +846,7 @@ class MeasurementReport {
     derivationSourceDataset._meta = _meta;
     derivationSourceDataset._vrMap = _vrMap;
     const report = new StructuredReport([derivationSourceDataset]);
-    const contentItem = MeasurementReport.contentItem(derivationSourceDataset);
+    const contentItem = tid1500MeasurementReport.contentItem(derivationSourceDataset);
 
     // Merge the derived dataset with the content from the Measurement Report
     report.dataset = Object.assign(report.dataset, contentItem);
@@ -971,6 +1088,7 @@ MeasurementReport.registerTool(FreehandRoi);
 
 
 
+
 const {
   Bidirectional: TID300Bidirectional
 } = dcmjs_es/* utilities */.BF.TID300;
@@ -3208,6 +3326,9 @@ function getImageIdOfSourceImageBySourceImageSequence(SourceImageSequence, sopUI
   if (ReferencedFrameNumber !== undefined) {
     if (baseImageId.includes("frames/")) {
       return baseImageId.replace(/frames\/\d+/, `frames/${ReferencedFrameNumber}`);
+    } else if (baseImageId.includes("dicomfile:")) {
+      // dicomfile base 1, despite having frame=
+      return baseImageId.replace(/frame=\d+/, `frame=${ReferencedFrameNumber}`);
     } else if (baseImageId.includes("frame=")) {
       return baseImageId.replace(/frame=\d+/, `frame=${ReferencedFrameNumber - 1}`);
     } else {
@@ -3785,8 +3906,6 @@ const CornerstonePMAP = {
 
 
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
-var esm = __webpack_require__(15327);
 ;// ../../../node_modules/@cornerstonejs/adapters/dist/esm/adapters/Cornerstone3D/cornerstone3DTag.js
 var CORNERSTONE_3D_TAG = "Cornerstone3DTools@^0.1.0";
 
@@ -3832,6 +3951,60 @@ function copySeriesTags(src) {
 
 
 
+;// ../../../node_modules/@cornerstonejs/adapters/dist/esm/adapters/helpers/scoordToWorld.js
+
+
+const {
+  imageToWorldCoords
+} = esm.utilities;
+function scoordToWorld(_ref, scoord) {
+  let {
+    is3DMeasurement,
+    referencedImageId
+  } = _ref;
+  const worldCoords = [];
+  if (is3DMeasurement) {
+    const {
+      GraphicData
+    } = scoord;
+    for (let i = 0; i < GraphicData.length; i += 3) {
+      const point = [GraphicData[i], GraphicData[i + 1], GraphicData[i + 2]];
+      worldCoords.push(point);
+    }
+  } else {
+    const {
+      GraphicData
+    } = scoord;
+    for (let i = 0; i < GraphicData.length; i += 2) {
+      const point = imageToWorldCoords(referencedImageId, [GraphicData[i], GraphicData[i + 1]]);
+      worldCoords.push(point);
+    }
+  }
+  return worldCoords;
+}
+
+
+
+;// ../../../node_modules/@cornerstonejs/adapters/dist/esm/adapters/helpers/toPoint3.js
+function toPoint3(flatPoints) {
+  const points = [];
+  if (!flatPoints?.length) {
+    return points;
+  }
+  const {
+    length: n
+  } = flatPoints;
+  if (n % 3 !== 0) {
+    throw new Error(`Points array should be divisible by 3 for SCOORD3D, but contents are: ${JSON.stringify(flatPoints)} of length ${n}`);
+  }
+  for (let i = 0; i < n; i += 3) {
+    points.push([flatPoints[i], flatPoints[i + 1], flatPoints[i + 2]]);
+  }
+  return points;
+}
+
+
+
 ;// ../../../node_modules/@cornerstonejs/adapters/dist/esm/adapters/Cornerstone3D/CodingScheme.js
 // This is a custom coding scheme defined to store some annotations from Cornerstone.
 // Note: CodeMeaning is VR type LO, which means we only actually support 64 characters
@@ -3851,6 +4024,156 @@ const CodingScheme = {
 
 ;// ../../../node_modules/@cornerstonejs/adapters/dist/esm/adapters/Cornerstone3D/constants/index.js
 const NO_IMAGE_ID = "none";
+const CS3D_DESIGNATOR = "99CS3D";
+const TEXT_ANNOTATION_POSITION = {
+  schemeDesignator: CS3D_DESIGNATOR,
+  meaning: "Text Annotation Position",
+  value: "TextPosition"
+};
+const COMMENT_CODE = {
+  schemeDesignator: "DCM",
+  meaning: "Comment",
+  value: "121106"
+};
+
+
+
+;// ../../../node_modules/@cornerstonejs/adapters/dist/esm/adapters/helpers/toScoordType.js
+
+
+const {
+  worldToImageCoords: globalWorldToImageCoords
+} = esm.utilities;
+let useWorldToImageCoords = globalWorldToImageCoords;
+function toScoord(_ref, point) {
+  let {
+    is3DMeasurement,
+    referencedImageId
+  } = _ref;
+  if (is3DMeasurement) {
+    return {
+      x: point[0],
+      y: point[1],
+      z: point[2]
+    };
+  }
+  const point2 = useWorldToImageCoords(referencedImageId, point);
+  return {
+    x: point2[0],
+    y: point2[1]
+  };
+}
+function toScoords(scoordArgs, points) {
+  return points.map(point => toScoord(scoordArgs, point));
+}
+function setWorldToImageCoords() {
+  let worldToImage = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : globalWorldToImageCoords;
+  useWorldToImageCoords = worldToImage;
+}
+
+
+
+;// ../../../node_modules/@cornerstonejs/adapters/dist/esm/adapters/Cornerstone3D/LabelData.js
+
+
+
+
+
+
+const {
+  sr: {
+    valueTypes,
+    coding
+  }
+} = dcmjs_es/* default */.Ay;
+const LabelData_CORNERSTONEFREETEXT = "CORNERSTONEFREETEXT";
+class LabelData {
+  constructor(tid300Item, annotation) {
+    this.tid300Item = tid300Item;
+    this.annotation = annotation;
+    this.ReferencedSOPSequence = tid300Item.ReferencedSOPSequence;
+  }
+  contentItem() {
+    const contentEntries = this.tid300Item.contentItem();
+    const {
+      label,
+      handles
+    } = this.annotation.data;
+    if (label) {
+      contentEntries.push(this.createQualitativeLabel(label));
+      this.filterCornerstoneFreeText(contentEntries);
+    }
+    if (handles?.textBox?.hasMoved) {
+      contentEntries.push(this.createQualitativeLabelPosition(this.annotation));
+    }
+    return contentEntries;
+  }
+  filterCornerstoneFreeText(contentEntries) {
+    for (let i = 0; i < contentEntries.length; i++) {
+      const group = contentEntries[i];
+      if (!group.ConceptCodeSequence) {
+        continue;
+      }
+      const csLabel = group.ConceptCodeSequence.find(item => item.CodeValue === LabelData_CORNERSTONEFREETEXT);
+      if (csLabel !== -1) {
+        group.ConceptCodeSequence.splice(csLabel, 1);
+        if (group.ConceptCodeSequence.length === 0) {
+          contentEntries.splice(i, 1);
+        }
+        return;
+      }
+    }
+  }
+  createQualitativeLabel(label) {
+    const relationshipType = valueTypes.RelationshipTypes.CONTAINS;
+    return new valueTypes.TextContentItem({
+      name: new coding.CodedConcept(COMMENT_CODE),
+      relationshipType,
+      value: label
+    });
+  }
+  createQualitativeLabelPosition(annotation) {
+    const {
+      textBox
+    } = annotation.data.handles;
+    const {
+      referencedImageId,
+      FrameOfReferenceUID: frameOfReferenceUID
+    } = annotation.metadata;
+    const is3DMeasurement = !referencedImageId;
+    const {
+      worldPosition
+    } = textBox;
+    const {
+      x,
+      y,
+      z
+    } = toScoord({
+      is3DMeasurement,
+      referencedImageId
+    }, worldPosition);
+    const graphicType = valueTypes.GraphicTypes.POINT;
+    const relationshipType = valueTypes.RelationshipTypes.CONTAINS;
+    const name = new coding.CodedConcept(TEXT_ANNOTATION_POSITION);
+    if (is3DMeasurement) {
+      const graphicData = [x, y, z];
+      return new valueTypes.Scoord3DContentItem({
+        name,
+        relationshipType,
+        graphicType,
+        frameOfReferenceUID,
+        graphicData
+      });
+    }
+    const graphicData = [x, y];
+    return new valueTypes.ScoordContentItem({
+      name,
+      relationshipType,
+      graphicType,
+      graphicData
+    });
+  }
+}
 
 
 
@@ -3866,6 +4189,9 @@ const NO_IMAGE_ID = "none";
 
 
 
+
+
+
 var _MeasurementReport;
 const {
   TID1500: MeasurementReport_TID1500,
@@ -3888,6 +4214,14 @@ const MeasurementReport_FINDING = {
   CodingSchemeDesignator: "DCM",
   CodeValue: "121071"
 };
+const COMMENT = {
+  CodingSchemeDesignator: COMMENT_CODE.schemeDesignator,
+  CodeValue: COMMENT_CODE.value
+};
+const COMMENT_POSITION = {
+  CodingSchemeDesignator: TEXT_ANNOTATION_POSITION.schemeDesignator,
+  CodeValue: TEXT_ANNOTATION_POSITION.value
+};
 const MeasurementReport_FINDING_SITE = {
   CodingSchemeDesignator: "SCT",
   CodeValue: "363698007"
@@ -3897,28 +4231,36 @@ const MeasurementReport_FINDING_SITE_OLD = {
   CodeValue: "G-C0E3"
 };
 class MeasurementReport_MeasurementReport {
-  static getTID300ContentItem(tool, ReferencedSOPSequence, toolClass, worldToImageCoords) {
-    const args = toolClass.getTID300RepresentationArguments(tool, worldToImageCoords);
+  static getTID300ContentItem(tool, ReferencedSOPSequence, toolClass, is3DMeasurement) {
+    const args = toolClass.getTID300RepresentationArguments(tool, is3DMeasurement);
     args.ReferencedSOPSequence = ReferencedSOPSequence;
-    const TID300Measurement = new toolClass.TID300Representation(args);
-    return TID300Measurement;
+    if (args.use3DSpatialCoordinates) {
+      args.ReferencedFrameOfReferenceUID = tool.metadata.FrameOfReferenceUID;
+    }
+    const tid300Measurement = new toolClass.TID300Representation(args);
+    const labelMeasurement = new LabelData(tid300Measurement, tool);
+    return labelMeasurement;
   }
-  static getMeasurementGroup(toolType, toolData, ReferencedSOPSequence, worldToImageCoords) {
+  static getMeasurementGroup(toolType, toolData, ReferencedSOPSequence, is3DMeasurement) {
     const toolTypeData = toolData[toolType];
     const toolClass = this.measurementAdapterByToolType.get(toolType);
     if (!toolTypeData || !toolTypeData.data || !toolTypeData.data.length || !toolClass) {
       return;
     }
     const Measurements = toolTypeData.data.map(tool => {
-      return this.getTID300ContentItem(tool, ReferencedSOPSequence, toolClass, worldToImageCoords);
+      return this.getTID300ContentItem(tool, ReferencedSOPSequence, toolClass, is3DMeasurement);
     });
     return new MeasurementReport_TID1501MeasurementGroup(Measurements);
   }
   static getCornerstoneLabelFromDefaultState(defaultState) {
     const {
       findingSites = [],
-      finding
+      finding,
+      commentGroup
     } = defaultState;
+    if (commentGroup?.TextValue) {
+      return commentGroup.TextValue;
+    }
     const cornersoneFreeTextCodingValue = CodingScheme.codeValues.CORNERSTONEFREETEXT;
     const freeTextLabel = findingSites.find(fs => fs.CodeValue === cornersoneFreeTextCodingValue);
     if (freeTextLabel) {
@@ -3967,21 +4309,32 @@ class MeasurementReport_MeasurementReport {
     } = ReferencedSOPSequence;
     const referencedImageId = sopInstanceUIDToImageIdMap[ReferencedSOPInstanceUID];
     const imagePlaneModule = metadata.get("imagePlaneModule", referencedImageId);
+    const annotationUID = MeasurementReport_DicomMetaDictionary.uid();
     return {
       SCOORDGroup,
       ReferencedSOPSequence,
       ReferencedSOPInstanceUID,
       ReferencedFrameNumber,
+      referencedImageId,
       state: {
         description: undefined,
         sopInstanceUid: ReferencedSOPInstanceUID,
         annotation: {
-          annotationUID: MeasurementReport_DicomMetaDictionary.uid(),
+          data: {
+            annotationUID,
+            cachedStats: {},
+            handles: {
+              activeHandleIndex: 0,
+              textBox: {
+                hasMoved: false
+              }
+            }
+          },
+          annotationUID,
           metadata: {
             toolName: toolType,
             referencedImageId,
-            FrameOfReferenceUID: imagePlaneModule.frameOfReferenceUID,
-            label: ""
+            FrameOfReferenceUID: imagePlaneModule.frameOfReferenceUID
           }
         }
       }
@@ -3992,21 +4345,33 @@ class MeasurementReport_MeasurementReport {
       SCOORD3DGroup,
       toolType
     } = _ref2;
-    return {
+    const annotationUID = MeasurementReport_DicomMetaDictionary.uid();
+    const toolData = {
       SCOORD3DGroup,
       FrameOfReferenceUID: SCOORD3DGroup.ReferencedFrameOfReferenceUID,
       state: {
         description: undefined,
         annotation: {
-          annotationUID: MeasurementReport_DicomMetaDictionary.uid(),
+          annotationUID,
+          data: {
+            annotationUID,
+            cachedStats: {},
+            handles: {
+              activeHandleIndex: 0,
+              textBox: {
+                hasMoved: false
+              }
+            }
+          },
           metadata: {
             toolName: toolType,
-            FrameOfReferenceUID: SCOORD3DGroup.ReferencedFrameOfReferenceUID,
-            label: ""
+            FrameOfReferenceUID: SCOORD3DGroup.ReferencedFrameOfReferenceUID
           }
         }
       }
     };
+    esm.utilities.updatePlaneRestriction(toPoint3(SCOORD3DGroup.GraphicData), toolData.state.annotation.metadata);
+    return toolData;
   }
   static getSpatialCoordinatesState(_ref3) {
     let {
@@ -4015,23 +4380,22 @@ class MeasurementReport_MeasurementReport {
       metadata,
       toolType
     } = _ref3;
-    const SCOORDGroup = toArray(NUMGroup.ContentSequence).find(group => group.ValueType === "SCOORD");
-    const SCOORD3DGroup = toArray(NUMGroup.ContentSequence).find(group => group.ValueType === "SCOORD3D");
-    if (SCOORDGroup) {
-      return this.processSCOORDGroup({
-        SCOORDGroup,
-        toolType,
-        metadata,
-        sopInstanceUIDToImageIdMap
-      });
-    } else if (SCOORD3DGroup) {
-      return this.processSCOORD3DGroup({
-        SCOORD3DGroup,
-        toolType
-      });
-    } else {
+    const contentSequenceArr = toArray(NUMGroup.ContentSequence);
+    const SCOORDGroup = contentSequenceArr.find(group => group.ValueType === "SCOORD");
+    const SCOORD3DGroup = contentSequenceArr.find(group => group.ValueType === "SCOORD3D");
+    const result = SCOORD3DGroup && this.processSCOORD3DGroup({
+      SCOORD3DGroup,
+      toolType
+    }) || SCOORDGroup && this.processSCOORDGroup({
+      SCOORDGroup,
+      toolType,
+      metadata,
+      sopInstanceUIDToImageIdMap
+    });
+    if (!result) {
       throw new Error("No spatial coordinates group found.");
     }
+    return result;
   }
   static processSpatialCoordinatesGroup(_ref4) {
     let {
@@ -4040,6 +4404,8 @@ class MeasurementReport_MeasurementReport {
       metadata,
       findingGroup,
       findingSiteGroups,
+      commentGroup,
+      commentPositionGroup,
       toolType
     } = _ref4;
     const {
@@ -4049,7 +4415,9 @@ class MeasurementReport_MeasurementReport {
       ReferencedSOPInstanceUID,
       ReferencedFrameNumber,
       SCOORD3DGroup,
-      FrameOfReferenceUID
+      FrameOfReferenceUID,
+      referencedImageId,
+      textBoxPosition
     } = this.getSpatialCoordinatesState({
       NUMGroup,
       sopInstanceUIDToImageIdMap,
@@ -4060,21 +4428,35 @@ class MeasurementReport_MeasurementReport {
     const findingSites = findingSiteGroups.map(fsg => {
       return MeasurementReport_addAccessors(fsg.ConceptCodeSequence);
     });
-    const defaultState = {
-      ...state,
-      finding,
-      findingSites
-    };
-    if (defaultState.finding) {
-      defaultState.description = defaultState.finding.CodeMeaning;
+    if (commentPositionGroup) {
+      state.commentPositionGroup = commentPositionGroup;
+      const textBoxCoords = scoordToWorld({
+        is3DMeasurement: !referencedImageId,
+        referencedImageId
+      }, commentPositionGroup);
+      state.annotation.data.handles.textBox = {
+        hasMoved: true,
+        worldPosition: textBoxCoords[0]
+      };
     }
-    defaultState.annotation.metadata.label = MeasurementReport_MeasurementReport.getCornerstoneLabelFromDefaultState(defaultState);
+    state.finding = finding;
+    state.findingSites = findingSites;
+    state.commentGroup = commentGroup;
+    state.commentPositionGroup = commentPositionGroup;
+    if (finding) {
+      state.description = finding.CodeMeaning;
+    }
+    state.annotation.data.label = this.getCornerstoneLabelFromDefaultState(state);
     return {
-      defaultState,
+      defaultState: state,
+      state,
       NUMGroup,
+      scoord: SCOORD3DGroup || SCOORDGroup,
       SCOORDGroup,
       ReferencedSOPSequence,
       ReferencedSOPInstanceUID,
+      referencedImageId,
+      textBoxPosition,
       ReferencedFrameNumber,
       SCOORD3DGroup,
       FrameOfReferenceUID
@@ -4086,16 +4468,39 @@ class MeasurementReport_MeasurementReport {
     } = MeasurementGroup;
     const contentSequenceArr = toArray(ContentSequence);
     const findingGroup = contentSequenceArr.find(group => this.codeValueMatch(group, MeasurementReport_FINDING));
+    const commentGroup = contentSequenceArr.find(group => this.codeValueMatch(group, COMMENT));
+    const commentPositionGroup = contentSequenceArr.find(group => this.codeValueMatch(group, COMMENT_POSITION));
     const findingSiteGroups = contentSequenceArr.filter(group => this.codeValueMatch(group, MeasurementReport_FINDING_SITE, MeasurementReport_FINDING_SITE_OLD)) || [];
-    const NUMGroup = contentSequenceArr.find(group => group.ValueType === "NUM");
-    return this.processSpatialCoordinatesGroup({
+    const NUMGroup = contentSequenceArr.find(group => group.ValueType === "NUM") || {
+      ContentSequence: contentSequenceArr.filter(group => group.ValueType === "SCOORD" || group.ValueType === "SCOORD3D")
+    };
+    const spatialGroup = this.processSpatialCoordinatesGroup({
       NUMGroup,
       sopInstanceUIDToImageIdMap,
       metadata,
       findingGroup,
       findingSiteGroups,
+      commentGroup,
+      commentPositionGroup,
       toolType
     });
+    const {
+      referencedImageId
+    } = spatialGroup.state.annotation.metadata;
+    const is3DMeasurement = !!spatialGroup.SCOORD3DGroup;
+    const scoordArgs = {
+      referencedImageId,
+      is3DMeasurement
+    };
+    const scoord = spatialGroup.SCOORD3DGroup || spatialGroup.SCOORDGroup;
+    const worldCoords = scoordToWorld(scoordArgs, scoord);
+    return {
+      ...spatialGroup,
+      is3DMeasurement,
+      scoordArgs,
+      scoord,
+      worldCoords
+    };
   }
   static generateReferencedSOPSequence(_ref5) {
     let {
@@ -4143,10 +4548,13 @@ class MeasurementReport_MeasurementReport {
     const referenceToolData = toolData?.[toolTypes?.[0]]?.data?.[0];
     const volumeId = referenceToolData?.metadata?.volumeId;
     const volume = esm.cache.getVolume(volumeId);
+    if (!volume) {
+      throw new Error(`No volume found for ${volumeId}`);
+    }
     const imageId = volume.imageIds[0];
     return imageId;
   }
-  static generateReport(toolState, metadataProvider, worldToImageCoords, options) {
+  static generateReport(toolState, metadataProvider, options) {
     let allMeasurementGroups = [];
     const sopInstanceUIDsToSeriesInstanceUIDMap = {};
     const derivationSourceDatasets = [];
@@ -4155,6 +4563,7 @@ class MeasurementReport_MeasurementReport {
     Object.keys(toolState).forEach(imageId => {
       const toolData = toolState[imageId];
       const toolTypes = Object.keys(toolData);
+      const is3DMeasurement = imageId === NO_IMAGE_ID;
       const ReferencedSOPSequence = this.generateReferencedSOPSequence({
         toolData,
         toolTypes,
@@ -4163,12 +4572,12 @@ class MeasurementReport_MeasurementReport {
         sopInstanceUIDsToSeriesInstanceUIDMap,
         derivationSourceDatasets
       });
-      if (imageId === NO_IMAGE_ID) {
+      if (is3DMeasurement) {
         is3DSR = true;
       }
       const measurementGroups = [];
       toolTypes.forEach(toolType => {
-        const group = this.getMeasurementGroup(toolType, toolData, ReferencedSOPSequence, worldToImageCoords);
+        const group = this.getMeasurementGroup(toolType, toolData, ReferencedSOPSequence, is3DMeasurement);
         if (group) {
           measurementGroups.push(group);
         }
@@ -4188,10 +4597,13 @@ class MeasurementReport_MeasurementReport {
     report.SpecificCharacterSet = "ISO_IR 192";
     if (is3DSR) {
       report.dataset.SOPClassUID = MeasurementReport_DicomMetaDictionary.sopClassUIDsByName.Comprehensive3DSR;
+      if (!report.dataset.SOPClassUID) {
+        throw new Error(`NO sop class defined for Comprehensive3DSR in ${JSON.stringify(MeasurementReport_DicomMetaDictionary.sopClassUIDsByName)}`);
+      }
     }
     return report;
   }
-  static generateToolState(dataset, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata, hooks) {
+  static generateToolState(dataset, sopInstanceUIDToImageIdMap, metadata, hooks) {
     if (dataset.ContentTemplateSequence.TemplateIdentifier !== "1500") {
       throw new Error("This package can currently only interpret DICOM SR TID 1500");
     }
@@ -4211,9 +4623,9 @@ class MeasurementReport_MeasurementReport {
         } = trackingIdentifierGroup;
         const trackingUniqueIdentifierGroup = measurementGroupContentSequence.find(contentItem => contentItem.ConceptNameCodeSequence.CodeMeaning === TRACKING_UNIQUE_IDENTIFIER);
         const trackingUniqueIdentifierValue = trackingUniqueIdentifierGroup?.UID;
-        const toolAdapter = hooks?.getToolClass?.(measurementGroup, dataset, this.measurementAdapterByToolType) || this.getAdapterForTrackingIdentifier(trackingIdentifierValue);
+        const toolAdapter = hooks?.getToolClass?.(measurementGroup, dataset, this.measurementAdapterByToolType) || this.getAdapterForTrackingIdentifier(trackingIdentifierValue) || this.getAdapterForCodeType(measurementGroup);
         if (toolAdapter) {
-          const measurement = toolAdapter.getMeasurementData(measurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata, trackingIdentifierValue);
+          const measurement = toolAdapter.getMeasurementData(measurementGroup, sopInstanceUIDToImageIdMap, metadata, trackingIdentifierValue);
           measurement.TrackingUniqueIdentifier = trackingUniqueIdentifierValue;
           console.log(`=== ${toolAdapter.toolType} ===`);
           console.log(measurement);
@@ -4260,10 +4672,40 @@ class MeasurementReport_MeasurementReport {
       }
     }
   }
+  static getAdapterForCodeType(measurementGroup) {
+    for (const adapter of this.measurementAdapterByTrackingIdentifier.values()) {
+      if (adapter.isValidMeasurement(measurementGroup)) {
+        return adapter;
+      }
+    }
+  }
+  static registerAdapterTypes(adapter) {
+    for (var _len2 = arguments.length, types = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+      types[_key2 - 1] = arguments[_key2];
+    }
+    for (const type of types) {
+      if (!this.measurementAdaptersByType.has(type)) {
+        this.measurementAdaptersByType.set(type, []);
+      }
+      const adapters = this.measurementAdaptersByType.get(type);
+      if (adapters.indexOf(adapter) === -1) {
+        adapters.push(adapter);
+      }
+    }
+  }
+  static getAdaptersForTypes(graphicCode, graphicType, pointCount) {
+    const adapters = [];
+    appendList(adapters, this.measurementAdaptersByType.get(`${graphicCode}-${graphicType}-${pointCount}`));
+    appendList(adapters, this.measurementAdaptersByType.get(`${graphicCode}-${graphicType}`));
+    appendList(adapters, this.measurementAdaptersByType.get(graphicCode));
+    appendList(adapters, this.measurementAdaptersByType.get(graphicType));
+    return adapters;
+  }
 }
 _MeasurementReport = MeasurementReport_MeasurementReport;
 _MeasurementReport.CORNERSTONE_3D_TAG = CORNERSTONE_3D_TAG;
 _MeasurementReport.measurementAdapterByToolType = new Map();
+_MeasurementReport.measurementAdaptersByType = new Map();
 _MeasurementReport.measurementAdapterByTrackingIdentifier = new Map();
 _MeasurementReport.codeValueMatch = (group, code, oldCode) => {
   const {
@@ -4286,6 +4728,12 @@ _MeasurementReport.generateDerivationSourceDataset = instance => {
     ...seriesTags
   };
 };
+function appendList(list, appendList) {
+  if (!appendList?.length) {
+    return;
+  }
+  list.push(...appendList);
+}
 
 
 
@@ -4293,7 +4741,55 @@ _MeasurementReport.generateDerivationSourceDataset = instance => {
 
 
 
+
+
+
+
 class BaseAdapter3D {
+  static registerType() {
+    let code = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
+    let type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
+    let count = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    let key = code;
+    if (type) {
+      key = `${key}${key.length ? "-" : ""}${type}`;
+    }
+    if (count) {
+      key = `${key}${key.length ? "-" : ""}${count}`;
+    }
+    MeasurementReport_MeasurementReport.registerAdapterTypes(this, key);
+  }
+  static getPointsCount(graphicItem) {
+    const is3DMeasurement = graphicItem.ValueType === "SCOORD3D";
+    const pointSize = is3DMeasurement ? 3 : 2;
+    return graphicItem.GraphicData.length / pointSize;
+  }
+  static getGraphicItems(measurementGroup, filter) {
+    const items = measurementGroup.ContentSequence.filter(group => group.ValueType === "SCOORD" || group.ValueType === "SCOORD3D");
+    return filter ? items.filter(filter) : items;
+  }
+  static getGraphicItem(measurementGroup) {
+    let offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    let type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+    const items = this.getGraphicItems(measurementGroup, type && (group => group.ValueType === type));
+    return items[offset];
+  }
+  static getGraphicCode(graphicItem) {
+    const {
+      ConceptNameCodeSequence: conceptNameItem
+    } = graphicItem;
+    const {
+      CodeValue: graphicValue,
+      CodingSchemeDesignator: graphicDesignator
+    } = conceptNameItem;
+    return `${graphicDesignator}:${graphicValue}`;
+  }
+  static getGraphicType(graphicItem) {
+    return graphicItem.GraphicType;
+  }
+  static isValidMeasurement(_measurementGroup) {
+    return false;
+  }
   static init(toolType, representation, options) {
     this.toolType = toolType;
     if (BaseAdapter3D.toolType) {
@@ -4332,7 +4828,7 @@ class BaseAdapter3D {
     }
     return trackingIdentifier.startsWith(this.trackingIdentifierTextValue);
   }
-  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, _imageToWorldCoords, metadata, trackingIdentifier) {
+  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, trackingIdentifier) {
     const {
       defaultState: state,
       ReferencedFrameNumber
@@ -4344,9 +4840,9 @@ class BaseAdapter3D {
     };
     return state;
   }
-  static getTID300RepresentationArguments(tool, worldToImageCoords) {
+  static getTID300RepresentationArguments(tool) {
+    let is3DMeasurement = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     const {
-      data,
       metadata
     } = tool;
     const {
@@ -4356,52 +4852,19 @@ class BaseAdapter3D {
     const {
       referencedImageId
     } = metadata;
-    if (!referencedImageId) {
-      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
-    }
-    const {
-      handles: {
-        points = []
-      }
-    } = data;
-    const pointsImage = points.map(point => {
-      const pointImage = worldToImageCoords(referencedImageId, point);
-      return {
-        x: pointImage[0],
-        y: pointImage[1]
-      };
-    });
+    const scoordProps = {
+      is3DMeasurement,
+      referencedImageId
+    };
+    const pointsImage = toScoords(scoordProps, tool.data.handles.points);
     const tidArguments = {
       points: pointsImage,
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       findingSites: findingSites || [],
-      finding
-    };
-    return tidArguments;
-  }
-  static getTID300RepresentationArgumentsSCOORD3D(tool) {
-    const {
-      data,
       finding,
-      findingSites
-    } = tool;
-    const {
-      handles: {
-        points = []
-      }
-    } = data;
-    const point = points[0];
-    const pointXYZ = {
-      x: point[0],
-      y: point[1],
-      z: point[2]
-    };
-    return {
-      points: [pointXYZ],
-      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
-      findingSites: findingSites || [],
-      finding
+      ReferencedFrameOfReferenceUID: is3DMeasurement ? metadata.FrameOfReferenceUID : null
     };
+    return tidArguments;
   }
 }
 
@@ -4413,90 +4876,26 @@ class BaseAdapter3D {
 
 
 
+
+
 var _ArrowAnnotate;
 const {
   Point: ArrowAnnotate_TID300Point
 } = dcmjs_es/* utilities */.BF.TID300;
 const {
-  codeValues
-} = CodingScheme;
+  imageToWorldCoords: ArrowAnnotate_imageToWorldCoords
+} = esm.utilities;
 class ArrowAnnotate_ArrowAnnotate extends BaseAdapter3D {
-  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata, _trackingIdentifier) {
-    const {
-      defaultState,
-      SCOORDGroup,
-      SCOORD3DGroup,
-      ReferencedFrameNumber
-    } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, ArrowAnnotate_ArrowAnnotate.toolType);
-    const referencedImageId = defaultState.annotation.metadata.referencedImageId;
-    const text = defaultState.annotation.metadata.label;
-    if (SCOORDGroup) {
-      return this.getMeasurementDataFromScoord({
-        SCOORDGroup,
-        referencedImageId,
-        metadata,
-        imageToWorldCoords,
-        defaultState,
-        text,
-        ReferencedFrameNumber
-      });
-    } else if (SCOORD3DGroup) {
-      return this.getMeasurementDataFromScoord3D({
-        SCOORD3DGroup,
-        defaultState,
-        text
-      });
-    } else {
-      throw new Error("Can't get measurement data with missing SCOORD and SCOORD3D groups.");
-    }
-  }
-  static getMeasurementDataFromScoord3D(_ref) {
-    let {
-      SCOORD3DGroup,
-      defaultState,
-      text
-    } = _ref;
+  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, _trackingIdentifier) {
     const {
-      GraphicData
-    } = SCOORD3DGroup;
-    const worldCoords = [];
-    for (let i = 0; i < GraphicData.length; i += 3) {
-      const point = [GraphicData[i], GraphicData[i + 1], GraphicData[i + 2]];
-      worldCoords.push(point);
-    }
-    const state = defaultState;
-    state.annotation.data = {
-      text,
-      handles: {
-        arrowFirst: true,
-        points: [worldCoords[0], worldCoords[1]],
-        activeHandleIndex: 0,
-        textBox: {
-          hasMoved: false
-        }
-      }
-    };
-    return state;
-  }
-  static getMeasurementDataFromScoord(_ref2) {
-    let {
+      state,
       SCOORDGroup,
+      worldCoords,
       referencedImageId,
-      metadata,
-      imageToWorldCoords,
-      defaultState,
-      text,
       ReferencedFrameNumber
-    } = _ref2;
-    const {
-      GraphicData
-    } = SCOORDGroup;
-    const worldCoords = [];
-    for (let i = 0; i < GraphicData.length; i += 2) {
-      const point = imageToWorldCoords(referencedImageId, [GraphicData[i], GraphicData[i + 1]]);
-      worldCoords.push(point);
-    }
-    if (worldCoords.length === 1) {
+    } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType);
+    const text = state.annotation.data.label;
+    if (worldCoords.length === 1 && SCOORDGroup) {
       const imagePixelModule = metadata.get("imagePixelModule", referencedImageId);
       let xOffset = 10;
       let yOffset = 10;
@@ -4508,123 +4907,57 @@ class ArrowAnnotate_ArrowAnnotate extends BaseAdapter3D {
         xOffset = columns / 10;
         yOffset = rows / 10;
       }
-      const secondPoint = imageToWorldCoords(referencedImageId, [GraphicData[0] + xOffset, GraphicData[1] + yOffset]);
+      const {
+        GraphicData
+      } = SCOORDGroup;
+      const secondPoint = ArrowAnnotate_imageToWorldCoords(referencedImageId, [GraphicData[0] + xOffset, GraphicData[1] + yOffset]);
       worldCoords.push(secondPoint);
     }
-    const state = defaultState;
     state.annotation.data = {
+      ...state.annotation.data,
       text,
       handles: {
+        ...state.annotation.data.handles,
         arrowFirst: true,
-        points: [worldCoords[0], worldCoords[1]],
-        activeHandleIndex: 0,
-        textBox: {
-          hasMoved: false
-        }
+        points: worldCoords
       },
       frameNumber: ReferencedFrameNumber
     };
     return state;
   }
-  static getTID300RepresentationArguments(tool, worldToImageCoords) {
+  static getTID300RepresentationArguments(tool) {
+    let is3DMeasurement = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     const {
       data,
       metadata,
       findingSites
     } = tool;
-    let {
+    const {
       finding
     } = tool;
     const {
       referencedImageId
     } = metadata;
-    if (!referencedImageId) {
-      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
-    }
-    const {
-      points,
-      arrowFirst
-    } = data.handles;
-    let point;
-    let point2;
-    if (arrowFirst) {
-      point = points[0];
-      point2 = points[1];
-    } else {
-      point = points[1];
-      point2 = points[0];
-    }
-    const pointImage = worldToImageCoords(referencedImageId, point);
-    const pointImage2 = worldToImageCoords(referencedImageId, point2);
-    const TID300RepresentationArguments = {
-      points: [{
-        x: pointImage[0],
-        y: pointImage[1]
-      }, {
-        x: pointImage2[0],
-        y: pointImage2[1]
-      }],
-      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
-      findingSites: findingSites || [],
-      finding,
-      use3DSpatialCoordinates: false
+    const scoordProps = {
+      is3DMeasurement,
+      referencedImageId
     };
-    if (!finding || finding.CodeValue !== codeValues.CORNERSTONEFREETEXT) {
-      finding = {
-        CodeValue: codeValues.CORNERSTONEFREETEXT,
-        CodingSchemeDesignator: CodingScheme.CodingSchemeDesignator,
-        CodeMeaning: data.text
-      };
-    }
-    return TID300RepresentationArguments;
-  }
-  static getTID300RepresentationArgumentsSCOORD3D(tool) {
-    const {
-      data,
-      findingSites,
-      metadata
-    } = tool;
-    let {
-      finding
-    } = tool;
     const {
       points,
       arrowFirst
     } = data.handles;
-    let point;
-    let point2;
-    if (arrowFirst) {
-      point = points[0];
-      point2 = points[1];
-    } else {
-      point = points[1];
-      point2 = points[0];
-    }
-    const pointImage = point;
-    const pointImage2 = point2;
+    const point = arrowFirst ? points[0] : points[1];
+    const point2 = arrowFirst ? points[1] : points[0];
+    const pointImage = toScoord(scoordProps, point);
+    const pointImage2 = toScoord(scoordProps, point2);
     const TID300RepresentationArguments = {
-      points: [{
-        x: pointImage[0],
-        y: pointImage[1],
-        z: pointImage[2]
-      }, {
-        x: pointImage2[0],
-        y: pointImage2[1],
-        z: pointImage2[2]
-      }],
+      points: [pointImage, pointImage2],
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       findingSites: findingSites || [],
       finding,
-      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
-      use3DSpatialCoordinates: true
+      ReferencedFrameOfReferenceUID: is3DMeasurement ? metadata.FrameOfReferenceUID : null,
+      use3DSpatialCoordinates: is3DMeasurement
     };
-    if (!finding || finding.CodeValue !== codeValues.CORNERSTONEFREETEXT) {
-      finding = {
-        CodeValue: codeValues.CORNERSTONEFREETEXT,
-        CodingSchemeDesignator: CodingScheme.CodingSchemeDesignator,
-        CodeMeaning: data.text
-      };
-    }
     return TID300RepresentationArguments;
   }
 }
@@ -4643,6 +4976,8 @@ _ArrowAnnotate = ArrowAnnotate_ArrowAnnotate;
 
 
 
+
+
 var _Bidirectional;
 const {
   Bidirectional: Bidirectional_TID300Bidirectional
@@ -4650,110 +4985,43 @@ const {
 const Bidirectional_LONG_AXIS = "Long Axis";
 const Bidirectional_SHORT_AXIS = "Short Axis";
 class Bidirectional_Bidirectional extends BaseAdapter3D {
-  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata) {
     const {
-      defaultState,
+      state,
+      scoordArgs,
+      referencedImageId,
       ReferencedFrameNumber
-    } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, Bidirectional_Bidirectional.toolType);
-    const referencedImageId = defaultState.annotation.metadata.referencedImageId;
+    } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType);
     const {
       ContentSequence
     } = MeasurementGroup;
     const longAxisNUMGroup = toArray(ContentSequence).find(group => group.ConceptNameCodeSequence.CodeMeaning === Bidirectional_LONG_AXIS);
     const shortAxisNUMGroup = toArray(ContentSequence).find(group => group.ConceptNameCodeSequence.CodeMeaning === Bidirectional_SHORT_AXIS);
-    const longAxisSCOORDGroup = toArray(longAxisNUMGroup.ContentSequence).find(group => group.ValueType === "SCOORD");
-    const shortAxisSCOORDGroup = toArray(shortAxisNUMGroup.ContentSequence).find(group => group.ValueType === "SCOORD");
-    if (longAxisSCOORDGroup && shortAxisSCOORDGroup) {
-      return this.getMeasurementDataFromScoord({
-        longAxisNUMGroup,
-        shortAxisNUMGroup,
-        longAxisSCOORDGroup,
-        shortAxisSCOORDGroup,
-        referencedImageId,
-        imageToWorldCoords,
-        ReferencedFrameNumber,
-        defaultState
-      });
-    } else {
-      return this.getMeasurementDataFromScoord3d({
-        longAxisNUMGroup,
-        shortAxisNUMGroup,
-        defaultState
-      });
-    }
-  }
-  static getMeasurementDataFromScoord(_ref) {
-    let {
-      longAxisNUMGroup,
-      shortAxisNUMGroup,
-      longAxisSCOORDGroup,
-      shortAxisSCOORDGroup,
-      referencedImageId,
-      imageToWorldCoords,
-      ReferencedFrameNumber,
-      defaultState
-    } = _ref;
+    const longAxisScoordGroup = toArray(longAxisNUMGroup.ContentSequence).find(group => group.ValueType === "SCOORD3D" || group.ValueType === "SCOORD");
+    const shortAxisScoordGroup = toArray(shortAxisNUMGroup.ContentSequence).find(group => group.ValueType === "SCOORD3D" || group.ValueType === "SCOORD");
     const worldCoords = [];
-    [longAxisSCOORDGroup, shortAxisSCOORDGroup].forEach(group => {
-      const {
-        GraphicData
-      } = group;
-      for (let i = 0; i < GraphicData.length; i += 2) {
-        const point = imageToWorldCoords(referencedImageId, [GraphicData[i], GraphicData[i + 1]]);
-        worldCoords.push(point);
-      }
-    });
-    const state = defaultState;
+    worldCoords.push(...scoordToWorld(scoordArgs, longAxisScoordGroup));
+    worldCoords.push(...scoordToWorld(scoordArgs, shortAxisScoordGroup));
     state.annotation.data = {
+      ...state.annotation.data,
       handles: {
-        points: [worldCoords[0], worldCoords[1], worldCoords[2], worldCoords[3]],
-        activeHandleIndex: 0,
-        textBox: {
-          hasMoved: false
-        }
+        ...state.annotation.data.handles,
+        points: [worldCoords[0], worldCoords[1], worldCoords[2], worldCoords[3]]
       },
-      cachedStats: {
+      frameNumber: ReferencedFrameNumber
+    };
+    if (referencedImageId) {
+      state.annotation.data.cachedStats = {
         [`imageId:${referencedImageId}`]: {
           length: longAxisNUMGroup.MeasuredValueSequence.NumericValue,
           width: shortAxisNUMGroup.MeasuredValueSequence.NumericValue
         }
-      },
-      frameNumber: ReferencedFrameNumber
-    };
-    return state;
-  }
-  static getMeasurementDataFromScoord3d(_ref2) {
-    let {
-      longAxisNUMGroup,
-      shortAxisNUMGroup,
-      defaultState
-    } = _ref2;
-    const worldCoords = [];
-    const longAxisSCOORD3DGroup = toArray(longAxisNUMGroup.ContentSequence).find(group => group.ValueType === "SCOORD3D");
-    const shortAxisSCOORD3DGroup = toArray(shortAxisNUMGroup.ContentSequence).find(group => group.ValueType === "SCOORD3D");
-    [longAxisSCOORD3DGroup, shortAxisSCOORD3DGroup].forEach(group => {
-      const {
-        GraphicData
-      } = group;
-      for (let i = 0; i < GraphicData.length; i += 3) {
-        const point = [GraphicData[i], GraphicData[i + 1], GraphicData[i + 2]];
-        worldCoords.push(point);
-      }
-    });
-    const state = defaultState;
-    state.annotation.data = {
-      handles: {
-        points: [worldCoords[0], worldCoords[1], worldCoords[2], worldCoords[3]],
-        activeHandleIndex: 0,
-        textBox: {
-          hasMoved: false
-        }
-      },
-      cachedStats: {}
-    };
+      };
+    }
     return state;
   }
-  static getTID300RepresentationArguments(tool, worldToImageCoords) {
+  static getTID300RepresentationArguments(tool) {
+    let is3DMeasurement = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     const {
       data,
       finding,
@@ -4767,6 +5035,10 @@ class Bidirectional_Bidirectional extends BaseAdapter3D {
     const {
       referencedImageId
     } = metadata;
+    const scoordProps = {
+      is3DMeasurement,
+      referencedImageId
+    };
     const {
       points
     } = handles;
@@ -4783,106 +5055,30 @@ class Bidirectional_Bidirectional extends BaseAdapter3D {
       shortAxisPoints = secondPointPairs;
       longAxisPoints = firstPointPairs;
     }
-    if (!referencedImageId) {
-      return this.getTID300RepresentationArgumentsSCOORD3D({
-        tool,
-        shortAxisPoints,
-        longAxisPoints
-      });
-    }
-    const longAxisStartImage = worldToImageCoords(referencedImageId, shortAxisPoints[0]);
-    const longAxisEndImage = worldToImageCoords(referencedImageId, shortAxisPoints[1]);
-    const shortAxisStartImage = worldToImageCoords(referencedImageId, longAxisPoints[0]);
-    const shortAxisEndImage = worldToImageCoords(referencedImageId, longAxisPoints[1]);
+    const longAxisStartImage = toScoord(scoordProps, shortAxisPoints[0]);
+    const longAxisEndImage = toScoord(scoordProps, shortAxisPoints[1]);
+    const shortAxisStartImage = toScoord(scoordProps, longAxisPoints[0]);
+    const shortAxisEndImage = toScoord(scoordProps, longAxisPoints[1]);
     const {
       length,
       width
     } = cachedStats[`imageId:${referencedImageId}`] || {};
     return {
       longAxis: {
-        point1: {
-          x: longAxisStartImage[0],
-          y: longAxisStartImage[1]
-        },
-        point2: {
-          x: longAxisEndImage[0],
-          y: longAxisEndImage[1]
-        }
-      },
-      shortAxis: {
-        point1: {
-          x: shortAxisStartImage[0],
-          y: shortAxisStartImage[1]
-        },
-        point2: {
-          x: shortAxisEndImage[0],
-          y: shortAxisEndImage[1]
-        }
-      },
-      longAxisLength: length,
-      shortAxisLength: width,
-      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
-      finding: finding,
-      findingSites: findingSites || [],
-      use3DSpatialCoordinates: false
-    };
-  }
-  static getTID300RepresentationArgumentsSCOORD3D(_ref3) {
-    let {
-      tool,
-      shortAxisPoints,
-      longAxisPoints
-    } = _ref3;
-    const {
-      data,
-      finding,
-      findingSites,
-      metadata
-    } = tool;
-    const {
-      cachedStats = {}
-    } = data;
-    const longAxisStart = shortAxisPoints[0];
-    const longAxisEnd = shortAxisPoints[1];
-    const shortAxisStart = longAxisPoints[0];
-    const shortAxisEnd = longAxisPoints[1];
-    const cachedStatsKeys = Object.keys(cachedStats)[0];
-    const {
-      length = undefined,
-      width = undefined
-    } = cachedStatsKeys ? cachedStats[cachedStatsKeys] : {};
-    return {
-      longAxis: {
-        point1: {
-          x: longAxisStart[0],
-          y: longAxisStart[1],
-          z: longAxisStart[2]
-        },
-        point2: {
-          x: longAxisEnd[0],
-          y: longAxisEnd[1],
-          z: longAxisEnd[2]
-        }
+        point1: longAxisStartImage,
+        point2: longAxisEndImage
       },
       shortAxis: {
-        point1: {
-          x: shortAxisStart[0],
-          y: shortAxisStart[1],
-          z: shortAxisStart[2]
-        },
-        point2: {
-          x: shortAxisEnd[0],
-          y: shortAxisEnd[1],
-          z: shortAxisEnd[2]
-        }
+        point1: shortAxisStartImage,
+        point2: shortAxisEndImage
       },
       longAxisLength: length,
       shortAxisLength: width,
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       finding: finding,
       findingSites: findingSites || [],
-      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
-      use3DSpatialCoordinates: true
+      ReferencedFrameOfReferenceUID: is3DMeasurement ? metadata.FrameOfReferenceUID : null,
+      use3DSpatialCoordinates: is3DMeasurement
     };
   }
 }
@@ -4899,98 +5095,40 @@ _Bidirectional = Bidirectional_Bidirectional;
 
 
 
+
+
+
 var _Angle;
 const {
   CobbAngle: Angle_TID300CobbAngle
 } = dcmjs_es/* utilities */.BF.TID300;
 class Angle_Angle extends BaseAdapter3D {
-  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata) {
     const {
-      defaultState,
-      NUMGroup,
-      SCOORDGroup,
-      SCOORD3DGroup,
-      ReferencedFrameNumber
-    } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, Angle_Angle.toolType);
-    if (SCOORDGroup) {
-      return this.getMeasurementDataFromScoord({
-        defaultState,
-        SCOORDGroup,
-        imageToWorldCoords,
-        NUMGroup,
-        ReferencedFrameNumber
-      });
-    } else if (SCOORD3DGroup) {
-      return this.getMeasurementDataFromScoord3D({
-        defaultState,
-        SCOORD3DGroup
-      });
-    } else {
-      throw new Error("Can't get measurement data with missing SCOORD and SCOORD3D groups.");
-    }
-  }
-  static getMeasurementDataFromScoord(_ref) {
-    let {
-      defaultState,
-      SCOORDGroup,
-      imageToWorldCoords,
+      state,
       NUMGroup,
+      worldCoords,
+      referencedImageId,
       ReferencedFrameNumber
-    } = _ref;
-    const referencedImageId = defaultState.annotation.metadata.referencedImageId;
-    const {
-      GraphicData
-    } = SCOORDGroup;
-    const worldCoords = [];
-    for (let i = 0; i < GraphicData.length; i += 2) {
-      const point = imageToWorldCoords(referencedImageId, [GraphicData[i], GraphicData[i + 1]]);
-      worldCoords.push(point);
-    }
-    const state = defaultState;
+    } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType);
+    const cachedStats = referencedImageId ? {
+      [`imageId:${referencedImageId}`]: {
+        angle: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : null
+      }
+    } : {};
     state.annotation.data = {
+      ...state.annotation.data,
       handles: {
-        points: [worldCoords[0], worldCoords[1], worldCoords[3]],
-        activeHandleIndex: 0,
-        textBox: {
-          hasMoved: false
-        }
-      },
-      cachedStats: {
-        [`imageId:${referencedImageId}`]: {
-          angle: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : null
-        }
+        ...state.annotation.data.handles,
+        points: [worldCoords[0], worldCoords[1], worldCoords[3]]
       },
+      cachedStats,
       frameNumber: ReferencedFrameNumber
     };
     return state;
   }
-  static getMeasurementDataFromScoord3D(_ref2) {
-    let {
-      defaultState,
-      SCOORD3DGroup
-    } = _ref2;
-    const {
-      GraphicData
-    } = SCOORD3DGroup;
-    const worldCoords = [];
-    for (let i = 0; i < GraphicData.length; i += 3) {
-      const point = [GraphicData[i], GraphicData[i + 1], GraphicData[i + 2]];
-      worldCoords.push(point);
-    }
-    const state = defaultState;
-    state.annotation.data = {
-      handles: {
-        points: [worldCoords[0], worldCoords[1], worldCoords[3]],
-        activeHandleIndex: 0,
-        textBox: {
-          hasMoved: false
-        }
-      },
-      cachedStats: {}
-    };
-    return state;
-  }
-  static getTID300RepresentationArguments(tool, worldToImageCoords) {
+  static getTID300RepresentationArguments(tool) {
+    let is3DMeasurement = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     const {
       data,
       finding,
@@ -5004,74 +5142,15 @@ class Angle_Angle extends BaseAdapter3D {
     const {
       referencedImageId
     } = metadata;
-    if (!referencedImageId) {
-      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
-    }
-    const start1 = worldToImageCoords(referencedImageId, handles.points[0]);
-    const middle = worldToImageCoords(referencedImageId, handles.points[1]);
-    const end = worldToImageCoords(referencedImageId, handles.points[2]);
-    const point1 = {
-      x: start1[0],
-      y: start1[1]
-    };
-    const point2 = {
-      x: middle[0],
-      y: middle[1]
-    };
-    const point3 = point2;
-    const point4 = {
-      x: end[0],
-      y: end[1]
-    };
-    const {
-      angle
-    } = cachedStats[`imageId:${referencedImageId}`] || {};
-    return {
-      point1,
-      point2,
-      point3,
-      point4,
-      rAngle: angle,
-      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
-      finding,
-      findingSites: findingSites || [],
-      use3DSpatialCoordinates: false
-    };
-  }
-  static getTID300RepresentationArgumentsSCOORD3D(tool) {
-    const {
-      data,
-      finding,
-      findingSites,
-      metadata
-    } = tool;
-    const {
-      cachedStats = {},
-      handles
-    } = data;
-    const start = handles.points[0];
-    const middle = handles.points[1];
-    const end = handles.points[2];
-    const point1 = {
-      x: start[0],
-      y: start[1],
-      z: start[2]
-    };
-    const point2 = {
-      x: middle[0],
-      y: middle[1],
-      z: middle[2]
-    };
-    const point3 = point2;
-    const point4 = {
-      x: end[0],
-      y: end[1],
-      z: end[2]
+    const scoordProps = {
+      is3DMeasurement,
+      referencedImageId
     };
-    const cachedStatsKeys = Object.keys(cachedStats)[0];
-    const {
-      angle = undefined
-    } = cachedStatsKeys ? cachedStats[cachedStatsKeys] : {};
+    const point1 = toScoord(scoordProps, handles.points[0]);
+    const point2 = toScoord(scoordProps, handles.points[1]);
+    const point3 = toScoord(scoordProps, handles.points[1]);
+    const point4 = toScoord(scoordProps, handles.points[2]);
+    const angle = cachedStats[`imageId:${referencedImageId}`]?.angle;
     return {
       point1,
       point2,
@@ -5081,8 +5160,8 @@ class Angle_Angle extends BaseAdapter3D {
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       finding,
       findingSites: findingSites || [],
-      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
-      use3DSpatialCoordinates: true
+      ReferencedFrameOfReferenceUID: is3DMeasurement ? metadata.FrameOfReferenceUID : null,
+      use3DSpatialCoordinates: is3DMeasurement
     };
   }
 }
@@ -5099,98 +5178,41 @@ _Angle = Angle_Angle;
 
 
 
+
+
+
 var _CobbAngle;
 const {
   CobbAngle: CobbAngle_TID300CobbAngle
 } = dcmjs_es/* utilities */.BF.TID300;
 class CobbAngle_CobbAngle extends BaseAdapter3D {
-  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata) {
     const {
-      defaultState,
+      state,
       NUMGroup,
-      SCOORDGroup,
-      SCOORD3DGroup,
+      referencedImageId,
+      worldCoords,
       ReferencedFrameNumber
     } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, CobbAngle_CobbAngle.toolType);
-    if (SCOORDGroup) {
-      return this.getMeasurementDataFromScoord({
-        defaultState,
-        SCOORDGroup,
-        imageToWorldCoords,
-        NUMGroup,
-        ReferencedFrameNumber
-      });
-    } else if (SCOORD3DGroup) {
-      return this.getMeasurementDataFromScoord3D({
-        defaultState,
-        SCOORD3DGroup
-      });
-    } else {
-      throw new Error("Can't get measurement data with missing SCOORD and SCOORD3D groups.");
-    }
-  }
-  static getMeasurementDataFromScoord(_ref) {
-    let {
-      defaultState,
-      SCOORDGroup,
-      imageToWorldCoords,
-      NUMGroup,
-      ReferencedFrameNumber
-    } = _ref;
-    const referencedImageId = defaultState.annotation.metadata.referencedImageId;
-    const {
-      GraphicData
-    } = SCOORDGroup;
-    const worldCoords = [];
-    for (let i = 0; i < GraphicData.length; i += 2) {
-      const point = imageToWorldCoords(referencedImageId, [GraphicData[i], GraphicData[i + 1]]);
-      worldCoords.push(point);
-    }
-    const state = defaultState;
     state.annotation.data = {
+      ...state.annotation.data,
       handles: {
-        points: [worldCoords[0], worldCoords[1], worldCoords[2], worldCoords[3]],
-        activeHandleIndex: 0,
-        textBox: {
-          hasMoved: false
-        }
+        ...state.annotation.data.handles,
+        points: [worldCoords[0], worldCoords[1], worldCoords[2], worldCoords[3]]
       },
-      cachedStats: {
+      frameNumber: ReferencedFrameNumber
+    };
+    if (referencedImageId) {
+      state.annotation.data.cachedStats = {
         [`imageId:${referencedImageId}`]: {
           angle: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : null
         }
-      },
-      frameNumber: ReferencedFrameNumber
-    };
-    return state;
-  }
-  static getMeasurementDataFromScoord3D(_ref2) {
-    let {
-      defaultState,
-      SCOORD3DGroup
-    } = _ref2;
-    const {
-      GraphicData
-    } = SCOORD3DGroup;
-    const worldCoords = [];
-    for (let i = 0; i < GraphicData.length; i += 3) {
-      const point = [GraphicData[i], GraphicData[i + 1], GraphicData[i + 2]];
-      worldCoords.push(point);
+      };
     }
-    const state = defaultState;
-    state.annotation.data = {
-      handles: {
-        points: [worldCoords[0], worldCoords[1], worldCoords[2], worldCoords[3]],
-        activeHandleIndex: 0,
-        textBox: {
-          hasMoved: false
-        }
-      },
-      cachedStats: {}
-    };
     return state;
   }
-  static getTID300RepresentationArguments(tool, worldToImageCoords) {
+  static getTID300RepresentationArguments(tool) {
+    let is3DMeasurement = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     const {
       data,
       finding,
@@ -5204,29 +5226,12 @@ class CobbAngle_CobbAngle extends BaseAdapter3D {
     const {
       referencedImageId
     } = metadata;
-    if (!referencedImageId) {
-      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
-    }
-    const start1 = worldToImageCoords(referencedImageId, handles.points[0]);
-    const end1 = worldToImageCoords(referencedImageId, handles.points[1]);
-    const start2 = worldToImageCoords(referencedImageId, handles.points[2]);
-    const end2 = worldToImageCoords(referencedImageId, handles.points[3]);
-    const point1 = {
-      x: start1[0],
-      y: start1[1]
-    };
-    const point2 = {
-      x: end1[0],
-      y: end1[1]
-    };
-    const point3 = {
-      x: start2[0],
-      y: start2[1]
-    };
-    const point4 = {
-      x: end2[0],
-      y: end2[1]
+    const scoordProps = {
+      is3DMeasurement,
+      referencedImageId
     };
+    const points = toScoords(scoordProps, handles.points);
+    const [point1, point2, point3, point4] = points;
     const {
       angle
     } = cachedStats[`imageId:${referencedImageId}`] || {};
@@ -5239,59 +5244,8 @@ class CobbAngle_CobbAngle extends BaseAdapter3D {
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       finding,
       findingSites: findingSites || [],
-      use3DSpatialCoordinates: false
-    };
-  }
-  static getTID300RepresentationArgumentsSCOORD3D(tool) {
-    const {
-      data,
-      finding,
-      findingSites,
-      metadata
-    } = tool;
-    const {
-      cachedStats = {},
-      handles
-    } = data;
-    const start1 = handles.points[0];
-    const end1 = handles.points[1];
-    const start2 = handles.points[2];
-    const end2 = handles.points[3];
-    const point1 = {
-      x: start1[0],
-      y: start1[1],
-      z: start1[2]
-    };
-    const point2 = {
-      x: end1[0],
-      y: end1[1],
-      z: end1[2]
-    };
-    const point3 = {
-      x: start2[0],
-      y: start2[1],
-      z: start2[2]
-    };
-    const point4 = {
-      x: end2[0],
-      y: end2[1],
-      z: end2[2]
-    };
-    const cachedStatsKeys = Object.keys(cachedStats)[0];
-    const {
-      angle = undefined
-    } = cachedStatsKeys ? cachedStats[cachedStatsKeys] : {};
-    return {
-      point1,
-      point2,
-      point3,
-      point4,
-      rAngle: angle,
-      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
-      finding,
-      findingSites: findingSites || [],
-      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
-      use3DSpatialCoordinates: true
+      ReferencedFrameOfReferenceUID: is3DMeasurement ? metadata.FrameOfReferenceUID : null,
+      use3DSpatialCoordinates: is3DMeasurement
     };
   }
 }
@@ -5308,100 +5262,43 @@ _CobbAngle = CobbAngle_CobbAngle;
 
 
 
+
+
+
 var _CircleROI;
 const {
   Circle: CircleROI_TID300Circle
 } = dcmjs_es/* utilities */.BF.TID300;
 class CircleROI extends BaseAdapter3D {
-  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata) {
     const {
-      defaultState,
-      NUMGroup,
-      SCOORDGroup,
-      SCOORD3DGroup,
-      ReferencedFrameNumber
-    } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, CircleROI.toolType);
-    if (SCOORDGroup) {
-      return this.getMeasurementDataFromScoord({
-        defaultState,
-        SCOORDGroup,
-        imageToWorldCoords,
-        NUMGroup,
-        ReferencedFrameNumber
-      });
-    } else if (SCOORD3DGroup) {
-      return this.getMeasurementDataFromScoord3D({
-        defaultState,
-        SCOORD3DGroup
-      });
-    } else {
-      throw new Error("Can't get measurement data with missing SCOORD and SCOORD3D groups.");
-    }
-  }
-  static getMeasurementDataFromScoord(_ref) {
-    let {
-      defaultState,
-      SCOORDGroup,
-      imageToWorldCoords,
+      state,
       NUMGroup,
+      worldCoords,
+      referencedImageId,
       ReferencedFrameNumber
-    } = _ref;
-    const referencedImageId = defaultState.annotation.metadata.referencedImageId;
-    const {
-      GraphicData
-    } = SCOORDGroup;
-    const pointsWorld = [];
-    for (let i = 0; i < GraphicData.length; i += 2) {
-      const worldPos = imageToWorldCoords(referencedImageId, [GraphicData[i], GraphicData[i + 1]]);
-      pointsWorld.push(worldPos);
-    }
-    const state = defaultState;
+    } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType);
     state.annotation.data = {
+      ...state.annotation.data,
       handles: {
-        points: [...pointsWorld],
-        activeHandleIndex: 0,
-        textBox: {
-          hasMoved: false
-        }
+        ...state.annotation.data.handles,
+        points: worldCoords
       },
-      cachedStats: {
+      frameNumber: ReferencedFrameNumber
+    };
+    if (referencedImageId) {
+      state.annotation.data.cachedStats = {
         [`imageId:${referencedImageId}`]: {
           area: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : 0,
           radius: 0,
           perimeter: 0
         }
-      },
-      frameNumber: ReferencedFrameNumber
-    };
-    return state;
-  }
-  static getMeasurementDataFromScoord3D(_ref2) {
-    let {
-      defaultState,
-      SCOORD3DGroup
-    } = _ref2;
-    const {
-      GraphicData
-    } = SCOORD3DGroup;
-    const pointsWorld = [];
-    for (let i = 0; i < GraphicData.length; i += 3) {
-      const worldPos = [GraphicData[i], GraphicData[i + 1], GraphicData[i + 2]];
-      pointsWorld.push(worldPos);
+      };
     }
-    const state = defaultState;
-    state.annotation.data = {
-      handles: {
-        points: [...pointsWorld],
-        activeHandleIndex: 0,
-        textBox: {
-          hasMoved: false
-        }
-      },
-      cachedStats: {}
-    };
     return state;
   }
-  static getTID300RepresentationArguments(tool, worldToImageCoords) {
+  static getTID300RepresentationArguments(tool) {
+    let is3DMeasurement = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     const {
       data,
       finding,
@@ -5415,20 +5312,12 @@ class CircleROI extends BaseAdapter3D {
     const {
       referencedImageId
     } = metadata;
-    if (!referencedImageId) {
-      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
-    }
-    const center = worldToImageCoords(referencedImageId, handles.points[0]);
-    const end = worldToImageCoords(referencedImageId, handles.points[1]);
-    const points = [];
-    points.push({
-      x: center[0],
-      y: center[1]
-    });
-    points.push({
-      x: end[0],
-      y: end[1]
-    });
+    const scoordProps = {
+      is3DMeasurement,
+      referencedImageId
+    };
+    const center = toScoord(scoordProps, handles.points[0]);
+    const end = toScoord(scoordProps, handles.points[1]);
     const {
       area,
       radius
@@ -5438,53 +5327,12 @@ class CircleROI extends BaseAdapter3D {
       area,
       perimeter,
       radius,
-      points,
-      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
-      finding,
-      findingSites: findingSites || [],
-      use3DSpatialCoordinates: false
-    };
-  }
-  static getTID300RepresentationArgumentsSCOORD3D(tool) {
-    const {
-      data,
-      finding,
-      findingSites,
-      metadata
-    } = tool;
-    const {
-      cachedStats = {},
-      handles
-    } = data;
-    const center = handles.points[0];
-    const end = handles.points[1];
-    const points = [];
-    points.push({
-      x: center[0],
-      y: center[1],
-      z: center[2]
-    });
-    points.push({
-      x: end[0],
-      y: end[1],
-      z: center[2]
-    });
-    const cachedStatsKeys = Object.keys(cachedStats)[0];
-    const {
-      area = undefined,
-      radius = 0
-    } = cachedStatsKeys ? cachedStats[cachedStatsKeys] : {};
-    const perimeter = 2 * Math.PI * radius;
-    return {
-      area,
-      perimeter,
-      radius,
-      points,
+      points: [center, end],
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       finding,
       findingSites: findingSites || [],
-      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
-      use3DSpatialCoordinates: true
+      ReferencedFrameOfReferenceUID: is3DMeasurement ? metadata.FrameOfReferenceUID : null,
+      use3DSpatialCoordinates: is3DMeasurement
     };
   }
 }
@@ -5496,149 +5344,44 @@ _CircleROI = CircleROI;
 
 
 
-// EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js + 1 modules
-var gl_matrix_esm = __webpack_require__(3823);
 ;// ../../../node_modules/@cornerstonejs/adapters/dist/esm/adapters/Cornerstone3D/EllipticalROI.js
 
 
 
 
 
+
+
 var _EllipticalROI;
 const {
   Ellipse: EllipticalROI_TID300Ellipse
 } = dcmjs_es/* utilities */.BF.TID300;
-const EPSILON = 1e-4;
 class EllipticalROI extends BaseAdapter3D {
-  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata) {
     const {
-      defaultState,
+      state,
       NUMGroup,
-      SCOORDGroup,
-      SCOORD3DGroup,
+      worldCoords,
+      referencedImageId,
       ReferencedFrameNumber
     } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, EllipticalROI.toolType);
-    if (SCOORDGroup) {
-      return this.getMeasurementDataFromScoord({
-        defaultState,
-        SCOORDGroup,
-        imageToWorldCoords,
-        metadata,
-        NUMGroup,
-        ReferencedFrameNumber
-      });
-    } else if (SCOORD3DGroup) {
-      return this.getMeasurementDataFromScoord3D({
-        defaultState,
-        SCOORD3DGroup
-      });
-    } else {
-      throw new Error("Can't get measurement data with missing SCOORD and SCOORD3D groups.");
-    }
-  }
-  static getMeasurementDataFromScoord(_ref) {
-    let {
-      defaultState,
-      SCOORDGroup,
-      imageToWorldCoords,
-      metadata,
-      NUMGroup,
-      ReferencedFrameNumber
-    } = _ref;
-    const referencedImageId = defaultState.annotation.metadata.referencedImageId;
-    const {
-      GraphicData
-    } = SCOORDGroup;
-    const pointsWorld = [];
-    for (let i = 0; i < GraphicData.length; i += 2) {
-      const worldPos = imageToWorldCoords(referencedImageId, [GraphicData[i], GraphicData[i + 1]]);
-      pointsWorld.push(worldPos);
-    }
-    const majorAxisStart = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(...pointsWorld[0]);
-    const majorAxisEnd = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(...pointsWorld[1]);
-    const minorAxisStart = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(...pointsWorld[2]);
-    const minorAxisEnd = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(...pointsWorld[3]);
-    const majorAxisVec = gl_matrix_esm/* vec3.create */.eR.create();
-    gl_matrix_esm/* vec3.sub */.eR.sub(majorAxisVec, majorAxisEnd, majorAxisStart);
-    gl_matrix_esm/* vec3.normalize */.eR.normalize(majorAxisVec, majorAxisVec);
-    const minorAxisVec = gl_matrix_esm/* vec3.create */.eR.create();
-    gl_matrix_esm/* vec3.sub */.eR.sub(minorAxisVec, minorAxisEnd, minorAxisStart);
-    gl_matrix_esm/* vec3.normalize */.eR.normalize(minorAxisVec, minorAxisVec);
-    const imagePlaneModule = metadata.get("imagePlaneModule", referencedImageId);
-    if (!imagePlaneModule) {
-      throw new Error("imageId does not have imagePlaneModule metadata");
-    }
-    const {
-      columnCosines
-    } = imagePlaneModule;
-    const columnCosinesVec = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(columnCosines[0], columnCosines[1], columnCosines[2]);
-    const projectedMajorAxisOnColVec = gl_matrix_esm/* vec3.dot */.eR.dot(columnCosinesVec, majorAxisVec);
-    const projectedMinorAxisOnColVec = gl_matrix_esm/* vec3.dot */.eR.dot(columnCosinesVec, minorAxisVec);
-    const absoluteOfMajorDotProduct = Math.abs(projectedMajorAxisOnColVec);
-    const absoluteOfMinorDotProduct = Math.abs(projectedMinorAxisOnColVec);
-    let ellipsePoints = [];
-    if (Math.abs(absoluteOfMajorDotProduct - 1) < EPSILON) {
-      ellipsePoints = [pointsWorld[0], pointsWorld[1], pointsWorld[2], pointsWorld[3]];
-    } else if (Math.abs(absoluteOfMinorDotProduct - 1) < EPSILON) {
-      ellipsePoints = [pointsWorld[2], pointsWorld[3], pointsWorld[0], pointsWorld[1]];
-    } else {
-      console.warn("OBLIQUE ELLIPSE NOT YET SUPPORTED");
-    }
-    const state = defaultState;
     state.annotation.data = {
+      ...state.annotation.data,
       handles: {
-        points: [...ellipsePoints],
-        activeHandleIndex: 0,
-        textBox: {
-          hasMoved: false
-        }
-      },
-      cachedStats: {
-        [`imageId:${referencedImageId}`]: {
-          area: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : 0
-        }
+        ...state.annotation.data.handles,
+        points: worldCoords
       },
       frameNumber: ReferencedFrameNumber
     };
+    state.annotation.data.cachedStats = referencedImageId ? {
+      [`imageId:${referencedImageId}`]: {
+        area: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : 0
+      }
+    } : {};
     return state;
   }
-  static getMeasurementDataFromScoord3D(_ref2) {
-    let {
-      defaultState,
-      SCOORD3DGroup
-    } = _ref2;
-    const {
-      GraphicData
-    } = SCOORD3DGroup;
-    const pointsWorld = [];
-    for (let i = 0; i < GraphicData.length; i += 3) {
-      const worldPos = [GraphicData[i], GraphicData[i + 1], GraphicData[i + 2]];
-      pointsWorld.push(worldPos);
-    }
-    const majorAxisStart = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(...pointsWorld[0]);
-    const majorAxisEnd = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(...pointsWorld[1]);
-    const minorAxisStart = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(...pointsWorld[2]);
-    const minorAxisEnd = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(...pointsWorld[3]);
-    const majorAxisVec = gl_matrix_esm/* vec3.create */.eR.create();
-    gl_matrix_esm/* vec3.sub */.eR.sub(majorAxisVec, majorAxisEnd, majorAxisStart);
-    gl_matrix_esm/* vec3.normalize */.eR.normalize(majorAxisVec, majorAxisVec);
-    const minorAxisVec = gl_matrix_esm/* vec3.create */.eR.create();
-    gl_matrix_esm/* vec3.sub */.eR.sub(minorAxisVec, minorAxisEnd, minorAxisStart);
-    gl_matrix_esm/* vec3.normalize */.eR.normalize(minorAxisVec, minorAxisVec);
-    const state = defaultState;
-    state.annotation.data = {
-      handles: {
-        points: [majorAxisStart, majorAxisEnd, minorAxisStart, minorAxisEnd],
-        activeHandleIndex: 0,
-        textBox: {
-          hasMoved: false
-        }
-      },
-      cachedStats: {}
-    };
-    return state;
-  }
-  static getTID300RepresentationArguments(tool, worldToImageCoords) {
+  static getTID300RepresentationArguments(tool) {
+    let is3DMeasurement = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     const {
       data,
       finding,
@@ -5653,83 +5396,10 @@ class EllipticalROI extends BaseAdapter3D {
     const {
       referencedImageId
     } = metadata;
-    if (!referencedImageId) {
-      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
-    }
-    let top, bottom, left, right;
-    if (rotation == 90 || rotation == 270) {
-      bottom = worldToImageCoords(referencedImageId, handles.points[2]);
-      top = worldToImageCoords(referencedImageId, handles.points[3]);
-      left = worldToImageCoords(referencedImageId, handles.points[0]);
-      right = worldToImageCoords(referencedImageId, handles.points[1]);
-    } else {
-      top = worldToImageCoords(referencedImageId, handles.points[0]);
-      bottom = worldToImageCoords(referencedImageId, handles.points[1]);
-      left = worldToImageCoords(referencedImageId, handles.points[2]);
-      right = worldToImageCoords(referencedImageId, handles.points[3]);
-    }
-    const topBottomLength = Math.abs(top[1] - bottom[1]);
-    const leftRightLength = Math.abs(left[0] - right[0]);
-    const points = [];
-    if (topBottomLength > leftRightLength) {
-      points.push({
-        x: top[0],
-        y: top[1]
-      });
-      points.push({
-        x: bottom[0],
-        y: bottom[1]
-      });
-      points.push({
-        x: left[0],
-        y: left[1]
-      });
-      points.push({
-        x: right[0],
-        y: right[1]
-      });
-    } else {
-      points.push({
-        x: left[0],
-        y: left[1]
-      });
-      points.push({
-        x: right[0],
-        y: right[1]
-      });
-      points.push({
-        x: top[0],
-        y: top[1]
-      });
-      points.push({
-        x: bottom[0],
-        y: bottom[1]
-      });
-    }
-    const {
-      area
-    } = cachedStats[`imageId:${referencedImageId}`] || {};
-    return {
-      area,
-      points,
-      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
-      finding,
-      findingSites: findingSites || [],
-      use3DSpatialCoordinates: false
+    const scoordProps = {
+      is3DMeasurement,
+      referencedImageId
     };
-  }
-  static getTID300RepresentationArgumentsSCOORD3D(tool) {
-    const {
-      data,
-      finding,
-      findingSites,
-      metadata
-    } = tool;
-    const {
-      cachedStats,
-      handles
-    } = data;
-    const rotation = data.initialRotation || 0;
     let top, bottom, left, right;
     if (rotation == 90 || rotation == 270) {
       bottom = handles.points[2];
@@ -5746,60 +5416,22 @@ class EllipticalROI extends BaseAdapter3D {
     const leftRightLength = Math.sqrt((left[0] - right[0]) ** 2 + (left[1] - right[1]) ** 2 + (left[2] - right[2]) ** 2);
     const points = [];
     if (topBottomLength > leftRightLength) {
-      points.push({
-        x: top[0],
-        y: top[1],
-        z: top[2]
-      });
-      points.push({
-        x: bottom[0],
-        y: bottom[1],
-        z: bottom[2]
-      });
-      points.push({
-        x: left[0],
-        y: left[1],
-        z: left[2]
-      });
-      points.push({
-        x: right[0],
-        y: right[1],
-        z: right[2]
-      });
+      points.push(top, bottom, left, right);
     } else {
-      points.push({
-        x: left[0],
-        y: left[1],
-        z: left[2]
-      });
-      points.push({
-        x: right[0],
-        y: right[1],
-        z: right[2]
-      });
-      points.push({
-        x: top[0],
-        y: top[1],
-        z: top[2]
-      });
-      points.push({
-        x: bottom[0],
-        y: bottom[1],
-        z: bottom[2]
-      });
+      points.push(left, right, top, bottom);
     }
-    const cachedStatsKeys = Object.keys(cachedStats)[0];
     const {
-      area = undefined
-    } = cachedStatsKeys ? cachedStats[cachedStatsKeys] : {};
+      area
+    } = cachedStats[`imageId:${referencedImageId}`] || {};
+    const convertedPoints = points.map(point => toScoord(scoordProps, point));
     return {
       area,
-      points,
+      points: convertedPoints,
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       finding,
       findingSites: findingSites || [],
-      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
-      use3DSpatialCoordinates: true
+      ReferencedFrameOfReferenceUID: is3DMeasurement ? metadata.FrameOfReferenceUID : null,
+      use3DSpatialCoordinates: is3DMeasurement
     };
   }
 }
@@ -5813,145 +5445,59 @@ _EllipticalROI.init("EllipticalROI", EllipticalROI_TID300Ellipse);
 
 
 
+
+
+
 var _RectangleROI;
 const {
   Polyline: RectangleROI_TID300Polyline
 } = dcmjs_es/* utilities */.BF.TID300;
 class RectangleROI extends BaseAdapter3D {
-  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata) {
     const {
-      defaultState,
-      NUMGroup,
-      SCOORDGroup,
-      SCOORD3DGroup,
-      ReferencedFrameNumber
-    } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, RectangleROI.toolType);
-    if (SCOORDGroup) {
-      return this.getMeasurementDataFromScoord({
-        defaultState,
-        SCOORDGroup,
-        imageToWorldCoords,
-        NUMGroup,
-        ReferencedFrameNumber
-      });
-    } else if (SCOORD3DGroup) {
-      return this.getMeasurementDataFromScoord3D({
-        SCOORD3DGroup,
-        defaultState
-      });
-    } else {
-      throw new Error("Can't get measurement data with missing SCOORD and SCOORD3D groups.");
-    }
-  }
-  static getMeasurementDataFromScoord(_ref) {
-    let {
-      defaultState,
-      SCOORDGroup,
-      imageToWorldCoords,
-      NUMGroup,
+      state,
+      worldCoords,
+      referencedImageId,
       ReferencedFrameNumber
-    } = _ref;
-    const referencedImageId = defaultState.annotation.metadata.referencedImageId;
-    const {
-      GraphicData
-    } = SCOORDGroup;
-    const worldCoords = [];
-    for (let i = 0; i < GraphicData.length; i += 2) {
-      const point = imageToWorldCoords(referencedImageId, [GraphicData[i], GraphicData[i + 1]]);
-      worldCoords.push(point);
-    }
-    const state = defaultState;
+    } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType);
+    const areaGroup = MeasurementGroup.ContentSequence.find(g => g.ValueType === "NUM" && g.ConceptNameCodeSequence[0].CodeMeaning === "Area");
+    const cachedStats = referencedImageId ? {
+      [`imageId:${referencedImageId}`]: {
+        area: areaGroup?.MeasuredValueSequence?.[0]?.NumericValue || 0,
+        areaUnit: areaGroup?.MeasuredValueSequence?.[0]?.MeasurementUnitsCodeSequence?.CodeValue
+      }
+    } : {};
     state.annotation.data = {
+      ...state.annotation.data,
       handles: {
-        points: [worldCoords[0], worldCoords[1], worldCoords[3], worldCoords[2]],
-        activeHandleIndex: 0,
-        textBox: {
-          hasMoved: false
-        }
-      },
-      cachedStats: {
-        [`imageId:${referencedImageId}`]: {
-          area: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : null
-        }
+        ...state.annotation.data.handles,
+        points: [worldCoords[0], worldCoords[1], worldCoords[3], worldCoords[2]]
       },
+      cachedStats,
       frameNumber: ReferencedFrameNumber
     };
     return state;
   }
-  static getMeasurementDataFromScoord3D(_ref2) {
-    let {
-      SCOORD3DGroup,
-      defaultState
-    } = _ref2;
-    const {
-      GraphicData
-    } = SCOORD3DGroup;
-    const worldCoords = [];
-    for (let i = 0; i < GraphicData.length; i += 3) {
-      const point = [GraphicData[i], GraphicData[i + 1], GraphicData[i + 2]];
-      worldCoords.push(point);
-    }
-    const state = defaultState;
-    state.annotation.data = {
-      handles: {
-        points: [worldCoords[0], worldCoords[1], worldCoords[3], worldCoords[2]],
-        activeHandleIndex: 0,
-        textBox: {
-          hasMoved: false
-        }
-      },
-      cachedStats: {}
-    };
-    return state;
-  }
-  static getTID300RepresentationArguments(tool, worldToImageCoords) {
+  static getTID300RepresentationArguments(tool) {
+    let is3DMeasurement = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     const {
       data,
       finding,
       findingSites,
       metadata
     } = tool;
-    const {
-      cachedStats = {},
-      handles
-    } = data;
     const {
       referencedImageId
     } = metadata;
-    if (!referencedImageId) {
-      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
-    }
-    const corners = handles.points.map(point => worldToImageCoords(referencedImageId, point));
-    const {
-      area,
-      perimeter
-    } = cachedStats;
-    return {
-      points: [corners[0], corners[1], corners[3], corners[2], corners[0]],
-      area,
-      perimeter,
-      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
-      finding,
-      findingSites: findingSites || [],
-      use3DSpatialCoordinates: false
+    const scoordProps = {
+      is3DMeasurement,
+      referencedImageId
     };
-  }
-  static getTID300RepresentationArgumentsSCOORD3D(tool) {
-    const {
-      data,
-      finding,
-      findingSites,
-      metadata
-    } = tool;
-    const {
-      cachedStats = {},
-      handles
-    } = data;
-    const corners = handles.points;
+    const corners = toScoords(scoordProps, data.handles.points);
     const {
       area,
       perimeter
-    } = cachedStats;
+    } = data.cachedStats[`imageId:${referencedImageId}`] || {};
     return {
       points: [corners[0], corners[1], corners[3], corners[2], corners[0]],
       area,
@@ -5959,8 +5505,7 @@ class RectangleROI extends BaseAdapter3D {
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       finding,
       findingSites: findingSites || [],
-      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
-      use3DSpatialCoordinates: true
+      use3DSpatialCoordinates: is3DMeasurement
     };
   }
 }
@@ -5977,95 +5522,42 @@ _RectangleROI = RectangleROI;
 
 
 
+
+
+
 var _Length;
 const {
   Length: Length_TID300Length
 } = dcmjs_es/* utilities */.BF.TID300;
 const Length_LENGTH = "Length";
 class Length_Length extends BaseAdapter3D {
-  static getMeasurementDataFromScoord(_ref) {
-    let {
-      defaultState,
-      NUMGroup,
-      SCOORDGroup,
-      ReferencedFrameNumber,
-      imageToWorldCoords
-    } = _ref;
-    const referencedImageId = defaultState.annotation.metadata.referencedImageId;
+  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata) {
     const {
-      GraphicData
-    } = SCOORDGroup;
-    const worldCoords = [];
-    for (let i = 0; i < GraphicData.length; i += 2) {
-      const point = imageToWorldCoords(referencedImageId, [GraphicData[i], GraphicData[i + 1]]);
-      worldCoords.push(point);
-    }
-    const state = defaultState;
+      state,
+      NUMGroup,
+      worldCoords,
+      referencedImageId,
+      ReferencedFrameNumber
+    } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType);
+    const cachedStats = referencedImageId ? {
+      [`imageId:${referencedImageId}`]: {
+        length: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : 0
+      }
+    } : {};
     state.annotation.data = {
+      ...state.annotation.data,
       handles: {
+        ...state.annotation.data.handles,
         points: [worldCoords[0], worldCoords[1]],
-        activeHandleIndex: 0,
-        textBox: {
-          hasMoved: false
-        }
-      },
-      cachedStats: {
-        [`imageId:${referencedImageId}`]: {
-          length: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : 0
-        }
+        activeHandleIndex: 0
       },
+      cachedStats,
       frameNumber: ReferencedFrameNumber
     };
     return state;
   }
-  static getMeasurementDataFromScoord3d(_ref2) {
-    let {
-      defaultState,
-      SCOORD3DGroup
-    } = _ref2;
-    const {
-      GraphicData
-    } = SCOORD3DGroup;
-    const worldCoords = GraphicData;
-    const state = defaultState;
-    state.annotation.data = {
-      handles: {
-        points: [worldCoords.slice(0, 3), worldCoords.slice(3, 6)],
-        activeHandleIndex: 0,
-        textBox: {
-          hasMoved: false
-        }
-      },
-      cachedStats: {}
-    };
-    return state;
-  }
-  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
-    const {
-      defaultState,
-      NUMGroup,
-      SCOORDGroup,
-      SCOORD3DGroup,
-      ReferencedFrameNumber
-    } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType);
-    if (SCOORDGroup) {
-      return this.getMeasurementDataFromScoord({
-        defaultState,
-        NUMGroup,
-        SCOORDGroup,
-        ReferencedFrameNumber,
-        imageToWorldCoords
-      });
-    } else if (SCOORD3DGroup) {
-      return this.getMeasurementDataFromScoord3d({
-        defaultState,
-        SCOORD3DGroup
-      });
-    } else {
-      throw new Error("Can't get measurement data with missing SCOORD and SCOORD3D groups.");
-    }
-  }
-  static getTID300RepresentationArguments(tool, worldToImageCoords) {
+  static getTID300RepresentationArguments(tool) {
+    let is3DMeasurement = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     const {
       data,
       finding,
@@ -6079,19 +5571,12 @@ class Length_Length extends BaseAdapter3D {
     const {
       referencedImageId
     } = metadata;
-    if (!referencedImageId) {
-      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
-    }
-    const start = worldToImageCoords(referencedImageId, handles.points[0]);
-    const end = worldToImageCoords(referencedImageId, handles.points[1]);
-    const point1 = {
-      x: start[0],
-      y: start[1]
-    };
-    const point2 = {
-      x: end[0],
-      y: end[1]
+    const scoordProps = {
+      is3DMeasurement,
+      referencedImageId
     };
+    const point1 = toScoord(scoordProps, handles.points[0]);
+    const point2 = toScoord(scoordProps, handles.points[1]);
     const {
       length: distance
     } = cachedStats[`imageId:${referencedImageId}`] || {};
@@ -6102,45 +5587,7 @@ class Length_Length extends BaseAdapter3D {
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       finding,
       findingSites: findingSites || [],
-      use3DSpatialCoordinates: false
-    };
-  }
-  static getTID300RepresentationArgumentsSCOORD3D(tool) {
-    const {
-      data,
-      finding,
-      findingSites,
-      metadata
-    } = tool;
-    const {
-      cachedStats = {},
-      handles
-    } = data;
-    const start = handles.points[0];
-    const end = handles.points[1];
-    const point1 = {
-      x: start[0],
-      y: start[1],
-      z: start[2]
-    };
-    const point2 = {
-      x: end[0],
-      y: end[1],
-      z: end[2]
-    };
-    const cachedStatsKeys = Object.keys(cachedStats)[0];
-    const {
-      length: distance = undefined
-    } = cachedStatsKeys ? cachedStats[cachedStatsKeys] : {};
-    return {
-      point1,
-      point2,
-      distance,
-      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
-      finding,
-      findingSites: findingSites || [],
-      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
-      use3DSpatialCoordinates: true
+      use3DSpatialCoordinates: is3DMeasurement
     };
   }
 }
@@ -6152,104 +5599,30 @@ _Length = Length_Length;
 
 
 
+// EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js + 1 modules
+var gl_matrix_esm = __webpack_require__(3823);
 ;// ../../../node_modules/@cornerstonejs/adapters/dist/esm/adapters/Cornerstone3D/PlanarFreehandROI.js
 
 
 
 
 
+
+
+
 var _PlanarFreehandROI;
 const {
   Polyline: PlanarFreehandROI_TID300Polyline
 } = dcmjs_es/* utilities */.BF.TID300;
 class PlanarFreehandROI extends BaseAdapter3D {
-  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata) {
     const {
-      defaultState,
-      NUMGroup,
-      SCOORDGroup,
-      SCOORD3DGroup,
-      ReferencedFrameNumber
-    } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, PlanarFreehandROI.toolType);
-    if (SCOORDGroup) {
-      return this.getMeasurementDataFromScoord({
-        defaultState,
-        SCOORDGroup,
-        imageToWorldCoords,
-        NUMGroup,
-        ReferencedFrameNumber
-      });
-    } else if (SCOORD3DGroup) {
-      return this.getMeasurementDataFromScoord3D({
-        defaultState,
-        SCOORD3DGroup
-      });
-    } else {
-      throw new Error("Can't get measurement data with missing SCOORD and SCOORD3D groups.");
-    }
-  }
-  static getMeasurementDataFromScoord(_ref) {
-    let {
-      defaultState,
-      SCOORDGroup,
-      imageToWorldCoords,
+      state,
       NUMGroup,
+      worldCoords,
+      referencedImageId,
       ReferencedFrameNumber
-    } = _ref;
-    const referencedImageId = defaultState.annotation.metadata.referencedImageId;
-    const {
-      GraphicData
-    } = SCOORDGroup;
-    const worldCoords = [];
-    for (let i = 0; i < GraphicData.length; i += 2) {
-      const point = imageToWorldCoords(referencedImageId, [GraphicData[i], GraphicData[i + 1]]);
-      worldCoords.push(point);
-    }
-    const distanceBetweenFirstAndLastPoint = gl_matrix_esm/* vec3.distance */.eR.distance(worldCoords[worldCoords.length - 1], worldCoords[0]);
-    let isOpenContour = true;
-    if (distanceBetweenFirstAndLastPoint < this.closedContourThreshold) {
-      worldCoords.pop();
-      isOpenContour = false;
-    }
-    const points = [];
-    if (isOpenContour) {
-      points.push(worldCoords[0], worldCoords[worldCoords.length - 1]);
-    }
-    const state = defaultState;
-    state.annotation.data = {
-      contour: {
-        polyline: worldCoords,
-        closed: !isOpenContour
-      },
-      handles: {
-        points,
-        activeHandleIndex: null,
-        textBox: {
-          hasMoved: false
-        }
-      },
-      cachedStats: {
-        [`imageId:${referencedImageId}`]: {
-          area: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : null
-        }
-      },
-      frameNumber: ReferencedFrameNumber
-    };
-    return state;
-  }
-  static getMeasurementDataFromScoord3D(_ref2) {
-    let {
-      defaultState,
-      SCOORD3DGroup
-    } = _ref2;
-    const {
-      GraphicData
-    } = SCOORD3DGroup;
-    const worldCoords = [];
-    for (let i = 0; i < GraphicData.length; i += 3) {
-      const point = [GraphicData[i], GraphicData[i + 1], GraphicData[i + 2]];
-      worldCoords.push(point);
-    }
+    } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType);
     const distanceBetweenFirstAndLastPoint = gl_matrix_esm/* vec3.distance */.eR.distance(worldCoords[worldCoords.length - 1], worldCoords[0]);
     let isOpenContour = true;
     if (distanceBetweenFirstAndLastPoint < this.closedContourThreshold) {
@@ -6260,24 +5633,29 @@ class PlanarFreehandROI extends BaseAdapter3D {
     if (isOpenContour) {
       points.push(worldCoords[0], worldCoords[worldCoords.length - 1]);
     }
-    const state = defaultState;
     state.annotation.data = {
+      ...state.annotation.data,
       contour: {
         polyline: worldCoords,
         closed: !isOpenContour
       },
       handles: {
-        points,
-        activeHandleIndex: null,
-        textBox: {
-          hasMoved: false
-        }
+        ...state.annotation.data.handles,
+        points
       },
-      cachedStats: {}
+      frameNumber: ReferencedFrameNumber
     };
+    if (referencedImageId) {
+      state.annotation.data.cachedStats = {
+        [`imageId:${referencedImageId}`]: {
+          area: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : null
+        }
+      };
+    }
     return state;
   }
-  static getTID300RepresentationArguments(tool, worldToImageCoords) {
+  static getTID300RepresentationArguments(tool) {
+    let is3DMeasurement = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     const {
       data,
       finding,
@@ -6292,13 +5670,14 @@ class PlanarFreehandROI extends BaseAdapter3D {
     const {
       referencedImageId
     } = metadata;
-    if (!referencedImageId) {
-      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
-    }
-    const points = polyline.map(worldPos => worldToImageCoords(referencedImageId, worldPos));
+    const scoordProps = {
+      is3DMeasurement,
+      referencedImageId
+    };
+    const points = toScoords(scoordProps, polyline);
     if (!isOpenContour) {
       const firstPoint = points[0];
-      points.push([firstPoint[0], firstPoint[1]]);
+      points.push(firstPoint);
     }
     const {
       area,
@@ -6321,50 +5700,8 @@ class PlanarFreehandROI extends BaseAdapter3D {
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       finding,
       findingSites: findingSites || [],
-      use3DSpatialCoordinates: false
-    };
-  }
-  static getTID300RepresentationArgumentsSCOORD3D(tool) {
-    const {
-      data,
-      finding,
-      findingSites,
-      metadata
-    } = tool;
-    const {
-      polyline,
-      closed
-    } = data.contour;
-    const isOpenContour = closed !== true;
-    const points = polyline;
-    if (!isOpenContour) {
-      const firstPoint = points[0];
-      points.push([firstPoint[0], firstPoint[1], firstPoint[2]]);
-    }
-    const cachedStatsKeys = Object.keys(data.cachedStats)[0];
-    const {
-      area = undefined,
-      areaUnit = undefined,
-      modalityUnit = undefined,
-      perimeter = undefined,
-      mean = undefined,
-      max = undefined,
-      stdDev = undefined
-    } = cachedStatsKeys ? data.cachedStats[cachedStatsKeys] : {};
-    return {
-      points,
-      area,
-      areaUnit,
-      perimeter,
-      modalityUnit,
-      mean,
-      max,
-      stdDev,
-      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
-      finding,
-      findingSites: findingSites || [],
-      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
-      use3DSpatialCoordinates: true
+      ReferencedFrameOfReferenceUID: is3DMeasurement ? metadata.FrameOfReferenceUID : null,
+      use3DSpatialCoordinates: is3DMeasurement
     };
   }
 }
@@ -6379,88 +5716,45 @@ _PlanarFreehandROI.init("PlanarFreehandROI", PlanarFreehandROI_TID300Polyline);
 
 
 
+
+
+
 var _Probe;
 const {
   Point: Probe_TID300Point
 } = dcmjs_es/* utilities */.BF.TID300;
 class Probe extends BaseAdapter3D {
-  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata, trackingIdentifier) {
-    const state = super.getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata, trackingIdentifier);
-    const {
-      defaultState,
-      SCOORDGroup,
-      SCOORD3DGroup
-    } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, Probe.toolType);
-    if (SCOORDGroup) {
-      return this.getMeasurementDataFromScoord({
-        state,
-        defaultState,
-        SCOORDGroup,
-        imageToWorldCoords
-      });
-    } else if (SCOORD3DGroup) {
-      return this.getMeasurementDataFromScoord3D({
-        state,
-        SCOORD3DGroup
-      });
-    } else {
-      throw new Error("Can't get measurement data with missing SCOORD and SCOORD3D groups.");
-    }
+  static isValidMeasurement(measurement) {
+    const graphicItem = this.getGraphicItem(measurement);
+    return this.getGraphicType(graphicItem) === "POINT" && this.getPointsCount(graphicItem) <= 2;
   }
-  static getMeasurementDataFromScoord(_ref) {
-    let {
-      state,
-      defaultState,
-      SCOORDGroup,
-      imageToWorldCoords
-    } = _ref;
-    const referencedImageId = defaultState.annotation.metadata.referencedImageId;
+  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, _trackingIdentifier) {
     const {
-      GraphicData
-    } = SCOORDGroup;
-    const worldCoords = [];
-    for (let i = 0; i < GraphicData.length; i += 2) {
-      const point = imageToWorldCoords(referencedImageId, [GraphicData[i], GraphicData[i + 1]]);
-      worldCoords.push(point);
-    }
-    state.annotation.data = {
-      ...state.annotation.data,
-      handles: {
-        points: worldCoords,
-        activeHandleIndex: null,
-        textBox: {
-          hasMoved: false
-        }
-      }
-    };
-    return state;
-  }
-  static getMeasurementDataFromScoord3D(_ref2) {
-    let {
       state,
-      SCOORD3DGroup
-    } = _ref2;
-    const {
-      GraphicData
-    } = SCOORD3DGroup;
-    const worldCoords = [];
-    for (let i = 0; i < GraphicData.length; i += 3) {
-      const point = [GraphicData[i], GraphicData[i + 1], GraphicData[i + 2]];
-      worldCoords.push(point);
-    }
+      NUMGroup,
+      worldCoords,
+      referencedImageId,
+      ReferencedFrameNumber
+    } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType);
+    const cachedStats = referencedImageId ? {
+      [`imageId:${referencedImageId}`]: {
+        value: NUMGroup?.MeasuredValueSequence?.NumericValue ?? null
+      }
+    } : {};
     state.annotation.data = {
       ...state.annotation.data,
       handles: {
-        points: worldCoords,
-        activeHandleIndex: null,
-        textBox: {
-          hasMoved: false
-        }
-      }
+        ...state.annotation.data.handles,
+        points: worldCoords
+      },
+      cachedStats,
+      frameNumber: ReferencedFrameNumber,
+      invalidated: true
     };
     return state;
   }
-  static getTID300RepresentationArguments(tool, worldToImageCoords) {
+  static getTID300RepresentationArguments(tool) {
+    let is3DMeasurement = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     const {
       data,
       metadata
@@ -6472,54 +5766,23 @@ class Probe extends BaseAdapter3D {
     const {
       referencedImageId
     } = metadata;
-    if (!referencedImageId) {
-      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
-    }
-    const {
-      handles: {
-        points = []
-      }
-    } = data;
-    const pointsImage = points.map(point => {
-      const pointImage = worldToImageCoords(referencedImageId, point);
-      return {
-        x: pointImage[0],
-        y: pointImage[1]
-      };
-    });
-    return {
-      points: pointsImage,
-      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
-      findingSites: findingSites || [],
-      finding,
-      use3DSpatialCoordinates: false
+    const scoordProps = {
+      is3DMeasurement,
+      referencedImageId
     };
-  }
-  static getTID300RepresentationArgumentsSCOORD3D(tool) {
-    const {
-      data,
-      finding,
-      findingSites,
-      metadata
-    } = tool;
     const {
       handles: {
         points = []
       }
     } = data;
-    const point = points[0];
-    const pointXYZ = {
-      x: point[0],
-      y: point[1],
-      z: point[2]
-    };
+    const pointsImage = toScoords(scoordProps, points);
     return {
-      points: [pointXYZ],
+      points: pointsImage,
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
-      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
       findingSites: findingSites || [],
       finding,
-      use3DSpatialCoordinates: true
+      ReferencedFrameOfReferenceUID: is3DMeasurement ? metadata.FrameOfReferenceUID : null,
+      use3DSpatialCoordinates: is3DMeasurement
     };
   }
 }
@@ -6527,6 +5790,8 @@ _Probe = Probe;
 (() => {
   _Probe.init("Probe", Probe_TID300Point);
   _Probe.registerLegacy();
+  _Probe.registerType("DCM:111030", "POINT", 1);
+  _Probe.registerType("DCM:111030", "POINT", 2);
 })();
 
 
@@ -6536,41 +5801,32 @@ _Probe = Probe;
 
 
 
+
 var _UltrasoundDirectional;
 const {
   Length: UltrasoundDirectional_TID300Length
 } = dcmjs_es/* utilities */.BF.TID300;
+const {
+  worldToImageCoords
+} = esm.utilities;
 class UltrasoundDirectional extends BaseAdapter3D {
-  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+  static getMeasurementData(measurementGroup, sopInstanceUIDToImageIdMap, metadata) {
     const {
-      defaultState,
-      SCOORDGroup,
+      state,
+      worldCoords,
       ReferencedFrameNumber
-    } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, UltrasoundDirectional.toolType);
-    const referencedImageId = defaultState.annotation.metadata.referencedImageId;
-    const {
-      GraphicData
-    } = SCOORDGroup;
-    const worldCoords = [];
-    for (let i = 0; i < GraphicData.length; i += 2) {
-      const point = imageToWorldCoords(referencedImageId, [GraphicData[i], GraphicData[i + 1]]);
-      worldCoords.push(point);
-    }
-    const state = defaultState;
+    } = MeasurementReport_MeasurementReport.getSetupMeasurementData(measurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType);
     state.annotation.data = {
+      ...state.annotation.data,
       handles: {
-        points: [worldCoords[0], worldCoords[1]],
-        activeHandleIndex: 0,
-        textBox: {
-          hasMoved: false
-        }
+        ...state.annotation.data.handles,
+        points: worldCoords
       },
-      cachedStats: {},
       frameNumber: ReferencedFrameNumber
     };
     return state;
   }
-  static getTID300RepresentationArguments(tool, worldToImageCoords) {
+  static getTID300RepresentationArguments(tool, is3DMeasurement) {
     const {
       data,
       finding,
@@ -7706,16 +6962,16 @@ const {
   Point: KeyImage_TID300Point
 } = dcmjs_es/* utilities */.BF.TID300;
 class KeyImage extends Probe {
-  static getMeasurementData(measurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata, trackingIdentifier) {
-    const baseData = super.getMeasurementData(measurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata, trackingIdentifier);
+  static getMeasurementData(measurementGroup, sopInstanceUIDToImageIdMap, metadata, trackingIdentifier) {
+    const baseData = super.getMeasurementData(measurementGroup, sopInstanceUIDToImageIdMap, metadata, trackingIdentifier);
     const {
       data
     } = baseData.annotation;
     data.isPoint = trackingIdentifier.indexOf("Point") !== -1;
     return baseData;
   }
-  static getTID300RepresentationArguments(tool, worldToImageCoords) {
-    const tid300Arguments = super.getTID300RepresentationArguments(tool, worldToImageCoords);
+  static getTID300RepresentationArguments(tool) {
+    const tid300Arguments = super.getTID300RepresentationArguments(tool);
     const {
       data
     } = tool;
@@ -7768,6 +7024,7 @@ _KeyImage.trackingSeriesPointIdentifier = `${_KeyImage.trackingIdentifierTextVal
 
 
 
+
 
 const Cornerstone3DSR = {
   BaseAdapter3D: BaseAdapter3D,
@@ -7785,7 +7042,10 @@ const Cornerstone3DSR = {
   KeyImage: KeyImage,
   MeasurementReport: MeasurementReport_MeasurementReport,
   CodeScheme: CodingScheme,
-  CORNERSTONE_3D_TAG: CORNERSTONE_3D_TAG
+  CORNERSTONE_3D_TAG: CORNERSTONE_3D_TAG,
+  COMMENT_CODE: COMMENT_CODE,
+  NO_IMAGE_ID: NO_IMAGE_ID,
+  TEXT_ANNOTATION_POSITION: TEXT_ANNOTATION_POSITION
 };
 const Cornerstone3DSEG = {
   Segmentation: Cornerstone3D_Segmentation_namespaceObject
@@ -7998,6 +7258,7 @@ const VTKjsSEG = {
 
 
 
+
 const adaptersSR = {
   Cornerstone: CornerstoneSR,
   Cornerstone3D: Cornerstone3DSR
@@ -8067,127 +7328,16 @@ function downloadDICOMData(bufferOrDataset, filename) {
 
 
 
-;// ../../../node_modules/@cornerstonejs/adapters/dist/esm/index.js
-
-
-
-
-
-
-
-
-/***/ }),
-
-/***/ 49892:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-"use strict";
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
-/* harmony export */ });
-var ToolModes;
-(function (ToolModes) {
-    ToolModes["Active"] = "Active";
-    ToolModes["Passive"] = "Passive";
-    ToolModes["Enabled"] = "Enabled";
-    ToolModes["Disabled"] = "Disabled";
-})(ToolModes || (ToolModes = {}));
-/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (ToolModes);
-
-
-/***/ }),
-
-/***/ 66452:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-"use strict";
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   i: () => (/* binding */ MouseBindings),
-/* harmony export */   q: () => (/* binding */ KeyboardBindings)
-/* harmony export */ });
-var MouseBindings;
-(function (MouseBindings) {
-    MouseBindings[MouseBindings["Primary"] = 1] = "Primary";
-    MouseBindings[MouseBindings["Secondary"] = 2] = "Secondary";
-    MouseBindings[MouseBindings["Primary_And_Secondary"] = 3] = "Primary_And_Secondary";
-    MouseBindings[MouseBindings["Auxiliary"] = 4] = "Auxiliary";
-    MouseBindings[MouseBindings["Primary_And_Auxiliary"] = 5] = "Primary_And_Auxiliary";
-    MouseBindings[MouseBindings["Secondary_And_Auxiliary"] = 6] = "Secondary_And_Auxiliary";
-    MouseBindings[MouseBindings["Primary_And_Secondary_And_Auxiliary"] = 7] = "Primary_And_Secondary_And_Auxiliary";
-    MouseBindings[MouseBindings["Fourth_Button"] = 8] = "Fourth_Button";
-    MouseBindings[MouseBindings["Fifth_Button"] = 16] = "Fifth_Button";
-    MouseBindings[MouseBindings["Wheel"] = 524288] = "Wheel";
-    MouseBindings[MouseBindings["Wheel_Primary"] = 524289] = "Wheel_Primary";
-})(MouseBindings || (MouseBindings = {}));
-var KeyboardBindings;
-(function (KeyboardBindings) {
-    KeyboardBindings[KeyboardBindings["Shift"] = 16] = "Shift";
-    KeyboardBindings[KeyboardBindings["Ctrl"] = 17] = "Ctrl";
-    KeyboardBindings[KeyboardBindings["Alt"] = 18] = "Alt";
-    KeyboardBindings[KeyboardBindings["Meta"] = 91] = "Meta";
-    KeyboardBindings[KeyboardBindings["ShiftCtrl"] = 1617] = "ShiftCtrl";
-    KeyboardBindings[KeyboardBindings["ShiftAlt"] = 1618] = "ShiftAlt";
-    KeyboardBindings[KeyboardBindings["ShiftMeta"] = 1691] = "ShiftMeta";
-    KeyboardBindings[KeyboardBindings["CtrlAlt"] = 1718] = "CtrlAlt";
-    KeyboardBindings[KeyboardBindings["CtrlMeta"] = 1791] = "CtrlMeta";
-    KeyboardBindings[KeyboardBindings["AltMeta"] = 1891] = "AltMeta";
-})(KeyboardBindings || (KeyboardBindings = {}));
 
 
 
-/***/ }),
+;// ../../../node_modules/@cornerstonejs/adapters/dist/esm/index.js
 
-/***/ 75183:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-"use strict";
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
-/* harmony export */ });
-var ChangeTypes;
-(function (ChangeTypes) {
-    ChangeTypes["Interaction"] = "Interaction";
-    ChangeTypes["HandlesUpdated"] = "HandlesUpdated";
-    ChangeTypes["StatsUpdated"] = "StatsUpdated";
-    ChangeTypes["InitialSetup"] = "InitialSetup";
-    ChangeTypes["Completed"] = "Completed";
-    ChangeTypes["InterpolationUpdated"] = "InterpolationUpdated";
-    ChangeTypes["History"] = "History";
-    ChangeTypes["MetadataReferenceModified"] = "MetadataReferenceModified";
-    ChangeTypes["LabelChange"] = "LabelChange";
-})(ChangeTypes || (ChangeTypes = {}));
-/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (ChangeTypes);
 
 
-/***/ }),
 
-/***/ 84093:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-"use strict";
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
-/* harmony export */ });
-var StrategyCallbacks;
-(function (StrategyCallbacks) {
-    StrategyCallbacks["OnInteractionStart"] = "onInteractionStart";
-    StrategyCallbacks["OnInteractionEnd"] = "onInteractionEnd";
-    StrategyCallbacks["Preview"] = "preview";
-    StrategyCallbacks["RejectPreview"] = "rejectPreview";
-    StrategyCallbacks["AcceptPreview"] = "acceptPreview";
-    StrategyCallbacks["Fill"] = "fill";
-    StrategyCallbacks["Interpolate"] = "interpolate";
-    StrategyCallbacks["StrategyFunction"] = "strategyFunction";
-    StrategyCallbacks["CreateIsInThreshold"] = "createIsInThreshold";
-    StrategyCallbacks["Initialize"] = "initialize";
-    StrategyCallbacks["INTERNAL_setValue"] = "setValue";
-    StrategyCallbacks["AddPreview"] = "addPreview";
-    StrategyCallbacks["ComputeInnerCircleRadius"] = "computeInnerCircleRadius";
-    StrategyCallbacks["GetStatistics"] = "getStatistics";
-    StrategyCallbacks["EnsureImageVolumeFor3DManipulation"] = "ensureImageVolumeFor3DManipulation";
-    StrategyCallbacks["EnsureSegmentationVolumeFor3DManipulation"] = "ensureSegmentationVolumeFor3DManipulation";
-})(StrategyCallbacks || (StrategyCallbacks = {}));
-/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (StrategyCallbacks);
 
 
 /***/ }),
@@ -8206,6 +7356,8 @@ var Events;
     Events["TOOLGROUP_VIEWPORT_REMOVED"] = "CORNERSTONE_TOOLS_TOOLGROUP_VIEWPORT_REMOVED";
     Events["TOOL_MODE_CHANGED"] = "CORNERSTONE_TOOLS_TOOL_MODE_CHANGED";
     Events["CROSSHAIR_TOOL_CENTER_CHANGED"] = "CORNERSTONE_TOOLS_CROSSHAIR_TOOL_CENTER_CHANGED";
+    Events["VOLUMECROPPINGCONTROL_TOOL_CHANGED"] = "CORNERSTONE_TOOLS_VOLUMECROPPINGCONTROL_TOOL_CHANGED";
+    Events["VOLUMECROPPING_TOOL_CHANGED"] = "CORNERSTONE_TOOLS_VOLUMECROPPING_TOOL_CHANGED";
     Events["ANNOTATION_ADDED"] = "CORNERSTONE_TOOLS_ANNOTATION_ADDED";
     Events["ANNOTATION_COMPLETED"] = "CORNERSTONE_TOOLS_ANNOTATION_COMPLETED";
     Events["ANNOTATION_MODIFIED"] = "CORNERSTONE_TOOLS_ANNOTATION_MODIFIED";