dcmjs 0.19.4 → 0.19.7

package/README.md

@@ -36,7 +36,7 @@ _Parts of DICOM that dcmjs will focus on:_
 
 _Parts of DICOM that dcmjs *will not* focus on:_
 
-- DIMSE (legacy networking like C-FIND, C-MOVE, etc).  See the [dicom-dimse project](https://github.com/PantelisGeorgiadis/dcmjs-dimse) for that.
+- DIMSE (legacy networking like C-STORE, C-FIND, C-MOVE, etc).  See the [dcmjs-dimse project](https://github.com/PantelisGeorgiadis/dcmjs-dimse) for that.
 - Physical Media (optical disks).  See [this FAQ](https://www.dclunie.com/medical-image-faq/html/index.html) if you need to work with those.
 
 # Usage

package/build/dcmjs.es.js

@@ -2642,6 +2642,13 @@ function () {
     value: function isPixelDataTag() {
       return this.is(0x7fe00010);
     }
+  }, {
+    key: "isPrivateCreator",
+    value: function isPrivateCreator() {
+      var group = this.group();
+      var element = this.element();
+      return group % 2 === 1 && element < 0x100 && element > 0x00;
+    }
   }, {
     key: "write",
     value: function write(stream, vrType, values, syntax, writeOptions) {
@@ -2746,7 +2753,8 @@ var addAccessors = function addAccessors(dest, src) {
       },
       set: function set(v) {
         src[key] = v;
-      }
+      },
+      configurable: true
     });
   });
 };
@@ -2910,6 +2918,7 @@ function () {
             var sqZero = naturalDataset[naturalName][0];
 
             if (sqZero && _typeof(sqZero) === "object" && !sqZero.length) {
+              naturalDataset[naturalName] = _toConsumableArray(naturalDataset[naturalName]);
               addAccessors(naturalDataset[naturalName], sqZero);
             } else {
               naturalDataset[naturalName] = sqZero;
@@ -3271,6 +3280,8 @@ function () {
             vrType = "OW";
           } else if (vrType == "xs") {
             vrType = "US";
+          } else if (tag.isPrivateCreator()) {
+            vrType = "LO";
           } else {
             vrType = "UN";
           }
@@ -12417,33 +12428,45 @@ function generateToolState$1(imageIds, arrayBuffer, metadataProvider) {
 }
 /**
  * Find the reference frame of the segmentation frame in the source data.
- *  @returns {string} Returns the imageId
+ *
+ * @param  {Object}      multiframe        dicom metadata
+ * @param  {Int}         frameSegment      frame dicom index
+ * @param  {String[]}    imageIds          A list of imageIds.
+ * @param  {Object}      metadataProvider  A Cornerstone metadataProvider to query
+ *                                         metadata from imageIds.
+ * @param  {Float}       tolerance         The tolerance parameter
+ *
+ * @returns {String}     Returns the imageId
  */
 
 
-function findReferenceSourceImageId(SourceImageSequence, imageIds, metadataProvider, PerFrameFunctionalGroups, frameOfReferenceUID, tolerance) {
-  var imageId = getImageIdOfSourceImage$1(SourceImageSequence, imageIds, metadataProvider);
+function findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadataProvider, tolerance) {
+  var FrameOfReferenceUID = multiframe.FrameOfReferenceUID,
+      PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
+      SourceImageSequence = multiframe.SourceImageSequence,
+      ReferencedSeriesSequence = multiframe.ReferencedSeriesSequence;
+  var PerFrameFunctionalGroup = PerFrameFunctionalGroupsSequence[frameSegment];
+  var imageId = undefined;
 
-  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 (ReferencedSeriesSequence) {
+    var referencedSeriesSequence = Array.isArray(ReferencedSeriesSequence) ? ReferencedSeriesSequence[0] : ReferencedSeriesSequence;
+    var ReferencedSeriesInstanceUID = referencedSeriesSequence.SeriesInstanceUID;
+    imageId = getImageIdOfSourceImagebyGeometry(ReferencedSeriesInstanceUID, FrameOfReferenceUID, PerFrameFunctionalGroup, imageIds, tolerance);
+  }
 
-        if (sourceImageMetadata === undefined || sourceImageMetadata.ImagePositionPatient === undefined || sourceImageMetadata.FrameOfReferenceUID !== frameOfReferenceUID) {
-          continue;
-        }
+  if (imageId === undefined) {
+    var sourceImageSequence;
 
-        if (compareArrays(PerFrameFunctionalGroups.PlanePositionSequence[0].ImagePositionPatient, sourceImageMetadata.ImagePositionPatient, tolerance)) {
-          return imageIds[_i5];
-        }
-      }
+    if (SourceImageSequence) {
+      sourceImageSequence = multiframe.SourceImageSequence[frameSegment];
+    } else if (PerFrameFunctionalGroup.DerivationImageSequence) {
+      var DerivationImageSequence = PerFrameFunctionalGroup.DerivationImageSequence;
+      DerivationImageSequence = Array.isArray(DerivationImageSequence) ? DerivationImageSequence[0] : DerivationImageSequence;
+      sourceImageSequence = DerivationImageSequence.SourceImageSequence;
+      sourceImageSequence = Array.isArray(sourceImageSequence) ? sourceImageSequence[0] : sourceImageSequence;
     }
+
+    imageId = getImageIdOfSourceImagebySourceImageSequence(sourceImageSequence, imageIds, metadataProvider);
   }
 
   return imageId;
@@ -12486,20 +12509,7 @@ function checkSEGsOverlapping(pixelData, multiframe, imageIds, validOrientations
       return "continue";
     }
 
-    var SourceImageSequence = void 0;
-
-    if (multiframe.SourceImageSequence) {
-      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 "continue";
-    }
-
-    var imageId = findReferenceSourceImageId(SourceImageSequence, imageIds, metadataProvider, PerFrameFunctionalGroups, multiframe.FrameOfReferenceUID, tolerance);
+    var imageId = findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadataProvider, tolerance);
 
     if (!imageId) {
       console.warn("Image not present in stack, can't import frame : " + i + ".");
@@ -12540,8 +12550,8 @@ function checkSEGsOverlapping(pixelData, multiframe, imageIds, validOrientations
 
       var temp2DArray = new Uint16Array(sliceLength).fill(0);
 
-      for (var _i6 = 0; _i6 < role.length; ++_i6) {
-        var _frameSegment = role[_i6];
+      for (var _i5 = 0; _i5 < role.length; ++_i5) {
+        var _frameSegment = role[_i5];
         var PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[_frameSegment];
         var ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
         var pixelDataI2D = ndarray(new Uint8Array(pixelData.buffer, _frameSegment * sliceLength, sliceLength), [Rows, Columns]);
@@ -12610,44 +12620,32 @@ function insertOverlappingPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray,
   var numberOfSegs = multiframe.SegmentSequence.length;
 
   for (var segmentIndexToProcess = 1; segmentIndexToProcess <= numberOfSegs; ++segmentIndexToProcess) {
-    var _loop4 = function _loop4(groupsLen, _i8) {
-      var PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[_i8];
-      var segmentIndex = getSegmentIndex(multiframe, _i8);
+    var _loop4 = function _loop4(groupsLen, _i7) {
+      var PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[_i7];
+      var segmentIndex = getSegmentIndex(multiframe, _i7);
 
       if (segmentIndex === undefined) {
         throw new Error("Could not retrieve the segment index. Aborting segmentation loading.");
       }
 
       if (segmentIndex !== segmentIndexToProcess) {
-        _i7 = _i8;
+        _i6 = _i7;
         return "continue";
       }
 
       var ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
-      var pixelDataI2D = ndarray(new Uint8Array(pixelData.buffer, _i8 * sliceLength, sliceLength), [Rows, Columns]);
+      var pixelDataI2D = ndarray(new Uint8Array(pixelData.buffer, _i7 * 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 SourceImageSequence = undefined;
-
-      if (multiframe.SourceImageSequence) {
-        SourceImageSequence = multiframe.SourceImageSequence[_i8];
-      } else {
-        SourceImageSequence = PerFrameFunctionalGroups.DerivationImageSequence.SourceImageSequence;
-      }
-
-      if (!SourceImageSequence) {
-        throw new Error("Source Image Sequence information missing: individual SEG frames are out of plane. " + "This is not yet supported. Aborting segmentation loading.");
-      }
-
-      var imageId = findReferenceSourceImageId(SourceImageSequence, imageIds, metadataProvider, PerFrameFunctionalGroups, multiframe.FrameOfReferenceUID, tolerance);
+      var imageId = findReferenceSourceImageId(multiframe, _i7, imageIds, metadataProvider, tolerance);
 
       if (!imageId) {
-        console.warn("Image not present in stack, can't import frame : " + _i8 + ".");
-        _i7 = _i8;
+        console.warn("Image not present in stack, can't import frame : " + _i7 + ".");
+        _i6 = _i7;
         return "continue";
       }
 
@@ -12679,7 +12677,7 @@ function insertOverlappingPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray,
 
             tempBuffer = labelmapBufferArray[m].slice(0);
             tempSegmentsOnFrame = lodash_clonedeep(segmentsOnFrameArray[m]);
-            _i8 = 0;
+            _i7 = 0;
             break;
           } else {
             labelmap2DView[j] = segmentIndex;
@@ -12702,11 +12700,11 @@ function insertOverlappingPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray,
         segmentsOnFrame[imageIdIndex].push(segmentIndex);
       }
 
-      _i7 = _i8;
+      _i6 = _i7;
     };
 
-    for (var _i7 = 0, groupsLen = PerFrameFunctionalGroupsSequence.length; _i7 < groupsLen; ++_i7) {
-      var _ret2 = _loop4(groupsLen, _i7);
+    for (var _i6 = 0, groupsLen = PerFrameFunctionalGroupsSequence.length; _i6 < groupsLen; ++_i6) {
+      var _ret2 = _loop4(groupsLen, _i6);
 
       if (_ret2 === "continue") continue;
     }
@@ -12735,38 +12733,26 @@ function insertPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray, labelmapBu
   var sharedImageOrientationPatient = SharedFunctionalGroupsSequence.PlaneOrientationSequence ? SharedFunctionalGroupsSequence.PlaneOrientationSequence.ImageOrientationPatient : undefined;
   var sliceLength = Columns * Rows;
 
-  var _loop5 = function _loop5(groupsLen, _i9) {
-    var PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[_i9];
+  var _loop5 = function _loop5(groupsLen, _i8) {
+    var PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[_i8];
     var ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
-    var pixelDataI2D = ndarray(new Uint8Array(pixelData.buffer, _i9 * 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 segmentIndex = getSegmentIndex(multiframe, _i9);
+    var segmentIndex = getSegmentIndex(multiframe, _i8);
 
     if (segmentIndex === undefined) {
       throw new Error("Could not retrieve the segment index. Aborting segmentation loading.");
     }
 
-    var SourceImageSequence = undefined;
-
-    if (multiframe.SourceImageSequence) {
-      SourceImageSequence = multiframe.SourceImageSequence[_i9];
-    } else {
-      SourceImageSequence = PerFrameFunctionalGroups.DerivationImageSequence.SourceImageSequence;
-    }
-
-    if (!SourceImageSequence) {
-      throw new Error("Source Image Sequence information missing: individual SEG frames are out of plane. " + "This is not yet supported. Aborting segmentation loading.");
-    }
-
-    var imageId = findReferenceSourceImageId(SourceImageSequence, imageIds, metadataProvider, PerFrameFunctionalGroups, multiframe.FrameOfReferenceUID, tolerance);
+    var imageId = findReferenceSourceImageId(multiframe, _i8, imageIds, metadataProvider, tolerance);
 
     if (!imageId) {
-      console.warn("Image not present in stack, can't import frame : " + _i9 + ".");
+      console.warn("Image not present in stack, can't import frame : " + _i8 + ".");
       return "continue";
     }
 
@@ -12802,8 +12788,8 @@ function insertPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray, labelmapBu
     }
   };
 
-  for (var _i9 = 0, groupsLen = PerFrameFunctionalGroupsSequence.length; _i9 < groupsLen; ++_i9) {
-    var _ret3 = _loop5(groupsLen, _i9);
+  for (var _i8 = 0, groupsLen = PerFrameFunctionalGroupsSequence.length; _i8 < groupsLen; ++_i8) {
+    var _ret3 = _loop5(groupsLen, _i8);
 
     if (_ret3 === "continue") continue;
   }
@@ -12888,21 +12874,51 @@ function unpackPixelData$1(multiframe) {
   return pixelData;
 }
 /**
- * getImageIdOfSourceImage - Returns the Cornerstone imageId of the source image.
+ * getImageIdOfSourceImagebySourceImageSequence - Returns the Cornerstone imageId of the source image.
  *
- * @param  {Object} SourceImageSequence Sequence describing the source image.
- * @param  {String[]} imageIds          A list of imageIds.
- * @param  {Object} metadataProvider    A Cornerstone metadataProvider to query
- *                                      metadata from imageIds.
- * @return {String}                     The corresponding imageId.
+ * @param  {Object}   SourceImageSequence  Sequence describing the source image.
+ * @param  {String[]} imageIds             A list of imageIds.
+ * @param  {Object}   metadataProvider     A Cornerstone metadataProvider to query
+ *                                         metadata from imageIds.
+ * @return {String}                        The corresponding imageId.
  */
 
 
-function getImageIdOfSourceImage$1(SourceImageSequence, imageIds, metadataProvider) {
+function getImageIdOfSourceImagebySourceImageSequence(SourceImageSequence, imageIds, metadataProvider) {
   var ReferencedSOPInstanceUID = SourceImageSequence.ReferencedSOPInstanceUID,
       ReferencedFrameNumber = SourceImageSequence.ReferencedFrameNumber;
   return ReferencedFrameNumber ? getImageIdOfReferencedFrame$1(ReferencedSOPInstanceUID, ReferencedFrameNumber, imageIds, metadataProvider) : getImageIdOfReferencedSingleFramedSOPInstance$1(ReferencedSOPInstanceUID, imageIds, metadataProvider);
 }
+/**
+ * getImageIdOfSourceImagebyGeometry - Returns the Cornerstone imageId of the source image.
+ *
+ * @param  {String}    ReferencedSeriesInstanceUID    Referenced series of the source image.
+ * @param  {String}    FrameOfReferenceUID            Frame of reference.
+ * @param  {Object}    PerFrameFunctionalGroup        Sequence describing segmentation reference attributes per frame.
+ * @param  {String[]}  imageIds                       A list of imageIds.
+ * @param  {Float}     tolerance                      The tolerance parameter
+ *
+ * @return {String}                                   The corresponding imageId.
+ */
+
+
+function getImageIdOfSourceImagebyGeometry(ReferencedSeriesInstanceUID, FrameOfReferenceUID, PerFrameFunctionalGroup, imageIds, tolerance) {
+  if (ReferencedSeriesInstanceUID === undefined || PerFrameFunctionalGroup.PlanePositionSequence === undefined || PerFrameFunctionalGroup.PlanePositionSequence[0] === undefined || PerFrameFunctionalGroup.PlanePositionSequence[0].ImagePositionPatient === undefined) {
+    return undefined;
+  }
+
+  for (var imageIdsIndexc = 0; imageIdsIndexc < imageIds.length; ++imageIdsIndexc) {
+    var sourceImageMetadata = cornerstone.metaData.get("instance", imageIds[imageIdsIndexc]);
+
+    if (sourceImageMetadata === undefined || sourceImageMetadata.ImagePositionPatient === undefined || sourceImageMetadata.FrameOfReferenceUID !== FrameOfReferenceUID || sourceImageMetadata.SeriesInstanceUID !== ReferencedSeriesInstanceUID) {
+      continue;
+    }
+
+    if (compareArrays(PerFrameFunctionalGroup.PlanePositionSequence[0].ImagePositionPatient, sourceImageMetadata.ImagePositionPatient, tolerance)) {
+      return imageIds[imageIdsIndexc];
+    }
+  }
+}
 /**
  * getImageIdOfReferencedSingleFramedSOPInstance - Returns the imageId
  * corresponding to the specified sopInstanceUid for single-frame images.
@@ -13037,8 +13053,8 @@ function compareArrays(array1, array2, tolerance) {
     return false;
   }
 
-  for (var _i10 = 0; _i10 < array1.length; ++_i10) {
-    if (!nearlyEqual(array1[_i10], array2[_i10], tolerance)) {
+  for (var _i9 = 0; _i9 < array1.length; ++_i9) {
+    if (!nearlyEqual(array1[_i9], array2[_i9], tolerance)) {
       return false;
     }
   }