dcmjs 0.43.1 → 0.44.1

package/build/dcmjs.es.js

@@ -9028,7 +9028,7 @@ function toWindows(inputArray, size) {
 }
 var DicomMessage$3, Tag$1;
 var binaryVRs = ["FL", "FD", "SL", "SS", "UL", "US", "AT"],
-  explicitVRs = ["OB", "OW", "OF", "SQ", "UC", "UR", "UT", "UN", "OD"],
+  length32VRs = ["OB", "OW", "OF", "SQ", "UC", "UR", "UT", "UN", "OD"],
   singleVRs$1 = ["SQ", "OF", "OW", "OB", "UN"];
 var ValueRepresentation = /*#__PURE__*/function () {
   function ValueRepresentation(type) {
@@ -9037,7 +9037,7 @@ var ValueRepresentation = /*#__PURE__*/function () {
     this.multi = false;
     this._isBinary = binaryVRs.indexOf(this.type) != -1;
     this._allowMultiple = !this._isBinary && singleVRs$1.indexOf(this.type) == -1;
-    this._isExplicit = explicitVRs.indexOf(this.type) != -1;
+    this._isLength32 = length32VRs.indexOf(this.type) != -1;
     this._storeRaw = true;
   }
   _createClass(ValueRepresentation, [{
@@ -9050,10 +9050,30 @@ var ValueRepresentation = /*#__PURE__*/function () {
     value: function allowMultiple() {
       return this._allowMultiple;
     }
+
+    /**
+     * Returns if the length is 32 bits.  This has nothing to do with being
+     * explicit or not, it only has to do with encoding.
+     * @deprecated  Replaced by isLength32
+     */
   }, {
     key: "isExplicit",
     value: function isExplicit() {
-      return this._isExplicit;
+      return this._isLength32;
+    }
+
+    /**
+     * Returns if the length is 32 bits.  This has nothing to do with being
+     * explicit or not, it only has to do with encoding.
+     *
+     * This used to be isExplicit, which was wrong as both encodings are explicit,
+     * just one uses a single 4 byte word to encode both VR and length, and
+     * the isLength32 always use a separate 32 bit length.
+     */
+  }, {
+    key: "isLength32",
+    value: function isLength32() {
+      return this._isLength32;
     }
 
     /**
@@ -10481,7 +10501,7 @@ var ParsedUnknownValue = /*#__PURE__*/function (_BinaryRepresentation2) {
     _this28.noMultiple = true;
     _this28._isBinary = true;
     _this28._allowMultiple = false;
-    _this28._isExplicit = true;
+    _this28._isLength32 = true;
     _this28._storeRaw = true;
     return _this28;
   }
@@ -10706,11 +10726,11 @@ var Tag = /*#__PURE__*/function () {
   }, {
     key: "write",
     value: function write(stream, vrType, values, syntax, writeOptions) {
-      var vr = ValueRepresentation.createByTypeString(vrType),
-        useSyntax = DicomMessage$1._normalizeSyntax(syntax);
-      var implicit = useSyntax == IMPLICIT_LITTLE_ENDIAN ? true : false,
-        isLittleEndian = useSyntax == IMPLICIT_LITTLE_ENDIAN || useSyntax == EXPLICIT_LITTLE_ENDIAN$1 ? true : false,
-        isEncapsulated = this.isPixelDataTag() && DicomMessage$1.isEncapsulated(syntax);
+      var vr = ValueRepresentation.createByTypeString(vrType);
+      var useSyntax = DicomMessage$1._normalizeSyntax(syntax);
+      var implicit = useSyntax == IMPLICIT_LITTLE_ENDIAN ? true : false;
+      var isLittleEndian = useSyntax == IMPLICIT_LITTLE_ENDIAN || useSyntax == EXPLICIT_LITTLE_ENDIAN$1 ? true : false;
+      var isEncapsulated = this.isPixelDataTag() && DicomMessage$1.isEncapsulated(syntax);
       var oldEndian = stream.isLittleEndian;
       stream.setEndian(isLittleEndian);
       stream.writeUint16(this.group());
@@ -10733,8 +10753,13 @@ var Tag = /*#__PURE__*/function () {
         stream.writeUint32(valueLength);
         written += 4;
       } else {
-        if (vr.isExplicit()) {
-          stream.writeAsciiString(vr.type);
+        // Big 16 length objects are encodings for values larger than
+        // 16 bit lengths which would normally use a 16 bit length field.
+        // This uses a VR=UN instead of the original VR, and a 32 bit length
+        var isBig16Length = !vr.isLength32() && valueLength >= 0x10000 && valueLength !== 0xffffffff;
+        if (vr.isLength32() || isBig16Length) {
+          // Write as vr UN for big values
+          stream.writeAsciiString(isBig16Length ? "UN" : vr.type);
           stream.writeUint16(0);
           stream.writeUint32(valueLength);
           written += 8;
@@ -10888,15 +10913,23 @@ var DicomMessage = /*#__PURE__*/function () {
       var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
         ignoreErrors: false,
         untilTag: null,
-        includeUntilTagValue: false
+        includeUntilTagValue: false,
+        stopOnGreaterTag: false
       };
       var ignoreErrors = options.ignoreErrors,
-        untilTag = options.untilTag;
+        untilTag = options.untilTag,
+        stopOnGreaterTag = options.stopOnGreaterTag;
       var dict = {};
       try {
+        var previousTagOffset;
         while (!bufferStream.end()) {
+          previousTagOffset = bufferStream.offset;
           var readInfo = DicomMessage._readTag(bufferStream, syntax, options);
           var cleanTagString = readInfo.tag.toCleanString();
+          if (untilTag && stopOnGreaterTag && cleanTagString > untilTag) {
+            bufferStream.offset = previousTagOffset;
+            break;
+          }
           if (cleanTagString === "00080005") {
             if (readInfo.values.length > 0) {
               var coding = readInfo.values[0];
@@ -10970,15 +11003,36 @@ var DicomMessage = /*#__PURE__*/function () {
       if (stream.readAsciiString(4) !== "DICM") {
         throw new Error("Invalid DICOM file, expected header is missing");
       }
+
+      // save position before reading first tag
+      var metaStartPos = stream.offset;
+
+      // read the first tag to check if it's the meta length tag
       var el = DicomMessage._readTag(stream, useSyntax);
+      var metaHeader = {};
       if (el.tag.toCleanString() !== "00020000") {
-        throw new Error("Invalid DICOM file, meta length tag is malformed or not present.");
-      }
-      var metaLength = el.values[0];
+        // meta length tag is missing
+        if (!options.ignoreErrors) {
+          throw new Error("Invalid DICOM file, meta length tag is malformed or not present.");
+        }
+
+        // reset stream to the position where we started reading tags
+        stream.offset = metaStartPos;
+
+        // read meta header elements sequentially
+        metaHeader = DicomMessage._read(stream, useSyntax, {
+          untilTag: "00030000",
+          stopOnGreaterTag: true,
+          ignoreErrors: true
+        });
+      } else {
+        // meta length tag is present
+        var metaLength = el.values[0];
 
-      //read header buffer
-      var metaStream = stream.more(metaLength);
-      var metaHeader = DicomMessage._read(metaStream, useSyntax, options);
+        // read header buffer using the specified meta length
+        var metaStream = stream.more(metaLength);
+        metaHeader = DicomMessage._read(metaStream, useSyntax, options);
+      }
 
       //get the syntax
       var mainSyntax = metaHeader["00020010"].Value[0];
@@ -11094,7 +11148,7 @@ var DicomMessage = /*#__PURE__*/function () {
         } else {
           vr = ValueRepresentation.createByTypeString(vrType);
         }
-        if (vr.isExplicit()) {
+        if (vr.isLength32()) {
           stream.increment(2);
           length = stream.readUint32();
         } else {