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

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

@@ -0,0 +1,36 @@
+declare class UltrasoundDirectional {
+    static toolType: string;
+    static utilityToolType: string;
+    static TID300Representation: any;
+    static isValidCornerstoneTrackingIdentifier: (TrackingIdentifier: any) => boolean;
+    static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any): {
+        description: any;
+        sopInstanceUid: any;
+        annotation: {
+            annotationUID: any;
+            metadata: {
+                toolName: any;
+                referencedImageId: any;
+                FrameOfReferenceUID: any;
+                label: string;
+            };
+            data: any;
+        };
+        finding: any;
+        findingSites: any[];
+    };
+    static getTID300RepresentationArguments(tool: any, worldToImageCoords: any): {
+        point1: {
+            x: any;
+            y: any;
+        };
+        point2: {
+            x: any;
+            y: any;
+        };
+        trackingIdentifierTextValue: string;
+        finding: any;
+        findingSites: any;
+    };
+}
+export default UltrasoundDirectional;

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

@@ -0,0 +1,93 @@
+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 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:
+    // TODO: this function is required for all Cornerstone Tool Adapters, since it is called by MeasurementReport.
+    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 || []
+      };
+    }
+  }]);
+}();
+_defineProperty(UltrasoundDirectional, "toolType", ULTRASOUND_DIRECTIONAL);
+_defineProperty(UltrasoundDirectional, "utilityToolType", ULTRASOUND_DIRECTIONAL);
+_defineProperty(UltrasoundDirectional, "TID300Representation", TID300Length);
+_defineProperty(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 };

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

@@ -1,28 +1,42 @@
 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 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;
 };
-export { Cornerstone3DSR, Cornerstone3DSEG };
+declare const Cornerstone3DRT: {
+    RTSS: typeof RTSS;
+};
+export { Cornerstone3DSR, Cornerstone3DSEG, Cornerstone3DRT };

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

@@ -0,0 +1,41 @@
+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 './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 Cornerstone3DRT = {
+  RTSS: index$1
+};
+
+export { Cornerstone3DRT, Cornerstone3DSEG, Cornerstone3DSR };

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

@@ -0,0 +1,20 @@
+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;
+  }
+  // The following is needed since the new cornerstone3D has changed
+  // case names such as EllipticalRoi to EllipticalROI
+  return toolType.toLowerCase() === this.toolType.toLowerCase();
+}
+
+export { isValidCornerstoneTrackingIdentifier as default };

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

@@ -0,0 +1,41 @@
+export default class 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 {{}}
+     */
+    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/esm/adapters/enums/Events.js

@@ -0,0 +1,13 @@
+/**
+ * Cornerstone adapters events
+ */
+var Events;
+(function (Events) {
+  /**
+   * Cornerstone segmentation load progress event
+   */
+  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/codeMeaningEquals.js

@@ -0,0 +1,14 @@
+/**
+ * Returns a function that checks if a given content item's ConceptNameCodeSequence.CodeMeaning
+ * matches the provided codeMeaningName.
+ * @param codeMeaningName - The CodeMeaning to match against.
+ * @returns A function that takes a content item and returns a boolean indicating whether the
+ * content item's CodeMeaning matches the provided codeMeaningName.
+ */
+var codeMeaningEquals = function codeMeaningEquals(codeMeaningName) {
+  return function (contentItem) {
+    return contentItem.ConceptNameCodeSequence.CodeMeaning === codeMeaningName;
+  };
+};
+
+export { codeMeaningEquals };

package/dist/{types → esm}/adapters/helpers/downloadDICOMData.d.ts

@@ -1,5 +1,5 @@
 interface DicomDataset {
-    _meta?: any;
+    _meta?: unknown;
 }
 /**
  * Trigger file download from an array buffer

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

@@ -0,0 +1,31 @@
+import { data } from 'dcmjs';
+import { Buffer } from 'buffer';
+
+var datasetToDict = data.datasetToDict;
+/**
+ * Trigger file download from an array buffer
+ * @param bufferOrDataset - ArrayBuffer or DicomDataset
+ * @param filename - name of the file to download
+ */
+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/graphicTypeEquals.js

@@ -0,0 +1,12 @@
+/**
+ * Checks if a given content item's GraphicType property matches a specified value.
+ * @param {string} graphicType - The value to compare the content item's GraphicType property to.
+ * @returns {function} A function that takes a content item and returns a boolean indicating whether its GraphicType property matches the specified value.
+ */
+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,62 @@
+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: {
+            generateSegmentation: (images: object[], labelmaps3DorBrushData: any | any[], options?: {
+                includeSliceSpacing: boolean;
+            }, cornerstoneToolsVersion?: number) => any;
+            generateToolState: (imageIds: string[], arrayBuffer: ArrayBuffer, metadataProvider: any, skipOverlapping?: bool, tolerance?: number, cornerstoneToolsVersion?: number) => any;
+            fillSegmentation: (segmentation: object[], inputLabelmaps3D: any | any[], options?: {
+                includeSliceSpacing: boolean;
+            }, cornerstoneToolsVersion?: number) => Blob;
+        };
+    };
+    Cornerstone3D: {
+        Segmentation: typeof import("./Cornerstone3D/Segmentation");
+    };
+    VTKjs: {
+        Segmentation: typeof import("./VTKjs/Segmentation").default;
+    };
+};
+declare const adaptersRT: {
+    Cornerstone3D: {
+        RTSS: typeof import("./Cornerstone3D/RTStruct");
+    };
+};
+export { adaptersSR, adaptersSEG, adaptersRT, Enums, helpers };