@cornerstonejs/adapters 2.0.0-beta.2 → 2.0.0-beta.21

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

@@ -0,0 +1,113 @@
+import { defineProperty as _defineProperty, createClass as _createClass, slicedToArray as _slicedToArray, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { utilities } from 'dcmjs';
+import CORNERSTONE_3D_TAG from './cornerstone3DTag.js';
+import MeasurementReport from './MeasurementReport.js';
+
+var TID300CobbAngle = utilities.TID300.CobbAngle;
+var MEASUREMENT_TYPE = "CobbAngle";
+var trackingIdentifierTextValue = "".concat(CORNERSTONE_3D_TAG, ":").concat(MEASUREMENT_TYPE);
+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, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+      var _MeasurementReport$ge = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, CobbAngle.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[2], 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("CobbAngle.getTID300RepresentationArguments: referencedImageId is not defined");
+      }
+      var start1 = worldToImageCoords(referencedImageId, handles.points[0]);
+      var end1 = worldToImageCoords(referencedImageId, handles.points[1]);
+      var start2 = worldToImageCoords(referencedImageId, handles.points[2]);
+      var end2 = worldToImageCoords(referencedImageId, handles.points[3]);
+      var point1 = {
+        x: start1[0],
+        y: start1[1]
+      };
+      var point2 = {
+        x: end1[0],
+        y: end1[1]
+      };
+      var point3 = {
+        x: start2[0],
+        y: start2[1]
+      };
+      var point4 = {
+        x: end2[0],
+        y: end2[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 || []
+      };
+    }
+  }]);
+}();
+_defineProperty(CobbAngle, "toolType", MEASUREMENT_TYPE);
+_defineProperty(CobbAngle, "utilityToolType", MEASUREMENT_TYPE);
+_defineProperty(CobbAngle, "TID300Representation", TID300CobbAngle);
+_defineProperty(CobbAngle, "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(CobbAngle);
+
+export { CobbAngle as default };

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

@@ -0,0 +1,9 @@
+export default CodingScheme;
+declare namespace CodingScheme {
+    export { CodingSchemeDesignator };
+    export namespace codeValues {
+        export { CORNERSTONEFREETEXT };
+    }
+}
+declare const CodingSchemeDesignator: "CORNERSTONEJS";
+declare const CORNERSTONEFREETEXT: "CORNERSTONEFREETEXT";

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

@@ -0,0 +1,15 @@
+// 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
+// here this is fine for most labels, but may be problematic at some point.
+var CORNERSTONEFREETEXT = "CORNERSTONEFREETEXT";
+
+// Cornerstone specified coding scheme for storing findings
+var CodingSchemeDesignator = "CORNERSTONEJS";
+var CodingScheme = {
+  CodingSchemeDesignator: CodingSchemeDesignator,
+  codeValues: {
+    CORNERSTONEFREETEXT: CORNERSTONEFREETEXT
+  }
+};
+
+export { CodingScheme as default };

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

@@ -0,0 +1,170 @@
+import { defineProperty as _defineProperty, createClass as _createClass, toConsumableArray as _toConsumableArray, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { vec3 } from 'gl-matrix';
+import { utilities } from 'dcmjs';
+import CORNERSTONE_3D_TAG from './cornerstone3DTag.js';
+import MeasurementReport from './MeasurementReport.js';
+import isValidCornerstoneTrackingIdentifier from './isValidCornerstoneTrackingIdentifier.js';
+
+var TID300Ellipse = utilities.TID300.Ellipse;
+var ELLIPTICALROI = "EllipticalROI";
+var EPSILON = 1e-4;
+var EllipticalROI = /*#__PURE__*/function () {
+  function EllipticalROI() {
+    _classCallCheck(this, EllipticalROI);
+  }
+  return _createClass(EllipticalROI, null, [{
+    key: "getMeasurementData",
+    value: function getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+      var _MeasurementReport$ge = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, EllipticalROI.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;
+      // GraphicData is ordered as [majorAxisStartX, majorAxisStartY, majorAxisEndX, majorAxisEndY, minorAxisStartX, minorAxisStartY, minorAxisEndX, minorAxisEndY]
+      // But Cornerstone3D points are ordered as top, bottom, left, right for the
+      // ellipse so we need to identify if the majorAxis is horizontal or vertical
+      // in the image plane and then choose the correct points to use for the ellipse.
+      var pointsWorld = [];
+      for (var i = 0; i < GraphicData.length; i += 2) {
+        var worldPos = imageToWorldCoords(referencedImageId, [GraphicData[i], GraphicData[i + 1]]);
+        pointsWorld.push(worldPos);
+      }
+      var majorAxisStart = vec3.fromValues.apply(vec3, _toConsumableArray(pointsWorld[0]));
+      var majorAxisEnd = vec3.fromValues.apply(vec3, _toConsumableArray(pointsWorld[1]));
+      var minorAxisStart = vec3.fromValues.apply(vec3, _toConsumableArray(pointsWorld[2]));
+      var minorAxisEnd = vec3.fromValues.apply(vec3, _toConsumableArray(pointsWorld[3]));
+      var majorAxisVec = vec3.create();
+      vec3.sub(majorAxisVec, majorAxisEnd, majorAxisStart);
+      // normalize majorAxisVec to avoid scaling issues
+      vec3.normalize(majorAxisVec, majorAxisVec);
+      var minorAxisVec = vec3.create();
+      vec3.sub(minorAxisVec, minorAxisEnd, minorAxisStart);
+      vec3.normalize(minorAxisVec, minorAxisVec);
+      var imagePlaneModule = metadata.get("imagePlaneModule", referencedImageId);
+      if (!imagePlaneModule) {
+        throw new Error("imageId does not have imagePlaneModule metadata");
+      }
+      var columnCosines = imagePlaneModule.columnCosines;
+      // find which axis is parallel to the columnCosines
+      var columnCosinesVec = vec3.fromValues(columnCosines[0], columnCosines[1], columnCosines[2]);
+      var projectedMajorAxisOnColVec = vec3.dot(columnCosinesVec, majorAxisVec);
+      var projectedMinorAxisOnColVec = vec3.dot(columnCosinesVec, minorAxisVec);
+      var absoluteOfMajorDotProduct = Math.abs(projectedMajorAxisOnColVec);
+      var absoluteOfMinorDotProduct = Math.abs(projectedMinorAxisOnColVec);
+      var 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");
+      }
+      var state = defaultState;
+      state.annotation.data = {
+        handles: {
+          points: _toConsumableArray(ellipsePoints),
+          activeHandleIndex: 0,
+          textBox: {
+            hasMoved: false
+          }
+        },
+        cachedStats: _defineProperty({}, "imageId:".concat(referencedImageId), {
+          area: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : 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 rotation = data.initialRotation || 0;
+      var referencedImageId = metadata.referencedImageId;
+      if (!referencedImageId) {
+        throw new Error("EllipticalROI.getTID300RepresentationArguments: referencedImageId is not defined");
+      }
+      var top, bottom, left, right;
+      // this way when it's restored we can assume the initial rotation is 0.
+      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]);
+      }
+      // find the major axis and minor axis
+      var topBottomLength = Math.abs(top[1] - bottom[1]);
+      var leftRightLength = Math.abs(left[0] - right[0]);
+      var points = [];
+      if (topBottomLength > leftRightLength) {
+        // major axis is bottom to top
+        points.push({
+          x: top[0],
+          y: top[1]
+        });
+        points.push({
+          x: bottom[0],
+          y: bottom[1]
+        });
+        // minor axis is left to right
+        points.push({
+          x: left[0],
+          y: left[1]
+        });
+        points.push({
+          x: right[0],
+          y: right[1]
+        });
+      } else {
+        // major axis is left to right
+        points.push({
+          x: left[0],
+          y: left[1]
+        });
+        points.push({
+          x: right[0],
+          y: right[1]
+        });
+        // minor axis is bottom to top
+        points.push({
+          x: top[0],
+          y: top[1]
+        });
+        points.push({
+          x: bottom[0],
+          y: bottom[1]
+        });
+      }
+      var _ref = cachedStats["imageId:".concat(referencedImageId)] || {},
+        area = _ref.area;
+      return {
+        area: area,
+        points: points,
+        trackingIdentifierTextValue: this.trackingIdentifierTextValue,
+        finding: finding,
+        findingSites: findingSites || []
+      };
+    }
+  }]);
+}();
+_defineProperty(EllipticalROI, "trackingIdentifierTextValue", "".concat(CORNERSTONE_3D_TAG, ":").concat(ELLIPTICALROI));
+_defineProperty(EllipticalROI, "toolType", ELLIPTICALROI);
+_defineProperty(EllipticalROI, "utilityToolType", ELLIPTICALROI);
+_defineProperty(EllipticalROI, "TID300Representation", TID300Ellipse);
+_defineProperty(EllipticalROI, "isValidCornerstoneTrackingIdentifier", isValidCornerstoneTrackingIdentifier);
+MeasurementReport.registerTool(EllipticalROI);
+
+export { EllipticalROI as default };

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

@@ -0,0 +1,41 @@
+export default Length;
+declare class Length {
+    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): {
+        point1: {
+            x: any;
+            y: any;
+        };
+        point2: {
+            x: any;
+            y: 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/Cornerstone3D/Length.js

@@ -0,0 +1,101 @@
+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 TID300Length = utilities.TID300.Length;
+var LENGTH = "Length";
+var trackingIdentifierTextValue = "".concat(CORNERSTONE_3D_TAG, ":").concat(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, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+      var _MeasurementReport$ge = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, Length.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]],
+          activeHandleIndex: 0,
+          textBox: {
+            hasMoved: false
+          }
+        },
+        cachedStats: _defineProperty({}, "imageId:".concat(referencedImageId), {
+          length: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : 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("Length.getTID300RepresentationArguments: referencedImageId is not defined");
+      }
+      var start = worldToImageCoords(referencedImageId, handles.points[0]);
+      var end = worldToImageCoords(referencedImageId, handles.points[1]);
+      var point1 = {
+        x: start[0],
+        y: start[1]
+      };
+      var point2 = {
+        x: end[0],
+        y: end[1]
+      };
+      var _ref = cachedStats["imageId:".concat(referencedImageId)] || {},
+        distance = _ref.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),
+    cornerstone3DTag = _TrackingIdentifier$s2[0],
+    toolType = _TrackingIdentifier$s2[1];
+  if (cornerstone3DTag !== CORNERSTONE_3D_TAG) {
+    return false;
+  }
+  return toolType === LENGTH;
+};
+MeasurementReport.registerTool(Length);
+
+export { Length as default };

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

@@ -1,5 +1,5 @@
 export default class MeasurementReport {
-    static CORNERSTONE_3D_TAG: any;
+    static CORNERSTONE_3D_TAG: string;
     static MEASUREMENT_BY_TOOLTYPE: {};
     static CORNERSTONE_TOOL_CLASSES_BY_UTILITY_TYPE: {};
     static CORNERSTONE_TOOL_CLASSES_BY_TOOL_TYPE: {};