def fmri_qc_workflow(dataset, settings, name='funcMRIQC'):
"""
The fMRI qc workflow
.. workflow::
import os.path as op
from mriqc.workflows.functional import fmri_qc_workflow
datadir = op.abspath('data')
wf = fmri_qc_workflow([op.join(datadir, 'sub-001/func/sub-001_task-rest_bold.nii.gz')],
settings={'bids_dir': datadir,
'output_dir': op.abspath('out'),
'no_sub': True})
"""
workflow = pe.Workflow(name=name)
biggest_file_gb = settings.get("biggest_file_size_gb", 1)
# Define workflow, inputs and outputs
# 0. Get data, put it in RAS orientation
inputnode = pe.Node(niu.IdentityInterface(fields=['in_file']),
name='inputnode')
WFLOGGER.info(
'Building fMRI QC workflow, datasets list: %s',
sorted([d.replace(settings['bids_dir'] + '/', '') for d in dataset]))
inputnode.iterables = [('in_file', dataset)]
outputnode = pe.Node(niu.IdentityInterface(
fields=['qc', 'mosaic', 'out_group', 'out_dvars', 'out_fd']),
name='outputnode')
non_steady_state_detector = pe.Node(nac.NonSteadyStateDetector(),
name="non_steady_state_detector")
sanitize = pe.Node(niutils.SanitizeImage(),
name="sanitize",
mem_gb=biggest_file_gb * 4.0)
sanitize.inputs.max_32bit = settings.get("float32", DEFAULTS['float32'])
# Workflow --------------------------------------------------------
# 1. HMC: head motion correct
if settings.get('hmc_fsl', False):
hmcwf = hmc_mcflirt(settings)
else:
hmcwf = hmc_afni(settings,
st_correct=settings.get('correct_slice_timing',
False),
despike=settings.get('despike', False),
deoblique=settings.get('deoblique', False),
start_idx=settings.get('start_idx', None),
stop_idx=settings.get('stop_idx', None))
# Set HMC settings
hmcwf.inputs.inputnode.fd_radius = settings.get('fd_radius',
DEFAULT_FD_RADIUS)
mean = pe.Node(
afni.TStat( # 2. Compute mean fmri
options='-mean', outputtype='NIFTI_GZ'),
name='mean',
mem_gb=biggest_file_gb * 1.5)
skullstrip_epi = fmri_bmsk_workflow(use_bet=True)
# EPI to MNI registration
ema = epi_mni_align(settings)
# Compute TSNR using nipype implementation
tsnr = pe.Node(nac.TSNR(),
name='compute_tsnr',
mem_gb=biggest_file_gb * 4.5)
# 7. Compute IQMs
iqmswf = compute_iqms(settings)
# Reports
repwf = individual_reports(settings)
workflow.connect([
(inputnode, iqmswf, [('in_file', 'inputnode.in_file')]),
(inputnode, sanitize, [('in_file', 'in_file')]),
(inputnode, non_steady_state_detector, [('in_file', 'in_file')]),
(non_steady_state_detector, sanitize, [('n_volumes_to_discard',
'n_volumes_to_discard')]),
(sanitize, hmcwf, [('out_file', 'inputnode.in_file')]),
(mean, skullstrip_epi, [('out_file', 'inputnode.in_file')]),
(hmcwf, mean, [('outputnode.out_file', 'in_file')]),
(hmcwf, tsnr, [('outputnode.out_file', 'in_file')]),
(mean, ema, [('out_file', 'inputnode.epi_mean')]),
(skullstrip_epi, ema, [('outputnode.out_file', 'inputnode.epi_mask')]),
(sanitize, iqmswf, [('out_file', 'inputnode.in_ras')]),
(mean, iqmswf, [('out_file', 'inputnode.epi_mean')]),
(hmcwf, iqmswf, [('outputnode.out_file', 'inputnode.hmc_epi'),
('outputnode.out_fd', 'inputnode.hmc_fd')]),
(skullstrip_epi, iqmswf, [('outputnode.out_file',
'inputnode.brainmask')]),
(tsnr, iqmswf, [('tsnr_file', 'inputnode.in_tsnr')]),
(sanitize, repwf, [('out_file', 'inputnode.in_ras')]),
(mean, repwf, [('out_file', 'inputnode.epi_mean')]),
(tsnr, repwf, [('stddev_file', 'inputnode.in_stddev')]),
(skullstrip_epi, repwf, [('outputnode.out_file', 'inputnode.brainmask')
]),
(hmcwf, repwf, [('outputnode.out_fd', 'inputnode.hmc_fd'),
('outputnode.out_file', 'inputnode.hmc_epi')]),
(ema, repwf, [('outputnode.epi_parc', 'inputnode.epi_parc'),
('outputnode.report', 'inputnode.mni_report')]),
(non_steady_state_detector, iqmswf, [('n_volumes_to_discard',
'inputnode.exclude_index')]),
(iqmswf, repwf, [('outputnode.out_file', 'inputnode.in_iqms'),
('outputnode.out_dvars', 'inputnode.in_dvars'),
('outputnode.outliers', 'inputnode.outliers')]),
(hmcwf, outputnode, [('outputnode.out_fd', 'out_fd')]),
])
if settings.get('fft_spikes_detector', False):
workflow.connect([
(iqmswf, repwf, [('outputnode.out_spikes', 'inputnode.in_spikes'),
('outputnode.out_fft', 'inputnode.in_fft')]),
])
if settings.get('ica', False):
melodic = pe.Node(nws.MELODICRPT(no_bet=True,
no_mask=True,
no_mm=True,
generate_report=True),
name="ICA",
mem_gb=biggest_file_gb * 5)
workflow.connect([(sanitize, melodic, [('out_file', 'in_files')]),
(skullstrip_epi, melodic, [('outputnode.out_file',
'report_mask')]),
(melodic, repwf, [('out_report',
'inputnode.ica_report')])])
# Upload metrics
if not settings.get('no_sub', False):
from ..interfaces.webapi import UploadIQMs
upldwf = pe.Node(UploadIQMs(), name='UploadMetrics')
upldwf.inputs.url = settings.get('webapi_url')
if settings.get('webapi_port'):
upldwf.inputs.port = settings.get('webapi_port')
upldwf.inputs.email = settings.get('email')
upldwf.inputs.strict = settings.get('upload_strict', False)
workflow.connect([
(iqmswf, upldwf, [('outputnode.out_file', 'in_iqms')]),
])
return workflow
def init_bold_confs_wf(bold_file_size_gb,
use_aroma,
ignore_aroma_err,
metadata,
name="bold_confs_wf"):
"""
This workflow calculates confounds for a BOLD series, and aggregates them
into a :abbr:`TSV (tab-separated value)` file, for use as nuisance
regressors in a :abbr:`GLM (general linear model)`.
The following confounds are calculated, with column headings in parentheses:
#. White matter / global signals (WhiteMatter, GlobalSignal)
#. DVARS - standard, nonstandard, and voxel-wise standard variants
(stdDVARS, non-stdDVARS, vx-wisestdDVARS)
#. Framewise displacement, based on MCFLIRT motion parameters (FramewiseDisplacement)
#. tCompCor
#. aCompCor
#. Cosine basis set for high-pass filtering w/ 0.008 Hz cut-off (CosineXX)
#. Non-steady-state volumes (NonSteadyStateXX)
#. MCFLIRT motion parameters, in mm and rad (X, Y, Z, RotX, RotY, RotZ)
#. ICA-AROMA-identified noise components, if enabled (AROMAAggrCompXX)
Prior to estimating aCompCor and tCompCor, non-steady-state volumes are
censored and high-pass filtered using a :abbr:`DCT (discrete cosine
transform)` basis.
The cosine basis, as well as one regressor per censored volume, are included
for convenience.
.. workflow::
:graph2use: orig
:simpleform: yes
from fmriprep.workflows.confounds import init_bold_confs_wf
wf = init_bold_confs_wf(bold_file_size_gb=1,
use_aroma=True,
ignore_aroma_err=True,
metadata={})
Parameters
bold_file_size_gb : float
Size of BOLD file in GB
use_aroma : bool
Perform ICA-AROMA on MNI-resampled functional series
ignore_aroma_err : bool
Do not fail on ICA-AROMA errors
metadata : dict
BIDS metadata for BOLD file
Inputs
bold_t1
BOLD image, resampled in T1w space
movpar_file
SPM-formatted motion parameters file
t1_mask
Mask of the skull-stripped template image
t1_tpms
List of tissue probability maps in T1w space
bold_mask_t1
BOLD series mask in T1w space
bold_mni
BOLD series, resampled to template space
bold_mask_mni
BOLD series mask in template space
Outputs
confounds_file
TSV of all aggregated confounds
confounds_list
List of calculated confounds for reporting
acompcor_report
Reportlet visualizing white-matter/CSF mask used for aCompCor
tcompcor_report
Reportlet visualizing ROI identified in tCompCor
ica_aroma_report
Reportlet visualizing MELODIC ICs, with ICA-AROMA signal/noise labels
aroma_noise_ics
CSV of noise components identified by ICA-AROMA
melodic_mix
FSL MELODIC mixing matrix
nonaggr_denoised_file
BOLD series with non-aggressive ICA-AROMA denoising applied
"""
inputnode = pe.Node(niu.IdentityInterface(fields=[
'bold_t1', 'movpar_file', 't1_mask', 't1_tpms', 'bold_mask_t1',
'bold_mni', 'bold_mask_mni'
]),
name='inputnode')
outputnode = pe.Node(niu.IdentityInterface(fields=[
'confounds_file', 'confounds_list', 'acompcor_report',
'tcompcor_report', 'ica_aroma_report', 'aroma_noise_ics',
'melodic_mix', 'nonaggr_denoised_file'
]),
name='outputnode')
# ICA-AROMA
if use_aroma:
ica_aroma_wf = init_ica_aroma_wf(name='ica_aroma_wf',
ignore_aroma_err=ignore_aroma_err)
# DVARS
dvars = pe.Node(nac.ComputeDVARS(save_all=True, remove_zerovariance=True),
name="dvars",
mem_gb=bold_file_size_gb * 3)
# Frame displacement
fdisp = pe.Node(nac.FramewiseDisplacement(parameter_source="SPM"),
name="fdisp",
mem_gb=bold_file_size_gb * 3)
# CompCor
non_steady_state = pe.Node(nac.NonSteadyStateDetector(),
name='non_steady_state')
tcompcor = pe.Node(TCompCorRPT(components_file='tcompcor.tsv',
generate_report=True,
pre_filter='cosine',
save_pre_filter=True,
percentile_threshold=.05),
name="tcompcor",
mem_gb=bold_file_size_gb * 3)
acompcor = pe.Node(ACompCorRPT(components_file='acompcor.tsv',
pre_filter='cosine',
save_pre_filter=True,
generate_report=True),
name="acompcor",
mem_gb=bold_file_size_gb * 3)
csf_roi = pe.Node(TPM2ROI(erode_mm=0, mask_erode_mm=30), name='csf_roi')
wm_roi = pe.Node(TPM2ROI(erode_mm=6, mask_erode_mm=10), name='wm_roi')
merge_rois = pe.Node(niu.Merge(2),
name='merge_rois',
run_without_submitting=True,
mem_gb=0.01)
combine_rois = pe.Node(CombineROIs(), name='combine_rois')
concat_rois = pe.Node(ConcatROIs(), name='concat_rois')
# Global and segment regressors
signals = pe.Node(SignalExtraction(
detrend=True, class_labels=["WhiteMatter", "GlobalSignal"]),
name="signals",
mem_gb=bold_file_size_gb * 3)
# Arrange confounds
add_header = pe.Node(
AddTSVHeader(columns=["X", "Y", "Z", "RotX", "RotY", "RotZ"]),
name="add_header",
mem_gb=0.01,
run_without_submitting=True)
concat = pe.Node(GatherConfounds(),
name="concat",
mem_gb=0.01,
run_without_submitting=True)
# Set TR if present
if 'RepetitionTime' in metadata:
tcompcor.inputs.repetition_time = metadata['RepetitionTime']
acompcor.inputs.repetition_time = metadata['RepetitionTime']
def _pick_csf(files):
return files[0]
def _pick_wm(files):
return files[2]
workflow = pe.Workflow(name=name)
workflow.connect([
# connect inputnode to each non-anatomical confound node
(inputnode, dvars, [('bold_t1', 'in_file'),
('bold_mask_t1', 'in_mask')]),
(inputnode, fdisp, [('movpar_file', 'in_file')]),
(inputnode, non_steady_state, [('bold_t1', 'in_file')]),
(inputnode, tcompcor, [('bold_t1', 'realigned_file')]),
(non_steady_state, tcompcor, [('n_volumes_to_discard',
'ignore_initial_volumes')]),
(non_steady_state, acompcor, [('n_volumes_to_discard',
'ignore_initial_volumes')]),
(inputnode, csf_roi, [(('t1_tpms', _pick_csf), 't1_tpm'),
('t1_mask', 't1_mask'),
('bold_mask_t1', 'bold_mask')]),
(csf_roi, tcompcor, [('eroded_mask', 'mask_files')]),
(inputnode, wm_roi, [(('t1_tpms', _pick_wm), 't1_tpm'),
('t1_mask', 't1_mask'),
('bold_mask_t1', 'bold_mask')]),
(csf_roi, merge_rois, [('roi_file', 'in1')]),
(wm_roi, merge_rois, [('roi_file', 'in2')]),
(merge_rois, combine_rois, [('out', 'in_files')]),
(inputnode, combine_rois, [('bold_t1', 'ref_header')]),
# anatomical confound: aCompCor.
(inputnode, acompcor, [('bold_t1', 'realigned_file')]),
(combine_rois, acompcor, [('out_file', 'mask_files')]),
(wm_roi, concat_rois, [('roi_file', 'in_file')]),
(inputnode, concat_rois, [('bold_mask_t1', 'in_mask')]),
(inputnode, concat_rois, [('bold_t1', 'ref_header')]),
# anatomical confound: signal extraction
(concat_rois, signals, [('out_file', 'label_files')]),
(inputnode, signals, [('bold_t1', 'in_file')]),
# connect the confound nodes to the concatenate node
(inputnode, add_header, [('movpar_file', 'in_file')]),
(signals, concat, [('out_file', 'signals')]),
(dvars, concat, [('out_all', 'dvars')]),
(fdisp, concat, [('out_file', 'fd')]),
(tcompcor, concat, [('components_file', 'tcompcor'),
('pre_filter_file', 'cos_basis')]),
(acompcor, concat, [('components_file', 'acompcor')]),
(add_header, concat, [('out_file', 'motion')]),
(concat, outputnode, [('confounds_file', 'confounds_file'),
('confounds_list', 'confounds_list')]),
(acompcor, outputnode, [('out_report', 'acompcor_report')]),
(tcompcor, outputnode, [('out_report', 'tcompcor_report')]),
])
if use_aroma:
workflow.connect([
(inputnode, ica_aroma_wf,
[('bold_mni', 'inputnode.bold_mni'),
('bold_mask_mni', 'inputnode.bold_mask_mni'),
('movpar_file', 'inputnode.movpar_file')]),
(ica_aroma_wf, concat, [('outputnode.aroma_confounds', 'aroma')]),
(ica_aroma_wf, outputnode,
[('outputnode.out_report', 'ica_aroma_report'),
('outputnode.aroma_noise_ics', 'aroma_noise_ics'),
('outputnode.melodic_mix', 'melodic_mix'),
('outputnode.nonaggr_denoised_file', 'nonaggr_denoised_file')])
])
return workflow
def init_bold_confs_wf(mem_gb, use_aroma, ignore_aroma_err, metadata,
name="bold_confs_wf"):
"""
This workflow calculates confounds for a BOLD series, and aggregates them
into a :abbr:`TSV (tab-separated value)` file, for use as nuisance
regressors in a :abbr:`GLM (general linear model)`.
The following confounds are calculated, with column headings in parentheses:
#. Region-wise average signal (``CSF``, ``WhiteMatter``, ``GlobalSignal``)
#. DVARS - standard, nonstandard, and voxel-wise standard variants
(``stdDVARS``, ``non-stdDVARS``, ``vx-wisestdDVARS``)
#. Framewise displacement, based on MCFLIRT motion parameters
(``FramewiseDisplacement``)
#. Temporal CompCor (``tCompCorXX``)
#. Anatomical CompCor (``aCompCorXX``)
#. Cosine basis set for high-pass filtering w/ 0.008 Hz cut-off
(``CosineXX``)
#. Non-steady-state volumes (``NonSteadyStateXX``)
#. Estimated head-motion parameters, in mm and rad
(``X``, ``Y``, ``Z``, ``RotX``, ``RotY``, ``RotZ``)
#. ICA-AROMA-identified noise components, if enabled
(``AROMAAggrCompXX``)
Prior to estimating aCompCor and tCompCor, non-steady-state volumes are
censored and high-pass filtered using a :abbr:`DCT (discrete cosine
transform)` basis.
The cosine basis, as well as one regressor per censored volume, are included
for convenience.
.. workflow::
:graph2use: orig
:simple_form: yes
from fmriprep.workflows.bold.confounds import init_bold_confs_wf
wf = init_bold_confs_wf(
mem_gb=1,
use_aroma=True,
ignore_aroma_err=True,
metadata={})
**Parameters**
mem_gb : float
Size of BOLD file in GB - please note that this size
should be calculated after resamplings that may extend
the FoV
use_aroma : bool
Perform ICA-AROMA on MNI-resampled functional series
ignore_aroma_err : bool
Do not fail on ICA-AROMA errors
metadata : dict
BIDS metadata for BOLD file
**Inputs**
bold
BOLD image, after the prescribed corrections (STC, HMC and SDC)
when available.
bold_mask
BOLD series mask
movpar_file
SPM-formatted motion parameters file
t1_mask
Mask of the skull-stripped template image
t1_tpms
List of tissue probability maps in T1w space
t1_bold_xform
Affine matrix that maps the T1w space into alignment with
the native BOLD space
bold_mni
BOLD image resampled in MNI space (only if ``use_aroma`` enabled)
bold_mask_mni
Brain mask corresponding to the BOLD image resampled in MNI space
(only if ``use_aroma`` enabled)
**Outputs**
confounds_file
TSV of all aggregated confounds
confounds_list
List of calculated confounds for reporting
acompcor_report
Reportlet visualizing white-matter/CSF mask used for aCompCor
tcompcor_report
Reportlet visualizing ROI identified in tCompCor
ica_aroma_report
Reportlet visualizing MELODIC ICs, with ICA-AROMA signal/noise labels
aroma_noise_ics
CSV of noise components identified by ICA-AROMA
melodic_mix
FSL MELODIC mixing matrix
nonaggr_denoised_file
BOLD series with non-aggressive ICA-AROMA denoising applied
**Subworkflows**
* :py:func:`~fmriprep.workflows.bold.confounds.init_ica_aroma_wf`
"""
inputnode = pe.Node(niu.IdentityInterface(
fields=['bold', 'bold_mask', 'movpar_file', 't1_mask', 't1_tpms',
't1_bold_xform', 'bold_mni', 'bold_mask_mni']),
name='inputnode')
outputnode = pe.Node(niu.IdentityInterface(
fields=['confounds_file', 'confounds_list', 'rois_report', 'ica_aroma_report',
'aroma_noise_ics', 'melodic_mix', 'nonaggr_denoised_file']),
name='outputnode')
# Get masks ready in T1w space
acc_tpm = pe.Node(AddTPMs(indices=[0, 2]), name='tpms_add_csf_wm') # acc stands for aCompCor
csf_roi = pe.Node(TPM2ROI(erode_mm=0, mask_erode_mm=30), name='csf_roi')
wm_roi = pe.Node(TPM2ROI(
erode_prop=0.6, mask_erode_prop=0.6**3), # 0.6 = radius; 0.6^3 = volume
name='wm_roi')
acc_roi = pe.Node(TPM2ROI(
erode_prop=0.6, mask_erode_prop=0.6**3), # 0.6 = radius; 0.6^3 = volume
name='acc_roi')
# Map ROIs in T1w space into BOLD space
csf_tfm = pe.Node(ApplyTransforms(interpolation='NearestNeighbor', float=True),
name='csf_tfm', mem_gb=0.1)
wm_tfm = pe.Node(ApplyTransforms(interpolation='NearestNeighbor', float=True),
name='wm_tfm', mem_gb=0.1)
acc_tfm = pe.Node(ApplyTransforms(interpolation='NearestNeighbor', float=True),
name='acc_tfm', mem_gb=0.1)
tcc_tfm = pe.Node(ApplyTransforms(interpolation='NearestNeighbor', float=True),
name='tcc_tfm', mem_gb=0.1)
# Ensure ROIs don't go off-limits (reduced FoV)
csf_msk = pe.Node(niu.Function(function=_maskroi), name='csf_msk')
wm_msk = pe.Node(niu.Function(function=_maskroi), name='wm_msk')
acc_msk = pe.Node(niu.Function(function=_maskroi), name='acc_msk')
tcc_msk = pe.Node(niu.Function(function=_maskroi), name='tcc_msk')
# DVARS
dvars = pe.Node(nac.ComputeDVARS(save_all=True, remove_zerovariance=True),
name="dvars", mem_gb=mem_gb)
# Frame displacement
fdisp = pe.Node(nac.FramewiseDisplacement(parameter_source="SPM"),
name="fdisp", mem_gb=mem_gb)
# a/t-CompCor
non_steady_state = pe.Node(nac.NonSteadyStateDetector(), name='non_steady_state')
tcompcor = pe.Node(nac.TCompCor(
components_file='tcompcor.tsv', pre_filter='cosine', save_pre_filter=True,
percentile_threshold=.05), name="tcompcor", mem_gb=mem_gb)
acompcor = pe.Node(nac.ACompCor(
components_file='acompcor.tsv', pre_filter='cosine', save_pre_filter=True),
name="acompcor", mem_gb=mem_gb)
# Set TR if present
if 'RepetitionTime' in metadata:
tcompcor.inputs.repetition_time = metadata['RepetitionTime']
acompcor.inputs.repetition_time = metadata['RepetitionTime']
# Global and segment regressors
mrg_lbl = pe.Node(niu.Merge(3), name='merge_rois', run_without_submitting=True)
signals = pe.Node(SignalExtraction(
detrend=True, class_labels=["CSF", "WhiteMatter", "GlobalSignal"]),
name="signals", mem_gb=mem_gb)
# Arrange confounds
add_header = pe.Node(AddTSVHeader(columns=["X", "Y", "Z", "RotX", "RotY", "RotZ"]),
name="add_header", mem_gb=0.01, run_without_submitting=True)
concat = pe.Node(GatherConfounds(), name="concat", mem_gb=0.01, run_without_submitting=True)
# Generate reportlet
mrg_compcor = pe.Node(niu.Merge(2), name='merge_compcor', run_without_submitting=True)
rois_plot = pe.Node(ROIsPlot(compress_report=True, colors=['r', 'b', 'magenta'],
generate_report=True), name='rois_plot')
def _pick_csf(files):
return files[0]
def _pick_wm(files):
return files[-1]
workflow = pe.Workflow(name=name)
workflow.connect([
# Massage ROIs (in T1w space)
(inputnode, acc_tpm, [('t1_tpms', 'in_files')]),
(inputnode, csf_roi, [(('t1_tpms', _pick_csf), 'in_tpm'),
('t1_mask', 'in_mask')]),
(inputnode, wm_roi, [(('t1_tpms', _pick_wm), 'in_tpm'),
('t1_mask', 'in_mask')]),
(inputnode, acc_roi, [('t1_mask', 'in_mask')]),
(acc_tpm, acc_roi, [('out_file', 'in_tpm')]),
# Map ROIs to BOLD
(inputnode, csf_tfm, [('bold_mask', 'reference_image'),
('t1_bold_xform', 'transforms')]),
(csf_roi, csf_tfm, [('roi_file', 'input_image')]),
(inputnode, wm_tfm, [('bold_mask', 'reference_image'),
('t1_bold_xform', 'transforms')]),
(wm_roi, wm_tfm, [('roi_file', 'input_image')]),
(inputnode, acc_tfm, [('bold_mask', 'reference_image'),
('t1_bold_xform', 'transforms')]),
(acc_roi, acc_tfm, [('roi_file', 'input_image')]),
(inputnode, tcc_tfm, [('bold_mask', 'reference_image'),
('t1_bold_xform', 'transforms')]),
(csf_roi, tcc_tfm, [('eroded_mask', 'input_image')]),
# Mask ROIs with bold_mask
(inputnode, csf_msk, [('bold_mask', 'in_mask')]),
(inputnode, wm_msk, [('bold_mask', 'in_mask')]),
(inputnode, acc_msk, [('bold_mask', 'in_mask')]),
(inputnode, tcc_msk, [('bold_mask', 'in_mask')]),
# connect inputnode to each non-anatomical confound node
(inputnode, dvars, [('bold', 'in_file'),
('bold_mask', 'in_mask')]),
(inputnode, fdisp, [('movpar_file', 'in_file')]),
# Calculate nonsteady state
(inputnode, non_steady_state, [('bold', 'in_file')]),
# tCompCor
(inputnode, tcompcor, [('bold', 'realigned_file')]),
(non_steady_state, tcompcor, [('n_volumes_to_discard', 'ignore_initial_volumes')]),
(tcc_tfm, tcc_msk, [('output_image', 'roi_file')]),
(tcc_msk, tcompcor, [('out', 'mask_files')]),
# aCompCor
(inputnode, acompcor, [('bold', 'realigned_file')]),
(non_steady_state, acompcor, [('n_volumes_to_discard', 'ignore_initial_volumes')]),
(acc_tfm, acc_msk, [('output_image', 'roi_file')]),
(acc_msk, acompcor, [('out', 'mask_files')]),
# Global signals extraction (constrained by anatomy)
(inputnode, signals, [('bold', 'in_file')]),
(csf_tfm, csf_msk, [('output_image', 'roi_file')]),
(csf_msk, mrg_lbl, [('out', 'in1')]),
(wm_tfm, wm_msk, [('output_image', 'roi_file')]),
(wm_msk, mrg_lbl, [('out', 'in2')]),
(inputnode, mrg_lbl, [('bold_mask', 'in3')]),
(mrg_lbl, signals, [('out', 'label_files')]),
# Collate computed confounds together
(inputnode, add_header, [('movpar_file', 'in_file')]),
(signals, concat, [('out_file', 'signals')]),
(dvars, concat, [('out_all', 'dvars')]),
(fdisp, concat, [('out_file', 'fd')]),
(tcompcor, concat, [('components_file', 'tcompcor'),
('pre_filter_file', 'cos_basis')]),
(acompcor, concat, [('components_file', 'acompcor')]),
(add_header, concat, [('out_file', 'motion')]),
# Set outputs
(concat, outputnode, [('confounds_file', 'confounds_file'),
('confounds_list', 'confounds_list')]),
(inputnode, rois_plot, [('bold', 'in_file'),
('bold_mask', 'in_mask')]),
(tcompcor, mrg_compcor, [('high_variance_masks', 'in1')]),
(acc_msk, mrg_compcor, [('out', 'in2')]),
(mrg_compcor, rois_plot, [('out', 'in_rois')]),
(rois_plot, outputnode, [('out_report', 'rois_report')]),
])
if use_aroma:
# ICA-AROMA
ica_aroma_wf = init_ica_aroma_wf(name='ica_aroma_wf',
ignore_aroma_err=ignore_aroma_err)
workflow.connect([
(inputnode, ica_aroma_wf, [('bold_mni', 'inputnode.bold_mni'),
('bold_mask_mni', 'inputnode.bold_mask_mni'),
('movpar_file', 'inputnode.movpar_file')]),
(ica_aroma_wf, concat,
[('outputnode.aroma_confounds', 'aroma')]),
(ica_aroma_wf, outputnode,
[('outputnode.out_report', 'ica_aroma_report'),
('outputnode.aroma_noise_ics', 'aroma_noise_ics'),
('outputnode.melodic_mix', 'melodic_mix'),
('outputnode.nonaggr_denoised_file', 'nonaggr_denoised_file')])
])
return workflow
def init_bold_confs_wf(bold_file_size_gb,
use_aroma,
ignore_aroma_err,
metadata,
name="bold_confs_wf"):
''' All input fields are required.
Calculates global regressor and tCompCor
from motion-corrected fMRI ('inputnode.fmri_file').
Calculates DVARS from the fMRI and an EPI brain mask ('inputnode.bold_mask')
Calculates frame displacement from MCFLIRT movement parameters ('inputnode.movpar_file')
Calculates segment regressors and aCompCor
from the fMRI and a white matter/gray matter/CSF segmentation ('inputnode.t1_seg'), after
applying the transform to the images. Transforms should be fsl-formatted.
Calculates noise components identified from ICA-AROMA (if ``use_aroma=True``)
Saves the confounds in a file ('outputnode.confounds_file')'''
inputnode = pe.Node(niu.IdentityInterface(fields=[
'fmri_file', 'movpar_file', 't1_mask', 't1_tpms', 'bold_mask',
'bold_mni', 'bold_mask_mni'
]),
name='inputnode')
outputnode = pe.Node(niu.IdentityInterface(fields=[
'confounds_file', 'confounds_list', 'acompcor_report',
'tcompcor_report', 'ica_aroma_report', 'aroma_noise_ics',
'melodic_mix', 'nonaggr_denoised_file'
]),
name='outputnode')
# ICA-AROMA
if use_aroma:
ica_aroma_wf = init_ica_aroma_wf(name='ica_aroma_wf',
ignore_aroma_err=ignore_aroma_err)
# DVARS
dvars = pe.Node(nac.ComputeDVARS(save_all=True, remove_zerovariance=True),
name="dvars",
mem_gb=bold_file_size_gb * 3)
# Frame displacement
fdisp = pe.Node(nac.FramewiseDisplacement(parameter_source="SPM"),
name="fdisp",
mem_gb=bold_file_size_gb * 3)
# CompCor
non_steady_state = pe.Node(nac.NonSteadyStateDetector(),
name='non_steady_state')
tcompcor = pe.Node(TCompCorRPT(components_file='tcompcor.tsv',
generate_report=True,
pre_filter='cosine',
save_pre_filter=True,
percentile_threshold=.05),
name="tcompcor",
mem_gb=bold_file_size_gb * 3)
acompcor = pe.Node(ACompCorRPT(components_file='acompcor.tsv',
pre_filter='cosine',
save_pre_filter=True,
generate_report=True),
name="acompcor",
mem_gb=bold_file_size_gb * 3)
csf_roi = pe.Node(TPM2ROI(erode_mm=0, mask_erode_mm=30), name='csf_roi')
wm_roi = pe.Node(TPM2ROI(erode_mm=6, mask_erode_mm=10), name='wm_roi')
merge_rois = pe.Node(niu.Merge(2),
name='merge_rois',
run_without_submit=True,
mem_gb=0.01)
combine_rois = pe.Node(CombineROIs(), name='combine_rois')
concat_rois = pe.Node(ConcatROIs(), name='concat_rois')
# Global and segment regressors
signals = pe.Node(SignalExtraction(
detrend=True, class_labels=["WhiteMatter", "GlobalSignal"]),
name="signals",
mem_gb=bold_file_size_gb * 3)
# Arrange confounds
add_header = pe.Node(
AddTSVHeader(columns=["X", "Y", "Z", "RotX", "RotY", "RotZ"]),
name="add_header",
mem_gb=0.01,
run_without_submit=True)
concat = pe.Node(GatherConfounds(),
name="concat",
mem_gb=0.01,
run_without_submit=True)
# Set TR if present
if 'RepetitionTime' in metadata:
tcompcor.inputs.repetition_time = metadata['RepetitionTime']
acompcor.inputs.repetition_time = metadata['RepetitionTime']
def _pick_csf(files):
return files[0]
def _pick_wm(files):
return files[2]
workflow = pe.Workflow(name=name)
workflow.connect([
# connect inputnode to each non-anatomical confound node
(inputnode, dvars, [('fmri_file', 'in_file'),
('bold_mask', 'in_mask')]),
(inputnode, fdisp, [('movpar_file', 'in_file')]),
(inputnode, non_steady_state, [('fmri_file', 'in_file')]),
(inputnode, tcompcor, [('fmri_file', 'realigned_file')]),
(non_steady_state, tcompcor, [('n_volumes_to_discard',
'ignore_initial_volumes')]),
(non_steady_state, acompcor, [('n_volumes_to_discard',
'ignore_initial_volumes')]),
(inputnode, csf_roi, [(('t1_tpms', _pick_csf), 't1_tpm'),
('t1_mask', 't1_mask'),
('bold_mask', 'bold_mask')]),
(csf_roi, tcompcor, [('eroded_mask', 'mask_files')]),
(inputnode, wm_roi, [(('t1_tpms', _pick_wm), 't1_tpm'),
('t1_mask', 't1_mask'),
('bold_mask', 'bold_mask')]),
(csf_roi, merge_rois, [('roi_file', 'in1')]),
(wm_roi, merge_rois, [('roi_file', 'in2')]),
(merge_rois, combine_rois, [('out', 'in_files')]),
(inputnode, combine_rois, [('fmri_file', 'ref_header')]),
# anatomical confound: aCompCor.
(inputnode, acompcor, [('fmri_file', 'realigned_file')]),
(combine_rois, acompcor, [('out_file', 'mask_files')]),
(wm_roi, concat_rois, [('roi_file', 'in_file')]),
(inputnode, concat_rois, [('bold_mask', 'in_mask')]),
(inputnode, concat_rois, [('fmri_file', 'ref_header')]),
# anatomical confound: signal extraction
(concat_rois, signals, [('out_file', 'label_files')]),
(inputnode, signals, [('fmri_file', 'in_file')]),
# connect the confound nodes to the concatenate node
(inputnode, add_header, [('movpar_file', 'in_file')]),
(signals, concat, [('out_file', 'signals')]),
(dvars, concat, [('out_all', 'dvars')]),
(fdisp, concat, [('out_file', 'fd')]),
(tcompcor, concat, [('components_file', 'tcompcor'),
('pre_filter_file', 'cos_basis')]),
(acompcor, concat, [('components_file', 'acompcor')]),
(add_header, concat, [('out_file', 'motion')]),
(concat, outputnode, [('confounds_file', 'confounds_file'),
('confounds_list', 'confounds_list')]),
(acompcor, outputnode, [('out_report', 'acompcor_report')]),
(tcompcor, outputnode, [('out_report', 'tcompcor_report')]),
])
if use_aroma:
workflow.connect([
(inputnode, ica_aroma_wf,
[('bold_mni', 'inputnode.bold_mni'),
('bold_mask_mni', 'inputnode.bold_mask_mni'),
('movpar_file', 'inputnode.movpar_file')]),
(ica_aroma_wf, concat, [('outputnode.aroma_confounds', 'aroma')]),
(ica_aroma_wf, outputnode,
[('outputnode.out_report', 'ica_aroma_report'),
('outputnode.aroma_noise_ics', 'aroma_noise_ics'),
('outputnode.melodic_mix', 'melodic_mix'),
('outputnode.nonaggr_denoised_file', 'nonaggr_denoised_file')])
])
return workflow