feat: 🎸 DICOM SR STOW on MeasurementAPI (#954)

* feat: 🎸 DICOM SR STOW on MeasurementAPI Closes: #758 * feat: 🎸 Adding the dataExchance from DICOM SR * feat: 🎸 Fix some issues and get the retrieve measurements working * feat: 🎸 Preventing measurement tool helpers to broke because the data is not Number (it comes as string from dcmjs) * feat: 🎸 Adding a button to start testing SATE functionality * feat: 🎸Small fixes into the code * feat: 🎸 MAke sure we get latest SR in the study, even on lazyLoad mode * Revert "feat: 🎸 Preventing measurement tool helpers to broke because the data is not Number (it comes as string from dcmjs)" This reverts commit 4b3a1efb5810487d2319826fd59c03d779882b5e. * feat: 🎸 Make sure after sync we update the viewports and also that annotation tools are set to passive, so it can be drawn in the viewports * feat: 🎸 Remove console logs and start using OHIF.log * feat: 🎸 Refactor measurement table to use Snackbar service of messages and make sure we only show save button if server type is dicomWeb * feat: 🎸 Refactor to remove mocked wadoRoot and use server * Fix to expose error once we can't save the SR * Update DCMJS into latest dev version * Update dcmjs with latest fixes * Fix PR callouts * Logging error on MeasurementReport creation * Preventing from breaking on non supported tools and also warning that some toolType is not sopported * Small error message update * Expose better the errors and when we have unsopported tools into the measurements * Renaming variable * Expose dcmjs tool support check * Change the way we warn the unsupportedTools * Adding style to the button * Small change on button style * Fix git conflicts * Fix after merge with latest master * Fix after merge with master, btn was not clickable * Fixing callouts * Adding util functions into files and refactor with JSDocs * Refactoring code, adding some basic JSDocs * Bump dcmjs with latest version and fixes * JSDocs and small refactors * yarn lock file after dcmjs update * Remove unused parameters * Registering a plain copy of server into measurementAPI * Small refactor * Start changing from toolType to toolName * Rename a function to get instanceMetadata * Adding error if server is not DICOMWeb on retrieve * Move snackbar outside of UI component and use UINotificationService * Refactor and JSDocs * Small fixes on JSDocs (style) * Remove unused import * Improve JSDocs on MeasurementApi * Remove refactor leftover * Improve JSDocs and propTypes * JSDocs and small refactors
2019-12-11 11:14:01 -05:00
1 parent 5cda5159da
commit ebe1af8d4f
@@ -3,12 +3,20 @@ import { MeasurementTable } from '@ohif/ui';
 import OHIF from '@ohif/core';
 import moment from 'moment';
 import cornerstone from 'cornerstone-core';
+import DICOMSR from './../../lib/DICOMSR';

 import jumpToRowItem from './jumpToRowItem.js';

 const { setViewportSpecificData } = OHIF.redux.actions;
 const { MeasurementApi } = OHIF.measurements;

+/**
+ * Takes a list of objects and a property and return the list grouped by the property
+ *
+ * @param {Array} list - The objects to be grouped by
+ * @param {string} props - The property to group the objects
+ * @returns {Object}
+ */
 function groupBy(list, props) {
  return list.reduce((a, b) => {
    (a[b[props]] = a[b[props]] || []).push(b);
@@ -16,16 +24,29 @@ function groupBy(list, props) {
  }, {});
 }

-function getAllTools() {
-  const config = OHIF.measurements.MeasurementApi.getConfiguration();
+/**
+ *  Takes a list of tools grouped and return all tools separately
+ *
+ * @param {Array} [toolGroups=[]] - The grouped tools
+ * @returns {Array} - The list of all tools on all groups
+ */
+function getAllTools(toolGroups = []) {
  let tools = [];
-  config.measurementTools.forEach(
+  toolGroups.forEach(
    toolGroup => (tools = tools.concat(toolGroup.childTools))
  );

  return tools;
 }

+/**
+ * Takes measurementData and build the measurement text to be used into the table
+ *
+ * @param {Object} [measurementData={}]
+ * @param {string} measurementData.location - The measurement location
+ * @param {string} measurementData.description - The measurement description
+ * @returns {string}
+ */
 function getMeasurementText(measurementData = {}) {
  const defaultText = '...';
  const { location = '', description = '' } = measurementData;
@@ -34,6 +55,14 @@ function getMeasurementText(measurementData = {}) {
  return result || defaultText;
 }

+/**
+ * Takes a list of measurements grouped by measurement numbers and return each measurement data by available timepoint
+ *
+ * @param {Array} measurementNumberList - The list of measurements
+ * @param {Array} timepoints - The list of available timepoints
+ * @param {Function} displayFunction - The function that builds the display text by each tool
+ * @returns
+ */
 function getDataForEachMeasurementNumber(
  measurementNumberList,
  timepoints,
@@ -56,10 +85,35 @@ function getDataForEachMeasurementNumber(
  return data;
 }

+/**
+ * Take a measurement toolName and return if any warnings
+ *
+ * @param {string} toolName - The tool name
+ * @returns {string}
+ */
+function getWarningsForMeasurement(toolName) {
+  const isToolSupported = DICOMSR.isToolSupported(toolName);
+
+  return {
+    hasWarnings: !isToolSupported,
+    warningTitle: isToolSupported ? '' : 'Unsupported Tool',
+    warningList: isToolSupported
+      ? []
+      : [`${toolName} cannot be persisted at this time`],
+  };
+}
+
+/**
+ * Take measurements from MeasurementAPI structure and convert into a measurementTable structure
+ *
+ * @param {Object} toolCollections - The list of all measurement grouped by groupTool and toolName
+ * @param {Array} timepoints - The list of available timepoints
+ * @returns
+ */
 function convertMeasurementsToTableData(toolCollections, timepoints) {
  const config = OHIF.measurements.MeasurementApi.getConfiguration();
  const toolGroups = config.measurementTools;
-  const tools = getAllTools();
+  const tools = getAllTools(toolGroups);

  const tableMeasurements = toolGroups.map(toolGroup => {
    return {
@@ -88,6 +142,12 @@ function convertMeasurementsToTableData(toolCollections, timepoints) {
      } = measurementData;
      const measurementId = measurementData._id;

+      const {
+        hasWarnings,
+        warningTitle,
+        warningList,
+      } = getWarningsForMeasurement(toolType);
+
      //check if all measurements with same measurementNumber will have same LABEL
      const tableMeasurement = {
        itemNumber: lesionNamingNumber,
@@ -96,10 +156,10 @@ function convertMeasurementsToTableData(toolCollections, timepoints) {
        measurementNumber,
        lesionNamingNumber,
        toolType,
-        hasWarnings: false, //TODO
-        warningTitle: '', //TODO
+        hasWarnings,
+        warningTitle,
+        warningList,
        isSplitLesion: false, //TODO
-        warningList: [], //TODO
        data: getDataForEachMeasurementNumber(
          measurementNumberList,
          timepoints,
@@ -126,6 +186,13 @@ function convertMeasurementsToTableData(toolCollections, timepoints) {
  return tableMeasurements;
 }

+/**
+ * Take a list of available timepoints and return a list header information for each timepoint
+ *
+ * @param {Array} timepoints - The list of available timepoints
+ * @param {string} timepoints[].latestDate - The date of the last study taken on the timepoint
+ * @returns {{label: string, key: string, date: string}[]}
+ */
 function convertTimepointsToTableData(timepoints) {
  if (!timepoints || !timepoints.length) {
    return [];
@@ -140,8 +207,28 @@ function convertTimepointsToTableData(timepoints) {
  ];
 }

+/**
+ *  Takes server type and return a function or undefined
+ *
+ * @param {string} serverType - The server type
+ * @returns {undefined|Function}
+ */
+function getSaveFunction(serverType) {
+  if (serverType === 'dicomWeb') {
+    return () => {
+      const measurementApi = OHIF.measurements.MeasurementApi.Instance;
+      const promise = measurementApi.storeMeasurements();
+      return promise;
+    };
+  }
+}
+
 const mapStateToProps = state => {
-  const { timepoints, measurements } = state.timepointManager;
+  const { timepointManager, servers } = state;
+  const { timepoints, measurements } = timepointManager;
+  const activeServer = servers.servers.find(a => a.active === true);
+  const saveFunction = getSaveFunction(activeServer.type);
+
  return {
    timepoints: convertTimepointsToTableData(timepoints),
    measurementCollection: convertMeasurementsToTableData(
@@ -150,6 +237,7 @@ const mapStateToProps = state => {
    ),
    timepointManager: state.timepointManager,
    viewports: state.viewports,
+    saveFunction,
  };
 };

@@ -265,10 +353,15 @@ const mapDispatchToProps = (dispatch, ownProps) => {
 };

 const mergeProps = (propsFromState, propsFromDispatch, ownProps) => {
+  const { timepoints, saveFunction, measurementCollection } = propsFromState;
+  const { onSaveComplete, selectedMeasurementNumber } = ownProps;
+
  return {
-    timepoints: propsFromState.timepoints,
-    measurementCollection: propsFromState.measurementCollection,
-    selectedMeasurementNumber: ownProps.selectedMeasurementNumber,
+    timepoints,
+    saveFunction,
+    measurementCollection,
+    onSaveComplete,
+    selectedMeasurementNumber,
    ...propsFromDispatch,
    onItemClick: (event, measurementData) => {
      // TODO: Add timepointId to .data for measurementData?
@@ -11,8 +11,9 @@ export default {
  preRegistration({ servicesManager, commandsManager, configuration = {} }) {
    init({ servicesManager, commandsManager, configuration });
  },
+
  getPanelModule({ servicesManager, commandsManager }) {
-    const { UILabellingFlowService } = servicesManager.services;
+    const { UILabellingFlowService, UINotificationService } = servicesManager.services;
    const ExtendedConnectedMeasurementTable = () => (
      <ConnectedMeasurementTable
        onRelabel={tool => {
@@ -38,6 +39,11 @@ export default {
            });
          }
        }}
+        onSaveComplete={message => {
+          if (UINotificationService) {
+            UINotificationService.show(message);
+          }
+        }}
      />
    );
    return {
@@ -1,13 +1,20 @@
-import { connect } from "react-redux";
-import Viewer from "./Viewer.js";
-import OHIF from "@ohif/core";
+import { connect } from 'react-redux';
+import Viewer from './Viewer.js';
+import OHIF from '@ohif/core';

 const { setTimepoints, setMeasurements } = OHIF.redux.actions;

-const mapStateToProps = (state, ownProps) => {
+const getActiveServer = servers => {
+  const isActive = a => a.active === true;
+  return servers.servers.find(isActive);
+};
+
+const mapStateToProps = state => {
+  const { viewports, servers } = state;
  return {
-    viewports: state.viewports.viewportSpecificData,
-    activeViewportIndex: state.viewports.activeViewportIndex
+    viewports: viewports.viewportSpecificData,
+    activeViewportIndex: viewports.activeViewportIndex,
+    activeServer: getActiveServer(servers),
  };
 };

@@ -18,7 +25,7 @@ const mapDispatchToProps = dispatch => {
    },
    onMeasurementsUpdated: measurements => {
      dispatch(setMeasurements(measurements));
-    }
+    },
  };
 };

@@ -11,6 +11,7 @@ import ConnectedStudyBrowser from './ConnectedStudyBrowser.js';
 import ConnectedViewerMain from './ConnectedViewerMain.js';
 import SidePanel from './../components/SidePanel.js';
 import { extensionManager } from './../App.js';
+import DICOMSR from '../lib/DICOMSR';

 // Contexts
 import WhiteLabellingContext from '../context/WhiteLabellingContext.js';
@@ -57,21 +58,31 @@ class Viewer extends Component {
  static propTypes = {
    studies: PropTypes.array,
    studyInstanceUids: PropTypes.array,
+    activeServer: PropTypes.shape({
+      type: PropTypes.string,
+      wadoRoot: PropTypes.string,
+    }),
    onTimepointsUpdated: PropTypes.func,
    onMeasurementsUpdated: PropTypes.func,
    // window.store.getState().viewports.viewportSpecificData
    viewports: PropTypes.object.isRequired,
    // window.store.getState().viewports.activeViewportIndex
    activeViewportIndex: PropTypes.number.isRequired,
+    isStudyLoaded: PropTypes.bool,
  };

  constructor(props) {
    super(props);
+
+    const { activeServer } = this.props;
+    const server = Object.assign({}, activeServer);
+
    OHIF.measurements.MeasurementApi.setConfiguration({
      dataExchange: {
-        retrieve: this.retrieveMeasurements,
-        store: this.storeMeasurements,
+        retrieve: DICOMSR.retrieveMeasurements,
+        store: DICOMSR.storeMeasurements,
      },
+      server,
    });

    OHIF.measurements.TimepointApi.setConfiguration({
@@ -93,18 +104,6 @@ class Viewer extends Component {
    thumbnails: [],
  };

-  retrieveMeasurements = (patientId, timepointIds) => {
-    OHIF.log.info('retrieveMeasurements');
-    // TODO: Retrieve the measurements from the latest available SR
-    return Promise.resolve();
-  };
-
-  storeMeasurements = (measurementData, timepointIds) => {
-    OHIF.log.info('storeMeasurements');
-    // TODO: Store the measurements into a new SR sent to the active server
-    return Promise.resolve();
-  };
-
  retrieveTimepoints = filter => {
    OHIF.log.info('retrieveTimepoints');

@@ -171,7 +170,7 @@ class Viewer extends Component {
  };

  componentDidMount() {
-    const { studies } = this.props;
+    const { studies, isStudyLoaded } = this.props;
    const { TimepointApi, MeasurementApi } = OHIF.measurements;
    const currentTimepointId = 'TimepointId';

@@ -191,8 +190,11 @@ class Viewer extends Component {
      const patientId = studies[0] && studies[0].patientId;

      timepointApi.retrieveTimepoints({ patientId });
-      measurementApi.retrieveMeasurements(patientId, [currentTimepointId]);
-
+      if (isStudyLoaded) {
+        this.measurementApi.retrieveMeasurements(patientId, [
+          currentTimepointId,
+        ]);
+      }
      this.setState({
        thumbnails: _mapStudiesToThumbnails(studies),
      });
@@ -200,18 +202,19 @@ class Viewer extends Component {
  }

  componentDidUpdate(prevProps) {
-    if (this.props.studies !== prevProps.studies) {
-      const { studies } = this.props;
-      const patientId = studies[0] && studies[0].patientId;
-      const currentTimepointId = this.currentTimepointId;
-
-      this.timepointApi.retrieveTimepoints({ patientId });
-      this.measurementApi.retrieveMeasurements(patientId, [currentTimepointId]);
-
+    const { studies, isStudyLoaded } = this.props;
+    if (studies !== prevProps.studies) {
      this.setState({
        thumbnails: _mapStudiesToThumbnails(studies),
      });
    }
+    if (isStudyLoaded && isStudyLoaded !== prevProps.isStudyLoaded) {
+      const patientId = studies[0] && studies[0].patientId;
+      const { currentTimepointId } = this;
+
+      this.timepointApi.retrieveTimepoints({ patientId });
+      this.measurementApi.retrieveMeasurements(patientId, [currentTimepointId]);
+    }
  }

  render() {
@@ -294,11 +297,11 @@ class Viewer extends Component {
                activeIndex={this.props.activeViewportIndex}
              />
            ) : (
-              <ConnectedStudyBrowser
-                studies={this.state.thumbnails}
-                studyMetadata={this.props.studies}
-              />
-            )}
+                <ConnectedStudyBrowser
+                  studies={this.state.thumbnails}
+                  studyMetadata={this.props.studies}
+                />
+              )}
          </SidePanel>

          {/* MAIN */}
@@ -334,7 +337,7 @@ export default Viewer;
 * @param {Study[]} studies
 * @param {DisplaySet[]} studies[].displaySets
 */
-const _mapStudiesToThumbnails = function(studies) {
+const _mapStudiesToThumbnails = function (studies) {
  return studies.map(study => {
    const { studyInstanceUid } = study;

@@ -178,6 +178,7 @@ function ViewerRetrieveStudyData({
  // hooks
  const [error, setError] = useState(false);
  const [studies, setStudies] = useState([]);
+  const [isStudyLoaded, setIsStudyLoaded] = useState(false);
  const snackbarContext = useSnackbarContext();
  const { appConfig = {} } = useContext(AppContext);
  const { filterQueryParam: isFilterStrategy = false } = appConfig;
@@ -218,6 +219,7 @@ function ViewerRetrieveStudyData({
    );

    setStudies([...studies, study]);
+    setIsStudyLoaded(true);
  };

  /**
@@ -332,7 +334,11 @@ function ViewerRetrieveStudyData({
  }

  return (
-    <ConnectedViewer studies={studies} studyInstanceUids={studyInstanceUids} />
+    <ConnectedViewer
+      studies={studies}
+      isStudyLoaded={isStudyLoaded}
+      studyInstanceUids={studyInstanceUids}
+    />
  );
 }

@@ -0,0 +1,73 @@
+import { log, studies, utils } from '@ohif/core';
+import { retrieveMeasurementFromSR, stowSRFromMeasurements } from './handleStructuredReport';
+import findMostRecentStructuredReport from './utils/findMostRecentStructuredReport';
+
+/**
+ *
+ * @typedef serverType
+ * @property {string} type - type of the server
+ * @property {string} wadoRoot - server wado root url
+ *
+ */
+
+/**
+ * Function to be registered into MeasurementAPI to retrieve measurements from DICOM Structured Reports
+ *
+ * @param {serverType} server
+ * @returns {Promise} Should resolve with OHIF measurementData object
+ */
+const retrieveMeasurements = server => {
+  log.info('[DICOMSR] retrieveMeasurements');
+
+  if (!server || server.type !== 'dicomWeb') {
+    log.error('[DICOMSR] DicomWeb server is required!');
+    return Promise.reject({});
+  }
+
+  const serverUrl = server.wadoRoot;
+  const studies = utils.studyMetadataManager.all();
+  const latestSeries = findMostRecentStructuredReport(studies);
+
+  if (!latestSeries) return Promise.resolve({});
+
+  return retrieveMeasurementFromSR(latestSeries, studies, serverUrl);
+};
+
+/**
+ *  Function to be registered into MeasurementAPI to store measurements into DICOM Structured Reports
+ *
+ * @param {Object} measurementData - OHIF measurementData object
+ * @param {Object} filter
+ * @param {serverType} server
+ * @returns {Object} With message to be displayed on success
+ */
+const storeMeasurements = async (measurementData, filter, server) => {
+  log.info('[DICOMSR] storeMeasurements');
+
+  if (!server || server.type !== 'dicomWeb') {
+    log.error('[DICOMSR] DicomWeb server is required!');
+    return Promise.reject({});
+  }
+
+  const serverUrl = server.wadoRoot;
+  const firstMeasurementKey = Object.keys(measurementData)[0];
+  const firstMeasurement = measurementData[firstMeasurementKey][0];
+  const studyInstanceUid =
+    firstMeasurement && firstMeasurement.studyInstanceUid;
+
+  try {
+    await stowSRFromMeasurements(measurementData, serverUrl);
+    if (studyInstanceUid) {
+      studies.deleteStudyMetadataPromise(studyInstanceUid);
+    }
+
+    return {
+      message: 'Measurements were saved with success',
+    };
+  } catch (error) {
+    log.error(`[DICOMSR] Error while saving the measurements: ${error.message}`);
+    throw new Error('Error while saving the measurements.');
+  }
+};
+
+export { retrieveMeasurements, storeMeasurements };
@@ -0,0 +1,84 @@
+import * as dcmjs from 'dcmjs';
+import { DICOMWeb } from '@ohif/core';
+import parseDicomStructuredReport from './parseDicomStructuredReport';
+import parseMeasurementsData from './parseMeasurementsData';
+import getAllDisplaySets from './utils/getAllDisplaySets';
+
+import { api } from 'dicomweb-client';
+
+const VERSION_NAME = 'dcmjs-0.0';
+const TRANSFER_SYNTAX_UID = '1.2.840.10008.1.2.1';
+
+/**
+ * Function to retrieve measurements from DICOM Structured Reports coming from determined server
+ *
+ * @param {Array} series - List of all series metaData loaded
+ * @param {Array} studies - List of all studies metaData loaded
+ * @param {string} serverUrl - Server URL to be used on request
+ * @returns {Object} MeasurementData
+ */
+const retrieveMeasurementFromSR = async (series, studies, serverUrl) => {
+  const config = {
+    url: serverUrl,
+    headers: DICOMWeb.getAuthorizationHeader(),
+  };
+
+  const dicomWeb = new api.DICOMwebClient(config);
+
+  const instance = series.getFirstInstance();
+  const options = {
+    studyInstanceUID: instance.getStudyInstanceUID(),
+    seriesInstanceUID: instance.getSeriesInstanceUID(),
+    sopInstanceUID: instance.getSOPInstanceUID(),
+  };
+
+  const part10SRArrayBuffer = await dicomWeb.retrieveInstance(options);
+  const displaySets = getAllDisplaySets(studies);
+  const measurementsData = parseDicomStructuredReport(part10SRArrayBuffer, displaySets);
+
+  return measurementsData;
+};
+
+/**
+ * Function to store measurements to DICOM Structured Reports in determined server
+ *
+ * @param {Object} measurements - OHIF measurementData object
+ * @param {string} serverUrl - Server URL to be used on request
+ * @returns {Promise}
+ */
+const stowSRFromMeasurements = async (measurements, serverUrl) => {
+  const { dataset } = parseMeasurementsData(
+    measurements
+  );
+  const { DicomMetaDictionary, DicomDict } = dcmjs.data;
+  const meta = {
+    FileMetaInformationVersion:
+      dataset._meta.FileMetaInformationVersion.Value,
+    MediaStorageSOPClassUID: dataset.SOPClassUID,
+    MediaStorageSOPInstanceUID: dataset.SOPInstanceUID,
+    TransferSyntaxUID: TRANSFER_SYNTAX_UID,
+    ImplementationClassUID: DicomMetaDictionary.uid(),
+    ImplementationVersionName: VERSION_NAME,
+  };
+
+  const denaturalized = DicomMetaDictionary.denaturalizeDataset(meta);
+  const dicomDict = new DicomDict(denaturalized);
+
+  dicomDict.dict = DicomMetaDictionary.denaturalizeDataset(dataset);
+
+  const part10Buffer = dicomDict.write();
+
+  const config = {
+    url: serverUrl,
+    headers: DICOMWeb.getAuthorizationHeader(),
+  };
+
+  const dicomWeb = new api.DICOMwebClient(config);
+  const options = {
+    datasets: [part10Buffer],
+  };
+
+  await dicomWeb.storeInstances(options);
+};
+
+export { retrieveMeasurementFromSR, stowSRFromMeasurements };
@@ -0,0 +1,10 @@
+import { retrieveMeasurements, storeMeasurements } from './dataExchange';
+import isToolSupported from './utils/isToolSupported';
+
+const DICOMSR = {
+  retrieveMeasurements,
+  storeMeasurements,
+  isToolSupported,
+};
+
+export default DICOMSR;
@@ -0,0 +1,82 @@
+import * as dcmjs from 'dcmjs';
+import findInstanceMetadataBySopInstanceUid from './utils/findInstanceMetadataBySopInstanceUid';
+
+/**
+ * Function to parse the part10 array buffer that comes from a DICOM Structured report into measurementData
+ * measurementData format is a viewer specific format to be stored into the redux and consumed by other components
+ * (e.g. measurement table)
+ *
+ * @param {ArrayBuffer} part10SRArrayBuffer
+ * @param {Array} displaySets
+ * @returns
+ */
+const parseDicomStructuredReport = (part10SRArrayBuffer, displaySets) => {
+  // Get the dicom data as an Object
+  const dicomData = dcmjs.data.DicomMessage.readFile(part10SRArrayBuffer);
+  const dataset = dcmjs.data.DicomMetaDictionary.naturalizeDataset(
+    dicomData.dict
+  );
+
+  const { MeasurementReport } = dcmjs.adapters.Cornerstone;
+  const storedMeasurementByToolType = MeasurementReport.generateToolState(
+    dataset
+  );
+  const measurementData = {};
+  let measurementNumber = 0;
+
+  Object.keys(storedMeasurementByToolType).forEach(toolName => {
+    const measurements = storedMeasurementByToolType[toolName];
+    measurementData[toolName] = [];
+
+    measurements.forEach(measurement => {
+      const instanceMetadata = findInstanceMetadataBySopInstanceUid(
+        displaySets,
+        measurement.sopInstanceUid
+      );
+      const { _study: study, _series: series } = instanceMetadata;
+      const { studyInstanceUid, patientId } = study;
+      const { seriesInstanceUid } = series;
+      const { sopInstanceUid, frameIndex } = measurement;
+      const imagePath = getImagePath(studyInstanceUid, seriesInstanceUid, sopInstanceUid, frameIndex);
+
+      const imageId = instanceMetadata.getImageId();
+      if (!imageId) {
+        return;
+      }
+
+      // TODO: We need the currentTimepointID set into the viewer
+      const currentTimepointId = 'TimepointId';
+
+      const toolData = Object.assign({}, measurement, {
+        imageId,
+        imagePath,
+        seriesInstanceUid,
+        studyInstanceUid,
+        patientId,
+        measurementNumber: ++measurementNumber,
+        timepointId: currentTimepointId,
+        toolType: toolName,
+        _id: imageId + measurementNumber,
+      });
+
+      measurementData[toolName].push(toolData);
+    });
+  });
+
+  return measurementData;
+};
+
+/**
+ * Function to create imagePath with all imageData related
+ *
+ * @param {string} studyInstanceUid
+ * @param {string} seriesInstanceUid
+ * @param {string} sopInstanceUid
+ * @param {string} frameIndex
+ * @returns
+ */
+const getImagePath = (studyInstanceUid, seriesInstanceUid, sopInstanceUid, frameIndex) => {
+  return [studyInstanceUid, seriesInstanceUid, sopInstanceUid, frameIndex].join('_');
+}
+
+export default parseDicomStructuredReport;
@@ -0,0 +1,55 @@
+import * as dcmjs from 'dcmjs';
+import { log, measurements } from '@ohif/core';
+import cornerstone from 'cornerstone-core';
+import isToolSupported from './utils/isToolSupported';
+
+/**
+ * Function to parse OHIF viewer measurementData into a dcmjs MeasurementReport
+ *
+ * @param {Object} measurementsData - OHIF measurementData object
+ * @returns {Object} Dataset: measurement report from dcmjs
+ */
+const parseMeasurementsData = measurementsData => {
+  const { MeasurementReport } = dcmjs.adapters.Cornerstone;
+  const { getImageIdForImagePath } = measurements;
+
+  const toolState = {};
+  const unsupportedTools = [];
+
+  Object.keys(measurementsData).forEach(measurementType => {
+    const annotations = measurementsData[measurementType];
+
+    annotations.forEach(annotation => {
+      const { toolType, imagePath } = annotation;
+
+      if (isToolSupported(toolType)) {
+        const imageId = getImageIdForImagePath(imagePath);
+        toolState[imageId] = toolState[imageId] || {};
+        toolState[imageId][toolType] = toolState[imageId][toolType] || {
+          data: [],
+        };
+
+        toolState[imageId][toolType].data.push(annotation);
+      } else {
+        unsupportedTools.push(toolType);
+      }
+    });
+  });
+
+  if (unsupportedTools.length > 0) {
+    log.warn(
+      `[DICOMSR] Tooltypes not supported: ${unsupportedTools.join(', ')}`
+    );
+  }
+
+  const report = MeasurementReport.generateReport(
+    toolState,
+    cornerstone.metaData
+  );
+
+  return {
+    dataset: report.dataset,
+  };
+};
+
+export default parseMeasurementsData;
@@ -0,0 +1,22 @@
+/**
+ *  Should Find the requested instance metadata into the displaySets and return
+ *
+ * @param {Array} displaySets - List of displaySets
+ * @param {string} sopInstanceUid - sopInstanceUID to look for
+ * @returns {Object} - instance metadata found
+ */
+const findInstanceMetadataBySopInstanceUid = (displaySets, sopInstanceUid) => {
+  let instanceFound;
+
+  displaySets.find(displaySet => {
+    if (!displaySet.images) return false;
+
+    instanceFound = displaySet.images.find(instanceMetadata => instanceMetadata._sopInstanceUID === sopInstanceUid);
+
+    return !!instanceFound;
+  });
+
+  return instanceFound;
+};
+
+export default findInstanceMetadataBySopInstanceUid;
@@ -0,0 +1,57 @@
+/**
+ * Should find the most recent Structured Report metadata
+ *
+ * @param {Array} studies
+ * @returns {Object} Series
+ */
+const findMostRecentStructuredReport = (studies) => {
+  let mostRecentStructuredReport;
+
+  studies.forEach(study => {
+    const allSeries = study.getSeries ? study.getSeries() : [];
+    allSeries.forEach(series => {
+
+      if (isStructuredReportSeries(series)) {
+        if (!mostRecentStructuredReport || compareSeriesDate(series, mostRecentStructuredReport)) {
+          mostRecentStructuredReport = series;
+        }
+      }
+    });
+  });
+
+  return mostRecentStructuredReport;
+};
+
+/**
+ *  Checks if series sopClassUID matches with the supported Structured Reports sopClassUID
+ *
+ * @param {Object} series - Series metadata
+ * @returns {boolean}
+ */
+const isStructuredReportSeries = (series) => {
+  const supportedSopClassUIDs = [
+    '1.2.840.10008.5.1.4.1.1.88.22',
+    '1.2.840.10008.5.1.4.1.1.11.1',
+  ];
+
+  const firstInstance = series.getFirstInstance();
+  const sopClassUid = firstInstance._instance.sopClassUid;
+
+  return supportedSopClassUIDs.includes(sopClassUid);
+}
+
+/**
+ *  Checkes if series1 is newer than series2
+ *
+ * @param {Object} series1 - Series Metadata 1
+ * @param {Object} series2 - Series Metadata 2
+ * @returns {boolean} true/false if series1 is newer than series2
+ */
+const compareSeriesDate = (series1, series2) => {
+  return series1._data.seriesDate > series2._data.seriesDate ||
+    (series1._data.seriesDate === series2._data.seriesDate &&
+      series1._data.seriesTime > series2._data.seriesTime);
+}
+
+
+export default findMostRecentStructuredReport;
@@ -0,0 +1,19 @@
+/**
+ * Retrieve a list of all displaySets of all studies
+ *
+ * @param {Object} studies - List of studies loaded into the viewer
+ * @returns {Object} List of DisplaySets
+ */
+const getAllDisplaySets = (studies) => {
+  let allDisplaySets = [];
+
+  studies.forEach(study => {
+    if (study.getDisplaySets) {
+      allDisplaySets = allDisplaySets.concat(study.getDisplaySets());
+    }
+  });
+
+  return allDisplaySets;
+};
+
+export default getAllDisplaySets;
@@ -0,0 +1,14 @@
+import * as dcmjs from 'dcmjs';
+
+/**
+ *  Checks if dcmjs has support to determined tool
+ *
+ * @param {string} toolName
+ * @returns {boolean}
+ */
+const isToolSupported = toolName => {
+  const adapter = dcmjs.adapters.Cornerstone;
+  return !!adapter[toolName];
+};
+
+export default isToolSupported;