@cornerstonejs/adapters 2.0.0-beta.2 → 2.0.0-beta.4

package/dist/adapters.es.js

@@ -1,7 +1,6 @@
-import { data, utilities, derivations, normalizers, log } from 'dcmjs';
+import dcmjs, { data, utilities, derivations, normalizers, log } from 'dcmjs';
 import { Buffer } from 'buffer';
 import ndarray from 'ndarray';
-import cloneDeep from 'lodash.clonedeep';
 import { vec3 } from 'gl-matrix';
 
 function _iterableToArrayLimit(arr, i) {
@@ -583,7 +582,7 @@ var StructuredReport$1 = derivations.StructuredReport;
 var Normalizer$4 = normalizers.Normalizer;
 var TID1500MeasurementReport$1 = TID1500$1.TID1500MeasurementReport,
   TID1501MeasurementGroup$1 = TID1500$1.TID1501MeasurementGroup;
-var DicomMetaDictionary$3 = data.DicomMetaDictionary;
+var DicomMetaDictionary$4 = data.DicomMetaDictionary;
 var FINDING$2 = {
   CodingSchemeDesignator: "DCM",
   CodeValue: "121071"
@@ -754,7 +753,7 @@ var MeasurementReport$1 = /*#__PURE__*/function () {
           vr: "UI"
         },
         ImplementationClassUID: {
-          Value: [DicomMetaDictionary$3.uid()],
+          Value: [DicomMetaDictionary$4.uid()],
           // TODO: could be git hash or other valid id
           vr: "UI"
         },
@@ -1827,7 +1826,7 @@ var _utilities$orientatio$1 = utilities.orientation,
 var datasetToBlob = utilities.datasetToBlob,
   BitArray$2 = utilities.BitArray,
   DicomMessage$1 = utilities.DicomMessage,
-  DicomMetaDictionary$2 = utilities.DicomMetaDictionary;
+  DicomMetaDictionary$3 = utilities.DicomMetaDictionary;
 var Normalizer$3 = normalizers.Normalizer;
 var SegmentationDerivation$2 = derivations.Segmentation;
 var Segmentation$5 = {
@@ -1957,16 +1956,16 @@ function _createSegFromImages$1(images, isMultiframe, options) {
     var image = images[0];
     var arrayBuffer = image.data.byteArray.buffer;
     var dicomData = DicomMessage$1.readFile(arrayBuffer);
-    var dataset = DicomMetaDictionary$2.naturalizeDataset(dicomData.dict);
-    dataset._meta = DicomMetaDictionary$2.namifyDataset(dicomData.meta);
+    var dataset = DicomMetaDictionary$3.naturalizeDataset(dicomData.dict);
+    dataset._meta = DicomMetaDictionary$3.namifyDataset(dicomData.meta);
     datasets.push(dataset);
   } else {
     for (var i = 0; i < images.length; i++) {
       var _image = images[i];
       var _arrayBuffer = _image.data.byteArray.buffer;
       var _dicomData = DicomMessage$1.readFile(_arrayBuffer);
-      var _dataset = DicomMetaDictionary$2.naturalizeDataset(_dicomData.dict);
-      _dataset._meta = DicomMetaDictionary$2.namifyDataset(_dicomData.meta);
+      var _dataset = DicomMetaDictionary$3.naturalizeDataset(_dicomData.dict);
+      _dataset._meta = DicomMetaDictionary$3.namifyDataset(_dicomData.meta);
       datasets.push(_dataset);
     }
   }
@@ -1986,8 +1985,8 @@ function _createSegFromImages$1(images, isMultiframe, options) {
  */
 function generateToolState$3(imageIds, arrayBuffer, metadataProvider) {
   var dicomData = DicomMessage$1.readFile(arrayBuffer);
-  var dataset = DicomMetaDictionary$2.naturalizeDataset(dicomData.dict);
-  dataset._meta = DicomMetaDictionary$2.namifyDataset(dicomData.meta);
+  var dataset = DicomMetaDictionary$3.naturalizeDataset(dicomData.dict);
+  dataset._meta = DicomMetaDictionary$3.namifyDataset(dicomData.meta);
   var multiframe = Normalizer$3.normalizeToDataset([dataset]);
   var imagePlaneModule = metadataProvider.get("imagePlaneModule", imageIds[0]);
   if (!imagePlaneModule) {
@@ -2267,7 +2266,7 @@ var _utilities$orientatio = utilities.orientation,
   nearlyEqual = _utilities$orientatio.nearlyEqual;
 var BitArray$1 = data.BitArray,
   DicomMessage = data.DicomMessage,
-  DicomMetaDictionary$1 = data.DicomMetaDictionary;
+  DicomMetaDictionary$2 = data.DicomMetaDictionary;
 var Normalizer$2 = normalizers.Normalizer;
 var SegmentationDerivation$1 = derivations.Segmentation;
 var _utilities$compressio = utilities.compression,
@@ -2417,16 +2416,16 @@ function _createSegFromImages(images, isMultiframe, options) {
     var image = images[0];
     var arrayBuffer = image.data.byteArray.buffer;
     var dicomData = DicomMessage.readFile(arrayBuffer);
-    var dataset = DicomMetaDictionary$1.naturalizeDataset(dicomData.dict);
-    dataset._meta = DicomMetaDictionary$1.namifyDataset(dicomData.meta);
+    var dataset = DicomMetaDictionary$2.naturalizeDataset(dicomData.dict);
+    dataset._meta = DicomMetaDictionary$2.namifyDataset(dicomData.meta);
     datasets.push(dataset);
   } else {
     for (var i = 0; i < images.length; i++) {
       var _image = images[i];
       var _arrayBuffer = _image.data.byteArray.buffer;
       var _dicomData = DicomMessage.readFile(_arrayBuffer);
-      var _dataset = DicomMetaDictionary$1.naturalizeDataset(_dicomData.dict);
-      _dataset._meta = DicomMetaDictionary$1.namifyDataset(_dicomData.meta);
+      var _dataset = DicomMetaDictionary$2.naturalizeDataset(_dicomData.dict);
+      _dataset._meta = DicomMetaDictionary$2.namifyDataset(_dicomData.meta);
       datasets.push(_dataset);
     }
   }
@@ -2610,8 +2609,8 @@ function _generateToolState() {
         case 0:
           _options$skipOverlapp = options.skipOverlapping, skipOverlapping = _options$skipOverlapp === void 0 ? false : _options$skipOverlapp, _options$tolerance = options.tolerance, tolerance = _options$tolerance === void 0 ? 1e-3 : _options$tolerance, _options$TypedArrayCo = options.TypedArrayConstructor, TypedArrayConstructor = _options$TypedArrayCo === void 0 ? Uint8Array : _options$TypedArrayCo, _options$maxBytesPerC = options.maxBytesPerChunk, maxBytesPerChunk = _options$maxBytesPerC === void 0 ? 199000000 : _options$maxBytesPerC, eventTarget = options.eventTarget, triggerEvent = options.triggerEvent;
           dicomData = DicomMessage.readFile(arrayBuffer);
-          dataset = DicomMetaDictionary$1.naturalizeDataset(dicomData.dict);
-          dataset._meta = DicomMetaDictionary$1.namifyDataset(dicomData.meta);
+          dataset = DicomMetaDictionary$2.naturalizeDataset(dicomData.dict);
+          dataset._meta = DicomMetaDictionary$2.namifyDataset(dicomData.meta);
           multiframe = Normalizer$2.normalizeToDataset([dataset]);
           imagePlaneModule = metadataProvider.get("imagePlaneModule", imageIds[0]);
           generalSeriesModule = metadataProvider.get("generalSeriesModule", imageIds[0]);
@@ -2895,7 +2894,7 @@ function insertOverlappingPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray,
   var tempBuffer = labelmapBufferArray[m].slice(0);
 
   // temp list for checking overlaps
-  var tempSegmentsOnFrame = cloneDeep(segmentsOnFrameArray[m]);
+  var tempSegmentsOnFrame = structuredClone(segmentsOnFrameArray[m]);
 
   /** split overlapping SEGs algorithm for each segment:
    *  A) copy the labelmapBuffer in the array with index 0
@@ -2954,7 +2953,7 @@ function insertOverlappingPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray,
               M++;
             }
             tempBuffer = labelmapBufferArray[m].slice(0);
-            tempSegmentsOnFrame = cloneDeep(segmentsOnFrameArray[m]);
+            tempSegmentsOnFrame = structuredClone(segmentsOnFrameArray[m]);
             _i2 = 0;
             break;
           } else {
@@ -2980,12 +2979,12 @@ function insertOverlappingPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray,
       if (_ret2 === "continue") continue;
     }
     labelmapBufferArray[m] = tempBuffer.slice(0);
-    segmentsOnFrameArray[m] = cloneDeep(tempSegmentsOnFrame);
+    segmentsOnFrameArray[m] = structuredClone(tempSegmentsOnFrame);
 
     // reset temp variables/buffers for new segment
     m = 0;
     tempBuffer = labelmapBufferArray[m].slice(0);
-    tempSegmentsOnFrame = cloneDeep(segmentsOnFrameArray[m]);
+    tempSegmentsOnFrame = structuredClone(segmentsOnFrameArray[m]);
   }
 }
 var getSegmentIndex = function getSegmentIndex(multiframe, frame) {
@@ -3587,7 +3586,7 @@ var TID1500 = utilities.TID1500, addAccessors = utilities.addAccessors;
 var StructuredReport = derivations.StructuredReport;
 var Normalizer$1 = normalizers.Normalizer;
 var TID1500MeasurementReport = TID1500.TID1500MeasurementReport, TID1501MeasurementGroup = TID1500.TID1501MeasurementGroup;
-var DicomMetaDictionary = data.DicomMetaDictionary;
+var DicomMetaDictionary$1 = data.DicomMetaDictionary;
 var FINDING = { CodingSchemeDesignator: "DCM", CodeValue: "121071" };
 var FINDING_SITE = { CodingSchemeDesignator: "SCT", CodeValue: "363698007" };
 var FINDING_SITE_OLD = { CodingSchemeDesignator: "SRT", CodeValue: "G-C0E3" };
@@ -3656,7 +3655,7 @@ var MeasurementReport = /** @class */ (function () {
                 vr: "UI"
             },
             ImplementationClassUID: {
-                Value: [DicomMetaDictionary.uid()],
+                Value: [DicomMetaDictionary$1.uid()],
                 vr: "UI"
             },
             ImplementationVersionName: {
@@ -3691,7 +3690,7 @@ var MeasurementReport = /** @class */ (function () {
             description: undefined,
             sopInstanceUid: ReferencedSOPInstanceUID,
             annotation: {
-                annotationUID: DicomMetaDictionary.uid(),
+                annotationUID: DicomMetaDictionary$1.uid(),
                 metadata: {
                     toolName: toolType,
                     referencedImageId: referencedImageId,
@@ -4974,6 +4973,726 @@ var Segmentation$1 = /*#__PURE__*/Object.freeze({
   generateToolState: generateToolState
 });
 
+/**
+ * Checks if point is within array
+ * @param {*} array
+ * @param {*} pt
+ * @returns
+ */
+function ptInArray(array, pt) {
+  var index = -1;
+  for (var i = 0; i < array.length; i++) {
+    if (isSamePoint(pt, array[i])) {
+      index = i;
+    }
+  }
+  return index;
+}
+
+/**
+ * Checks if point A and point B contain same values
+ * @param {*} ptA
+ * @param {*} ptB
+ * @returns
+ */
+function isSamePoint(ptA, ptB) {
+  if (ptA[0] == ptB[0] && ptA[1] == ptB[1] && ptA[2] == ptB[2]) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+/**
+ * Goes through linesArray and replaces all references of old index with new index
+ * @param {*} linesArray
+ * @param {*} oldIndex
+ * @param {*} newIndex
+ */
+function replacePointIndexReferences(linesArray, oldIndex, newIndex) {
+  for (var i = 0; i < linesArray.length; i++) {
+    var line = linesArray[i];
+    if (line.a == oldIndex) {
+      line.a = newIndex;
+    } else if (line.b == oldIndex) {
+      line.b = newIndex;
+    }
+  }
+}
+
+/**
+ * Iterate through polyData from vtkjs and merge any points that are the same
+ * then update merged point references within lines array
+ * @param {*} polyData
+ * @param {*} bypass
+ * @returns
+ */
+function removeDuplicatePoints(polyData, bypass) {
+  var points = polyData.getPoints();
+  var lines = polyData.getLines();
+  var pointsArray = [];
+  for (var i = 0; i < points.getNumberOfPoints(); i++) {
+    var pt = points.getPoint(i).slice();
+    pointsArray.push(pt);
+  }
+  var linesArray = [];
+  for (var _i = 0; _i < lines.getNumberOfCells(); _i++) {
+    var cell = lines.getCell(_i * 3).slice();
+    //console.log(JSON.stringify(cell));
+    var a = cell[0];
+    var b = cell[1];
+    var line = {
+      a: a,
+      b: b
+    };
+    linesArray.push(line);
+  }
+  if (bypass) {
+    return {
+      points: pointsArray,
+      lines: linesArray
+    };
+  }
+
+  // Iterate through points and replace any duplicates
+  var newPoints = [];
+  for (var _i2 = 0; _i2 < pointsArray.length; _i2++) {
+    var _pt = pointsArray[_i2];
+    var index = ptInArray(newPoints, _pt);
+    if (index >= 0) {
+      // Duplicate Point -> replace references in lines
+      replacePointIndexReferences(linesArray, _i2, index);
+    } else {
+      index = newPoints.length;
+      newPoints.push(_pt);
+      replacePointIndexReferences(linesArray, _i2, index);
+    }
+  }
+
+  // Final pass through lines, remove any that refer to exact same point
+  var newLines = [];
+  linesArray.forEach(function (line) {
+    if (line.a != line.b) {
+      newLines.push(line);
+    }
+  });
+  return {
+    points: newPoints,
+    lines: newLines
+  };
+}
+
+function findNextLink(line, lines, contourPoints) {
+  var index = -1;
+  lines.forEach(function (cell, i) {
+    if (index >= 0) {
+      return;
+    }
+    if (cell.a == line.b) {
+      index = i;
+    }
+  });
+  if (index >= 0) {
+    var nextLine = lines[index];
+    lines.splice(index, 1);
+    contourPoints.push(nextLine.b);
+    if (contourPoints[0] == nextLine.b) {
+      return {
+        remainingLines: lines,
+        contourPoints: contourPoints,
+        type: "CLOSED_PLANAR"
+        //type: 'CLOSEDPLANAR_XOR',
+      };
+    }
+
+    return findNextLink(nextLine, lines, contourPoints);
+  }
+  return {
+    remainingLines: lines,
+    contourPoints: contourPoints,
+    type: "OPEN_PLANAR"
+  };
+}
+
+/**
+ *
+ * @param {*} lines
+ */
+function findContours(lines) {
+  if (lines.length == 0) {
+    return [];
+  }
+  var contourPoints = [];
+  var firstCell = lines.shift();
+  contourPoints.push(firstCell.a);
+  contourPoints.push(firstCell.b);
+  var result = findNextLink(firstCell, lines, contourPoints);
+  if (result.remainingLines.length == 0) {
+    return [{
+      type: result.type,
+      contourPoints: result.contourPoints
+    }];
+  } else {
+    var extraContours = findContours(result.remainingLines);
+    extraContours.push({
+      type: result.type,
+      contourPoints: result.contourPoints
+    });
+    return extraContours;
+  }
+}
+function findContoursFromReducedSet(lines, points) {
+  return findContours(lines);
+}
+
+function generateContourSetsFromLabelmap(_ref) {
+  var segmentations = _ref.segmentations,
+    cornerstoneCache = _ref.cornerstoneCache,
+    cornerstoneToolsEnums = _ref.cornerstoneToolsEnums,
+    vtkUtils = _ref.vtkUtils;
+  var LABELMAP = cornerstoneToolsEnums.SegmentationRepresentations.Labelmap;
+  var representationData = segmentations.representationData,
+    segments = segmentations.segments;
+  var segVolumeId = representationData[LABELMAP].volumeId;
+
+  // Get segmentation volume
+  var vol = cornerstoneCache.getVolume(segVolumeId);
+  if (!vol) {
+    console.warn("No volume found for ".concat(segVolumeId));
+    return;
+  }
+  var numSlices = vol.dimensions[2];
+
+  // Get image volume segmentation references
+  var imageVol = cornerstoneCache.getVolume(vol.referencedVolumeId);
+  if (!imageVol) {
+    console.warn("No volume found for ".concat(vol.referencedVolumeId));
+    return;
+  }
+
+  // NOTE: Workaround for marching squares not finding closed contours at
+  // boundary of image volume, clear pixels along x-y border of volume
+  var segData = vol.imageData.getPointData().getScalars().getData();
+  var pixelsPerSlice = vol.dimensions[0] * vol.dimensions[1];
+  for (var z = 0; z < numSlices; z++) {
+    for (var y = 0; y < vol.dimensions[1]; y++) {
+      for (var x = 0; x < vol.dimensions[0]; x++) {
+        var index = x + y * vol.dimensions[0] + z * pixelsPerSlice;
+        if (x === 0 || y === 0 || x === vol.dimensions[0] - 1 || y === vol.dimensions[1] - 1) {
+          segData[index] = 0;
+        }
+      }
+    }
+  }
+
+  // end workaround
+  //
+  //
+  var ContourSets = [];
+
+  // Iterate through all segments in current segmentation set
+  var numSegments = segments.length;
+  for (var segIndex = 0; segIndex < numSegments; segIndex++) {
+    var segment = segments[segIndex];
+
+    // Skip empty segments
+    if (!segment) {
+      continue;
+    }
+    var contourSequence = [];
+    for (var sliceIndex = 0; sliceIndex < numSlices; sliceIndex++) {
+      // Check if the slice is empty before running marching cube
+      if (isSliceEmptyForSegment(sliceIndex, segData, pixelsPerSlice, segIndex)) {
+        continue;
+      }
+      try {
+        var _reducedSet$points;
+        var scalars = vtkUtils.vtkDataArray.newInstance({
+          name: "Scalars",
+          values: Array.from(segData),
+          numberOfComponents: 1
+        });
+
+        // Modify segData for this specific segment directly
+        var segmentIndexFound = false;
+        for (var i = 0; i < segData.length; i++) {
+          var value = segData[i];
+          if (value === segIndex) {
+            segmentIndexFound = true;
+            scalars.setValue(i, 1);
+          } else {
+            scalars.setValue(i, 0);
+          }
+        }
+        if (!segmentIndexFound) {
+          continue;
+        }
+        var mSquares = vtkUtils.vtkImageMarchingSquares.newInstance({
+          slice: sliceIndex
+        });
+
+        // filter out the scalar data so that only it has background and
+        // the current segment index
+        var imageDataCopy = vtkUtils.vtkImageData.newInstance();
+        imageDataCopy.shallowCopy(vol.imageData);
+        imageDataCopy.getPointData().setScalars(scalars);
+
+        // Connect pipeline
+        mSquares.setInputData(imageDataCopy);
+        var cValues = [];
+        cValues[0] = 1;
+        mSquares.setContourValues(cValues);
+        mSquares.setMergePoints(false);
+
+        // Perform marching squares
+        var msOutput = mSquares.getOutputData();
+
+        // Clean up output from marching squares
+        var reducedSet = removeDuplicatePoints(msOutput);
+        if ((_reducedSet$points = reducedSet.points) !== null && _reducedSet$points !== void 0 && _reducedSet$points.length) {
+          var contours = findContoursFromReducedSet(reducedSet.lines, reducedSet.points);
+          contourSequence.push({
+            referencedImageId: imageVol.imageIds[sliceIndex],
+            contours: contours,
+            polyData: reducedSet
+          });
+        }
+      } catch (e) {
+        console.warn(sliceIndex);
+        console.warn(e);
+      }
+    }
+    var metadata = {
+      referencedImageId: imageVol.imageIds[0],
+      // just use 0
+      FrameOfReferenceUID: imageVol.metadata.FrameOfReferenceUID
+    };
+    var ContourSet = {
+      label: segment.label,
+      color: segment.color,
+      metadata: metadata,
+      sliceContours: contourSequence
+    };
+    ContourSets.push(ContourSet);
+  }
+  return ContourSets;
+}
+function isSliceEmptyForSegment(sliceIndex, segData, pixelsPerSlice, segIndex) {
+  var startIdx = sliceIndex * pixelsPerSlice;
+  var endIdx = startIdx + pixelsPerSlice;
+  for (var i = startIdx; i < endIdx; i++) {
+    if (segData[i] === segIndex) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// comment
+var RectangleROIStartEndThreshold = /*#__PURE__*/function () {
+  function RectangleROIStartEndThreshold() {
+    _classCallCheck(this, RectangleROIStartEndThreshold);
+  } // empty
+  _createClass(RectangleROIStartEndThreshold, null, [{
+    key: "getContourSequence",
+    value: function getContourSequence(toolData, metadataProvider) {
+      var data = toolData.data;
+      var _data$cachedStats = data.cachedStats,
+        projectionPoints = _data$cachedStats.projectionPoints,
+        projectionPointsImageIds = _data$cachedStats.projectionPointsImageIds;
+      return projectionPoints.map(function (point, index) {
+        var ContourData = getPointData(point);
+        var ContourImageSequence = getContourImageSequence(projectionPointsImageIds[index], metadataProvider);
+        return {
+          NumberOfContourPoints: ContourData.length / 3,
+          ContourImageSequence: ContourImageSequence,
+          ContourGeometricType: "CLOSED_PLANAR",
+          ContourData: ContourData
+        };
+      });
+    }
+  }]);
+  return 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
+  var orderedPoints = [].concat(_toConsumableArray(points[0]), _toConsumableArray(points[1]), _toConsumableArray(points[3]), _toConsumableArray(points[2]));
+  var pointsArray = orderedPoints.flat();
+
+  // reduce the precision of the points to 2 decimal places
+  var pointsArrayWithPrecision = pointsArray.map(function (point) {
+    return point.toFixed(2);
+  });
+  return pointsArrayWithPrecision;
+}
+function getContourImageSequence(imageId, metadataProvider) {
+  var sopCommon = metadataProvider.get("sopCommonModule", imageId);
+  return {
+    ReferencedSOPClassUID: sopCommon.sopClassUID,
+    ReferencedSOPInstanceUID: sopCommon.sopInstanceUID
+  };
+}
+
+function validateAnnotation(annotation) {
+  if (!(annotation !== null && annotation !== void 0 && 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");
+  }
+}
+var AnnotationToPointData = /*#__PURE__*/function () {
+  function AnnotationToPointData() {
+    _classCallCheck(this, AnnotationToPointData);
+  } // empty
+  _createClass(AnnotationToPointData, null, [{
+    key: "convert",
+    value: function convert(annotation, index, metadataProvider) {
+      validateAnnotation(annotation);
+      var toolName = annotation.metadata.toolName;
+      var toolClass = AnnotationToPointData.TOOL_NAMES[toolName];
+      if (!toolClass) {
+        throw new Error("Unknown tool type: ".concat(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.
+      var ContourSequence = toolClass.getContourSequence(annotation, metadataProvider);
+
+      // Todo: random rgb color for now, options should be passed in
+      var color = [Math.floor(Math.random() * 255), Math.floor(Math.random() * 255), Math.floor(Math.random() * 255)];
+      return {
+        ReferencedROINumber: index + 1,
+        ROIDisplayColor: color,
+        ContourSequence: ContourSequence
+      };
+    }
+  }, {
+    key: "register",
+    value: function register(toolClass) {
+      AnnotationToPointData.TOOL_NAMES[toolClass.toolName] = toolClass;
+    }
+  }]);
+  return AnnotationToPointData;
+}();
+AnnotationToPointData.TOOL_NAMES = {};
+AnnotationToPointData.register(RectangleROIStartEndThreshold);
+
+function getPatientModule(imageId, metadataProvider) {
+  var generalSeriesModule = metadataProvider.get("generalSeriesModule", imageId);
+  var generalStudyModule = metadataProvider.get("generalStudyModule", imageId);
+  var patientStudyModule = metadataProvider.get("patientStudyModule", imageId);
+  var patientModule = metadataProvider.get("patientModule", imageId);
+  var 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(metadata, metadataProvider, dataset) {
+  var imageId = metadata.referencedImageId,
+    FrameOfReferenceUID = metadata.FrameOfReferenceUID;
+  var instance = metadataProvider.get("instance", imageId);
+  var SeriesInstanceUID = instance.SeriesInstanceUID;
+  var ReferencedSeriesSequence = dataset.ReferencedSeriesSequence;
+  return [{
+    FrameOfReferenceUID: FrameOfReferenceUID,
+    RTReferencedStudySequence: [{
+      ReferencedSOPClassUID: dataset.SOPClassUID,
+      ReferencedSOPInstanceUID: dataset.SOPInstanceUID,
+      RTReferencedSeriesSequence: [{
+        SeriesInstanceUID: SeriesInstanceUID,
+        ContourImageSequence: _toConsumableArray(ReferencedSeriesSequence[0].ReferencedInstanceSequence)
+      }]
+    }]
+  }];
+}
+
+function getReferencedSeriesSequence(metadata, _index, metadataProvider, DicomMetadataStore) {
+  // grab imageId from toolData
+  var imageId = metadata.referencedImageId;
+  var instance = metadataProvider.get("instance", imageId);
+  var SeriesInstanceUID = instance.SeriesInstanceUID,
+    StudyInstanceUID = instance.StudyInstanceUID;
+  var ReferencedSeriesSequence = [];
+  if (SeriesInstanceUID) {
+    var series = DicomMetadataStore.getSeries(StudyInstanceUID, SeriesInstanceUID);
+    var ReferencedSeries = {
+      SeriesInstanceUID: SeriesInstanceUID,
+      ReferencedInstanceSequence: []
+    };
+    series.instances.forEach(function (instance) {
+      var SOPInstanceUID = instance.SOPInstanceUID,
+        SOPClassUID = instance.SOPClassUID;
+      ReferencedSeries.ReferencedInstanceSequence.push({
+        ReferencedSOPClassUID: SOPClassUID,
+        ReferencedSOPInstanceUID: SOPInstanceUID
+      });
+    });
+    ReferencedSeriesSequence.push(ReferencedSeries);
+  }
+  return ReferencedSeriesSequence;
+}
+
+function getRTROIObservationsSequence(toolData, index) {
+  return {
+    ObservationNumber: index + 1,
+    ReferencedROINumber: index + 1,
+    RTROIInterpretedType: "Todo: type",
+    ROIInterpreter: "Todo: interpreter"
+  };
+}
+
+function getRTSeriesModule(DicomMetaDictionary) {
+  return {
+    SeriesInstanceUID: DicomMetaDictionary.uid(),
+    // generate a new series instance uid
+    SeriesNumber: "99" // Todo:: what should be the series number?
+  };
+}
+
+function getStructureSetModule(contour, index) {
+  var FrameOfReferenceUID = contour.metadata.FrameOfReferenceUID;
+  return {
+    ROINumber: index + 1,
+    ROIName: contour.name || "Todo: name ".concat(index + 1),
+    ROIDescription: "Todo: description ".concat(index + 1),
+    ROIGenerationAlgorithm: "Todo: algorithm",
+    ReferencedFrameOfReferenceUID: FrameOfReferenceUID
+  };
+}
+
+var DicomMetaDictionary = dcmjs.data.DicomMetaDictionary;
+/**
+ * Convert handles to RTSS report containing the dcmjs dicom dataset.
+ *
+ * Note: current WIP and using segmentation to contour conversion,
+ * routine that is not fully tested
+ *
+ * @param segmentations - Cornerstone tool segmentations data
+ * @param metadataProvider - Metadata provider
+ * @param DicomMetadataStore - metadata store instance
+ * @param cs - cornerstone instance
+ * @param csTools - cornerstone tool instance
+ * @returns Report object containing the dataset
+ */
+function generateRTSSFromSegmentations(segmentations, metadataProvider, DicomMetadataStore, cornerstoneCache, cornerstoneToolsEnums, vtkUtils) {
+    // Convert segmentations to ROIContours
+    var roiContours = [];
+    var contourSets = generateContourSetsFromLabelmap({
+        segmentations: segmentations,
+        cornerstoneCache: cornerstoneCache,
+        cornerstoneToolsEnums: cornerstoneToolsEnums,
+        vtkUtils: vtkUtils
+    });
+    contourSets.forEach(function (contourSet, segIndex) {
+        // Check contour set isn't undefined
+        if (contourSet) {
+            var contourSequence_1 = [];
+            contourSet.sliceContours.forEach(function (sliceContour) {
+                /**
+                 * addContour - Adds a new ROI with related contours to ROIContourSequence
+                 *
+                 * @param newContour - cornerstoneTools `ROIContour` object
+                 *
+                 * newContour = {
+                 *   name: string,
+                 *   description: string,
+                 *   contourSequence: array[contour]
+                 *   color: array[number],
+                 *   metadata: {
+                 *       referencedImageId: string,
+                 *       FrameOfReferenceUID: string
+                 *     }
+                 * }
+                 *
+                 * contour = {
+                 *   ContourImageSequence: array[
+                 *       { ReferencedSOPClassUID: string, ReferencedSOPInstanceUID: string}
+                 *     ]
+                 *   ContourGeometricType: string,
+                 *   NumberOfContourPoints: number,
+                 *   ContourData: array[number]
+                 * }
+                 */
+                // Note: change needed if support non-planar contour representation is needed
+                var sopCommon = metadataProvider.get("sopCommonModule", sliceContour.referencedImageId);
+                var ReferencedSOPClassUID = sopCommon.sopClassUID;
+                var ReferencedSOPInstanceUID = sopCommon.sopInstanceUID;
+                var ContourImageSequence = [
+                    { ReferencedSOPClassUID: ReferencedSOPClassUID, ReferencedSOPInstanceUID: ReferencedSOPInstanceUID } // NOTE: replace in dcmjs?
+                ];
+                var sliceContourPolyData = sliceContour.polyData;
+                sliceContour.contours.forEach(function (contour, index) {
+                    var ContourGeometricType = contour.type;
+                    var NumberOfContourPoints = contour.contourPoints.length;
+                    var ContourData = [];
+                    contour.contourPoints.forEach(function (point) {
+                        var pointData = sliceContourPolyData.points[point];
+                        pointData[0] = +pointData[0].toFixed(2);
+                        pointData[1] = +pointData[1].toFixed(2);
+                        pointData[2] = +pointData[2].toFixed(2);
+                        ContourData.push(pointData[0]);
+                        ContourData.push(pointData[1]);
+                        ContourData.push(pointData[2]);
+                    });
+                    contourSequence_1.push({
+                        ContourImageSequence: ContourImageSequence,
+                        ContourGeometricType: ContourGeometricType,
+                        NumberOfContourPoints: NumberOfContourPoints,
+                        ContourNumber: index + 1,
+                        ContourData: ContourData
+                    });
+                });
+            });
+            var segLabel = contourSet.label || "Segment ".concat(segIndex + 1);
+            var ROIContour = {
+                name: segLabel,
+                description: segLabel,
+                contourSequence: contourSequence_1,
+                color: contourSet.color,
+                metadata: contourSet.metadata
+            };
+            roiContours.push(ROIContour);
+        }
+    });
+    var rtMetadata = {
+        name: segmentations.label,
+        label: segmentations.label
+    };
+    var dataset = _initializeDataset(rtMetadata, roiContours[0].metadata, metadataProvider);
+    roiContours.forEach(function (contour, index) {
+        var roiContour = {
+            ROIDisplayColor: contour.color || [255, 0, 0],
+            ContourSequence: contour.contourSequence,
+            ReferencedROINumber: index + 1
+        };
+        dataset.StructureSetROISequence.push(getStructureSetModule(contour, index));
+        dataset.ROIContourSequence.push(roiContour);
+        // ReferencedSeriesSequence
+        dataset.ReferencedSeriesSequence = getReferencedSeriesSequence(contour.metadata, index, metadataProvider, DicomMetadataStore);
+        // ReferencedFrameOfReferenceSequence
+        dataset.ReferencedFrameOfReferenceSequence =
+            getReferencedFrameOfReferenceSequence(contour.metadata, metadataProvider, dataset);
+    });
+    var fileMetaInformationVersionArray = new Uint8Array(2);
+    fileMetaInformationVersionArray[1] = 1;
+    var _meta = {
+        FileMetaInformationVersion: {
+            Value: [fileMetaInformationVersionArray.buffer],
+            vr: "OB"
+        },
+        TransferSyntaxUID: {
+            Value: ["1.2.840.10008.1.2.1"],
+            vr: "UI"
+        },
+        ImplementationClassUID: {
+            Value: [DicomMetaDictionary.uid()],
+            vr: "UI"
+        },
+        ImplementationVersionName: {
+            Value: ["dcmjs"],
+            vr: "SH"
+        }
+    };
+    dataset._meta = _meta;
+    return dataset;
+}
+/**
+ * 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
+ */
+function generateRTSSFromAnnotations(annotations, metadataProvider, DicomMetadataStore, options) {
+    var rtMetadata = {
+        name: "RTSS from Annotations",
+        label: "RTSS from Annotations"
+    };
+    var dataset = _initializeDataset(rtMetadata, annotations[0].metadata, metadataProvider);
+    annotations.forEach(function (annotation, index) {
+        var ContourSequence = AnnotationToPointData.convert(annotation, index, metadataProvider, options);
+        dataset.StructureSetROISequence.push(getStructureSetModule(annotation, index));
+        dataset.ROIContourSequence.push(ContourSequence);
+        dataset.RTROIObservationsSequence.push(getRTROIObservationsSequence(annotation, index));
+        // ReferencedSeriesSequence
+        // Todo: handle more than one series
+        dataset.ReferencedSeriesSequence = getReferencedSeriesSequence(annotation.metadata, index, metadataProvider, DicomMetadataStore);
+        // ReferencedFrameOfReferenceSequence
+        dataset.ReferencedFrameOfReferenceSequence =
+            getReferencedFrameOfReferenceSequence(annotation.metadata, metadataProvider, dataset);
+    });
+    var fileMetaInformationVersionArray = new Uint8Array(2);
+    fileMetaInformationVersionArray[1] = 1;
+    var _meta = {
+        FileMetaInformationVersion: {
+            Value: [fileMetaInformationVersionArray.buffer],
+            vr: "OB"
+        },
+        TransferSyntaxUID: {
+            Value: ["1.2.840.10008.1.2.1"],
+            vr: "UI"
+        },
+        ImplementationClassUID: {
+            Value: [DicomMetaDictionary.uid()],
+            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, _hooks = {}) {
+// function generateToolState() {
+//     // Todo
+//     console.warn("RTSS.generateToolState not implemented");
+// }
+function _initializeDataset(rtMetadata, imgMetadata, metadataProvider) {
+    var rtSOPInstanceUID = DicomMetaDictionary.uid();
+    // get the first annotation data
+    var imageId = imgMetadata.referencedImageId, FrameOfReferenceUID = imgMetadata.FrameOfReferenceUID;
+    var studyInstanceUID = metadataProvider.get("generalSeriesModule", imageId).studyInstanceUID;
+    var patientModule = getPatientModule(imageId, metadataProvider);
+    var rtSeriesModule = getRTSeriesModule(DicomMetaDictionary);
+    return __assign(__assign(__assign({ StructureSetROISequence: [], ROIContourSequence: [], RTROIObservationsSequence: [], ReferencedSeriesSequence: [], ReferencedFrameOfReferenceSequence: [] }, patientModule), rtSeriesModule), { StudyInstanceUID: studyInstanceUID, SOPClassUID: "1.2.840.10008.5.1.4.1.1.481.3", SOPInstanceUID: rtSOPInstanceUID, Manufacturer: "dcmjs", Modality: "RTSTRUCT", FrameOfReferenceUID: FrameOfReferenceUID, PositionReferenceIndicator: "", StructureSetLabel: rtMetadata.label || "", StructureSetName: rtMetadata.name || "", ReferringPhysicianName: "", OperatorsName: "", StructureSetDate: DicomMetaDictionary.date(), StructureSetTime: DicomMetaDictionary.time() });
+}
+
+var RTSS = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  generateContourSetsFromLabelmap: generateContourSetsFromLabelmap,
+  generateRTSSFromAnnotations: generateRTSSFromAnnotations,
+  generateRTSSFromSegmentations: generateRTSSFromSegmentations
+});
+
 var Cornerstone3DSR = {
     Bidirectional: Bidirectional,
     CobbAngle: CobbAngle,
@@ -4992,6 +5711,9 @@ var Cornerstone3DSR = {
 var Cornerstone3DSEG = {
     Segmentation: Segmentation$1
 };
+var Cornerstone3DRT = {
+    RTSS: RTSS
+};
 
 var Colors = data.Colors,
   BitArray = data.BitArray;
@@ -5189,6 +5911,9 @@ var adaptersSEG = {
     Cornerstone3D: Cornerstone3DSEG,
     VTKjs: VTKjsSEG
 };
+var adaptersRT = {
+    Cornerstone3D: Cornerstone3DRT
+};
 
-export { index as Enums, adaptersSEG, adaptersSR, index$1 as helpers };
+export { index as Enums, adaptersRT, adaptersSEG, adaptersSR, index$1 as helpers };
 //# sourceMappingURL=adapters.es.js.map