Merge branch 'develop' into enh/desc-preproc_names

Author: sgiavasis

CHANGELOG.md

@@ -21,6 +21,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Added the ability to ingress TotalReadoutTime from epi field map meta-data from the JSON sidecars.
 - Added the ability to use TotalReadoutTime of epi field maps in the calculation of FSL topup distortion correction.
 - Difference method (``-``) for ``CPAC.utils.configuration.Configuration`` instances
+- Calculate reho and alff when timeseries in template space
 
 ### Changed
 - Added a level of depth to `working` directories to match `log` and `output` directory structure

CPAC/alff/alff.py

@@ -273,3 +273,38 @@ def alff_falff(wf, cfg, strat_pool, pipe_num, opt=None):
     }
 
     return (wf, outputs)
+
+def alff_falff_space_template(wf, cfg, strat_pool, pipe_num, opt=None):
+    '''
+    {"name": "alff_falff_space_template",
+     "config": ["amplitude_low_frequency_fluctuation"],
+     "switch": ["run"],
+     "option_key": "None",
+     "option_val": "None",
+     "inputs": [["space-template_desc-denoisedNofilt_bold"],
+                "space-template_desc-bold_mask"],
+     "outputs": ["space-template_alff",
+                 "space-template_falff"]}
+    '''
+
+    alff = create_alff(f'alff_falff_{pipe_num}')
+
+    alff.inputs.hp_input.hp = \
+        cfg.amplitude_low_frequency_fluctuation['highpass_cutoff']
+    alff.inputs.lp_input.lp = \
+        cfg.amplitude_low_frequency_fluctuation['lowpass_cutoff']
+    alff.get_node('hp_input').iterables = ('hp', alff.inputs.hp_input.hp)
+    alff.get_node('lp_input').iterables = ('lp', alff.inputs.lp_input.lp)
+
+    node, out = strat_pool.get_data(["space-template_desc-denoisedNofilt_bold"])
+    wf.connect(node, out, alff, 'inputspec.rest_res')
+
+    node, out = strat_pool.get_data("space-template_desc-bold_mask")
+    wf.connect(node, out, alff, 'inputspec.rest_mask')
+
+    outputs = {
+        'space-template_alff': (alff, 'outputspec.alff_img'),
+        'space-template_falff': (alff, 'outputspec.falff_img')
+    }
+
+    return (wf, outputs)

CPAC/nuisance/nuisance.py

@@ -2534,7 +2534,6 @@ def nuisance_regression(wf, cfg, strat_pool, pipe_num, opt, space):
         outputs = {
             desc_keys[0]: (nuis, 'outputspec.residual_file_path'),
             desc_keys[1]: (nuis, 'outputspec.residual_file_path'),
-            desc_keys[2]: (nuis, 'outputspec.residual_file_path')
         }
 
     return (wf, outputs)
@@ -2589,13 +2588,10 @@ def nuisance_regression_template(wf, cfg, strat_pool, pipe_num, opt=None):
                  "dvars"),
                 "TR"],
      "outputs": {"space-template_desc-preproc_bold": {
-        "Description": "Preprocessed BOLD image that was nuisance-"
+        "Description": "Preprocessed BOLD image that was nusiance-"
                        "regressed in template space"},
                  "space-template_desc-cleaned_bold": {
-        "Description": "Preprocessed BOLD image that was nuisance-"
-                       "regressed in template space"},
-                 "space-template_desc-denoisedNofilt_bold": {
-        "Description": "Preprocessed BOLD image that was nuisance-"
+        "Description": "Preprocessed BOLD image that was nusiance-"
                        "regressed in template space"},
                  "regressors": {
         "Description": "Regressors that were applied in template space"}}}

CPAC/pipeline/cpac_pipeline.py

@@ -102,6 +102,7 @@
     warp_bold_mean_to_T1template,
     warp_bold_mask_to_T1template,
     warp_deriv_mask_to_T1template,
+    warp_denoiseNofilt_to_T1template,
     warp_timeseries_to_EPItemplate,
     warp_bold_mean_to_EPItemplate,
     warp_bold_mask_to_EPItemplate,
@@ -183,8 +184,8 @@
     multiple_regression
 )
 
-from CPAC.alff.alff import alff_falff
-from CPAC.reho.reho import reho
+from CPAC.alff.alff import alff_falff, alff_falff_space_template
+from CPAC.reho.reho import reho, reho_space_template
 
 from CPAC.vmhc.vmhc import (
     smooth_func_vmhc,
@@ -1281,6 +1282,10 @@ def build_workflow(subject_id, sub_dict, cfg, pipeline_name=None,
     if not rpool.check_rpool('space-template_desc-bold_mask'):
         pipeline_blocks += [warp_bold_mask_to_T1template,
                             warp_deriv_mask_to_T1template]
+        
+    target_space_alff = cfg.amplitude_low_frequency_fluctuation['target_space']
+    if 'Template' in target_space_alff and not rpool.check_rpool('space-template_desc-denoisedNofilt_bold'):
+        pipeline_blocks += [warp_denoiseNofilt_to_T1template]
 
     template = cfg.registration_workflows['functional_registration']['func_registration_to_template']['target_template']['using']
 
@@ -1323,6 +1328,7 @@ def build_workflow(subject_id, sub_dict, cfg, pipeline_name=None,
     tse_atlases, sca_atlases = gather_extraction_maps(cfg)
     cfg.timeseries_extraction['tse_atlases'] = tse_atlases
     cfg.seed_based_correlation_analysis['sca_atlases'] = sca_atlases
+    target_space_reho = cfg.regional_homogeneity['target_space']
 
     if not rpool.check_rpool('desc-Mean_timeseries') and \
                     'Avg' in tse_atlases:
@@ -1348,11 +1354,21 @@ def build_workflow(subject_id, sub_dict, cfg, pipeline_name=None,
                     'MultReg' in sca_atlases:
         pipeline_blocks += [multiple_regression]
 
-    if not rpool.check_rpool('alff'):
-        pipeline_blocks += [alff_falff]
-
-    if not rpool.check_rpool('reho'):
-        pipeline_blocks += [reho]
+    if 'Native' in target_space_alff:
+        if not rpool.check_rpool('alff'):
+            pipeline_blocks += [alff_falff]
+
+    if 'Template' in target_space_alff:
+        if not rpool.check_rpool('space-template_alff'):
+            pipeline_blocks += [alff_falff_space_template]
+
+    if 'Native' in target_space_reho:
+        if not rpool.check_rpool('reho'):
+            pipeline_blocks += [reho]
+            
+    if 'Template' in target_space_reho:
+        if not rpool.check_rpool('space-template_reho'):
+            pipeline_blocks += [reho_space_template]
 
     if not rpool.check_rpool('vmhc'):
         pipeline_blocks += [smooth_func_vmhc,

CPAC/pipeline/engine.py

@@ -88,8 +88,10 @@ def __init__(self, rpool=None, name=None, cfg=None, pipe_list=None):
 
             self.run_smoothing = 'smoothed' in cfg.post_processing[
                 'spatial_smoothing']['output']
+            self.smoothing_bool = cfg.post_processing['spatial_smoothing']['run']
             self.run_zscoring = 'z-scored' in cfg.post_processing[
                 'z-scoring']['output']
+            self.zscoring_bool = cfg.post_processing['z-scoring']['run']
             self.fwhm = cfg.post_processing['spatial_smoothing']['fwhm']
             self.smooth_opts = cfg.post_processing['spatial_smoothing'][
                 'smoothing_method']
@@ -697,7 +699,7 @@ def post_process(self, wf, label, connection, json_info, pipe_idx, pipe_x,
                     mask_idx = self.generate_prov_string(mask_prov)[1]
                     break
 
-        if self.run_smoothing:
+        if self.smoothing_bool:
             if label in Outputs.to_smooth:
                 for smooth_opt in self.smooth_opts:
 
@@ -736,7 +738,7 @@ def post_process(self, wf, label, connection, json_info, pipe_idx, pipe_x,
                                   pipe_idx, f'spatial_smoothing_{smooth_opt}',
                                   fork=True)
 
-        if self.run_zscoring:            
+        if self.zscoring_bool:            
             for label_con_tpl in post_labels:
                 label = label_con_tpl[0]
                 connection = (label_con_tpl[1], label_con_tpl[2])

CPAC/pipeline/schema.py

@@ -96,7 +96,8 @@
                 str, {'components': int, 'method': str}
             ),
         },
-    }
+    },
+    'target_space': ['Native', 'Template']
 }
 mutex = {  # mutually exclusive booleans
     'FSL-BET': {
@@ -823,6 +824,7 @@ def sanitize(filename):
     },
     'amplitude_low_frequency_fluctuation': {
         'run': bool,
+        'target_space': [In(valid_options['target_space'])],
         'highpass_cutoff': [float],
         'lowpass_cutoff': [float],
     },
@@ -839,15 +841,18 @@ def sanitize(filename):
     },
     'regional_homogeneity': {
         'run': bool,
+        'target_space': [In(valid_options['target_space'])],
         'cluster_size': In({7, 19, 27}),
     },
     'post_processing': {
         'spatial_smoothing': {
+            'run': bool,
             'output': [In({'smoothed', 'nonsmoothed'})],
             'smoothing_method': [In({'FSL', 'AFNI'})],
             'fwhm': [int]
         },
         'z-scoring': {
+            'run': bool,
             'output': [In({'z-scored', 'raw'})],
         },
     },

CPAC/registration/registration.py

@@ -3651,10 +3651,63 @@ def warp_timeseries_to_T1template_dcan_nhp(wf, cfg, strat_pool, pipe_num, opt=No
 
     return (wf, outputs)
 
+def warp_denoiseNofilt_to_T1template(wf, cfg, strat_pool, pipe_num, opt=None):
+    '''
+    Node Block:
+    {"name": "transform_denoisedNofilt_to_T1template",
+     "config": ["amplitude_low_frequency_fluctuation"],
+     "switch": ["run"],
+     "option_key": ["target_space"],
+     "option_val": "Template",
+     "inputs": [(["desc-denoisedNofilt_bold"],
+                 "from-bold_to-template_mode-image_xfm"),
+                "T1w-brain-template-funcreg"],
+     "outputs": ["space-template_desc-denoisedNofilt_bold"]}
+    '''
+
+    xfm_prov = strat_pool.get_cpac_provenance(
+        'from-bold_to-template_mode-image_xfm')
+    reg_tool = check_prov_for_regtool(xfm_prov)
+
+    num_cpus = cfg.pipeline_setup['system_config'][
+        'max_cores_per_participant']
+
+    num_ants_cores = cfg.pipeline_setup['system_config']['num_ants_threads']
+
+    apply_xfm = apply_transform(f'warp_denoisedNofilt_to_T1template_{pipe_num}', reg_tool,
+                                time_series=True, num_cpus=num_cpus,
+                                num_ants_cores=num_ants_cores)
+
+    if reg_tool == 'ants':
+        apply_xfm.inputs.inputspec.interpolation = cfg.registration_workflows[
+            'functional_registration']['func_registration_to_template'][
+            'ANTs_pipelines']['interpolation']
+    elif reg_tool == 'fsl':
+        apply_xfm.inputs.inputspec.interpolation = cfg.registration_workflows[
+            'functional_registration']['func_registration_to_template'][
+            'FNIRT_pipelines']['interpolation']
+
+    connect, resource = strat_pool.get_data(["desc-denoisedNofilt_bold"],
+                                            report_fetched=True)
+    node, out = connect
+    wf.connect(node, out, apply_xfm, 'inputspec.input_image')
+
+    node, out = strat_pool.get_data("T1w-brain-template-funcreg")
+    wf.connect(node, out, apply_xfm, 'inputspec.reference')
+
+    node, out = strat_pool.get_data("from-bold_to-template_mode-image_xfm")
+    wf.connect(node, out, apply_xfm, 'inputspec.transform')
+
+    outputs = {
+        f'space-template_{resource}': (apply_xfm, 'outputspec.output_image')
+    }
+
+    return (wf, outputs)
+
 
 def single_step_resample_timeseries_to_T1template(wf, cfg, strat_pool,
                                                   pipe_num, opt=None):
-    """
+    '''
     Apply motion correction, coreg, anat-to-template transforms on
     slice-time corrected functional timeseries based on fMRIPrep
     pipeline
@@ -3713,7 +3766,7 @@ def single_step_resample_timeseries_to_T1template(wf, cfg, strat_pool,
      "outputs": ["space-template_desc-preproc_bold",
                  "space-template_desc-brain_bold",
                  "space-template_desc-bold_mask"]}
-    """  # noqa: 501
+    '''  # noqa: 501
     bbr2itk = pe.Node(util.Function(input_names=['reference_file',
                                                  'source_file',
                                                  'transform_file'],

CPAC/reho/reho.py

@@ -147,3 +147,43 @@ def reho(wf, cfg, strat_pool, pipe_num, opt=None):
     }
 
     return (wf, outputs)
+
+
+def reho_space_template(wf, cfg, strat_pool, pipe_num, opt=None):
+    '''
+    {"name": "ReHo_space_template",
+     "config": ["regional_homogeneity"],
+     "switch": ["run"],
+     "option_key": "None",
+     "option_val": "None",
+     "inputs": [["space-template_desc-cleaned_bold", "space-template_desc-brain_bold",
+                 "space-template_desc-preproc_bold", "space-template_bold"],
+                "space-template_desc-bold_mask"],
+     "outputs": ["space-template_reho"]}
+    '''
+
+    cluster_size = cfg.regional_homogeneity['cluster_size']
+
+    # Check the cluster size is supported
+    if cluster_size not in [7, 19, 27]:
+        err_msg = 'Cluster size specified: %d, is not ' \
+                  'supported. Change to 7, 19, or 27 and try ' \
+                  'again' % cluster_size
+        raise Exception(err_msg)
+
+    reho = create_reho(f'reho_{pipe_num}')
+    reho.inputs.inputspec.cluster_size = cluster_size
+
+
+    node, out = strat_pool.get_data(["space-template_desc-cleaned_bold", "space-template_desc-brain_bold",
+                                     "space-template_desc-preproc_bold", "space-template_bold"])
+    wf.connect(node, out, reho, 'inputspec.rest_res_filt')
+
+    node, out_file = strat_pool.get_data('space-template_desc-bold_mask')
+    wf.connect(node, out_file, reho, 'inputspec.rest_mask')
+
+    outputs = {
+        'space-template_reho': (reho, 'outputspec.raw_reho_map')
+    }
+
+    return (wf, outputs)

CPAC/resources/configs/pipeline_config_default.yml

@@ -1472,6 +1472,8 @@ post_processing:
 
   spatial_smoothing:
 
+    run: On
+
     # Smooth the derivative outputs.
     # Set as ['nonsmoothed'] to disable smoothing. Set as ['smoothed', 'nonsmoothed'] to get both.
     #
@@ -1491,6 +1493,8 @@ post_processing:
 
   z-scoring:
 
+    run: On
+
     # z-score standardize the derivatives. This may be needed for group-level analysis.
     # Set as ['raw'] to disable z-scoring. Set as ['z-scored', 'raw'] to get both.
     #
@@ -1593,6 +1597,9 @@ amplitude_low_frequency_fluctuation:
   # Calculate Amplitude of Low Frequency Fluctuations (ALFF) and fractional ALFF (f/ALFF) for all voxels.
   run: On
 
+  # space: Template or Native
+  target_space: ['Native']
+
   # Frequency cutoff (in Hz) for the high-pass filter used when calculating f/ALFF.
   highpass_cutoff: [0.01]
 
@@ -1606,6 +1613,9 @@ regional_homogeneity:
   # Calculate Regional Homogeneity (ReHo) for all voxels.
   run: On
 
+  # space: Template or Native
+  target_space: ['Native']
+
   # Number of neighboring voxels used when calculating ReHo
   # 7 (Faces)
   # 19 (Faces + Edges)