@cornerstonejs/adapters 2.0.0-beta.7 → 2.0.0

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

@@ -1,34 +1,46 @@
 import MeasurementReport from "./MeasurementReport";
+import ArrowAnnotate from "./ArrowAnnotate";
 import Bidirectional from "./Bidirectional";
 import Angle from "./Angle";
 import CobbAngle from "./CobbAngle";
 import CircleROI from "./CircleROI";
 import EllipticalROI from "./EllipticalROI";
 import RectangleROI from "./RectangleROI";
+import Length from "./Length";
 import PlanarFreehandROI from "./PlanarFreehandROI";
+import Probe from "./Probe";
 import UltrasoundDirectional from "./UltrasoundDirectional";
 import * as Segmentation from "./Segmentation";
+import * as ParametricMap from "./ParametricMap";
 import * as RTSS from "./RTStruct";
 declare const Cornerstone3DSR: {
     Bidirectional: typeof Bidirectional;
     CobbAngle: typeof CobbAngle;
     Angle: typeof Angle;
-    Length: any;
+    Length: typeof Length;
     CircleROI: typeof CircleROI;
     EllipticalROI: typeof EllipticalROI;
     RectangleROI: typeof RectangleROI;
-    ArrowAnnotate: any;
-    Probe: any;
+    ArrowAnnotate: typeof ArrowAnnotate;
+    Probe: typeof Probe;
     PlanarFreehandROI: typeof PlanarFreehandROI;
     UltrasoundDirectional: typeof UltrasoundDirectional;
     MeasurementReport: typeof MeasurementReport;
-    CodeScheme: any;
-    CORNERSTONE_3D_TAG: any;
+    CodeScheme: {
+        CodingSchemeDesignator: string;
+        codeValues: {
+            CORNERSTONEFREETEXT: string;
+        };
+    };
+    CORNERSTONE_3D_TAG: string;
 };
 declare const Cornerstone3DSEG: {
     Segmentation: typeof Segmentation;
 };
+declare const Cornerstone3DPMAP: {
+    ParametricMap: typeof ParametricMap;
+};
 declare const Cornerstone3DRT: {
     RTSS: typeof RTSS;
 };
-export { Cornerstone3DSR, Cornerstone3DSEG, Cornerstone3DRT };
+export { Cornerstone3DSR, Cornerstone3DSEG, Cornerstone3DPMAP, Cornerstone3DRT };

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

@@ -0,0 +1,45 @@
+import MeasurementReport from './MeasurementReport.js';
+import CodingScheme from './CodingScheme.js';
+import CORNERSTONE_3D_TAG from './cornerstone3DTag.js';
+import ArrowAnnotate from './ArrowAnnotate.js';
+import Bidirectional from './Bidirectional.js';
+import Angle from './Angle.js';
+import CobbAngle from './CobbAngle.js';
+import CircleROI from './CircleROI.js';
+import EllipticalROI from './EllipticalROI.js';
+import RectangleROI from './RectangleROI.js';
+import Length from './Length.js';
+import PlanarFreehandROI from './PlanarFreehandROI.js';
+import Probe from './Probe.js';
+import UltrasoundDirectional from './UltrasoundDirectional.js';
+import * as index from './Segmentation/index.js';
+import * as index$1 from './ParametricMap/index.js';
+import * as index$2 from './RTStruct/index.js';
+
+var Cornerstone3DSR = {
+  Bidirectional: Bidirectional,
+  CobbAngle: CobbAngle,
+  Angle: Angle,
+  Length: Length,
+  CircleROI: CircleROI,
+  EllipticalROI: EllipticalROI,
+  RectangleROI: RectangleROI,
+  ArrowAnnotate: ArrowAnnotate,
+  Probe: Probe,
+  PlanarFreehandROI: PlanarFreehandROI,
+  UltrasoundDirectional: UltrasoundDirectional,
+  MeasurementReport: MeasurementReport,
+  CodeScheme: CodingScheme,
+  CORNERSTONE_3D_TAG: CORNERSTONE_3D_TAG
+};
+var Cornerstone3DSEG = {
+  Segmentation: index
+};
+var Cornerstone3DPMAP = {
+  ParametricMap: index$1
+};
+var Cornerstone3DRT = {
+  RTSS: index$2
+};
+
+export { Cornerstone3DPMAP, Cornerstone3DRT, Cornerstone3DSEG, Cornerstone3DSR };

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

@@ -0,0 +1,18 @@
+import { slicedToArray as _slicedToArray } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import CORNERSTONE_3D_TAG from './cornerstone3DTag.js';
+
+function isValidCornerstoneTrackingIdentifier(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.toLowerCase() === this.toolType.toLowerCase();
+}
+
+export { isValidCornerstoneTrackingIdentifier as default };

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

@@ -0,0 +1,3 @@
+export default class Segmentation {
+    static generateSegments(dataset: any): {};
+}

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

@@ -0,0 +1,186 @@
+import { createClass as _createClass, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { data } from 'dcmjs';
+
+var Colors = data.Colors,
+  BitArray = data.BitArray;
+
+// TODO: Is there a better name for this? RGBAInt?
+// Should we move it to Colors.js
+function dicomlab2RGBA(cielab) {
+  var rgba = Colors.dicomlab2RGB(cielab).map(function (x) {
+    return Math.round(x * 255);
+  });
+  rgba.push(255);
+  return rgba;
+}
+
+// TODO: Copied these functions in from VTK Math so we don't need a dependency.
+// I guess we should put them somewhere
+// https://github.com/Kitware/vtk-js/blob/master/Sources/Common/Core/Math/index.js
+function cross(x, y, out) {
+  var Zx = x[1] * y[2] - x[2] * y[1];
+  var Zy = x[2] * y[0] - x[0] * y[2];
+  var Zz = x[0] * y[1] - x[1] * y[0];
+  out[0] = Zx;
+  out[1] = Zy;
+  out[2] = Zz;
+}
+function norm(x) {
+  var n = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 3;
+  switch (n) {
+    case 1:
+      return Math.abs(x);
+    case 2:
+      return Math.sqrt(x[0] * x[0] + x[1] * x[1]);
+    case 3:
+      return Math.sqrt(x[0] * x[0] + x[1] * x[1] + x[2] * x[2]);
+    default:
+      {
+        var sum = 0;
+        for (var i = 0; i < n; i++) {
+          sum += x[i] * x[i];
+        }
+        return Math.sqrt(sum);
+      }
+  }
+}
+function normalize(x) {
+  var den = norm(x);
+  if (den !== 0.0) {
+    x[0] /= den;
+    x[1] /= den;
+    x[2] /= den;
+  }
+  return den;
+}
+function subtract(a, b, out) {
+  out[0] = a[0] - b[0];
+  out[1] = a[1] - b[1];
+  out[2] = a[2] - b[2];
+}
+
+// TODO: This is a useful utility on its own. We should move it somewhere?
+// dcmjs.adapters.vtk.Multiframe? dcmjs.utils?
+function geometryFromFunctionalGroups(dataset, PerFrameFunctionalGroups) {
+  var geometry = {};
+  var pixelMeasures = dataset.SharedFunctionalGroupsSequence.PixelMeasuresSequence;
+  var planeOrientation = dataset.SharedFunctionalGroupsSequence.PlaneOrientationSequence;
+
+  // Find the origin of the volume from the PerFrameFunctionalGroups' ImagePositionPatient values
+  //
+  // TODO: assumes sorted frames. This should read the ImagePositionPatient from each frame and
+  // sort them to obtain the first and last position along the acquisition axis.
+  var firstFunctionalGroup = PerFrameFunctionalGroups[0];
+  var lastFunctionalGroup = PerFrameFunctionalGroups[PerFrameFunctionalGroups.length - 1];
+  var firstPosition = firstFunctionalGroup.PlanePositionSequence.ImagePositionPatient.map(Number);
+  var lastPosition = lastFunctionalGroup.PlanePositionSequence.ImagePositionPatient.map(Number);
+  geometry.origin = firstPosition;
+
+  // NB: DICOM PixelSpacing is defined as Row then Column,
+  // unlike ImageOrientationPatient
+  geometry.spacing = [pixelMeasures.PixelSpacing[1], pixelMeasures.PixelSpacing[0], pixelMeasures.SpacingBetweenSlices].map(Number);
+  geometry.dimensions = [dataset.Columns, dataset.Rows, PerFrameFunctionalGroups.length].map(Number);
+  var orientation = planeOrientation.ImageOrientationPatient.map(Number);
+  var columnStepToPatient = orientation.slice(0, 3);
+  var rowStepToPatient = orientation.slice(3, 6);
+  geometry.planeNormal = [];
+  cross(columnStepToPatient, rowStepToPatient, geometry.planeNormal);
+  geometry.sliceStep = [];
+  subtract(lastPosition, firstPosition, geometry.sliceStep);
+  normalize(geometry.sliceStep);
+  geometry.direction = columnStepToPatient.concat(rowStepToPatient).concat(geometry.sliceStep);
+  return geometry;
+}
+var Segmentation = /*#__PURE__*/function () {
+  function Segmentation() {
+    _classCallCheck(this, Segmentation);
+  }
+
+  /**
+   * Produces an array of Segments from an input DICOM Segmentation dataset
+   *
+   * Segments are returned with Geometry values that can be used to create
+   * VTK Image Data objects.
+   *
+   * @example Example usage to create VTK Volume actors from each segment:
+   *
+   * const actors = [];
+   * const segments = generateToolState(dataset);
+   * segments.forEach(segment => {
+   *   // now make actors using the segment information
+   *   const scalarArray = vtk.Common.Core.vtkDataArray.newInstance({
+   *        name: "Scalars",
+   *        numberOfComponents: 1,
+   *        values: segment.pixelData,
+   *    });
+   *
+   *    const imageData = vtk.Common.DataModel.vtkImageData.newInstance();
+   *    imageData.getPointData().setScalars(scalarArray);
+   *    imageData.setDimensions(geometry.dimensions);
+   *    imageData.setSpacing(geometry.spacing);
+   *    imageData.setOrigin(geometry.origin);
+   *    imageData.setDirection(geometry.direction);
+   *
+   *    const mapper = vtk.Rendering.Core.vtkVolumeMapper.newInstance();
+   *    mapper.setInputData(imageData);
+   *    mapper.setSampleDistance(2.);
+   *
+   *    const actor = vtk.Rendering.Core.vtkVolume.newInstance();
+   *    actor.setMapper(mapper);
+   *
+   *    actors.push(actor);
+   * });
+   *
+   * @param dataset
+   * @return {{}}
+   */
+  return _createClass(Segmentation, null, [{
+    key: "generateSegments",
+    value: function generateSegments(dataset) {
+      if (dataset.SegmentSequence.constructor.name !== "Array") {
+        dataset.SegmentSequence = [dataset.SegmentSequence];
+      }
+      dataset.SegmentSequence.forEach(function (segment) {
+        // TODO: other interesting fields could be extracted from the segment
+        // TODO: Read SegmentsOverlay field
+        // http://dicom.nema.org/medical/dicom/current/output/chtml/part03/sect_C.8.20.2.html
+
+        // TODO: Looks like vtkColor only wants RGB in 0-1 values.
+        // Why was this example converting to RGBA with 0-255 values?
+        var color = dicomlab2RGBA(segment.RecommendedDisplayCIELabValue);
+        segments[segment.SegmentNumber] = {
+          color: color,
+          functionalGroups: [],
+          offset: null,
+          size: null,
+          pixelData: null
+        };
+      });
+
+      // make a list of functional groups per segment
+      dataset.PerFrameFunctionalGroupsSequence.forEach(function (functionalGroup) {
+        var segmentNumber = functionalGroup.SegmentIdentificationSequence.ReferencedSegmentNumber;
+        segments[segmentNumber].functionalGroups.push(functionalGroup);
+      });
+
+      // determine per-segment index into the pixel data
+      // TODO: only handles one-bit-per pixel
+      var frameSize = Math.ceil(dataset.Rows * dataset.Columns / 8);
+      var nextOffset = 0;
+      Object.keys(segments).forEach(function (segmentNumber) {
+        var segment = segments[segmentNumber];
+        segment.numberOfFrames = segment.functionalGroups.length;
+        segment.size = segment.numberOfFrames * frameSize;
+        segment.offset = nextOffset;
+        nextOffset = segment.offset + segment.size;
+        var packedSegment = dataset.PixelData.slice(segment.offset, nextOffset);
+        segment.pixelData = BitArray.unpack(packedSegment);
+        var geometry = geometryFromFunctionalGroups(dataset, segment.functionalGroups);
+        segment.geometry = geometry;
+      });
+      return segments;
+    }
+  }]);
+}();
+
+export { Segmentation as default };

package/dist/esm/adapters/VTKjs/index.d.ts

@@ -0,0 +1,5 @@
+import Segmentation from "./Segmentation";
+declare const VTKjsSEG: {
+    Segmentation: typeof Segmentation;
+};
+export { VTKjsSEG };

package/dist/esm/adapters/VTKjs/index.js

@@ -0,0 +1,7 @@
+import Segmentation from './Segmentation.js';
+
+var VTKjsSEG = {
+  Segmentation: Segmentation
+};
+
+export { VTKjsSEG };

package/dist/{types → esm}/adapters/enums/Events.d.ts

@@ -1,10 +1,4 @@
-/**
- * Cornerstone adapters events
- */
 declare enum Events {
-    /**
-     * Cornerstone segmentation load progress event
-     */
     SEGMENTATION_LOAD_PROGRESS = "CORNERSTONE_ADAPTER_SEGMENTATION_LOAD_PROGRESS"
 }
 export default Events;

package/dist/esm/adapters/enums/Events.js

@@ -0,0 +1,7 @@
+var Events;
+(function (Events) {
+  Events["SEGMENTATION_LOAD_PROGRESS"] = "CORNERSTONE_ADAPTER_SEGMENTATION_LOAD_PROGRESS";
+})(Events || (Events = {}));
+var Events$1 = Events;
+
+export { Events$1 as default };

package/dist/esm/adapters/enums/index.js

@@ -0,0 +1 @@
+export { default as Events } from './Events.js';

package/dist/esm/adapters/helpers/checkIfPerpendicular.d.ts

@@ -0,0 +1 @@
+export default function checkIfPerpendicular(iop1: number[], iop2: number[], tolerance: number): boolean;

package/dist/esm/adapters/helpers/checkIfPerpendicular.js

@@ -0,0 +1,7 @@
+function checkIfPerpendicular(iop1, iop2, tolerance) {
+  var absDotColumnCosines = Math.abs(iop1[0] * iop2[0] + iop1[1] * iop2[1] + iop1[2] * iop2[2]);
+  var absDotRowCosines = Math.abs(iop1[3] * iop2[3] + iop1[4] * iop2[4] + iop1[5] * iop2[5]);
+  return (absDotColumnCosines < tolerance || Math.abs(absDotColumnCosines - 1) < tolerance) && (absDotRowCosines < tolerance || Math.abs(absDotRowCosines - 1) < tolerance);
+}
+
+export { checkIfPerpendicular as default };

package/dist/esm/adapters/helpers/checkOrientation.d.ts

@@ -0,0 +1 @@
+export default function checkOrientation(multiframe: any, validOrientations: any, sourceDataDimensions: any, tolerance: any): "Planar" | "Perpendicular" | "Oblique";

package/dist/esm/adapters/helpers/checkOrientation.js

@@ -0,0 +1,22 @@
+import checkIfPerpendicular from './checkIfPerpendicular.js';
+import compareArrays from './compareArrays.js';
+
+function checkOrientation(multiframe, validOrientations, sourceDataDimensions, tolerance) {
+  var SharedFunctionalGroupsSequence = multiframe.SharedFunctionalGroupsSequence,
+    PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence;
+  var sharedImageOrientationPatient = SharedFunctionalGroupsSequence.PlaneOrientationSequence ? SharedFunctionalGroupsSequence.PlaneOrientationSequence.ImageOrientationPatient : undefined;
+  var PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[0];
+  var iop = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
+  var inPlane = validOrientations.some(function (operation) {
+    return compareArrays(iop, operation, tolerance);
+  });
+  if (inPlane) {
+    return "Planar";
+  }
+  if (checkIfPerpendicular(iop, validOrientations[0], tolerance) && sourceDataDimensions.includes(multiframe.Rows) && sourceDataDimensions.includes(multiframe.Columns)) {
+    return "Perpendicular";
+  }
+  return "Oblique";
+}
+
+export { checkOrientation as default };

package/dist/esm/adapters/helpers/codeMeaningEquals.d.ts

@@ -0,0 +1,2 @@
+declare const codeMeaningEquals: (codeMeaningName: string) => (contentItem: any) => boolean;
+export { codeMeaningEquals };

package/dist/esm/adapters/helpers/codeMeaningEquals.js

@@ -0,0 +1,7 @@
+var codeMeaningEquals = function codeMeaningEquals(codeMeaningName) {
+  return function (contentItem) {
+    return contentItem.ConceptNameCodeSequence.CodeMeaning === codeMeaningName;
+  };
+};
+
+export { codeMeaningEquals };

package/dist/esm/adapters/helpers/compareArrays.d.ts

@@ -0,0 +1 @@
+export default function compareArrays(array1: number[], array2: number[], tolerance: number): boolean;

package/dist/esm/adapters/helpers/compareArrays.js

@@ -0,0 +1,16 @@
+import { utilities } from 'dcmjs';
+
+var nearlyEqual = utilities.orientation.nearlyEqual;
+function compareArrays(array1, array2, tolerance) {
+  if (array1.length !== array2.length) {
+    return false;
+  }
+  for (var i = 0; i < array1.length; ++i) {
+    if (!nearlyEqual(array1[i], array2[i], tolerance)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export { compareArrays as default };

package/dist/esm/adapters/helpers/downloadDICOMData.d.ts

@@ -0,0 +1,5 @@
+interface DicomDataset {
+    _meta?: unknown;
+}
+export declare function downloadDICOMData(bufferOrDataset: ArrayBuffer | DicomDataset, filename: string): void;
+export {};

package/dist/esm/adapters/helpers/downloadDICOMData.js

@@ -0,0 +1,26 @@
+import { data } from 'dcmjs';
+import { Buffer } from 'buffer';
+
+var datasetToDict = data.datasetToDict;
+function downloadDICOMData(bufferOrDataset, filename) {
+  var blob;
+  if (bufferOrDataset instanceof ArrayBuffer) {
+    blob = new Blob([bufferOrDataset], {
+      type: "application/dicom"
+    });
+  } else {
+    if (!bufferOrDataset._meta) {
+      throw new Error("Dataset must have a _meta property");
+    }
+    var buffer = Buffer.from(datasetToDict(bufferOrDataset).write());
+    blob = new Blob([buffer], {
+      type: "application/dicom"
+    });
+  }
+  var link = document.createElement("a");
+  link.href = window.URL.createObjectURL(blob);
+  link.download = filename;
+  link.click();
+}
+
+export { downloadDICOMData };

package/dist/esm/adapters/helpers/getDatasetsFromImages.d.ts

@@ -0,0 +1 @@
+export default function getDatasetsFromImages(images: any, isMultiframe: any, options?: any): any;

package/dist/esm/adapters/helpers/getDatasetsFromImages.js

@@ -0,0 +1,33 @@
+import { data, normalizers } from 'dcmjs';
+
+var DicomMessage = data.DicomMessage,
+  DicomMetaDictionary = data.DicomMetaDictionary;
+var Normalizer = normalizers.Normalizer;
+function getDatasetsFromImages(images, isMultiframe, options) {
+  var datasets = [];
+  if (isMultiframe) {
+    var image = images[0];
+    var arrayBuffer = image.data.byteArray.buffer;
+    var dicomData = DicomMessage.readFile(arrayBuffer);
+    var dataset = DicomMetaDictionary.naturalizeDataset(dicomData.dict);
+    dataset._meta = DicomMetaDictionary.namifyDataset(dicomData.meta);
+    datasets.push(dataset);
+  } else {
+    for (var i = 0; i < images.length; i++) {
+      var _image = images[i];
+      var _arrayBuffer = _image.data.byteArray.buffer;
+      var _dicomData = DicomMessage.readFile(_arrayBuffer);
+      var _dataset = DicomMetaDictionary.naturalizeDataset(_dicomData.dict);
+      _dataset._meta = DicomMetaDictionary.namifyDataset(_dicomData.meta);
+      datasets.push(_dataset);
+    }
+  }
+  if (options !== null && options !== void 0 && options.SpecificCharacterSet) {
+    datasets.forEach(function (dataset) {
+      return dataset.SpecificCharacterSet = options.SpecificCharacterSet;
+    });
+  }
+  return Normalizer.normalizeToDataset(datasets);
+}
+
+export { getDatasetsFromImages as default };

package/dist/esm/adapters/helpers/graphicTypeEquals.d.ts

@@ -0,0 +1,2 @@
+declare const graphicTypeEquals: (graphicType: any) => (contentItem: any) => boolean;
+export { graphicTypeEquals };

package/dist/esm/adapters/helpers/graphicTypeEquals.js

@@ -0,0 +1,7 @@
+var graphicTypeEquals = function graphicTypeEquals(graphicType) {
+  return function (contentItem) {
+    return contentItem && contentItem.GraphicType === graphicType;
+  };
+};
+
+export { graphicTypeEquals };

package/dist/esm/adapters/helpers/index.js

@@ -0,0 +1,4 @@
+export { toArray } from './toArray.js';
+export { codeMeaningEquals } from './codeMeaningEquals.js';
+export { graphicTypeEquals } from './graphicTypeEquals.js';
+export { downloadDICOMData } from './downloadDICOMData.js';

package/dist/esm/adapters/helpers/toArray.js

@@ -0,0 +1,5 @@
+var toArray = function toArray(x) {
+  return Array.isArray(x) ? x : [x];
+};
+
+export { toArray };

package/dist/esm/adapters/index.d.ts

@@ -0,0 +1,66 @@
+import * as Enums from "./enums";
+import * as helpers from "./helpers";
+declare const adaptersSR: {
+    Cornerstone: {
+        Length: typeof import("./Cornerstone/Length").default;
+        FreehandRoi: typeof import("./Cornerstone/FreehandRoi").default;
+        Bidirectional: typeof import("./Cornerstone/Bidirectional").default;
+        EllipticalRoi: typeof import("./Cornerstone/EllipticalRoi").default;
+        CircleRoi: typeof import("./Cornerstone/CircleRoi").default;
+        ArrowAnnotate: typeof import("./Cornerstone/ArrowAnnotate").default;
+        MeasurementReport: typeof import("./Cornerstone/MeasurementReport").default;
+        CobbAngle: typeof import("./Cornerstone/CobbAngle").default;
+        Angle: typeof import("./Cornerstone/Angle").default;
+        RectangleRoi: typeof import("./Cornerstone/RectangleRoi").default;
+    };
+    Cornerstone3D: {
+        Bidirectional: typeof import("./Cornerstone3D/Bidirectional").default;
+        CobbAngle: typeof import("./Cornerstone3D/CobbAngle").default;
+        Angle: typeof import("./Cornerstone3D/Angle").default;
+        Length: typeof import("./Cornerstone3D/Length").default;
+        CircleROI: typeof import("./Cornerstone3D/CircleROI").default;
+        EllipticalROI: typeof import("./Cornerstone3D/EllipticalROI").default;
+        RectangleROI: typeof import("./Cornerstone3D/RectangleROI").default;
+        ArrowAnnotate: typeof import("./Cornerstone3D/ArrowAnnotate").default;
+        Probe: typeof import("./Cornerstone3D/Probe").default;
+        PlanarFreehandROI: typeof import("./Cornerstone3D/PlanarFreehandROI").default;
+        UltrasoundDirectional: typeof import("./Cornerstone3D/UltrasoundDirectional").default;
+        MeasurementReport: typeof import("./Cornerstone3D/MeasurementReport").default;
+        CodeScheme: {
+            CodingSchemeDesignator: string;
+            codeValues: {
+                CORNERSTONEFREETEXT: string;
+            };
+        };
+        CORNERSTONE_3D_TAG: string;
+    };
+};
+declare const adaptersSEG: {
+    Cornerstone: {
+        Segmentation: typeof import("./Cornerstone/Segmentation");
+    };
+    Cornerstone3D: {
+        Segmentation: typeof import("./Cornerstone3D/Segmentation");
+    };
+    VTKjs: {
+        Segmentation: typeof import("./VTKjs/Segmentation").default;
+    };
+};
+declare const adaptersPMAP: {
+    Cornerstone: {
+        ParametricMap: {
+            generateToolState: (imageIds: any, arrayBuffer: any, metadataProvider: any, tolerance?: number) => Promise<{
+                pixelData: any;
+            }>;
+        };
+    };
+    Cornerstone3D: {
+        ParametricMap: typeof import("./Cornerstone3D/ParametricMap");
+    };
+};
+declare const adaptersRT: {
+    Cornerstone3D: {
+        RTSS: typeof import("./Cornerstone3D/RTStruct");
+    };
+};
+export { adaptersSR, adaptersSEG, adaptersPMAP, adaptersRT, Enums, helpers };

package/dist/esm/adapters/index.js

@@ -0,0 +1,24 @@
+import { CornerstoneSR, CornerstoneSEG, CornerstonePMAP } from './Cornerstone/index.js';
+import { Cornerstone3DSR, Cornerstone3DSEG, Cornerstone3DPMAP, Cornerstone3DRT } from './Cornerstone3D/index.js';
+import { VTKjsSEG } from './VTKjs/index.js';
+import './enums/Events.js';
+import './helpers/downloadDICOMData.js';
+
+var adaptersSR = {
+  Cornerstone: CornerstoneSR,
+  Cornerstone3D: Cornerstone3DSR
+};
+var adaptersSEG = {
+  Cornerstone: CornerstoneSEG,
+  Cornerstone3D: Cornerstone3DSEG,
+  VTKjs: VTKjsSEG
+};
+var adaptersPMAP = {
+  Cornerstone: CornerstonePMAP,
+  Cornerstone3D: Cornerstone3DPMAP
+};
+var adaptersRT = {
+  Cornerstone3D: Cornerstone3DRT
+};
+
+export { adaptersPMAP, adaptersRT, adaptersSEG, adaptersSR };

package/dist/esm/index.d.ts

@@ -0,0 +1,2 @@
+import { Enums, adaptersSR, adaptersSEG, adaptersPMAP, adaptersRT, helpers } from "./adapters";
+export { adaptersSR, adaptersSEG, adaptersPMAP, adaptersRT, Enums, helpers };

package/dist/esm/index.js

@@ -0,0 +1,5 @@
+export { adaptersPMAP, adaptersRT, adaptersSEG, adaptersSR } from './adapters/index.js';
+import * as index from './adapters/enums/index.js';
+export { index as Enums };
+import * as index$1 from './adapters/helpers/index.js';
+export { index$1 as helpers };