@cornerstonejs/adapters 2.0.0-beta.8 → 2.0.0

package/dist/esm/adapters/Cornerstone/cornerstone4Tag.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "cornerstoneTools@^4.0.0";
+export default _default;

package/dist/esm/adapters/Cornerstone/cornerstone4Tag.js

@@ -0,0 +1,3 @@
+var CORNERSTONE_4_TAG = "cornerstoneTools@^4.0.0";
+
+export { CORNERSTONE_4_TAG as default };

package/dist/esm/adapters/Cornerstone/index.d.ts

@@ -0,0 +1,34 @@
+import MeasurementReport from "./MeasurementReport";
+import Length from "./Length";
+import FreehandRoi from "./FreehandRoi";
+import Bidirectional from "./Bidirectional";
+import EllipticalRoi from "./EllipticalRoi";
+import CircleRoi from "./CircleRoi";
+import ArrowAnnotate from "./ArrowAnnotate";
+import CobbAngle from "./CobbAngle";
+import Angle from "./Angle";
+import RectangleRoi from "./RectangleRoi";
+import * as Segmentation from "./Segmentation";
+declare const CornerstoneSR: {
+    Length: typeof Length;
+    FreehandRoi: typeof FreehandRoi;
+    Bidirectional: typeof Bidirectional;
+    EllipticalRoi: typeof EllipticalRoi;
+    CircleRoi: typeof CircleRoi;
+    ArrowAnnotate: typeof ArrowAnnotate;
+    MeasurementReport: typeof MeasurementReport;
+    CobbAngle: typeof CobbAngle;
+    Angle: typeof Angle;
+    RectangleRoi: typeof RectangleRoi;
+};
+declare const CornerstoneSEG: {
+    Segmentation: typeof Segmentation;
+};
+declare const CornerstonePMAP: {
+    ParametricMap: {
+        generateToolState: (imageIds: any, arrayBuffer: any, metadataProvider: any, tolerance?: number) => Promise<{
+            pixelData: any;
+        }>;
+    };
+};
+export { CornerstoneSR, CornerstoneSEG, CornerstonePMAP };

package/dist/esm/adapters/Cornerstone/index.js

@@ -0,0 +1,33 @@
+import MeasurementReport from './MeasurementReport.js';
+import Length from './Length.js';
+import FreehandRoi from './FreehandRoi.js';
+import Bidirectional from './Bidirectional.js';
+import EllipticalRoi from './EllipticalRoi.js';
+import CircleRoi from './CircleRoi.js';
+import ArrowAnnotate from './ArrowAnnotate.js';
+import CobbAngle from './CobbAngle.js';
+import Angle from './Angle.js';
+import RectangleRoi from './RectangleRoi.js';
+import * as Segmentation from './Segmentation.js';
+import ParametricMapObj from './ParametricMap.js';
+
+var CornerstoneSR = {
+  Length: Length,
+  FreehandRoi: FreehandRoi,
+  Bidirectional: Bidirectional,
+  EllipticalRoi: EllipticalRoi,
+  CircleRoi: CircleRoi,
+  ArrowAnnotate: ArrowAnnotate,
+  MeasurementReport: MeasurementReport,
+  CobbAngle: CobbAngle,
+  Angle: Angle,
+  RectangleRoi: RectangleRoi
+};
+var CornerstoneSEG = {
+  Segmentation: Segmentation
+};
+var CornerstonePMAP = {
+  ParametricMap: ParametricMapObj
+};
+
+export { CornerstonePMAP, CornerstoneSEG, CornerstoneSR };

package/dist/esm/adapters/Cornerstone3D/Angle.js

@@ -0,0 +1,109 @@
+import { slicedToArray as _slicedToArray, createClass as _createClass, defineProperty as _defineProperty, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { utilities } from 'dcmjs';
+import CORNERSTONE_3D_TAG from './cornerstone3DTag.js';
+import MeasurementReport from './MeasurementReport.js';
+
+var _Angle;
+var TID300CobbAngle = utilities.TID300.CobbAngle;
+var MEASUREMENT_TYPE = "Angle";
+var trackingIdentifierTextValue = "".concat(CORNERSTONE_3D_TAG, ":").concat(MEASUREMENT_TYPE);
+var Angle = /*#__PURE__*/function () {
+  function Angle() {
+    _classCallCheck(this, Angle);
+  }
+  return _createClass(Angle, null, [{
+    key: "getMeasurementData",
+    value: function getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+      var _MeasurementReport$ge = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, Angle.toolType),
+        defaultState = _MeasurementReport$ge.defaultState,
+        NUMGroup = _MeasurementReport$ge.NUMGroup,
+        SCOORDGroup = _MeasurementReport$ge.SCOORDGroup,
+        ReferencedFrameNumber = _MeasurementReport$ge.ReferencedFrameNumber;
+      var referencedImageId = defaultState.annotation.metadata.referencedImageId;
+      var GraphicData = SCOORDGroup.GraphicData;
+      var worldCoords = [];
+      for (var i = 0; i < GraphicData.length; i += 2) {
+        var point = imageToWorldCoords(referencedImageId, [GraphicData[i], GraphicData[i + 1]]);
+        worldCoords.push(point);
+      }
+      var state = defaultState;
+      state.annotation.data = {
+        handles: {
+          points: [worldCoords[0], worldCoords[1], worldCoords[3]],
+          activeHandleIndex: 0,
+          textBox: {
+            hasMoved: false
+          }
+        },
+        cachedStats: _defineProperty({}, "imageId:".concat(referencedImageId), {
+          angle: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : null
+        }),
+        frameNumber: ReferencedFrameNumber
+      };
+      return state;
+    }
+  }, {
+    key: "getTID300RepresentationArguments",
+    value: function getTID300RepresentationArguments(tool, worldToImageCoords) {
+      var data = tool.data,
+        finding = tool.finding,
+        findingSites = tool.findingSites,
+        metadata = tool.metadata;
+      var _data$cachedStats = data.cachedStats,
+        cachedStats = _data$cachedStats === void 0 ? {} : _data$cachedStats,
+        handles = data.handles;
+      var referencedImageId = metadata.referencedImageId;
+      if (!referencedImageId) {
+        throw new Error("Angle.getTID300RepresentationArguments: referencedImageId is not defined");
+      }
+      var start1 = worldToImageCoords(referencedImageId, handles.points[0]);
+      var middle = worldToImageCoords(referencedImageId, handles.points[1]);
+      var end = worldToImageCoords(referencedImageId, handles.points[2]);
+      var point1 = {
+        x: start1[0],
+        y: start1[1]
+      };
+      var point2 = {
+        x: middle[0],
+        y: middle[1]
+      };
+      var point3 = point2;
+      var point4 = {
+        x: end[0],
+        y: end[1]
+      };
+      var _ref = cachedStats["imageId:".concat(referencedImageId)] || {},
+        angle = _ref.angle;
+      return {
+        point1: point1,
+        point2: point2,
+        point3: point3,
+        point4: point4,
+        rAngle: angle,
+        trackingIdentifierTextValue: trackingIdentifierTextValue,
+        finding: finding,
+        findingSites: findingSites || []
+      };
+    }
+  }]);
+}();
+_Angle = Angle;
+_Angle.toolType = MEASUREMENT_TYPE;
+_Angle.utilityToolType = MEASUREMENT_TYPE;
+_Angle.TID300Representation = TID300CobbAngle;
+_Angle.isValidCornerstoneTrackingIdentifier = function (TrackingIdentifier) {
+  if (!TrackingIdentifier.includes(":")) {
+    return false;
+  }
+  var _TrackingIdentifier$s = TrackingIdentifier.split(":"),
+    _TrackingIdentifier$s2 = _slicedToArray(_TrackingIdentifier$s, 2),
+    cornerstone3DTag = _TrackingIdentifier$s2[0],
+    toolType = _TrackingIdentifier$s2[1];
+  if (cornerstone3DTag !== CORNERSTONE_3D_TAG) {
+    return false;
+  }
+  return toolType === MEASUREMENT_TYPE;
+};
+MeasurementReport.registerTool(Angle);
+
+export { Angle as default };

package/dist/esm/adapters/Cornerstone3D/ArrowAnnotate.d.ts

@@ -0,0 +1,35 @@
+export default ArrowAnnotate;
+declare class ArrowAnnotate {
+    static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any): {
+        description: any;
+        sopInstanceUid: any;
+        annotation: {
+            annotationUID: any;
+            metadata: {
+                toolName: any;
+                referencedImageId: any;
+                FrameOfReferenceUID: any;
+                label: string;
+            };
+            data: any;
+        };
+        finding: any;
+        findingSites: any[];
+    };
+    static getTID300RepresentationArguments(tool: any, worldToImageCoords: any): {
+        points: {
+            x: any;
+            y: any;
+        }[];
+        trackingIdentifierTextValue: string;
+        findingSites: any;
+    };
+}
+declare namespace ArrowAnnotate {
+    export { ARROW_ANNOTATE as toolType };
+    export { ARROW_ANNOTATE as utilityToolType };
+    export { TID300Point as TID300Representation };
+    export function isValidCornerstoneTrackingIdentifier(TrackingIdentifier: any): boolean;
+}
+declare const ARROW_ANNOTATE: "ArrowAnnotate";
+declare const TID300Point: any;

package/dist/esm/adapters/Cornerstone3D/ArrowAnnotate.js

@@ -0,0 +1,123 @@
+import { slicedToArray as _slicedToArray, createClass as _createClass, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import MeasurementReport from './MeasurementReport.js';
+import { utilities } from 'dcmjs';
+import CORNERSTONE_3D_TAG from './cornerstone3DTag.js';
+import CodingScheme from './CodingScheme.js';
+
+var TID300Point = utilities.TID300.Point;
+var ARROW_ANNOTATE = "ArrowAnnotate";
+var trackingIdentifierTextValue = "".concat(CORNERSTONE_3D_TAG, ":").concat(ARROW_ANNOTATE);
+var codeValues = CodingScheme.codeValues,
+  CodingSchemeDesignator = CodingScheme.CodingSchemeDesignator;
+var ArrowAnnotate = /*#__PURE__*/function () {
+  function ArrowAnnotate() {
+    _classCallCheck(this, ArrowAnnotate);
+  }
+  return _createClass(ArrowAnnotate, null, [{
+    key: "getMeasurementData",
+    value: function getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+      var _MeasurementReport$ge = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, ArrowAnnotate.toolType),
+        defaultState = _MeasurementReport$ge.defaultState,
+        SCOORDGroup = _MeasurementReport$ge.SCOORDGroup,
+        ReferencedFrameNumber = _MeasurementReport$ge.ReferencedFrameNumber;
+      var referencedImageId = defaultState.annotation.metadata.referencedImageId;
+      var text = defaultState.annotation.metadata.label;
+      var GraphicData = SCOORDGroup.GraphicData;
+      var worldCoords = [];
+      for (var i = 0; i < GraphicData.length; i += 2) {
+        var point = imageToWorldCoords(referencedImageId, [GraphicData[i], GraphicData[i + 1]]);
+        worldCoords.push(point);
+      }
+
+      // Since the arrowAnnotate measurement is just a point, to generate the tool state
+      // we derive the second point based on the image size relative to the first point.
+      if (worldCoords.length === 1) {
+        var imagePixelModule = metadata.get("imagePixelModule", referencedImageId);
+        var xOffset = 10;
+        var yOffset = 10;
+        if (imagePixelModule) {
+          var columns = imagePixelModule.columns,
+            rows = imagePixelModule.rows;
+          xOffset = columns / 10;
+          yOffset = rows / 10;
+        }
+        var secondPoint = imageToWorldCoords(referencedImageId, [GraphicData[0] + xOffset, GraphicData[1] + yOffset]);
+        worldCoords.push(secondPoint);
+      }
+      var state = defaultState;
+      state.annotation.data = {
+        text: text,
+        handles: {
+          arrowFirst: true,
+          points: [worldCoords[0], worldCoords[1]],
+          activeHandleIndex: 0,
+          textBox: {
+            hasMoved: false
+          }
+        },
+        frameNumber: ReferencedFrameNumber
+      };
+      return state;
+    }
+  }, {
+    key: "getTID300RepresentationArguments",
+    value: function getTID300RepresentationArguments(tool, worldToImageCoords) {
+      var data = tool.data,
+        metadata = tool.metadata;
+      var finding = tool.finding,
+        findingSites = tool.findingSites;
+      var referencedImageId = metadata.referencedImageId;
+      if (!referencedImageId) {
+        throw new Error("ArrowAnnotate.getTID300RepresentationArguments: referencedImageId is not defined");
+      }
+      var _data$handles = data.handles,
+        points = _data$handles.points,
+        arrowFirst = _data$handles.arrowFirst;
+      var point;
+      if (arrowFirst) {
+        point = points[0];
+      } else {
+        point = points[1];
+      }
+      var pointImage = worldToImageCoords(referencedImageId, point);
+      var TID300RepresentationArguments = {
+        points: [{
+          x: pointImage[0],
+          y: pointImage[1]
+        }],
+        trackingIdentifierTextValue: trackingIdentifierTextValue,
+        findingSites: findingSites || []
+      };
+
+      // If freetext finding isn't present, add it from the tool text.
+      if (!finding || finding.CodeValue !== codeValues.CORNERSTONEFREETEXT) {
+        finding = {
+          CodeValue: codeValues.CORNERSTONEFREETEXT,
+          CodingSchemeDesignator: CodingSchemeDesignator,
+          CodeMeaning: data.text
+        };
+      }
+      TID300RepresentationArguments.finding = finding;
+      return TID300RepresentationArguments;
+    }
+  }]);
+}();
+ArrowAnnotate.toolType = ARROW_ANNOTATE;
+ArrowAnnotate.utilityToolType = ARROW_ANNOTATE;
+ArrowAnnotate.TID300Representation = TID300Point;
+ArrowAnnotate.isValidCornerstoneTrackingIdentifier = function (TrackingIdentifier) {
+  if (!TrackingIdentifier.includes(":")) {
+    return false;
+  }
+  var _TrackingIdentifier$s = TrackingIdentifier.split(":"),
+    _TrackingIdentifier$s2 = _slicedToArray(_TrackingIdentifier$s, 2),
+    cornerstone3DTag = _TrackingIdentifier$s2[0],
+    toolType = _TrackingIdentifier$s2[1];
+  if (cornerstone3DTag !== CORNERSTONE_3D_TAG) {
+    return false;
+  }
+  return toolType === ARROW_ANNOTATE;
+};
+MeasurementReport.registerTool(ArrowAnnotate);
+
+export { ArrowAnnotate as default };

package/dist/esm/adapters/Cornerstone3D/Bidirectional.js

@@ -0,0 +1,147 @@
+import { slicedToArray as _slicedToArray, createClass as _createClass, defineProperty as _defineProperty, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { utilities } from 'dcmjs';
+import CORNERSTONE_3D_TAG from './cornerstone3DTag.js';
+import MeasurementReport from './MeasurementReport.js';
+import { toArray } from '../helpers/toArray.js';
+import '../helpers/downloadDICOMData.js';
+
+var _Bidirectional;
+var TID300Bidirectional = utilities.TID300.Bidirectional;
+var BIDIRECTIONAL = "Bidirectional";
+var LONG_AXIS = "Long Axis";
+var SHORT_AXIS = "Short Axis";
+var trackingIdentifierTextValue = "".concat(CORNERSTONE_3D_TAG, ":").concat(BIDIRECTIONAL);
+var Bidirectional = /*#__PURE__*/function () {
+  function Bidirectional() {
+    _classCallCheck(this, Bidirectional);
+  }
+  return _createClass(Bidirectional, null, [{
+    key: "getMeasurementData",
+    value: function getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+      var _MeasurementReport$ge = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, Bidirectional.toolType),
+        defaultState = _MeasurementReport$ge.defaultState,
+        ReferencedFrameNumber = _MeasurementReport$ge.ReferencedFrameNumber;
+      var referencedImageId = defaultState.annotation.metadata.referencedImageId;
+      var ContentSequence = MeasurementGroup.ContentSequence;
+      var longAxisNUMGroup = toArray(ContentSequence).find(function (group) {
+        return group.ConceptNameCodeSequence.CodeMeaning === LONG_AXIS;
+      });
+      var longAxisSCOORDGroup = toArray(longAxisNUMGroup.ContentSequence).find(function (group) {
+        return group.ValueType === "SCOORD";
+      });
+      var shortAxisNUMGroup = toArray(ContentSequence).find(function (group) {
+        return group.ConceptNameCodeSequence.CodeMeaning === SHORT_AXIS;
+      });
+      var shortAxisSCOORDGroup = toArray(shortAxisNUMGroup.ContentSequence).find(function (group) {
+        return group.ValueType === "SCOORD";
+      });
+      var worldCoords = [];
+      [longAxisSCOORDGroup, shortAxisSCOORDGroup].forEach(function (group) {
+        var GraphicData = group.GraphicData;
+        for (var i = 0; i < GraphicData.length; i += 2) {
+          var point = imageToWorldCoords(referencedImageId, [GraphicData[i], GraphicData[i + 1]]);
+          worldCoords.push(point);
+        }
+      });
+      var state = defaultState;
+      state.annotation.data = {
+        handles: {
+          points: [worldCoords[0], worldCoords[1], worldCoords[2], worldCoords[3]],
+          activeHandleIndex: 0,
+          textBox: {
+            hasMoved: false
+          }
+        },
+        cachedStats: _defineProperty({}, "imageId:".concat(referencedImageId), {
+          length: longAxisNUMGroup.MeasuredValueSequence.NumericValue,
+          width: shortAxisNUMGroup.MeasuredValueSequence.NumericValue
+        }),
+        frameNumber: ReferencedFrameNumber
+      };
+      return state;
+    }
+  }, {
+    key: "getTID300RepresentationArguments",
+    value: function getTID300RepresentationArguments(tool, worldToImageCoords) {
+      var data = tool.data,
+        finding = tool.finding,
+        findingSites = tool.findingSites,
+        metadata = tool.metadata;
+      var _data$cachedStats = data.cachedStats,
+        cachedStats = _data$cachedStats === void 0 ? {} : _data$cachedStats,
+        handles = data.handles;
+      var referencedImageId = metadata.referencedImageId;
+      if (!referencedImageId) {
+        throw new Error("Bidirectional.getTID300RepresentationArguments: referencedImageId is not defined");
+      }
+      var _ref = cachedStats["imageId:".concat(referencedImageId)] || {},
+        length = _ref.length,
+        width = _ref.width;
+      var points = handles.points;
+      var firstPointPairs = [points[0], points[1]];
+      var secondPointPairs = [points[2], points[3]];
+      var firstPointPairsDistance = Math.sqrt(Math.pow(firstPointPairs[0][0] - firstPointPairs[1][0], 2) + Math.pow(firstPointPairs[0][1] - firstPointPairs[1][1], 2) + Math.pow(firstPointPairs[0][2] - firstPointPairs[1][2], 2));
+      var secondPointPairsDistance = Math.sqrt(Math.pow(secondPointPairs[0][0] - secondPointPairs[1][0], 2) + Math.pow(secondPointPairs[0][1] - secondPointPairs[1][1], 2) + Math.pow(secondPointPairs[0][2] - secondPointPairs[1][2], 2));
+      var shortAxisPoints;
+      var longAxisPoints;
+      if (firstPointPairsDistance > secondPointPairsDistance) {
+        shortAxisPoints = firstPointPairs;
+        longAxisPoints = secondPointPairs;
+      } else {
+        shortAxisPoints = secondPointPairs;
+        longAxisPoints = firstPointPairs;
+      }
+      var longAxisStartImage = worldToImageCoords(referencedImageId, shortAxisPoints[0]);
+      var longAxisEndImage = worldToImageCoords(referencedImageId, shortAxisPoints[1]);
+      var shortAxisStartImage = worldToImageCoords(referencedImageId, longAxisPoints[0]);
+      var shortAxisEndImage = worldToImageCoords(referencedImageId, longAxisPoints[1]);
+      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: trackingIdentifierTextValue,
+        finding: finding,
+        findingSites: findingSites || []
+      };
+    }
+  }]);
+}();
+_Bidirectional = Bidirectional;
+_Bidirectional.toolType = BIDIRECTIONAL;
+_Bidirectional.utilityToolType = BIDIRECTIONAL;
+_Bidirectional.TID300Representation = TID300Bidirectional;
+_Bidirectional.isValidCornerstoneTrackingIdentifier = function (TrackingIdentifier) {
+  if (!TrackingIdentifier.includes(":")) {
+    return false;
+  }
+  var _TrackingIdentifier$s = TrackingIdentifier.split(":"),
+    _TrackingIdentifier$s2 = _slicedToArray(_TrackingIdentifier$s, 2),
+    cornerstone3DTag = _TrackingIdentifier$s2[0],
+    toolType = _TrackingIdentifier$s2[1];
+  if (cornerstone3DTag !== CORNERSTONE_3D_TAG) {
+    return false;
+  }
+  return toolType === BIDIRECTIONAL;
+};
+MeasurementReport.registerTool(Bidirectional);
+
+export { Bidirectional as default };

package/dist/{types → esm}/adapters/Cornerstone3D/CircleROI.d.ts

@@ -5,7 +5,6 @@ declare class CircleROI {
     static utilityToolType: string;
     static TID300Representation: any;
     static isValidCornerstoneTrackingIdentifier: typeof isValidCornerstoneTrackingIdentifier;
-    /** Gets the measurement data for cornerstone, given DICOM SR measurement data. */
     static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any): {
         description: any;
         sopInstanceUid: any;
@@ -22,12 +21,6 @@ declare class CircleROI {
         finding: any;
         findingSites: any[];
     };
-    /**
-     * Gets the TID 300 representation of a circle, given the cornerstone representation.
-     *
-     * @param {Object} tool
-     * @returns
-     */
     static getTID300RepresentationArguments(tool: any, worldToImageCoords: any): {
         area: any;
         perimeter: number;

package/dist/esm/adapters/Cornerstone3D/CircleROI.js

@@ -0,0 +1,96 @@
+import { createClass as _createClass, defineProperty as _defineProperty, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { utilities } from 'dcmjs';
+import MeasurementReport from './MeasurementReport.js';
+import CORNERSTONE_3D_TAG from './cornerstone3DTag.js';
+import isValidCornerstoneTrackingIdentifier from './isValidCornerstoneTrackingIdentifier.js';
+
+var _CircleROI;
+var TID300Circle = utilities.TID300.Circle;
+var CIRCLEROI = "CircleROI";
+var CircleROI = /*#__PURE__*/function () {
+  function CircleROI() {
+    _classCallCheck(this, CircleROI);
+  }
+  return _createClass(CircleROI, null, [{
+    key: "getMeasurementData",
+    value: function getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+      var _MeasurementReport$ge = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, CircleROI.toolType),
+        defaultState = _MeasurementReport$ge.defaultState,
+        NUMGroup = _MeasurementReport$ge.NUMGroup,
+        SCOORDGroup = _MeasurementReport$ge.SCOORDGroup,
+        ReferencedFrameNumber = _MeasurementReport$ge.ReferencedFrameNumber;
+      var referencedImageId = defaultState.annotation.metadata.referencedImageId;
+      var GraphicData = SCOORDGroup.GraphicData;
+      var pointsWorld = [];
+      for (var i = 0; i < GraphicData.length; i += 2) {
+        var worldPos = imageToWorldCoords(referencedImageId, [GraphicData[i], GraphicData[i + 1]]);
+        pointsWorld.push(worldPos);
+      }
+      var state = defaultState;
+      state.annotation.data = {
+        handles: {
+          points: [].concat(pointsWorld),
+          activeHandleIndex: 0,
+          textBox: {
+            hasMoved: false
+          }
+        },
+        cachedStats: _defineProperty({}, "imageId:".concat(referencedImageId), {
+          area: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : 0,
+          radius: 0,
+          perimeter: 0
+        }),
+        frameNumber: ReferencedFrameNumber
+      };
+      return state;
+    }
+  }, {
+    key: "getTID300RepresentationArguments",
+    value: function getTID300RepresentationArguments(tool, worldToImageCoords) {
+      var data = tool.data,
+        finding = tool.finding,
+        findingSites = tool.findingSites,
+        metadata = tool.metadata;
+      var _data$cachedStats = data.cachedStats,
+        cachedStats = _data$cachedStats === void 0 ? {} : _data$cachedStats,
+        handles = data.handles;
+      var referencedImageId = metadata.referencedImageId;
+      if (!referencedImageId) {
+        throw new Error("CircleROI.getTID300RepresentationArguments: referencedImageId is not defined");
+      }
+      var center = worldToImageCoords(referencedImageId, handles.points[0]);
+      var end = worldToImageCoords(referencedImageId, handles.points[1]);
+      var points = [];
+      points.push({
+        x: center[0],
+        y: center[1]
+      });
+      points.push({
+        x: end[0],
+        y: end[1]
+      });
+      var _ref = cachedStats["imageId:".concat(referencedImageId)] || {},
+        area = _ref.area,
+        radius = _ref.radius;
+      var perimeter = 2 * Math.PI * radius;
+      return {
+        area: area,
+        perimeter: perimeter,
+        radius: radius,
+        points: points,
+        trackingIdentifierTextValue: this.trackingIdentifierTextValue,
+        finding: finding,
+        findingSites: findingSites || []
+      };
+    }
+  }]);
+}();
+_CircleROI = CircleROI;
+_CircleROI.trackingIdentifierTextValue = "".concat(CORNERSTONE_3D_TAG, ":").concat(CIRCLEROI);
+_CircleROI.toolType = CIRCLEROI;
+_CircleROI.utilityToolType = CIRCLEROI;
+_CircleROI.TID300Representation = TID300Circle;
+_CircleROI.isValidCornerstoneTrackingIdentifier = isValidCornerstoneTrackingIdentifier;
+MeasurementReport.registerTool(CircleROI);
+
+export { CircleROI as default };