Working local download, STOW to PACS an view in SR Viewport.

platform/core/src/DICOMSR/dataExchange.js

@@ -6,6 +6,10 @@ import {
   stowSRFromMeasurements,
 } from './handleStructuredReport';
 import findMostRecentStructuredReport from './utils/findMostRecentStructuredReport';
+import cornerstoneTools from 'cornerstone-tools';
+import dcmjs from 'dcmjs';
+
+const { MeasurementReport } = dcmjs.adapters.Cornerstone;
 
 /**
  *
@@ -47,7 +51,7 @@ const retrieveMeasurements = server => {
  * @param {serverType} server
  * @returns {Object} With message to be displayed on success
  */
-const storeMeasurements = async (measurementData, filter, server) => {
+const storeMeasurementsOld = async (measurementData, filter, server) => {
   log.info('[DICOMSR] storeMeasurements');
 
   if (!server || server.type !== 'dicomWeb') {
@@ -78,4 +82,112 @@ const storeMeasurements = async (measurementData, filter, server) => {
   }
 };
 
-export { retrieveMeasurements, storeMeasurements };
+const downloadReport = measurementData => {
+  const srDataset = generateReport(measurementData);
+  const reportBlob = dcmjs.data.datasetToBlob(srDataset);
+
+  //Create a URL for the binary.
+  var objectUrl = URL.createObjectURL(reportBlob);
+  window.location.assign(objectUrl);
+};
+
+const generateReport = measurementData => {
+  const ids = measurementData.map(md => md.id);
+  const filteredToolState = _getFilteredCornerstoneToolState(ids);
+
+  const report = MeasurementReport.generateReport(
+    filteredToolState,
+    cornerstone.metaData
+  );
+
+  return report.dataset;
+};
+
+const storeMeasurements = async (measurementData, dataSource) => {
+  // TODO -> Eventually use the measurements directly and not the dcmjs adapter,
+  // But it is good enough for now whilst we only have cornerstone as a datasource.
+  log.info('[DICOMSR] storeMeasurements');
+
+  if (!dataSource || !dataSource.store || !dataSource.store.dicom) {
+    log.error('[DICOMSR] datasource has no dataSource.store.dicom endpoint!');
+    return Promise.reject({});
+  }
+
+  const naturalizedReport = generateReport(measurementData);
+  const { StudyInstanceUID } = naturalizedReport;
+
+  try {
+    await dataSource.store.dicom(naturalizedReport);
+
+    if (StudyInstanceUID) {
+      studies.deleteStudyMetadataPromise(StudyInstanceUID);
+    }
+
+    return {
+      message: 'Measurements saved successfully',
+    };
+  } catch (error) {
+    log.error(
+      `[DICOMSR] Error while saving the measurements: ${error.message}`
+    );
+    throw new Error('Error while saving the measurements.');
+  }
+};
+
+function _getFilteredCornerstoneToolState(uidFilter) {
+  const globalToolState = cornerstoneTools.globalImageIdSpecificToolStateManager.saveToolState();
+  const filteredToolState = {};
+
+  function addToFilteredToolState(imageId, toolType, toolDataI) {
+    if (!filteredToolState[imageId]) {
+      filteredToolState[imageId] = {};
+    }
+
+    const imageIdSpecificToolState = filteredToolState[imageId];
+
+    if (!imageIdSpecificToolState[toolType]) {
+      imageIdSpecificToolState[toolType] = {
+        data: [],
+      };
+    }
+
+    const toolData = imageIdSpecificToolState[toolType].data;
+
+    toolData.push(toolDataI);
+  }
+
+  const uids = uidFilter.slice();
+  const imageIds = Object.keys(globalToolState);
+
+  for (let i = 0; i < imageIds.length; i++) {
+    const imageId = imageIds[i];
+    const imageIdSpecificToolState = globalToolState[imageId];
+
+    const toolTypes = Object.keys(imageIdSpecificToolState);
+
+    for (let j = 0; j < toolTypes.length; j++) {
+      const toolType = toolTypes[j];
+      const toolData = imageIdSpecificToolState[toolType].data;
+
+      if (toolData) {
+        for (let k = 0; k < toolData.length; k++) {
+          const toolDataK = toolData[k];
+          const uidIndex = uids.findIndex(uid => uid === toolDataK.id);
+
+          if (uidIndex !== -1) {
+            addToFilteredToolState(imageId, toolType, toolDataK);
+            uids.splice(uidIndex, 1);
+
+            if (!uids.length) {
+              return filteredToolState;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return filteredToolState;
+}
+
+export { retrieveMeasurements, storeMeasurements, downloadReport };

platform/core/src/DICOMSR/index.js

@@ -1,9 +1,14 @@
-import { retrieveMeasurements, storeMeasurements } from './dataExchange';
+import {
+  retrieveMeasurements,
+  storeMeasurements,
+  downloadReport,
+} from './dataExchange';
 import isToolSupported from './utils/isToolSupported';
 
 const DICOMSR = {
   retrieveMeasurements,
   storeMeasurements,
+  downloadReport,
   isToolSupported,
 };
 

platform/core/src/DataSources/IWebApiDataSource.js

@@ -15,6 +15,7 @@ import { DicomMetadataStore } from '@ohif/core';
 function create({
   query,
   retrieve,
+  store,
   retrieveSeriesMetadata,
   getImageIdsForDisplaySet,
 }) {
@@ -44,13 +45,20 @@ function create({
     series: {},
   };
 
+  const defaultStore = {
+    dicom: async naturalizedDataset => {
+      throw new Error(
+        'store.dicom(naturalizedDicom, StudyInstanceUID) not implemented for dataSource.'
+      );
+    },
+  };
+
   return {
     query: query || defaultQuery,
     retrieve: retrieve || defaultRetrieve,
+    store: store || defaultStore,
     getImageIdsForDisplaySet,
     retrieveSeriesMetadata,
-    // then go get all series level metadata.
-    // Store this in the DICOM MetadataStore.
   };
 }