@ohif/app 3.7.0-beta.99 → 3.7.0

package/dist/{831.bundle.83658f62fcc769043605.js → 757.bundle.ec8301d8e70d2b990f65.js}

@@ -1,4 +1,4 @@
-(self["webpackChunk"] = self["webpackChunk"] || []).push([[831],{
+(self["webpackChunk"] = self["webpackChunk"] || []).push([[757],{
 
 /***/ 82803:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
@@ -90,6 +90,373 @@ exports.Z = function (_ref) {
   );
 };
 
+/***/ }),
+
+/***/ 49399:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  ZP: () => (/* binding */ vtkImageMarchingSquares$1)
+});
+
+// UNUSED EXPORTS: extend, newInstance
+
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/macros.js + 6 modules
+var macros = __webpack_require__(41168);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/PolyData.js + 9 modules
+var PolyData = __webpack_require__(1299);
+// EXTERNAL MODULE: ../../../node_modules/@babel/runtime/helpers/esm/classCallCheck.js
+var classCallCheck = __webpack_require__(72688);
+// EXTERNAL MODULE: ../../../node_modules/@babel/runtime/helpers/esm/createClass.js
+var createClass = __webpack_require__(75755);
+;// CONCATENATED MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/EdgeLocator.js
+
+
+
+var EdgeLocator = /*#__PURE__*/function () {
+  function EdgeLocator() {
+    var oriented = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+
+    (0,classCallCheck/* default */.Z)(this, EdgeLocator);
+
+    this.oriented = oriented;
+    this.edgeMap = new Map();
+  }
+
+  (0,createClass/* default */.Z)(EdgeLocator, [{
+    key: "initialize",
+    value: function initialize() {
+      this.edgeMap.clear();
+    }
+  }, {
+    key: "computeEdgeKey",
+    value: function computeEdgeKey(pointId0, pointId1) {
+      return this.oriented || pointId0 < pointId1 ? // Cantor pairing function:
+      0.5 * (pointId0 * pointId1) * (pointId0 * pointId1 + 1) + pointId1 : 0.5 * (pointId1 * pointId0) * (pointId1 * pointId0 + 1) + pointId0;
+    }
+  }, {
+    key: "insertUniqueEdge",
+    value: function insertUniqueEdge(pointId0, pointId1, newEdgeValue) {
+      // Generate a unique key
+      var key = this.computeEdgeKey(pointId0, pointId1);
+      var node = this.edgeMap.get(key);
+
+      if (!node) {
+        // Didn't find key, so add a new edge entry
+        node = {
+          key: key,
+          edgeId: this.edgeMap.size,
+          value: newEdgeValue
+        };
+        this.edgeMap.set(key, node);
+      }
+
+      return node;
+    }
+  }, {
+    key: "insertEdge",
+    value: function insertEdge(pointId0, pointId1, newEdgeValue) {
+      // Generate a unique key
+      var key = this.computeEdgeKey(pointId0, pointId1);
+      var node = {
+        key: key,
+        edgeId: this.edgeMap.size,
+        value: newEdgeValue
+      };
+      this.edgeMap.set(key, node);
+      return node;
+    }
+  }, {
+    key: "isInsertedEdge",
+    value: function isInsertedEdge(pointId0, pointId1) {
+      var key = this.computeEdgeKey(pointId0, pointId1);
+      return this.edgeMap.get(key);
+    }
+  }], [{
+    key: "getEdgePointIds",
+    value: function getEdgePointIds(node) {
+      var n = 0.5 * (-1 + Math.sqrt(8 * node.key + 1));
+      var pointId0 = node.key - 0.5 * (n + 1) * n;
+      var pointId1 = n - pointId0;
+      return [pointId0, pointId1];
+    }
+  }]);
+
+  return EdgeLocator;
+}();
+
+function newInstance() {
+  var initialValues = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return new EdgeLocator(initialValues.oriented);
+}
+
+var vtkEdgeLocator = {
+  newInstance: newInstance
+};
+
+
+
+;// CONCATENATED MODULE: ../../../node_modules/@kitware/vtk.js/Filters/General/ImageMarchingSquares/caseTable.js
+// ----------------------------------------------------------------------------
+// Marching squares case functions (using lines to generate the 2D tessellation).
+// For each case, a list of edge ids that form the triangles. A -1 marks the
+// end of the list of edges. Edges are taken three at a time to generate
+// triangle points.
+// ----------------------------------------------------------------------------
+var MARCHING_SQUARES_CASES = [[-1, -1, -1, -1, -1]
+/* 0 */
+, [0, 3, -1, -1, -1]
+/* 1 */
+, [1, 0, -1, -1, -1]
+/* 2 */
+, [1, 3, -1, -1, -1]
+/* 3 */
+, [2, 1, -1, -1, -1]
+/* 4 */
+, [0, 3, 2, 1, -1]
+/* 5 */
+, [2, 0, -1, -1, -1]
+/* 6 */
+, [2, 3, -1, -1, -1]
+/* 7 */
+, [3, 2, -1, -1, -1]
+/* 8 */
+, [0, 2, -1, -1, -1]
+/* 9 */
+, [1, 0, 3, 2, -1]
+/* 10 */
+, [1, 2, -1, -1, -1]
+/* 11 */
+, [3, 1, -1, -1, -1]
+/* 12 */
+, [0, 1, -1, -1, -1]
+/* 13 */
+, [3, 0, -1, -1, -1]
+/* 14 */
+, [-1, -1, -1, -1, -1]
+/* 15 */
+];
+var EDGES = [[0, 1], [1, 3], [2, 3], [0, 2]];
+
+function getCase(index) {
+  return MARCHING_SQUARES_CASES[index];
+} // Define the four edges of the pixel by the following pairs of vertices
+
+
+function getEdge(eid) {
+  return EDGES[eid];
+} // ----------------------------------------------------------------------------
+// Static API
+// ----------------------------------------------------------------------------
+
+
+var vtkCaseTable = {
+  getCase: getCase,
+  getEdge: getEdge
+};
+
+
+
+;// CONCATENATED MODULE: ../../../node_modules/@kitware/vtk.js/Filters/General/ImageMarchingSquares.js
+
+
+
+
+
+var vtkErrorMacro = macros["default"].vtkErrorMacro,
+    vtkDebugMacro = macros["default"].vtkDebugMacro; // ----------------------------------------------------------------------------
+// vtkImageMarchingSquares methods
+// ----------------------------------------------------------------------------
+
+function vtkImageMarchingSquares(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkImageMarchingSquares');
+
+  publicAPI.getContourValues = function () {
+    return model.contourValues;
+  };
+
+  publicAPI.setContourValues = function (cValues) {
+    model.contourValues = cValues;
+    publicAPI.modified();
+  };
+
+  var ids = [];
+  var pixelScalars = [];
+  var pixelPts = [];
+  var edgeLocator = vtkEdgeLocator.newInstance(); // Retrieve scalars and pixel coordinates. i-j-k is origin of pixel.
+
+  publicAPI.getPixelScalars = function (i, j, k, slice, dims, origin, spacing, s) {
+    // First get the indices for the pixel
+    ids[0] = k * slice + j * dims[0] + i; // i, j, k
+
+    ids[1] = ids[0] + 1; // i+1, j, k
+
+    ids[2] = ids[0] + dims[0]; // i, j+1, k
+
+    ids[3] = ids[2] + 1; // i+1, j+1, k
+    // Now retrieve the scalars
+
+    for (var ii = 0; ii < 4; ++ii) {
+      pixelScalars[ii] = s[ids[ii]];
+    }
+  }; // Retrieve pixel coordinates. i-j-k is origin of pixel.
+
+
+  publicAPI.getPixelPoints = function (i, j, k, dims, origin, spacing) {
+    // (i,i+1),(j,j+1),(k,k+1) - i varies fastest; then j; then k
+    pixelPts[0] = origin[0] + i * spacing[0]; // 0
+
+    pixelPts[1] = origin[1] + j * spacing[1];
+    pixelPts[2] = pixelPts[0] + spacing[0]; // 1
+
+    pixelPts[3] = pixelPts[1];
+    pixelPts[4] = pixelPts[0]; // 2
+
+    pixelPts[5] = pixelPts[1] + spacing[1];
+    pixelPts[6] = pixelPts[2]; // 3
+
+    pixelPts[7] = pixelPts[5];
+  };
+
+  publicAPI.produceLines = function (cVal, i, j, k, slice, dims, origin, spacing, scalars, points, lines) {
+    var CASE_MASK = [1, 2, 8, 4]; // case table is actually for quad
+
+    var xyz = [];
+    var pId;
+    publicAPI.getPixelScalars(i, j, k, slice, dims, origin, spacing, scalars);
+    var index = 0;
+
+    for (var idx = 0; idx < 4; idx++) {
+      if (pixelScalars[idx] >= cVal) {
+        index |= CASE_MASK[idx]; // eslint-disable-line no-bitwise
+      }
+    }
+
+    var pixelLines = vtkCaseTable.getCase(index);
+
+    if (pixelLines[0] < 0) {
+      return; // don't get the pixel coordinates, nothing to do
+    }
+
+    publicAPI.getPixelPoints(i, j, k, dims, origin, spacing);
+    var z = origin[2] + k * spacing[2];
+
+    for (var _idx = 0; pixelLines[_idx] >= 0; _idx += 3) {
+      lines.push(2);
+
+      for (var eid = 0; eid < 2; eid++) {
+        var edgeVerts = vtkCaseTable.getEdge(pixelLines[_idx + eid]);
+        pId = undefined;
+
+        if (model.mergePoints) {
+          var _edgeLocator$isInsert;
+
+          pId = (_edgeLocator$isInsert = edgeLocator.isInsertedEdge(ids[edgeVerts[0]], ids[edgeVerts[1]])) === null || _edgeLocator$isInsert === void 0 ? void 0 : _edgeLocator$isInsert.value;
+        }
+
+        if (pId === undefined) {
+          var t = (cVal - pixelScalars[edgeVerts[0]]) / (pixelScalars[edgeVerts[1]] - pixelScalars[edgeVerts[0]]);
+          var x0 = pixelPts.slice(edgeVerts[0] * 2, (edgeVerts[0] + 1) * 2);
+          var x1 = pixelPts.slice(edgeVerts[1] * 2, (edgeVerts[1] + 1) * 2);
+          xyz[0] = x0[0] + t * (x1[0] - x0[0]);
+          xyz[1] = x0[1] + t * (x1[1] - x0[1]);
+          pId = points.length / 3;
+          points.push(xyz[0], xyz[1], z);
+
+          if (model.mergePoints) {
+            edgeLocator.insertEdge(ids[edgeVerts[0]], ids[edgeVerts[1]], pId);
+          }
+        }
+
+        lines.push(pId);
+      }
+    }
+  };
+
+  publicAPI.requestData = function (inData, outData) {
+    // implement requestData
+    var input = inData[0];
+
+    if (!input) {
+      vtkErrorMacro('Invalid or missing input');
+      return;
+    }
+
+    console.time('msquares'); // Retrieve output and volume data
+
+    var origin = input.getOrigin();
+    var spacing = input.getSpacing();
+    var dims = input.getDimensions();
+    var s = input.getPointData().getScalars().getData(); // Points - dynamic array
+
+    var pBuffer = []; // Cells - dynamic array
+
+    var lBuffer = []; // Ensure slice is valid
+
+    var slice = dims[0] * dims[1];
+    var k = Math.round(model.slice);
+
+    if (k >= dims[2]) {
+      k = 0;
+    } // Loop over all contour values, and then pixels, determine case and process
+
+
+    for (var cv = 0; cv < model.contourValues.length; ++cv) {
+      for (var j = 0; j < dims[1] - 1; ++j) {
+        for (var i = 0; i < dims[0] - 1; ++i) {
+          publicAPI.produceLines(model.contourValues[cv], i, j, k, slice, dims, origin, spacing, s, pBuffer, lBuffer);
+        }
+      }
+
+      edgeLocator.initialize();
+    } // Update output
+
+
+    var polydata = PolyData/* default.newInstance */.ZP.newInstance();
+    polydata.getPoints().setData(new Float32Array(pBuffer), 3);
+    polydata.getLines().setData(new Uint32Array(lBuffer));
+    outData[0] = polydata;
+    vtkDebugMacro('Produced output');
+    console.timeEnd('msquares');
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {
+  contourValues: [],
+  slice: 0,
+  mergePoints: false
+}; // ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues); // Make this a VTK object
+
+  macros["default"].obj(publicAPI, model); // Also make it an algorithm with one input and one output
+
+  macros["default"].algo(publicAPI, model, 1, 1);
+  macros["default"].setGet(publicAPI, model, ['slice', 'mergePoints']); // Object specific methods
+
+  macros["default"].algo(publicAPI, model, 1, 1);
+  vtkImageMarchingSquares(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var ImageMarchingSquares_newInstance = macros["default"].newInstance(extend, 'vtkImageMarchingSquares'); // ----------------------------------------------------------------------------
+
+var vtkImageMarchingSquares$1 = {
+  newInstance: ImageMarchingSquares_newInstance,
+  extend: extend
+};
+
+
+
+
 /***/ }),
 
 /***/ 55187:

package/dist/{782.bundle.f6d16bde1ecbb30f1693.js → 788.bundle.b9dabaea41cb029360b1.js}

@@ -1,6 +1,6 @@
-(self["webpackChunk"] = self["webpackChunk"] || []).push([[782],{
+(self["webpackChunk"] = self["webpackChunk"] || []).push([[788],{
 
-/***/ 43851:
+/***/ 4483:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -1964,310 +1964,10 @@ function createAndDownloadTMTVReport(segReport, additionalReportRows) {
   a.download = `${firstReport.PatientID}_tmtv.csv`;
   a.click();
 }
-;// CONCATENATED MODULE: ../../../extensions/tmtv/src/utils/dicomRTAnnotationExport/RTStructureSet/measurements/RectangleROIStartEndThreshold.js
-// comment
-class RectangleROIStartEndThreshold_RectangleROIStartEndThreshold {
-  constructor() {}
-  static getContourSequence(toolData, metadataProvider) {
-    const {
-      data
-    } = toolData;
-    const {
-      projectionPoints,
-      projectionPointsImageIds
-    } = data.cachedStats;
-    return projectionPoints.map((point, index) => {
-      const ContourData = getPointData(point);
-      const ContourImageSequence = getContourImageSequence(projectionPointsImageIds[index], metadataProvider);
-      return {
-        NumberOfContourPoints: ContourData.length / 3,
-        ContourImageSequence,
-        ContourGeometricType: 'CLOSED_PLANAR',
-        ContourData
-      };
-    });
-  }
-}
-RectangleROIStartEndThreshold_RectangleROIStartEndThreshold.toolName = 'RectangleROIStartEndThreshold';
-function getPointData(points) {
-  // Since this is a closed contour, the order of the points is important.
-  // re-order the points to be in the correct order clockwise
-  // Spread to make sure Float32Arrays are converted to arrays
-  const orderedPoints = [...points[0], ...points[1], ...points[3], ...points[2]];
-  const pointsArray = orderedPoints.flat();
-
-  // reduce the precision of the points to 2 decimal places
-  const pointsArrayWithPrecision = pointsArray.map(point => {
-    return point.toFixed(2);
-  });
-  return pointsArrayWithPrecision;
-}
-function getContourImageSequence(imageId, metadataProvider) {
-  const sopCommon = metadataProvider.get('sopCommonModule', imageId);
-  return {
-    ReferencedSOPClassUID: sopCommon.sopClassUID,
-    ReferencedSOPInstanceUID: sopCommon.sopInstanceUID
-  };
-}
-/* harmony default export */ const measurements_RectangleROIStartEndThreshold = (RectangleROIStartEndThreshold_RectangleROIStartEndThreshold);
-;// CONCATENATED MODULE: ../../../extensions/tmtv/src/utils/dicomRTAnnotationExport/RTStructureSet/measurements/AnnotationToPointData.js
-
-function validateAnnotation(annotation) {
-  if (!annotation?.data) {
-    throw new Error('Tool data is empty');
-  }
-  if (!annotation.metadata || annotation.metadata.referenceImageId) {
-    throw new Error('Tool data is not associated with any imageId');
-  }
-}
-class AnnotationToPointData {
-  constructor() {}
-  static convert(annotation, index, metadataProvider) {
-    validateAnnotation(annotation);
-    const {
-      toolName
-    } = annotation.metadata;
-    const toolClass = AnnotationToPointData.TOOL_NAMES[toolName];
-    if (!toolClass) {
-      throw new Error(`Unknown tool type: ${toolName}, cannot convert to RTSSReport`);
-    }
-
-    // Each toolData should become a list of contours, ContourSequence
-    // contains a list of contours with their pointData, their geometry
-    // type and their length.
-    const ContourSequence = toolClass.getContourSequence(annotation, metadataProvider);
-
-    // Todo: random rgb color for now, options should be passed in
-    const color = [Math.floor(Math.random() * 255), Math.floor(Math.random() * 255), Math.floor(Math.random() * 255)];
-    return {
-      ReferencedROINumber: index + 1,
-      ROIDisplayColor: color,
-      ContourSequence
-    };
-  }
-  static register(toolClass) {
-    AnnotationToPointData.TOOL_NAMES[toolClass.toolName] = toolClass;
-  }
-}
-AnnotationToPointData.TOOL_NAMES = {};
-AnnotationToPointData.register(measurements_RectangleROIStartEndThreshold);
-/* harmony default export */ const measurements_AnnotationToPointData = (AnnotationToPointData);
 // EXTERNAL MODULE: ../../../node_modules/dcmjs/build/dcmjs.es.js
 var dcmjs_es = __webpack_require__(67540);
-;// CONCATENATED MODULE: ../../../extensions/tmtv/src/utils/dicomRTAnnotationExport/RTStructureSet/RTSSReport.js
-
-
-
-const {
-  DicomMetaDictionary
-} = dcmjs_es["default"].data;
-class RTSSReport {
-  constructor() {}
-
-  /**
-   * Convert handles to RTSSReport report object containing the dcmjs dicom dataset.
-   *
-   * Note: The tool data needs to be formatted in a specific way, and currently
-   * it is limited to the RectangleROIStartEndTool in the Cornerstone.
-   *
-   * @param annotations Array of Cornerstone tool annotation data
-   * @param metadataProvider Metadata provider
-   * @param options report generation options
-   * @returns Report object containing the dataset
-   */
-  static generateReport(annotations, metadataProvider, options) {
-    let dataset = initializeDataset(annotations, metadataProvider);
-    annotations.forEach((annotation, index) => {
-      const ContourSequence = measurements_AnnotationToPointData.convert(annotation, index, metadataProvider, options);
-      dataset.StructureSetROISequence.push(getStructureSetModule(annotation, index, metadataProvider));
-      dataset.ROIContourSequence.push(ContourSequence);
-      dataset.RTROIObservationsSequence.push(getRTROIObservationsSequence(annotation, index, metadataProvider));
-
-      // ReferencedSeriesSequence
-      // Todo: handle more than one series
-      dataset.ReferencedSeriesSequence = getReferencedSeriesSequence(annotation, index, metadataProvider);
-
-      // ReferencedFrameOfReferenceSequence
-      dataset.ReferencedFrameOfReferenceSequence = getReferencedFrameOfReferenceSequence(annotation, metadataProvider, dataset);
-    });
-    const fileMetaInformationVersionArray = new Uint8Array(2);
-    fileMetaInformationVersionArray[1] = 1;
-    const _meta = {
-      FileMetaInformationVersion: {
-        Value: [fileMetaInformationVersionArray.buffer],
-        vr: 'OB'
-      },
-      TransferSyntaxUID: {
-        Value: ['1.2.840.10008.1.2.1'],
-        vr: 'UI'
-      },
-      ImplementationClassUID: {
-        Value: [DicomMetaDictionary.uid()],
-        // TODO: could be git hash or other valid id
-        vr: 'UI'
-      },
-      ImplementationVersionName: {
-        Value: ['dcmjs'],
-        vr: 'SH'
-      }
-    };
-    dataset._meta = _meta;
-    return dataset;
-  }
-
-  /**
-   * Generate Cornerstone tool state from dataset
-   * @param {object} dataset dataset
-   * @param {object} hooks
-   * @param {function} hooks.getToolClass Function to map dataset to a tool class
-   * @returns
-   */
-  static generateToolState(dataset) {
-    let hooks = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    // Todo
-    console.warn('RTSSReport.generateToolState not implemented');
-  }
-}
-function initializeDataset(annotations, metadataProvider) {
-  const rtSOPInstanceUID = DicomMetaDictionary.uid();
-
-  // get the first annotation data
-  const {
-    referencedImageId: imageId,
-    FrameOfReferenceUID
-  } = annotations[0].metadata;
-  const {
-    studyInstanceUID
-  } = metadataProvider.get('generalSeriesModule', imageId);
-  const patientModule = getPatientModule(imageId, metadataProvider);
-  const rtSeriesModule = getRTSeriesModule(imageId, metadataProvider);
-  return {
-    StructureSetROISequence: [],
-    ROIContourSequence: [],
-    RTROIObservationsSequence: [],
-    ReferencedSeriesSequence: [],
-    ReferencedFrameOfReferenceSequence: [],
-    ...patientModule,
-    ...rtSeriesModule,
-    StudyInstanceUID: studyInstanceUID,
-    SOPClassUID: '1.2.840.10008.5.1.4.1.1.481.3',
-    // RT Structure Set Storage
-    SOPInstanceUID: rtSOPInstanceUID,
-    Manufacturer: 'dcmjs',
-    Modality: 'RTSTRUCT',
-    FrameOfReferenceUID,
-    PositionReferenceIndicator: '',
-    StructureSetLabel: '',
-    StructureSetName: '',
-    ReferringPhysicianName: '',
-    OperatorsName: '',
-    StructureSetDate: DicomMetaDictionary.date(),
-    StructureSetTime: DicomMetaDictionary.time()
-  };
-}
-function getPatientModule(imageId, metadataProvider) {
-  const generalSeriesModule = metadataProvider.get('generalSeriesModule', imageId);
-  const generalStudyModule = metadataProvider.get('generalStudyModule', imageId);
-  const patientStudyModule = metadataProvider.get('patientStudyModule', imageId);
-  const patientModule = metadataProvider.get('patientModule', imageId);
-  const patientDemographicModule = metadataProvider.get('patientDemographicModule', imageId);
-  return {
-    Modality: generalSeriesModule.modality,
-    PatientID: patientModule.patientId,
-    PatientName: patientModule.patientName,
-    PatientBirthDate: '',
-    PatientAge: patientStudyModule.patientAge,
-    PatientSex: patientDemographicModule.patientSex,
-    PatientWeight: patientStudyModule.patientWeight,
-    StudyDate: generalStudyModule.studyDate,
-    StudyTime: generalStudyModule.studyTime,
-    StudyID: 'ToDo',
-    AccessionNumber: generalStudyModule.accessionNumber
-  };
-}
-function getReferencedFrameOfReferenceSequence(toolData, metadataProvider, dataset) {
-  const {
-    referencedImageId: imageId,
-    FrameOfReferenceUID
-  } = toolData.metadata;
-  const instance = metadataProvider.get('instance', imageId);
-  const {
-    SeriesInstanceUID
-  } = instance;
-  const {
-    ReferencedSeriesSequence
-  } = dataset;
-  return [{
-    FrameOfReferenceUID,
-    RTReferencedStudySequence: [{
-      ReferencedSOPClassUID: dataset.SOPClassUID,
-      ReferencedSOPInstanceUID: dataset.SOPInstanceUID,
-      RTReferencedSeriesSequence: [{
-        SeriesInstanceUID,
-        ContourImageSequence: [...ReferencedSeriesSequence[0].ReferencedInstanceSequence]
-      }]
-    }]
-  }];
-}
-function getReferencedSeriesSequence(toolData, index, metadataProvider) {
-  // grab imageId from toolData
-  const {
-    referencedImageId: imageId
-  } = toolData.metadata;
-  const instance = metadataProvider.get('instance', imageId);
-  const {
-    SeriesInstanceUID,
-    StudyInstanceUID
-  } = instance;
-  const ReferencedSeriesSequence = [];
-  if (SeriesInstanceUID) {
-    const series = core_src.DicomMetadataStore.getSeries(StudyInstanceUID, SeriesInstanceUID);
-    const ReferencedSeries = {
-      SeriesInstanceUID,
-      ReferencedInstanceSequence: []
-    };
-    series.instances.forEach(instance => {
-      const {
-        SOPInstanceUID,
-        SOPClassUID
-      } = instance;
-      ReferencedSeries.ReferencedInstanceSequence.push({
-        ReferencedSOPClassUID: SOPClassUID,
-        ReferencedSOPInstanceUID: SOPInstanceUID
-      });
-    });
-    ReferencedSeriesSequence.push(ReferencedSeries);
-  }
-  return ReferencedSeriesSequence;
-}
-function getRTSeriesModule(imageId, metadataProvider) {
-  return {
-    SeriesInstanceUID: DicomMetaDictionary.uid(),
-    // generate a new series instance uid
-    SeriesNumber: '99' // Todo:: what should be the series number?
-  };
-}
-
-function getStructureSetModule(toolData, index, metadataProvider) {
-  const {
-    FrameOfReferenceUID
-  } = toolData.metadata;
-  return {
-    ROINumber: index + 1,
-    ROIName: `Todo: name ${index + 1}`,
-    ROIDescription: `Todo: description ${index + 1}`,
-    ROIGenerationAlgorithm: 'Todo: algorithm',
-    ReferencedFrameOfReferenceUID: FrameOfReferenceUID
-  };
-}
-function getRTROIObservationsSequence(toolData, index, metadataProvider) {
-  return {
-    ObservationNumber: index + 1,
-    ReferencedROINumber: index + 1,
-    RTROIInterpretedType: 'Todo: type',
-    ROIInterpreter: 'Todo: interpreter'
-  };
-}
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/adapters/dist/adapters.es.js
+var adapters_es = __webpack_require__(91202);
 ;// CONCATENATED MODULE: ../../../extensions/tmtv/src/utils/dicomRTAnnotationExport/RTStructureSet/dicomRTAnnotationExport.js
 
 
@@ -2277,7 +1977,7 @@ const {
 } = dcmjs_es["default"].data;
 const metadataProvider = core_src.classes.MetadataProvider;
 function dicomRTAnnotationExport(annotations) {
-  const dataset = RTSSReport.generateReport(annotations, metadataProvider);
+  const dataset = adapters_es.adaptersRT.Cornerstone3D.RTSS.generateRTSSFromAnnotations(annotations, metadataProvider, core_src.DicomMetadataStore);
   const reportBlob = datasetToBlob(dataset);
 
   //Create a URL for the binary.