@cornerstonejs/adapters 2.0.0-beta.13 → 2.0.0-beta.15

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

@@ -0,0 +1,274 @@
+import { createClass as _createClass, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { utilities, derivations, normalizers, data } from 'dcmjs';
+import { toArray } from '../helpers/toArray.js';
+import { codeMeaningEquals } from '../helpers/codeMeaningEquals.js';
+import '../helpers/downloadDICOMData.js';
+
+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) {
+  var args = toolClass.getTID300RepresentationArguments(tool);
+  args.ReferencedSOPSequence = ReferencedSOPSequence;
+  var TID300Measurement = new toolClass.TID300Representation(args);
+  return TID300Measurement;
+}
+function getMeasurementGroup(toolType, toolData, ReferencedSOPSequence) {
+  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);
+  });
+  return new TID1501MeasurementGroup(Measurements);
+}
+var MeasurementReport = /*#__PURE__*/function () {
+  function MeasurementReport() {
+    _classCallCheck(this, MeasurementReport);
+  }
+  return _createClass(MeasurementReport, null, [{
+    key: "getSetupMeasurementData",
+    value: function getSetupMeasurementData(MeasurementGroup) {
+      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 defaultState = {
+        sopInstanceUid: ReferencedSOPInstanceUID,
+        frameIndex: ReferencedFrameNumber || 1,
+        complete: true,
+        finding: findingGroup ? addAccessors(findingGroup.ConceptCodeSequence) : undefined,
+        findingSites: findingSiteGroups.map(function (fsg) {
+          return addAccessors(fsg.ConceptCodeSequence);
+        })
+      };
+      if (defaultState.finding) {
+        defaultState.description = defaultState.finding.CodeMeaning;
+      }
+      var findingSite = defaultState.findingSites && defaultState.findingSites[0];
+      if (findingSite) {
+        defaultState.location = findingSite[0] && findingSite[0].CodeMeaning || findingSite.CodeMeaning;
+      }
+      return {
+        defaultState: defaultState,
+        findingGroup: findingGroup,
+        findingSiteGroups: findingSiteGroups,
+        NUMGroup: NUMGroup,
+        SCOORDGroup: SCOORDGroup,
+        ReferencedSOPSequence: ReferencedSOPSequence,
+        ReferencedSOPInstanceUID: ReferencedSOPInstanceUID,
+        ReferencedFrameNumber: ReferencedFrameNumber
+      };
+    }
+  }, {
+    key: "generateReport",
+    value: function generateReport(toolState, metadataProvider, options) {
+      // ToolState for array of imageIDs to a Report
+      // Assume Cornerstone metadata provider has access to Study / Series / Sop Instance UID
+
+      var allMeasurementGroups = [];
+      var firstImageId = Object.keys(toolState)[0];
+      if (!firstImageId) {
+        throw new Error("No measurements provided.");
+      }
+
+      /* 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 generalSeriesModule = metadataProvider.get("generalSeriesModule", firstImageId);
+
+      //const sopCommonModule = metadataProvider.get('sopCommonModule', firstImageId);
+
+      // NOTE: We are getting the Series and Study UIDs from the first imageId of the toolState
+      // which means that if the toolState is for multiple series, the report will have the incorrect
+      // SeriesInstanceUIDs
+      var studyInstanceUID = generalSeriesModule.studyInstanceUID,
+        seriesInstanceUID = generalSeriesModule.seriesInstanceUID;
+
+      // Loop through each image in the toolData
+      Object.keys(toolState).forEach(function (imageId) {
+        var sopCommonModule = metadataProvider.get("sopCommonModule", imageId);
+        var frameNumber = metadataProvider.get("frameNumber", imageId);
+        var toolData = toolState[imageId];
+        var toolTypes = Object.keys(toolData);
+        var ReferencedSOPSequence = {
+          ReferencedSOPClassUID: sopCommonModule.sopClassUID,
+          ReferencedSOPInstanceUID: sopCommonModule.sopInstanceUID
+        };
+        if (Normalizer.isMultiframeSOPClassUID(sopCommonModule.sopClassUID)) {
+          ReferencedSOPSequence.ReferencedFrameNumber = frameNumber;
+        }
+
+        // Loop through each tool type for the image
+        var measurementGroups = [];
+        toolTypes.forEach(function (toolType) {
+          var group = getMeasurementGroup(toolType, toolData, ReferencedSOPSequence);
+          if (group) {
+            measurementGroups.push(group);
+          }
+        });
+        allMeasurementGroups = allMeasurementGroups.concat(measurementGroups);
+      });
+      var _MeasurementReport = new TID1500MeasurementReport({
+        TID1501MeasurementGroups: allMeasurementGroups
+      }, options);
+
+      // 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 derivationSourceDataset = {
+        StudyInstanceUID: studyInstanceUID,
+        SeriesInstanceUID: seriesInstanceUID
+        //SOPInstanceUID: sopInstanceUID, // TODO: Necessary?
+        //SOPClassUID: sopClassUID,
+      };
+      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"
+        }
+      };
+      var _vrMap = {
+        PixelData: "OW"
+      };
+      derivationSourceDataset._meta = _meta;
+      derivationSourceDataset._vrMap = _vrMap;
+      var report = new StructuredReport([derivationSourceDataset]);
+      var contentItem = _MeasurementReport.contentItem(derivationSourceDataset);
+
+      // Merge the derived dataset with the content from the Measurement Report
+      report.dataset = Object.assign(report.dataset, contentItem);
+      report.dataset._meta = _meta;
+      report.dataset.SpecificCharacterSet = "ISO_IR 192";
+      return report;
+    }
+
+    /**
+     * 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
+     */
+  }, {
+    key: "generateToolState",
+    value: function generateToolState(dataset) {
+      var hooks = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      // 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";
+
+      // 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) {
+        var measurementGroupContentSequence = toArray(measurementGroup.ContentSequence);
+        var TrackingIdentifierGroup = measurementGroupContentSequence.find(function (contentItem) {
+          return contentItem.ConceptNameCodeSequence.CodeMeaning === TRACKING_IDENTIFIER;
+        });
+        var TrackingIdentifierValue = TrackingIdentifierGroup.TextValue;
+        var toolClass = hooks.getToolClass ? hooks.getToolClass(measurementGroup, dataset, registeredToolClasses) : registeredToolClasses.find(function (tc) {
+          return tc.isValidCornerstoneTrackingIdentifier(TrackingIdentifierValue);
+        });
+        if (toolClass) {
+          var measurement = toolClass.getMeasurementData(measurementGroup);
+          console.log("=== ".concat(toolClass.toolType, " ==="));
+          console.log(measurement);
+          measurementData[toolClass.toolType].push(measurement);
+        }
+      });
+
+      // 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;
+    }
+  }, {
+    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.MEASUREMENT_BY_TOOLTYPE = {};
+MeasurementReport.CORNERSTONE_TOOL_CLASSES_BY_UTILITY_TYPE = {};
+MeasurementReport.CORNERSTONE_TOOL_CLASSES_BY_TOOL_TYPE = {};
+
+export { MeasurementReport as default };

package/dist/esm/adapters/Cornerstone/RectangleRoi.d.ts

@@ -0,0 +1,44 @@
+export default RectangleRoi;
+declare class RectangleRoi {
+    static getMeasurementData(MeasurementGroup: any): {
+        toolType: string;
+        handles: {
+            start: {};
+            end: {};
+            textBox: {
+                active: boolean;
+                hasMoved: boolean;
+                movesIndependently: boolean;
+                drawnIndependently: boolean;
+                allowedOutsideImage: boolean;
+                hasBoundingBox: boolean;
+            };
+            initialRotation: number;
+        };
+        cachedStats: {
+            area: any;
+        };
+        color: any;
+        invalidated: boolean;
+        sopInstanceUid: any;
+        frameIndex: any;
+        complete: boolean;
+        finding: any;
+        findingSites: any[];
+    };
+    static getTID300RepresentationArguments(tool: any): {
+        points: any[];
+        area: any;
+        perimeter: any;
+        trackingIdentifierTextValue: string;
+        finding: any;
+        findingSites: any;
+    };
+}
+declare namespace RectangleRoi {
+    export let toolType: string;
+    export let utilityToolType: string;
+    export { TID300Polyline as TID300Representation };
+    export function isValidCornerstoneTrackingIdentifier(TrackingIdentifier: any): boolean;
+}
+declare const TID300Polyline: any;

package/dist/esm/adapters/Cornerstone/RectangleRoi.js

@@ -0,0 +1,97 @@
+import { slicedToArray as _slicedToArray, createClass as _createClass, objectSpread2 as _objectSpread2, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { utilities } from 'dcmjs';
+import MeasurementReport from './MeasurementReport.js';
+import CORNERSTONE_4_TAG from './cornerstone4Tag.js';
+
+var TID300Polyline = utilities.TID300.Polyline;
+var RectangleRoi = /*#__PURE__*/function () {
+  function RectangleRoi() {
+    _classCallCheck(this, RectangleRoi);
+  }
+  return _createClass(RectangleRoi, null, [{
+    key: "getMeasurementData",
+    value: function getMeasurementData(MeasurementGroup) {
+      var _MeasurementReport$ge = MeasurementReport.getSetupMeasurementData(MeasurementGroup),
+        defaultState = _MeasurementReport$ge.defaultState,
+        SCOORDGroup = _MeasurementReport$ge.SCOORDGroup,
+        NUMGroup = _MeasurementReport$ge.NUMGroup;
+      var state = _objectSpread2(_objectSpread2({}, defaultState), {}, {
+        toolType: RectangleRoi.toolType,
+        handles: {
+          start: {},
+          end: {},
+          textBox: {
+            active: false,
+            hasMoved: false,
+            movesIndependently: false,
+            drawnIndependently: true,
+            allowedOutsideImage: true,
+            hasBoundingBox: true
+          },
+          initialRotation: 0
+        },
+        cachedStats: {
+          area: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : 0
+        },
+        color: undefined,
+        invalidated: true
+      });
+      var _SCOORDGroup$GraphicD = _slicedToArray(SCOORDGroup.GraphicData, 6);
+      state.handles.start.x = _SCOORDGroup$GraphicD[0];
+      state.handles.start.y = _SCOORDGroup$GraphicD[1];
+      _SCOORDGroup$GraphicD[2];
+      _SCOORDGroup$GraphicD[3];
+      state.handles.end.x = _SCOORDGroup$GraphicD[4];
+      state.handles.end.y = _SCOORDGroup$GraphicD[5];
+      return state;
+    }
+  }, {
+    key: "getTID300RepresentationArguments",
+    value: function getTID300RepresentationArguments(tool) {
+      var finding = tool.finding,
+        findingSites = tool.findingSites,
+        _tool$cachedStats = tool.cachedStats,
+        cachedStats = _tool$cachedStats === void 0 ? {} : _tool$cachedStats,
+        handles = tool.handles;
+      var start = handles.start,
+        end = handles.end;
+      var points = [start, {
+        x: start.x,
+        y: end.y
+      }, end, {
+        x: end.x,
+        y: start.y
+      }];
+      var area = cachedStats.area,
+        perimeter = cachedStats.perimeter;
+      var trackingIdentifierTextValue = "cornerstoneTools@^4.0.0:RectangleRoi";
+      return {
+        points: points,
+        area: area,
+        perimeter: perimeter,
+        trackingIdentifierTextValue: trackingIdentifierTextValue,
+        finding: finding,
+        findingSites: findingSites || []
+      };
+    }
+  }]);
+}();
+RectangleRoi.toolType = "RectangleRoi";
+RectangleRoi.utilityToolType = "RectangleRoi";
+RectangleRoi.TID300Representation = TID300Polyline;
+RectangleRoi.isValidCornerstoneTrackingIdentifier = function (TrackingIdentifier) {
+  if (!TrackingIdentifier.includes(":")) {
+    return false;
+  }
+  var _TrackingIdentifier$s = TrackingIdentifier.split(":"),
+    _TrackingIdentifier$s2 = _slicedToArray(_TrackingIdentifier$s, 2),
+    cornerstone4Tag = _TrackingIdentifier$s2[0],
+    toolType = _TrackingIdentifier$s2[1];
+  if (cornerstone4Tag !== CORNERSTONE_4_TAG) {
+    return false;
+  }
+  return toolType === RectangleRoi.toolType;
+};
+MeasurementReport.registerTool(RectangleRoi);
+
+export { RectangleRoi as default };

package/dist/esm/adapters/Cornerstone/Segmentation.d.ts

@@ -0,0 +1,44 @@
+export default Segmentation;
+declare namespace Segmentation {
+    export { generateSegmentation };
+    export { generateToolState };
+    export { fillSegmentation };
+}
+/**
+ * generateSegmentation - Generates a DICOM Segmentation object given cornerstoneTools data.
+ *
+ * @param  {object[]} images    An array of the cornerstone image objects.
+ * @param  {Object|Object[]} labelmaps3DorBrushData For 4.X: The cornerstone `Labelmap3D` object, or an array of objects.
+ *                                                  For 3.X: the BrushData.
+ * @param  {number} cornerstoneToolsVersion The cornerstoneTools major version to map against.
+ * @returns {Object}
+ */
+declare function generateSegmentation(images: object[], labelmaps3DorBrushData: any | any[], options?: {
+    includeSliceSpacing: boolean;
+}, cornerstoneToolsVersion?: number): any;
+/**
+ * generateToolState - Given a set of cornrstoneTools imageIds and a Segmentation buffer,
+ * derive cornerstoneTools toolState and brush metadata.
+ *
+ * @param  {string[]} imageIds    An array of the imageIds.
+ * @param  {ArrayBuffer} arrayBuffer The SEG arrayBuffer.
+ * @param {*} metadataProvider
+ * @param  {bool} skipOverlapping - skip checks for overlapping segs, default value false.
+ * @param  {number} tolerance - default value 1.e-3.
+ * @param  {number} cornerstoneToolsVersion - default value 4.
+ *
+ * @returns {Object}  The toolState and an object from which the
+ *                    segment metadata can be derived.
+ */
+declare function generateToolState(imageIds: string[], arrayBuffer: ArrayBuffer, metadataProvider: any, skipOverlapping?: bool, tolerance?: number, cornerstoneToolsVersion?: number): any;
+/**
+ * fillSegmentation - Fills a derived segmentation dataset with cornerstoneTools `LabelMap3D` data.
+ *
+ * @param  {object[]} segmentation An empty segmentation derived dataset.
+ * @param  {Object|Object[]} inputLabelmaps3D The cornerstone `Labelmap3D` object, or an array of objects.
+ * @param  {Object} userOptions Options object to override default options.
+ * @returns {Blob}           description
+ */
+declare function fillSegmentation(segmentation: object[], inputLabelmaps3D: any | any[], options?: {
+    includeSliceSpacing: boolean;
+}, cornerstoneToolsVersion?: number): Blob;

package/dist/esm/adapters/Cornerstone/Segmentation.js

@@ -0,0 +1,79 @@
+import Segmentation$2 from './Segmentation_3X.js';
+import Segmentation$1 from './Segmentation_4X.js';
+
+var Segmentation = {
+  generateSegmentation: generateSegmentation,
+  generateToolState: generateToolState,
+  fillSegmentation: fillSegmentation
+};
+
+/**
+ * generateSegmentation - Generates a DICOM Segmentation object given cornerstoneTools data.
+ *
+ * @param  {object[]} images    An array of the cornerstone image objects.
+ * @param  {Object|Object[]} labelmaps3DorBrushData For 4.X: The cornerstone `Labelmap3D` object, or an array of objects.
+ *                                                  For 3.X: the BrushData.
+ * @param  {number} cornerstoneToolsVersion The cornerstoneTools major version to map against.
+ * @returns {Object}
+ */
+function generateSegmentation(images, labelmaps3DorBrushData) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+    includeSliceSpacing: true
+  };
+  var cornerstoneToolsVersion = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 4;
+  if (cornerstoneToolsVersion === 4) {
+    return Segmentation$1.generateSegmentation(images, labelmaps3DorBrushData, options);
+  }
+  if (cornerstoneToolsVersion === 3) {
+    return Segmentation$2.generateSegmentation(images, labelmaps3DorBrushData, options);
+  }
+  console.warn("No generateSegmentation adapater for cornerstone version ".concat(cornerstoneToolsVersion, ", exiting."));
+}
+
+/**
+ * generateToolState - Given a set of cornrstoneTools imageIds and a Segmentation buffer,
+ * derive cornerstoneTools toolState and brush metadata.
+ *
+ * @param  {string[]} imageIds    An array of the imageIds.
+ * @param  {ArrayBuffer} arrayBuffer The SEG arrayBuffer.
+ * @param {*} metadataProvider
+ * @param  {bool} skipOverlapping - skip checks for overlapping segs, default value false.
+ * @param  {number} tolerance - default value 1.e-3.
+ * @param  {number} cornerstoneToolsVersion - default value 4.
+ *
+ * @returns {Object}  The toolState and an object from which the
+ *                    segment metadata can be derived.
+ */
+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;
+  var cornerstoneToolsVersion = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 4;
+  if (cornerstoneToolsVersion === 4) {
+    return Segmentation$1.generateToolState(imageIds, arrayBuffer, metadataProvider, skipOverlapping, tolerance);
+  }
+  if (cornerstoneToolsVersion === 3) {
+    return Segmentation$2.generateToolState(imageIds, arrayBuffer, metadataProvider);
+  }
+  console.warn("No generateToolState adapater for cornerstone version ".concat(cornerstoneToolsVersion, ", exiting."));
+}
+
+/**
+ * fillSegmentation - Fills a derived segmentation dataset with cornerstoneTools `LabelMap3D` data.
+ *
+ * @param  {object[]} segmentation An empty segmentation derived dataset.
+ * @param  {Object|Object[]} inputLabelmaps3D The cornerstone `Labelmap3D` object, or an array of objects.
+ * @param  {Object} userOptions Options object to override default options.
+ * @returns {Blob}           description
+ */
+function fillSegmentation(segmentation, inputLabelmaps3D) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+    includeSliceSpacing: true
+  };
+  var cornerstoneToolsVersion = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 4;
+  if (cornerstoneToolsVersion === 4) {
+    return Segmentation$1.fillSegmentation(segmentation, inputLabelmaps3D, options);
+  }
+  console.warn("No generateSegmentation adapater for cornerstone version ".concat(cornerstoneToolsVersion, ", exiting."));
+}
+
+export { Segmentation as default };

package/dist/esm/adapters/Cornerstone/Segmentation_3X.d.ts

@@ -0,0 +1,45 @@
+export default Segmentation;
+export type BrushData = {
+    /**
+     * - The cornerstoneTools global toolState.
+     */
+    toolState: any;
+    /**
+     * - The cornerstoneTools segment metadata that corresponds to the
+     *   seriesInstanceUid.
+     */
+    segments: any[];
+};
+declare namespace Segmentation {
+    export { generateSegmentation };
+    export { generateToolState };
+}
+/**
+ *
+ * @typedef {Object} BrushData
+ * @property {Object} toolState - The cornerstoneTools global toolState.
+ * @property {Object[]} segments - The cornerstoneTools segment metadata that corresponds to the
+ *                                 seriesInstanceUid.
+ */
+/**
+ * generateSegmentation - Generates cornerstoneTools brush data, given a stack of
+ * imageIds, images and the cornerstoneTools brushData.
+ *
+ * @param  {object[]} images    An array of the cornerstone image objects.
+ * @param  {BrushData} brushData and object containing the brushData.
+ * @returns {type}           description
+ */
+declare function generateSegmentation(images: object[], brushData: BrushData, options?: {
+    includeSliceSpacing: boolean;
+}): type;
+/**
+ * generateToolState - Given a set of cornrstoneTools imageIds and a Segmentation buffer,
+ * derive cornerstoneTools toolState and brush metadata.
+ *
+ * @param  {string[]} imageIds    An array of the imageIds.
+ * @param  {ArrayBuffer} arrayBuffer The SEG arrayBuffer.
+ * @param {*} metadataProvider
+ * @returns {Object}  The toolState and an object from which the
+ *                    segment metadata can be derived.
+ */
+declare function generateToolState(imageIds: string[], arrayBuffer: ArrayBuffer, metadataProvider: any): any;