@cornerstonejs/adapters 3.0.0-beta.4 → 3.0.0-beta.6

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

@@ -1,147 +1,132 @@
-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';
+import 'buffer';
+import BaseAdapter3D from './BaseAdapter3D.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);
+const {
+  Bidirectional: TID300Bidirectional
+} = utilities.TID300;
+const LONG_AXIS = "Long Axis";
+const SHORT_AXIS = "Short Axis";
+class Bidirectional extends BaseAdapter3D {
+  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+    const {
+      defaultState,
+      ReferencedFrameNumber
+    } = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, Bidirectional.toolType);
+    const referencedImageId = defaultState.annotation.metadata.referencedImageId;
+    const {
+      ContentSequence
+    } = MeasurementGroup;
+    const longAxisNUMGroup = toArray(ContentSequence).find(group => group.ConceptNameCodeSequence.CodeMeaning === LONG_AXIS);
+    const longAxisSCOORDGroup = toArray(longAxisNUMGroup.ContentSequence).find(group => group.ValueType === "SCOORD");
+    const shortAxisNUMGroup = toArray(ContentSequence).find(group => group.ConceptNameCodeSequence.CodeMeaning === SHORT_AXIS);
+    const shortAxisSCOORDGroup = toArray(shortAxisNUMGroup.ContentSequence).find(group => 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;
+    state.annotation.data = {
+      handles: {
+        points: [worldCoords[0], worldCoords[1], worldCoords[2], worldCoords[3]],
+        activeHandleIndex: 0,
+        textBox: {
+          hasMoved: false
         }
-      });
-      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), {
+      },
+      cachedStats: {
+        ["imageId:".concat(referencedImageId)]: {
           length: longAxisNUMGroup.MeasuredValueSequence.NumericValue,
           width: shortAxisNUMGroup.MeasuredValueSequence.NumericValue
-        }),
-        frameNumber: ReferencedFrameNumber
-      };
-      return state;
+        }
+      },
+      frameNumber: ReferencedFrameNumber
+    };
+    return state;
+  }
+  static getTID300RepresentationArguments(tool, worldToImageCoords) {
+    const {
+      data,
+      finding,
+      findingSites,
+      metadata
+    } = tool;
+    const {
+      cachedStats = {},
+      handles
+    } = data;
+    const {
+      referencedImageId
+    } = metadata;
+    if (!referencedImageId) {
+      throw new Error("Bidirectional.getTID300RepresentationArguments: referencedImageId is not defined");
     }
-  }, {
-    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]
-          }
+    const {
+      length,
+      width
+    } = cachedStats["imageId:".concat(referencedImageId)] || {};
+    const {
+      points
+    } = handles;
+    const firstPointPairs = [points[0], points[1]];
+    const secondPointPairs = [points[2], points[3]];
+    const 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));
+    const 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));
+    let shortAxisPoints;
+    let longAxisPoints;
+    if (firstPointPairsDistance > secondPointPairsDistance) {
+      shortAxisPoints = firstPointPairs;
+      longAxisPoints = secondPointPairs;
+    } else {
+      shortAxisPoints = secondPointPairs;
+      longAxisPoints = firstPointPairs;
+    }
+    const longAxisStartImage = worldToImageCoords(referencedImageId, shortAxisPoints[0]);
+    const longAxisEndImage = worldToImageCoords(referencedImageId, shortAxisPoints[1]);
+    const shortAxisStartImage = worldToImageCoords(referencedImageId, longAxisPoints[0]);
+    const shortAxisEndImage = worldToImageCoords(referencedImageId, longAxisPoints[1]);
+    return {
+      longAxis: {
+        point1: {
+          x: longAxisStartImage[0],
+          y: longAxisStartImage[1]
         },
-        shortAxis: {
-          point1: {
-            x: shortAxisStartImage[0],
-            y: shortAxisStartImage[1]
-          },
-          point2: {
-            x: shortAxisEndImage[0],
-            y: shortAxisEndImage[1]
-          }
+        point2: {
+          x: longAxisEndImage[0],
+          y: longAxisEndImage[1]
+        }
+      },
+      shortAxis: {
+        point1: {
+          x: shortAxisStartImage[0],
+          y: shortAxisStartImage[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;
+        point2: {
+          x: shortAxisEndImage[0],
+          y: shortAxisEndImage[1]
+        }
+      },
+      longAxisLength: length,
+      shortAxisLength: width,
+      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
+      finding: finding,
+      findingSites: findingSites || []
+    };
   }
-  return toolType === BIDIRECTIONAL;
-};
-MeasurementReport.registerTool(Bidirectional);
+}
+_Bidirectional = Bidirectional;
+(() => {
+  _Bidirectional.init("Bidirectional", TID300Bidirectional);
+  _Bidirectional.registerLegacy();
+})();
 
 export { Bidirectional as default };

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

@@ -1,10 +1,5 @@
-import isValidCornerstoneTrackingIdentifier from "./isValidCornerstoneTrackingIdentifier";
-declare class CircleROI {
-    static trackingIdentifierTextValue: string;
-    static toolType: string;
-    static utilityToolType: string;
-    static TID300Representation: any;
-    static isValidCornerstoneTrackingIdentifier: typeof isValidCornerstoneTrackingIdentifier;
+import BaseAdapter3D from "./BaseAdapter3D";
+declare class CircleROI extends BaseAdapter3D {
     static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any): {
         description: any;
         sopInstanceUid: any;

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

@@ -1,96 +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';
+import BaseAdapter3D from './BaseAdapter3D.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), {
+const {
+  Circle: TID300Circle
+} = utilities.TID300;
+class CircleROI extends BaseAdapter3D {
+  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+    const {
+      defaultState,
+      NUMGroup,
+      SCOORDGroup,
+      ReferencedFrameNumber
+    } = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, CircleROI.toolType);
+    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;
+    state.annotation.data = {
+      handles: {
+        points: [...pointsWorld],
+        activeHandleIndex: 0,
+        textBox: {
+          hasMoved: false
+        }
+      },
+      cachedStats: {
+        ["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 || []
-      };
+        }
+      },
+      frameNumber: ReferencedFrameNumber
+    };
+    return state;
+  }
+  static getTID300RepresentationArguments(tool, worldToImageCoords) {
+    const {
+      data,
+      finding,
+      findingSites,
+      metadata
+    } = tool;
+    const {
+      cachedStats = {},
+      handles
+    } = data;
+    const {
+      referencedImageId
+    } = metadata;
+    if (!referencedImageId) {
+      throw new Error("CircleROI.getTID300RepresentationArguments: referencedImageId is not defined");
     }
-  }]);
-}();
+    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 {
+      area,
+      radius
+    } = cachedStats["imageId:".concat(referencedImageId)] || {};
+    const perimeter = 2 * Math.PI * radius;
+    return {
+      area,
+      perimeter,
+      radius,
+      points,
+      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
+      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);
+(() => {
+  _CircleROI.init("CircleROI", TID300Circle);
+  _CircleROI.registerLegacy();
+})();
 
 export { CircleROI as default };

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

@@ -1,8 +1,5 @@
-declare class CobbAngle {
-    static toolType: string;
-    static utilityToolType: string;
-    static TID300Representation: any;
-    static isValidCornerstoneTrackingIdentifier: (TrackingIdentifier: any) => boolean;
+import BaseAdapter3D from "./BaseAdapter3D";
+declare class CobbAngle extends BaseAdapter3D {
     static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any): {
         description: any;
         sopInstanceUid: any;