NF - moved trackvis reader from dipy

Author: matthew-brett

nibabel/__init__.py

@@ -6,12 +6,11 @@
 #   copyright and license terms.
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
-"""This package provides read and write access to some common
-neuroimaging file formats.
+"""This package provides read and write access to some common neuroimaging file
+formats.
 
-The various image format classes give full or selective access to header
-(meta) information and access to the image data is made available via
-NumPy arrays.
+The various image format classes give full or selective access to header (meta)
+information and access to the image data is made available via NumPy arrays.
 
 ============
  Quickstart
@@ -44,22 +43,23 @@
 
 
 # module imports
-from nibabel import analyze as ana
-from nibabel import spm99analyze as spm99
-from nibabel import spm2analyze as spm2
-from nibabel import nifti1 as ni1
-from nibabel import minc
+from . import analyze as ana
+from . import spm99analyze as spm99
+from . import spm2analyze as spm2
+from . import nifti1 as ni1
+from . import minc
 # object imports
-from nibabel.fileholders import FileHolder, FileHolderError
-from nibabel.loadsave import load, save
-from nibabel.analyze import AnalyzeHeader, AnalyzeImage
-from nibabel.spm99analyze import Spm99AnalyzeHeader, Spm99AnalyzeImage
-from nibabel.spm2analyze import Spm2AnalyzeHeader, Spm2AnalyzeImage
-from nibabel.nifti1 import Nifti1Header, Nifti1Image, Nifti1Pair
-from nibabel.minc import MincImage
-from nibabel.funcs import (squeeze_image, concat_images, four_to_three,
+from .fileholders import FileHolder, FileHolderError
+from .loadsave import load, save
+from .analyze import AnalyzeHeader, AnalyzeImage
+from .spm99analyze import Spm99AnalyzeHeader, Spm99AnalyzeImage
+from .spm2analyze import Spm2AnalyzeHeader, Spm2AnalyzeImage
+from .nifti1 import Nifti1Header, Nifti1Image, Nifti1Pair
+from .minc import MincImage
+from .funcs import (squeeze_image, concat_images, four_to_three,
                            as_closest_canonical)
-from nibabel.orientations import (io_orientation, orientation_affine,
+from .orientations import (io_orientation, orientation_affine,
                                   flip_axis, OrientationError,
                                   apply_orientation)
-from nibabel.imageclasses import class_map, ext_map
+from .imageclasses import class_map, ext_map
+from . import trackvis

nibabel/tests/test_trackvis.py

@@ -0,0 +1,183 @@
+''' Testing trackvis module '''
+
+from StringIO import StringIO
+
+import numpy as np
+
+import nibabel.trackvis as tv
+
+from nose.tools import assert_true, assert_false, assert_equal, assert_raises
+
+from numpy.testing import assert_array_equal, assert_array_almost_equal
+
+from nibabel.testing import parametric
+
+
+@parametric
+def test_write():
+    streams = []
+    out_f = StringIO()
+    tv.write(out_f, [], {})
+    yield assert_equal(out_f.getvalue(), tv.empty_header().tostring())
+    out_f.truncate(0)
+    # Write something not-default
+    tv.write(out_f, [], {'id_string':'TRACKb'})
+    # read it back
+    out_f.seek(0)
+    streams, hdr = tv.read(out_f)
+    yield assert_equal(hdr['id_string'], 'TRACKb')
+    # check that we can pass none for the header
+    out_f.truncate(0)
+    tv.write(out_f, [])
+    out_f.truncate(0)
+    tv.write(out_f, [], None)
+    # check that we check input values
+    out_f.truncate(0)
+    yield assert_raises(tv.HeaderError,
+           tv.write, out_f, [],{'id_string':'not OK'})
+    yield assert_raises(tv.HeaderError,
+           tv.write, out_f, [],{'version': 3})
+    yield assert_raises(tv.HeaderError,
+           tv.write, out_f, [],{'hdr_size': 0})
+
+
+def streams_equal(stream1, stream2):
+    if not np.all(stream1[0] == stream1[0]):
+        return False
+    if stream1[1] is None:
+        if not stream2[1] is None:
+            return false
+    if stream1[2] is None:
+        if not stream2[2] is None:
+            return false
+    if not np.all(stream1[1] == stream1[1]):
+        return False
+    if not np.all(stream1[2] == stream1[2]):
+        return False
+    return True
+
+
+def streamlist_equal(streamlist1, streamlist2):
+    if len(streamlist1) != len(streamlist2):
+        return False
+    for s1, s2 in zip(streamlist1, streamlist2):
+        if not streams_equal(s1, s2):
+            return False
+    return True
+
+
+def test_round_trip():
+    out_f = StringIO()
+    xyz0 = np.tile(np.arange(5).reshape(5,1), (1, 3))
+    xyz1 = np.tile(np.arange(5).reshape(5,1) + 10, (1, 3))
+    streams = [(xyz0, None, None), (xyz1, None, None)]
+    tv.write(out_f, streams, {})
+    out_f.seek(0)
+    streams2, hdr = tv.read(out_f)
+    yield assert_true, streamlist_equal(streams, streams2)
+
+
+@parametric
+def test_empty_header():
+    for endian in '<>':
+        for version in (1, 2):
+            hdr = tv.empty_header(endian, version)
+            yield assert_equal(hdr['id_string'], 'TRACK')
+            yield assert_equal(hdr['version'], version)
+            yield assert_equal(hdr['hdr_size'], 1000)
+            yield assert_array_equal(
+                hdr['image_orientation_patient'],
+                [0,0,0,0,0,0])
+    hdr = tv.empty_header(version=2)
+    yield assert_array_equal(hdr['vox_to_ras'], np.zeros((4,4)))
+    hdr_endian = tv.endian_codes[tv.empty_header().dtype.byteorder]
+    yield assert_equal(hdr_endian, tv.native_code)
+
+
+@parametric
+def test_get_affine():
+    hdr = tv.empty_header()
+    # default header gives useless affine
+    yield assert_array_equal(tv.aff_from_hdr(hdr),
+                             np.diag([0,0,0,1]))
+    hdr['voxel_size'] = 1
+    yield assert_array_equal(tv.aff_from_hdr(hdr),
+                             np.diag([0,0,0,1]))
+    # DICOM direction cosines
+    hdr['image_orientation_patient'] = [1,0,0,0,1,0]
+    yield assert_array_equal(tv.aff_from_hdr(hdr),
+                             np.diag([-1,-1,1,1]))
+    # RAS direction cosines
+    hdr['image_orientation_patient'] = [-1,0,0,0,-1,0]
+    yield assert_array_equal(tv.aff_from_hdr(hdr),
+                             np.eye(4))
+    # translations
+    hdr['origin'] = [1,2,3]
+    exp_aff = np.eye(4)
+    exp_aff[:3,3] = [-1,-2,3]
+    yield assert_array_equal(tv.aff_from_hdr(hdr),
+                             exp_aff)
+    # now use the easier vox_to_ras field
+    hdr = tv.empty_header()
+    aff = np.eye(4)
+    aff[:3,:] = np.arange(12).reshape(3,4)
+    hdr['vox_to_ras'] = aff
+    yield assert_array_equal(tv.aff_from_hdr(hdr), aff)
+    # mappings work too
+    d = {'version': 1,
+         'voxel_size': np.array([1,2,3]),
+         'image_orientation_patient': np.array([1,0,0,0,1,0]),
+         'origin': np.array([10,11,12])}
+    aff = tv.aff_from_hdr(d)
+
+
+@parametric
+def test_aff_to_hdr():
+    for version in (1, 2):
+        hdr = {'version': version}
+        affine = np.diag([1,2,3,1])
+        affine[:3,3] = [10,11,12]
+        tv.aff_to_hdr(affine, hdr)
+        yield assert_array_almost_equal(tv.aff_from_hdr(hdr), affine)
+        # put flip into affine
+        aff2 = affine.copy()
+        aff2[:,2] *=-1
+        tv.aff_to_hdr(aff2, hdr)
+        yield assert_array_almost_equal(tv.aff_from_hdr(hdr), aff2)
+        if version == 2:
+            yield assert_array_almost_equal(hdr['vox_to_ras'], aff2)
+
+
+@parametric
+def test_tv_class():
+    tvf = tv.TrackvisFile([])
+    yield assert_equal(tvf.streamlines, [])
+    yield assert_true(isinstance(tvf.header, np.ndarray))
+    yield assert_equal(tvf.endianness, tv.native_code)
+    yield assert_equal(tvf.filename, None)
+    out_f = StringIO()
+    tvf.to_file(out_f)
+    yield assert_equal(out_f.getvalue(), tv.empty_header().tostring())
+    out_f.truncate(0)
+    # Write something not-default
+    tvf = tv.TrackvisFile([], {'id_string':'TRACKb'})
+    tvf.to_file(out_f)
+    # read it back
+    out_f.seek(0)
+    tvf_back = tv.TrackvisFile.from_file(out_f)
+    yield assert_equal(tvf_back.header['id_string'], 'TRACKb')
+    # check that we check input values
+    out_f.truncate(0)
+    yield assert_raises(tv.HeaderError,
+                        tv.TrackvisFile,
+                        [],{'id_string':'not OK'})
+    yield assert_raises(tv.HeaderError,
+                        tv.TrackvisFile,
+                        [],{'version': 3})
+    yield assert_raises(tv.HeaderError,
+                        tv.TrackvisFile,
+                        [],{'hdr_size':0})
+    affine = np.diag([1,2,3,1])
+    affine[:3,3] = [10,11,12]
+    tvf.set_affine(affine)
+    yield assert_true(np.all(tvf.get_affine() == affine))

nibabel/tests/test_utils.py

@@ -21,7 +21,8 @@
                                  calculate_scale,
                                  scale_min_max,
                                  can_cast, allopen,
-                                 shape_zoom_affine)
+                                 shape_zoom_affine,
+                                 rec2dict)
 
 from numpy.testing import (assert_array_almost_equal,
                            assert_array_equal)
@@ -133,10 +134,10 @@ def test_array_to_file():
     data_back = write_return(arr, str_io, ndt) # float, thus no effect
     yield assert_array_equal(data_back, arr)
     # True is the default, but just to show its possible
-    data_back = write_return(arr, str_io, ndt, nan2zero=True) 
+    data_back = write_return(arr, str_io, ndt, nan2zero=True)
     yield assert_array_equal(data_back, arr)
     data_back = write_return(arr, str_io,
-                             np.dtype(np.int64), nan2zero=True) 
+                             np.dtype(np.int64), nan2zero=True)
     yield assert_array_equal(data_back, [[0, 0],[0, 0]])
     # otherwise things get a bit weird; tidied here
     # How weird?  Look at arr.astype(np.int64)
@@ -160,8 +161,8 @@ def test_array_to_file():
     array_to_file(arr + np.inf, str_io, np.int32, 0, 0.0, None)
     data_back = array_from_file(arr.shape, np.int32, str_io)
     yield assert_array_equal(data_back, np.zeros(arr.shape))
-    
-    
+
+
 def write_return(data, fileobj, out_dtype, *args, **kwargs):
     fileobj.truncate(0)
     array_to_file(data, fileobj, out_dtype, *args, **kwargs)
@@ -238,7 +239,7 @@ def test_can_cast():
         yield assert_equal, def_res, can_cast(intype, outtype)
         yield assert_equal, scale_res, can_cast(intype, outtype, False, True)
         yield assert_equal, all_res, can_cast(intype, outtype, True, True)
-        
+
 
 @parametric
 def test_allopen():
@@ -282,3 +283,9 @@ def test_shape_zoom_affine():
                     [ 0.,  0.,  0.,  1.]])
     yield assert_array_almost_equal(res, exp)
 
+
+@parametric
+def test_rec2dict():
+    r = np.zeros((), dtype = [('x', 'i4'), ('s', 'S10')])
+    d = rec2dict(r)
+    yield assert_equal(d, {'x': 0, 's': ''})