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

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

@@ -0,0 +1,250 @@
+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;
+/**
+ * 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) {
+  // Convert segmentations to ROIContours
+  var roiContours = [];
+  var contourSets = generateContourSetsFromLabelmap({
+    segmentations: segmentations
+  });
+  contourSets.forEach(function (contourSet, segIndex) {
+    // Check contour set isn't undefined
+    if (contourSet) {
+      var contourSequence = [];
+      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.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);
+    // 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()],
+      // TODO: could be git hash or other valid id
+      vr: "UI"
+    },
+    ImplementationVersionName: {
+      Value: ["dcmjs"],
+      vr: "SH"
+    }
+  };
+  dataset._meta = _meta;
+  // @ts-ignore
+  dataset.SpecificCharacterSet = "ISO_IR 192";
+  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
+ * @returns Report object containing the 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));
+    // 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()],
+      // TODO: could be git hash or other valid id
+      vr: "UI"
+    },
+    ImplementationVersionName: {
+      Value: ["dcmjs"],
+      vr: "SH"
+    }
+  };
+  dataset._meta = _meta;
+  //@ts-ignore
+  dataset.SpecificCharacterSet = "ISO_IR 192";
+  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 _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",
+    // RT Structure Set Storage
+    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.d.ts

@@ -0,0 +1,4 @@
+import { utilities } from "@cornerstonejs/tools";
+import { generateRTSSFromAnnotations, generateRTSSFromSegmentations } from "./RTSS";
+declare const generateContourSetsFromLabelmap: typeof utilities.contours.generateContourSetsFromLabelmap;
+export { generateContourSetsFromLabelmap, 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,92 @@
+import { defineProperty as _defineProperty, createClass as _createClass, slicedToArray as _slicedToArray, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { utilities } from 'dcmjs';
+import CORNERSTONE_3D_TAG from './cornerstone3DTag.js';
+import MeasurementReport from './MeasurementReport.js';
+
+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 || []
+      };
+    }
+  }]);
+}();
+_defineProperty(RectangleROI, "toolType", TOOLTYPE);
+_defineProperty(RectangleROI, "utilityToolType", TOOLTYPE);
+_defineProperty(RectangleROI, "TID300Representation", TID300Polyline);
+_defineProperty(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/esm/adapters/Cornerstone3D/Segmentation/generateLabelMaps2DFrom3D.js

@@ -0,0 +1,45 @@
+/**
+ * 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.
+ */
+function generateLabelMaps2DFrom3D(labelmap3D) {
+  // 1. we need to generate labelmaps2D from labelmaps3D, a labelmap2D is for each
+  // slice
+  var scalarData = labelmap3D.scalarData,
+    dimensions = labelmap3D.dimensions;
+  // scalarData is a flat array of all the pixels in the volume.
+  var labelmaps2D = [];
+  var segmentsOnLabelmap3D = new Set();
+  // X-Y are the row and column dimensions, Z is the number of slices.
+  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;
+  }
+  // remove segment 0 from segmentsOnLabelmap3D
+  labelmap3D.segmentsOnLabelmap = Array.from(segmentsOnLabelmap3D);
+  labelmap3D.labelmaps2D = labelmaps2D;
+  return labelmap3D;
+}
+
+export { generateLabelMaps2DFrom3D };

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

@@ -0,0 +1,47 @@
+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;
+/**
+ * generateSegmentation - Generates a DICOM Segmentation object given cornerstoneTools data.
+ *
+ * @param images - An array of the cornerstone image objects, which includes imageId and metadata
+ * @param labelmaps - An array of the 3D Volumes that contain the segmentation data.
+ */
+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);
+}
+/**
+ * _createMultiframeSegmentationFromReferencedImages - description
+ *
+ * @param images - An array of the cornerstone image objects related to the reference
+ * series that the segmentation is derived from. You can use methods such as
+ * volume.getCornerstoneImages() to get this array.
+ *
+ * @param options - the options object for the SegmentationDerivation.
+ * @returns The Seg derived dataSet.
+ */
+function _createMultiframeSegmentationFromReferencedImages(images, metadata, options) {
+  var datasets = images.map(function (image) {
+    // add the sopClassUID to the dataset
+    var instance = metadata.get("instance", image.imageId);
+    return _objectSpread2(_objectSpread2(_objectSpread2({}, image), instance), {}, {
+      // Todo: move to dcmjs tag style
+      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.js

@@ -0,0 +1,25 @@
+import { CornerstoneSEG } from '../../Cornerstone/index.js';
+
+var Segmentation = CornerstoneSEG.Segmentation;
+var generateToolStateCornerstoneLegacy = Segmentation.generateToolState;
+/**
+ * generateToolState - Given a set of cornerstoneTools imageIds and a Segmentation buffer,
+ * derive cornerstoneTools toolState and brush metadata.
+ *
+ * @param   imageIds - An array of the imageIds.
+ * @param   arrayBuffer - The SEG arrayBuffer.
+ * @param   skipOverlapping - skip checks for overlapping segs, default value false.
+ * @param   tolerance - default value 1.e-3.
+ *
+ * @returns a list of array buffer for each labelMap
+ *  an object from which the segment metadata can be derived
+ *  list containing the track of segments per frame
+ *  list containing the track of segments per frame for each labelMap                   (available only for the overlapping case).
+ */
+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 generateToolStateCornerstoneLegacy(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';