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

package/dist/umd/adapters.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('dcmjs'), require('buffer'), require('ndarray'), require('gl-matrix'), require('@cornerstonejs/tools')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'dcmjs', 'buffer', 'ndarray', 'gl-matrix', '@cornerstonejs/tools'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Adapters = {}, global.dcmjs, global.buffer, global.ndarray, global.glMatrix, global.cornerstoneTools));
-})(this, (function (exports, dcmjs, buffer, ndarray, glMatrix, tools) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('dcmjs'), require('buffer'), require('ndarray'), require('lodash.clonedeep'), require('gl-matrix'), require('@cornerstonejs/tools')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'dcmjs', 'buffer', 'ndarray', 'lodash.clonedeep', 'gl-matrix', '@cornerstonejs/tools'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Adapters = {}, global.dcmjs, global.buffer, global.ndarray, global._.cloneDeep, global.glMatrix, global.cornerstoneTools));
+})(this, (function (exports, dcmjs, buffer, ndarray, lodash_clonedeep, glMatrix, tools) { 'use strict';
 
   function _arrayLikeToArray(r, a) {
     (null == a || a > r.length) && (a = r.length);
@@ -562,10 +562,10 @@
   var TID1500$1 = dcmjs.utilities.TID1500,
     addAccessors$1 = dcmjs.utilities.addAccessors;
   var StructuredReport$1 = dcmjs.derivations.StructuredReport;
-  var Normalizer$4 = dcmjs.normalizers.Normalizer;
+  var Normalizer$6 = dcmjs.normalizers.Normalizer;
   var TID1500MeasurementReport$1 = TID1500$1.TID1500MeasurementReport,
     TID1501MeasurementGroup$1 = TID1500$1.TID1501MeasurementGroup;
-  var DicomMetaDictionary$4 = dcmjs.data.DicomMetaDictionary;
+  var DicomMetaDictionary$6 = dcmjs.data.DicomMetaDictionary;
   var FINDING$2 = {
     CodingSchemeDesignator: "DCM",
     CodeValue: "121071"
@@ -696,7 +696,7 @@
             ReferencedSOPClassUID: sopCommonModule.sopClassUID,
             ReferencedSOPInstanceUID: sopCommonModule.sopInstanceUID
           };
-          if (Normalizer$4.isMultiframeSOPClassUID(sopCommonModule.sopClassUID)) {
+          if (Normalizer$6.isMultiframeSOPClassUID(sopCommonModule.sopClassUID)) {
             ReferencedSOPSequence.ReferencedFrameNumber = frameNumber;
           }
 
@@ -737,7 +737,7 @@
             vr: "UI"
           },
           ImplementationClassUID: {
-            Value: [DicomMetaDictionary$4.uid()],
+            Value: [DicomMetaDictionary$6.uid()],
             // TODO: could be git hash or other valid id
             vr: "UI"
           },
@@ -1793,6 +1793,44 @@
   };
   MeasurementReport$1.registerTool(RectangleRoi);
 
+  var DicomMessage$3 = dcmjs.data.DicomMessage,
+    DicomMetaDictionary$5 = dcmjs.data.DicomMetaDictionary;
+  var Normalizer$5 = dcmjs.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$3.readFile(arrayBuffer);
+      var dataset = DicomMetaDictionary$5.naturalizeDataset(dicomData.dict);
+      dataset._meta = DicomMetaDictionary$5.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$3.readFile(_arrayBuffer);
+        var _dataset = DicomMetaDictionary$5.naturalizeDataset(_dicomData.dict);
+        _dataset._meta = DicomMetaDictionary$5.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$5.normalizeToDataset(datasets);
+  }
+
   var _utilities$orientatio$1 = dcmjs.utilities.orientation,
     rotateDirectionCosinesInPlane$1 = _utilities$orientatio$1.rotateDirectionCosinesInPlane,
     flipIOP$1 = _utilities$orientatio$1.flipImageOrientationPatient,
@@ -1800,13 +1838,13 @@
     rotateMatrix902D$1 = _utilities$orientatio$1.rotateMatrix902D;
   var datasetToBlob = dcmjs.utilities.datasetToBlob,
     BitArray$2 = dcmjs.utilities.BitArray,
-    DicomMessage$1 = dcmjs.utilities.DicomMessage,
-    DicomMetaDictionary$3 = dcmjs.utilities.DicomMetaDictionary;
-  var Normalizer$3 = dcmjs.normalizers.Normalizer;
+    DicomMessage$2 = dcmjs.utilities.DicomMessage,
+    DicomMetaDictionary$4 = dcmjs.utilities.DicomMetaDictionary;
+  var Normalizer$4 = dcmjs.normalizers.Normalizer;
   var SegmentationDerivation$2 = dcmjs.derivations.Segmentation;
   var Segmentation$5 = {
     generateSegmentation: generateSegmentation$3,
-    generateToolState: generateToolState$3
+    generateToolState: generateToolState$5
   };
 
   /**
@@ -1926,25 +1964,7 @@
    * @returns {Object}              The Seg derived dataSet.
    */
   function _createSegFromImages$1(images, isMultiframe, options) {
-    var datasets = [];
-    if (isMultiframe) {
-      var image = images[0];
-      var arrayBuffer = image.data.byteArray.buffer;
-      var dicomData = DicomMessage$1.readFile(arrayBuffer);
-      var dataset = DicomMetaDictionary$3.naturalizeDataset(dicomData.dict);
-      dataset._meta = DicomMetaDictionary$3.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$1.readFile(_arrayBuffer);
-        var _dataset = DicomMetaDictionary$3.naturalizeDataset(_dicomData.dict);
-        _dataset._meta = DicomMetaDictionary$3.namifyDataset(_dicomData.meta);
-        datasets.push(_dataset);
-      }
-    }
-    var multiframe = Normalizer$3.normalizeToDataset(datasets);
+    var multiframe = getDatasetsFromImages(images, isMultiframe);
     return new SegmentationDerivation$2([multiframe], options);
   }
 
@@ -1958,11 +1978,11 @@
    * @returns {Object}  The toolState and an object from which the
    *                    segment metadata can be derived.
    */
-  function generateToolState$3(imageIds, arrayBuffer, metadataProvider) {
-    var dicomData = DicomMessage$1.readFile(arrayBuffer);
-    var dataset = DicomMetaDictionary$3.naturalizeDataset(dicomData.dict);
-    dataset._meta = DicomMetaDictionary$3.namifyDataset(dicomData.meta);
-    var multiframe = Normalizer$3.normalizeToDataset([dataset]);
+  function generateToolState$5(imageIds, arrayBuffer, metadataProvider) {
+    var dicomData = DicomMessage$2.readFile(arrayBuffer);
+    var dataset = DicomMetaDictionary$4.naturalizeDataset(dicomData.dict);
+    dataset._meta = DicomMetaDictionary$4.namifyDataset(dicomData.meta);
+    var multiframe = Normalizer$4.normalizeToDataset([dataset]);
     var imagePlaneModule = metadataProvider.get("imagePlaneModule", imageIds[0]);
     if (!imagePlaneModule) {
       console.warn("Insufficient metadata, imagePlaneModule missing.");
@@ -2077,7 +2097,7 @@
   function getImageIdOfSourceImage(SourceImageSequence, imageIds, metadataProvider) {
     var ReferencedSOPInstanceUID = SourceImageSequence.ReferencedSOPInstanceUID,
       ReferencedFrameNumber = SourceImageSequence.ReferencedFrameNumber;
-    return ReferencedFrameNumber ? getImageIdOfReferencedFrame$1(ReferencedSOPInstanceUID, ReferencedFrameNumber, imageIds, metadataProvider) : getImageIdOfReferencedSingleFramedSOPInstance(ReferencedSOPInstanceUID, imageIds, metadataProvider);
+    return ReferencedFrameNumber ? getImageIdOfReferencedFrame$2(ReferencedSOPInstanceUID, ReferencedFrameNumber, imageIds, metadataProvider) : getImageIdOfReferencedSingleFramedSOPInstance(ReferencedSOPInstanceUID, imageIds, metadataProvider);
   }
 
   /**
@@ -2111,7 +2131,7 @@
    *                                   from the cornerstone imageIds.
    * @return {String}                  The imageId that corresponds to the sopInstanceUid.
    */
-  function getImageIdOfReferencedFrame$1(sopInstanceUid, frameNumber, imageIds, metadataProvider) {
+  function getImageIdOfReferencedFrame$2(sopInstanceUid, frameNumber, imageIds, metadataProvider) {
     var imageId = imageIds.find(function (imageId) {
       var sopCommonModule = metadataProvider.get("sopCommonModule", imageId);
       if (!sopCommonModule) {
@@ -2216,6 +2236,61 @@
     };
   }
 
+  /**
+   * 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);
+  }
+
+  var nearlyEqual = dcmjs.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;
+  }
+
+  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";
+  }
+
   /**
    * Cornerstone adapters events
    */
@@ -2237,12 +2312,11 @@
     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$1 = dcmjs.data.BitArray,
-    DicomMessage = dcmjs.data.DicomMessage,
-    DicomMetaDictionary$2 = dcmjs.data.DicomMetaDictionary;
-  var Normalizer$2 = dcmjs.normalizers.Normalizer;
+    DicomMessage$1 = dcmjs.data.DicomMessage,
+    DicomMetaDictionary$3 = dcmjs.data.DicomMetaDictionary;
+  var Normalizer$3 = dcmjs.normalizers.Normalizer;
   var SegmentationDerivation$1 = dcmjs.derivations.Segmentation;
   var _utilities$compressio = dcmjs.utilities.compression,
     encode = _utilities$compressio.encode,
@@ -2387,27 +2461,7 @@
    * @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$2.naturalizeDataset(dicomData.dict);
-      dataset._meta = DicomMetaDictionary$2.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$2.naturalizeDataset(_dicomData.dict);
-        _dataset._meta = DicomMetaDictionary$2.namifyDataset(_dicomData.meta);
-        _dataset.SpecificCharacterSet = "ISO_IR 192";
-        datasets.push(_dataset);
-      }
-    }
-    var multiframe = Normalizer$2.normalizeToDataset(datasets);
+    var multiframe = getDatasetsFromImages(images, isMultiframe);
     return new SegmentationDerivation$1([multiframe], options);
   }
 
@@ -2426,8 +2480,8 @@
    * @return {[][][]} 3D list containing the track of segments per frame for each labelMap
    *                  (available only for the overlapping case).
    */
-  function generateToolState$2(_x, _x2, _x3, _x4) {
-    return _generateToolState.apply(this, arguments);
+  function generateToolState$4(_x, _x2, _x3, _x4) {
+    return _generateToolState$1.apply(this, arguments);
   } // function insertPixelDataPerpendicular(
   //     segmentsOnFrame,
   //     labelmapBuffer,
@@ -2579,17 +2633,17 @@
    *
    * @returns {String}     Returns the imageId
    */
-  function _generateToolState() {
-    _generateToolState = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(imageIds, arrayBuffer, metadataProvider, options) {
+  function _generateToolState$1() {
+    _generateToolState$1 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(imageIds, arrayBuffer, metadataProvider, options) {
       var _options$skipOverlapp, skipOverlapping, _options$tolerance, tolerance, _options$TypedArrayCo, TypedArrayConstructor, _options$maxBytesPerC, maxBytesPerChunk, eventTarget, triggerEvent, dicomData, dataset, multiframe, imagePlaneModule, generalSeriesModule, SeriesInstanceUID, ImageOrientationPatient, validOrientations, sliceLength, segMetadata, TransferSyntaxUID, pixelData, pixelDataChunks, rleEncodedFrames, orientation, sopUIDImageIdIndexMap, overlapping, insertFunction, segmentsOnFrameArray, segmentsOnFrame, arrayBufferLength, labelmapBufferArray, imageIdMaps, segmentsPixelIndices, overlappingSegments, centroidXYZ;
       return _regeneratorRuntime().wrap(function _callee$(_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
             _options$skipOverlapp = options.skipOverlapping, skipOverlapping = _options$skipOverlapp === void 0 ? false : _options$skipOverlapp, _options$tolerance = options.tolerance, tolerance = _options$tolerance === void 0 ? 1e-3 : _options$tolerance, _options$TypedArrayCo = options.TypedArrayConstructor, TypedArrayConstructor = _options$TypedArrayCo === void 0 ? Uint8Array : _options$TypedArrayCo, _options$maxBytesPerC = options.maxBytesPerChunk, maxBytesPerChunk = _options$maxBytesPerC === void 0 ? 199000000 : _options$maxBytesPerC, eventTarget = options.eventTarget, triggerEvent = options.triggerEvent;
-            dicomData = DicomMessage.readFile(arrayBuffer);
-            dataset = DicomMetaDictionary$2.naturalizeDataset(dicomData.dict);
-            dataset._meta = DicomMetaDictionary$2.namifyDataset(dicomData.meta);
-            multiframe = Normalizer$2.normalizeToDataset([dataset]);
+            dicomData = DicomMessage$1.readFile(arrayBuffer);
+            dataset = DicomMetaDictionary$3.naturalizeDataset(dicomData.dict);
+            dataset._meta = DicomMetaDictionary$3.namifyDataset(dicomData.meta);
+            multiframe = Normalizer$3.normalizeToDataset([dataset]);
             imagePlaneModule = metadataProvider.get("imagePlaneModule", imageIds[0]);
             generalSeriesModule = metadataProvider.get("generalSeriesModule", imageIds[0]);
             SeriesInstanceUID = generalSeriesModule.seriesInstanceUID;
@@ -2648,7 +2702,7 @@
             if (overlapping) {
               insertFunction = insertOverlappingPixelDataPlanar;
             } else {
-              insertFunction = insertPixelDataPlanar;
+              insertFunction = insertPixelDataPlanar$1;
             }
             return _context.abrupt("break", 37);
           case 35:
@@ -2714,9 +2768,9 @@
         }
       }, _callee);
     }));
-    return _generateToolState.apply(this, arguments);
+    return _generateToolState$1.apply(this, arguments);
   }
-  function findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap) {
+  function findReferenceSourceImageId$1(multiframe, frameSegment, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap) {
     var imageId = undefined;
     if (!multiframe) {
       return imageId;
@@ -2757,12 +2811,12 @@
       frameSourceImageSequence = SourceImageSequence[frameSegment];
     }
     if (frameSourceImageSequence) {
-      imageId = getImageIdOfSourceImageBySourceImageSequence(frameSourceImageSequence, sopUIDImageIdIndexMap);
+      imageId = getImageIdOfSourceImageBySourceImageSequence$1(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);
+      imageId = getImageIdOfSourceImagebyGeometry$1(ReferencedSeriesInstanceUID, FrameOfReferenceUID, PerFrameFunctionalGroup, imageIds, metadataProvider, tolerance);
     }
     return imageId;
   }
@@ -2799,7 +2853,7 @@
           console.warn("Could not retrieve the segment index for frame segment " + frameSegment + ", skipping this frame.");
           return 0; // continue
         }
-        var imageId = findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
+        var imageId = findReferenceSourceImageId$1(multiframe, frameSegment, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
         if (!imageId) {
           console.warn("Image not present in stack, can't import frame : " + frameSegment + ".");
           return 0; // continue
@@ -2908,7 +2962,7 @@
           if (!alignedPixelDataI) {
             throw new Error("Individual SEG frames are out of plane with respect to the first SEG frame. " + "This is not yet supported. Aborting segmentation loading.");
           }
-          var imageId = findReferenceSourceImageId(multiframe, _i2, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
+          var imageId = findReferenceSourceImageId$1(multiframe, _i2, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
           if (!imageId) {
             console.warn("Image not present in stack, can't import frame : " + _i2 + ".");
             i = _i2;
@@ -2976,7 +3030,7 @@
     var PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[frame];
     return PerFrameFunctionalGroups && PerFrameFunctionalGroups.SegmentIdentificationSequence ? PerFrameFunctionalGroups.SegmentIdentificationSequence.ReferencedSegmentNumber : SharedFunctionalGroupsSequence.SegmentIdentificationSequence ? SharedFunctionalGroupsSequence.SegmentIdentificationSequence.ReferencedSegmentNumber : undefined;
   };
-  function insertPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray, labelmapBufferArray, pixelData, multiframe, imageIds, validOrientations, metadataProvider, tolerance, TypedArrayConstructor, segmentsPixelIndices, sopUIDImageIdIndexMap, imageIdMaps, eventTarget, triggerEvent) {
+  function insertPixelDataPlanar$1(segmentsOnFrame, segmentsOnFrameArray, labelmapBufferArray, pixelData, multiframe, imageIds, validOrientations, metadataProvider, tolerance, TypedArrayConstructor, segmentsPixelIndices, sopUIDImageIdIndexMap, imageIdMaps, eventTarget, triggerEvent) {
     var SharedFunctionalGroupsSequence = multiframe.SharedFunctionalGroupsSequence,
       PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
       Rows = multiframe.Rows,
@@ -3011,7 +3065,7 @@
           if (!segmentsPixelIndices.has(segmentIndex)) {
             segmentsPixelIndices.set(segmentIndex, {});
           }
-          var imageId = findReferenceSourceImageId(multiframe, i, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
+          var imageId = findReferenceSourceImageId$1(multiframe, i, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
           if (!imageId) {
             console.warn("Image not present in stack, can't import frame : " + i + ".");
             continue;
@@ -3067,41 +3121,6 @@
       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.
@@ -3164,10 +3183,10 @@
    * @param  {Object}   sopUIDImageIdIndexMap A map of SOPInstanceUIDs to imageIds.
    * @return {String}                        The corresponding imageId.
    */
-  function getImageIdOfSourceImageBySourceImageSequence(SourceImageSequence, sopUIDImageIdIndexMap) {
+  function getImageIdOfSourceImageBySourceImageSequence$1(SourceImageSequence, sopUIDImageIdIndexMap) {
     var ReferencedSOPInstanceUID = SourceImageSequence.ReferencedSOPInstanceUID,
       ReferencedFrameNumber = SourceImageSequence.ReferencedFrameNumber;
-    return ReferencedFrameNumber ? getImageIdOfReferencedFrame(ReferencedSOPInstanceUID, ReferencedFrameNumber, sopUIDImageIdIndexMap) : sopUIDImageIdIndexMap[ReferencedSOPInstanceUID];
+    return ReferencedFrameNumber ? getImageIdOfReferencedFrame$1(ReferencedSOPInstanceUID, ReferencedFrameNumber, sopUIDImageIdIndexMap) : sopUIDImageIdIndexMap[ReferencedSOPInstanceUID];
   }
 
   /**
@@ -3182,7 +3201,7 @@
    *
    * @return {String}                                   The corresponding imageId.
    */
-  function getImageIdOfSourceImagebyGeometry(ReferencedSeriesInstanceUID, FrameOfReferenceUID, PerFrameFunctionalGroup, imageIds, metadataProvider, tolerance) {
+  function getImageIdOfSourceImagebyGeometry$1(ReferencedSeriesInstanceUID, FrameOfReferenceUID, PerFrameFunctionalGroup, imageIds, metadataProvider, tolerance) {
     if (ReferencedSeriesInstanceUID === undefined || PerFrameFunctionalGroup.PlanePositionSequence === undefined || PerFrameFunctionalGroup.PlanePositionSequence[0] === undefined || PerFrameFunctionalGroup.PlanePositionSequence[0].ImagePositionPatient === undefined) {
       return undefined;
     }
@@ -3207,7 +3226,7 @@
    * @param  {Object} sopUIDImageIdIndexMap A map of SOPInstanceUIDs to imageIds.
    * @return {String}                  The imageId that corresponds to the sopInstanceUid.
    */
-  function getImageIdOfReferencedFrame(sopInstanceUid, frameNumber, sopUIDImageIdIndexMap) {
+  function getImageIdOfReferencedFrame$1(sopInstanceUid, frameNumber, sopUIDImageIdIndexMap) {
     var imageId = sopUIDImageIdIndexMap[sopInstanceUid];
     if (!imageId) {
       return;
@@ -3289,27 +3308,6 @@
       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 = [];
@@ -3423,13 +3421,13 @@
   }
   var Segmentation$4 = {
     generateSegmentation: generateSegmentation$2,
-    generateToolState: generateToolState$2,
+    generateToolState: generateToolState$4,
     fillSegmentation: fillSegmentation$1
   };
 
   var Segmentation$3 = {
     generateSegmentation: generateSegmentation$1,
-    generateToolState: generateToolState$1,
+    generateToolState: generateToolState$3,
     fillSegmentation: fillSegmentation
   };
 
@@ -3470,7 +3468,7 @@
    * @returns {Object}  The toolState and an object from which the
    *                    segment metadata can be derived.
    */
-  function generateToolState$1(imageIds, arrayBuffer, metadataProvider) {
+  function generateToolState$3(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;
@@ -3502,6 +3500,216 @@
     console.warn("No generateSegmentation adapater for cornerstone version ".concat(cornerstoneToolsVersion, ", exiting."));
   }
 
+  var DicomMessage = dcmjs.data.DicomMessage,
+    DicomMetaDictionary$2 = dcmjs.data.DicomMetaDictionary;
+  var Normalizer$2 = dcmjs.normalizers.Normalizer;
+  function generateToolState$2(_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$2.naturalizeDataset(dicomData.dict);
+            dataset._meta = DicomMetaDictionary$2.namifyDataset(dicomData.meta);
+            multiframe = Normalizer$2.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) {
+      dcmjs.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$2
+  };
+
   var CornerstoneSR = {
     Length: Length$1,
     FreehandRoi: FreehandRoi,
@@ -3517,6 +3725,9 @@
   var CornerstoneSEG = {
     Segmentation: Segmentation$3
   };
+  var CornerstonePMAP = {
+    ParametricMap: ParametricMapObj
+  };
 
   var CORNERSTONE_3D_TAG = "Cornerstone3DTools@^0.1.0";
 
@@ -5151,7 +5362,7 @@
    *  list containing the track of segments per frame
    *  list containing the track of segments per frame for each labelMap                   (available only for the overlapping case).
    */
-  function generateToolState(imageIds, arrayBuffer, metadataProvider) {
+  function generateToolState$1(imageIds, arrayBuffer, metadataProvider) {
     var skipOverlapping = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
     var tolerance = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1e-3;
     return generateToolStateCornerstoneLegacy(imageIds, arrayBuffer, metadataProvider, skipOverlapping, tolerance);
@@ -5161,6 +5372,19 @@
     __proto__: null,
     generateLabelMaps2DFrom3D: generateLabelMaps2DFrom3D,
     generateSegmentation: generateSegmentation,
+    generateToolState: generateToolState$1
+  });
+
+  var ParametricMap$1 = CornerstonePMAP.ParametricMap;
+  var generateToolStateCornerstone = ParametricMap$1.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);
+  }
+
+  var ParametricMap = /*#__PURE__*/Object.freeze({
+    __proto__: null,
     generateToolState: generateToolState
   });
 
@@ -5525,6 +5749,9 @@
   var Cornerstone3DSEG = {
     Segmentation: Segmentation$1
   };
+  var Cornerstone3DPMAP = {
+    ParametricMap: ParametricMap
+  };
   var Cornerstone3DRT = {
     RTSS: RTSS
   };
@@ -5724,11 +5951,17 @@
     Cornerstone3D: Cornerstone3DSEG,
     VTKjs: VTKjsSEG
   };
+  var adaptersPMAP = {
+    Cornerstone: CornerstonePMAP,
+    Cornerstone3D: Cornerstone3DPMAP
+    // VTKjs: VTKjsPMAP
+  };
   var adaptersRT = {
     Cornerstone3D: Cornerstone3DRT
   };
 
   exports.Enums = index;
+  exports.adaptersPMAP = adaptersPMAP;
   exports.adaptersRT = adaptersRT;
   exports.adaptersSEG = adaptersSEG;
   exports.adaptersSR = adaptersSR;