Merge branch 'master' into patch-1

Josh Warner (Mac) · Josh Warner (Mac) · commit 060d4fe6afca · 2015-01-10T16:49:31.000-07:00
diff --git a/CHANGES b/CHANGES
@@ -8,6 +8,9 @@ Next release
 * FIX: Utility interface test dir (https://github.com/nipy/nipype/pull/986)
 * FIX: IPython engine directory reset after crash (https://github.com/nipy/nipype/pull/987)
 * 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)
 
 Release 0.10.0 (October 10, 2014)
 ============
diff --git a/bin/nipype_display_crash b/bin/nipype_display_crash
@@ -74,7 +74,6 @@ if __name__ == "__main__":
                         default=None,
                         help='Directory to run the node in' + defstr)
     args = parser.parse_args()
-    print args.debug, args.ipydebug
     debug = 'ipython' if args.ipydebug else args.debug
     if debug == 'ipython':
         import sys
diff --git a/doc/devel/software_using_nipype.rst b/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
 ----------
 
diff --git a/examples/fmri_ants_openfmri.py b/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')
diff --git a/nipype/interfaces/freesurfer/model.py b/nipype/interfaces/freesurfer/model.py
@@ -635,8 +635,9 @@ class SegStats(FSCommand):
 
     def _list_outputs(self):
         outputs = self.output_spec().get()
-        outputs['summary_file'] = os.path.abspath(self.inputs.summary_file)
-        if not isdefined(outputs['summary_file']):
+        if isdefined(self.inputs.summary_file):
+        	outputs['summary_file'] = os.path.abspath(self.inputs.summary_file)
+        else:
             outputs['summary_file'] = os.path.join(os.getcwd(), 'summary.stats')
         suffices = dict(avgwf_txt_file='_avgwf.txt', avgwf_file='_avgwf.nii.gz',
                         sf_avg_file='sfavg.txt')
diff --git a/nipype/workflows/fmri/fsl/estimate.py b/nipype/workflows/fmri/fsl/estimate.py
@@ -250,7 +250,10 @@ def get_dofvolumes(dof_files, cope_files):
         import nibabel as nb
         import numpy as np
         img = nb.load(cope_files[0])
-        out_data = np.zeros(img.get_shape())
+        if len(img.get_shape()) > 3:
+            out_data = np.zeros(img.get_shape())
+        else:
+            out_data = np.zeros(list(img.get_shape()) + [1])
         for i in range(out_data.shape[-1]):
             dof = np.loadtxt(dof_files[i])
             out_data[:, :, :, i] = dof
diff --git a/nipype/workflows/fmri/fsl/preprocess.py b/nipype/workflows/fmri/fsl/preprocess.py
@@ -8,6 +8,8 @@
 import nipype.interfaces.freesurfer as fs    # freesurfer
 import nipype.interfaces.spm as spm
 
+from nipype import LooseVersion
+
 from ...smri.freesurfer.utils import create_getmask_flow
 
 def getthreshop(thresh):
@@ -415,6 +417,11 @@ def create_featreg_preproc(name='featpreproc', highpass=True, whichvol='middle')
     >>> preproc.run() # doctest: +SKIP
     """
 
+    version = 0
+    if fsl.Info.version() and \
+        LooseVersion(fsl.Info.version()) > LooseVersion('5.0.6'):
+        version = 507
+
     featpreproc = pe.Workflow(name=name)
 
     """
@@ -658,17 +665,6 @@ def create_featreg_preproc(name='featpreproc', highpass=True, whichvol='middle')
 
     featpreproc.connect(medianval, ('out_stat', getmeanscale), meanscale, 'op_string')
 
-    """
-    Perform temporal highpass filtering on the data
-    """
-
-    if highpass:
-        highpass = pe.MapNode(interface=fsl.ImageMaths(suffix='_tempfilt'),
-                              iterfield=['in_file'],
-                              name='highpass')
-        featpreproc.connect(inputnode, ('highpass', highpass_operand), highpass, 'op_string')
-        featpreproc.connect(meanscale, 'out_file', highpass, 'in_file')
-        featpreproc.connect(highpass, 'out_file', outputnode, 'highpassed_files')
 
     """
     Generate a mean functional image from the first run
@@ -681,6 +677,37 @@ def create_featreg_preproc(name='featpreproc', highpass=True, whichvol='middle')
 
     featpreproc.connect(meanscale, ('out_file', pickfirst), meanfunc3, 'in_file')
     featpreproc.connect(meanfunc3, 'out_file', outputnode, 'mean')
+
+    """
+    Perform temporal highpass filtering on the data
+    """
+
+    if highpass:
+        highpass = pe.MapNode(interface=fsl.ImageMaths(suffix='_tempfilt'),
+                              iterfield=['in_file'],
+                              name='highpass')
+        featpreproc.connect(inputnode, ('highpass', highpass_operand), highpass, 'op_string')
+        featpreproc.connect(meanscale, 'out_file', highpass, 'in_file')
+
+        if version < 507:
+            featpreproc.connect(highpass, 'out_file', outputnode, 'highpassed_files')
+        else:
+            """
+            Add back the mean removed by the highpass filter operation as of FSL 5.0.7
+            """
+            meanfunc4 = pe.MapNode(interface=fsl.ImageMaths(op_string='-Tmean',
+                                                            suffix='_mean'),
+                                   iterfield=['in_file'],
+                                   name='meanfunc4')
+            
+            featpreproc.connect(meanscale, 'out_file', meanfunc4, 'in_file')
+            addmean = pe.MapNode(interface=fsl.BinaryMaths(operation='add'),
+                                 iterfield=['in_file', 'operand_file'],
+                                 name='addmean')
+            featpreproc.connect(highpass, 'out_file', addmean, 'in_file')
+            featpreproc.connect(meanfunc4, 'out_file', addmean, 'operand_file')
+            featpreproc.connect(addmean, 'out_file', outputnode, 'highpassed_files')
+
     return featpreproc
 
 
