dcmjs 0.19.2 → 0.19.3

package/build/dcmjs.es.js

@@ -12180,28 +12180,28 @@ function fillSegmentation(segmentation, inputLabelmaps3D) {
         metadata = labelmap3D.metadata;
     var referencedFramesPerSegment = [];
 
-    for (var i = 1; i < metadata.length; i++) {
-      if (metadata[i]) {
-        referencedFramesPerSegment[i] = [];
+    for (var _i = 1; _i < metadata.length; _i++) {
+      if (metadata[_i]) {
+        referencedFramesPerSegment[_i] = [];
       }
     }
 
-    var _loop2 = function _loop2(_i) {
-      var labelmap2D = labelmaps2D[_i];
+    var _loop2 = function _loop2(_i2) {
+      var labelmap2D = labelmaps2D[_i2];
 
-      if (labelmaps2D[_i]) {
+      if (labelmaps2D[_i2]) {
         var segmentsOnLabelmap = labelmap2D.segmentsOnLabelmap;
         segmentsOnLabelmap.forEach(function (segmentIndex) {
           if (segmentIndex !== 0) {
-            referencedFramesPerSegment[segmentIndex].push(_i);
+            referencedFramesPerSegment[segmentIndex].push(_i2);
             numberOfFrames++;
           }
         });
       }
     };
 
-    for (var _i = 0; _i < labelmaps2D.length; _i++) {
-      _loop2(_i);
+    for (var _i2 = 0; _i2 < labelmaps2D.length; _i2++) {
+      _loop2(_i2);
     }
 
     referencedFramesPerLabelmap[labelmapIndex] = referencedFramesPerSegment;
@@ -12267,8 +12267,8 @@ function _getLabelmapsFromRefernecedFrameIndicies(labelmap3D, referencedFrameInd
   var labelmaps2D = labelmap3D.labelmaps2D;
   var labelmaps = [];
 
-  for (var i = 0; i < referencedFrameIndicies.length; i++) {
-    var frame = referencedFrameIndicies[i];
+  for (var _i3 = 0; _i3 < referencedFrameIndicies.length; _i3++) {
+    var frame = referencedFrameIndicies[_i3];
     labelmaps.push(labelmaps2D[frame].pixelData);
   }
 
@@ -12294,8 +12294,8 @@ function _createSegFromImages$1(images, isMultiframe, options) {
     dataset._meta = DicomMetaDictionary.namifyDataset(dicomData.meta);
     datasets.push(dataset);
   } else {
-    for (var i = 0; i < images.length; i++) {
-      var _image = images[i];
+    for (var _i4 = 0; _i4 < images.length; _i4++) {
+      var _image = images[_i4];
       var _arrayBuffer = _image.data.byteArray.buffer;
 
       var _dicomData = DicomMessage.readFile(_arrayBuffer);
@@ -12415,17 +12415,40 @@ function generateToolState$1(imageIds, arrayBuffer, metadataProvider) {
   };
 }
 /**
- * Checks if there is any overlapping segmentations. The check is performed frame by frame.
- *  Two assumptions are used in the loop:
- *  1) numberOfSegs * numberOfFrames = groupsLen,
- *     i.e. for each frame we have a N PerFrameFunctionalGroupsSequence, where N is the number of segmentations (numberOfSegs).
- *  2) the order of the group sequence is = numberOfFrames of segmentation 1 +  numberOfFrames of segmentation 2 + ... + numberOfFrames of segmentation numberOfSegs
- *
- *  -------------------
- *
- *  TO DO: We could check the ImagePositionPatient and working in 3D coordinates (instead of indexes) and remove the assumptions,
- *  but this would greatly increase the computation time (i.e. we would have to sort the data before running checkSEGsOverlapping).
- *
+ * Find the reference frame of the segmentation frame in the source data.
+ *  @returns {string} Returns the imageId
+ */
+
+
+function findReferenceSourceImageId(SourceImageSequence, imageIds, metadataProvider, PerFrameFunctionalGroups, frameOfReferenceUID, tolerance) {
+  var imageId = getImageIdOfSourceImage$1(SourceImageSequence, imageIds, metadataProvider);
+
+  if (!imageId) {
+    /** not found, we can do a check with the PlanePositionSequence.
+     * (WARNING!) However, if more than a source series is present,
+     * this logic can find the wrong frame
+     * (i.e. two source series, with the same frameOfReferenceUID,
+     * that have each a frame with the same ImagePositionPatient of PlanePositionSequence).
+     */
+    if (PerFrameFunctionalGroups.PlanePositionSequence !== undefined && PerFrameFunctionalGroups.PlanePositionSequence[0] !== undefined && PerFrameFunctionalGroups.PlanePositionSequence[0].ImagePositionPatient !== undefined) {
+      for (var _i5 = 0; _i5 < imageIds.length; ++_i5) {
+        var sourceImageMetadata = cornerstone.metaData.get("instance", imageIds[_i5]);
+
+        if (sourceImageMetadata === undefined || sourceImageMetadata.ImagePositionPatient === undefined || sourceImageMetadata.FrameOfReferenceUID !== frameOfReferenceUID) {
+          continue;
+        }
+
+        if (compareArrays(PerFrameFunctionalGroups.PlanePositionSequence[0].ImagePositionPatient, sourceImageMetadata.ImagePositionPatient, tolerance)) {
+          return imageIds[_i5];
+        }
+      }
+    }
+  }
+
+  return imageId;
+}
+/**
+ * Checks if there is any overlapping segmentations.
  *  @returns {boolean} Returns a flag if segmentations overlapping
  */
 
@@ -12433,135 +12456,126 @@ function generateToolState$1(imageIds, arrayBuffer, metadataProvider) {
 function checkSEGsOverlapping(pixelData, multiframe, imageIds, validOrientations, metadataProvider, tolerance) {
   var SharedFunctionalGroupsSequence = multiframe.SharedFunctionalGroupsSequence,
       PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
+      SegmentSequence = multiframe.SegmentSequence,
       Rows = multiframe.Rows,
       Columns = multiframe.Columns;
-  var sharedImageOrientationPatient = SharedFunctionalGroupsSequence.PlaneOrientationSequence ? SharedFunctionalGroupsSequence.PlaneOrientationSequence.ImageOrientationPatient : undefined;
-  var sliceLength = Columns * Rows;
-  var firstSegIndex = -1;
-  var previousimageIdIndex = -1;
-  var temp2DArray = new Uint16Array(sliceLength).fill(0);
-  var groupsLen = PerFrameFunctionalGroupsSequence.length;
-  var numberOfSegs = multiframe.SegmentSequence.length;
-  var numberOfFrames = imageIds.length;
-
-  if (numberOfSegs * numberOfFrames !== groupsLen) {
-    console.warn("Failed to check for overlap of segments: " + "missing frames in PerFrameFunctionalGroupsSequence " + "or the segmentation has different geometry respect to the source image.");
-    return false;
-  }
-
-  var refSegFrame0 = getSegmentIndex(multiframe, 0);
-  var refSegFrame1 = getSegmentIndex(multiframe, 1);
+  var numberOfSegs = SegmentSequence.length;
 
-  if (refSegFrame0 === undefined || refSegFrame1 === undefined || refSegFrame0 !== refSegFrame1) {
-    console.warn("Failed to check for overlap of segments: frames in PerFrameFunctionalGroupsSequence are not sorted.");
+  if (numberOfSegs < 2) {
     return false;
   }
 
-  var i = 0;
-
-  var _loop4 = function _loop4() {
-    var PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[i];
-    var ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
-    var pixelDataI2D = ndarray(new Uint8Array(pixelData.buffer, i * sliceLength, sliceLength), [Rows, Columns]);
-    var alignedPixelDataI = alignPixelDataWithSourceData$1(pixelDataI2D, ImageOrientationPatientI, validOrientations, tolerance);
+  var sharedImageOrientationPatient = SharedFunctionalGroupsSequence.PlaneOrientationSequence ? SharedFunctionalGroupsSequence.PlaneOrientationSequence.ImageOrientationPatient : undefined;
+  var sliceLength = Columns * Rows;
+  var groupsLen = PerFrameFunctionalGroupsSequence.length;
+  /** sort groupsLen to have all the segments for each frame in an array
+   * frame 2 : 1, 2
+   * frame 4 : 1, 3
+   * frame 5 : 4
+   */
 
-    if (!alignedPixelDataI) {
-      console.warn("Individual SEG frames are out of plane with respect to the first SEG frame, this is not yet supported, skipping this frame.");
-      return {
-        v: false
-      };
-    }
+  var frameSegmentsMapping = new Map();
 
-    var segmentIndex = getSegmentIndex(multiframe, i);
+  var _loop3 = function _loop3(frameSegment) {
+    var PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[frameSegment];
+    var segmentIndex = getSegmentIndex(multiframe, frameSegment);
 
     if (segmentIndex === undefined) {
-      console.warn("Could not retrieve the segment index, skipping this frame.");
-      return {
-        v: false
-      };
+      console.warn("Could not retrieve the segment index for frame segment " + frameSegment + ", skipping this frame.");
+      return "continue";
     }
 
     var SourceImageSequence = void 0;
 
     if (multiframe.SourceImageSequence) {
-      SourceImageSequence = multiframe.SourceImageSequence[i];
+      SourceImageSequence = multiframe.SourceImageSequence[frameSegment];
     } else {
       SourceImageSequence = PerFrameFunctionalGroups.DerivationImageSequence.SourceImageSequence;
     }
 
     if (!SourceImageSequence) {
       console.warn("Source Image Sequence information missing: individual SEG frames are out of plane, this is not yet supported, skipping this frame.");
-      return {
-        v: false
-      };
+      return "continue";
     }
 
-    var imageId = getImageIdOfSourceImage$1(SourceImageSequence, imageIds, metadataProvider);
+    var imageId = findReferenceSourceImageId(SourceImageSequence, imageIds, metadataProvider, PerFrameFunctionalGroups, multiframe.FrameOfReferenceUID, tolerance);
 
     if (!imageId) {
-      // Image not present in stack, can't import this frame.
-      i = i + numberOfFrames;
-
-      if (i >= groupsLen) {
-        i = i - numberOfFrames * numberOfSegs + 1;
-
-        if (i >= numberOfFrames) {
-          return "break";
-        }
-      }
-
+      console.warn("Image not present in stack, can't import frame : " + i + ".");
       return "continue";
     }
 
-    var data = alignedPixelDataI.data;
     var imageIdIndex = imageIds.findIndex(function (element) {
       return element === imageId;
     });
 
-    if (i === 0) {
-      firstSegIndex = segmentIndex;
-    }
-
-    if (segmentIndex === firstSegIndex && imageIdIndex > previousimageIdIndex) {
-      temp2DArray.fill(0);
-      previousimageIdIndex = imageIdIndex;
-    }
-
-    for (var j = 0, len = alignedPixelDataI.data.length; j < len; ++j) {
-      if (data[j]) {
-        temp2DArray[j]++;
+    if (frameSegmentsMapping.has(imageIdIndex)) {
+      var segmentArray = frameSegmentsMapping.get(imageIdIndex);
 
-        if (temp2DArray[j] > 1) {
-          return {
-            v: true
-          };
-        }
+      if (!segmentArray.includes(frameSegment)) {
+        segmentArray.push(frameSegment);
+        frameSegmentsMapping.set(imageIdIndex, segmentArray);
       }
+    } else {
+      frameSegmentsMapping.set(imageIdIndex, [frameSegment]);
     }
+  };
 
-    i = i + numberOfFrames;
+  for (var frameSegment = 0; frameSegment < groupsLen; ++frameSegment) {
+    var _ret = _loop3(frameSegment);
 
-    if (i >= groupsLen) {
-      i = i - numberOfFrames * numberOfSegs + 1;
+    if (_ret === "continue") continue;
+  }
 
-      if (i >= numberOfFrames) {
-        return "break";
-      }
-    }
-  };
+  var _iteratorNormalCompletion = true;
+  var _didIteratorError = false;
+  var _iteratorError = undefined;
 
-  _loop3: while (i < groupsLen) {
-    var _ret = _loop4();
+  try {
+    for (var _iterator = frameSegmentsMapping.entries()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var _step$value = _slicedToArray(_step.value, 2),
+          user = _step$value[0],
+          role = _step$value[1];
+
+      var temp2DArray = new Uint16Array(sliceLength).fill(0);
+
+      for (var _i6 = 0; _i6 < role.length; ++_i6) {
+        var _frameSegment = role[_i6];
+        var PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[_frameSegment];
+        var ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
+        var pixelDataI2D = ndarray(new Uint8Array(pixelData.buffer, _frameSegment * sliceLength, sliceLength), [Rows, Columns]);
+        var alignedPixelDataI = alignPixelDataWithSourceData$1(pixelDataI2D, ImageOrientationPatientI, validOrientations, tolerance);
+
+        if (!alignedPixelDataI) {
+          console.warn("Individual SEG frames are out of plane with respect to the first SEG frame, this is not yet supported, skipping this frame.");
+          continue;
+        }
 
-    switch (_ret) {
-      case "break":
-        break _loop3;
+        var data = alignedPixelDataI.data;
 
-      case "continue":
-        continue;
+        for (var j = 0, len = data.length; j < len; ++j) {
+          if (data[j] !== 0) {
+            temp2DArray[j]++;
 
-      default:
-        if (_typeof(_ret) === "object") return _ret.v;
+            if (temp2DArray[j] > 1) {
+              return true;
+            }
+          }
+        }
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
     }
   }
 
@@ -12585,42 +12599,41 @@ function insertOverlappingPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray,
   var tempBuffer = labelmapBufferArray[m].slice(0); // temp list for checking overlaps
 
   var tempSegmentsOnFrame = lodash_clonedeep(segmentsOnFrameArray[m]);
-  /* split overlapping SEGs algorithm for each segment: 
-  A) copy the labelmapBuffer in the array with index 0
-  B) add the segment pixel per pixel on the copied buffer from (A)
-  C) if no overlap, copy the results back on the orignal array from (A)
-  D) if overlap, repeat increasing the index m up to M (if out of memory, add new buffer in the array and M++); 
-  */
+  /** split overlapping SEGs algorithm for each segment:
+   *  A) copy the labelmapBuffer in the array with index 0
+   *  B) add the segment pixel per pixel on the copied buffer from (A)
+   *  C) if no overlap, copy the results back on the orignal array from (A)
+   *  D) if overlap, repeat increasing the index m up to M (if out of memory, add new buffer in the array and M++);
+   */
 
   var numberOfSegs = multiframe.SegmentSequence.length;
 
   for (var segmentIndexToProcess = 1; segmentIndexToProcess <= numberOfSegs; ++segmentIndexToProcess) {
-    var _loop5 = function _loop5(_i2, groupsLen) {
-      var PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[_i2];
-      var segmentIndex = getSegmentIndex(multiframe, _i2);
+    var _loop4 = function _loop4(groupsLen, _i8) {
+      var PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[_i8];
+      var segmentIndex = getSegmentIndex(multiframe, _i8);
 
       if (segmentIndex === undefined) {
         throw new Error("Could not retrieve the segment index. Aborting segmentation loading.");
       }
 
       if (segmentIndex !== segmentIndexToProcess) {
-        i = _i2;
+        _i7 = _i8;
         return "continue";
       }
 
       var ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
-      var pixelDataI2D = ndarray(new Uint8Array(pixelData.buffer, _i2 * sliceLength, sliceLength), [Rows, Columns]);
+      var pixelDataI2D = ndarray(new Uint8Array(pixelData.buffer, _i8 * sliceLength, sliceLength), [Rows, Columns]);
       var alignedPixelDataI = alignPixelDataWithSourceData$1(pixelDataI2D, ImageOrientationPatientI, validOrientations, tolerance);
 
       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 = undefined;
       var SourceImageSequence = undefined;
 
       if (multiframe.SourceImageSequence) {
-        SourceImageSequence = multiframe.SourceImageSequence[_i2];
+        SourceImageSequence = multiframe.SourceImageSequence[_i8];
       } else {
         SourceImageSequence = PerFrameFunctionalGroups.DerivationImageSequence.SourceImageSequence;
       }
@@ -12629,11 +12642,11 @@ function insertOverlappingPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray,
         throw new Error("Source Image Sequence information missing: individual SEG frames are out of plane. " + "This is not yet supported. Aborting segmentation loading.");
       }
 
-      imageId = getImageIdOfSourceImage$1(SourceImageSequence, imageIds, metadataProvider);
+      var imageId = findReferenceSourceImageId(SourceImageSequence, imageIds, metadataProvider, PerFrameFunctionalGroups, multiframe.FrameOfReferenceUID, tolerance);
 
       if (!imageId) {
-        i = _i2;
-        // Image not present in stack, can't import this frame.
+        console.warn("Image not present in stack, can't import frame : " + _i8 + ".");
+        _i7 = _i8;
         return "continue";
       }
 
@@ -12665,7 +12678,7 @@ function insertOverlappingPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray,
 
             tempBuffer = labelmapBufferArray[m].slice(0);
             tempSegmentsOnFrame = lodash_clonedeep(segmentsOnFrameArray[m]);
-            _i2 = 0;
+            _i8 = 0;
             break;
           } else {
             labelmap2DView[j] = segmentIndex;
@@ -12688,11 +12701,11 @@ function insertOverlappingPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray,
         segmentsOnFrame[imageIdIndex].push(segmentIndex);
       }
 
-      i = _i2;
+      _i7 = _i8;
     };
 
-    for (var i = 0, groupsLen = PerFrameFunctionalGroupsSequence.length; i < groupsLen; ++i) {
-      var _ret2 = _loop5(i, groupsLen);
+    for (var _i7 = 0, groupsLen = PerFrameFunctionalGroupsSequence.length; _i7 < groupsLen; ++_i7) {
+      var _ret2 = _loop4(groupsLen, _i7);
 
       if (_ret2 === "continue") continue;
     }
@@ -12721,27 +12734,26 @@ function insertPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray, labelmapBu
   var sharedImageOrientationPatient = SharedFunctionalGroupsSequence.PlaneOrientationSequence ? SharedFunctionalGroupsSequence.PlaneOrientationSequence.ImageOrientationPatient : undefined;
   var sliceLength = Columns * Rows;
 
-  var _loop6 = function _loop6(groupsLen, _i3) {
-    var PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[_i3];
+  var _loop5 = function _loop5(groupsLen, _i9) {
+    var PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[_i9];
     var ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
-    var pixelDataI2D = ndarray(new Uint8Array(pixelData.buffer, _i3 * sliceLength, sliceLength), [Rows, Columns]);
+    var pixelDataI2D = ndarray(new Uint8Array(pixelData.buffer, _i9 * sliceLength, sliceLength), [Rows, Columns]);
     var alignedPixelDataI = alignPixelDataWithSourceData$1(pixelDataI2D, ImageOrientationPatientI, validOrientations, tolerance);
 
     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 segmentIndex = getSegmentIndex(multiframe, _i3);
+    var segmentIndex = getSegmentIndex(multiframe, _i9);
 
     if (segmentIndex === undefined) {
       throw new Error("Could not retrieve the segment index. Aborting segmentation loading.");
     }
 
-    var imageId = undefined;
     var SourceImageSequence = undefined;
 
     if (multiframe.SourceImageSequence) {
-      SourceImageSequence = multiframe.SourceImageSequence[_i3];
+      SourceImageSequence = multiframe.SourceImageSequence[_i9];
     } else {
       SourceImageSequence = PerFrameFunctionalGroups.DerivationImageSequence.SourceImageSequence;
     }
@@ -12750,10 +12762,10 @@ function insertPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray, labelmapBu
       throw new Error("Source Image Sequence information missing: individual SEG frames are out of plane. " + "This is not yet supported. Aborting segmentation loading.");
     }
 
-    imageId = getImageIdOfSourceImage$1(SourceImageSequence, imageIds, metadataProvider);
+    var imageId = findReferenceSourceImageId(SourceImageSequence, imageIds, metadataProvider, PerFrameFunctionalGroups, multiframe.FrameOfReferenceUID, tolerance);
 
     if (!imageId) {
-      // Image not present in stack, can't import this frame.
+      console.warn("Image not present in stack, can't import frame : " + _i9 + ".");
       return "continue";
     }
 
@@ -12769,7 +12781,7 @@ function insertPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray, labelmapBu
     var byteOffset = sliceLength * 2 * imageIdIndex; // 2 bytes/pixel
 
     var labelmap2DView = new Uint16Array(labelmapBufferArray[0], byteOffset, sliceLength);
-    var data = alignedPixelDataI.data; //
+    var data = alignedPixelDataI.data;
 
     for (var j = 0, len = alignedPixelDataI.data.length; j < len; ++j) {
       if (data[j]) {
@@ -12789,8 +12801,8 @@ function insertPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray, labelmapBu
     }
   };
 
-  for (var _i3 = 0, groupsLen = PerFrameFunctionalGroupsSequence.length; _i3 < groupsLen; ++_i3) {
-    var _ret3 = _loop6(groupsLen, _i3);
+  for (var _i9 = 0, groupsLen = PerFrameFunctionalGroupsSequence.length; _i9 < groupsLen; ++_i9) {
+    var _ret3 = _loop5(groupsLen, _i9);
 
     if (_ret3 === "continue") continue;
   }
@@ -12804,7 +12816,7 @@ function checkOrientation(multiframe, validOrientations, sourceDataDimensions, t
   var PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[0];
   var iop = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
   var inPlane = validOrientations.some(function (operation) {
-    return compareIOP$1(iop, operation, tolerance);
+    return compareArrays(iop, operation, tolerance);
   });
 
   if (inPlane) {
@@ -12977,50 +12989,60 @@ function getValidOrientations$1(iop) {
 
 
 function alignPixelDataWithSourceData$1(pixelData2D, iop, orientations, tolerance) {
-  if (compareIOP$1(iop, orientations[0], tolerance)) {
+  if (compareArrays(iop, orientations[0], tolerance)) {
     return pixelData2D;
-  } else if (compareIOP$1(iop, orientations[1], tolerance)) {
+  } else if (compareArrays(iop, orientations[1], tolerance)) {
     // Flipped vertically.
     // Undo Flip
     return flipMatrix2D.v(pixelData2D);
-  } else if (compareIOP$1(iop, orientations[2], tolerance)) {
+  } else if (compareArrays(iop, orientations[2], tolerance)) {
     // Flipped horizontally.
     // Unfo flip
     return flipMatrix2D.h(pixelData2D);
-  } else if (compareIOP$1(iop, orientations[3], tolerance)) {
+  } else if (compareArrays(iop, orientations[3], tolerance)) {
     //Rotated 90 degrees
     // Rotate back
     return rotateMatrix902D(pixelData2D);
-  } else if (compareIOP$1(iop, orientations[4], tolerance)) {
+  } else if (compareArrays(iop, orientations[4], tolerance)) {
     //Rotated 90 degrees and fliped horizontally.
     // Undo flip and rotate back.
     return rotateMatrix902D(flipMatrix2D.h(pixelData2D));
-  } else if (compareIOP$1(iop, orientations[5], tolerance)) {
+  } else if (compareArrays(iop, orientations[5], tolerance)) {
     // Rotated 90 degrees and fliped vertically
     // Unfo flip and rotate back.
     return rotateMatrix902D(flipMatrix2D.v(pixelData2D));
-  } else if (compareIOP$1(iop, orientations[6], tolerance)) {
+  } else if (compareArrays(iop, orientations[6], tolerance)) {
     // Rotated 180 degrees. // TODO -> Do this more effeciently, there is a 1:1 mapping like 90 degree rotation.
     return rotateMatrix902D(rotateMatrix902D(pixelData2D));
-  } else if (compareIOP$1(iop, orientations[7], tolerance)) {
+  } else if (compareArrays(iop, orientations[7], tolerance)) {
     // Rotated 270 degrees
     // Rotate back.
     return rotateMatrix902D(rotateMatrix902D(rotateMatrix902D(pixelData2D)));
   }
 }
 /**
- * compareIOP - Returns true if iop1 and iop2 are equal
+ * compareArrays - Returns true if array1 and array2 are equal
  * within a tolerance.
  *
- * @param  {Number[6]} iop1 - An ImageOrientationPatient array.
- * @param  {Number[6]} iop2 - An ImageOrientationPatient array.
+ * @param  {Number[]} array1 - An array.
+ * @param  {Number[]} array2 - An array.
  * @param {Number} tolerance.
- * @return {Boolean} True if iop1 and iop2 are equal.
+ * @return {Boolean} True if array1 and array2 are equal.
  */
 
 
-function compareIOP$1(iop1, iop2, tolerance) {
-  return nearlyEqual(iop1[0], iop2[0], tolerance) && nearlyEqual(iop1[1], iop2[1], tolerance) && nearlyEqual(iop1[2], iop2[2], tolerance) && nearlyEqual(iop1[3], iop2[3], tolerance) && nearlyEqual(iop1[4], iop2[4], tolerance) && nearlyEqual(iop1[5], iop2[5], tolerance);
+function compareArrays(array1, array2, tolerance) {
+  if (array1.length != array2.length) {
+    return false;
+  }
+
+  for (var _i10 = 0; _i10 < array1.length; ++_i10) {
+    if (!nearlyEqual(array1[_i10], array2[_i10], tolerance)) {
+      return false;
+    }
+  }
+
+  return true;
 }
 
 function getSegmentMetadata$1(multiframe, seriesInstanceUid) {