dcmjs 0.23.1 → 0.24.2

package/build/dcmjs.es.js

@@ -1069,8 +1069,19 @@ var BufferStream = /*#__PURE__*/function () {
     value: function checkSize(step) {
       if (this.offset + step > this.buffer.byteLength) {
         //throw new Error("Writing exceeded the size of buffer");
-        //resize
-        var dstSize = this.offset + step;
+        //
+        // Resize the buffer.
+        // The idea is that when it is necessary to increase the buffer size,
+        // there will likely be more bytes which need to be written to the
+        // buffer in the future. Buffer allocation is costly.
+        // So we increase the buffer size right now
+        // by a larger amount than necessary, to reserve space for later
+        // writes which then can be done much faster. The current size of
+        // the buffer is the best estimate of the scale by which the size
+        // should increase.
+        // So approximately doubling the size of the buffer
+        // (while ensuring it fits the new data) is a simple but effective strategy.
+        var dstSize = this.offset + step + this.buffer.byteLength;
         var dst = new ArrayBuffer(dstSize);
         new Uint8Array(dst).set(new Uint8Array(this.buffer));
         this.buffer = dst;
@@ -1127,7 +1138,10 @@ var BufferStream = /*#__PURE__*/function () {
         throw new Error("Request more than currently allocated buffer");
       }
 
-      var newBuf = new ReadBufferStream(this.buffer, null, this.offset, this.offset + length);
+      var newBuf = new ReadBufferStream(this.buffer, null, {
+        start: this.offset,
+        stop: this.offset + length
+      });
       this.increment(length);
       return newBuf;
     }
@@ -1157,20 +1171,41 @@ var ReadBufferStream = /*#__PURE__*/function (_BufferStream) {
 
   var _super = _createSuper(ReadBufferStream);
 
-  function ReadBufferStream(buffer, littleEndian, start, end) {
+  function ReadBufferStream(buffer, littleEndian) {
     var _this;
 
+    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+      start: null,
+      stop: null,
+      noCopy: false
+    };
+
     _classCallCheck(this, ReadBufferStream);
 
     _this = _super.call(this, buffer, littleEndian);
-    _this.offset = start || 0;
-    _this.size = end || _this.buffer.byteLength;
+    _this.offset = options.start || 0;
+    _this.size = options.stop || _this.buffer.byteLength;
+    _this.noCopy = options.noCopy;
     _this.startOffset = _this.offset;
     _this.endOffset = _this.size;
     return _this;
   }
 
   _createClass(ReadBufferStream, [{
+    key: "getBuffer",
+    value: function getBuffer(start, end) {
+      if (this.noCopy) {
+        return new Uint8Array(this.buffer, start, end - start);
+      }
+
+      if (!start && !end) {
+        start = 0;
+        end = this.size;
+      }
+
+      return this.buffer.slice(start, end);
+    }
+  }, {
     key: "readString",
     value: function readString(length) {
       var chars = [];
@@ -1292,25 +1327,10 @@ var WriteBufferStream = /*#__PURE__*/function (_BufferStream2) {
   return _createClass(WriteBufferStream);
 }(BufferStream);
 
-function paddingLeft(paddingValue, string) {
-  return String(paddingValue + string).slice(-paddingValue.length);
-}
-
 function rtrim(str) {
   return str.replace(/\s*$/g, "");
 }
 
-function tagFromNumbers(group, element) {
-  return new Tag((group << 16 | element) >>> 0);
-}
-
-function readTag(stream) {
-  var group = stream.readUint16(),
-      element = stream.readUint16();
-  var tag = tagFromNumbers(group, element);
-  return tag;
-}
-
 function toWindows(inputArray, size) {
   return Array.from({
     length: inputArray.length - (size - 1)
@@ -1655,17 +1675,28 @@ var BinaryRepresentation = /*#__PURE__*/function (_ValueRepresentation2) {
             offsets = [];
           }
 
-          var getFrameOrFragement = function getFrameOrFragement(stream) {
+          var SequenceItemTag = 0xfffee000;
+          var SequenceDelimiterTag = 0xfffee0dd;
+
+          var getNextSequenceItemData = function getNextSequenceItemData(stream) {
             var nextTag = Tag.readTag(stream);
 
-            if (!nextTag.is(0xfffee000)) {
-              return [null, true];
+            if (nextTag.is(SequenceItemTag)) {
+              var _itemLength = stream.readUint32();
+
+              var buffer = stream.getBuffer(stream.offset, stream.offset + _itemLength);
+              stream.increment(_itemLength);
+              return buffer;
+            } else if (nextTag.is(SequenceDelimiterTag)) {
+              // Read SequenceDelimiterItem value for the SequenceDelimiterTag
+              if (stream.readUint32() !== 0) {
+                throw Error("SequenceDelimiterItem tag value was not zero");
+              }
+
+              return null;
             }
 
-            var frameOrFragmentItemLength = stream.readUint32();
-            var buffer = stream.getBuffer(stream.offset, stream.offset + frameOrFragmentItemLength);
-            stream.increment(frameOrFragmentItemLength);
-            return [buffer, false];
+            throw Error("Invalid tag in sequence");
           }; // If there is an offset table, use that to loop through pixel data sequence
 
 
@@ -1684,33 +1715,40 @@ var BinaryRepresentation = /*#__PURE__*/function (_ValueRepresentation2) {
                   stop = _range[1]; // create a new readable stream based on the range
 
 
-              var s = new ReadBufferStream(stream.buffer, stream.isLittleEndian, start, stop);
+              var rangeStream = new ReadBufferStream(stream.buffer, stream.isLittleEndian, {
+                start: start,
+                stop: stop,
+                noCopy: stream.noCopy
+              });
+              var frameSize = 0;
 
-              while (!s.end()) {
-                var _getFrameOrFragement = getFrameOrFragement(s),
-                    _getFrameOrFragement2 = _slicedToArray(_getFrameOrFragement, 2),
-                    buf = _getFrameOrFragement2[0],
-                    done = _getFrameOrFragement2[1];
+              while (!rangeStream.end()) {
+                var buf = getNextSequenceItemData(rangeStream);
 
-                if (done) {
+                if (buf === null) {
                   break;
                 }
 
                 fragments.push(buf);
-              }
+                frameSize += buf.byteLength;
+              } // Ensure the parent stream's offset is kept up to date
 
-              return fragments;
-            });
-            frames = frames.map(function (fragments) {
-              if (fragments.length < 1) {
+
+              stream.offset = rangeStream.offset; // If there's only one buffer thne just return it directly
+
+              if (fragments.length === 1) {
                 return fragments[0];
+              }
+
+              if (rangeStream.noCopy) {
+                // return the fragments for downstream application to process
+                return fragments;
               } else {
-                var frameSize = fragments.reduce(function (size, buffer) {
-                  return size + buffer.byteLength;
-                }, 0);
-                var mergedFrame = new Uint8Array(frameSize);
+                // Allocate a final ArrayBuffer and concat all buffers into it
+                var mergedFrame = new ArrayBuffer(frameSize);
+                var u8Data = new Uint8Array(mergedFrame);
                 fragments.reduce(function (offset, buffer) {
-                  mergedFrame.set(new Uint8Array(buffer), offset);
+                  u8Data.set(new Uint8Array(buffer), offset);
                   return offset + buffer.byteLength;
                 }, 0);
                 return mergedFrame;
@@ -1718,22 +1756,15 @@ var BinaryRepresentation = /*#__PURE__*/function (_ValueRepresentation2) {
             });
           } // If no offset table, loop through remainder of stream looking for termination tag
           else {
-            while (stream.offset < stream.size) {
-              var _getFrameOrFragement3 = getFrameOrFragement(stream),
-                  _getFrameOrFragement4 = _slicedToArray(_getFrameOrFragement3, 2),
-                  buffer = _getFrameOrFragement4[0],
-                  done = _getFrameOrFragement4[1];
+            while (!stream.end()) {
+              var buffer = getNextSequenceItemData(stream);
+
+              if (buffer === null) {
+                break;
+              }
 
-              if (done) break;
               frames.push(buffer);
             }
-          } // Read SequenceDelimitationItem Tag
-
-
-          stream.readUint32(); // Read SequenceDelimitationItem value.
-
-          if (stream.size - stream.offset >= 4) {
-            stream.readUint32();
           }
         } else {
           throw new Error("Item tag not found after undefined binary length");
@@ -1854,9 +1885,7 @@ var AttributeTag = /*#__PURE__*/function (_ValueRepresentation3) {
   _createClass(AttributeTag, [{
     key: "readBytes",
     value: function readBytes(stream) {
-      var group = stream.readUint16(),
-          element = stream.readUint16();
-      return tagFromNumbers(group, element).value;
+      return Tag.readTag(stream).value;
     }
   }, {
     key: "writeBytes",
@@ -2293,7 +2322,7 @@ var SequenceOfItems = /*#__PURE__*/function (_ValueRepresentation7) {
         /* eslint-disable-next-line no-constant-condition */
 
         while (true) {
-          var tag = readTag(stream),
+          var tag = Tag.readTag(stream),
               length = null;
           read += 4;
 
@@ -2364,7 +2393,9 @@ var SequenceOfItems = /*#__PURE__*/function (_ValueRepresentation7) {
 
               read += toRead;
               if (undef) stream.increment(8);
-              var items = DicomMessage.read(itemStream, syntax);
+
+              var items = DicomMessage._read(itemStream, syntax);
+
               elements.push(items);
             }
 
@@ -2644,7 +2675,23 @@ var UniqueIdentifier = /*#__PURE__*/function (_StringRepresentation16) {
   _createClass(UniqueIdentifier, [{
     key: "readBytes",
     value: function readBytes(stream, length) {
-      return this.readNullPaddedString(stream, length).replace(/[^0-9.]/g, "");
+      var result = this.readNullPaddedString(stream, length);
+      var BACKSLASH = String.fromCharCode(0x5c);
+      var uidRegExp = /[^0-9.]/g; // Treat backslashes as a delimiter for multiple UIDs, in which case an
+      // array of UIDs is returned. This is used by DICOM Q&R to support
+      // querying and matching multiple items on a UID field in a single
+      // query. For more details see:
+      //
+      // https://dicom.nema.org/medical/dicom/current/output/chtml/part04/sect_C.2.2.2.2.html
+      // https://dicom.nema.org/medical/dicom/current/output/chtml/part05/sect_6.4.html
+
+      if (result.indexOf(BACKSLASH) === -1) {
+        return result.replace(uidRegExp, "");
+      } else {
+        return result.split(BACKSLASH).map(function (uid) {
+          return uid.replace(uidRegExp, "");
+        });
+      }
     }
   }]);
 
@@ -2780,6 +2827,10 @@ var OtherFloatString = /*#__PURE__*/function (_BinaryRepresentation5) {
 var IMPLICIT_LITTLE_ENDIAN = "1.2.840.10008.1.2";
 var EXPLICIT_LITTLE_ENDIAN = "1.2.840.10008.1.2.1";
 
+function paddingLeft(paddingValue, string) {
+  return String(paddingValue + string).slice(-paddingValue.length);
+}
+
 var Tag = /*#__PURE__*/function () {
   function Tag(value) {
     _classCallCheck(this, Tag);
@@ -3349,11 +3400,40 @@ var DicomMessage = /*#__PURE__*/function () {
     value: function read(bufferStream, syntax, ignoreErrors) {
       var untilTag = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
       var includeUntilTagValue = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+      console.warn("DicomMessage.read to be deprecated after dcmjs 0.24.x");
+      return this._read(bufferStream, syntax, {
+        ignoreErrors: ignoreErrors,
+        untilTag: untilTag,
+        includeUntilTagValue: includeUntilTagValue
+      });
+    }
+  }, {
+    key: "readTag",
+    value: function readTag(bufferStream, syntax) {
+      var untilTag = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+      var includeUntilTagValue = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+      console.warn("DicomMessage.readTag to be deprecated after dcmjs 0.24.x");
+      return this._readTag(bufferStream, syntax, {
+        untilTag: untilTag,
+        includeUntilTagValue: includeUntilTagValue
+      });
+    }
+  }, {
+    key: "_read",
+    value: function _read(bufferStream, syntax) {
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+        ignoreErrors: false,
+        untilTag: null,
+        includeUntilTagValue: false
+      };
+      var ignoreErrors = options.ignoreErrors,
+          untilTag = options.untilTag;
       var dict = {};
 
       try {
         while (!bufferStream.end()) {
-          var readInfo = DicomMessage.readTag(bufferStream, syntax, untilTag, includeUntilTagValue);
+          var readInfo = DicomMessage._readTag(bufferStream, syntax, options);
+
           var cleanTagString = readInfo.tag.toCleanString();
           dict[cleanTagString] = {
             vr: readInfo.vr.type,
@@ -3395,12 +3475,12 @@ var DicomMessage = /*#__PURE__*/function () {
       var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
         ignoreErrors: false,
         untilTag: null,
-        includeUntilTagValue: false
+        includeUntilTagValue: false,
+        noCopy: false
       };
-      var ignoreErrors = options.ignoreErrors,
-          untilTag = options.untilTag,
-          includeUntilTagValue = options.includeUntilTagValue;
-      var stream = new ReadBufferStream(buffer),
+      var stream = new ReadBufferStream(buffer, null, {
+        noCopy: options.noCopy
+      }),
           useSyntax = EXPLICIT_LITTLE_ENDIAN$1;
       stream.reset();
       stream.increment(128);
@@ -3409,15 +3489,20 @@ var DicomMessage = /*#__PURE__*/function () {
         throw new Error("Invalid a dicom file");
       }
 
-      var el = DicomMessage.readTag(stream, useSyntax),
+      var el = DicomMessage._readTag(stream, useSyntax),
           metaLength = el.values[0]; //read header buffer
 
+
       var metaStream = stream.more(metaLength);
-      var metaHeader = DicomMessage.read(metaStream, useSyntax, ignoreErrors); //get the syntax
+
+      var metaHeader = DicomMessage._read(metaStream, useSyntax, options); //get the syntax
+
 
       var mainSyntax = metaHeader["00020010"].Value[0];
       mainSyntax = DicomMessage._normalizeSyntax(mainSyntax);
-      var objects = DicomMessage.read(stream, mainSyntax, ignoreErrors, untilTag, includeUntilTagValue);
+
+      var objects = DicomMessage._read(stream, mainSyntax, options);
+
       var dicomDict = new DicomDict(metaHeader);
       dicomDict.dict = objects;
       return dicomDict;
@@ -3443,17 +3528,19 @@ var DicomMessage = /*#__PURE__*/function () {
       return written;
     }
   }, {
-    key: "readTag",
-    value: function readTag(stream, syntax) {
-      var untilTag = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
-      var includeUntilTagValue = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    key: "_readTag",
+    value: function _readTag(stream, syntax) {
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+        untilTag: null,
+        includeUntilTagValue: false
+      };
+      var untilTag = options.untilTag,
+          includeUntilTagValue = options.includeUntilTagValue;
       var implicit = syntax == IMPLICIT_LITTLE_ENDIAN$1 ? true : false,
           isLittleEndian = syntax == IMPLICIT_LITTLE_ENDIAN$1 || syntax == EXPLICIT_LITTLE_ENDIAN$1 ? true : false;
       var oldEndian = stream.isLittleEndian;
       stream.setEndian(isLittleEndian);
-      var group = stream.readUint16(),
-          element = stream.readUint16(),
-          tag = tagFromNumbers(group, element);
+      var tag = Tag.readTag(stream);
 
       if (untilTag === tag.toCleanString() && untilTag !== null) {
         if (!includeUntilTagValue) {