Merge pull request #113 from CoBrALab/updates

Updates

Author: Gab-D-G

rabies/conf_reg_pkg/confound_regression.py

@@ -4,9 +4,7 @@
 from nipype import Function
 from .utils import regress, data_diagnosis, select_timeseries, exec_ICA_AROMA
 
-
-def init_confound_regression_wf(lowpass=None, highpass=None, smoothing_filter=0.3, run_aroma=False, aroma_dim=0, conf_list=[],
-                                TR='1.0s', apply_scrubbing=False, scrubbing_threshold=0.1, timeseries_interval='all', diagnosis_output=False, name="confound_regression_wf"):
+def init_confound_regression_wf(cr_opts, name="confound_regression_wf"):
 
     workflow = pe.Workflow(name=name)
     inputnode = pe.Node(niu.IdentityInterface(fields=[
@@ -19,20 +17,20 @@ def init_confound_regression_wf(lowpass=None, highpass=None, smoothing_filter=0.
                                     output_names=['cleaned_path', 'bold_file', 'VE_file'],
                                     function=regress),
                            name='regress', mem_gb=1)
-    regress_node.inputs.conf_list = conf_list
-    regress_node.inputs.TR = float(TR.split('s')[0])
-    regress_node.inputs.lowpass = lowpass
-    regress_node.inputs.highpass = highpass
-    regress_node.inputs.smoothing_filter = smoothing_filter
-    regress_node.inputs.apply_scrubbing = apply_scrubbing
-    regress_node.inputs.scrubbing_threshold = scrubbing_threshold
-    regress_node.inputs.timeseries_interval = timeseries_interval
+    regress_node.inputs.conf_list = cr_opts.conf_list
+    regress_node.inputs.TR = float(cr_opts.TR.split('s')[0])
+    regress_node.inputs.lowpass = cr_opts.lowpass
+    regress_node.inputs.highpass = cr_opts.highpass
+    regress_node.inputs.smoothing_filter = cr_opts.smoothing_filter
+    regress_node.inputs.apply_scrubbing = cr_opts.apply_scrubbing
+    regress_node.inputs.scrubbing_threshold = cr_opts.scrubbing_threshold
+    regress_node.inputs.timeseries_interval = cr_opts.timeseries_interval
 
     select_timeseries_node = pe.Node(Function(input_names=['bold_file', 'timeseries_interval'],
                                               output_names=['bold_file'],
                                               function=select_timeseries),
                                      name='select_timeseries', mem_gb=1)
-    select_timeseries_node.inputs.timeseries_interval = timeseries_interval
+    select_timeseries_node.inputs.timeseries_interval = cr_opts.timeseries_interval
 
     workflow.connect([
         (inputnode, select_timeseries_node, [
@@ -49,13 +47,13 @@ def init_confound_regression_wf(lowpass=None, highpass=None, smoothing_filter=0.
             ]),
         ])
 
-    if run_aroma:
+    if cr_opts.run_aroma:
         ica_aroma_node = pe.Node(Function(input_names=['inFile', 'mc_file', 'brain_mask', 'csf_mask', 'tr', 'aroma_dim'],
                                           output_names=['cleaned_file', 'aroma_out'],
                                           function=exec_ICA_AROMA),
                                  name='ica_aroma', mem_gb=1)
-        ica_aroma_node.inputs.tr = float(TR.split('s')[0])
-        ica_aroma_node.inputs.aroma_dim = aroma_dim
+        ica_aroma_node.inputs.tr = float(cr_opts.TR.split('s')[0])
+        ica_aroma_node.inputs.aroma_dim = cr_opts.aroma_dim
 
         workflow.connect([
             (inputnode, ica_aroma_node, [
@@ -80,7 +78,7 @@ def init_confound_regression_wf(lowpass=None, highpass=None, smoothing_filter=0.
                 ]),
             ])
 
-    if diagnosis_output:
+    if cr_opts.diagnosis_output:
         data_diagnosis_node = pe.Node(data_diagnosis(),
                                       name='data_diagnosis', mem_gb=1)
 

rabies/main_wf.py

@@ -343,8 +343,7 @@ def init_main_wf(data_dir_path, output_folder, opts, cr_opts=None, analysis_opts
                                            name='anat_convert_to_RAS')
 
         # setting anat preprocessing nodes
-        anat_preproc_wf = init_anat_preproc_wf(reg_script=opts.anat_reg_script,
-                                               disable_anat_preproc=opts.disable_anat_preproc, rabies_data_type=opts.data_type, rabies_mem_scale=opts.scale_min_memory)
+        anat_preproc_wf = init_anat_preproc_wf(opts=opts)
         anat_preproc_wf.inputs.inputnode.template_mask = str(opts.brain_mask)
 
         transform_masks = pe.Node(Function(input_names=['brain_mask_in', 'WM_mask_in', 'CSF_mask_in', 'vascular_mask_in', 'atlas_labels_in', 'reference_image', 'anat_to_template_inverse_warp', 'anat_to_template_affine', 'template_to_common_affine', 'template_to_common_inverse_warp'],
@@ -609,9 +608,7 @@ def integrate_confound_regression(workflow, outputnode, cr_opts, bold_only):
     cr_output = os.path.abspath(str(cr_opts.output_dir))
 
     from rabies.conf_reg_pkg.confound_regression import init_confound_regression_wf
-    confound_regression_wf = init_confound_regression_wf(lowpass=cr_opts.lowpass, highpass=cr_opts.highpass,
-                                                         smoothing_filter=cr_opts.smoothing_filter, run_aroma=cr_opts.run_aroma, aroma_dim=cr_opts.aroma_dim, conf_list=cr_opts.conf_list, TR=cr_opts.TR, apply_scrubbing=cr_opts.apply_scrubbing,
-                                                         scrubbing_threshold=cr_opts.scrubbing_threshold, timeseries_interval=cr_opts.timeseries_interval, diagnosis_output=cr_opts.diagnosis_output, name=cr_opts.wf_name)
+    confound_regression_wf = init_confound_regression_wf(cr_opts=cr_opts, name=cr_opts.wf_name)
 
     workflow.connect([
         (outputnode, confound_regression_wf, [

rabies/preprocess_pkg/anat_preproc.py

@@ -6,7 +6,7 @@
 )
 
 
-def init_anat_preproc_wf(reg_script, disable_anat_preproc=False, rabies_data_type=8, rabies_mem_scale=1.0, name='anat_preproc_wf'):
+def init_anat_preproc_wf(opts, name='anat_preproc_wf'):
     '''
     This workflow executes anatomical preprocessing based on anat_preproc.sh,
     which includes initial N4 bias field correction and Adaptive
@@ -21,8 +21,8 @@ def init_anat_preproc_wf(reg_script, disable_anat_preproc=False, rabies_data_typ
     outputnode = pe.Node(niu.IdentityInterface(
         fields=['anat_preproc','init_denoise', 'denoise_mask']), name='outputnode')
 
-    anat_preproc = pe.Node(AnatPreproc(reg_script=reg_script, disable_anat_preproc=disable_anat_preproc, rabies_data_type=rabies_data_type),
-                           name='Anat_Preproc', mem_gb=0.6*rabies_mem_scale)
+    anat_preproc = pe.Node(AnatPreproc(reg_script=opts.anat_reg_script, disable_anat_preproc=opts.disable_anat_preproc, rabies_data_type=opts.data_type),
+                           name='Anat_Preproc', mem_gb=0.6*opts.scale_min_memory)
 
     workflow.connect([
         (inputnode, anat_preproc, [

rabies/preprocess_pkg/bias_correction.py

@@ -1,4 +1,3 @@
-import os
 from nipype.pipeline import engine as pe
 from nipype.interfaces import utility as niu
 from nipype.interfaces.base import (
@@ -7,7 +6,7 @@
 )
 
 
-def bias_correction_wf(bias_cor_method='otsu_reg', rabies_data_type=8, rabies_mem_scale=1.0, name='bias_correction_wf'):
+def bias_correction_wf(opts, name='bias_correction_wf'):
 
     workflow = pe.Workflow(name=name)
 
@@ -19,17 +18,16 @@ def bias_correction_wf(bias_cor_method='otsu_reg', rabies_data_type=8, rabies_me
             fields=['corrected_EPI', 'denoise_mask', 'warped_EPI', 'init_denoise']),
         name='outputnode')
 
-    if bias_cor_method=='otsu_reg':
-        bias_correction = pe.Node(OtsuEPIBiasCorrection(rabies_data_type=rabies_data_type),
-                                  name='bias_correction', mem_gb=0.3*rabies_mem_scale)
+    if opts.bias_cor_method=='otsu_reg':
+        bias_correction = pe.Node(OtsuEPIBiasCorrection(rabies_data_type=opts.data_type),
+                                  name='bias_correction', mem_gb=0.3*opts.scale_min_memory)
 
-    elif bias_cor_method=='thresh_reg':
-        bias_correction = pe.Node(EPIBiasCorrection(rabies_data_type=rabies_data_type),
-                                  name='bias_correction', mem_gb=0.3*rabies_mem_scale)
+    elif opts.bias_cor_method=='thresh_reg':
+        bias_correction = pe.Node(EPIBiasCorrection(rabies_data_type=opts.data_type),
+                                  name='bias_correction', mem_gb=0.3*opts.scale_min_memory)
     else:
         raise ValueError("Wrong --bias_cor_method.")
 
-
     workflow.connect([
         (inputnode, bias_correction, [('ref_EPI', 'input_ref_EPI'),
                                       ('anat', 'anat'),

rabies/preprocess_pkg/bold_main_wf.py

@@ -11,7 +11,7 @@
 from nipype.interfaces.utility import Function
 
 
-def init_bold_main_wf(opts, bias_cor_only=False, aCompCor_method='50%', name='bold_main_wf'):
+def init_bold_main_wf(opts, bias_cor_only=False, name='bold_main_wf'):
     """
     This workflow controls the functional preprocessing stages of the pipeline when both
     functional and anatomical images are provided.
@@ -136,10 +136,8 @@ def init_bold_main_wf(opts, bias_cor_only=False, aCompCor_method='50%', name='bo
                              name="transitionnode")
 
     if bias_cor_only or (not opts.bold_only):
-        bold_reference_wf = init_bold_reference_wf(
-            detect_dummy=opts.detect_dummy, rabies_data_type=opts.data_type, rabies_mem_scale=opts.scale_min_memory, min_proc=opts.min_proc)
-        bias_cor_wf = bias_correction_wf(
-            bias_cor_method=opts.bias_cor_method, rabies_data_type=opts.data_type, rabies_mem_scale=opts.scale_min_memory)
+        bold_reference_wf = init_bold_reference_wf(opts=opts)
+        bias_cor_wf = bias_correction_wf(opts=opts)
 
         if opts.apply_despiking:
             despike = pe.Node(
@@ -192,12 +190,10 @@ def init_bold_main_wf(opts, bias_cor_only=False, aCompCor_method='50%', name='bo
     if opts.bold_only and bias_cor_only:
         return workflow
 
-    bold_stc_wf = init_bold_stc_wf(
-        no_STC=opts.no_STC, tr=opts.TR, tpattern=opts.tpattern, rabies_data_type=opts.data_type, rabies_mem_scale=opts.scale_min_memory, min_proc=opts.min_proc)
+    bold_stc_wf = init_bold_stc_wf(opts=opts)
 
     # HMC on the BOLD
-    bold_hmc_wf = init_bold_hmc_wf(slice_mc=opts.apply_slice_mc, rabies_data_type=opts.data_type,
-                                   rabies_mem_scale=opts.scale_min_memory, min_proc=opts.min_proc, local_threads=opts.local_threads)
+    bold_hmc_wf = init_bold_hmc_wf(opts=opts)
 
     if not opts.bold_only:
         def commonspace_transforms(template_to_common_warp, template_to_common_affine, anat_to_template_warp, anat_to_template_affine, warp_bold2anat, affine_bold2anat):
@@ -218,11 +214,9 @@ def commonspace_transforms(template_to_common_warp, template_to_common_affine, a
                                                        function=commonspace_transforms),
                                               name='commonspace_transforms_prep')
 
-    bold_commonspace_trans_wf = init_bold_commonspace_trans_wf(resampling_dim=opts.commonspace_resampling, brain_mask=str(opts.brain_mask), WM_mask=str(opts.WM_mask), CSF_mask=str(opts.CSF_mask), vascular_mask=str(opts.vascular_mask), atlas_labels=str(opts.labels),
-        slice_mc=opts.apply_slice_mc, rabies_data_type=opts.data_type, rabies_mem_scale=opts.scale_min_memory, min_proc=opts.min_proc)
+    bold_commonspace_trans_wf = init_bold_commonspace_trans_wf(opts=opts)
 
-    bold_confs_wf = init_bold_confs_wf(
-        aCompCor_method=aCompCor_method, name="bold_confs_wf", rabies_data_type=opts.data_type, rabies_mem_scale=opts.scale_min_memory, min_proc=opts.min_proc)
+    bold_confs_wf = init_bold_confs_wf(opts=opts, name="bold_confs_wf")
 
     # MAIN WORKFLOW STRUCTURE #######################################################
     workflow.connect([
@@ -287,8 +281,7 @@ def commonspace_transforms(template_to_common_warp, template_to_common_affine, a
         ])
 
     if not opts.bold_only:
-        bold_reg_wf = init_bold_reg_wf(coreg_script=opts.coreg_script, rabies_data_type=opts.data_type,
-                                       rabies_mem_scale=opts.scale_min_memory, min_proc=opts.min_proc)
+        bold_reg_wf = init_bold_reg_wf(opts=opts)
 
         def SyN_coreg_transforms_prep(warp_bold2anat, affine_bold2anat):
             # transforms_list,inverses
@@ -300,8 +293,7 @@ def SyN_coreg_transforms_prep(warp_bold2anat, affine_bold2anat):
                                   name='transforms_prep')
 
         # Apply transforms in 1 shot
-        bold_bold_trans_wf = init_bold_preproc_trans_wf(
-            resampling_dim=opts.nativespace_resampling, slice_mc=opts.apply_slice_mc, rabies_data_type=opts.data_type, rabies_mem_scale=opts.scale_min_memory, min_proc=opts.min_proc)
+        bold_bold_trans_wf = init_bold_preproc_trans_wf(opts=opts)
 
         workflow.connect([
             (inputnode, bold_reg_wf, [

rabies/preprocess_pkg/confounds.py

@@ -7,7 +7,7 @@
 )
 
 
-def init_bold_confs_wf(aCompCor_method='50%', rabies_data_type=8, rabies_mem_scale=1.0, min_proc=1, name="bold_confs_wf"):
+def init_bold_confs_wf(opts, aCompCor_method='50%', name="bold_confs_wf"):
 
     inputnode = pe.Node(niu.IdentityInterface(
         fields=['bold', 'ref_bold', 'movpar_file', 't1_mask', 't1_labels', 'WM_mask', 'CSF_mask', 'vascular_mask', 'name_source']),
@@ -31,10 +31,10 @@ def init_bold_confs_wf(aCompCor_method='50%', rabies_data_type=8, rabies_mem_sca
     propagate_labels = pe.Node(MaskEPI(), name='prop_labels_EPI')
     propagate_labels.inputs.name_spec = 'anat_labels'
 
-    estimate_confounds = pe.Node(EstimateConfounds(aCompCor_method=aCompCor_method, rabies_data_type=rabies_data_type),
-                                 name='estimate_confounds', mem_gb=2.3*rabies_mem_scale)
+    estimate_confounds = pe.Node(EstimateConfounds(aCompCor_method=aCompCor_method, rabies_data_type=opts.data_type),
+                                 name='estimate_confounds', mem_gb=2.3*opts.scale_min_memory)
     estimate_confounds.plugin_args = {
-        'qsub_args': '-pe smp %s' % (str(2*min_proc)), 'overwrite': True}
+        'qsub_args': '-pe smp %s' % (str(2*opts.min_proc)), 'overwrite': True}
 
     workflow = pe.Workflow(name=name)
     workflow.connect([

rabies/preprocess_pkg/hmc.py

@@ -4,10 +4,9 @@
     traits, TraitedSpec, BaseInterfaceInputSpec,
     File, BaseInterface
 )
-from .utils import SliceMotionCorrection
+from .utils import SliceMotionCorrection, antsMotionCorr
 
-
-def init_bold_hmc_wf(slice_mc=False, rabies_data_type=8, rabies_mem_scale=1.0, min_proc=1, local_threads=1, name='bold_hmc_wf'):
+def init_bold_hmc_wf(opts, name='bold_hmc_wf'):
     """
     This workflow estimates the motion parameters to perform HMC over the BOLD image.
 
@@ -28,7 +27,6 @@ def init_bold_hmc_wf(slice_mc=False, rabies_data_type=8, rabies_mem_scale=1.0, m
         movpar_file
             CSV file with antsMotionCorr motion parameters
     """
-    import os
 
     workflow = pe.Workflow(name=name)
     inputnode = pe.Node(niu.IdentityInterface(fields=['bold_file', 'ref_image']),
@@ -39,23 +37,24 @@ def init_bold_hmc_wf(slice_mc=False, rabies_data_type=8, rabies_mem_scale=1.0, m
         name='outputnode')
 
     # Head motion correction (hmc)
-    motion_estimation = pe.Node(EstimateMotion(rabies_data_type=rabies_data_type), name='ants_MC', mem_gb=1.1*rabies_mem_scale)
+    motion_estimation = pe.Node(antsMotionCorr(prebuilt_option=opts.HMC_option,transform_type=opts.HMC_transform, second=False, rabies_data_type=opts.data_type),
+                         name='ants_MC', mem_gb=1.1*opts.scale_min_memory)
     motion_estimation.plugin_args = {
-        'qsub_args': '-pe smp %s' % (str(3*min_proc)), 'overwrite': True}
+        'qsub_args': '-pe smp %s' % (str(3*opts.min_proc)), 'overwrite': True}
 
     workflow.connect([
         (inputnode, motion_estimation, [('ref_image', 'ref_file'),
                                         ('bold_file', 'in_file')]),
         (motion_estimation, outputnode, [
-         ('motcorr_params', 'motcorr_params')]),
+         ('csv_params', 'motcorr_params')]),
     ])
 
-    if slice_mc:
-        slice_mc_n_procs = int(local_threads/4)+1
+    if opts.apply_slice_mc:
+        slice_mc_n_procs = int(opts.local_threads/4)+1
         slice_mc_node = pe.Node(SliceMotionCorrection(n_procs=slice_mc_n_procs),
                                 name='slice_mc', mem_gb=1*slice_mc_n_procs, n_procs=slice_mc_n_procs)
         slice_mc_node.plugin_args = {
-            'qsub_args': '-pe smp %s' % (str(3*min_proc)), 'overwrite': True}
+            'qsub_args': '-pe smp %s' % (str(3*opts.min_proc)), 'overwrite': True}
 
         # conducting a volumetric realignment before slice-specific mc to correct for larger head translations and rotations
         workflow.connect([
@@ -68,43 +67,3 @@ def init_bold_hmc_wf(slice_mc=False, rabies_data_type=8, rabies_mem_scale=1.0, m
         ])
 
     return workflow
-
-
-class EstimateMotionInputSpec(BaseInterfaceInputSpec):
-    in_file = File(exists=True, mandatory=True, desc="4D EPI file")
-    ref_file = File(exists=True, mandatory=True,
-                    desc="Reference image to which timeseries are realigned for motion estimation")
-    rabies_data_type = traits.Int(mandatory=True,
-        desc="Integer specifying SimpleITK data type.")
-
-
-class EstimateMotionOutputSpec(TraitedSpec):
-    motcorr_params = File(
-        exists=True, desc="Motion estimation derived from antsMotionCorr")
-    mc_corrected_bold = File(exists=True, desc="motion corrected time series")
-
-
-class EstimateMotion(BaseInterface):
-    """
-    Runs ants motion correction interface and returns the motion estimation
-    """
-
-    input_spec = EstimateMotionInputSpec
-    output_spec = EstimateMotionOutputSpec
-
-    def _run_interface(self, runtime):
-        import os
-        from .utils import antsMotionCorr
-        res = antsMotionCorr(in_file=self.inputs.in_file,
-                             ref_file=self.inputs.ref_file, second=False, rabies_data_type=self.inputs.rabies_data_type).run()
-        csv_params = os.path.abspath(res.outputs.csv_params)
-
-        setattr(self, 'csv_params', csv_params)
-        setattr(self, 'mc_corrected_bold', os.path.abspath(
-            res.outputs.mc_corrected_bold))
-
-        return runtime
-
-    def _list_outputs(self):
-        return {'mc_corrected_bold': getattr(self, 'mc_corrected_bold'),
-                'motcorr_params': getattr(self, 'csv_params')}

rabies/preprocess_pkg/registration.py

@@ -3,7 +3,7 @@
 from nipype import Function
 
 
-def init_bold_reg_wf(coreg_script='SyN', rabies_data_type=8, rabies_mem_scale=1.0, min_proc=1, name='bold_reg_wf'):
+def init_bold_reg_wf(opts, name='bold_reg_wf'):
     """
     This workflow registers the reference BOLD image to anat-space, using
     antsRegistration, either applying Affine registration only, or the
@@ -55,11 +55,11 @@ def init_bold_reg_wf(coreg_script='SyN', rabies_data_type=8, rabies_mem_scale=1.
                                             "anat_mask", "rabies_data_type"],
                                output_names=['affine_bold2anat', 'warp_bold2anat',
                                              'inverse_warp_bold2anat', 'output_warped_bold'],
-                               function=run_antsRegistration), name='EPI_Coregistration', mem_gb=3*rabies_mem_scale)
-    run_reg.inputs.reg_method = coreg_script
-    run_reg.inputs.rabies_data_type = rabies_data_type
+                               function=run_antsRegistration), name='EPI_Coregistration', mem_gb=3*opts.scale_min_memory)
+    run_reg.inputs.reg_method = opts.coreg_script
+    run_reg.inputs.rabies_data_type = opts.data_type
     run_reg.plugin_args = {
-        'qsub_args': '-pe smp %s' % (str(3*min_proc)), 'overwrite': True}
+        'qsub_args': '-pe smp %s' % (str(3*opts.min_proc)), 'overwrite': True}
 
     workflow.connect([
         (inputnode, run_reg, [