fix: resolved conflicts

Author: satra

.travis.yml

@@ -4,6 +4,19 @@
 # for it to be on multiple physical lines, so long as you remember: - There
 # can't be any leading "-"s - All newlines will be removed, so use ";"s
 language: python
+
+# Run jobs on container-based infrastructure, can be overridden per job
+sudo: false
+
+cache:
+  directories:
+    - $HOME/.cache/pip
+
+addons:
+  apt:
+    packages:
+      - libhdf5-serial-dev
+
 env:
     global:
         - DEPENDS="numpy scipy matplotlib h5py"
@@ -46,9 +59,6 @@ before_install:
       pip install coverage;
       pip install coveralls;
       fi
-    - if [[ $DEPENDS == *h5py* ]]; then
-      sudo apt-get install libhdf5-serial-dev;
-      fi
 # command to install dependencies
 install:
     - python setup.py install

Changelog

@@ -24,6 +24,17 @@ and Stephan Gerhard (SG).
 
 References like "pr/298" refer to github pull request numbers.
 
+* Upcoming
+
+  * Trackvis reader will now allow final streamline to have fewer points that
+    tne numbe declared in the header, with ``strict=False`` argument to
+    ``read`` function;
+  * Minor API breakage in trackvis reader. We are now raising a DataError if
+    there are too few streamlines in the file, instead of a HeaderError.  We
+    are raising a DataError if the track is truncated when ``strict=True``
+    (the default), rather than a TypeError when trying to create the points
+    array.
+
 * 2.0.1 (Saturday 27 June 2015)
 
   Contributions from Ben Cipollini, Chris Markiewicz, Alexandre Gramfort,

bin/nib-nifti-dx

@@ -25,8 +25,8 @@ def main():
     (opts, files) = parser.parse_args()
 
     for fname in files:
-        with nib.volumeutils.BinOpener(fname) as fobj:
-            hdr =  fobj.read(nib.nifti1.header_dtype.itemsize)
+        with nib.openers.ImageOpener(fname) as fobj:
+            hdr = fobj.read(nib.nifti1.header_dtype.itemsize)
         result = nib.Nifti1Header.diagnose_binaryblock(hdr)
         if len(result):
             print('Picky header check output for "%s"\n' % fname)

nibabel/__init__.py

@@ -61,7 +61,7 @@
 from .orientations import (io_orientation, orientation_affine,
                            flip_axis, OrientationError,
                            apply_orientation, aff2axcodes)
-from .imageclasses import class_map, ext_map
+from .imageclasses import class_map, ext_map, all_image_classes
 from . import trackvis
 from . import mriutils
 
@@ -73,9 +73,11 @@
     bench = Tester().bench
     del Tester
 except ImportError:
-    def test(*args, **kwargs): raise RuntimeError('Need numpy >= 1.2 for tests')
+    def test(*args, **kwargs):
+        raise RuntimeError('Need numpy >= 1.2 for tests')
 
 from .pkg_info import get_pkg_info as _get_pkg_info
 
+
 def get_info():
     return _get_pkg_info(os.path.dirname(__file__))

nibabel/affines.py

@@ -72,9 +72,9 @@ def apply_affine(aff, pts):
     shape = pts.shape
     pts = pts.reshape((-1, shape[-1]))
     # rzs == rotations, zooms, shears
-    rzs = aff[:-1,:-1]
-    trans = aff[:-1,-1]
-    res = np.dot(pts, rzs.T) + trans[None,:]
+    rzs = aff[:-1, :-1]
+    trans = aff[:-1, -1]
+    res = np.dot(pts, rzs.T) + trans[None, :]
     return res.reshape(shape)
 
 
@@ -90,8 +90,8 @@ def to_matvec(transform):
         NxM transform matrix in homogeneous coordinates representing an affine
         transformation from an (N-1)-dimensional space to an (M-1)-dimensional
         space. An example is a 4x4 transform representing rotations and
-        translations in 3 dimensions. A 4x3 matrix can represent a 2-dimensional
-        plane embedded in 3 dimensional space.
+        translations in 3 dimensions. A 4x3 matrix can represent a
+        2-dimensional plane embedded in 3 dimensional space.
 
     Returns
     -------
@@ -124,8 +124,8 @@ def to_matvec(transform):
 def from_matvec(matrix, vector=None):
     """ Combine a matrix and vector into an homogeneous affine
 
-    Combine a rotation / scaling / shearing matrix and translation vector into a
-    transform in homogeneous coordinates.
+    Combine a rotation / scaling / shearing matrix and translation vector into
+    a transform in homogeneous coordinates.
 
     Parameters
     ----------
@@ -163,7 +163,7 @@ def from_matvec(matrix, vector=None):
     """
     matrix = np.asarray(matrix)
     nin, nout = matrix.shape
-    t = np.zeros((nin+1,nout+1), matrix.dtype)
+    t = np.zeros((nin + 1, nout + 1), matrix.dtype)
     t[0:nin, 0:nout] = matrix
     t[nin, nout] = 1.
     if not vector is None:
@@ -175,8 +175,8 @@ def append_diag(aff, steps, starts=()):
     """ Add diagonal elements `steps` and translations `starts` to affine
 
     Typical use is in expanding 4x4 affines to larger dimensions.  Nipy is the
-    main consumer because it uses NxM affines, whereas we generally only use 4x4
-    affines; the routine is here for convenience.
+    main consumer because it uses NxM affines, whereas we generally only use
+    4x4 affines; the routine is here for convenience.
 
     Parameters
     ----------
@@ -219,13 +219,13 @@ def append_diag(aff, steps, starts=()):
     aff_plus = np.zeros((old_n_out + n_steps + 1,
                          old_n_in + n_steps + 1), dtype=aff.dtype)
     # Get stuff from old affine
-    aff_plus[:old_n_out,:old_n_in] = aff[:old_n_out, :old_n_in]
-    aff_plus[:old_n_out,-1] = aff[:old_n_out,-1]
+    aff_plus[:old_n_out, :old_n_in] = aff[:old_n_out, :old_n_in]
+    aff_plus[:old_n_out, -1] = aff[:old_n_out, -1]
     # Add new diagonal elements
     for i, el in enumerate(steps):
         aff_plus[old_n_out+i, old_n_in+i] = el
     # Add translations for new affine, plus last 1
-    aff_plus[old_n_out:,-1] = list(starts) + [1]
+    aff_plus[old_n_out:, -1] = list(starts) + [1]
     return aff_plus
 
 

nibabel/analyze.py

@@ -46,23 +46,23 @@
 The inability to store affines means that we have to guess what orientation the
 image has.  Most Analyze images are stored on disk in (fastest-changing to
 slowest-changing) R->L, P->A and I->S order.  That is, the first voxel is the
-rightmost, most posterior and most inferior voxel location in the image, and the
-next voxel is one voxel towards the left of the image.
+rightmost, most posterior and most inferior voxel location in the image, and
+the next voxel is one voxel towards the left of the image.
 
 Most people refer to this disk storage format as 'radiological', on the basis
 that, if you load up the data as an array ``img_arr`` where the first axis is
-the fastest changing, then take a slice in the I->S axis - ``img_arr[:,:,10]`` -
-then the right part of the brain will be on the left of your displayed slice.
+the fastest changing, then take a slice in the I->S axis - ``img_arr[:,:,10]``
+- then the right part of the brain will be on the left of your displayed slice.
 Radiologists like looking at images where the left of the brain is on the right
 side of the image.
 
 Conversely, if the image has the voxels stored with the left voxels first -
 L->R, P->A, I->S, then this would be 'neurological' format.  Neurologists like
 looking at images where the left side of the brain is on the left of the image.
 
-When we are guessing at an affine for Analyze, this translates to the problem of
-whether the affine should consider proceeding within the data down an X line as
-being from left to right, or right to left.
+When we are guessing at an affine for Analyze, this translates to the problem
+of whether the affine should consider proceeding within the data down an X line
+as being from left to right, or right to left.
 
 By default we assume that the image is stored in R->L format.  We encode this
 choice in the ``default_x_flip`` flag that can be True or False.  True means
@@ -153,18 +153,18 @@
 header_dtype = np.dtype(header_key_dtd + image_dimension_dtd +
                         data_history_dtd)
 
-_dtdefs = ( # code, conversion function, equivalent dtype, aliases
+_dtdefs = (  # code, conversion function, equivalent dtype, aliases
     (0, 'none', np.void),
-    (1, 'binary', np.void), # 1 bit per voxel, needs thought
+    (1, 'binary', np.void),  # 1 bit per voxel, needs thought
     (2, 'uint8', np.uint8),
     (4, 'int16', np.int16),
     (8, 'int32', np.int32),
     (16, 'float32', np.float32),
-    (32, 'complex64', np.complex64), # numpy complex format?
+    (32, 'complex64', np.complex64),  # numpy complex format?
     (64, 'float64', np.float64),
-    (128, 'RGB', np.dtype([('R','u1'),
-                  ('G', 'u1'),
-                  ('B', 'u1')])),
+    (128, 'RGB', np.dtype([('R', 'u1'),
+                           ('G', 'u1'),
+                           ('B', 'u1')])),
     (255, 'all', np.void))
 
 # Make full code alias bank, including dtype column
@@ -343,7 +343,7 @@ def default_structarr(klass, endianness=None):
         hdr_data['dim'] = 1
         hdr_data['dim'][0] = 0
         hdr_data['pixdim'] = 1
-        hdr_data['datatype'] = 16 # float32
+        hdr_data['datatype'] = 16  # float32
         hdr_data['bitpix'] = 32
         return hdr_data
 
@@ -858,7 +858,7 @@ def _chk_bitpix(klass, hdr, fix=False):
         rep.problem_level = 10
         rep.problem_msg = 'bitpix does not match datatype'
         if fix:
-            hdr['bitpix'] = bitpix # inplace modification
+            hdr['bitpix'] = bitpix  # inplace modification
             rep.fix_msg = 'setting bitpix to match datatype'
         return hdr, rep
 
@@ -892,13 +892,28 @@ def _chk_pixdims(hdr, fix=False):
             rep.fix_msg = ' and '.join(fmsgs)
         return hdr, rep
 
+    @classmethod
+    def may_contain_header(klass, binaryblock):
+        if len(binaryblock) < klass.sizeof_hdr:
+            return False
+
+        hdr_struct = np.ndarray(shape=(), dtype=header_dtype,
+                                buffer=binaryblock[:klass.sizeof_hdr])
+        bs_hdr_struct = hdr_struct.byteswap()
+        return 348 in (hdr_struct['sizeof_hdr'], bs_hdr_struct['sizeof_hdr'])
+
 
 class AnalyzeImage(SpatialImage):
     """ Class for basic Analyze format image
     """
     header_class = AnalyzeHeader
-    files_types = (('image','.img'), ('header','.hdr'))
-    _compressed_exts = ('.gz', '.bz2')
+    _meta_sniff_len = header_class.sizeof_hdr
+    files_types = (('image', '.img'), ('header', '.hdr'))
+    valid_exts = ('.img', '.hdr')
+    _compressed_suffixes = ('.gz', '.bz2')
+
+    makeable = True
+    rw = True
 
     ImageArrayProxy = ArrayProxy
 
@@ -931,10 +946,10 @@ def from_file_map(klass, file_map, mmap=True):
         mmap : {True, False, 'c', 'r'}, optional, keyword only
             `mmap` controls the use of numpy memory mapping for reading image
             array data.  If False, do not try numpy ``memmap`` for data array.
-            If one of {'c', 'r'}, try numpy memmap with ``mode=mmap``.  A `mmap`
-            value of True gives the same behavior as ``mmap='c'``.  If image
-            data file cannot be memory-mapped, ignore `mmap` value and read
-            array from file.
+            If one of {'c', 'r'}, try numpy memmap with ``mode=mmap``.  A
+            `mmap` value of True gives the same behavior as ``mmap='c'``.  If
+            image data file cannot be memory-mapped, ignore `mmap` value and
+            read array from file.
 
         Returns
         -------
@@ -971,10 +986,10 @@ def from_filename(klass, filename, mmap=True):
         mmap : {True, False, 'c', 'r'}, optional, keyword only
             `mmap` controls the use of numpy memory mapping for reading image
             array data.  If False, do not try numpy ``memmap`` for data array.
-            If one of {'c', 'r'}, try numpy memmap with ``mode=mmap``.  A `mmap`
-            value of True gives the same behavior as ``mmap='c'``.  If image
-            data file cannot be memory-mapped, ignore `mmap` value and read
-            array from file.
+            If one of {'c', 'r'}, try numpy memmap with ``mode=mmap``.  A
+            `mmap` value of True gives the same behavior as ``mmap='c'``.  If
+            image data file cannot be memory-mapped, ignore `mmap` value and
+            read array from file.
 
         Returns
         -------
@@ -1030,7 +1045,8 @@ def to_file_map(self, file_map=None):
             arr_writer = ArrayWriter(data, out_dtype, check_scaling=False)
         hdr_fh, img_fh = self._get_fileholders(file_map)
         # Check if hdr and img refer to same file; this can happen with odd
-        # analyze images but most often this is because it's a single nifti file
+        # analyze images but most often this is because it's a single nifti
+        # file
         hdr_img_same = hdr_fh.same_file_as(img_fh)
         hdrf = hdr_fh.get_prepare_fileobj(mode='wb')
         if hdr_img_same:

nibabel/arrayproxy.py

@@ -27,9 +27,10 @@
 """
 import warnings
 
-from .volumeutils import BinOpener, array_from_file, apply_read_scaling
+from .volumeutils import array_from_file, apply_read_scaling
 from .fileslice import fileslice
 from .keywordonly import kw_only_meth
+from .openers import ImageOpener
 
 
 class ArrayProxy(object):
@@ -130,7 +131,7 @@ def get_unscaled(self):
 
         This is an optional part of the proxy API
         '''
-        with BinOpener(self.file_like) as fileobj:
+        with ImageOpener(self.file_like) as fileobj:
             raw_data = array_from_file(self._shape,
                                        self._dtype,
                                        fileobj,
@@ -145,7 +146,7 @@ def __array__(self):
         return apply_read_scaling(raw_data, self._slope, self._inter)
 
     def __getitem__(self, slicer):
-        with BinOpener(self.file_like) as fileobj:
+        with ImageOpener(self.file_like) as fileobj:
             raw_data = fileslice(fileobj,
                                  slicer,
                                  self._shape,