809 bad dicom write size

src/dicom/dicomWriter.js

@@ -430,13 +430,14 @@ dwv.dicom.DataWriter.prototype.writeDataElementItems = function (
     if (itemKeys.length === 0) {
       continue;
     }
-    // write item
-    var itemElement = item.xFFFEE000;
-    itemElement.value = [];
-    var implicitLength = (itemElement.vl === 'u/l');
-    if (implicitLength) {
-      itemElement.vl = 0xffffffff;
-    }
+    // item element (create new to not modify original)
+    var implicitLength = item.xFFFEE000.vl === 'u/l';
+    var itemElement = {
+      tag: item.xFFFEE000.tag,
+      vr: item.xFFFEE000.vr,
+      vl: implicitLength ? 0xffffffff : item.xFFFEE000.vl,
+      value: []
+    };
     byteOffset = this.writeDataElement(itemElement, byteOffset, isImplicit);
     // write rest
     for (var m = 0; m < itemKeys.length; ++m) {
@@ -887,9 +888,8 @@ dwv.dicom.DicomWriter.prototype.getBuffer = function (dicomElements) {
       var realVl = element.endOffset - element.startOffset;
       localSize += parseInt(realVl, 10);
 
-      // add size of sequence delimitation item
-      if (dwv.dicom.isImplicitLengthSequence(element) ||
-        dwv.dicom.isImplicitLengthPixels(element)) {
+      // add size of pixel sequence delimitation items
+      if (dwv.dicom.isImplicitLengthPixels(element)) {
         localSize += dwv.dicom.getDataElementPrefixByteSize('NONE', isImplicit);
       }
 
@@ -944,13 +944,29 @@ dwv.dicom.DicomWriter.prototype.getBuffer = function (dicomElements) {
   for (var j = 0, lenj = metaElements.length; j < lenj; ++j) {
     offset = metaWriter.writeDataElement(metaElements[j], offset, false);
   }
+
+  // check meta position
+  var preambleSize = 128 + 4;
+  var metaOffset = preambleSize + fmiglSize + metaLength;
+  if (offset !== metaOffset) {
+    console.warn('Bad size calculation... meta offset: ', offset,
+      ', calculated size:', metaOffset,
+      '(diff:', offset - metaOffset, ')');
+  }
+
   // pass flag to writer
   dataWriter.useUnVrForPrivateSq = this.useUnVrForPrivateSq;
   // write non meta
   for (var k = 0, lenk = rawElements.length; k < lenk; ++k) {
     offset = dataWriter.writeDataElement(rawElements[k], offset, isImplicit);
   }
 
+  // check final position
+  if (offset !== totalSize) {
+    console.warn('Bad size calculation... final offset: ', offset,
+      ', calculated size:', totalSize,
+      '(diff:', offset - totalSize, ')');
+  }
   // return
   return buffer;
 };
@@ -988,8 +1004,7 @@ dwv.dicom.getDicomElement = function (tagName) {
   // return element definition
   return {
     'tag': {'group': tagGE.group, 'element': tagGE.element},
-    'vr': dict[tagGE.group][tagGE.element][0],
-    'vl': dict[tagGE.group][tagGE.element][1]
+    'vr': dict[tagGE.group][tagGE.element][0]
   };
 };
 
@@ -1043,12 +1058,6 @@ dwv.dicom.setElementValue = function (element, value, isImplicit) {
           subSize += dwv.dicom.setElementValue(
             subElement, itemData[elemKeys[j]]);
 
-          // add sequence delimitation size for sub sequences
-          if (dwv.dicom.isImplicitLengthSequence(subElement)) {
-            subSize += dwv.dicom.getDataElementPrefixByteSize(
-              'NONE', isImplicit);
-          }
-
           name = dwv.dicom.getGroupElementKey(
             subElement.tag.group, subElement.tag.element);
           itemElements[name] = subElement;
@@ -1086,6 +1095,11 @@ dwv.dicom.setElementValue = function (element, value, isImplicit) {
         sqItems.push(itemElements);
       }
 
+      // add sequence delimitation size
+      if (!explicitLength) {
+        size += dwv.dicom.getDataElementPrefixByteSize('NONE', isImplicit);
+      }
+
       element.value = sqItems;
       if (explicitLength) {
         element.vl = size;

tests/data/dwv-test-anonymise.json

@@ -12,6 +12,7 @@
   "PixelRepresentation": 0,
   "Rows": 32,
   "Columns": 32,
+  "PixelSpacing": [1,1],
   "BitsAllocated": 16,
   "BitsStored": 12,
   "HighBit": 11,

tests/dicom/dicomGenerator.js

@@ -79,7 +79,6 @@ dwv.dicom.generatePixelDataFromJSONTags = function (
   }
 
   // extract info from tags
-  var isImplicit = dwv.dicom.isImplicitTransferSyntax(tags.TransferSyntaxUID);
   var numberOfRows = tags.Rows;
   var numberOfColumns = tags.Columns;
   var bitsAllocated = tags.BitsAllocated;
@@ -153,8 +152,7 @@ dwv.dicom.generatePixelDataFromJSONTags = function (
   if (bitsAllocated === 8) {
     vr = 'OB';
   }
-  var pixVL = dwv.dicom.getDataElementPrefixByteSize(vr, isImplicit) +
-       (pixels.BYTES_PER_ELEMENT * dataLength);
+  var pixVL = pixels.BYTES_PER_ELEMENT * dataLength;
   return {
     'tag': {'group': '0x7FE0', 'element': '0x0010'},
     'vr': vr,

tests/dicom/dicomWriter.test.js

@@ -115,13 +115,22 @@ QUnit.test('Test patient anonymisation', function (assert) {
     // raw tags
     var rawTags = dicomParser.getRawDicomElements();
     // check values
-    assert.equal(rawTags.x00100010.value[0], patientsName, 'patientsName');
-    assert.equal(rawTags.x00100020.value[0], patientID, 'patientID');
     assert.equal(
-      rawTags.x00100030.value[0],
+      rawTags.x00100010.value[0].trim(),
+      patientsName,
+      'patientsName');
+    assert.equal(
+      rawTags.x00100020.value[0].trim(),
+      patientID,
+      'patientID');
+    assert.equal(
+      rawTags.x00100030.value[0].trim(),
       patientsBirthDate,
       'patientsBirthDate');
-    assert.equal(rawTags.x00100040.value[0], patientsSex, 'patientsSex');
+    assert.equal(
+      rawTags.x00100040.value[0].trim(),
+      patientsSex,
+      'patientsSex');
 
     var dicomWriter = new dwv.dicom.DicomWriter();
     dicomWriter.rules = rules;
@@ -138,7 +147,10 @@ QUnit.test('Test patient anonymisation', function (assert) {
       rawTags.x00100010.value[0],
       patientsNameAnonymised,
       'patientName');
-    assert.equal(rawTags.x00100020.value[0], patientsIdAnonymised, 'patientID');
+    assert.equal(
+      rawTags.x00100020.value[0],
+      patientsIdAnonymised,
+      'patientID');
     assert.notOk(rawTags.x00100030, 'patientsBirthDate');
     assert.notOk(rawTags.x00100040, 'patientsSex');