//////////////////////////////////////////////////////////////////////////
//                                                                      //
// This is a generated file. You can view the original                  //
// source in your browser if your browser supports source maps.         //
// Source maps are supported by all recent versions of Chrome, Safari,  //
// and Firefox, and by Internet Explorer 11.                            //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


(function () {

/* Imports */
var Meteor = Package.meteor.Meteor;
var global = Package.meteor.global;
var meteorEnv = Package.meteor.meteorEnv;
var cornerstone = Package['ohif:cornerstone'].cornerstone;
var cornerstoneMath = Package['ohif:cornerstone'].cornerstoneMath;
var cornerstoneTools = Package['ohif:cornerstone'].cornerstoneTools;
var cornerstoneWADOImageLoader = Package['ohif:cornerstone'].cornerstoneWADOImageLoader;
var dicomParser = Package['ohif:cornerstone'].dicomParser;
var dcmjs = Package['ohif:cornerstone'].dcmjs;
var dialogPolyfill = Package['ohif:viewerbase'].dialogPolyfill;
var MeasurementSchemaTypes = Package['ohif:measurements'].MeasurementSchemaTypes;
var WADOProxy = Package['ohif:wadoproxy'].WADOProxy;
var meteorInstall = Package.modules.meteorInstall;
var meteorBabelHelpers = Package['babel-runtime'].meteorBabelHelpers;
var Promise = Package.promise.Promise;
var Symbol = Package['ecmascript-runtime-client'].Symbol;
var Map = Package['ecmascript-runtime-client'].Map;
var Set = Package['ecmascript-runtime-client'].Set;

/* Package-scope variables */
var getLengthMeasurementData, measurementGroupContentItem, retrieveDataFromMeasurements, report, dataset, measurement, retrieveDataFromSR, headerArray, contentArray, footerArray;

var require = meteorInstall({"node_modules":{"meteor":{"ohif:measurement-table":{"client":{"index.js":function(require,exports,module){

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                                         //
// packages/ohif_measurement-table/client/index.js                                                         //
//                                                                                                         //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                                                           //
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

module.export({
  MeasurementTable: function () {
    return MeasurementTable;
  }
});
var OHIF;
module.watch(require("meteor/ohif:core"), {
  OHIF: function (v) {
    OHIF = v;
  }
}, 0);
var Session;
module.watch(require("meteor/session"), {
  Session: function (v) {
    Session = v;
  }
}, 1);
var configureApis;
module.watch(require("./configuration/configuration"), {
  configureApis: function (v) {
    configureApis = v;
  }
}, 2);

var MeasurementTable =
/*#__PURE__*/
function () {
  function MeasurementTable() {
    configureApis();
    Session.set('TimepointsReady', false);
    Session.set('MeasurementsReady', false);
  }

  var _proto = MeasurementTable.prototype;

  _proto.onCreated = function () {
    function onCreated(instance) {
      var _this = this;

      var _OHIF$measurements, TimepointApi, MeasurementApi, timepointApi, measurementApi, apis, patientId;

      return _regenerator.default.async(function () {
        function onCreated$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _OHIF$measurements = OHIF.measurements, TimepointApi = _OHIF$measurements.TimepointApi, MeasurementApi = _OHIF$measurements.MeasurementApi;
                OHIF.viewer.data.currentTimepointId = 'TimepointId';
                timepointApi = new TimepointApi(OHIF.viewer.data.currentTimepointId);
                measurementApi = new MeasurementApi(timepointApi);
                apis = {
                  timepointApi: timepointApi,
                  measurementApi: measurementApi
                };
                Object.assign(OHIF.viewer, apis);
                Object.assign(instance.data, apis);
                patientId = instance.data.studies[0].patientId;
                _context.next = 10;
                return _regenerator.default.awrap(timepointApi.retrieveTimepoints({
                  patientId: patientId
                }));

              case 10:
                Session.set('TimepointsReady', true);
                _context.next = 13;
                return _regenerator.default.awrap(measurementApi.retrieveMeasurements(patientId, [OHIF.viewer.data.currentTimepointId]));

              case 13:
                Session.set('MeasurementsReady', true);
                measurementApi.syncMeasurementsAndToolData();
                this.firstMeasurementActivated = false;
                instance.autorun(function () {
                  if (!Session.get('TimepointsReady') || !Session.get('MeasurementsReady') || !Session.get('ViewerReady') || _this.firstMeasurementActivated) {
                    return;
                  }

                  _this.jumpToFirstMeasurement();
                });
                instance.measurementModifiedHandler = _.throttle(function (event, instance) {
                  OHIF.measurements.MeasurementHandlers.onModified(event, instance);
                }, 300);

              case 18:
              case "end":
                return _context.stop();
            }
          }
        }

        return onCreated$;
      }(), null, this);
    }

    return onCreated;
  }();

  _proto.onDestroyed = function () {
    function onDestroyed() {
      Session.set('TimepointsReady', false);
      Session.set('MeasurementsReady', false);
    }

    return onDestroyed;
  }();

  _proto.jumpToFirstMeasurement = function () {
    function jumpToFirstMeasurement() {
      // Find and activate the first measurement by Lesion Number
      // NOTE: This is inefficient, we should be using a hanging protocol
      // to hang the first measurement's imageId immediately, rather
      // than changing images after initial loading...
      var config = OHIF.measurements.MeasurementApi.getConfiguration();
      var tools = config.measurementTools[0].childTools;
      var firstTool = tools[Object.keys(tools)[0]];
      var measurementTypeId = firstTool.id;
      var collection = OHIF.viewer.measurementApi.tools[measurementTypeId];
      var sorting = {
        sort: {
          measurementNumber: -1
        }
      };
      var data = collection.find({}, sorting).fetch(); // TODO: Clean this up, it's probably an inefficient way to get what we need

      var groupObject = _.groupBy(data, function (m) {
        return m.measurementNumber;
      }); // Reformat the data


      var rows = Object.keys(groupObject).map(function (key) {
        return {
          measurementTypeId: measurementTypeId,
          measurementNumber: key,
          entries: groupObject[key]
        };
      });
      var rowItem = rows[0];
      var timepoints = [OHIF.viewer.timepointApi.current()];

      if (rowItem) {
        OHIF.measurements.jumpToRowItem(rowItem, timepoints);
      }

      this.firstMeasurementActivated = true;
    }

    return jumpToFirstMeasurement;
  }();

  return MeasurementTable;
}();

MeasurementTable.measurementEvents = {
  'cornerstonetoolsmeasurementadded .imageViewerViewport': function (event, instance) {
    var originalEvent = event.originalEvent;
    OHIF.measurements.MeasurementHandlers.onAdded(originalEvent, instance);
  },
  'cornerstonetoolsmeasurementmodified .imageViewerViewport': function (event, instance) {
    var originalEvent = event.originalEvent;
    instance.measurementModifiedHandler(originalEvent, instance);
  },
  'cornerstonemeasurementremoved .imageViewerViewport': function (event, instance) {
    var originalEvent = event.originalEvent;
    OHIF.measurements.MeasurementHandlers.onRemoved(originalEvent, instance);
  }
};
;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////

},"configuration":{"configuration.js":function(require,exports,module){

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                                         //
// packages/ohif_measurement-table/client/configuration/configuration.js                                   //
//                                                                                                         //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                                                           //
module.export({
  configureApis: function () {
    return configureApis;
  }
});
var OHIF;
module.watch(require("meteor/ohif:core"), {
  OHIF: function (v) {
    OHIF = v;
  }
}, 0);
var measurementTools;
module.watch(require("./measurementTools"), {
  measurementTools: function (v) {
    measurementTools = v;
  }
}, 1);
var retrieveMeasurements, storeMeasurements, retrieveTimepoints, storeTimepoints, removeTimepoint, updateTimepoint, disassociateStudy;
module.watch(require("./dataExchange"), {
  retrieveMeasurements: function (v) {
    retrieveMeasurements = v;
  },
  storeMeasurements: function (v) {
    storeMeasurements = v;
  },
  retrieveTimepoints: function (v) {
    retrieveTimepoints = v;
  },
  storeTimepoints: function (v) {
    storeTimepoints = v;
  },
  removeTimepoint: function (v) {
    removeTimepoint = v;
  },
  updateTimepoint: function (v) {
    updateTimepoint = v;
  },
  disassociateStudy: function (v) {
    disassociateStudy = v;
  }
}, 2);

var configureApis = function () {
  OHIF.measurements.MeasurementApi.setConfiguration({
    measurementTools: measurementTools,
    dataExchange: {
      retrieve: retrieveMeasurements,
      store: storeMeasurements
    },
    dataValidation: {
      validation: function () {}
    }
  });
  OHIF.measurements.TimepointApi.setConfiguration({
    dataExchange: {
      retrieve: retrieveTimepoints,
      store: storeTimepoints,
      remove: removeTimepoint,
      update: updateTimepoint,
      disassociate: disassociateStudy
    }
  });
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////

},"dataExchange.js":function(require,exports,module){

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                                         //
// packages/ohif_measurement-table/client/configuration/dataExchange.js                                    //
//                                                                                                         //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                                                           //
module.export({
  retrieveMeasurements: function () {
    return retrieveMeasurements;
  },
  storeMeasurements: function () {
    return storeMeasurements;
  },
  retrieveTimepoints: function () {
    return retrieveTimepoints;
  },
  storeTimepoints: function () {
    return storeTimepoints;
  },
  updateTimepoint: function () {
    return updateTimepoint;
  },
  removeTimepoint: function () {
    return removeTimepoint;
  },
  disassociateStudy: function () {
    return disassociateStudy;
  }
});
var OHIF;
module.watch(require("meteor/ohif:core"), {
  OHIF: function (v) {
    OHIF = v;
  }
}, 0);
var retrieveMeasurementFromSR, stowSRFromMeasurements;
module.watch(require("../utils/handleSR"), {
  retrieveMeasurementFromSR: function (v) {
    retrieveMeasurementFromSR = v;
  },
  stowSRFromMeasurements: function (v) {
    stowSRFromMeasurements = v;
  }
}, 1);
var getLatestSRSeries;
module.watch(require("../utils/srUtils"), {
  getLatestSRSeries: function (v) {
    getLatestSRSeries = v;
  }
}, 2);

var retrieveMeasurements = function (patientId, timepointIds) {
  OHIF.log.info('retrieveMeasurements');
  var latestSeries = getLatestSRSeries();
  if (!latestSeries) return Promise.resolve({});
  return retrieveMeasurementFromSR(latestSeries).then(function (value) {
    return {
      length: value
    };
  });
};

var storeMeasurements = function (measurementData, timepointIds) {
  OHIF.log.info('storeMeasurements');
  var server = OHIF.servers.getCurrentServer();

  if (!server || server.type !== 'dicomWeb') {
    return Promise.resolve({});
  }

  var studyInstanceUid = measurementData[Object.keys(measurementData)[0]][0].studyInstanceUid;
  return stowSRFromMeasurements(measurementData).then(function () {
    OHIF.studies.deleteStudyMetadataPromise(studyInstanceUid);
  });
};

var retrieveTimepoints = function (filter) {
  var studyInstanceUids = OHIF.viewer.StudyMetadataList.all().map(function (study) {
    return study.getStudyInstanceUID();
  });
  OHIF.log.info('retrieveTimepoints');
  return Promise.resolve([{
    timepointType: 'baseline',
    timepointId: 'TimepointId',
    studyInstanceUids: studyInstanceUids,
    patientId: filter.patientId,
    earliestDate: new Date(),
    latestDate: new Date(),
    isLocked: false
  }]);
};

var storeTimepoints = function (timepointData) {
  OHIF.log.info('storeTimepoints');
  return Promise.resolve();
};

var updateTimepoint = function (timepointData, query) {
  OHIF.log.info('updateTimepoint');
  return Promise.resolve();
};

var removeTimepoint = function (timepointId) {
  OHIF.log.info('removeTimepoint');
  return Promise.resolve();
};

var disassociateStudy = function (timepointIds, studyInstanceUid) {
  return Promise.resolve();
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////

},"measurementTools.js":function(require,exports,module){

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                                         //
// packages/ohif_measurement-table/client/configuration/measurementTools.js                                //
//                                                                                                         //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                                                           //
module.export({
  measurementTools: function () {
    return measurementTools;
  }
});
var ToolGroupBaseSchema;
module.watch(require("../schema/toolGroupSchema"), {
  ToolGroupBaseSchema: function (v) {
    ToolGroupBaseSchema = v;
  }
}, 0);
var length;
module.watch(require("../schema/length"), {
  "default": function (v) {
    length = v;
  }
}, 1);
var ellipticalRoi;
module.watch(require("../schema/ellipticalRoi"), {
  "default": function (v) {
    ellipticalRoi = v;
  }
}, 2);
var rectangleRoi;
module.watch(require("../schema/rectangleRoi"), {
  "default": function (v) {
    rectangleRoi = v;
  }
}, 3);
var simpleAngle;
module.watch(require("../schema/simpleAngle"), {
  "default": function (v) {
    simpleAngle = v;
  }
}, 4);
var arrowAnnotate;
module.watch(require("../schema/arrowAnnotate"), {
  "default": function (v) {
    arrowAnnotate = v;
  }
}, 5);
var trackedTools = [length, ellipticalRoi, rectangleRoi, simpleAngle, arrowAnnotate];
var measurementTools = [{
  id: 'allTools',
  name: 'Measurements',
  childTools: trackedTools,
  schema: ToolGroupBaseSchema
}];
/////////////////////////////////////////////////////////////////////////////////////////////////////////////

}},"schema":{"arrowAnnotate.js":function(require,exports,module){

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                                         //
// packages/ohif_measurement-table/client/schema/arrowAnnotate.js                                          //
//                                                                                                         //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                                                           //
var SimpleSchema;
module.watch(require("meteor/aldeed:simple-schema"), {
  SimpleSchema: function (v) {
    SimpleSchema = v;
  }
}, 0);
var MeasurementSchemaTypes;
module.watch(require("meteor/ohif:measurements/both/schema/measurements"), {
  MeasurementSchemaTypes: function (v) {
    MeasurementSchemaTypes = v;
  }
}, 1);
var CornerstoneHandleSchema = MeasurementSchemaTypes.CornerstoneHandleSchema;
var handlesSchema = new SimpleSchema({
  start: {
    type: CornerstoneHandleSchema,
    label: 'Start'
  },
  end: {
    type: CornerstoneHandleSchema,
    label: 'End'
  },
  textBox: {
    type: CornerstoneHandleSchema,
    label: 'Text Box'
  }
});
var toolSchema = new SimpleSchema([MeasurementSchemaTypes.CornerstoneToolMeasurement, {
  handles: {
    type: handlesSchema,
    label: 'Handles'
  },
  measurementNumber: {
    type: Number,
    label: 'Measurement Number'
  },
  location: {
    type: String,
    label: 'Location',
    optional: true
  },
  description: {
    type: String,
    label: 'Description',
    optional: true
  },
  toolType: {
    type: String,
    label: 'Measurement Tool Type',
    defaultValue: 'arrowAnnotate'
  },
  text: {
    type: String,
    label: 'text',
    optional: true
  }
}]);

var displayFunction = function (data) {
  return data.text || '';
};

module.exportDefault({
  id: 'arrowAnnotate',
  name: 'ArrowAnnotate',
  toolGroup: 'allTools',
  cornerstoneToolType: 'arrowAnnotate',
  schema: toolSchema,
  options: {
    measurementTable: {
      displayFunction: displayFunction
    }
  }
});
/////////////////////////////////////////////////////////////////////////////////////////////////////////////

},"ellipticalRoi.js":function(require,exports,module){

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                                         //
// packages/ohif_measurement-table/client/schema/ellipticalRoi.js                                          //
//                                                                                                         //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                                                           //
var SimpleSchema;
module.watch(require("meteor/aldeed:simple-schema"), {
  SimpleSchema: function (v) {
    SimpleSchema = v;
  }
}, 0);
var MeasurementSchemaTypes;
module.watch(require("meteor/ohif:measurements/both/schema/measurements"), {
  MeasurementSchemaTypes: function (v) {
    MeasurementSchemaTypes = v;
  }
}, 1);
var CornerstoneHandleSchema = MeasurementSchemaTypes.CornerstoneHandleSchema;
var handlesSchema = new SimpleSchema({
  start: {
    type: CornerstoneHandleSchema,
    label: 'Start'
  },
  end: {
    type: CornerstoneHandleSchema,
    label: 'End'
  },
  textBox: {
    type: CornerstoneHandleSchema,
    label: 'Text Box'
  }
});
var MeanStdDevSchema = new SimpleSchema({
  count: {
    type: Number,
    label: 'count',
    decimal: true
  },
  mean: {
    type: Number,
    label: 'mean',
    decimal: true
  },
  stdDev: {
    type: Number,
    label: 'stdDev',
    decimal: true
  },
  variance: {
    type: Number,
    label: 'variance',
    decimal: true
  }
});
var toolSchema = new SimpleSchema([MeasurementSchemaTypes.CornerstoneToolMeasurement, {
  handles: {
    type: handlesSchema,
    label: 'Handles'
  },
  measurementNumber: {
    type: Number,
    label: 'Measurement Number'
  },
  toolType: {
    type: String,
    label: 'Measurement Tool Type',
    defaultValue: 'ellipticalRoi'
  },
  location: {
    type: String,
    label: 'Location',
    optional: true
  },
  description: {
    type: String,
    label: 'Description',
    optional: true
  },
  area: {
    type: Number,
    label: 'Ellipse Area value',
    decimal: true,
    optional: true
  },
  meanStdDev: {
    type: MeanStdDevSchema,
    label: 'MeanStd Values',
    optional: true
  }
}]);

var displayFunction = function (data) {
  var meanValue = '';

  if (data.meanStdDev && data.meanStdDev.mean) {
    meanValue = data.meanStdDev.mean.toFixed(2) + ' HU';
  }

  return meanValue; // let meanValue = data.meanStdDev && data.meanStdDev.mean || 0;
  // return numberWithCommas(meanValue).toFixed(2) + ' HU';
  //return data.meanStdDev.mean.toFixed(2);
};

module.exportDefault({
  id: 'ellipticalRoi',
  name: 'Ellipse',
  toolGroup: 'allTools',
  cornerstoneToolType: 'ellipticalRoi',
  schema: toolSchema,
  options: {
    measurementTable: {
      displayFunction: displayFunction
    }
  }
});
/////////////////////////////////////////////////////////////////////////////////////////////////////////////

},"length.js":function(require,exports,module){

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                                         //
// packages/ohif_measurement-table/client/schema/length.js                                                 //
//                                                                                                         //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                                                           //
var SimpleSchema;
module.watch(require("meteor/aldeed:simple-schema"), {
  SimpleSchema: function (v) {
    SimpleSchema = v;
  }
}, 0);
var MeasurementSchemaTypes;
module.watch(require("meteor/ohif:measurements/both/schema/measurements"), {
  MeasurementSchemaTypes: function (v) {
    MeasurementSchemaTypes = v;
  }
}, 1);
var CornerstoneHandleSchema = MeasurementSchemaTypes.CornerstoneHandleSchema;
var handlesSchema = new SimpleSchema({
  start: {
    type: CornerstoneHandleSchema,
    label: 'Start'
  },
  end: {
    type: CornerstoneHandleSchema,
    label: 'End'
  },
  textBox: {
    type: CornerstoneHandleSchema,
    label: 'Text Box'
  }
});
var toolSchema = new SimpleSchema([MeasurementSchemaTypes.CornerstoneToolMeasurement, {
  handles: {
    type: handlesSchema,
    label: 'Handles'
  },
  measurementNumber: {
    type: Number,
    label: 'Measurement Number'
  },
  location: {
    type: String,
    label: 'Location',
    optional: true
  },
  description: {
    type: String,
    label: 'Description',
    optional: true
  },
  toolType: {
    type: String,
    label: 'Measurement Tool Type',
    defaultValue: 'length'
  },
  length: {
    type: Number,
    label: 'Length',
    optional: true,
    decimal: true
  }
}]);

var displayFunction = function (data) {
  var lengthValue = '';

  if (data.length) {
    lengthValue = data.length.toFixed(2) + ' mm';
  }

  return lengthValue;
};

module.exportDefault({
  id: 'length',
  name: 'Length',
  toolGroup: 'allTools',
  cornerstoneToolType: 'length',
  schema: toolSchema,
  options: {
    measurementTable: {
      displayFunction: displayFunction
    }
  }
});
/////////////////////////////////////////////////////////////////////////////////////////////////////////////

},"rectangleRoi.js":function(require,exports,module){

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                                         //
// packages/ohif_measurement-table/client/schema/rectangleRoi.js                                           //
//                                                                                                         //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                                                           //
var SimpleSchema;
module.watch(require("meteor/aldeed:simple-schema"), {
  SimpleSchema: function (v) {
    SimpleSchema = v;
  }
}, 0);
var MeasurementSchemaTypes;
module.watch(require("meteor/ohif:measurements/both/schema/measurements"), {
  MeasurementSchemaTypes: function (v) {
    MeasurementSchemaTypes = v;
  }
}, 1);
var CornerstoneHandleSchema = MeasurementSchemaTypes.CornerstoneHandleSchema;
var handlesSchema = new SimpleSchema({
  start: {
    type: CornerstoneHandleSchema,
    label: 'Start'
  },
  end: {
    type: CornerstoneHandleSchema,
    label: 'End'
  },
  textBox: {
    type: CornerstoneHandleSchema,
    label: 'Text Box'
  }
});
var MeanStdDevSchema = new SimpleSchema({
  count: {
    type: Number,
    label: 'count',
    decimal: true
  },
  mean: {
    type: Number,
    label: 'mean',
    decimal: true
  },
  stdDev: {
    type: Number,
    label: 'stdDev',
    decimal: true
  },
  variance: {
    type: Number,
    label: 'variance',
    decimal: true
  }
});
var toolSchema = new SimpleSchema([MeasurementSchemaTypes.CornerstoneToolMeasurement, {
  handles: {
    type: handlesSchema,
    label: 'Handles'
  },
  measurementNumber: {
    type: Number,
    label: 'Measurement Number'
  },
  toolType: {
    type: String,
    label: 'Measurement Tool Type',
    defaultValue: 'rectangleRoi'
  },
  location: {
    type: String,
    label: 'Location',
    optional: true
  },
  description: {
    type: String,
    label: 'Description',
    optional: true
  },
  area: {
    type: Number,
    label: 'Rectangle Area value',
    decimal: true,
    optional: true
  },
  meanStdDev: {
    type: MeanStdDevSchema,
    label: 'MeanStd Values',
    optional: true
  }
}]);

var displayFunction = function (data) {
  var meanValue = '';

  if (data.meanStdDev && data.meanStdDev.mean) {
    meanValue = data.meanStdDev.mean.toFixed(2) + ' HU';
  }

  return meanValue;
};

module.exportDefault({
  id: 'rectangleRoi',
  name: 'Rectangle',
  toolGroup: 'allTools',
  cornerstoneToolType: 'rectangleRoi',
  schema: toolSchema,
  options: {
    measurementTable: {
      displayFunction: displayFunction
    }
  }
});
/////////////////////////////////////////////////////////////////////////////////////////////////////////////

},"simpleAngle.js":function(require,exports,module){

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                                         //
// packages/ohif_measurement-table/client/schema/simpleAngle.js                                            //
//                                                                                                         //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                                                           //
var SimpleSchema;
module.watch(require("meteor/aldeed:simple-schema"), {
  SimpleSchema: function (v) {
    SimpleSchema = v;
  }
}, 0);
var MeasurementSchemaTypes;
module.watch(require("meteor/ohif:measurements/both/schema/measurements"), {
  MeasurementSchemaTypes: function (v) {
    MeasurementSchemaTypes = v;
  }
}, 1);
var CornerstoneHandleSchema = MeasurementSchemaTypes.CornerstoneHandleSchema;
var handlesSchema = new SimpleSchema({
  start: {
    type: CornerstoneHandleSchema,
    label: 'Start'
  },
  middle: {
    type: CornerstoneHandleSchema,
    label: 'Middle'
  },
  end: {
    type: CornerstoneHandleSchema,
    label: 'End'
  },
  textBox: {
    type: CornerstoneHandleSchema,
    label: 'Text Box'
  }
});
var toolSchema = new SimpleSchema([MeasurementSchemaTypes.CornerstoneToolMeasurement, {
  handles: {
    type: handlesSchema,
    label: 'Handles'
  },
  measurementNumber: {
    type: Number,
    label: 'Measurement Number'
  },
  location: {
    type: String,
    label: 'Location',
    optional: true
  },
  description: {
    type: String,
    label: 'Description',
    optional: true
  },
  toolType: {
    type: String,
    label: 'Measurement Tool Type',
    defaultValue: 'simpleAngle'
  },
  rAngle: {
    type: Number,
    label: 'Angle',
    optional: true,
    decimal: true
  }
}]);

var displayFunction = function (data) {
  var text = '';

  if (data.rAngle) {
    text = data.rAngle.toFixed(2) + String.fromCharCode(parseInt('00B0', 16));
  }

  return text;
};

module.exportDefault({
  id: 'simpleAngle',
  name: 'SimpleAngle',
  toolGroup: 'allTools',
  cornerstoneToolType: 'simpleAngle',
  schema: toolSchema,
  options: {
    measurementTable: {
      displayFunction: displayFunction
    }
  }
});
/////////////////////////////////////////////////////////////////////////////////////////////////////////////

},"toolGroupSchema.js":function(require,exports,module){

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                                         //
// packages/ohif_measurement-table/client/schema/toolGroupSchema.js                                        //
//                                                                                                         //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                                                           //
module.export({
  ToolGroupBaseSchema: function () {
    return ToolGroupBaseSchema;
  }
});
var SimpleSchema;
module.watch(require("meteor/aldeed:simple-schema"), {
  SimpleSchema: function (v) {
    SimpleSchema = v;
  }
}, 0);
var ToolGroupBaseSchema = new SimpleSchema({
  toolId: {
    type: String,
    label: 'Tool ID',
    optional: true
  },
  toolItemId: {
    type: String,
    label: 'Tool Item ID',
    optional: true
  },
  createdAt: {
    type: Date
  },
  studyInstanceUid: {
    type: String,
    label: 'Study Instance UID'
  },
  timepointId: {
    type: String,
    label: 'Timepoint ID'
  },
  measurementNumber: {
    type: Number,
    label: 'Measurement Number'
  }
});
/////////////////////////////////////////////////////////////////////////////////////////////////////////////

}},"utils":{"getLengthMeasurementData.js":function(require,exports,module){

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                                         //
// packages/ohif_measurement-table/client/utils/getLengthMeasurementData.js                                //
//                                                                                                         //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                                                           //
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));

var OHIF;
module.watch(require("meteor/ohif:core"), {
  OHIF: function (v) {
    OHIF = v;
  }
}, 0);
var cornerstone;
module.watch(require("meteor/ohif:cornerstone"), {
  cornerstone: function (v) {
    cornerstone = v;
  }
}, 1);
var getInstanceMetadata;
module.watch(require("./srUtils"), {
  getInstanceMetadata: function (v) {
    getInstanceMetadata = v;
  }
}, 2);
module.exportDefault(getLengthMeasurementData = function (lengthMeasurementContent, displaySets) {
  var lengthStates = [];
  lengthMeasurementContent.forEach(function (groupItemContent) {
    var lengthContent = groupItemContent.ContentSequence;
    var reference = lengthContent.ContentSequence.ReferencedSOPSequence;
    var lengthState = {};
    lengthState.measuredValue = groupItemContent.MeasuredValueSequence.NumericValue;
    lengthState.handles = {
      start: {},
      end: {}
    };

    var _lengthContent$Graphi = (0, _slicedToArray2.default)(lengthContent.GraphicData, 4);

    lengthState.handles.start.x = _lengthContent$Graphi[0];
    lengthState.handles.start.y = _lengthContent$Graphi[1];
    lengthState.handles.end.x = _lengthContent$Graphi[2];
    lengthState.handles.end.y = _lengthContent$Graphi[3];
    // TODO: Save textbox position in GraphicData?
    lengthState.handles.textBox = {
      hasMoved: false,
      movesIndependently: false,
      drawnIndependently: true,
      allowedOutsideImage: true,
      hasBoundingBox: true
    };
    lengthState.ReferencedInstanceUID = reference.ReferencedSOPInstanceUID;

    if (reference.ReferencedFrameNumber && reference.ReferencedFrameNumber !== 'NaN') {
      lengthState.ReferencedFrameNumber = reference.ReferencedFrameNumber;
    } else {
      lengthState.ReferencedFrameNumber = 0;
    }

    lengthStates.push(lengthState);
  });
  var lengthMeasurementData = [];
  var measurementNumber = 0;
  lengthStates.forEach(function (lengthState) {
    var sopInstanceUid = lengthState.ReferencedInstanceUID;
    var instanceMetadata = getInstanceMetadata(displaySets, sopInstanceUid);
    var imageId = OHIF.viewerbase.getImageId(instanceMetadata);

    if (!imageId) {
      return;
    }

    var studyInstanceUid = cornerstone.metaData.get('study', imageId).studyInstanceUid;
    var seriesInstanceUid = cornerstone.metaData.get('series', imageId).seriesInstanceUid;
    var patientId = instanceMetadata._study.patientId;
    var frameIndex = lengthState.ReferencedFrameNumber;
    var imagePath = [studyInstanceUid, seriesInstanceUid, sopInstanceUid, frameIndex].join('_');
    var measurement = {
      handles: lengthState.handles,
      length: lengthState.measuredValue,
      imageId: imageId,
      imagePath: imagePath,
      sopInstanceUid: sopInstanceUid,
      seriesInstanceUid: seriesInstanceUid,
      studyInstanceUid: studyInstanceUid,
      patientId: patientId,
      frameIndex: frameIndex,
      measurementNumber: ++measurementNumber,
      userId: 'UserID',
      timepointId: OHIF.viewer.data.currentTimepointId,
      toolType: 'length',
      _id: imageId + measurementNumber
    };
    lengthMeasurementData.push(measurement);
  });
  return lengthMeasurementData;
});
/////////////////////////////////////////////////////////////////////////////////////////////////////////////

},"getLengthMeasurementGroupContentItem.js":function(require,exports,module){

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                                         //
// packages/ohif_measurement-table/client/utils/getLengthMeasurementGroupContentItem.js                    //
//                                                                                                         //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                                                           //
module.exportDefault(measurementGroupContentItem = function (measurement, sopClassUid) {
  var handles = measurement.handles,
      length = measurement.length,
      frameIndex = measurement.frameIndex,
      sopInstanceUid = measurement.sopInstanceUid;
  var measurementContentItem = [{
    RelationshipType: 'HAS OBS CONTEXT',
    ValueType: 'TEXT',
    ConceptNameCodeSequence: {
      CodeValue: '112039',
      CodingSchemeDesignator: 'DCM',
      CodeMeaning: 'Tracking Identifier'
    },
    TextValue: 'web annotation'
  }, {
    RelationshipType: 'HAS OBS CONTEXT',
    ValueType: 'UIDREF',
    ConceptNameCodeSequence: {
      CodeValue: '112040',
      CodingSchemeDesignator: 'DCM',
      CodeMeaning: 'Tracking Unique Identifier'
    },
    UID: dcmjs.data.DicomMetaDictionary.uid()
  }, {
    RelationshipType: 'CONTAINS',
    ValueType: 'CODE',
    ConceptNameCodeSequence: {
      CodeValue: '121071',
      CodingSchemeDesignator: 'DCM',
      CodeMeaning: 'Finding'
    },
    ConceptCodeSequence: {
      CodeValue: 'SAMPLEFINDING',
      CodingSchemeDesignator: '99dcmjs',
      CodeMeaning: 'Sample Finding'
    }
  }, {
    RelationshipType: 'CONTAINS',
    ValueType: 'NUM',
    ConceptNameCodeSequence: {
      CodeValue: 'G-D7FE',
      CodingSchemeDesignator: 'SRT',
      CodeMeaning: 'Length'
    },
    MeasuredValueSequence: {
      MeasurementUnitsCodeSequence: {
        CodeValue: 'mm',
        CodingSchemeDesignator: 'UCUM',
        CodingSchemeVersion: '1.4',
        CodeMeaning: 'millimeter'
      },
      NumericValue: length
    },
    ContentSequence: {
      RelationshipType: 'INFERRED FROM',
      ValueType: 'SCOORD',
      GraphicType: 'POLYLINE',
      GraphicData: [handles.start.x, handles.start.y, handles.end.x, handles.end.y],
      ContentSequence: {
        RelationshipType: 'SELECTED FROM',
        ValueType: 'IMAGE',
        ReferencedSOPSequence: {
          ReferencedSOPClassUID: sopClassUid,
          ReferencedSOPInstanceUID: sopInstanceUid,
          ReferencedFrameNumber: frameIndex
        }
      }
    }
  }];
  return measurementContentItem;
});
/////////////////////////////////////////////////////////////////////////////////////////////////////////////

},"handleSR.js":function(require,exports,module){

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                                         //
// packages/ohif_measurement-table/client/utils/handleSR.js                                                //
//                                                                                                         //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                                                           //
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

module.export({
  retrieveMeasurementFromSR: function () {
    return retrieveMeasurementFromSR;
  },
  stowSRFromMeasurements: function () {
    return stowSRFromMeasurements;
  }
});
var dcmjs;
module.watch(require("meteor/ohif:cornerstone"), {
  dcmjs: function (v) {
    dcmjs = v;
  }
}, 0);
var retrieveDataFromSR;
module.watch(require("./retrieveDataFromSR"), {
  "default": function (v) {
    retrieveDataFromSR = v;
  }
}, 1);
var retrieveDataFromMeasurements;
module.watch(require("./retrieveDataFromMeasurements"), {
  "default": function (v) {
    retrieveDataFromMeasurements = v;
  }
}, 2);
var multipartEncode;
module.watch(require("./srUtils"), {
  multipartEncode: function (v) {
    multipartEncode = v;
  }
}, 3);

var retrieveMeasurementFromSR = function () {
  function _callee(series) {
    var instance, options, url, result, data, measurementData;
    return _regenerator.default.async(function () {
      function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              instance = series.getFirstInstance();
              options = {
                method: 'GET',
                responseType: 'arraybuffer'
              };
              url = instance.getDataProperty('wadouri');
              _context.prev = 3;
              _context.next = 6;
              return _regenerator.default.awrap(DICOMWeb.makeRequest(url, options));

            case 6:
              result = _context.sent;
              _context.next = 9;
              return _regenerator.default.awrap(result.arrayBuffer());

            case 9:
              data = _context.sent;
              measurementData = retrieveDataFromSR(data);
              return _context.abrupt("return", Promise.resolve(measurementData));

            case 14:
              _context.prev = 14;
              _context.t0 = _context["catch"](3);
              return _context.abrupt("return", Promise.reject(_context.t0));

            case 17:
            case "end":
              return _context.stop();
          }
        }
      }

      return _callee$;
    }(), null, this, [[3, 14]]);
  }

  return _callee;
}();
/**
 * Retrieve the DICOMWeb STOW-RS URL for the current server.
 *
 * See ftp://medical.nema.org/medical/dicom/current/output/html/part18.html#sect_6.6.1.1
 *
 * @return {string|null} The URL, rerouted to the proxy if the WADOProxy is enabled.
 */


function getStowRsUrl() {
  var server = OHIF.servers.getCurrentServer();
  var url = server.wadoRoot + "/studies";
  return WADOProxy.convertURL(url, server);
}

var stowSRFromMeasurements = function () {
  function _callee2(measurements) {
    var serverUrl, reportDataset, boundary, options;
    return _regenerator.default.async(function () {
      function _callee2$(_context2) {
        while (1) {
          switch (_context2.prev = _context2.next) {
            case 0:
              serverUrl = getStowRsUrl();
              reportDataset = retrieveDataFromMeasurements(measurements);
              boundary = dcmjs.data.DicomMetaDictionary.uid();
              options = {
                method: 'POST',
                body: multipartEncode(reportDataset, boundary),
                headers: {
                  'Content-Type': "multipart/related; type=application/dicom; boundary=" + boundary
                }
              };
              _context2.prev = 4;
              _context2.next = 7;
              return _regenerator.default.awrap(DICOMWeb.makeRequest(serverUrl, options));

            case 7:
              return _context2.abrupt("return", Promise.resolve());

            case 10:
              _context2.prev = 10;
              _context2.t0 = _context2["catch"](4);
              return _context2.abrupt("return", Promise.reject(_context2.t0));

            case 13:
            case "end":
              return _context2.stop();
          }
        }
      }

      return _callee2$;
    }(), null, this, [[4, 10]]);
  }

  return _callee2;
}();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////

},"retrieveDataFromMeasurements.js":function(require,exports,module){

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                                         //
// packages/ohif_measurement-table/client/utils/retrieveDataFromMeasurements.js                            //
//                                                                                                         //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                                                           //
var dcmjs;
module.watch(require("meteor/ohif:cornerstone"), {
  dcmjs: function (v) {
    dcmjs = v;
  }
}, 0);
var getInstanceMetadata, getAllDisplaySets;
module.watch(require("./srUtils"), {
  getInstanceMetadata: function (v) {
    getInstanceMetadata = v;
  },
  getAllDisplaySets: function (v) {
    getAllDisplaySets = v;
  }
}, 1);
var getLengthMeasurementGroupContentItem;
module.watch(require("./getLengthMeasurementGroupContentItem"), {
  "default": function (v) {
    getLengthMeasurementGroupContentItem = v;
  }
}, 2);
module.exportDefault(retrieveDataFromMeasurements = function (measurements) {
  var _measurements$allTool = measurements.allTools[0],
      studyInstanceUid = _measurements$allTool.studyInstanceUid,
      seriesInstanceUid = _measurements$allTool.seriesInstanceUid,
      sopInstanceUid = _measurements$allTool.sopInstanceUid;
  var displaySets = getAllDisplaySets();
  var instanceMetadata = getInstanceMetadata(displaySets, sopInstanceUid);
  var sopClassUid = instanceMetadata._data.sopClassUid; // TODO: figure out what is needed to make a dcmjs dataset from
  // information available in the viewer.  Apparently the raw dicom is not available
  // directly.

  var derivationSourceDataset = {
    StudyInstanceUID: studyInstanceUid,
    SeriesInstanceUID: seriesInstanceUid,
    SOPInstanceUID: sopInstanceUid,
    SOPClassUID: sopClassUid
  };
  report = new dcmjs.derivations.StructuredReport([derivationSourceDataset]);
  dataset = report.dataset; // TODO: what is the correct metaheader
  // http://dicom.nema.org/medical/Dicom/current/output/chtml/part10/chapter_7.html
  // TODO: move meta creation to dcmjs

  var fileMetaInformationVersionArray = new Uint16Array(1);
  fileMetaInformationVersionArray[0] = 1;
  dataset._meta = {
    FileMetaInformationVersion: fileMetaInformationVersionArray.buffer,
    MediaStorageSOPClassUID: dataset.SOPClassUID,
    MediaStorageSOPInstanceUID: dataset.SOPInstanceUID,
    TransferSyntaxUID: "1.2.840.10008.1.2.1",
    // Explicit little endian (always for dcmjs?)
    ImplementationClassUID: dcmjs.data.DicomMetaDictionary.uid(),
    // TODO: could be git hash or other valid id
    ImplementationVersionName: "OHIFViewer"
  }; // TODO: factor out a lot of this back into dcmjs for use in both
  // the example and in the Viewer

  var measurementGroupContentSequence = [];

  for (var _iterator = measurements.allTools, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
    if (_isArray) {
      if (_i >= _iterator.length) break;
      measurement = _iterator[_i++];
    } else {
      _i = _iterator.next();
      if (_i.done) break;
      measurement = _i.value;
    }

    if (measurement.toolType === 'length') {
      measurementGroupContentSequence.push.apply(measurementGroupContentSequence, getLengthMeasurementGroupContentItem(measurement, sopClassUid));
    }
  } // TODO: make a TID1550 derivation as an SR subclass


  dataset = Object.assign(dataset, {
    ConceptNameCodeSequence: {
      CodeValue: '126000',
      CodingSchemeDesignator: 'DCM',
      CodeMeaning: 'Imaging Measurement Report'
    },
    ContinuityOfContent: 'SEPARATE',
    PerformedProcedureCodeSequence: [],
    CompletionFlag: 'COMPLETE',
    VerificationFlag: 'UNVERIFIED',
    ReferencedPerformedProcedureStepSequence: [],
    InstanceNumber: 1,
    CurrentRequestedProcedureEvidenceSequence: {
      StudyInstanceUID: dataset.StudyInstanceUID,
      ReferencedSeriesSequence: {
        SeriesInstanceUID: dataset.SeriesInstanceUID,
        ReferencedSOPSequence: {
          ReferencedSOPClassUID: derivationSourceDataset.SOPClassUID,
          ReferencedSOPInstanceUID: derivationSourceDataset.SOPInstanceUID
        }
      }
    },
    CodingSchemeIdentificationSequence: {
      CodingSchemeDesignator: "99dcmjs",
      CodingSchemeName: "Codes used for dcmjs",
      CodingSchemeVersion: "0",
      CodingSchemeResponsibleOrganization: "https://github.com/pieper/dcmjs"
    },
    ContentTemplateSequence: {
      MappingResource: 'DCMR',
      TemplateIdentifier: '1500'
    },
    ContentSequence: [{
      RelationshipType: 'HAS CONCEPT MOD',
      ValueType: 'CODE',
      ConceptNameCodeSequence: {
        CodeValue: '121049',
        CodingSchemeDesignator: 'DCM',
        CodeMeaning: 'Language of Content Item and Descendants'
      },
      ConceptCodeSequence: {
        CodeValue: 'eng',
        CodingSchemeDesignator: 'RFC3066',
        CodeMeaning: 'English'
      },
      ContentSequence: {
        RelationshipType: 'HAS CONCEPT MOD',
        ValueType: 'CODE',
        ConceptNameCodeSequence: {
          CodeValue: '121046',
          CodingSchemeDesignator: 'DCM',
          CodeMeaning: 'Country of Language'
        },
        ConceptCodeSequence: {
          CodeValue: 'US',
          CodingSchemeDesignator: 'ISO3166_1',
          CodeMeaning: 'United States'
        }
      }
    }, {
      RelationshipType: 'HAS OBS CONTEXT',
      ValueType: 'PNAME',
      ConceptNameCodeSequence: {
        CodeValue: '121008',
        CodingSchemeDesignator: 'DCM',
        CodeMeaning: 'Person Observer Name'
      },
      PersonName: 'user^web' // TODO: these can be options argument for constructor

    }, {
      RelationshipType: 'HAS OBS CONTEXT',
      ValueType: 'TEXT',
      ConceptNameCodeSequence: {
        CodeValue: 'RP-100006',
        CodingSchemeDesignator: '99dcmjs',
        CodeMeaning: "Person Observer's Login Name"
      },
      TextValue: 'user'
    }, {
      RelationshipType: 'HAS CONCEPT MOD',
      ValueType: 'CODE',
      ConceptNameCodeSequence: {
        CodeValue: '121058',
        CodingSchemeDesignator: 'DCM',
        CodeMeaning: 'Procedure reported'
      },
      ConceptCodeSequence: {
        CodeValue: '1',
        CodingSchemeDesignator: '99dcmjs',
        CodeMeaning: 'Unknown procedure'
      }
    }, {
      RelationshipType: 'CONTAINS',
      ValueType: 'CONTAINER',
      ConceptNameCodeSequence: {
        CodeValue: '111028',
        CodingSchemeDesignator: 'DCM',
        CodeMeaning: 'Image Library'
      },
      ContinuityOfContent: 'SEPARATE',
      ContentSequence: {
        RelationshipType: 'CONTAINS',
        ValueType: 'CONTAINER',
        ConceptNameCodeSequence: {
          CodeValue: '126200',
          CodingSchemeDesignator: 'DCM',
          CodeMeaning: 'Image Library Group'
        },
        ContinuityOfContent: 'SEPARATE',
        ContentSequence: {
          RelationshipType: 'CONTAINS',
          ValueType: 'IMAGE',
          ReferencedSOPSequence: {
            // TODO: this should refer to the UIDs extracted from the toolState / instance info
            ReferencedSOPClassUID: dataset.SOPClassUID,
            ReferencedSOPInstanceUID: dataset.SOPInstanceUID
          }
        }
      }
    }, {
      RelationshipType: 'CONTAINS',
      ValueType: 'CONTAINER',
      ConceptNameCodeSequence: {
        CodeValue: '126010',
        CodingSchemeDesignator: 'DCM',
        CodeMeaning: 'Imaging Measurements' // TODO: would be nice to abstract the code sequences (in a dictionary? a service?)

      },
      ContinuityOfContent: 'SEPARATE',
      ContentSequence: {
        RelationshipType: 'CONTAINS',
        ValueType: 'CONTAINER',
        ConceptNameCodeSequence: {
          CodeValue: '125007',
          CodingSchemeDesignator: 'DCM',
          CodeMeaning: 'Measurement Group'
        },
        ContinuityOfContent: 'SEPARATE',
        ContentSequence: measurementGroupContentSequence
      }
    }]
  });
  return dataset;
});
/////////////////////////////////////////////////////////////////////////////////////////////////////////////

},"retrieveDataFromSR.js":function(require,exports,module){

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                                         //
// packages/ohif_measurement-table/client/utils/retrieveDataFromSR.js                                      //
//                                                                                                         //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                                                           //
var dcmjs;
module.watch(require("meteor/ohif:cornerstone"), {
  dcmjs: function (v) {
    dcmjs = v;
  }
}, 0);
var getLengthMeasurementData;
module.watch(require("./getLengthMeasurementData"), {
  "default": function (v) {
    getLengthMeasurementData = v;
  }
}, 1);
var toArray, codeMeaningEquals, getAllDisplaySets;
module.watch(require("./srUtils"), {
  toArray: function (v) {
    toArray = v;
  },
  codeMeaningEquals: function (v) {
    codeMeaningEquals = v;
  },
  getAllDisplaySets: function (v) {
    getAllDisplaySets = v;
  }
}, 2);

var imagingMeasurementsToMeasurementData = function (dataset, displaySets) {
  // Identify the Imaging Measurements
  var imagingMeasurementContent = toArray(dataset.ContentSequence).find(codeMeaningEquals("Imaging Measurements")); // Retrieve the Measurements themselves

  var measurementGroupContent = toArray(imagingMeasurementContent.ContentSequence).find(codeMeaningEquals("Measurement Group")); // For now, bail out if the dataset is not a TID1500 SR with length measurements
  // TODO: generalize to the various kinds of report
  // TODO: generalize to the kinds of measurements the Viewer supports

  if (dataset.ContentTemplateSequence.TemplateIdentifier !== "1500") {
    OHIF.log.warn("This package can currently only interpret DICOM SR TID 1500");
    return {};
  } // Filter to find Length measurements in the Structured Report


  var lengthMeasurementContent = toArray(measurementGroupContent.ContentSequence).filter(codeMeaningEquals("Length")); // Retrieve Length Measurement Data

  return getLengthMeasurementData(lengthMeasurementContent, displaySets);
};

module.exportDefault(retrieveDataFromSR = function (Part10SRArrayBuffer) {
  var allDisplaySets = getAllDisplaySets(); // get the dicom data as an Object

  var dicomData = dcmjs.data.DicomMessage.readFile(Part10SRArrayBuffer);
  var dataset = dcmjs.data.DicomMetaDictionary.naturalizeDataset(dicomData.dict); // Convert the SR into the kind of object the Measurements package is expecting

  return imagingMeasurementsToMeasurementData(dataset, allDisplaySets);
});
/////////////////////////////////////////////////////////////////////////////////////////////////////////////

},"srUtils.js":function(require,exports,module){

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                                         //
// packages/ohif_measurement-table/client/utils/srUtils.js                                                 //
//                                                                                                         //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                                                           //
module.export({
  codeMeaningEquals: function () {
    return codeMeaningEquals;
  },
  getAllDisplaySets: function () {
    return getAllDisplaySets;
  },
  getInstanceMetadata: function () {
    return getInstanceMetadata;
  },
  getLatestSRSeries: function () {
    return getLatestSRSeries;
  },
  multipartEncode: function () {
    return multipartEncode;
  },
  toArray: function () {
    return toArray;
  }
});
var dcmjs;
module.watch(require("meteor/ohif:cornerstone"), {
  dcmjs: function (v) {
    dcmjs = v;
  }
}, 0);
var supportedSopClassUIDs = ['1.2.840.10008.5.1.4.1.1.88.22'];

var toArray = function (x) {
  return x.constructor.name === "Array" ? x : [x];
};

var codeMeaningEquals = function (codeMeaningName) {
  return function (contentItem) {
    return contentItem.ConceptNameCodeSequence.CodeMeaning === codeMeaningName;
  };
};

var getAllDisplaySets = function () {
  var allStudies = OHIF.viewer.Studies.all();
  var allDisplaySets = [];
  allStudies.forEach(function (study) {
    allDisplaySets = allDisplaySets.concat(study.displaySets);
  });
  return allDisplaySets;
};

var getInstanceMetadata = function (displaySets, sopInstanceUid) {
  var instance; // Use Array.some so that this loop stops when the internal loop
  // has found the correct instance

  displaySets.some(function (displaySet) {
    // Search the display set to find the instance metadata for
    return displaySet.images.find(function (instanceMetadata) {
      if (instanceMetadata._sopInstanceUID === sopInstanceUid) {
        instance = instanceMetadata;
        return true;
      }
    });
  });
  return instance;
};

var getLatestSRSeries = function () {
  var allStudies = OHIF.viewer.StudyMetadataList.all();
  var latestSeries;
  allStudies.forEach(function (study) {
    study.getSeries().forEach(function (series) {
      var firstInstance = series.getFirstInstance();
      var sopClassUid = firstInstance._instance.sopClassUid;

      if (supportedSopClassUIDs.includes(sopClassUid)) {
        if (!latestSeries) {
          latestSeries = series;
        } else if (series._data.seriesDate > latestSeries._data.seriesDate || series._data.seriesDate === latestSeries._data.seriesDate && series._data.seriesTime > latestSeries._data.seriesTime) {
          latestSeries = series;
        }
      }
    });
  });
  return latestSeries;
};

var stringToArray = function (string) {
  return Uint8Array.from(Array.from(string).map(function (letter) {
    return letter.charCodeAt(0);
  }));
};

var multipartEncode = function (dataset, boundary) {
  var denaturalizedMetaheader = dcmjs.data.DicomMetaDictionary.denaturalizeDataset(dataset._meta);
  var dicomDict = new dcmjs.data.DicomDict(denaturalizedMetaheader);
  dicomDict.dict = dcmjs.data.DicomMetaDictionary.denaturalizeDataset(dataset);
  var part10Buffer = dicomDict.write();
  var header = "\r\n--" + boundary + "\r\nContent-Type: application/dicom\r\n\r\n";
  var footer = "\r\n--" + boundary + "--";
  headerArray = stringToArray(header);
  contentArray = new Uint8Array(part10Buffer);
  footerArray = stringToArray(footer);
  var multipartArray = new Uint8Array(headerArray.length + contentArray.length + footerArray.length);
  multipartArray.set(headerArray, 0);
  multipartArray.set(contentArray, headerArray.length);
  multipartArray.set(footerArray, headerArray.length + contentArray.length);
  return multipartArray.buffer;
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////

}}}}}}},{
  "extensions": [
    ".js",
    ".json"
  ]
});
var exports = require("/node_modules/meteor/ohif:measurement-table/client/index.js");

/* Exports */
Package._define("ohif:measurement-table", exports);

})();