NiftiHeader determines dicom byte encoding in extension

Author: kastman

nibabel/nifti1.py

@@ -382,47 +382,58 @@ def write_to(self, fileobj, byteswap):
 
 
 class Nifti1DicomExtension(Nifti1Extension):
-    """Class for NIfTI1 DICOM header extension.
+    """NIfTI1 DICOM header extension.
 
     This class is a thin wrapper around pydicom to read a binary DICOM
     byte string. If pydicom is not available, it silently falls back to the
     standard NiftiExtension class.
     """
-    def __init__(self, code, content):
+    def __init__(self, code, content, parent_hdr=None):
         self._code = code
+        if parent_hdr:
+            self._is_little_endian = parent_hdr.endianness == '<'
+        else:
+            self._is_little_endian = True
         if content.__class__ == Dataset:
             self._is_implicit_VR = False
-            self._is_little_endian = True
             self._raw_content = self._mangle(content)
             self._content = content
         elif len(content):  # Got a byte string - unmangle it
             self._raw_content = content
             self._is_implicit_VR = self._guess_implicit_VR()
-            self._is_little_endian = self._guess_little_endian()
-            self._content = self._unmangle(content)
-        else:
+            ds = self._unmangle_and_verify(content, self._is_implicit_VR,
+                                           self._is_little_endian)
+            self._content = ds
+        else:  # Otherwise, initialize a new dicom dataset
             self._is_implicit_VR = False
-            self._is_little_endian = True
             self._content = Dataset()
 
+    def _unmangle_and_verify(self, content, is_implicit_VR, is_little_endian):
+        """"Decode and verify dicom dataset"""
+        ds = self._unmangle(content, is_implicit_VR, is_little_endian)
+        for elem in ds:
+            if elem.VR not in dicom_converters.keys():
+                raise StandardError  # Ensure that all VRs are valid
+        return ds
+
     def _guess_implicit_VR(self):
-        """Without a DICOM Transfer Syntax, it's difficult to tell if Value
+        """Try to guess DICOM syntax by checking for valid VRs.
+
+        Without a DICOM Transfer Syntax, it's difficult to tell if Value
         Representations (VRs) are included in the DICOM encoding or not.
         This reads where the first VR would be and checks it against a list of
-        valid VRs"""
+        valid VRs
+        """
         potential_vr = self._raw_content[4:6].decode()
         if potential_vr in dicom_converters.keys():
             implicit_VR = False
         else:
             implicit_VR = True
         return implicit_VR
 
-    def _guess_little_endian(self):
-        return True
-
-    def _unmangle(self, value):
+    def _unmangle(self, value, is_implicit_VR=False, is_little_endian=True):
         bio = BytesIO(value)
-        ds = read_dataset(bio, self._is_implicit_VR, self._is_little_endian)
+        ds = read_dataset(bio, is_implicit_VR, is_little_endian)
         return ds
 
     def _mangle(self, dataset):

nibabel/tests/test_nifti1.py

@@ -1104,6 +1104,7 @@ def test_nifti_dicom_extension():
     dcmext = Nifti1DicomExtension(2, dcmbytes_explicit)
     assert_equal(dcmext.__class__, Nifti1DicomExtension)
     assert_equal(dcmext._guess_implicit_VR(), False)
+    assert_equal(dcmext._is_little_endian, True)
     assert_equal(dcmext.get_code(), 2)
     assert_equal(dcmext.get_content().PatientID, 'NiPy')
     assert_equal(len(dcmext.get_content().values()), 1)
@@ -1118,20 +1119,37 @@ def test_nifti_dicom_extension():
     assert_equal(dcmext.get_code(), 2)
     assert_equal(dcmext.get_content().PatientID, 'NiPy')
     assert_equal(len(dcmext.get_content().values()), 1)
-    assert_equal(dcmext._mangle(dcmext.get_content()),dcmbytes_implicit)
+    assert_equal(dcmext._mangle(dcmext.get_content()), dcmbytes_implicit)
+    assert_equal(dcmext.get_sizeondisk() % 16, 0)
+
+    # create a single dicom tag (Patient ID, [0010,0020]) with Explicit VR / BE
+    dcmbytes_explicit_be = struct.pack('>2H2sH4s', 0x10, 0x20,
+                                       'LO'.encode('utf-8'), 4,
+                                       'NiPy'.encode('utf-8'))
+    hdr_be = Nifti1Header(endianness='>')  # Big Endian Nifti1Header
+    dcmext = Nifti1DicomExtension(2, dcmbytes_explicit_be, parent_hdr=hdr_be)
+    assert_equal(dcmext.__class__, Nifti1DicomExtension)
+    assert_equal(dcmext._guess_implicit_VR(), False)
+    assert_equal(dcmext.get_code(), 2)
+    assert_equal(dcmext.get_content().PatientID, 'NiPy')
+    assert_equal(dcmext.get_content()[0x10, 0x20].value, 'NiPy')
+    assert_equal(len(dcmext.get_content().values()), 1)
+    assert_equal(dcmext._mangle(dcmext.get_content()), dcmbytes_explicit_be)
     assert_equal(dcmext.get_sizeondisk() % 16, 0)
 
+    # Check that a dicom dataset is written w/ BE encoding when not created
+    # using BE bytestring when given a BE nifti header
+    dcmext = Nifti1DicomExtension(2, ds, parent_hdr=hdr_be)
+    assert_equal(dcmext._mangle(dcmext.get_content()), dcmbytes_explicit_be)
+
     # dicom extension access from nifti extensions
     assert_equal(exts_container.count('dicom'), 0)
     exts_container.append(dcmext)
     assert_equal(exts_container.count('dicom'), 1)
     assert_equal(exts_container.get_codes(), [6, 6, 2])
-    assert_equal(dcmext._mangle(dcmext.get_content()), dcmbytes_implicit)
+    assert_equal(dcmext._mangle(dcmext.get_content()), dcmbytes_explicit_be)
     assert_equal(dcmext.get_sizeondisk() % 16, 0)
 
-    bio = BytesIO()
-    dcmext.write_to(bio, False)
-
 
 class TestNifti1General(object):
     """ Test class to test nifti1 in general