Read full datasets (with TransferSyntax)

Author: kastman

nibabel/nifti1.py

@@ -390,9 +390,52 @@ class Nifti1DicomExtension(Nifti1Extension):
     def __init__(self, code, content):
         self._code = code
         self._raw_content = content
-        self._is_implicit_VR = self._guess_implicit_VR()
+        self._bio = BytesIO(content)
         self._content = self._unmangle(content)
 
+    def _check_encoding(self):
+        """DICOM Data can be stored in the header either as a valid DICOM
+        object, with a preamble, meta info, transfer syntax etc., or as a
+        set of naked tags.  Check for meta info and transfer synatx here
+        and fall back to heuristics if metainfo is missing."""
+        self._bio.seek(0)
+        self._preamble = read_preamble(self._bio,True)  # Attempt to read preamble,
+                                                        # skip if missing w/o error
+
+        if self._preamble:
+            self._meta,_is_implicit_VR,_is_little_endian = self._check_meta()
+        else:
+            self._meta = None
+            _is_implicit_VR = self._guess_implicit_VR()
+            _is_little_endian = self._guess_little_endian()
+        return _is_implicit_VR,_is_little_endian
+
+
+    def _check_meta(self):
+        """Check the DICOM Transfer Syntax and set encoding appropriately.
+        Extracted from dicom.filereader.read_partial, see there for detail"""
+        file_meta_dataset = _read_file_meta_info(self._bio)
+        transfer_syntax = file_meta_dataset.TransferSyntaxUID
+        if transfer_syntax == dicom.UID.ImplicitVRLittleEndian:
+            is_implicit_VR = True
+            is_little_endian = True
+        elif transfer_syntax == dicom.UID.ExplicitVRLittleEndian:
+            is_implicit_VR = False
+            is_little_endian = True
+        elif transfer_syntax == dicom.UID.ExplicitVRBigEndian:
+            is_implicit_VR = False
+            is_little_endian = False
+        elif transfer_syntax == dicom.UID.DeflatedExplicitVRLittleEndian:
+            zipped = fileobj.read()
+            unzipped = zlib.decompress(zipped, -zlib.MAX_WBITS)
+            self._bio = BytesIO(unzipped)  # a file-like object
+            is_implicit_VR = False
+            is_little_endian = True
+        else:
+            is_implicit_VR = False
+            is_little_endian = True
+        return file_meta_dataset, is_implicit_VR, is_little_endian
+
     def _guess_implicit_VR(self):
         """Without a DICOM Transfer Syntax, it's difficult to tell if Value
         Representations (VRs) are included in the DICOM encoding or not.
@@ -405,28 +448,30 @@ def _guess_implicit_VR(self):
             implicit_VR=True
         return implicit_VR
 
-    def _is_little_endian(self):
+    def _guess_little_endian(self):
         return True
 
     def _unmangle(self,value):
-        raw_io=BytesIO(value)
-        ds=read_dataset(raw_io,self._is_implicit_VR,self._is_little_endian)
-        return ds
+        self._is_implicit_VR, self._is_little_endian = self._check_encoding()
+
+        ds=read_dataset(self._bio,self._is_implicit_VR,self._is_little_endian)
+        content = FileDataset(
+            self._bio,ds,self._preamble,self._meta,self._is_implicit_VR,self._is_little_endian
+        )
+        return content
 
     def _mangle(self, value):
-        raw_io=BytesIO()
-        dio=DicomFileLike(raw_io)
-        dio.is_implicit_VR = self._is_implicit_VR
-        dio.is_little_endian = self._is_little_endian
-        ds_len=write_dataset(dio,value)
-        dio.seek(0)
-        return dio.read(ds_len)
+        bio=BytesIO()
+        write_file(bio,value)
+        bio.seek(0)
+        return bio.read()
 
 try:
-    from dicom.filereader import read_dataset
-    from dicom.filewriter import write_dataset
-    from dicom.filebase import DicomFileLike
+    from dicom.dataset import FileDataset
+    from dicom.filereader import read_dataset,read_preamble,_read_file_meta_info
+    from dicom.filewriter import write_file
     from dicom.values import converters as dicom_converters
+    import dicom.UID
     from io import BytesIO
 except ImportError:
     """Fall back to standard reader if pydicom unavailable."""

nibabel/tests/test_nifti1.py

@@ -40,6 +40,7 @@
 
 header_file = os.path.join(data_path, 'nifti1.hdr')
 image_file = os.path.join(data_path, 'example4d.nii.gz')
+dicom_file = os.path.join(data_path, '0.dcm')
 
 try:
     import dicom
@@ -1093,6 +1094,8 @@ 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_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)
@@ -1103,6 +1106,8 @@ def test_nifti_dicom_extension():
     dcmbytes_implicit = struct.pack('<HHL4s',0x10,0x20,4,'NiPy'.encode('utf-8'))
     dcmext = Nifti1DicomExtension(2,dcmbytes_implicit)
     assert_equal(dcmext._guess_implicit_VR(),True)
+    assert_equal(dcmext._is_implicit_VR,True)
+    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)
@@ -1117,8 +1122,24 @@ def test_nifti_dicom_extension():
     assert_equal(dcmext._mangle(dcmext.get_content()),dcmbytes_implicit)
     assert_equal(dcmext.get_sizeondisk() % 16, 0)
 
-    raw_io = BytesIO()
-    dcmext.write_to(raw_io,False)
+    # Use a full dicom file with metadata as a header
+    with open(dicom_file,'rb') as dim:
+        dcmbytes_full = dim.read()
+    dcmext = Nifti1DicomExtension(2,dcmbytes_full)
+    assert_equal(dcmext._is_implicit_VR,True)
+    assert_equal(dcmext._is_little_endian,True)
+    assert_equal(dcmext.get_code(),2)
+    assert_equal(dcmext.get_content().PatientID, '1234')
+    assert_equal(len(dcmext.get_content().values()), 139)
+    # assert_equal(
+    #     dcmext.get_content().file_meta,
+    #     dicom.filereader.read_file_meta_info(dicom_file))
+    assert_equal(dcmext.get_sizeondisk() % 16, 0)
+    
+    # make it round-tripable
+    assert_equal(dcmext._mangle(dcmext.get_content()),dcmbytes_full)
+
+    dcmext.write_to(BytesIO(),False)
 
 class TestNifti1General(object):
     """ Test class to test nifti1 in general