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

package/dist/esm/adapters/Cornerstone3D/MeasurementReport.js

@@ -0,0 +1,314 @@
+import { defineProperty as _defineProperty, createClass as _createClass, objectSpread2 as _objectSpread2, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { utilities, derivations, normalizers, data } from 'dcmjs';
+import CORNERSTONE_3D_TAG from './cornerstone3DTag.js';
+import { toArray } from '../helpers/toArray.js';
+import { codeMeaningEquals } from '../helpers/codeMeaningEquals.js';
+import '../helpers/downloadDICOMData.js';
+import CodingScheme from './CodingScheme.js';
+
+var _MeasurementReport;
+var TID1500 = utilities.TID1500,
+  addAccessors = utilities.addAccessors;
+var StructuredReport = derivations.StructuredReport;
+var Normalizer = normalizers.Normalizer;
+var TID1500MeasurementReport = TID1500.TID1500MeasurementReport,
+  TID1501MeasurementGroup = TID1500.TID1501MeasurementGroup;
+var DicomMetaDictionary = data.DicomMetaDictionary;
+var FINDING = {
+  CodingSchemeDesignator: "DCM",
+  CodeValue: "121071"
+};
+var FINDING_SITE = {
+  CodingSchemeDesignator: "SCT",
+  CodeValue: "363698007"
+};
+var FINDING_SITE_OLD = {
+  CodingSchemeDesignator: "SRT",
+  CodeValue: "G-C0E3"
+};
+var codeValueMatch = function codeValueMatch(group, code, oldCode) {
+  var ConceptNameCodeSequence = group.ConceptNameCodeSequence;
+  if (!ConceptNameCodeSequence) {
+    return;
+  }
+  var CodingSchemeDesignator = ConceptNameCodeSequence.CodingSchemeDesignator,
+    CodeValue = ConceptNameCodeSequence.CodeValue;
+  return CodingSchemeDesignator == code.CodingSchemeDesignator && CodeValue == code.CodeValue || oldCode && CodingSchemeDesignator == oldCode.CodingSchemeDesignator && CodeValue == oldCode.CodeValue;
+};
+function getTID300ContentItem(tool, toolType, ReferencedSOPSequence, toolClass, worldToImageCoords) {
+  var args = toolClass.getTID300RepresentationArguments(tool, worldToImageCoords);
+  args.ReferencedSOPSequence = ReferencedSOPSequence;
+  var TID300Measurement = new toolClass.TID300Representation(args);
+  return TID300Measurement;
+}
+function getMeasurementGroup(toolType, toolData, ReferencedSOPSequence, worldToImageCoords) {
+  var toolTypeData = toolData[toolType];
+  var toolClass = MeasurementReport.CORNERSTONE_TOOL_CLASSES_BY_TOOL_TYPE[toolType];
+  if (!toolTypeData || !toolTypeData.data || !toolTypeData.data.length || !toolClass) {
+    return;
+  }
+  // Loop through the array of tool instances
+  // for this tool
+  var Measurements = toolTypeData.data.map(function (tool) {
+    return getTID300ContentItem(tool, toolType, ReferencedSOPSequence, toolClass, worldToImageCoords);
+  });
+  return new TID1501MeasurementGroup(Measurements);
+}
+var MeasurementReport = /*#__PURE__*/function () {
+  function MeasurementReport() {
+    _classCallCheck(this, MeasurementReport);
+  }
+  return _createClass(MeasurementReport, null, [{
+    key: "getCornerstoneLabelFromDefaultState",
+    value: function getCornerstoneLabelFromDefaultState(defaultState) {
+      var _defaultState$finding = defaultState.findingSites,
+        findingSites = _defaultState$finding === void 0 ? [] : _defaultState$finding,
+        finding = defaultState.finding;
+      var cornersoneFreeTextCodingValue = CodingScheme.codeValues.CORNERSTONEFREETEXT;
+      var freeTextLabel = findingSites.find(function (fs) {
+        return fs.CodeValue === cornersoneFreeTextCodingValue;
+      });
+      if (freeTextLabel) {
+        return freeTextLabel.CodeMeaning;
+      }
+      if (finding && finding.CodeValue === cornersoneFreeTextCodingValue) {
+        return finding.CodeMeaning;
+      }
+    }
+  }, {
+    key: "generateDatasetMeta",
+    value: function generateDatasetMeta() {
+      // TODO: what is the correct metaheader
+      // http://dicom.nema.org/medical/Dicom/current/output/chtml/part10/chapter_7.html
+      // TODO: move meta creation to happen in derivations.js
+      var fileMetaInformationVersionArray = new Uint8Array(2);
+      fileMetaInformationVersionArray[1] = 1;
+      var _meta = {
+        FileMetaInformationVersion: {
+          Value: [fileMetaInformationVersionArray.buffer],
+          vr: "OB"
+        },
+        //MediaStorageSOPClassUID
+        //MediaStorageSOPInstanceUID: sopCommonModule.sopInstanceUID,
+        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"
+        }
+      };
+      return _meta;
+    }
+  }, {
+    key: "getSetupMeasurementData",
+    value: function getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, toolType) {
+      var ContentSequence = MeasurementGroup.ContentSequence;
+      var contentSequenceArr = toArray(ContentSequence);
+      var findingGroup = contentSequenceArr.find(function (group) {
+        return codeValueMatch(group, FINDING);
+      });
+      var findingSiteGroups = contentSequenceArr.filter(function (group) {
+        return codeValueMatch(group, FINDING_SITE, FINDING_SITE_OLD);
+      }) || [];
+      var NUMGroup = contentSequenceArr.find(function (group) {
+        return group.ValueType === "NUM";
+      });
+      var SCOORDGroup = toArray(NUMGroup.ContentSequence).find(function (group) {
+        return group.ValueType === "SCOORD";
+      });
+      var ReferencedSOPSequence = SCOORDGroup.ContentSequence.ReferencedSOPSequence;
+      var ReferencedSOPInstanceUID = ReferencedSOPSequence.ReferencedSOPInstanceUID,
+        ReferencedFrameNumber = ReferencedSOPSequence.ReferencedFrameNumber;
+      var referencedImageId = sopInstanceUIDToImageIdMap[ReferencedSOPInstanceUID];
+      var imagePlaneModule = metadata.get("imagePlaneModule", referencedImageId);
+      var finding = findingGroup ? addAccessors(findingGroup.ConceptCodeSequence) : undefined;
+      var findingSites = findingSiteGroups.map(function (fsg) {
+        return addAccessors(fsg.ConceptCodeSequence);
+      });
+      var defaultState = {
+        description: undefined,
+        sopInstanceUid: ReferencedSOPInstanceUID,
+        annotation: {
+          annotationUID: DicomMetaDictionary.uid(),
+          metadata: {
+            toolName: toolType,
+            referencedImageId: referencedImageId,
+            FrameOfReferenceUID: imagePlaneModule.frameOfReferenceUID,
+            label: ""
+          },
+          data: undefined
+        },
+        finding: finding,
+        findingSites: findingSites
+      };
+      if (defaultState.finding) {
+        defaultState.description = defaultState.finding.CodeMeaning;
+      }
+      defaultState.annotation.metadata.label = MeasurementReport.getCornerstoneLabelFromDefaultState(defaultState);
+      return {
+        defaultState: defaultState,
+        NUMGroup: NUMGroup,
+        SCOORDGroup: SCOORDGroup,
+        ReferencedSOPSequence: ReferencedSOPSequence,
+        ReferencedSOPInstanceUID: ReferencedSOPInstanceUID,
+        ReferencedFrameNumber: ReferencedFrameNumber
+      };
+    }
+  }, {
+    key: "generateReport",
+    value: function generateReport(toolState, metadataProvider, worldToImageCoords, options) {
+      // ToolState for array of imageIDs to a Report
+      // Assume Cornerstone metadata provider has access to Study / Series / Sop Instance UID
+      var allMeasurementGroups = [];
+      /* Patient ID
+      Warning - Missing attribute or value that would be needed to build DICOMDIR - Patient ID
+      Warning - Missing attribute or value that would be needed to build DICOMDIR - Study Date
+      Warning - Missing attribute or value that would be needed to build DICOMDIR - Study Time
+      Warning - Missing attribute or value that would be needed to build DICOMDIR - Study ID
+      */
+      var sopInstanceUIDsToSeriesInstanceUIDMap = {};
+      var derivationSourceDatasets = [];
+      var _meta = MeasurementReport.generateDatasetMeta();
+      // Loop through each image in the toolData
+      Object.keys(toolState).forEach(function (imageId) {
+        var sopCommonModule = metadataProvider.get("sopCommonModule", imageId);
+        var instance = metadataProvider.get("instance", imageId);
+        var sopInstanceUID = sopCommonModule.sopInstanceUID,
+          sopClassUID = sopCommonModule.sopClassUID;
+        var seriesInstanceUID = instance.SeriesInstanceUID;
+        sopInstanceUIDsToSeriesInstanceUIDMap[sopInstanceUID] = seriesInstanceUID;
+        if (!derivationSourceDatasets.find(function (dsd) {
+          return dsd.SeriesInstanceUID === seriesInstanceUID;
+        })) {
+          // Entry not present for series, create one.
+          var derivationSourceDataset = MeasurementReport.generateDerivationSourceDataset(instance);
+          derivationSourceDatasets.push(derivationSourceDataset);
+        }
+        var frameNumber = metadataProvider.get("frameNumber", imageId);
+        var toolData = toolState[imageId];
+        var toolTypes = Object.keys(toolData);
+        var ReferencedSOPSequence = {
+          ReferencedSOPClassUID: sopClassUID,
+          ReferencedSOPInstanceUID: sopInstanceUID,
+          ReferencedFrameNumber: undefined
+        };
+        if (instance && instance.NumberOfFrames && instance.NumberOfFrames > 1 || Normalizer.isMultiframeSOPClassUID(sopClassUID)) {
+          ReferencedSOPSequence.ReferencedFrameNumber = frameNumber;
+        }
+        // Loop through each tool type for the image
+        var measurementGroups = [];
+        toolTypes.forEach(function (toolType) {
+          var group = getMeasurementGroup(toolType, toolData, ReferencedSOPSequence, worldToImageCoords);
+          if (group) {
+            measurementGroups.push(group);
+          }
+        });
+        allMeasurementGroups = allMeasurementGroups.concat(measurementGroups);
+      });
+      var tid1500MeasurementReport = new TID1500MeasurementReport({
+        TID1501MeasurementGroups: allMeasurementGroups
+      }, options);
+      var report = new StructuredReport(derivationSourceDatasets, options);
+      var contentItem = tid1500MeasurementReport.contentItem(derivationSourceDatasets, _objectSpread2(_objectSpread2({}, options), {}, {
+        sopInstanceUIDsToSeriesInstanceUIDMap: sopInstanceUIDsToSeriesInstanceUIDMap
+      }));
+      // Merge the derived dataset with the content from the Measurement Report
+      report.dataset = Object.assign(report.dataset, contentItem);
+      report.dataset._meta = _meta;
+      report.SpecificCharacterSet = "ISO_IR 192";
+      return report;
+    }
+    /**
+     * Generate Cornerstone tool state from dataset
+     */
+  }, {
+    key: "generateToolState",
+    value: function generateToolState(dataset, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata, hooks) {
+      // For now, bail out if the dataset is not a TID1500 SR with length measurements
+      if (dataset.ContentTemplateSequence.TemplateIdentifier !== "1500") {
+        throw new Error("This package can currently only interpret DICOM SR TID 1500");
+      }
+      var REPORT = "Imaging Measurements";
+      var GROUP = "Measurement Group";
+      var TRACKING_IDENTIFIER = "Tracking Identifier";
+      var TRACKING_UNIQUE_IDENTIFIER = "Tracking Unique Identifier";
+      // Identify the Imaging Measurements
+      var imagingMeasurementContent = toArray(dataset.ContentSequence).find(codeMeaningEquals(REPORT));
+      // Retrieve the Measurements themselves
+      var measurementGroups = toArray(imagingMeasurementContent.ContentSequence).filter(codeMeaningEquals(GROUP));
+      // For each of the supported measurement types, compute the measurement data
+      var measurementData = {};
+      var cornerstoneToolClasses = MeasurementReport.CORNERSTONE_TOOL_CLASSES_BY_UTILITY_TYPE;
+      var registeredToolClasses = [];
+      Object.keys(cornerstoneToolClasses).forEach(function (key) {
+        registeredToolClasses.push(cornerstoneToolClasses[key]);
+        measurementData[key] = [];
+      });
+      measurementGroups.forEach(function (measurementGroup) {
+        try {
+          var _hooks$getToolClass;
+          var measurementGroupContentSequence = toArray(measurementGroup.ContentSequence);
+          var TrackingIdentifierGroup = measurementGroupContentSequence.find(function (contentItem) {
+            return contentItem.ConceptNameCodeSequence.CodeMeaning === TRACKING_IDENTIFIER;
+          });
+          var TrackingIdentifierValue = TrackingIdentifierGroup.TextValue;
+          var TrackingUniqueIdentifierGroup = measurementGroupContentSequence.find(function (contentItem) {
+            return contentItem.ConceptNameCodeSequence.CodeMeaning === TRACKING_UNIQUE_IDENTIFIER;
+          });
+          var TrackingUniqueIdentifierValue = TrackingUniqueIdentifierGroup === null || TrackingUniqueIdentifierGroup === void 0 ? void 0 : TrackingUniqueIdentifierGroup.UID;
+          var toolClass = (hooks === null || hooks === void 0 || (_hooks$getToolClass = hooks.getToolClass) === null || _hooks$getToolClass === void 0 ? void 0 : _hooks$getToolClass.call(hooks, measurementGroup, dataset, registeredToolClasses)) || registeredToolClasses.find(function (tc) {
+            return tc.isValidCornerstoneTrackingIdentifier(TrackingIdentifierValue);
+          });
+          if (toolClass) {
+            var measurement = toolClass.getMeasurementData(measurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata);
+            measurement.TrackingUniqueIdentifier = TrackingUniqueIdentifierValue;
+            console.log("=== ".concat(toolClass.toolType, " ==="));
+            console.log(measurement);
+            measurementData[toolClass.toolType].push(measurement);
+          }
+        } catch (e) {
+          console.warn("Unable to generate tool state for", measurementGroup, e);
+        }
+      });
+      // NOTE: There is no way of knowing the cornerstone imageIds as that could be anything.
+      // That is up to the consumer to derive from the SOPInstanceUIDs.
+      return measurementData;
+    }
+    /**
+     * Register a new tool type.
+     * @param toolClass to perform I/O to DICOM for this tool
+     */
+  }, {
+    key: "registerTool",
+    value: function registerTool(toolClass) {
+      MeasurementReport.CORNERSTONE_TOOL_CLASSES_BY_UTILITY_TYPE[toolClass.utilityToolType] = toolClass;
+      MeasurementReport.CORNERSTONE_TOOL_CLASSES_BY_TOOL_TYPE[toolClass.toolType] = toolClass;
+      MeasurementReport.MEASUREMENT_BY_TOOLTYPE[toolClass.toolType] = toolClass.utilityToolType;
+    }
+  }]);
+}();
+_MeasurementReport = MeasurementReport;
+_defineProperty(MeasurementReport, "CORNERSTONE_3D_TAG", CORNERSTONE_3D_TAG);
+_defineProperty(MeasurementReport, "MEASUREMENT_BY_TOOLTYPE", {});
+_defineProperty(MeasurementReport, "CORNERSTONE_TOOL_CLASSES_BY_UTILITY_TYPE", {});
+_defineProperty(MeasurementReport, "CORNERSTONE_TOOL_CLASSES_BY_TOOL_TYPE", {});
+_defineProperty(MeasurementReport, "generateDerivationSourceDataset", function (instance) {
+  var _vrMap = {
+    PixelData: "OW"
+  };
+  var _meta = _MeasurementReport.generateDatasetMeta();
+  var derivationSourceDataset = _objectSpread2(_objectSpread2({}, instance), {}, {
+    _meta: _meta,
+    _vrMap: _vrMap
+  });
+  return derivationSourceDataset;
+});
+
+export { MeasurementReport as default };

package/dist/{types → esm}/adapters/Cornerstone3D/PlanarFreehandROI.d.ts

@@ -20,9 +20,16 @@ declare class PlanarFreehandROI {
         findingSites: any[];
     };
     static getTID300RepresentationArguments(tool: any, worldToImageCoords: any): {
+        /** From cachedStats */
         points: any;
-        area: number;
-        perimeter: number;
+        area: any;
+        areaUnits: any;
+        perimeter: any;
+        pixelValueUnits: any;
+        mean: any;
+        max: any;
+        stdDev: any;
+        /** Other */
         trackingIdentifierTextValue: string;
         finding: any;
         findingSites: any;

package/dist/esm/adapters/Cornerstone3D/PlanarFreehandROI.js

@@ -0,0 +1,129 @@
+import { defineProperty as _defineProperty, createClass as _createClass, slicedToArray as _slicedToArray, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import MeasurementReport from './MeasurementReport.js';
+import { utilities } from 'dcmjs';
+import CORNERSTONE_3D_TAG from './cornerstone3DTag.js';
+import { vec3 } from 'gl-matrix';
+
+var TID300Polyline = utilities.TID300.Polyline;
+var PLANARFREEHANDROI = "PlanarFreehandROI";
+var trackingIdentifierTextValue = "".concat(CORNERSTONE_3D_TAG, ":").concat(PLANARFREEHANDROI);
+var closedContourThreshold = 1e-5;
+var PlanarFreehandROI = /*#__PURE__*/function () {
+  function PlanarFreehandROI() {
+    _classCallCheck(this, PlanarFreehandROI);
+  }
+  return _createClass(PlanarFreehandROI, null, [{
+    key: "getMeasurementData",
+    value: function getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+      var _MeasurementReport$ge = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, PlanarFreehandROI.toolType),
+        defaultState = _MeasurementReport$ge.defaultState,
+        NUMGroup = _MeasurementReport$ge.NUMGroup,
+        SCOORDGroup = _MeasurementReport$ge.SCOORDGroup,
+        ReferencedFrameNumber = _MeasurementReport$ge.ReferencedFrameNumber;
+      var referencedImageId = defaultState.annotation.metadata.referencedImageId;
+      var GraphicData = SCOORDGroup.GraphicData;
+      var worldCoords = [];
+      for (var i = 0; i < GraphicData.length; i += 2) {
+        var point = imageToWorldCoords(referencedImageId, [GraphicData[i], GraphicData[i + 1]]);
+        worldCoords.push(point);
+      }
+      var distanceBetweenFirstAndLastPoint = vec3.distance(worldCoords[worldCoords.length - 1], worldCoords[0]);
+      var isOpenContour = true;
+      // If the contour is closed, this should have been encoded as exactly the same point, so check for a very small difference.
+      if (distanceBetweenFirstAndLastPoint < closedContourThreshold) {
+        worldCoords.pop(); // Remove the last element which is duplicated.
+        isOpenContour = false;
+      }
+      var points = [];
+      if (isOpenContour) {
+        points.push(worldCoords[0], worldCoords[worldCoords.length - 1]);
+      }
+      var state = defaultState;
+      state.annotation.data = {
+        contour: {
+          polyline: worldCoords,
+          closed: !isOpenContour
+        },
+        handles: {
+          points: points,
+          activeHandleIndex: null,
+          textBox: {
+            hasMoved: false
+          }
+        },
+        cachedStats: _defineProperty({}, "imageId:".concat(referencedImageId), {
+          area: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : null
+        }),
+        frameNumber: ReferencedFrameNumber
+      };
+      return state;
+    }
+  }, {
+    key: "getTID300RepresentationArguments",
+    value: function getTID300RepresentationArguments(tool, worldToImageCoords) {
+      var data = tool.data,
+        finding = tool.finding,
+        findingSites = tool.findingSites,
+        metadata = tool.metadata;
+      var _data$contour = data.contour,
+        polyline = _data$contour.polyline,
+        closed = _data$contour.closed;
+      var isOpenContour = closed !== true;
+      var referencedImageId = metadata.referencedImageId;
+      if (!referencedImageId) {
+        throw new Error("PlanarFreehandROI.getTID300RepresentationArguments: referencedImageId is not defined");
+      }
+      var points = polyline.map(function (worldPos) {
+        return worldToImageCoords(referencedImageId, worldPos);
+      });
+      if (!isOpenContour) {
+        // Need to repeat the first point at the end of to have an explicitly closed contour.
+        var firstPoint = points[0];
+        // Explicitly expand to avoid circular references.
+        points.push([firstPoint[0], firstPoint[1]]);
+      }
+      var _ref = data.cachedStats["imageId:".concat(referencedImageId)] || {},
+        area = _ref.area,
+        areaUnits = _ref.areaUnits,
+        pixelValueUnits = _ref.pixelValueUnits,
+        perimeter = _ref.perimeter,
+        mean = _ref.mean,
+        max = _ref.max,
+        stdDev = _ref.stdDev;
+      return {
+        /** From cachedStats */
+        points: points,
+        area: area,
+        areaUnits: areaUnits,
+        perimeter: perimeter,
+        pixelValueUnits: pixelValueUnits,
+        mean: mean,
+        max: max,
+        stdDev: stdDev,
+        /** Other */
+        trackingIdentifierTextValue: trackingIdentifierTextValue,
+        finding: finding,
+        findingSites: findingSites || []
+      };
+    }
+  }]);
+}();
+_defineProperty(PlanarFreehandROI, "toolType", PLANARFREEHANDROI);
+_defineProperty(PlanarFreehandROI, "utilityToolType", PLANARFREEHANDROI);
+_defineProperty(PlanarFreehandROI, "TID300Representation", TID300Polyline);
+_defineProperty(PlanarFreehandROI, "isValidCornerstoneTrackingIdentifier", function (TrackingIdentifier) {
+  if (!TrackingIdentifier.includes(":")) {
+    return false;
+  }
+  var _TrackingIdentifier$s = TrackingIdentifier.split(":"),
+    _TrackingIdentifier$s2 = _slicedToArray(_TrackingIdentifier$s, 2),
+    cornerstone3DTag = _TrackingIdentifier$s2[0],
+    toolType = _TrackingIdentifier$s2[1];
+  if (cornerstone3DTag !== CORNERSTONE_3D_TAG) {
+    return false;
+  }
+  return toolType === PLANARFREEHANDROI;
+});
+MeasurementReport.registerTool(PlanarFreehandROI);
+
+export { PlanarFreehandROI as default };

package/dist/esm/adapters/Cornerstone3D/Probe.d.ts

@@ -0,0 +1,33 @@
+export default Probe;
+declare class Probe {
+    static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any): {
+        description: any;
+        sopInstanceUid: any;
+        annotation: {
+            annotationUID: any;
+            metadata: {
+                toolName: any;
+                referencedImageId: any;
+                FrameOfReferenceUID: any;
+                label: string;
+            };
+            data: any;
+        };
+        finding: any;
+        findingSites: any[];
+    };
+    static getTID300RepresentationArguments(tool: any, worldToImageCoords: any): {
+        points: any;
+        trackingIdentifierTextValue: string;
+        findingSites: any;
+        finding: any;
+    };
+}
+declare namespace Probe {
+    export { PROBE as toolType };
+    export { PROBE as utilityToolType };
+    export { TID300Point as TID300Representation };
+    export function isValidCornerstoneTrackingIdentifier(TrackingIdentifier: any): boolean;
+}
+declare const PROBE: "Probe";
+declare const TID300Point: any;

package/dist/esm/adapters/Cornerstone3D/Probe.js

@@ -0,0 +1,87 @@
+import { slicedToArray as _slicedToArray, createClass as _createClass, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { utilities } from 'dcmjs';
+import CORNERSTONE_3D_TAG from './cornerstone3DTag.js';
+import MeasurementReport from './MeasurementReport.js';
+
+var TID300Point = utilities.TID300.Point;
+var PROBE = "Probe";
+var trackingIdentifierTextValue = "".concat(CORNERSTONE_3D_TAG, ":").concat(PROBE);
+var Probe = /*#__PURE__*/function () {
+  function Probe() {
+    _classCallCheck(this, Probe);
+  }
+  return _createClass(Probe, null, [{
+    key: "getMeasurementData",
+    value: function getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+      var _MeasurementReport$ge = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, Probe.toolType),
+        defaultState = _MeasurementReport$ge.defaultState,
+        SCOORDGroup = _MeasurementReport$ge.SCOORDGroup,
+        ReferencedFrameNumber = _MeasurementReport$ge.ReferencedFrameNumber;
+      var referencedImageId = defaultState.annotation.metadata.referencedImageId;
+      var GraphicData = SCOORDGroup.GraphicData;
+      var worldCoords = [];
+      for (var i = 0; i < GraphicData.length; i += 2) {
+        var point = imageToWorldCoords(referencedImageId, [GraphicData[i], GraphicData[i + 1]]);
+        worldCoords.push(point);
+      }
+      var state = defaultState;
+      state.annotation.data = {
+        handles: {
+          points: worldCoords,
+          activeHandleIndex: null,
+          textBox: {
+            hasMoved: false
+          }
+        },
+        frameNumber: ReferencedFrameNumber
+      };
+      return state;
+    }
+  }, {
+    key: "getTID300RepresentationArguments",
+    value: function getTID300RepresentationArguments(tool, worldToImageCoords) {
+      var data = tool.data,
+        metadata = tool.metadata;
+      var finding = tool.finding,
+        findingSites = tool.findingSites;
+      var referencedImageId = metadata.referencedImageId;
+      if (!referencedImageId) {
+        throw new Error("Probe.getTID300RepresentationArguments: referencedImageId is not defined");
+      }
+      var points = data.handles.points;
+      var pointsImage = points.map(function (point) {
+        var pointImage = worldToImageCoords(referencedImageId, point);
+        return {
+          x: pointImage[0],
+          y: pointImage[1]
+        };
+      });
+      var TID300RepresentationArguments = {
+        points: pointsImage,
+        trackingIdentifierTextValue: trackingIdentifierTextValue,
+        findingSites: findingSites || [],
+        finding: finding
+      };
+      return TID300RepresentationArguments;
+    }
+  }]);
+}();
+Probe.toolType = PROBE;
+Probe.utilityToolType = PROBE;
+Probe.TID300Representation = TID300Point;
+Probe.isValidCornerstoneTrackingIdentifier = function (TrackingIdentifier) {
+  if (!TrackingIdentifier.includes(":")) {
+    return false;
+  }
+  var _TrackingIdentifier$s = TrackingIdentifier.split(":"),
+    _TrackingIdentifier$s2 = _slicedToArray(_TrackingIdentifier$s, 2),
+    cornerstone3DTag = _TrackingIdentifier$s2[0],
+    toolType = _TrackingIdentifier$s2[1];
+  if (cornerstone3DTag !== CORNERSTONE_3D_TAG) {
+    return false;
+  }
+  return toolType === PROBE;
+};
+MeasurementReport.registerTool(Probe);
+
+export { Probe as default };

package/dist/esm/adapters/Cornerstone3D/RTStruct/RTSS.d.ts

@@ -0,0 +1,90 @@
+/**
+ * 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
+ */
+declare function generateRTSSFromSegmentations(segmentations: any, metadataProvider: any, DicomMetadataStore: any): {
+    StudyInstanceUID: any;
+    SOPClassUID: string;
+    SOPInstanceUID: any;
+    Manufacturer: string;
+    Modality: string;
+    FrameOfReferenceUID: any;
+    PositionReferenceIndicator: string;
+    StructureSetLabel: any;
+    StructureSetName: any;
+    ReferringPhysicianName: string;
+    OperatorsName: string;
+    StructureSetDate: any;
+    StructureSetTime: any;
+    _meta: any;
+    SeriesInstanceUID: any;
+    SeriesNumber: string;
+    PatientID: any;
+    PatientName: any;
+    PatientBirthDate: string;
+    PatientAge: any;
+    PatientSex: any;
+    PatientWeight: any;
+    StudyDate: any;
+    StudyTime: any;
+    StudyID: string;
+    AccessionNumber: any;
+    StructureSetROISequence: any[];
+    ROIContourSequence: any[];
+    RTROIObservationsSequence: any[];
+    ReferencedSeriesSequence: any[];
+    ReferencedFrameOfReferenceSequence: any[];
+};
+/**
+ * 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
+ * @returns Report object containing the dataset
+ */
+declare function generateRTSSFromAnnotations(annotations: any, metadataProvider: any, DicomMetadataStore: any): {
+    StudyInstanceUID: any;
+    SOPClassUID: string;
+    SOPInstanceUID: any;
+    Manufacturer: string;
+    Modality: string;
+    FrameOfReferenceUID: any;
+    PositionReferenceIndicator: string;
+    StructureSetLabel: any;
+    StructureSetName: any;
+    ReferringPhysicianName: string;
+    OperatorsName: string;
+    StructureSetDate: any;
+    StructureSetTime: any;
+    _meta: any;
+    SeriesInstanceUID: any;
+    SeriesNumber: string;
+    PatientID: any;
+    PatientName: any;
+    PatientBirthDate: string;
+    PatientAge: any;
+    PatientSex: any;
+    PatientWeight: any;
+    StudyDate: any;
+    StudyTime: any;
+    StudyID: string;
+    AccessionNumber: any;
+    StructureSetROISequence: any[];
+    ROIContourSequence: any[];
+    RTROIObservationsSequence: any[];
+    ReferencedSeriesSequence: any[];
+    ReferencedFrameOfReferenceSequence: any[];
+};
+export { generateRTSSFromSegmentations, generateRTSSFromAnnotations };