Merge remote-tracking branch 'upstream/master' into enh/MigrateToSetuptools

Author: oesteban

codecov.yml

@@ -1,11 +1,17 @@
 coverage:
   range: "0...100"
   status:
+    patch:
+      default:
+        target: 0
+        threshold: 100
     project:
       default:
         target: 0
         threshold: 100
-      patch: false
+      patch:
+        target: 0
+        threshold: 100
       unittests:
         target: 0
         threshold: 100

doc/devel/testing_nipype.rst

@@ -39,7 +39,7 @@ dependencies. Installing software dependencies and downloading the necessary dat
 will reduce the number of skip tests.
 
 Some tests in Nipype make use of some images distributed within the `FSL course data
-<http://fsl.fmrib.ox.ac.uk/fslcourse/>`_. This reduced version of the package can be downloaded `here 
+<http://fsl.fmrib.ox.ac.uk/fslcourse/>`_. This reduced version of the package can be downloaded `here
 <https://3552243d5be815c1b09152da6525cb8fe7b900a6.googledrive.com/host/0BxI12kyv2olZVUswazA3NkFvOXM/nipype-fsl_course_data.tar.gz>`_.
 To enable the tests depending on these data, just unpack the targz file and set the :code:`FSL_COURSE_DATA` environment
 variable to point to that folder.

doc/users/grabbing_and_sinking.rst

@@ -235,7 +235,7 @@ when using multiple nested iterables.
 Substitutions
 -------------
 
-The `substitutions` and `substitutions_regexp` inputs allow users to modify the
+The ``substitutions`` and ``regexp_substitutions`` inputs allow users to modify the
 output destination path and name of a file. Substitutions are a list of 2-tuples
 and are carried out in the order in which they were entered. Assuming that the
 output path of a file is:

nipype/algorithms/tests/test_auto_CompCor.py

@@ -0,0 +1,38 @@
+# AUTO-GENERATED by tools/checkspecs.py - DO NOT EDIT
+from ...testing import assert_equal
+from ..confounds import CompCor
+
+
+def test_CompCor_inputs():
+    input_map = dict(components_file=dict(mandatory=False,
+    usedefault=True,
+    ),
+    ignore_exception=dict(nohash=True,
+    usedefault=True,
+    ),
+    mask_file=dict(mandatory=False,
+    ),
+    num_components=dict(usedefault=True,
+    ),
+    realigned_file=dict(mandatory=True,
+    ),
+    regress_poly_degree=dict(usedefault=True,
+    ),
+    use_regress_poly=dict(usedefault=True,
+    ),
+    )
+    inputs = CompCor.input_spec()
+
+    for key, metadata in list(input_map.items()):
+        for metakey, value in list(metadata.items()):
+            yield assert_equal, getattr(inputs.traits()[key], metakey), value
+
+
+def test_CompCor_outputs():
+    output_map = dict(components_file=dict(),
+    )
+    outputs = CompCor.output_spec()
+
+    for key, metadata in list(output_map.items()):
+        for metakey, value in list(metadata.items()):
+            yield assert_equal, getattr(outputs.traits()[key], metakey), value

nipype/algorithms/tests/test_auto_TCompCor.py

@@ -0,0 +1,40 @@
+# AUTO-GENERATED by tools/checkspecs.py - DO NOT EDIT
+from ...testing import assert_equal
+from ..confounds import TCompCor
+
+
+def test_TCompCor_inputs():
+    input_map = dict(components_file=dict(mandatory=False,
+    usedefault=True,
+    ),
+    ignore_exception=dict(nohash=True,
+    usedefault=True,
+    ),
+    mask_file=dict(mandatory=False,
+    ),
+    num_components=dict(usedefault=True,
+    ),
+    percentile_threshold=dict(usedefault=True,
+    ),
+    realigned_file=dict(mandatory=True,
+    ),
+    regress_poly_degree=dict(usedefault=True,
+    ),
+    use_regress_poly=dict(usedefault=True,
+    ),
+    )
+    inputs = TCompCor.input_spec()
+
+    for key, metadata in list(input_map.items()):
+        for metakey, value in list(metadata.items()):
+            yield assert_equal, getattr(inputs.traits()[key], metakey), value
+
+
+def test_TCompCor_outputs():
+    output_map = dict(components_file=dict(),
+    )
+    outputs = TCompCor.output_spec()
+
+    for key, metadata in list(output_map.items()):
+        for metakey, value in list(metadata.items()):
+            yield assert_equal, getattr(outputs.traits()[key], metakey), value

nipype/algorithms/tests/test_confounds.py

@@ -1,12 +1,14 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 import os
-from nipype.testing import (assert_equal, example_data, skipif)
-from nipype.algorithms.confounds import FramewiseDisplacement, ComputeDVARS
-import numpy as np
 from tempfile import mkdtemp
 from shutil import rmtree
 
+from nipype.testing import (assert_equal, example_data, skipif, assert_true)
+from nipype.algorithms.confounds import FramewiseDisplacement, ComputeDVARS
+import numpy as np
+
+
 nonitime = True
 try:
     import nitime
@@ -18,11 +20,12 @@
 def test_fd():
     tempdir = mkdtemp()
     ground_truth = np.loadtxt(example_data('fsl_motion_outliers_fd.txt'))
-    fd = FramewiseDisplacement(in_plots=example_data('fsl_mcflirt_movpar.txt'),
-                               out_file=tempdir + '/fd.txt')
-    res = fd.run()
-    yield assert_equal, np.allclose(ground_truth, np.loadtxt(res.outputs.out_file)), True
-    yield assert_equal, np.abs(ground_truth.mean() - res.outputs.fd_average) < 1e-4, True
+    fdisplacement = FramewiseDisplacement(in_plots=example_data('fsl_mcflirt_movpar.txt'),
+                                          out_file=tempdir + '/fd.txt')
+    res = fdisplacement.run()
+
+    yield assert_true, np.allclose(ground_truth, np.loadtxt(res.outputs.out_file), atol=.16)
+    yield assert_true, np.abs(ground_truth.mean() - res.outputs.fd_average) < 1e-2
     rmtree(tempdir)
 
 @skipif(nonitime)
@@ -31,9 +34,9 @@ def test_dvars():
     ground_truth = np.loadtxt(example_data('ds003_sub-01_mc.DVARS'))
     dvars = ComputeDVARS(in_file=example_data('ds003_sub-01_mc.nii.gz'),
                          in_mask=example_data('ds003_sub-01_mc_brainmask.nii.gz'),
-                         save_all = True)
+                         save_all=True)
     os.chdir(tempdir)
     res = dvars.run()
 
     dv1 = np.loadtxt(res.outputs.out_std)
-    yield assert_equal, (np.abs(dv1 - ground_truth).sum()/ len(dv1)) < 0.05, True
+    yield assert_equal, (np.abs(dv1 - ground_truth).sum()/ len(dv1)) < 0.05, True

nipype/interfaces/dipy/reconstruction.py

@@ -211,6 +211,7 @@ def _run_interface(self, runtime):
         from dipy.reconst.csdeconv import recursive_response, auto_response
 
         img = nb.load(self.inputs.in_file)
+        imref = nb.four_to_three(img)[0]
         affine = img.get_affine()
 
         if isdefined(self.inputs.in_mask):

nipype/interfaces/fsl/base.py

@@ -22,7 +22,7 @@
 
 Examples
 --------
-See the docstrings of the individual classes for examples.  
+See the docstrings of the individual classes for examples.
 
 """
 from __future__ import print_function, division, unicode_literals, absolute_import

nipype/interfaces/nilearn.py

@@ -0,0 +1,141 @@
+# -*- 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:
+'''
+Algorithms to compute statistics on :abbr:`fMRI (functional MRI)`
+
+    Change directory to provide relative paths for doctests
+    >>> import os
+    >>> 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)
+
+import numpy as np
+import nibabel as nb
+
+from .. import logging
+from ..interfaces.base import (traits, TraitedSpec, BaseInterface,
+                               BaseInterfaceInputSpec, File, InputMultiPath)
+IFLOG = logging.getLogger('interface')
+
+class SignalExtractionInputSpec(BaseInterfaceInputSpec):
+    in_file = File(exists=True, mandatory=True, desc='4-D fMRI nii file')
+    label_files = InputMultiPath(File(exists=True), mandatory=True,
+                                 desc='a 3-D label image, with 0 denoting '
+                                 'background, or a list of 3-D probability '
+                                 'maps (one per label) or the equivalent 4D '
+                                 'file.')
+    class_labels = traits.List(mandatory=True,
+                               desc='Human-readable labels for each segment '
+                               'in the label file, in order. The length of '
+                               'class_labels must be equal to the number of '
+                               'segments (background excluded). This list '
+                               'corresponds to the class labels in label_file '
+                               'in ascending order')
+    out_file = File('signals.tsv', usedefault=True, exists=False,
+                    mandatory=False, desc='The name of the file to output to. '
+                    'signals.tsv by default')
+    incl_shared_variance = traits.Bool(True, usedefault=True, mandatory=False, desc='By default '
+                                       '(True), returns simple time series calculated from each '
+                                       'region independently (e.g., for noise regression). If '
+                                       'False, returns unique signals for each region, discarding '
+                                       'shared variance (e.g., for connectivity. Only has effect '
+                                       'with 4D probability maps.')
+    include_global = traits.Bool(False, usedefault=True, mandatory=False,
+                                 desc='If True, include an extra column '
+                                 'labeled "global", with values calculated from the entire brain '
+                                 '(instead of just regions).')
+    detrend = traits.Bool(False, usedefault=True, mandatory=False,
+                          desc='If True, perform detrending using nilearn.')
+
+class SignalExtractionOutputSpec(TraitedSpec):
+    out_file = File(exists=True, desc='tsv file containing the computed '
+                    'signals, with as many columns as there are labels and as '
+                    'many rows as there are timepoints in in_file, plus a '
+                    'header row with values from class_labels')
+
+class SignalExtraction(BaseInterface):
+    '''
+    Extracts signals over tissue classes or brain regions
+
+    >>> seinterface = SignalExtraction()
+    >>> seinterface.inputs.in_file = 'functional.nii'
+    >>> seinterface.inputs.label_files = 'segmentation0.nii.gz'
+    >>> seinterface.inputs.out_file = 'means.tsv'
+    >>> segments = ['CSF', 'gray', 'white']
+    >>> seinterface.inputs.class_labels = segments
+    >>> seinterface.inputs.detrend = True
+    >>> seinterface.inputs.include_global = True
+    '''
+    input_spec = SignalExtractionInputSpec
+    output_spec = SignalExtractionOutputSpec
+
+    def _run_interface(self, runtime):
+        maskers = self._process_inputs()
+
+        signals = []
+        for masker in maskers:
+            signals.append(masker.fit_transform(self.inputs.in_file))
+        region_signals = np.hstack(signals)
+
+        output = np.vstack((self.inputs.class_labels, region_signals.astype(str)))
+
+        # save output
+        np.savetxt(self.inputs.out_file, output, fmt=b'%s', delimiter='\t')
+        return runtime
+
+    def _process_inputs(self):
+        ''' validate and  process inputs into useful form.
+        Returns a list of nilearn maskers and the list of corresponding label names.'''
+        import nilearn.input_data as nl
+        import nilearn.image as nli
+
+        label_data = nli.concat_imgs(self.inputs.label_files)
+        maskers = []
+
+        # determine form of label files, choose appropriate nilearn masker
+        if np.amax(label_data.get_data()) > 1: # 3d label file
+            n_labels = np.amax(label_data.get_data())
+            maskers.append(nl.NiftiLabelsMasker(label_data))
+        else: # 4d labels
+            n_labels = label_data.get_data().shape[3]
+            if self.inputs.incl_shared_variance: # 4d labels, independent computation
+                for img in nli.iter_img(label_data):
+                    maskers.append(nl.NiftiMapsMasker(self._4d(img.get_data(), img.affine)))
+            else: # 4d labels, one computation fitting all
+                maskers.append(nl.NiftiMapsMasker(label_data))
+
+        # check label list size
+        if len(self.inputs.class_labels) != n_labels:
+            raise ValueError('The length of class_labels {} does not '
+                             'match the number of regions {} found in '
+                             'label_files {}'.format(self.inputs.class_labels,
+                                                     n_labels,
+                                                     self.inputs.label_files))
+
+        if self.inputs.include_global:
+            global_label_data = label_data.get_data().sum(axis=3) # sum across all regions
+            global_label_data = np.rint(global_label_data).astype(int).clip(0, 1) # binarize
+            global_label_data = self._4d(global_label_data, label_data.affine)
+            global_masker = nl.NiftiLabelsMasker(global_label_data, detrend=self.inputs.detrend)
+            maskers.insert(0, global_masker)
+            self.inputs.class_labels.insert(0, 'global')
+
+        for masker in maskers:
+            masker.set_params(detrend=self.inputs.detrend)
+
+        return maskers
+
+    def _4d(self, array, affine):
+        ''' takes a 3-dimensional numpy array and an affine,
+        returns the equivalent 4th dimensional nifti file '''
+        return nb.Nifti1Image(array[:, :, :, np.newaxis], affine)
+
+    def _list_outputs(self):
+        outputs = self._outputs().get()
+        outputs['out_file'] = self.inputs.out_file
+        return outputs

nipype/interfaces/semtools/brains/tests/test_auto_GenerateEdgeMapImage.py

@@ -0,0 +1,53 @@
+# AUTO-GENERATED by tools/checkspecs.py - DO NOT EDIT
+from .....testing import assert_equal
+from ..utilities import GenerateEdgeMapImage
+
+
+def test_GenerateEdgeMapImage_inputs():
+    input_map = dict(args=dict(argstr='%s',
+    ),
+    environ=dict(nohash=True,
+    usedefault=True,
+    ),
+    ignore_exception=dict(nohash=True,
+    usedefault=True,
+    ),
+    inputMRVolumes=dict(argstr='--inputMRVolumes %s...',
+    ),
+    inputMask=dict(argstr='--inputMask %s',
+    ),
+    lowerPercentileMatching=dict(argstr='--lowerPercentileMatching %f',
+    ),
+    maximumOutputRange=dict(argstr='--maximumOutputRange %d',
+    ),
+    minimumOutputRange=dict(argstr='--minimumOutputRange %d',
+    ),
+    numberOfThreads=dict(argstr='--numberOfThreads %d',
+    ),
+    outputEdgeMap=dict(argstr='--outputEdgeMap %s',
+    hash_files=False,
+    ),
+    outputMaximumGradientImage=dict(argstr='--outputMaximumGradientImage %s',
+    hash_files=False,
+    ),
+    terminal_output=dict(nohash=True,
+    ),
+    upperPercentileMatching=dict(argstr='--upperPercentileMatching %f',
+    ),
+    )
+    inputs = GenerateEdgeMapImage.input_spec()
+
+    for key, metadata in list(input_map.items()):
+        for metakey, value in list(metadata.items()):
+            yield assert_equal, getattr(inputs.traits()[key], metakey), value
+
+
+def test_GenerateEdgeMapImage_outputs():
+    output_map = dict(outputEdgeMap=dict(),
+    outputMaximumGradientImage=dict(),
+    )
+    outputs = GenerateEdgeMapImage.output_spec()
+
+    for key, metadata in list(output_map.items()):
+        for metakey, value in list(metadata.items()):
+            yield assert_equal, getattr(outputs.traits()[key], metakey), value