Merge branch 'master' of github.com:nipy/nipype into enh/qwarp

Author: chrisgorgo

nipype/algorithms/confounds.py

@@ -8,13 +8,15 @@
 import pytest
 from ...testing import utils
 from ..confounds import CompCor, TCompCor, ACompCor
+from ...interfaces.base import Undefined
 
 
 class TestCompCor():
     ''' Note: Tests currently do a poor job of testing functionality '''
 
     filenames = {'functionalnii': 'compcorfunc.nii',
                  'masknii': 'compcormask.nii',
+                 'masknii2': 'compcormask2.nii',
                  'components_file': None}
 
     @pytest.fixture(autouse=True)
@@ -28,7 +30,15 @@ def setup_class(self, tmpdir):
         mask = np.ones(self.fake_data.shape[:3])
         mask[0, 0, 0] = 0
         mask[0, 0, 1] = 0
-        self.mask_file = utils.save_toy_nii(mask, self.filenames['masknii'])
+        mask1 = utils.save_toy_nii(mask, self.filenames['masknii'])
+
+        other_mask = np.ones(self.fake_data.shape[:3])
+        other_mask[0, 1, 0] = 0
+        other_mask[1, 1, 0] = 0
+        mask2 = utils.save_toy_nii(other_mask, self.filenames['masknii2'])
+
+        self.mask_files = [mask1, mask2]
+
 
     def test_compcor(self):
         expected_components = [['-0.1989607212', '-0.5753813646'],
@@ -37,16 +47,19 @@ def test_compcor(self):
                                ['0.4206466244', '-0.3361270124'],
                                ['-0.1246655485', '-0.1235705610']]
 
-        self.run_cc(CompCor(realigned_file=self.realigned_file, mask_file=self.mask_file),
-                    expected_components)
+        self.run_cc(CompCor(realigned_file=self.realigned_file,
+                            mask_files=self.mask_files),
+                            expected_components)
 
-        self.run_cc(ACompCor(realigned_file=self.realigned_file, mask_file=self.mask_file,
+        self.run_cc(ACompCor(realigned_file=self.realigned_file,
+                             mask_files=self.mask_files,
                              components_file='acc_components_file'),
-                    expected_components, 'aCompCor')
+                             expected_components, 'aCompCor')
 
 
     def test_tcompcor(self):
-        ccinterface = TCompCor(realigned_file=self.realigned_file, percentile_threshold=0.75)
+        ccinterface = TCompCor(realigned_file=self.realigned_file,
+                               percentile_threshold=0.75)
         self.run_cc(ccinterface, [['-0.1114536190', '-0.4632908609'],
                                   ['0.4566907310', '0.6983205193'],
                                   ['-0.7132557407', '0.1340170559'],
@@ -62,27 +75,29 @@ def test_tcompcor_no_percentile(self):
         assert num_nonmasked_voxels == 1
 
     def test_compcor_no_regress_poly(self):
-        self.run_cc(CompCor(realigned_file=self.realigned_file, mask_file=self.mask_file,
-                            use_regress_poly=False), [['0.4451946442', '-0.7683311482'],
-                                                      ['-0.4285129505', '-0.0926034137'],
-                                                      ['0.5721540256', '0.5608764842'],
-                                                      ['-0.5367548139', '0.0059943226'],
-                                                      ['-0.0520809054', '0.2940637551']])
+        self.run_cc(CompCor(realigned_file=self.realigned_file,
+                    mask_files=self.mask_files,
+                    use_regress_poly=False), [['0.4451946442', '-0.7683311482'],
+                                              ['-0.4285129505', '-0.0926034137'],
+                                              ['0.5721540256', '0.5608764842'],
+                                              ['-0.5367548139', '0.0059943226'],
+                                              ['-0.0520809054', '0.2940637551']])
 
     def test_tcompcor_asymmetric_dim(self):
         asymmetric_shape = (2, 3, 4, 5)
-        asymmetric_data = utils.save_toy_nii(np.zeros(asymmetric_shape), 'asymmetric.nii')
+        asymmetric_data = utils.save_toy_nii(np.zeros(asymmetric_shape),
+                                            'asymmetric.nii')
 
         TCompCor(realigned_file=asymmetric_data).run()
         assert nb.load('mask.nii').get_data().shape == asymmetric_shape[:3]
 
     def test_compcor_bad_input_shapes(self):
-        shape_less_than = (1, 2, 2, 5) # dim 0 is < dim 0 of self.mask_file (2)
-        shape_more_than = (3, 3, 3, 5) # dim 0 is > dim 0 of self.mask_file (2)
+        shape_less_than = (1, 2, 2, 5) # dim 0 is < dim 0 of self.mask_files (2)
+        shape_more_than = (3, 3, 3, 5) # dim 0 is > dim 0 of self.mask_files (2)
 
         for data_shape in (shape_less_than, shape_more_than):
             data_file = utils.save_toy_nii(np.zeros(data_shape), 'temp.nii')
-            interface = CompCor(realigned_file=data_file, mask_file=self.mask_file)
+            interface = CompCor(realigned_file=data_file, mask_files=self.mask_files)
             with pytest.raises(ValueError, message="Dimension mismatch"): interface.run()
 
     def test_tcompcor_bad_input_dim(self):
@@ -91,6 +106,25 @@ def test_tcompcor_bad_input_dim(self):
         interface = TCompCor(realigned_file=data_file)
         with pytest.raises(ValueError, message='Not a 4D file'): interface.run()
 
+    def test_tcompcor_merge_intersect_masks(self):
+        for method in ['union', 'intersect']:
+            TCompCor(realigned_file=self.realigned_file,
+                     mask_files=self.mask_files,
+                     merge_method=method).run()
+            if method == 'union':
+                assert np.array_equal(nb.load('mask.nii').get_data(),
+                                     ([[[0,0],[0,0]],[[0,0],[1,0]]]))
+            if method == 'intersect':
+                assert np.array_equal(nb.load('mask.nii').get_data(),
+                                      ([[[0,0],[0,0]],[[0,1],[0,0]]]))
+
+    def test_tcompcor_index_mask(self):
+        TCompCor(realigned_file=self.realigned_file,
+                 mask_files=self.mask_files,
+                 mask_index=1).run()
+        assert np.array_equal(nb.load('mask.nii').get_data(),
+                            ([[[0,0],[0,0]],[[0,1],[0,0]]]))
+
     def run_cc(self, ccinterface, expected_components, expected_header='CompCor'):
         # run
         ccresult = ccinterface.run()

nipype/algorithms/tests/test_compcor.py

@@ -1028,7 +1028,7 @@ def _prep_expert_file(self):
 
         contents = ''.join(lines)
         if not isdefined(self.inputs.xopts) and \
-                self.get_expert_file() == contents:
+                self._get_expert_file() == contents:
             return ' -xopts-use'
 
         expert_fname = os.path.abspath('expert.opts')

nipype/interfaces/freesurfer/preprocess.py

@@ -324,6 +324,12 @@ def test_mcflirt(setup_flirt):
     realcmd = 'mcflirt -in ' + infile + ' -out ' + outfile2
     assert frt.cmdline == realcmd
 
+
+@pytest.mark.skipif(no_fsl(), reason="fsl is not installed")
+def test_mcflirt_opt(setup_flirt):
+    tmpdir, infile, reffile = setup_flirt
+    _, nme = os.path.split(infile)
+
     opt_map = {
         'cost': ('-cost mutualinfo', 'mutualinfo'),
         'bins': ('-bins 256', 256),
@@ -344,6 +350,9 @@ def test_mcflirt(setup_flirt):
 
     for name, settings in list(opt_map.items()):
         fnt = fsl.MCFLIRT(in_file=infile, **{name: settings[1]})
+        outfile = os.path.join(os.getcwd(), nme)
+        outfile = fnt._gen_fname(outfile, suffix='_mcf')
+
         instr = '-in %s' % (infile)
         outstr = '-out %s' % (outfile)
         if name in ('init', 'cost', 'dof', 'mean_vol', 'bins'):
@@ -357,10 +366,14 @@ def test_mcflirt(setup_flirt):
                                             outstr,
                                             settings[0]])
 
+
+@pytest.mark.skipif(no_fsl(), reason="fsl is not installed")
+def test_mcflirt_noinput():
     # Test error is raised when missing required args
     fnt = fsl.MCFLIRT()
-    with pytest.raises(ValueError):
+    with pytest.raises(ValueError) as excinfo:
         fnt.run()
+    assert str(excinfo.value).startswith("MCFLIRT requires a value for input 'in_file'")
 
 # test fnirt
 

nipype/interfaces/fsl/tests/test_preprocess.py

@@ -7,10 +7,9 @@
     >>> filepath = os.path.dirname( os.path.realpath( __file__ ) )
     >>> datadir = os.path.realpath(os.path.join(filepath, '../../testing/data'))
     >>> os.chdir(datadir)
-
 """
 from __future__ import print_function, division, unicode_literals, absolute_import
-from builtins import open
+from io import open
 
 import os.path as op
 import nibabel as nb
@@ -55,10 +54,11 @@ def read_mrtrix_tracks(in_file, as_generator=True):
 
 
 def read_mrtrix_header(in_file):
-    fileobj = open(in_file, 'r')
+    fileobj = open(in_file, 'rb')
     header = {}
     iflogger.info('Reading header data...')
     for line in fileobj:
+        line = line.decode()
         if line == 'END\n':
             iflogger.info('Reached the end of the header!')
             break
@@ -78,7 +78,7 @@ def read_mrtrix_header(in_file):
 def read_mrtrix_streamlines(in_file, header, as_generator=True):
     offset = header['offset']
     stream_count = header['count']
-    fileobj = open(in_file, 'r')
+    fileobj = open(in_file, 'rb')
     fileobj.seek(offset)
     endianness = native_code
     f4dt = np.dtype(endianness + 'f4')
@@ -138,9 +138,14 @@ def track_gen(track_points):
             if n_streams == stream_count:
                 iflogger.info('100% : {n} tracks read'.format(n=n_streams))
                 raise StopIteration
-            if n_streams % int(stream_count / 100) == 0:
-                percent = int(float(n_streams) / float(stream_count) * 100)
-                iflogger.info('{p}% : {n} tracks read'.format(p=percent, n=n_streams))
+            try:
+                if n_streams % int(stream_count / 100) == 0:
+                    percent = int(float(n_streams) / float(stream_count) * 100)
+                    iflogger.info('{p}% : {n} tracks read'.format(p=percent,
+                                                                  n=n_streams))
+            except ZeroDivisionError:
+                iflogger.info('{} stream read out of {}'.format(n_streams,
+                                                                stream_count))
     track_points, nonfinite_list = points_per_track(offset)
     fileobj.seek(offset)
     streamlines = track_gen(track_points)
@@ -166,10 +171,8 @@ class MRTrix2TrackVis(BaseInterface):
     """
     Converts MRtrix (.tck) tract files into TrackVis (.trk) format
     using functions from dipy
-
     Example
     -------
-
     >>> import nipype.interfaces.mrtrix as mrt
     >>> tck2trk = mrt.MRTrix2TrackVis()
     >>> tck2trk.inputs.in_file = 'dwi_CSD_tracked.tck'

nipype/interfaces/mrtrix/convert.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+# emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
+# vi: set ft=python sts=4 ts=4 sw=4 et:
+
+"""
+The niftyreg module provides classes for interfacing with the `NiftyReg
+<http://sourceforge.net/projects/niftyreg/>`_ command line tools.
+
+Top-level namespace for niftyreg.
+"""
+
+from .base import no_niftyreg, get_custom_path
+from .reg import RegAladin, RegF3D
+from .regutils import (RegResample, RegJacobian, RegAverage, RegTools,
+                       RegTransform, RegMeasure)

nipype/interfaces/niftyreg/__init__.py

@@ -0,0 +1,128 @@
+# -*- coding: utf-8 -*-
+# emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
+# vi: set ft=python sts=4 ts=4 sw=4 et:
+
+"""
+The niftyreg module provides classes for interfacing with `niftyreg
+<http://sourceforge.net/projects/niftyreg/>`_ command line tools.
+
+These are the base tools for working with niftyreg.
+
+Registration tools are found in niftyreg/reg.py
+Every other tool is found in niftyreg/regutils.py
+
+Examples
+--------
+See the docstrings of the individual classes for examples.
+
+"""
+
+from __future__ import (print_function, division, unicode_literals,
+                        absolute_import)
+from builtins import property, super
+from distutils.version import StrictVersion
+import os
+import shutil
+import subprocess
+from warnings import warn
+
+from ..base import CommandLine, isdefined, CommandLineInputSpec, traits
+from ...utils.filemanip import split_filename
+
+
+def get_custom_path(command):
+    return os.path.join(os.getenv('NIFTYREGDIR', ''), command)
+
+
+def no_niftyreg(cmd='reg_f3d'):
+    try:
+        return shutil.which(cmd) is None
+    except AttributeError:  # Python < 3.3
+        return not any(
+            [os.path.isfile(os.path.join(path, cmd)) and
+             os.access(os.path.join(path, cmd), os.X_OK)
+             for path in os.environ["PATH"].split(os.pathsep)])
+
+
+class NiftyRegCommandInputSpec(CommandLineInputSpec):
+    """Input Spec for niftyreg interfaces."""
+    # Set the number of omp thread to use
+    omp_core_val = traits.Int(desc='Number of openmp thread to use',
+                              argstr='-omp %i')
+
+
+class NiftyRegCommand(CommandLine):
+    """
+    Base support interface for NiftyReg commands.
+    """
+    _suffix = '_nr'
+    _min_version = '1.5.30'
+
+    def __init__(self, required_version=None, **inputs):
+        super(NiftyRegCommand, self).__init__(**inputs)
+        self.required_version = required_version
+        _version = self.get_version()
+        if _version:
+            _version = _version.decode("utf-8")
+            if StrictVersion(_version) < StrictVersion(self._min_version):
+                msg = 'A later version of Niftyreg is required (%s < %s)'
+                warn(msg % (_version, self._min_version))
+            if required_version is not None:
+                if StrictVersion(_version) != StrictVersion(required_version):
+                    msg = 'The version of NiftyReg differs from the required'
+                    msg += '(%s != %s)'
+                    warn(msg % (_version, self.required_version))
+
+    def check_version(self):
+        _version = self.get_version()
+        if not _version:
+            raise Exception('Niftyreg not found')
+        # Decoding to string:
+        _version = _version.decode("utf-8")
+        if StrictVersion(_version) < StrictVersion(self._min_version):
+            err = 'A later version of Niftyreg is required (%s < %s)'
+            raise ValueError(err % (_version, self._min_version))
+        if self.required_version:
+            if StrictVersion(_version) != StrictVersion(self.required_version):
+                err = 'The version of NiftyReg differs from the required'
+                err += '(%s != %s)'
+                raise ValueError(err % (_version, self.required_version))
+
+    def get_version(self):
+        if no_niftyreg(cmd=self.cmd):
+            return None
+        exec_cmd = ''.join((self.cmd, ' -v'))
+        return subprocess.check_output(exec_cmd, shell=True).strip()
+
+    @property
+    def version(self):
+        return self.get_version()
+
+    def exists(self):
+        return self.get_version() is not None
+
+    def _run_interface(self, runtime):
+        # Update num threads estimate from OMP_NUM_THREADS env var
+        # Default to 1 if not set
+        if not isdefined(self.inputs.environ['OMP_NUM_THREADS']):
+            self.inputs.environ['OMP_NUM_THREADS'] = self.num_threads
+        return super(NiftyRegCommand, self)._run_interface(runtime)
+
+    def _format_arg(self, name, spec, value):
+        if name == 'omp_core_val':
+            self.numthreads = value
+        return super(NiftyRegCommand, self)._format_arg(name, spec, value)
+
+    def _gen_fname(self, basename, out_dir=None, suffix=None, ext=None):
+        if basename == '':
+            msg = 'Unable to generate filename for command %s. ' % self.cmd
+            msg += 'basename is not set!'
+            raise ValueError(msg)
+        _, final_bn, final_ext = split_filename(basename)
+        if out_dir is None:
+            out_dir = os.getcwd()
+        if ext is not None:
+            final_ext = ext
+        if suffix is not None:
+            final_bn = ''.join((final_bn, suffix))
+        return os.path.abspath(os.path.join(out_dir, final_bn + final_ext))