@cornerstonejs/adapters 2.0.0-beta.8 → 2.0.1

package/dist/esm/adapters/Cornerstone3D/RTStruct/RTSS.js

@@ -0,0 +1,175 @@
+import { objectSpread2 as _objectSpread2 } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import { utilities } from '@cornerstonejs/tools';
+import dcmjs from 'dcmjs';
+import getPatientModule from './utilities/getPatientModule.js';
+import getReferencedFrameOfReferenceSequence from './utilities/getReferencedFrameOfReferenceSequence.js';
+import getReferencedSeriesSequence from './utilities/getReferencedSeriesSequence.js';
+import getRTROIObservationsSequence from './utilities/getRTROIObservationsSequence.js';
+import getRTSeriesModule from './utilities/getRTSeriesModule.js';
+import getStructureSetModule from './utilities/getStructureSetModule.js';
+
+var _utilities$contours = utilities.contours,
+  generateContourSetsFromLabelmap = _utilities$contours.generateContourSetsFromLabelmap,
+  AnnotationToPointData = _utilities$contours.AnnotationToPointData;
+var DicomMetaDictionary = dcmjs.data.DicomMetaDictionary;
+function generateRTSSFromSegmentations(segmentations, metadataProvider, DicomMetadataStore) {
+  var roiContours = [];
+  var contourSets = generateContourSetsFromLabelmap({
+    segmentations: segmentations
+  });
+  contourSets.forEach(function (contourSet, segIndex) {
+    if (contourSet) {
+      var contourSequence = [];
+      contourSet.sliceContours.forEach(function (sliceContour) {
+        var sopCommon = metadataProvider.get("sopCommonModule", sliceContour.referencedImageId);
+        var ReferencedSOPClassUID = sopCommon.sopClassUID;
+        var ReferencedSOPInstanceUID = sopCommon.sopInstanceUID;
+        var ContourImageSequence = [{
+          ReferencedSOPClassUID: ReferencedSOPClassUID,
+          ReferencedSOPInstanceUID: ReferencedSOPInstanceUID
+        }];
+        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.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,
+        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);
+    dataset.ReferencedSeriesSequence = getReferencedSeriesSequence(contour.metadata, index, metadataProvider, DicomMetadataStore);
+    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;
+  dataset.SpecificCharacterSet = "ISO_IR 192";
+  return dataset;
+}
+function generateRTSSFromAnnotations(annotations, metadataProvider, DicomMetadataStore) {
+  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);
+    dataset.StructureSetROISequence.push(getStructureSetModule(annotation, index));
+    dataset.ROIContourSequence.push(ContourSequence);
+    dataset.RTROIObservationsSequence.push(getRTROIObservationsSequence(annotation, index));
+    dataset.ReferencedSeriesSequence = getReferencedSeriesSequence(annotation.metadata, index, metadataProvider, DicomMetadataStore);
+    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;
+  dataset.SpecificCharacterSet = "ISO_IR 192";
+  return dataset;
+}
+function _initializeDataset(rtMetadata, imgMetadata, metadataProvider) {
+  var rtSOPInstanceUID = DicomMetaDictionary.uid();
+  var imageId = imgMetadata.referencedImageId,
+    FrameOfReferenceUID = imgMetadata.FrameOfReferenceUID;
+  var _metadataProvider$get = metadataProvider.get("generalSeriesModule", imageId),
+    studyInstanceUID = _metadataProvider$get.studyInstanceUID;
+  var patientModule = getPatientModule(imageId, metadataProvider);
+  var rtSeriesModule = getRTSeriesModule(DicomMetaDictionary);
+  return _objectSpread2(_objectSpread2(_objectSpread2({
+    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(),
+    _meta: null
+  });
+}
+
+export { generateRTSSFromAnnotations, generateRTSSFromSegmentations };

package/dist/esm/adapters/Cornerstone3D/RTStruct/index.js

@@ -0,0 +1,6 @@
+import { utilities } from '@cornerstonejs/tools';
+export { generateRTSSFromAnnotations, generateRTSSFromSegmentations } from './RTSS.js';
+
+var generateContourSetsFromLabelmap = utilities.contours.generateContourSetsFromLabelmap;
+
+export { generateContourSetsFromLabelmap };

package/dist/esm/adapters/Cornerstone3D/RTStruct/utilities/getPatientModule.d.ts

@@ -0,0 +1,13 @@
+export default function getPatientModule(imageId: any, metadataProvider: any): {
+    Modality: any;
+    PatientID: any;
+    PatientName: any;
+    PatientBirthDate: string;
+    PatientAge: any;
+    PatientSex: any;
+    PatientWeight: any;
+    StudyDate: any;
+    StudyTime: any;
+    StudyID: string;
+    AccessionNumber: any;
+};

package/dist/esm/adapters/Cornerstone3D/RTStruct/utilities/getPatientModule.js

@@ -0,0 +1,22 @@
+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
+  };
+}
+
+export { getPatientModule as default };

package/dist/esm/adapters/Cornerstone3D/RTStruct/utilities/getRTROIObservationsSequence.d.ts

@@ -0,0 +1,6 @@
+export default function getRTROIObservationsSequence(toolData: any, index: any): {
+    ObservationNumber: any;
+    ReferencedROINumber: any;
+    RTROIInterpretedType: string;
+    ROIInterpreter: string;
+};

package/dist/esm/adapters/Cornerstone3D/RTStruct/utilities/getRTROIObservationsSequence.js

@@ -0,0 +1,10 @@
+function getRTROIObservationsSequence(toolData, index) {
+  return {
+    ObservationNumber: index + 1,
+    ReferencedROINumber: index + 1,
+    RTROIInterpretedType: "Todo: type",
+    ROIInterpreter: "Todo: interpreter"
+  };
+}
+
+export { getRTROIObservationsSequence as default };

package/dist/esm/adapters/Cornerstone3D/RTStruct/utilities/getRTSeriesModule.d.ts

@@ -0,0 +1,4 @@
+export default function getRTSeriesModule(DicomMetaDictionary: any): {
+    SeriesInstanceUID: any;
+    SeriesNumber: string;
+};

package/dist/esm/adapters/Cornerstone3D/RTStruct/utilities/getRTSeriesModule.js

@@ -0,0 +1,9 @@
+function getRTSeriesModule(DicomMetaDictionary) {
+  return {
+    SeriesInstanceUID: DicomMetaDictionary.uid(),
+    // generate a new series instance uid
+    SeriesNumber: "99" // Todo:: what should be the series number?
+  };
+}
+
+export { getRTSeriesModule as default };

package/dist/esm/adapters/Cornerstone3D/RTStruct/utilities/getReferencedFrameOfReferenceSequence.d.ts

@@ -0,0 +1,11 @@
+export default function getReferencedFrameOfReferenceSequence(metadata: any, metadataProvider: any, dataset: any): {
+    FrameOfReferenceUID: any;
+    RTReferencedStudySequence: {
+        ReferencedSOPClassUID: any;
+        ReferencedSOPInstanceUID: any;
+        RTReferencedSeriesSequence: {
+            SeriesInstanceUID: any;
+            ContourImageSequence: any[];
+        }[];
+    }[];
+}[];

package/dist/esm/adapters/Cornerstone3D/RTStruct/utilities/getReferencedFrameOfReferenceSequence.js

@@ -0,0 +1,22 @@
+import { toConsumableArray as _toConsumableArray } from '../../../../_virtual/_rollupPluginBabelHelpers.js';
+
+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)
+      }]
+    }]
+  }];
+}
+
+export { getReferencedFrameOfReferenceSequence as default };

package/dist/esm/adapters/Cornerstone3D/RTStruct/utilities/getReferencedSeriesSequence.d.ts

@@ -0,0 +1,4 @@
+export default function getReferencedSeriesSequence(metadata: any, _index: any, metadataProvider: any, DicomMetadataStore: any): {
+    SeriesInstanceUID: any;
+    ReferencedInstanceSequence: any[];
+}[];

package/dist/esm/adapters/Cornerstone3D/RTStruct/utilities/getReferencedSeriesSequence.js

@@ -0,0 +1,27 @@
+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;
+}
+
+export { getReferencedSeriesSequence as default };

package/dist/esm/adapters/Cornerstone3D/RTStruct/utilities/getStructureSetModule.d.ts

@@ -0,0 +1,7 @@
+export default function getStructureSetModule(contour: any, index: any): {
+    ROINumber: any;
+    ROIName: any;
+    ROIDescription: string;
+    ROIGenerationAlgorithm: string;
+    ReferencedFrameOfReferenceUID: any;
+};

package/dist/esm/adapters/Cornerstone3D/RTStruct/utilities/getStructureSetModule.js

@@ -0,0 +1,12 @@
+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
+  };
+}
+
+export { getStructureSetModule as default };

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

@@ -0,0 +1,94 @@
+import { slicedToArray as _slicedToArray, createClass as _createClass, defineProperty as _defineProperty, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { utilities } from 'dcmjs';
+import CORNERSTONE_3D_TAG from './cornerstone3DTag.js';
+import MeasurementReport from './MeasurementReport.js';
+
+var _RectangleROI;
+var TID300Polyline = utilities.TID300.Polyline;
+var TOOLTYPE = "RectangleROI";
+var trackingIdentifierTextValue = "".concat(CORNERSTONE_3D_TAG, ":").concat(TOOLTYPE);
+var RectangleROI = /*#__PURE__*/function () {
+  function RectangleROI() {
+    _classCallCheck(this, RectangleROI);
+  }
+  return _createClass(RectangleROI, null, [{
+    key: "getMeasurementData",
+    value: function getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+      var _MeasurementReport$ge = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, RectangleROI.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 state = defaultState;
+      state.annotation.data = {
+        handles: {
+          points: [worldCoords[0], worldCoords[1], worldCoords[3], worldCoords[2]],
+          activeHandleIndex: 0,
+          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$cachedStats = data.cachedStats,
+        cachedStats = _data$cachedStats === void 0 ? {} : _data$cachedStats,
+        handles = data.handles;
+      var referencedImageId = metadata.referencedImageId;
+      if (!referencedImageId) {
+        throw new Error("CobbAngle.getTID300RepresentationArguments: referencedImageId is not defined");
+      }
+      var corners = handles.points.map(function (point) {
+        return worldToImageCoords(referencedImageId, point);
+      });
+      var area = cachedStats.area,
+        perimeter = cachedStats.perimeter;
+      return {
+        points: [corners[0], corners[1], corners[3], corners[2], corners[0]],
+        area: area,
+        perimeter: perimeter,
+        trackingIdentifierTextValue: trackingIdentifierTextValue,
+        finding: finding,
+        findingSites: findingSites || []
+      };
+    }
+  }]);
+}();
+_RectangleROI = RectangleROI;
+_RectangleROI.toolType = TOOLTYPE;
+_RectangleROI.utilityToolType = TOOLTYPE;
+_RectangleROI.TID300Representation = TID300Polyline;
+_RectangleROI.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 === TOOLTYPE;
+};
+MeasurementReport.registerTool(RectangleROI);
+
+export { RectangleROI as default };

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

@@ -1,9 +1,3 @@
-/**
- * Generates 2D label maps from a 3D label map.
- * @param labelmap3D - The 3D label map object to generate 2D label maps from. It is derived
- * from the volume labelmap.
- * @returns The label map object containing the 2D label maps and segments on label maps.
- */
 declare function generateLabelMaps2DFrom3D(labelmap3D: any): {
     scalarData: number[];
     dimensions: number[];

package/dist/esm/adapters/Cornerstone3D/Segmentation/generateLabelMaps2DFrom3D.js

@@ -0,0 +1,34 @@
+function generateLabelMaps2DFrom3D(labelmap3D) {
+  var scalarData = labelmap3D.scalarData,
+    dimensions = labelmap3D.dimensions;
+  var labelmaps2D = [];
+  var segmentsOnLabelmap3D = new Set();
+  for (var z = 0; z < dimensions[2]; z++) {
+    var pixelData = scalarData.slice(z * dimensions[0] * dimensions[1], (z + 1) * dimensions[0] * dimensions[1]);
+    var segmentsOnLabelmap = [];
+    for (var i = 0; i < pixelData.length; i++) {
+      var segment = pixelData[i];
+      if (!segmentsOnLabelmap.includes(segment) && segment !== 0) {
+        segmentsOnLabelmap.push(segment);
+      }
+    }
+    var labelmap2D = {
+      segmentsOnLabelmap: segmentsOnLabelmap,
+      pixelData: pixelData,
+      rows: dimensions[1],
+      columns: dimensions[0]
+    };
+    if (segmentsOnLabelmap.length === 0) {
+      continue;
+    }
+    segmentsOnLabelmap.forEach(function (segmentIndex) {
+      segmentsOnLabelmap3D.add(segmentIndex);
+    });
+    labelmaps2D[dimensions[2] - 1 - z] = labelmap2D;
+  }
+  labelmap3D.segmentsOnLabelmap = Array.from(segmentsOnLabelmap3D);
+  labelmap3D.labelmaps2D = labelmaps2D;
+  return labelmap3D;
+}
+
+export { generateLabelMaps2DFrom3D };

package/dist/esm/adapters/Cornerstone3D/Segmentation/generateSegmentation.d.ts

@@ -0,0 +1,2 @@
+declare function generateSegmentation(images: any, labelmaps: any, metadata: any, options?: {}): any;
+export { generateSegmentation };

package/dist/esm/adapters/Cornerstone3D/Segmentation/generateSegmentation.js

@@ -0,0 +1,29 @@
+import { objectSpread2 as _objectSpread2 } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import { normalizers, derivations } from 'dcmjs';
+import { fillSegmentation } from '../../Cornerstone/Segmentation_4X.js';
+
+var Normalizer = normalizers.Normalizer;
+var SegmentationDerivation = derivations.Segmentation;
+function generateSegmentation(images, labelmaps, metadata) {
+  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  var segmentation = _createMultiframeSegmentationFromReferencedImages(images, metadata, options);
+  return fillSegmentation(segmentation, labelmaps, options);
+}
+function _createMultiframeSegmentationFromReferencedImages(images, metadata, options) {
+  var datasets = images.map(function (image) {
+    var instance = metadata.get("instance", image.imageId);
+    return _objectSpread2(_objectSpread2(_objectSpread2({}, image), instance), {}, {
+      SOPClassUID: instance.SopClassUID || instance.SOPClassUID,
+      SOPInstanceUID: instance.SopInstanceUID || instance.SOPInstanceUID,
+      PixelData: image.voxelManager.getScalarData(),
+      _vrMap: {
+        PixelData: "OW"
+      },
+      _meta: {}
+    });
+  });
+  var multiframe = Normalizer.normalizeToDataset(datasets);
+  return new SegmentationDerivation([multiframe], options);
+}
+
+export { generateSegmentation };

package/dist/esm/adapters/Cornerstone3D/Segmentation/generateToolState.d.ts

@@ -0,0 +1,2 @@
+declare function generateToolState(imageIds: any, arrayBuffer: any, metadataProvider: any, skipOverlapping?: boolean, tolerance?: number): any;
+export { generateToolState };

package/dist/esm/adapters/Cornerstone3D/Segmentation/generateToolState.js

@@ -0,0 +1,9 @@
+import { generateToolState as generateToolState$1 } from '../../Cornerstone/Segmentation.js';
+
+function generateToolState(imageIds, arrayBuffer, metadataProvider) {
+  var skipOverlapping = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  var tolerance = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1e-3;
+  return generateToolState$1(imageIds, arrayBuffer, metadataProvider, skipOverlapping, tolerance);
+}
+
+export { generateToolState };

package/dist/esm/adapters/Cornerstone3D/Segmentation/index.js

@@ -0,0 +1,3 @@
+export { generateSegmentation } from './generateSegmentation.js';
+export { generateLabelMaps2DFrom3D } from './generateLabelMaps2DFrom3D.js';
+export { generateToolState } from './generateToolState.js';

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

@@ -0,0 +1,93 @@
+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 _UltrasoundDirectional;
+var TID300Length = utilities.TID300.Length;
+var ULTRASOUND_DIRECTIONAL = "UltrasoundDirectionalTool";
+var trackingIdentifierTextValue = "".concat(CORNERSTONE_3D_TAG, ":").concat(ULTRASOUND_DIRECTIONAL);
+var UltrasoundDirectional = /*#__PURE__*/function () {
+  function UltrasoundDirectional() {
+    _classCallCheck(this, UltrasoundDirectional);
+  }
+  return _createClass(UltrasoundDirectional, null, [{
+    key: "getMeasurementData",
+    value: function getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+      var _MeasurementReport$ge = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, UltrasoundDirectional.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[0], worldCoords[1]],
+          activeHandleIndex: 0,
+          textBox: {
+            hasMoved: false
+          }
+        },
+        cachedStats: {},
+        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 handles = data.handles;
+      var referencedImageId = metadata.referencedImageId;
+      if (!referencedImageId) {
+        throw new Error("UltrasoundDirectionalTool.getTID300RepresentationArguments: referencedImageId is not defined");
+      }
+      var start = worldToImageCoords(referencedImageId, handles.points[0]);
+      var end = worldToImageCoords(referencedImageId, handles.points[1]);
+      var point1 = {
+        x: start[0],
+        y: start[1]
+      };
+      var point2 = {
+        x: end[0],
+        y: end[1]
+      };
+      return {
+        point1: point1,
+        point2: point2,
+        trackingIdentifierTextValue: trackingIdentifierTextValue,
+        finding: finding,
+        findingSites: findingSites || []
+      };
+    }
+  }]);
+}();
+_UltrasoundDirectional = UltrasoundDirectional;
+_UltrasoundDirectional.toolType = ULTRASOUND_DIRECTIONAL;
+_UltrasoundDirectional.utilityToolType = ULTRASOUND_DIRECTIONAL;
+_UltrasoundDirectional.TID300Representation = TID300Length;
+_UltrasoundDirectional.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 === ULTRASOUND_DIRECTIONAL;
+};
+MeasurementReport.registerTool(UltrasoundDirectional);
+
+export { UltrasoundDirectional as default };

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

@@ -0,0 +1,2 @@
+declare const _default: "Cornerstone3DTools@^0.1.0";
+export default _default;

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

@@ -0,0 +1,3 @@
+var CORNERSTONE_3D_TAG = "Cornerstone3DTools@^0.1.0";
+
+export { CORNERSTONE_3D_TAG as default };