Merge branch 'master' into enh_add_average_error_2_errormap

Author: lsqshr

CHANGES

@@ -1,6 +1,15 @@
 Next release
 ============
 
+* BUG: matplotlib is supposed to be optional (https://github.com/nipy/nipype/pull/1003)
+* FIX: Fix split_filename behaviour when path has no file component (https://github.com/nipy/nipype/pull/1035)
+* ENH: Updated FSL dtifit to include option for grad non-linearities (https://github.com/nipy/nipype/pull/1032)
+* ENH: Updated Camino tracking interfaces, which can now use FSL bedpostx output.
+       New options also include choice of tracker, interpolator, stepsize and 
+       curveinterval for angle threshold (https://github.com/nipy/nipype/pull/1029)
+* FIX: Interfaces redirecting X crashed if $DISPLAY not defined (https://github.com/nipy/nipype/pull/1027)
+* FIX: Bug crashed 'make api' (https://github.com/nipy/nipype/pull/1026)
+* ENH: Updated antsIntroduction to handle RA and RI registrations (https://github.com/nipy/nipype/pull/1009)
 * ENH: Updated N4BiasCorrection input spec to include weight image and spline order. Made 
 	   argument formatting consistent. Cleaned ants.segmentation according to PEP8.
 	   (https://github.com/nipy/nipype/pull/990/files)
@@ -10,6 +19,9 @@ Next release
 * ENH: Resting state fMRI example with NiPy realignment and no SPM (https://github.com/nipy/nipype/pull/992)
 * FIX: Corrected Freesurfer SegStats _list_outputs to avoid error if summary_file is 
 	   undefined (issue #994)(https://https://github.com/nipy/nipype/pull/996)
+* FIX: OpenfMRI support and FSL 5.0.7 changes (https://github.com/nipy/nipype/pull/1006)
+* FIX: Output prefix in SPM Normalize with modulation (https://github.com/nipy/nipype/pull/1023)
+* ENH: Usability improvements in cluster environments (https://github.com/nipy/nipype/pull/1025)
 
 Release 0.10.0 (October 10, 2014)
 ============

doc/devel/software_using_nipype.rst

@@ -28,6 +28,11 @@ Forward
 
 `Forward <http://cyclotronresearchcentre.github.io/forward/>`_ is set of tools simplifying the preparation of accurate electromagnetic head models for EEG forward modeling. It uses Nipype Workflows and Interfaces.
 
+Limbo
+-----
+
+`Limbo <https://github.com/Gilles86/in_limbo>`_ is a toolbox for finding brain regions that are neither significantly active nor inactive, but rather “in limbo”. It was build using custom Nipype Interfaces and Workflows.
+
 Lyman
 -----
 
@@ -38,6 +43,11 @@ Medimsight
 
 `Medimsight <https://www.medimsight.com>`_ is a commercial service medical imaging cloud platform. It uses Nipype to interface with various neuroimaging software.
 
+MIA
+---
+
+`MIA <http://mia.sourceforge.net>`_ MIA is a a toolkit for gray scale medical image analysis. It provides Nipype interfaces for easy integration with other software.
+
 Mindboggle
 ----------
 

doc/users/config_file.rst

@@ -120,6 +120,11 @@ Execution
     characters will be replaced by their hash. (possible values: ``true`` and
 	``false``; default value: ``true``)
 
+*poll_sleep_duration*
+    This controls how long the job submission loop will sleep between submitting
+    all pending jobs and checking for job completion. To be nice to cluster
+    schedulers the default is set to 60 seconds.
+
 Example
 ~~~~~~~
 

examples/fmri_ants_openfmri.py

@@ -14,8 +14,8 @@
 
 from nipype import config
 config.enable_provenance()
-from nipype.external import six
 
+from nipype.external import six
 
 from glob import glob
 import os
@@ -174,8 +174,8 @@ def create_reg_workflow(name='registration'):
     reg.inputs.winsorize_upper_quantile = 0.995
     reg.inputs.args = '--float'
     reg.inputs.output_warped_image = 'output_warped_image.nii.gz'
-    reg.inputs.num_threads = 4
-    reg.plugin_args = {'qsub_args': '-l nodes=1:ppn=4'}
+    reg.inputs.num_threads = 2
+    reg.plugin_args = {'qsub_args': '-pe orte 2'}
     register.connect(stripper, 'out_file', reg, 'moving_image')
     register.connect(inputnode,'target_image_brain', reg,'fixed_image')
 
@@ -284,12 +284,13 @@ def get_subjectinfo(subject_id, base_dir, task_id, model_id):
     for idx in range(n_tasks):
         taskidx = np.where(taskinfo[:, 0] == 'task%03d' % (idx + 1))
         conds.append([condition.replace(' ', '_') for condition
-                      in taskinfo[taskidx[0], 2]])
-        files = glob(os.path.join(base_dir,
-                                  subject_id,
-                                  'BOLD',
-                                  'task%03d_run*' % (idx + 1)))
-        run_ids.insert(idx, range(1, len(files) + 1))
+                      in taskinfo[taskidx[0], 2]]) # if 'junk' not in condition])
+        files = sorted(glob(os.path.join(base_dir,
+                                         subject_id,
+                                         'BOLD',
+                                         'task%03d_run*' % (idx + 1))))
+        runs = [int(val[-3:]) for val in files]
+        run_ids.insert(idx, runs)
     TR = np.genfromtxt(os.path.join(base_dir, 'scan_key.txt'))[1]
     return run_ids[task_id - 1], conds[task_id - 1], TR
 
@@ -361,25 +362,45 @@ def analyze_openfmri_dataset(data_dir, subject=None, model_id=None,
     """
     Return data components as anat, bold and behav
     """
-
-    datasource = pe.Node(nio.DataGrabber(infields=['subject_id', 'run_id',
+    contrast_file = os.path.join(data_dir, 'models', 'model%03d' % model_id,
+                                 'task_contrasts.txt')
+    has_contrast = os.path.exists(contrast_file)
+    if has_contrast:
+        datasource = pe.Node(nio.DataGrabber(infields=['subject_id', 'run_id',
                                                    'task_id', 'model_id'],
                                          outfields=['anat', 'bold', 'behav',
                                                     'contrasts']),
                          name='datasource')
+    else:
+        datasource = pe.Node(nio.DataGrabber(infields=['subject_id', 'run_id',
+                                                   'task_id', 'model_id'],
+                                         outfields=['anat', 'bold', 'behav']),
+                         name='datasource')
     datasource.inputs.base_directory = data_dir
     datasource.inputs.template = '*'
-    datasource.inputs.field_template = {'anat': '%s/anatomy/highres001.nii.gz',
-                                'bold': '%s/BOLD/task%03d_r*/bold.nii.gz',
-                                'behav': ('%s/model/model%03d/onsets/task%03d_'
-                                          'run%03d/cond*.txt'),
-                                'contrasts': ('models/model%03d/'
-                                              'task_contrasts.txt')}
-    datasource.inputs.template_args = {'anat': [['subject_id']],
+
+    if has_contrast:
+        datasource.inputs.field_template = {'anat': '%s/anatomy/highres001.nii.gz',
+                                            'bold': '%s/BOLD/task%03d_r*/bold.nii.gz',
+                                            'behav': ('%s/model/model%03d/onsets/task%03d_'
+                                                      'run%03d/cond*.txt'),
+                                            'contrasts': ('models/model%03d/'
+                                                          'task_contrasts.txt')}
+        datasource.inputs.template_args = {'anat': [['subject_id']],
                                        'bold': [['subject_id', 'task_id']],
                                        'behav': [['subject_id', 'model_id',
                                                   'task_id', 'run_id']],
                                        'contrasts': [['model_id']]}
+    else:
+        datasource.inputs.field_template = {'anat': '%s/anatomy/highres001.nii.gz',
+                                            'bold': '%s/BOLD/task%03d_r*/bold.nii.gz',
+                                            'behav': ('%s/model/model%03d/onsets/task%03d_'
+                                                      'run%03d/cond*.txt')}
+        datasource.inputs.template_args = {'anat': [['subject_id']],
+                                       'bold': [['subject_id', 'task_id']],
+                                       'behav': [['subject_id', 'model_id',
+                                                  'task_id', 'run_id']]}
+
     datasource.inputs.sort_filelist = True
 
     """
@@ -412,9 +433,11 @@ def get_highpass(TR, hpcutoff):
 
     def get_contrasts(contrast_file, task_id, conds):
         import numpy as np
-        contrast_def = np.genfromtxt(contrast_file, dtype=object)
-        if len(contrast_def.shape) == 1:
-            contrast_def = contrast_def[None, :]
+        import os
+        contrast_def = []
+        if os.path.exists(contrast_file):
+            with open(contrast_file, 'rt') as fp:
+                contrast_def.extend([np.array(row.split()) for row in fp.readlines() if row.strip()])
         contrasts = []
         for row in contrast_def:
             if row[0] != 'task%03d' % task_id:
@@ -448,22 +471,33 @@ def get_contrasts(contrast_file, task_id, conds):
                            name="modelspec")
     modelspec.inputs.input_units = 'secs'
 
-    def check_behav_list(behav):
-        out_behav = []
+    def check_behav_list(behav, run_id, conds):
+        from nipype.external import six
+        import numpy as np
+        num_conds = len(conds)
         if isinstance(behav, six.string_types):
             behav = [behav]
-        for val in behav:
-            if not isinstance(val, list):
-                out_behav.append([val])
-            else:
-                out_behav.append(val)
-        return out_behav
+        behav_array = np.array(behav).flatten()
+        num_elements = behav_array.shape[0]
+        return behav_array.reshape(num_elements/num_conds, num_conds).tolist()
+
+    reshape_behav = pe.Node(niu.Function(input_names=['behav', 'run_id', 'conds'],
+                                       output_names=['behav'],
+                                       function=check_behav_list),
+                          name='reshape_behav')
 
     wf.connect(subjinfo, 'TR', modelspec, 'time_repetition')
-    wf.connect(datasource, ('behav', check_behav_list), modelspec, 'event_files')
+    wf.connect(datasource, 'behav', reshape_behav, 'behav')
+    wf.connect(subjinfo, 'run_id', reshape_behav, 'run_id')
+    wf.connect(subjinfo, 'conds', reshape_behav, 'conds')
+    wf.connect(reshape_behav, 'behav', modelspec, 'event_files')
+
     wf.connect(subjinfo, 'TR', modelfit, 'inputspec.interscan_interval')
     wf.connect(subjinfo, 'conds', contrastgen, 'conds')
-    wf.connect(datasource, 'contrasts', contrastgen, 'contrast_file')
+    if has_contrast:
+        wf.connect(datasource, 'contrasts', contrastgen, 'contrast_file')
+    else:
+        contrastgen.inputs.contrast_file = ''
     wf.connect(infosource, 'task_id', contrastgen, 'task_id')
     wf.connect(contrastgen, 'contrasts', modelfit, 'inputspec.contrasts')
 
@@ -487,32 +521,39 @@ def check_behav_list(behav):
     Reorder the copes so that now it combines across runs
     """
 
-    def sort_copes(files):
-        numelements = len(files[0])
-        outfiles = []
-        for i in range(numelements):
-            outfiles.insert(i, [])
-            for j, elements in enumerate(files):
-                outfiles[i].append(elements[i])
-        return outfiles
-
-    def num_copes(files):
-        return len(files)
+    def sort_copes(copes, varcopes, contrasts):
+        import numpy as np
+        if not isinstance(copes, list):
+            copes = [copes]
+            varcopes = [varcopes]
+        num_copes = len(contrasts)
+        n_runs = len(copes)
+        all_copes = np.array(copes).flatten()
+        all_varcopes = np.array(varcopes).flatten()
+        outcopes = all_copes.reshape(len(all_copes)/num_copes, num_copes).T.tolist()
+        outvarcopes = all_varcopes.reshape(len(all_varcopes)/num_copes, num_copes).T.tolist()
+        return outcopes, outvarcopes, n_runs
+
+    cope_sorter = pe.Node(niu.Function(input_names=['copes', 'varcopes',
+                                                    'contrasts'],
+                                       output_names=['copes', 'varcopes',
+                                                     'n_runs'],
+                                       function=sort_copes),
+                          name='cope_sorter')
 
     pickfirst = lambda x: x[0]
 
+    wf.connect(contrastgen, 'contrasts', cope_sorter, 'contrasts')
     wf.connect([(preproc, fixed_fx, [(('outputspec.mask', pickfirst),
                                       'flameo.mask_file')]),
-                (modelfit, fixed_fx, [(('outputspec.copes', sort_copes),
-                                       'inputspec.copes'),
-                                       ('outputspec.dof_file',
+                (modelfit, cope_sorter, [('outputspec.copes', 'copes')]),
+                (modelfit, cope_sorter, [('outputspec.varcopes', 'varcopes')]),
+                (cope_sorter, fixed_fx, [('copes', 'inputspec.copes'),
+                                         ('varcopes', 'inputspec.varcopes'),
+                                         ('n_runs', 'l2model.num_copes')]),
+                (modelfit, fixed_fx, [('outputspec.dof_file',
                                         'inputspec.dof_files'),
-                                       (('outputspec.varcopes',
-                                         sort_copes),
-                                        'inputspec.varcopes'),
-                                       (('outputspec.copes', num_copes),
-                                        'l2model.num_copes'),
-                                       ])
+                                      ])
                 ])
 
     wf.connect(preproc, 'outputspec.mean', registration, 'inputspec.mean_image')

examples/rsfmri_vol_surface_preprocessing_nipy.py

@@ -945,7 +945,7 @@ def create_resting_workflow(args, name=None):
     if args.dicom_file:
         TR, slice_times, slice_thickness = get_info(args.dicom_file)
         slice_times = (np.array(slice_times)/1000.).tolist()
-        
+
     if name is None:
         name = 'resting_' + args.subject_id
     kwargs = dict(files=[os.path.abspath(filename) for filename in args.files],

nipype/algorithms/tests/test_auto_Overlap.py

@@ -0,0 +1,46 @@
+# AUTO-GENERATED by tools/checkspecs.py - DO NOT EDIT
+from nipype.testing import assert_equal
+from nipype.algorithms.misc import Overlap
+
+def test_Overlap_inputs():
+    input_map = dict(bg_overlap=dict(mandatory=True,
+    usedefault=True,
+    ),
+    ignore_exception=dict(nohash=True,
+    usedefault=True,
+    ),
+    mask_volume=dict(),
+    out_file=dict(usedefault=True,
+    ),
+    vol_units=dict(mandatory=True,
+    usedefault=True,
+    ),
+    volume1=dict(mandatory=True,
+    ),
+    volume2=dict(mandatory=True,
+    ),
+    weighting=dict(usedefault=True,
+    ),
+    )
+    inputs = Overlap.input_spec()
+
+    for key, metadata in input_map.items():
+        for metakey, value in metadata.items():
+            yield assert_equal, getattr(inputs.traits()[key], metakey), value
+
+def test_Overlap_outputs():
+    output_map = dict(dice=dict(),
+    diff_file=dict(),
+    jaccard=dict(),
+    labels=dict(),
+    roi_di=dict(),
+    roi_ji=dict(),
+    roi_voldiff=dict(),
+    volume_difference=dict(),
+    )
+    outputs = Overlap.output_spec()
+
+    for key, metadata in output_map.items():
+        for metakey, value in metadata.items():
+            yield assert_equal, getattr(outputs.traits()[key], metakey), value
+

nipype/interfaces/ants/legacy.py

@@ -94,16 +94,21 @@ class antsIntroduction(ANTSCommand):
 
     def _list_outputs(self):
         outputs = self._outputs().get()
+        transmodel = self.inputs.transformation_model
+
+        # When transform is set as 'RI'/'RA', wrap fields should not be expected
+        # The default transformation is GR, which outputs the wrap fields
+        if not isdefined(transmodel) or (isdefined(transmodel) and transmodel not in ['RI', 'RA']):
+            outputs['warp_field'] = os.path.join(os.getcwd(),
+                                 self.inputs.out_prefix +
+                                 'Warp.nii.gz')
+            outputs['inverse_warp_field'] = os.path.join(os.getcwd(),
+                                     self.inputs.out_prefix +
+                                     'InverseWarp.nii.gz')
 
         outputs['affine_transformation'] = os.path.join(os.getcwd(),
                                                         self.inputs.out_prefix +
                                                         'Affine.txt')
-        outputs['warp_field'] = os.path.join(os.getcwd(),
-                                             self.inputs.out_prefix +
-                                             'Warp.nii.gz')
-        outputs['inverse_warp_field'] = os.path.join(os.getcwd(),
-                                                     self.inputs.out_prefix +
-                                                     'InverseWarp.nii.gz')
         outputs['input_file'] = os.path.join(os.getcwd(),
                                              self.inputs.out_prefix +
                                              'repaired.nii.gz')

nipype/interfaces/ants/segmentation.py

@@ -268,7 +268,7 @@ class N4BiasFieldCorrection(ANTSCommand):
 
     Examples
     --------
-	
+
 	>>> import copy
     >>> from nipype.interfaces.ants import N4BiasFieldCorrection
     >>> n4 = N4BiasFieldCorrection()
@@ -327,14 +327,14 @@ def _format_arg(self, name, trait_spec, value):
             output = self._gen_filename('output_image')
             newval = '[ %s, %s ]' % (output, bias_image)
             return trait_spec.argstr % newval
-            
+
         if name == 'bspline_fitting_distance':
             if isdefined(self.inputs.bspline_order):
                 newval = '[ %g, %d ]' % (value, self.inputs.bspline_order)
             else:
                 newval = '[ %g ]' % value
             return trait_spec.argstr % newval
-            
+
         if ((name == 'n_iterations') and
            (isdefined(self.inputs.convergence_threshold))):
             newval = '[ %s, %g ]' % ('x'.join([str(elt) for elt in value]),