Using lateral_ventricles_mask as the csf_mask when segmentation is off (#1656)

shnizzedy · web-flow · commit 7b7aee9a0dad · 2022-02-11T14:24:27.000-05:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -18,6 +18,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
     - `fslmaths`
     - `mri_vol2vol`
     - `recon-all`
+- Added ability to use lateral ventricles mask in place of Cerebrospinal Fluid mask when when Segmentation is Off, specifically for the Rodent pipeline, but works on any dataset when Segmentation is Off. 
 
 ### Changed
 - In a given pipeline configuration, segmentation probability maps and binary tissue masks are warped to template space, and those warped masks are included in the output directory
@@ -32,6 +33,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Fixed [bug](https://github.com/FCP-INDI/C-PAC/issues/1638) in which working connectivity matrix filepaths were generated incorrectly, preventing generating matrices depending on container bindings
 - Fixed broken links in README
 - Fixed [bug](https://github.com/FCP-INDI/C-PAC/issues/1575) in which anatomical-only configurations required functional data directories
+- Fixed [bug] (https://github.com/FCP-INDI/C-PAC/issues/1532) in which nuisance regressors runs when Segmentation is Off by using Lateral Ventricles Mask as the CSF mask. 
 
 ## [1.8.2] - 2021-12-02
 
diff --git a/CPAC/nuisance/nuisance.py b/CPAC/nuisance/nuisance.py
@@ -461,6 +461,7 @@ def gather_nuisance(functional_file_path,
 def create_regressor_workflow(nuisance_selectors,
                               use_ants,
                               ventricle_mask_exist,
+                              csf_mask_exist,
                               all_bold=False,
                               name='nuisance_regressors'):
     """
@@ -1129,6 +1130,7 @@ def create_regressor_workflow(nuisance_selectors,
                         pipeline_resource_pool,
                         tissue_regressor_descriptor,
                         regressor_selector,
+                        csf_mask_exist,
                         use_ants=use_ants,
                         ventricle_mask_exist=ventricle_mask_exist,
                         all_bold=all_bold
@@ -2176,9 +2178,13 @@ def nuisance_regressors_generation(wf, cfg, strat_pool, pipe_num, opt=None):
         use_ants = reg_tool == 'ants'
 
     ventricle = strat_pool.check_rpool('lateral-ventricles-mask')
+    csf_mask = strat_pool.check_rpool(["label-CSF_desc-eroded_mask",
+                                        "label-CSF_desc-preproc_mask",
+                                        "label-CSF_mask"])
 
     regressors = create_regressor_workflow(opt, use_ants,
                                            ventricle_mask_exist=ventricle,
+                                           csf_mask_exist = csf_mask,
                                            name='nuisance_regressors_'
                                                 f'{opt["Name"]}_{pipe_num}')
 
@@ -2578,10 +2584,14 @@ def nuisance_regressors_generation_EPItemplate(wf, cfg, strat_pool, pipe_num, op
 
     use_ants = reg_tool == 'ants'
     ventricle = strat_pool.check_rpool('lateral-ventricles-mask')
+    csf_mask = strat_pool.check_rpool(["space-bold_label-CSF_desc-eroded_mask",
+                                        "space-bold_label-CSF_desc-preproc_mask",
+                                        "space-bold_label-CSF_mask"])
 
     regressors = create_regressor_workflow(opt, use_ants,
                                            ventricle_mask_exist=ventricle,
                                            all_bold=True,
+                                            csf_mask_exist = csf_mask,
                                            name='nuisance_regressors_'
                                                 f'{opt["Name"]}_{pipe_num}')
 
diff --git a/CPAC/nuisance/utils/__init__.py b/CPAC/nuisance/utils/__init__.py
@@ -7,13 +7,16 @@
 import nipype.interfaces.utility as util
 from CPAC.pipeline import nipype_pipeline_engine as pe
 from nipype.interfaces import afni
+from nipype import logging
 
 from CPAC.nuisance.utils.compcor import calc_compcor_components
 from CPAC.nuisance.utils.crc import encode as crc_encode
 from CPAC.utils.interfaces.fsl import Merge as fslMerge
 from CPAC.utils.interfaces.function import Function
 from CPAC.registration.utils import check_transforms, generate_inverse_transform_flags
 
+logger = logging.getLogger('nipype.workflow')
+
 
 def find_offending_time_points(fd_j_file_path=None, fd_p_file_path=None, dvars_file_path=None,
                                fd_j_threshold=None, fd_p_threshold=None, dvars_threshold=None,
@@ -271,6 +274,7 @@ def generate_summarize_tissue_mask(nuisance_wf,
                                    pipeline_resource_pool,
                                    regressor_descriptor,
                                    regressor_selector,
+                                   csf_mask_exist,
                                    use_ants=True,
                                    ventricle_mask_exist=True,
                                    all_bold=False):
@@ -322,46 +326,46 @@ def generate_summarize_tissue_mask(nuisance_wf,
         
             if all_bold:
                 pass
-        
-            mask_to_epi = pe.Node(interface=fsl.FLIRT(),
-                                  name='{}_flirt'
-                                       .format(node_mask_key),
-                        mem_gb=3.63,
-                        mem_x=(3767129957844731 / 1208925819614629174706176,
-                               'in_file'))
-
-            mask_to_epi.inputs.interp = 'nearestneighbour'
-
-            if regressor_selector['extraction_resolution'] == "Functional":
-                # apply anat2func matrix
-                mask_to_epi.inputs.apply_xfm = True
-                mask_to_epi.inputs.output_type = 'NIFTI_GZ'
-                nuisance_wf.connect(*(
-                    pipeline_resource_pool['Functional_mean'] +
-                    (mask_to_epi, 'reference')
-                ))
-                nuisance_wf.connect(*(
-                    pipeline_resource_pool['Transformations']['anat_to_func_linear_xfm'] +
-                    (mask_to_epi, 'in_matrix_file')
-                ))
 
-            else:
-                resolution = regressor_selector['extraction_resolution']
-                mask_to_epi.inputs.apply_isoxfm = resolution
+            if csf_mask_exist:
+                mask_to_epi = pe.Node(interface=fsl.FLIRT(),
+                                name='{}_flirt'.format(node_mask_key),
+                                mem_gb=3.63,
+                                mem_x=(3767129957844731 / 1208925819614629174706176,
+                                    'in_file'))
+
+                mask_to_epi.inputs.interp = 'nearestneighbour'
+
+                if regressor_selector['extraction_resolution'] == "Functional":
+                    # apply anat2func matrix
+                    mask_to_epi.inputs.apply_xfm = True
+                    mask_to_epi.inputs.output_type = 'NIFTI_GZ'
+                    nuisance_wf.connect(*(
+                        pipeline_resource_pool['Functional_mean'] +
+                        (mask_to_epi, 'reference')
+                    ))
+                    nuisance_wf.connect(*(
+                        pipeline_resource_pool['Transformations']['anat_to_func_linear_xfm'] +
+                        (mask_to_epi, 'in_matrix_file')
+                    ))
 
-                nuisance_wf.connect(*(
-                    pipeline_resource_pool['Anatomical_{}mm'
+                else:
+                    resolution = regressor_selector['extraction_resolution']
+                    mask_to_epi.inputs.apply_isoxfm = resolution
+
+                    nuisance_wf.connect(*(
+                        pipeline_resource_pool['Anatomical_{}mm'
                                            .format(resolution)] +
-                    (mask_to_epi, 'reference')
-                ))
+                        (mask_to_epi, 'reference')
+                    ))
 
-            nuisance_wf.connect(*(
-                pipeline_resource_pool[prev_mask_key] +
-                (mask_to_epi, 'in_file')
-            ))
+                nuisance_wf.connect(*(
+                    pipeline_resource_pool[prev_mask_key] +
+                    (mask_to_epi, 'in_file')
+                ))
 
-            pipeline_resource_pool[mask_key] = \
-                (mask_to_epi, 'out_file')
+                pipeline_resource_pool[mask_key] = \
+                    (mask_to_epi, 'out_file')
 
             if full_mask_key.startswith('CerebrospinalFluid'):
                 pipeline_resource_pool = generate_summarize_tissue_mask_ventricles_masking(
@@ -370,6 +374,7 @@ def generate_summarize_tissue_mask(nuisance_wf,
                     regressor_descriptor,
                     regressor_selector,
                     node_mask_key,
+                    csf_mask_exist,
                     use_ants,
                     ventricle_mask_exist
                 )
@@ -389,27 +394,28 @@ def generate_summarize_tissue_mask(nuisance_wf,
             pipeline_resource_pool[mask_key] = \
                 (erode_mask_node, 'out_file')
 
-    return pipeline_resource_pool, full_mask_key
+    return pipeline_resource_pool, full_mask_key   
 
 
 def generate_summarize_tissue_mask_ventricles_masking(nuisance_wf,
                                                       pipeline_resource_pool,
                                                       regressor_descriptor,
                                                       regressor_selector,
                                                       mask_key,
+                                                      csf_mask_exist,
                                                       use_ants=True,
                                                       ventricle_mask_exist=True):
 
+    if csf_mask_exist == False:
+        logger.warning('Segmentation is Off, - therefore will be using '
+                        'lateral_ventricle_mask as CerebrospinalFluid_mask.')
+
     # Mask CSF with Ventricles
     if '{}_Unmasked'.format(mask_key) not in pipeline_resource_pool:
 
-        # reduce CSF mask to the lateral ventricles
-        mask_csf_with_lat_ven = pe.Node(interface=afni.Calc(outputtype='NIFTI_GZ'), name='{}_Ventricles'.format(mask_key))
-        mask_csf_with_lat_ven.inputs.expr = 'a*b'
-        mask_csf_with_lat_ven.inputs.out_file = 'csf_lat_ven_mask.nii.gz'
-
-        if ventricle_mask_exist :
+        if ventricle_mask_exist:
             ventricles_key = 'VentriclesToAnat'
+
             if 'resolution' in regressor_descriptor:
                 ventricles_key += '_{}'.format(regressor_descriptor['resolution'])
 
@@ -444,7 +450,20 @@ def generate_summarize_tissue_mask_ventricles_masking(nuisance_wf,
                     nuisance_wf.connect(collect_linear_transforms, 'out', lat_ven_mni_to_anat, 'transforms')
 
                     nuisance_wf.connect(*(pipeline_resource_pool['Ventricles'] + (lat_ven_mni_to_anat, 'input_image')))
-                    nuisance_wf.connect(*(pipeline_resource_pool[mask_key] + (lat_ven_mni_to_anat, 'reference_image')))
+                    resolution = regressor_selector['extraction_resolution']
+
+                    if csf_mask_exist:
+                        nuisance_wf.connect(*(
+                            pipeline_resource_pool[mask_key] +
+                            (lat_ven_mni_to_anat, 'reference_image')))
+                    elif resolution == 'Functional':
+                        nuisance_wf.connect(*(
+                            pipeline_resource_pool['Functional_mean'] +
+                            (lat_ven_mni_to_anat, 'reference_image')))
+                    else:
+                        nuisance_wf.connect(*(
+                            pipeline_resource_pool['Anatomical_{}mm'.format(resolution)] + 
+                            (lat_ven_mni_to_anat, 'reference_image')))
 
                     pipeline_resource_pool[ventricles_key] = (lat_ven_mni_to_anat, 'output_image')
 
@@ -460,17 +479,26 @@ def generate_summarize_tissue_mask_ventricles_masking(nuisance_wf,
 
                     pipeline_resource_pool[ventricles_key] = (lat_ven_mni_to_anat, 'out_file')
 
-            nuisance_wf.connect(*(pipeline_resource_pool[ventricles_key] + (mask_csf_with_lat_ven, 'in_file_a')))
-            nuisance_wf.connect(*(pipeline_resource_pool[mask_key] + (mask_csf_with_lat_ven, 'in_file_b')))
+            if csf_mask_exist:
+                # reduce CSF mask to the lateral ventricles
+                mask_csf_with_lat_ven = pe.Node(interface=afni.Calc(outputtype='NIFTI_GZ'),
+                                                name='{}_Ventricles'.format(mask_key))
+                mask_csf_with_lat_ven.inputs.expr = 'a*b'
+                mask_csf_with_lat_ven.inputs.out_file = 'csf_lat_ven_mask.nii.gz'
+
+                nuisance_wf.connect(*(pipeline_resource_pool[ventricles_key] + (mask_csf_with_lat_ven, 'in_file_a')))
+                nuisance_wf.connect(*(pipeline_resource_pool[mask_key] + (mask_csf_with_lat_ven, 'in_file_b')))
 
-            pipeline_resource_pool['{}_Unmasked'.format(mask_key)] = pipeline_resource_pool[mask_key]
-            pipeline_resource_pool[mask_key] = (mask_csf_with_lat_ven, 'out_file')
-        else :
-            pipeline_resource_pool['{}_Unmasked'.format(mask_key)] = pipeline_resource_pool[mask_key]
+                pipeline_resource_pool['{}_Unmasked'.format(mask_key)] = pipeline_resource_pool[mask_key]
+                pipeline_resource_pool[mask_key] = (mask_csf_with_lat_ven, 'out_file')
 
+            else:
+                pipeline_resource_pool[mask_key] = pipeline_resource_pool[ventricles_key]
+        
         return pipeline_resource_pool
 
 
+
 class NuisanceRegressor(object):
 
     def __init__(self, selector):
@@ -579,7 +607,7 @@ def encode(selector):
                     res = "%.2gmm" % s['extraction_resolution']
                     if s.get('erode_mask'):
                         res += 'E'
-                    pieces += [res]
+                    pieces += [res]      
 
                 pieces += [NuisanceRegressor._summary_params(s)]
                 pieces += [NuisanceRegressor._derivative_params(s)]
