@cornerstonejs/adapters 2.0.0-beta.7 → 2.0.0

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

@@ -0,0 +1,97 @@
+import { slicedToArray as _slicedToArray, createClass as _createClass, objectSpread2 as _objectSpread2, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { utilities } from 'dcmjs';
+import MeasurementReport from './MeasurementReport.js';
+import CORNERSTONE_4_TAG from './cornerstone4Tag.js';
+
+var TID300Point = utilities.TID300.Point;
+var ARROW_ANNOTATE = "ArrowAnnotate";
+var CORNERSTONEFREETEXT = "CORNERSTONEFREETEXT";
+var ArrowAnnotate = /*#__PURE__*/function () {
+  function ArrowAnnotate() {
+    _classCallCheck(this, ArrowAnnotate);
+  }
+  return _createClass(ArrowAnnotate, null, [{
+    key: "getMeasurementData",
+    value: function getMeasurementData(MeasurementGroup) {
+      var _MeasurementReport$ge = MeasurementReport.getSetupMeasurementData(MeasurementGroup),
+        defaultState = _MeasurementReport$ge.defaultState,
+        SCOORDGroup = _MeasurementReport$ge.SCOORDGroup,
+        findingGroup = _MeasurementReport$ge.findingGroup;
+      var text = findingGroup.ConceptCodeSequence.CodeMeaning;
+      var GraphicData = SCOORDGroup.GraphicData;
+      var state = _objectSpread2(_objectSpread2({}, defaultState), {}, {
+        toolType: ArrowAnnotate.toolType,
+        active: false,
+        handles: {
+          start: {
+            x: GraphicData[0],
+            y: GraphicData[1],
+            highlight: true,
+            active: false
+          },
+          // Use a generic offset if the stored data doesn't have the endpoint, otherwise
+          // use the actual endpoint.
+          end: {
+            x: GraphicData.length == 4 ? GraphicData[2] : GraphicData[0] + 20,
+            y: GraphicData.length == 4 ? GraphicData[3] : GraphicData[1] + 20,
+            highlight: true,
+            active: false
+          },
+          textBox: {
+            hasMoved: false,
+            movesIndependently: false,
+            drawnIndependently: true,
+            allowedOutsideImage: true,
+            hasBoundingBox: true
+          }
+        },
+        invalidated: true,
+        text: text,
+        visible: true
+      });
+      return state;
+    }
+  }, {
+    key: "getTID300RepresentationArguments",
+    value: function getTID300RepresentationArguments(tool) {
+      var points = [tool.handles.start, tool.handles.end];
+      var finding = tool.finding,
+        findingSites = tool.findingSites;
+      var TID300RepresentationArguments = {
+        points: points,
+        trackingIdentifierTextValue: "cornerstoneTools@^4.0.0:ArrowAnnotate",
+        findingSites: findingSites || []
+      };
+
+      // If freetext finding isn't present, add it from the tool text.
+      if (!finding || finding.CodeValue !== CORNERSTONEFREETEXT) {
+        finding = {
+          CodeValue: CORNERSTONEFREETEXT,
+          CodingSchemeDesignator: "CST4",
+          CodeMeaning: tool.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),
+    cornerstone4Tag = _TrackingIdentifier$s2[0],
+    toolType = _TrackingIdentifier$s2[1];
+  if (cornerstone4Tag !== CORNERSTONE_4_TAG) {
+    return false;
+  }
+  return toolType === ARROW_ANNOTATE;
+};
+MeasurementReport.registerTool(ArrowAnnotate);
+
+export { ArrowAnnotate as default };

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

@@ -0,0 +1,89 @@
+export default Bidirectional;
+declare class Bidirectional {
+    static getMeasurementData(MeasurementGroup: any): {
+        sopInstanceUid: any;
+        frameIndex: any;
+        toolType: string;
+        active: boolean;
+        handles: {
+            start: {
+                x: any;
+                y: any;
+                drawnIndependently: boolean;
+                allowedOutsideImage: boolean;
+                active: boolean;
+                highlight: boolean;
+                index: number;
+            };
+            end: {
+                x: any;
+                y: any;
+                drawnIndependently: boolean;
+                allowedOutsideImage: boolean;
+                active: boolean;
+                highlight: boolean;
+                index: number;
+            };
+            perpendicularStart: {
+                x: any;
+                y: any;
+                drawnIndependently: boolean;
+                allowedOutsideImage: boolean;
+                active: boolean;
+                highlight: boolean;
+                index: number;
+            };
+            perpendicularEnd: {
+                x: any;
+                y: any;
+                drawnIndependently: boolean;
+                allowedOutsideImage: boolean;
+                active: boolean;
+                highlight: boolean;
+                index: number;
+            };
+            textBox: {
+                highlight: boolean;
+                hasMoved: boolean;
+                active: boolean;
+                movesIndependently: boolean;
+                drawnIndependently: boolean;
+                allowedOutsideImage: boolean;
+                hasBoundingBox: boolean;
+                x: number;
+                y: number;
+            };
+        };
+        invalidated: boolean;
+        isCreating: boolean;
+        longestDiameter: string;
+        shortestDiameter: string;
+        toolName: string;
+        visible: boolean;
+        finding: any;
+        findingSites: any[];
+    };
+    static getTID300RepresentationArguments(tool: any): {
+        longAxis: {
+            point1: any;
+            point2: any;
+        };
+        shortAxis: {
+            point1: any;
+            point2: any;
+        };
+        longAxisLength: any;
+        shortAxisLength: any;
+        trackingIdentifierTextValue: string;
+        finding: any;
+        findingSites: any;
+    };
+}
+declare namespace Bidirectional {
+    export { BIDIRECTIONAL as toolType };
+    export { BIDIRECTIONAL as utilityToolType };
+    export { TID300Bidirectional as TID300Representation };
+    export function isValidCornerstoneTrackingIdentifier(TrackingIdentifier: any): boolean;
+}
+declare const BIDIRECTIONAL: "Bidirectional";
+declare const TID300Bidirectional: any;

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

@@ -0,0 +1,170 @@
+import { slicedToArray as _slicedToArray, createClass as _createClass, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { utilities } from 'dcmjs';
+import MeasurementReport from './MeasurementReport.js';
+import CORNERSTONE_4_TAG from './cornerstone4Tag.js';
+import { toArray } from '../helpers/toArray.js';
+import '../helpers/downloadDICOMData.js';
+
+var TID300Bidirectional = utilities.TID300.Bidirectional;
+var BIDIRECTIONAL = "Bidirectional";
+var LONG_AXIS = "Long Axis";
+var SHORT_AXIS = "Short Axis";
+var FINDING = "121071";
+var FINDING_SITE = "G-C0E3";
+var Bidirectional = /*#__PURE__*/function () {
+  function Bidirectional() {
+    _classCallCheck(this, Bidirectional);
+  }
+  return _createClass(Bidirectional, null, [{
+    key: "getMeasurementData",
+    value:
+    // TODO: this function is required for all Cornerstone Tool Adapters, since it is called by MeasurementReport.
+    function getMeasurementData(MeasurementGroup) {
+      var ContentSequence = MeasurementGroup.ContentSequence;
+      var findingGroup = toArray(ContentSequence).find(function (group) {
+        return group.ConceptNameCodeSequence.CodeValue === FINDING;
+      });
+      var findingSiteGroups = toArray(ContentSequence).filter(function (group) {
+        return group.ConceptNameCodeSequence.CodeValue === FINDING_SITE;
+      });
+      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 ReferencedSOPSequence = longAxisSCOORDGroup.ContentSequence.ReferencedSOPSequence;
+      var ReferencedSOPInstanceUID = ReferencedSOPSequence.ReferencedSOPInstanceUID,
+        ReferencedFrameNumber = ReferencedSOPSequence.ReferencedFrameNumber;
+
+      // Long axis
+
+      var longestDiameter = String(longAxisNUMGroup.MeasuredValueSequence.NumericValue);
+      var shortestDiameter = String(shortAxisNUMGroup.MeasuredValueSequence.NumericValue);
+      var bottomRight = {
+        x: Math.max(longAxisSCOORDGroup.GraphicData[0], longAxisSCOORDGroup.GraphicData[2], shortAxisSCOORDGroup.GraphicData[0], shortAxisSCOORDGroup.GraphicData[2]),
+        y: Math.max(longAxisSCOORDGroup.GraphicData[1], longAxisSCOORDGroup.GraphicData[3], shortAxisSCOORDGroup.GraphicData[1], shortAxisSCOORDGroup.GraphicData[3])
+      };
+      var state = {
+        sopInstanceUid: ReferencedSOPInstanceUID,
+        frameIndex: ReferencedFrameNumber || 1,
+        toolType: Bidirectional.toolType,
+        active: false,
+        handles: {
+          start: {
+            x: longAxisSCOORDGroup.GraphicData[0],
+            y: longAxisSCOORDGroup.GraphicData[1],
+            drawnIndependently: false,
+            allowedOutsideImage: false,
+            active: false,
+            highlight: false,
+            index: 0
+          },
+          end: {
+            x: longAxisSCOORDGroup.GraphicData[2],
+            y: longAxisSCOORDGroup.GraphicData[3],
+            drawnIndependently: false,
+            allowedOutsideImage: false,
+            active: false,
+            highlight: false,
+            index: 1
+          },
+          perpendicularStart: {
+            x: shortAxisSCOORDGroup.GraphicData[0],
+            y: shortAxisSCOORDGroup.GraphicData[1],
+            drawnIndependently: false,
+            allowedOutsideImage: false,
+            active: false,
+            highlight: false,
+            index: 2
+          },
+          perpendicularEnd: {
+            x: shortAxisSCOORDGroup.GraphicData[2],
+            y: shortAxisSCOORDGroup.GraphicData[3],
+            drawnIndependently: false,
+            allowedOutsideImage: false,
+            active: false,
+            highlight: false,
+            index: 3
+          },
+          textBox: {
+            highlight: false,
+            hasMoved: true,
+            active: false,
+            movesIndependently: false,
+            drawnIndependently: true,
+            allowedOutsideImage: true,
+            hasBoundingBox: true,
+            x: bottomRight.x + 10,
+            y: bottomRight.y + 10
+          }
+        },
+        invalidated: false,
+        isCreating: false,
+        longestDiameter: longestDiameter,
+        shortestDiameter: shortestDiameter,
+        toolName: "Bidirectional",
+        visible: true,
+        finding: findingGroup ? findingGroup.ConceptCodeSequence : undefined,
+        findingSites: findingSiteGroups.map(function (fsg) {
+          return fsg.ConceptCodeSequence;
+        })
+      };
+      return state;
+    }
+  }, {
+    key: "getTID300RepresentationArguments",
+    value: function getTID300RepresentationArguments(tool) {
+      var _tool$handles = tool.handles,
+        start = _tool$handles.start,
+        end = _tool$handles.end,
+        perpendicularStart = _tool$handles.perpendicularStart,
+        perpendicularEnd = _tool$handles.perpendicularEnd;
+      var shortestDiameter = tool.shortestDiameter,
+        longestDiameter = tool.longestDiameter,
+        finding = tool.finding,
+        findingSites = tool.findingSites;
+      var trackingIdentifierTextValue = "cornerstoneTools@^4.0.0:Bidirectional";
+      return {
+        longAxis: {
+          point1: start,
+          point2: end
+        },
+        shortAxis: {
+          point1: perpendicularStart,
+          point2: perpendicularEnd
+        },
+        longAxisLength: longestDiameter,
+        shortAxisLength: shortestDiameter,
+        trackingIdentifierTextValue: trackingIdentifierTextValue,
+        finding: finding,
+        findingSites: findingSites || []
+      };
+    }
+  }]);
+}();
+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),
+    cornerstone4Tag = _TrackingIdentifier$s2[0],
+    toolType = _TrackingIdentifier$s2[1];
+  if (cornerstone4Tag !== CORNERSTONE_4_TAG) {
+    return false;
+  }
+  return toolType === BIDIRECTIONAL;
+};
+MeasurementReport.registerTool(Bidirectional);
+
+export { Bidirectional as default };

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

@@ -0,0 +1,58 @@
+export default CircleRoi;
+declare class CircleRoi {
+    static getMeasurementData(MeasurementGroup: any): {
+        toolType: string;
+        active: boolean;
+        cachedStats: {
+            area: any;
+            radius: number;
+            perimeter: number;
+        };
+        handles: {
+            end: {
+                highlight: boolean;
+                active: boolean;
+                x: any;
+                y: any;
+            };
+            initialRotation: number;
+            start: {
+                highlight: boolean;
+                active: boolean;
+                x: any;
+                y: any;
+            };
+            textBox: {
+                hasMoved: boolean;
+                movesIndependently: boolean;
+                drawnIndependently: boolean;
+                allowedOutsideImage: boolean;
+                hasBoundingBox: boolean;
+            };
+        };
+        invalidated: boolean;
+        visible: boolean;
+        sopInstanceUid: any;
+        frameIndex: any;
+        complete: boolean;
+        finding: any;
+        findingSites: any[];
+    };
+    static getTID300RepresentationArguments(tool: any): {
+        area: any;
+        perimeter: number;
+        radius: any;
+        points: any[];
+        trackingIdentifierTextValue: string;
+        finding: any;
+        findingSites: any;
+    };
+}
+declare namespace CircleRoi {
+    export { CIRCLEROI as toolType };
+    export { CIRCLEROI as utilityToolType };
+    export { TID300Circle as TID300Representation };
+    export function isValidCornerstoneTrackingIdentifier(TrackingIdentifier: any): boolean;
+}
+declare const CIRCLEROI: "CircleRoi";
+declare const TID300Circle: any;

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

@@ -0,0 +1,115 @@
+import { slicedToArray as _slicedToArray, createClass as _createClass, objectSpread2 as _objectSpread2, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { utilities } from 'dcmjs';
+import MeasurementReport from './MeasurementReport.js';
+import CORNERSTONE_4_TAG from './cornerstone4Tag.js';
+
+var TID300Circle = utilities.TID300.Circle;
+var CIRCLEROI = "CircleRoi";
+var CircleRoi = /*#__PURE__*/function () {
+  function CircleRoi() {
+    _classCallCheck(this, CircleRoi);
+  }
+  return _createClass(CircleRoi, null, [{
+    key: "getMeasurementData",
+    value: /** Gets the measurement data for cornerstone, given DICOM SR measurement data. */
+    function getMeasurementData(MeasurementGroup) {
+      var _MeasurementReport$ge = MeasurementReport.getSetupMeasurementData(MeasurementGroup),
+        defaultState = _MeasurementReport$ge.defaultState,
+        NUMGroup = _MeasurementReport$ge.NUMGroup,
+        SCOORDGroup = _MeasurementReport$ge.SCOORDGroup;
+      var GraphicData = SCOORDGroup.GraphicData;
+      var center = {
+        x: GraphicData[0],
+        y: GraphicData[1]
+      };
+      var end = {
+        x: GraphicData[2],
+        y: GraphicData[3]
+      };
+      var state = _objectSpread2(_objectSpread2({}, defaultState), {}, {
+        toolType: CircleRoi.toolType,
+        active: false,
+        cachedStats: {
+          area: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : 0,
+          // Dummy values to be updated by cornerstone
+          radius: 0,
+          perimeter: 0
+        },
+        handles: {
+          end: _objectSpread2(_objectSpread2({}, end), {}, {
+            highlight: false,
+            active: false
+          }),
+          initialRotation: 0,
+          start: _objectSpread2(_objectSpread2({}, center), {}, {
+            highlight: false,
+            active: false
+          }),
+          textBox: {
+            hasMoved: false,
+            movesIndependently: false,
+            drawnIndependently: true,
+            allowedOutsideImage: true,
+            hasBoundingBox: true
+          }
+        },
+        invalidated: true,
+        visible: true
+      });
+      return state;
+    }
+
+    /**
+     * Gets the TID 300 representation of a circle, given the cornerstone representation.
+     *
+     * @param {Object} tool
+     * @returns
+     */
+  }, {
+    key: "getTID300RepresentationArguments",
+    value: function getTID300RepresentationArguments(tool) {
+      var _tool$cachedStats = tool.cachedStats,
+        cachedStats = _tool$cachedStats === void 0 ? {} : _tool$cachedStats,
+        handles = tool.handles,
+        finding = tool.finding,
+        findingSites = tool.findingSites;
+      var center = handles.start,
+        end = handles.end;
+      var area = cachedStats.area,
+        radius = cachedStats.radius;
+      var perimeter = 2 * Math.PI * radius;
+      var points = [];
+      points.push(center);
+      points.push(end);
+      var trackingIdentifierTextValue = "cornerstoneTools@^4.0.0:CircleRoi";
+      return {
+        area: area,
+        perimeter: perimeter,
+        radius: radius,
+        points: points,
+        trackingIdentifierTextValue: trackingIdentifierTextValue,
+        finding: finding,
+        findingSites: findingSites || []
+      };
+    }
+  }]);
+}();
+CircleRoi.toolType = CIRCLEROI;
+CircleRoi.utilityToolType = CIRCLEROI;
+CircleRoi.TID300Representation = TID300Circle;
+CircleRoi.isValidCornerstoneTrackingIdentifier = function (TrackingIdentifier) {
+  if (!TrackingIdentifier.includes(":")) {
+    return false;
+  }
+  var _TrackingIdentifier$s = TrackingIdentifier.split(":"),
+    _TrackingIdentifier$s2 = _slicedToArray(_TrackingIdentifier$s, 2),
+    cornerstone4Tag = _TrackingIdentifier$s2[0],
+    toolType = _TrackingIdentifier$s2[1];
+  if (cornerstone4Tag !== CORNERSTONE_4_TAG) {
+    return false;
+  }
+  return toolType === CIRCLEROI;
+};
+MeasurementReport.registerTool(CircleRoi);
+
+export { CircleRoi as default };

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

@@ -0,0 +1,49 @@
+export default CobbAngle;
+declare class CobbAngle {
+    static getMeasurementData(MeasurementGroup: any): {
+        rAngle: any;
+        toolType: string;
+        handles: {
+            start: {};
+            end: {};
+            start2: {
+                highlight: boolean;
+                drawnIndependently: boolean;
+            };
+            end2: {
+                highlight: boolean;
+                drawnIndependently: boolean;
+            };
+            textBox: {
+                hasMoved: boolean;
+                movesIndependently: boolean;
+                drawnIndependently: boolean;
+                allowedOutsideImage: boolean;
+                hasBoundingBox: boolean;
+            };
+        };
+        sopInstanceUid: any;
+        frameIndex: any;
+        complete: boolean;
+        finding: any;
+        findingSites: any[];
+    };
+    static getTID300RepresentationArguments(tool: any): {
+        point1: any;
+        point2: any;
+        point3: any;
+        point4: any;
+        rAngle: any;
+        trackingIdentifierTextValue: string;
+        finding: any;
+        findingSites: any;
+    };
+}
+declare namespace CobbAngle {
+    export { COBB_ANGLE as toolType };
+    export { COBB_ANGLE as utilityToolType };
+    export { TID300CobbAngle as TID300Representation };
+    export function isValidCornerstoneTrackingIdentifier(TrackingIdentifier: any): boolean;
+}
+declare const COBB_ANGLE: "CobbAngle";
+declare const TID300CobbAngle: any;

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

@@ -0,0 +1,98 @@
+import { slicedToArray as _slicedToArray, createClass as _createClass, objectSpread2 as _objectSpread2, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { utilities } from 'dcmjs';
+import MeasurementReport from './MeasurementReport.js';
+import CORNERSTONE_4_TAG from './cornerstone4Tag.js';
+
+var TID300CobbAngle = utilities.TID300.CobbAngle;
+var COBB_ANGLE = "CobbAngle";
+var CobbAngle = /*#__PURE__*/function () {
+  function CobbAngle() {
+    _classCallCheck(this, CobbAngle);
+  }
+  return _createClass(CobbAngle, null, [{
+    key: "getMeasurementData",
+    value:
+    // TODO: this function is required for all Cornerstone Tool Adapters, since it is called by MeasurementReport.
+    function getMeasurementData(MeasurementGroup) {
+      var _MeasurementReport$ge = MeasurementReport.getSetupMeasurementData(MeasurementGroup),
+        defaultState = _MeasurementReport$ge.defaultState,
+        NUMGroup = _MeasurementReport$ge.NUMGroup,
+        SCOORDGroup = _MeasurementReport$ge.SCOORDGroup;
+      var state = _objectSpread2(_objectSpread2({}, defaultState), {}, {
+        rAngle: NUMGroup.MeasuredValueSequence.NumericValue,
+        toolType: CobbAngle.toolType,
+        handles: {
+          start: {},
+          end: {},
+          start2: {
+            highlight: true,
+            drawnIndependently: true
+          },
+          end2: {
+            highlight: true,
+            drawnIndependently: true
+          },
+          textBox: {
+            hasMoved: false,
+            movesIndependently: false,
+            drawnIndependently: true,
+            allowedOutsideImage: true,
+            hasBoundingBox: true
+          }
+        }
+      });
+      var _SCOORDGroup$GraphicD = _slicedToArray(SCOORDGroup.GraphicData, 8);
+      state.handles.start.x = _SCOORDGroup$GraphicD[0];
+      state.handles.start.y = _SCOORDGroup$GraphicD[1];
+      state.handles.end.x = _SCOORDGroup$GraphicD[2];
+      state.handles.end.y = _SCOORDGroup$GraphicD[3];
+      state.handles.start2.x = _SCOORDGroup$GraphicD[4];
+      state.handles.start2.y = _SCOORDGroup$GraphicD[5];
+      state.handles.end2.x = _SCOORDGroup$GraphicD[6];
+      state.handles.end2.y = _SCOORDGroup$GraphicD[7];
+      return state;
+    }
+  }, {
+    key: "getTID300RepresentationArguments",
+    value: function getTID300RepresentationArguments(tool) {
+      var handles = tool.handles,
+        finding = tool.finding,
+        findingSites = tool.findingSites;
+      var point1 = handles.start;
+      var point2 = handles.end;
+      var point3 = handles.start2;
+      var point4 = handles.end2;
+      var rAngle = tool.rAngle;
+      var trackingIdentifierTextValue = "cornerstoneTools@^4.0.0:CobbAngle";
+      return {
+        point1: point1,
+        point2: point2,
+        point3: point3,
+        point4: point4,
+        rAngle: rAngle,
+        trackingIdentifierTextValue: trackingIdentifierTextValue,
+        finding: finding,
+        findingSites: findingSites || []
+      };
+    }
+  }]);
+}();
+CobbAngle.toolType = COBB_ANGLE;
+CobbAngle.utilityToolType = COBB_ANGLE;
+CobbAngle.TID300Representation = TID300CobbAngle;
+CobbAngle.isValidCornerstoneTrackingIdentifier = function (TrackingIdentifier) {
+  if (!TrackingIdentifier.includes(":")) {
+    return false;
+  }
+  var _TrackingIdentifier$s = TrackingIdentifier.split(":"),
+    _TrackingIdentifier$s2 = _slicedToArray(_TrackingIdentifier$s, 2),
+    cornerstone4Tag = _TrackingIdentifier$s2[0],
+    toolType = _TrackingIdentifier$s2[1];
+  if (cornerstone4Tag !== CORNERSTONE_4_TAG) {
+    return false;
+  }
+  return toolType === COBB_ANGLE;
+};
+MeasurementReport.registerTool(CobbAngle);
+
+export { CobbAngle as default };