@cornerstonejs/adapters 2.0.0-beta.24 → 2.0.0-beta.25

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

@@ -0,0 +1,7 @@
+declare function generateToolState(imageIds: any, arrayBuffer: any, metadataProvider: any, tolerance?: number): Promise<{
+    pixelData: any;
+}>;
+declare const ParametricMapObj: {
+    generateToolState: typeof generateToolState;
+};
+export { ParametricMapObj as default, ParametricMapObj as ParametricMap };

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

@@ -0,0 +1,216 @@
+import { asyncToGenerator as _asyncToGenerator, regeneratorRuntime as _regeneratorRuntime, toConsumableArray as _toConsumableArray } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { data, normalizers, log } from 'dcmjs';
+import checkOrientation from '../helpers/checkOrientation.js';
+import compareArrays from '../helpers/compareArrays.js';
+
+var DicomMessage = data.DicomMessage,
+  DicomMetaDictionary = data.DicomMetaDictionary;
+var Normalizer = normalizers.Normalizer;
+function generateToolState(_x, _x2, _x3) {
+  return _generateToolState.apply(this, arguments);
+}
+function _generateToolState() {
+  _generateToolState = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(imageIds, arrayBuffer, metadataProvider) {
+    var tolerance,
+      dicomData,
+      dataset,
+      multiframe,
+      imagePlaneModule,
+      ImageOrientationPatient,
+      validOrientations,
+      pixelData,
+      orientation,
+      sopUIDImageIdIndexMap,
+      orientationText,
+      imageIdMaps,
+      _args = arguments;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          tolerance = _args.length > 3 && _args[3] !== undefined ? _args[3] : 1e-3;
+          dicomData = DicomMessage.readFile(arrayBuffer);
+          dataset = DicomMetaDictionary.naturalizeDataset(dicomData.dict);
+          dataset._meta = DicomMetaDictionary.namifyDataset(dicomData.meta);
+          multiframe = Normalizer.normalizeToDataset([dataset]);
+          imagePlaneModule = metadataProvider.get("imagePlaneModule", imageIds[0]);
+          if (!imagePlaneModule) {
+            console.warn("Insufficient metadata, imagePlaneModule missing.");
+          }
+          ImageOrientationPatient = Array.isArray(imagePlaneModule.rowCosines) ? [].concat(_toConsumableArray(imagePlaneModule.rowCosines), _toConsumableArray(imagePlaneModule.columnCosines)) : [imagePlaneModule.rowCosines.x, imagePlaneModule.rowCosines.y, imagePlaneModule.rowCosines.z, imagePlaneModule.columnCosines.x, imagePlaneModule.columnCosines.y, imagePlaneModule.columnCosines.z]; // It currently supports parametric maps with same orientation
+          validOrientations = [ImageOrientationPatient];
+          pixelData = getPixelData(multiframe);
+          orientation = checkOrientation(multiframe, validOrientations, [imagePlaneModule.rows, imagePlaneModule.columns, imageIds.length], tolerance); // Pre-compute the sop UID to imageId index map so that in the for loop
+          // we don't have to call metadataProvider.get() for each imageId over
+          // and over again.
+          sopUIDImageIdIndexMap = imageIds.reduce(function (acc, imageId) {
+            var _metadataProvider$get = metadataProvider.get("generalImageModule", imageId),
+              sopInstanceUID = _metadataProvider$get.sopInstanceUID;
+            acc[sopInstanceUID] = imageId;
+            return acc;
+          }, {});
+          if (!(orientation !== "Planar")) {
+            _context.next = 15;
+            break;
+          }
+          orientationText = {
+            Perpendicular: "orthogonal",
+            Oblique: "oblique"
+          };
+          throw new Error("Parametric maps ".concat(orientationText[orientation], " to the acquisition plane of the source data are not yet supported."));
+        case 15:
+          // Pre-compute the indices and metadata so that we don't have to call
+          // a function for each imageId in the for loop.
+          imageIdMaps = imageIds.reduce(function (acc, curr, index) {
+            acc.indices[curr] = index;
+            acc.metadata[curr] = metadataProvider.get("instance", curr);
+            return acc;
+          }, {
+            indices: {},
+            metadata: {}
+          });
+          _context.next = 18;
+          return insertPixelDataPlanar(pixelData, multiframe, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap, imageIdMaps);
+        case 18:
+          return _context.abrupt("return", {
+            pixelData: pixelData
+          });
+        case 19:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _generateToolState.apply(this, arguments);
+}
+function insertPixelDataPlanar(sourcePixelData, multiframe, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap, imageIdMaps) {
+  var targetPixelData = new sourcePixelData.constructor(sourcePixelData.length);
+  var PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
+    Rows = multiframe.Rows,
+    Columns = multiframe.Columns;
+  var sliceLength = Columns * Rows;
+  var numSlices = PerFrameFunctionalGroupsSequence.length;
+  for (var i = 0; i < numSlices; i++) {
+    var sourceSliceDataView = new sourcePixelData.constructor(sourcePixelData.buffer, i * sliceLength, sliceLength);
+    var imageId = findReferenceSourceImageId(multiframe, i, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
+    if (!imageId) {
+      console.warn("Image not present in stack, can't import frame : " + i + ".");
+      continue;
+    }
+    var sourceImageMetadata = imageIdMaps.metadata[imageId];
+    if (Rows !== sourceImageMetadata.Rows || Columns !== sourceImageMetadata.Columns) {
+      throw new Error("Parametric map have different geometry dimensions (Rows and Columns) " + "respect to the source image reference frame. This is not yet supported.");
+    }
+    var imageIdIndex = imageIdMaps.indices[imageId];
+    var byteOffset = sliceLength * imageIdIndex * targetPixelData.BYTES_PER_ELEMENT;
+    var targetSliceDataView = new targetPixelData.constructor(targetPixelData.buffer, byteOffset, sliceLength);
+    // Copy from source to target which works for parametric maps with same orientation.
+    // TODO: Find a dataset with parametric map in a different orientation and add finish this implementation
+    targetSliceDataView.set(sourceSliceDataView);
+  }
+  return targetPixelData;
+}
+function getPixelData(multiframe) {
+  var TypedArrayClass;
+  var data;
+  if (multiframe.PixelData) {
+    var _multiframe$PixelRepr;
+    var validTypedArrays = multiframe.BitsAllocated === 16 ? [Uint16Array, Int16Array] : [Uint32Array, Int32Array];
+    TypedArrayClass = validTypedArrays[(_multiframe$PixelRepr = multiframe.PixelRepresentation) !== null && _multiframe$PixelRepr !== void 0 ? _multiframe$PixelRepr : 0];
+    data = multiframe.PixelData;
+  } else if (multiframe.FloatPixelData) {
+    TypedArrayClass = Float32Array;
+    data = multiframe.FloatPixelData;
+  } else if (multiframe.DoubleFloatPixelData) {
+    TypedArrayClass = Float64Array;
+    data = multiframe.DoubleFloatPixelData;
+  }
+  if (data === undefined) {
+    log.error("This parametric map pixel data is undefined.");
+  }
+  if (Array.isArray(data)) {
+    data = data[0];
+  }
+  return new TypedArrayClass(data);
+}
+function findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap) {
+  var imageId = undefined;
+  if (!multiframe) {
+    return imageId;
+  }
+  var FrameOfReferenceUID = multiframe.FrameOfReferenceUID,
+    PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
+    SourceImageSequence = multiframe.SourceImageSequence,
+    ReferencedSeriesSequence = multiframe.ReferencedSeriesSequence;
+  if (!PerFrameFunctionalGroupsSequence || PerFrameFunctionalGroupsSequence.length === 0) {
+    return imageId;
+  }
+  var PerFrameFunctionalGroup = PerFrameFunctionalGroupsSequence[frameSegment];
+  if (!PerFrameFunctionalGroup) {
+    return imageId;
+  }
+  var frameSourceImageSequence = undefined;
+  if (PerFrameFunctionalGroup.DerivationImageSequence) {
+    var DerivationImageSequence = PerFrameFunctionalGroup.DerivationImageSequence;
+    if (Array.isArray(DerivationImageSequence)) {
+      if (DerivationImageSequence.length !== 0) {
+        DerivationImageSequence = DerivationImageSequence[0];
+      } else {
+        DerivationImageSequence = undefined;
+      }
+    }
+    if (DerivationImageSequence) {
+      frameSourceImageSequence = DerivationImageSequence.SourceImageSequence;
+      if (Array.isArray(frameSourceImageSequence)) {
+        if (frameSourceImageSequence.length !== 0) {
+          frameSourceImageSequence = frameSourceImageSequence[0];
+        } else {
+          frameSourceImageSequence = undefined;
+        }
+      }
+    }
+  } else if (SourceImageSequence && SourceImageSequence.length !== 0) {
+    console.warn("DerivationImageSequence not present, using SourceImageSequence assuming SEG has the same geometry as the source image.");
+    frameSourceImageSequence = SourceImageSequence[frameSegment];
+  }
+  if (frameSourceImageSequence) {
+    imageId = getImageIdOfSourceImageBySourceImageSequence(frameSourceImageSequence, sopUIDImageIdIndexMap);
+  }
+  if (imageId === undefined && ReferencedSeriesSequence) {
+    var referencedSeriesSequence = Array.isArray(ReferencedSeriesSequence) ? ReferencedSeriesSequence[0] : ReferencedSeriesSequence;
+    var ReferencedSeriesInstanceUID = referencedSeriesSequence.SeriesInstanceUID;
+    imageId = getImageIdOfSourceImagebyGeometry(ReferencedSeriesInstanceUID, FrameOfReferenceUID, PerFrameFunctionalGroup, imageIds, metadataProvider, tolerance);
+  }
+  return imageId;
+}
+function getImageIdOfSourceImageBySourceImageSequence(SourceImageSequence, sopUIDImageIdIndexMap) {
+  var ReferencedSOPInstanceUID = SourceImageSequence.ReferencedSOPInstanceUID,
+    ReferencedFrameNumber = SourceImageSequence.ReferencedFrameNumber;
+  return ReferencedFrameNumber ? getImageIdOfReferencedFrame(ReferencedSOPInstanceUID, ReferencedFrameNumber, sopUIDImageIdIndexMap) : sopUIDImageIdIndexMap[ReferencedSOPInstanceUID];
+}
+function getImageIdOfSourceImagebyGeometry(ReferencedSeriesInstanceUID, FrameOfReferenceUID, PerFrameFunctionalGroup, imageIds, metadataProvider, tolerance) {
+  if (ReferencedSeriesInstanceUID === undefined || PerFrameFunctionalGroup.PlanePositionSequence === undefined || PerFrameFunctionalGroup.PlanePositionSequence[0] === undefined || PerFrameFunctionalGroup.PlanePositionSequence[0].ImagePositionPatient === undefined) {
+    return undefined;
+  }
+  for (var imageIdsIndex = 0; imageIdsIndex < imageIds.length; ++imageIdsIndex) {
+    var sourceImageMetadata = metadataProvider.get("instance", imageIds[imageIdsIndex]);
+    if (sourceImageMetadata === undefined || sourceImageMetadata.ImagePositionPatient === undefined || sourceImageMetadata.FrameOfReferenceUID !== FrameOfReferenceUID || sourceImageMetadata.SeriesInstanceUID !== ReferencedSeriesInstanceUID) {
+      continue;
+    }
+    if (compareArrays(PerFrameFunctionalGroup.PlanePositionSequence[0].ImagePositionPatient, sourceImageMetadata.ImagePositionPatient, tolerance)) {
+      return imageIds[imageIdsIndex];
+    }
+  }
+}
+function getImageIdOfReferencedFrame(sopInstanceUid, frameNumber, sopUIDImageIdIndexMap) {
+  var imageId = sopUIDImageIdIndexMap[sopInstanceUid];
+  if (!imageId) {
+    return;
+  }
+  var imageIdFrameNumber = Number(imageId.split("frame=")[1]);
+  return imageIdFrameNumber === frameNumber - 1 ? imageId : undefined;
+}
+var ParametricMapObj = {
+  generateToolState: generateToolState
+};
+
+export { ParametricMapObj as ParametricMap, ParametricMapObj as default };

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

@@ -1,6 +1,7 @@
 import { toConsumableArray as _toConsumableArray } from '../../_virtual/_rollupPluginBabelHelpers.js';
 import { utilities, normalizers, derivations, log } from 'dcmjs';
 import ndarray from 'ndarray';
+import getDatasetsFromImages from '../helpers/getDatasetsFromImages.js';
 
 var _utilities$orientatio = utilities.orientation,
   rotateDirectionCosinesInPlane = _utilities$orientatio.rotateDirectionCosinesInPlane,
@@ -135,25 +136,7 @@ function _getSegCount(seg, segments) {
  * @returns {Object}              The Seg derived dataSet.
  */
 function _createSegFromImages(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);
-    }
-  }
-  var multiframe = Normalizer.normalizeToDataset(datasets);
+  var multiframe = getDatasetsFromImages(images, isMultiframe);
   return new SegmentationDerivation([multiframe], options);
 }
 

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

@@ -1,14 +1,17 @@
 import { asyncToGenerator as _asyncToGenerator, regeneratorRuntime as _regeneratorRuntime, toConsumableArray as _toConsumableArray, createForOfIteratorHelper as _createForOfIteratorHelper, slicedToArray as _slicedToArray } from '../../_virtual/_rollupPluginBabelHelpers.js';
 import { utilities, data, normalizers, derivations, log } from 'dcmjs';
 import ndarray from 'ndarray';
+import '../../node_modules/lodash.clonedeep/index.js';
+import getDatasetsFromImages from '../helpers/getDatasetsFromImages.js';
+import checkOrientation from '../helpers/checkOrientation.js';
+import compareArrays from '../helpers/compareArrays.js';
 import Events from '../enums/Events.js';
 
 var _utilities$orientatio = utilities.orientation,
   rotateDirectionCosinesInPlane = _utilities$orientatio.rotateDirectionCosinesInPlane,
   flipIOP = _utilities$orientatio.flipImageOrientationPatient,
   flipMatrix2D = _utilities$orientatio.flipMatrix2D,
-  rotateMatrix902D = _utilities$orientatio.rotateMatrix902D,
-  nearlyEqual = _utilities$orientatio.nearlyEqual;
+  rotateMatrix902D = _utilities$orientatio.rotateMatrix902D;
 var BitArray = data.BitArray,
   DicomMessage = data.DicomMessage,
   DicomMetaDictionary = data.DicomMetaDictionary;
@@ -157,27 +160,7 @@ function _getLabelmapsFromReferencedFrameIndicies(labelmap3D, referencedFrameInd
  * @returns {Object}              The Seg derived dataSet.
  */
 function _createSegFromImages(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);
-    dataset.SpecificCharacterSet = "ISO_IR 192";
-    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);
-      _dataset.SpecificCharacterSet = "ISO_IR 192";
-      datasets.push(_dataset);
-    }
-  }
-  var multiframe = Normalizer.normalizeToDataset(datasets);
+  var multiframe = getDatasetsFromImages(images, isMultiframe);
   return new SegmentationDerivation([multiframe], options);
 }
 
@@ -837,41 +820,6 @@ function insertPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray, labelmapBu
     processInChunks();
   });
 }
-function checkOrientation(multiframe, validOrientations, sourceDataDimensions, tolerance) {
-  var SharedFunctionalGroupsSequence = multiframe.SharedFunctionalGroupsSequence,
-    PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence;
-  var sharedImageOrientationPatient = SharedFunctionalGroupsSequence.PlaneOrientationSequence ? SharedFunctionalGroupsSequence.PlaneOrientationSequence.ImageOrientationPatient : undefined;
-
-  // Check if in plane.
-  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)) {
-    // Perpendicular and fits on same grid.
-    return "Perpendicular";
-  }
-  return "Oblique";
-}
-
-/**
- * checkIfPerpendicular - Returns true if iop1 and iop2 are perpendicular
- * within a tolerance.
- *
- * @param  {Number[6]} iop1 An ImageOrientationPatient array.
- * @param  {Number[6]} iop2 An ImageOrientationPatient array.
- * @param  {Number} tolerance.
- * @return {Boolean} True if iop1 and iop2 are equal.
- */
-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);
-}
 
 /**
  * unpackPixelData - Unpacks bit packed pixelData if the Segmentation is BINARY.
@@ -1059,27 +1007,6 @@ function alignPixelDataWithSourceData(pixelData2D, iop, orientations, tolerance)
     return rotateMatrix902D(rotateMatrix902D(rotateMatrix902D(pixelData2D)));
   }
 }
-
-/**
- * compareArrays - Returns true if array1 and array2 are equal
- * within a tolerance.
- *
- * @param  {Number[]} array1 - An array.
- * @param  {Number[]} array2 - An array.
- * @param {Number} tolerance.
- * @return {Boolean} True if array1 and array2 are equal.
- */
-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;
-}
 function getSegmentMetadata(multiframe, seriesInstanceUid) {
   var segmentSequence = multiframe.SegmentSequence;
   var data = [];

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

@@ -31,4 +31,11 @@ declare const CornerstoneSEG: {
         }, cornerstoneToolsVersion?: number) => Blob;
     };
 };
-export { CornerstoneSR, CornerstoneSEG };
+declare const CornerstonePMAP: {
+    ParametricMap: {
+        generateToolState: (imageIds: any, arrayBuffer: any, metadataProvider: any, tolerance?: number) => Promise<{
+            pixelData: any;
+        }>;
+    };
+};
+export { CornerstoneSR, CornerstoneSEG, CornerstonePMAP };

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

@@ -9,6 +9,7 @@ import CobbAngle from './CobbAngle.js';
 import Angle from './Angle.js';
 import RectangleRoi from './RectangleRoi.js';
 import Segmentation from './Segmentation.js';
+import ParametricMapObj from './ParametricMap.js';
 
 var CornerstoneSR = {
   Length: Length,
@@ -25,5 +26,8 @@ var CornerstoneSR = {
 var CornerstoneSEG = {
   Segmentation: Segmentation
 };
+var CornerstonePMAP = {
+  ParametricMap: ParametricMapObj
+};
 
-export { CornerstoneSEG, CornerstoneSR };
+export { CornerstonePMAP, CornerstoneSEG, CornerstoneSR };

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

@@ -0,0 +1,3 @@
+export function generateToolState(imageIds: any, arrayBuffer: any, metadataProvider: any, skipOverlapping?: boolean, tolerance?: number): Promise<{
+    pixelData: any;
+}>;

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

@@ -0,0 +1,11 @@
+import { CornerstonePMAP } from '../../Cornerstone/index.js';
+
+var ParametricMap = CornerstonePMAP.ParametricMap;
+var generateToolStateCornerstone = ParametricMap.generateToolState;
+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 generateToolStateCornerstone(imageIds, arrayBuffer, metadataProvider, skipOverlapping, tolerance);
+}
+
+export { generateToolState };

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

@@ -0,0 +1 @@
+export { generateToolState } from "./generateToolState";

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

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

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

@@ -11,6 +11,7 @@ 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;
@@ -36,7 +37,10 @@ declare const Cornerstone3DSR: {
 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

@@ -13,7 +13,8 @@ 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';
+import * as index$1 from './ParametricMap/index.js';
+import * as index$2 from './RTStruct/index.js';
 
 var Cornerstone3DSR = {
   Bidirectional: Bidirectional,
@@ -34,8 +35,11 @@ var Cornerstone3DSR = {
 var Cornerstone3DSEG = {
   Segmentation: index
 };
+var Cornerstone3DPMAP = {
+  ParametricMap: index$1
+};
 var Cornerstone3DRT = {
-  RTSS: index$1
+  RTSS: index$2
 };
 
-export { Cornerstone3DRT, Cornerstone3DSEG, Cornerstone3DSR };
+export { Cornerstone3DPMAP, Cornerstone3DRT, Cornerstone3DSEG, Cornerstone3DSR };

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

@@ -0,0 +1,9 @@
+/**
+ * Returns true if iop1 and iop2 are perpendicular within a tolerance.
+ *
+ * @param iop1 - First ImageOrientationPatient
+ * @param iop2 - Second ImageOrientationPatient
+ * @param tolerance - Tolerance
+ * @returns True if iop1 and iop2 are equal.
+ */
+export default function checkIfPerpendicular(iop1: number[], iop2: number[], tolerance: number): boolean;

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

@@ -0,0 +1,15 @@
+/**
+ * Returns true if iop1 and iop2 are perpendicular within a tolerance.
+ *
+ * @param iop1 - First ImageOrientationPatient
+ * @param iop2 - Second ImageOrientationPatient
+ * @param tolerance - Tolerance
+ * @returns True if iop1 and iop2 are equal.
+ */
+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,24 @@
+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;
+  // Check if in plane.
+  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)) {
+    // Perpendicular and fits on same grid.
+    return "Perpendicular";
+  }
+  return "Oblique";
+}
+
+export { checkOrientation as default };

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

@@ -0,0 +1,9 @@
+/**
+ * Returns true if array1 and array2 are equal within a tolerance.
+ *
+ * @param array1 - First array
+ * @param array2 - Second array
+ * @param tolerance - Tolerance
+ * @returns True if array1 and array2 are equal.
+ */
+export default function compareArrays(array1: number[], array2: number[], tolerance: number): boolean;

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

@@ -0,0 +1,24 @@
+import { utilities } from 'dcmjs';
+
+var nearlyEqual = utilities.orientation.nearlyEqual;
+/**
+ * Returns true if array1 and array2 are equal within a tolerance.
+ *
+ * @param array1 - First array
+ * @param array2 - Second array
+ * @param tolerance - Tolerance
+ * @returns True if array1 and array2 are equal.
+ */
+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/getDatasetsFromImages.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Convert an array of cornerstone images into datasets
+ *
+ * @param  images - An array of the cornerstone image objects
+ * @param isMultiframe - Whether the images are multiframe
+ * @param options - Options object that may contain:
+ *   - SpecificCharacterSet: character set to be set to each dataset
+ */
+export default function getDatasetsFromImages(images: any, isMultiframe: any, options?: any): any;

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

@@ -0,0 +1,41 @@
+import { data, normalizers } from 'dcmjs';
+
+var DicomMessage = data.DicomMessage,
+  DicomMetaDictionary = data.DicomMetaDictionary;
+var Normalizer = normalizers.Normalizer;
+/**
+ * Convert an array of cornerstone images into datasets
+ *
+ * @param  images - An array of the cornerstone image objects
+ * @param isMultiframe - Whether the images are multiframe
+ * @param options - Options object that may contain:
+ *   - SpecificCharacterSet: character set to be set to each dataset
+ */
+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/index.d.ts

@@ -54,9 +54,21 @@ declare const adaptersSEG: {
         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, adaptersRT, Enums, helpers };
+export { adaptersSR, adaptersSEG, adaptersPMAP, adaptersRT, Enums, helpers };