@cornerstonejs/adapters 2.0.0-beta.8 → 2.0.1

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

@@ -0,0 +1,57 @@
+export default EllipticalRoi;
+declare class EllipticalRoi {
+    static getMeasurementData(MeasurementGroup: any): {
+        toolType: string;
+        active: boolean;
+        cachedStats: {
+            area: any;
+        };
+        handles: {
+            end: {
+                x: any;
+                y: any;
+                highlight: boolean;
+                active: boolean;
+            };
+            initialRotation: number;
+            start: {
+                x: number;
+                y: number;
+                highlight: boolean;
+                active: boolean;
+            };
+            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;
+        points: {
+            x: number;
+            y: number;
+        }[];
+        trackingIdentifierTextValue: string;
+        finding: any;
+        findingSites: any;
+    };
+}
+declare namespace EllipticalRoi {
+    export { ELLIPTICALROI as toolType };
+    export { ELLIPTICALROI as utilityToolType };
+    export { TID300Ellipse as TID300Representation };
+    export function isValidCornerstoneTrackingIdentifier(TrackingIdentifier: any): boolean;
+}
+declare const ELLIPTICALROI: "EllipticalRoi";
+declare const TID300Ellipse: any;

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

@@ -0,0 +1,178 @@
+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 TID300Ellipse = utilities.TID300.Ellipse;
+var ELLIPTICALROI = "EllipticalRoi";
+var EllipticalRoi = /*#__PURE__*/function () {
+  function EllipticalRoi() {
+    _classCallCheck(this, EllipticalRoi);
+  }
+  return _createClass(EllipticalRoi, 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 GraphicData = SCOORDGroup.GraphicData;
+      var majorAxis = [{
+        x: GraphicData[0],
+        y: GraphicData[1]
+      }, {
+        x: GraphicData[2],
+        y: GraphicData[3]
+      }];
+      var minorAxis = [{
+        x: GraphicData[4],
+        y: GraphicData[5]
+      }, {
+        x: GraphicData[6],
+        y: GraphicData[7]
+      }];
+
+      // Calculate two opposite corners of box defined by two axes.
+
+      var minorAxisLength = Math.sqrt(Math.pow(minorAxis[0].x - minorAxis[1].x, 2) + Math.pow(minorAxis[0].y - minorAxis[1].y, 2));
+      var minorAxisDirection = {
+        x: (minorAxis[1].x - minorAxis[0].x) / minorAxisLength,
+        y: (minorAxis[1].y - minorAxis[0].y) / minorAxisLength
+      };
+      var halfMinorAxisLength = minorAxisLength / 2;
+
+      // First end point of major axis + half minor axis vector
+      var corner1 = {
+        x: majorAxis[0].x + minorAxisDirection.x * halfMinorAxisLength,
+        y: majorAxis[0].y + minorAxisDirection.y * halfMinorAxisLength
+      };
+
+      // Second end point of major axis - half of minor axis vector
+      var corner2 = {
+        x: majorAxis[1].x - minorAxisDirection.x * halfMinorAxisLength,
+        y: majorAxis[1].y - minorAxisDirection.y * halfMinorAxisLength
+      };
+      var state = _objectSpread2(_objectSpread2({}, defaultState), {}, {
+        toolType: EllipticalRoi.toolType,
+        active: false,
+        cachedStats: {
+          area: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : 0
+        },
+        handles: {
+          end: {
+            x: corner1.x,
+            y: corner1.y,
+            highlight: false,
+            active: false
+          },
+          initialRotation: 0,
+          start: {
+            x: corner2.x,
+            y: corner2.y,
+            highlight: false,
+            active: false
+          },
+          textBox: {
+            hasMoved: false,
+            movesIndependently: false,
+            drawnIndependently: true,
+            allowedOutsideImage: true,
+            hasBoundingBox: true
+          }
+        },
+        invalidated: true,
+        visible: true
+      });
+      return state;
+    }
+  }, {
+    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 start = handles.start,
+        end = handles.end;
+      var area = cachedStats.area;
+      var halfXLength = Math.abs(start.x - end.x) / 2;
+      var halfYLength = Math.abs(start.y - end.y) / 2;
+      var points = [];
+      var center = {
+        x: (start.x + end.x) / 2,
+        y: (start.y + end.y) / 2
+      };
+      if (halfXLength > halfYLength) {
+        // X-axis major
+        // Major axis
+        points.push({
+          x: center.x - halfXLength,
+          y: center.y
+        });
+        points.push({
+          x: center.x + halfXLength,
+          y: center.y
+        });
+        // Minor axis
+        points.push({
+          x: center.x,
+          y: center.y - halfYLength
+        });
+        points.push({
+          x: center.x,
+          y: center.y + halfYLength
+        });
+      } else {
+        // Y-axis major
+        // Major axis
+        points.push({
+          x: center.x,
+          y: center.y - halfYLength
+        });
+        points.push({
+          x: center.x,
+          y: center.y + halfYLength
+        });
+        // Minor axis
+        points.push({
+          x: center.x - halfXLength,
+          y: center.y
+        });
+        points.push({
+          x: center.x + halfXLength,
+          y: center.y
+        });
+      }
+      var trackingIdentifierTextValue = "cornerstoneTools@^4.0.0:EllipticalRoi";
+      return {
+        area: area,
+        points: points,
+        trackingIdentifierTextValue: trackingIdentifierTextValue,
+        finding: finding,
+        findingSites: findingSites || []
+      };
+    }
+  }]);
+}();
+EllipticalRoi.toolType = ELLIPTICALROI;
+EllipticalRoi.utilityToolType = ELLIPTICALROI;
+EllipticalRoi.TID300Representation = TID300Ellipse;
+EllipticalRoi.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 === ELLIPTICALROI;
+};
+MeasurementReport.registerTool(EllipticalRoi);
+
+export { EllipticalRoi as default };

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

@@ -0,0 +1,42 @@
+export default FreehandRoi;
+declare class FreehandRoi {
+    static getMeasurementData(MeasurementGroup: any): {
+        toolType: string;
+        handles: {
+            points: any[];
+            textBox: {
+                active: boolean;
+                hasMoved: boolean;
+                movesIndependently: boolean;
+                drawnIndependently: boolean;
+                allowedOutsideImage: boolean;
+                hasBoundingBox: boolean;
+            };
+        };
+        cachedStats: {
+            area: any;
+        };
+        color: any;
+        invalidated: boolean;
+        sopInstanceUid: any;
+        frameIndex: any;
+        complete: boolean;
+        finding: any;
+        findingSites: any[];
+    };
+    static getTID300RepresentationArguments(tool: any): {
+        points: any;
+        area: any;
+        perimeter: any;
+        trackingIdentifierTextValue: string;
+        finding: any;
+        findingSites: any;
+    };
+}
+declare namespace FreehandRoi {
+    export let toolType: string;
+    export let utilityToolType: string;
+    export { TID300Polyline as TID300Representation };
+    export function isValidCornerstoneTrackingIdentifier(TrackingIdentifier: any): boolean;
+}
+declare const TID300Polyline: any;

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

@@ -0,0 +1,89 @@
+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 TID300Polyline = utilities.TID300.Polyline;
+var FreehandRoi = /*#__PURE__*/function () {
+  function FreehandRoi() {
+    _classCallCheck(this, FreehandRoi);
+  }
+  return _createClass(FreehandRoi, null, [{
+    key: "getMeasurementData",
+    value: function getMeasurementData(MeasurementGroup) {
+      var _MeasurementReport$ge = MeasurementReport.getSetupMeasurementData(MeasurementGroup),
+        defaultState = _MeasurementReport$ge.defaultState,
+        SCOORDGroup = _MeasurementReport$ge.SCOORDGroup,
+        NUMGroup = _MeasurementReport$ge.NUMGroup;
+      var state = _objectSpread2(_objectSpread2({}, defaultState), {}, {
+        toolType: FreehandRoi.toolType,
+        handles: {
+          points: [],
+          textBox: {
+            active: false,
+            hasMoved: false,
+            movesIndependently: false,
+            drawnIndependently: true,
+            allowedOutsideImage: true,
+            hasBoundingBox: true
+          }
+        },
+        cachedStats: {
+          area: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : 0
+        },
+        color: undefined,
+        invalidated: true
+      });
+      var GraphicData = SCOORDGroup.GraphicData;
+      for (var i = 0; i < GraphicData.length; i += 2) {
+        state.handles.points.push({
+          x: GraphicData[i],
+          y: GraphicData[i + 1]
+        });
+      }
+      return state;
+    }
+  }, {
+    key: "getTID300RepresentationArguments",
+    value: function getTID300RepresentationArguments(tool) {
+      var handles = tool.handles,
+        finding = tool.finding,
+        findingSites = tool.findingSites,
+        _tool$cachedStats = tool.cachedStats,
+        cachedStats = _tool$cachedStats === void 0 ? {} : _tool$cachedStats;
+      var points = handles.points;
+      var _cachedStats$area = cachedStats.area,
+        area = _cachedStats$area === void 0 ? 0 : _cachedStats$area,
+        _cachedStats$perimete = cachedStats.perimeter,
+        perimeter = _cachedStats$perimete === void 0 ? 0 : _cachedStats$perimete;
+      var trackingIdentifierTextValue = "cornerstoneTools@^4.0.0:FreehandRoi";
+      return {
+        points: points,
+        area: area,
+        perimeter: perimeter,
+        trackingIdentifierTextValue: trackingIdentifierTextValue,
+        finding: finding,
+        findingSites: findingSites || []
+      };
+    }
+  }]);
+}();
+FreehandRoi.toolType = "FreehandRoi";
+FreehandRoi.utilityToolType = "FreehandRoi";
+FreehandRoi.TID300Representation = TID300Polyline;
+FreehandRoi.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 === FreehandRoi.toolType;
+};
+MeasurementReport.registerTool(FreehandRoi);
+
+export { FreehandRoi as default };

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

@@ -0,0 +1,39 @@
+export default Length;
+declare class Length {
+    static getMeasurementData(MeasurementGroup: any): {
+        length: any;
+        toolType: string;
+        handles: {
+            start: {};
+            end: {};
+            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;
+        distance: any;
+        trackingIdentifierTextValue: string;
+        finding: any;
+        findingSites: any;
+    };
+}
+declare namespace Length {
+    export { LENGTH as toolType };
+    export { LENGTH as utilityToolType };
+    export { TID300Length as TID300Representation };
+    export function isValidCornerstoneTrackingIdentifier(TrackingIdentifier: any): boolean;
+}
+declare const LENGTH: "Length";
+declare const TID300Length: any;

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

@@ -0,0 +1,82 @@
+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 TID300Length = utilities.TID300.Length;
+var LENGTH = "Length";
+var Length = /*#__PURE__*/function () {
+  function Length() {
+    _classCallCheck(this, Length);
+  }
+  return _createClass(Length, 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), {}, {
+        length: NUMGroup.MeasuredValueSequence.NumericValue,
+        toolType: Length.toolType,
+        handles: {
+          start: {},
+          end: {},
+          textBox: {
+            hasMoved: false,
+            movesIndependently: false,
+            drawnIndependently: true,
+            allowedOutsideImage: true,
+            hasBoundingBox: true
+          }
+        }
+      });
+      var _SCOORDGroup$GraphicD = _slicedToArray(SCOORDGroup.GraphicData, 4);
+      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];
+      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 distance = tool.length;
+      var trackingIdentifierTextValue = "cornerstoneTools@^4.0.0:Length";
+      return {
+        point1: point1,
+        point2: point2,
+        distance: distance,
+        trackingIdentifierTextValue: trackingIdentifierTextValue,
+        finding: finding,
+        findingSites: findingSites || []
+      };
+    }
+  }]);
+}();
+Length.toolType = LENGTH;
+Length.utilityToolType = LENGTH;
+Length.TID300Representation = TID300Length;
+Length.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 === LENGTH;
+};
+MeasurementReport.registerTool(Length);
+
+export { Length as default };

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

@@ -0,0 +1,29 @@
+declare class MeasurementReport {
+    static getSetupMeasurementData(MeasurementGroup: any): {
+        defaultState: {
+            sopInstanceUid: any;
+            frameIndex: any;
+            complete: boolean;
+            finding: any;
+            findingSites: any[];
+        };
+        findingGroup: any;
+        findingSiteGroups: any[];
+        NUMGroup: any;
+        SCOORDGroup: any;
+        ReferencedSOPSequence: any;
+        ReferencedSOPInstanceUID: any;
+        ReferencedFrameNumber: any;
+    };
+    static generateReport(toolState: any, metadataProvider: any, options: any): any;
+    static generateToolState(dataset: object, hooks?: {
+        getToolClass: Function;
+    }): {};
+    static registerTool(toolClass: any): void;
+}
+declare namespace MeasurementReport {
+    let MEASUREMENT_BY_TOOLTYPE: {};
+    let CORNERSTONE_TOOL_CLASSES_BY_UTILITY_TYPE: {};
+    let CORNERSTONE_TOOL_CLASSES_BY_TOOL_TYPE: {};
+}
+export default MeasurementReport;