def compute_iqms(settings, name='ComputeIQMs'):
"""Workflow that actually computes the IQMs"""
workflow = pe.Workflow(name=name)
inputnode = pe.Node(niu.IdentityInterface(fields=[
'subject_id', 'session_id', 'task_id', 'run_id', 'orig', 'epi_mean',
'brainmask', 'hmc_epi', 'hmc_fd', 'in_tsnr', 'metadata']), name='inputnode')
outputnode = pe.Node(niu.IdentityInterface(
fields=['out_file', 'out_dvars', 'outliers', 'out_spikes', 'out_fft']),
name='outputnode')
deriv_dir = check_folder(op.abspath(op.join(settings['output_dir'], 'derivatives')))
# Compute DVARS
dvnode = pe.Node(nac.ComputeDVARS(save_plot=False, save_all=True), name='ComputeDVARS')
# AFNI quality measures
fwhm = pe.Node(afni.FWHMx(combine=True, detrend=True), name='smoothness')
# fwhm.inputs.acf = True # add when AFNI >= 16
outliers = pe.Node(afni.OutlierCount(fraction=True, out_file='ouliers.out'),
name='outliers')
quality = pe.Node(afni.QualityIndex(automask=True), out_file='quality.out',
name='quality')
# FFT spikes finder
spikes_fft = pe.Node(niu.Function(
input_names=['in_file'], output_names=['n_spikes', 'out_spikes', 'out_fft'],
function=slice_wise_fft), name='SpikesFinderFFT')
measures = pe.Node(FunctionalQC(), name='measures')
workflow.connect([
(inputnode, dvnode, [('orig', 'in_file'),
('brainmask', 'in_mask')]),
(inputnode, measures, [('epi_mean', 'in_epi'),
('brainmask', 'in_mask'),
('hmc_epi', 'in_hmc'),
('hmc_fd', 'in_fd'),
('in_tsnr', 'in_tsnr')]),
(inputnode, fwhm, [('epi_mean', 'in_file'),
('brainmask', 'mask')]),
(inputnode, spikes_fft, [('orig', 'in_file')]),
(inputnode, quality, [('hmc_epi', 'in_file')]),
(inputnode, outliers, [('hmc_epi', 'in_file'),
('brainmask', 'mask')]),
(dvnode, measures, [('out_all', 'in_dvars')]),
(dvnode, outputnode, [('out_all', 'out_dvars')]),
(outliers, outputnode, [('out_file', 'outliers')]),
(spikes_fft, outputnode, [('out_spikes', 'out_spikes'),
('out_fft', 'out_fft')])
])
# Save to JSON file
datasink = pe.Node(IQMFileSink(
modality='bold', out_dir=deriv_dir), name='datasink')
workflow.connect([
(inputnode, datasink, [('subject_id', 'subject_id'),
('session_id', 'session_id'),
('task_id', 'task_id'),
('run_id', 'run_id'),
('metadata', 'metadata')]),
(outliers, datasink, [(('out_file', _parse_tout), 'aor')]),
(quality, datasink, [(('out_file', _parse_tqual), 'aqi')]),
(measures, datasink, [('out_qc', 'root')]),
(spikes_fft, datasink, [('n_spikes', 'spikes_num')]),
(fwhm, datasink, [(('fwhm', fwhm_dict), 'root0')]),
(datasink, outputnode, [('out_file', 'out_file')])
])
return workflow
def compute_iqms(name="ComputeIQMs"):
"""
Initialize the workflow that actually computes the IQMs.
.. workflow::
from mriqc.workflows.functional import compute_iqms
from mriqc.testing import mock_config
with mock_config():
wf = compute_iqms()
"""
from nipype.algorithms.confounds import ComputeDVARS
from nipype.interfaces.afni import OutlierCount, QualityIndex
from niworkflows.interfaces.bids import ReadSidecarJSON
from mriqc.interfaces import FunctionalQC, IQMFileSink
from mriqc.interfaces.reports import AddProvenance
from mriqc.interfaces.transitional import GCOR
from mriqc.workflows.utils import _tofloat, get_fwhmx
mem_gb = config.workflow.biggest_file_gb
workflow = pe.Workflow(name=name)
inputnode = pe.Node(
niu.IdentityInterface(fields=[
"in_file",
"in_ras",
"epi_mean",
"brainmask",
"hmc_epi",
"hmc_fd",
"fd_thres",
"in_tsnr",
"metadata",
"exclude_index",
]),
name="inputnode",
)
outputnode = pe.Node(
niu.IdentityInterface(fields=[
"out_file",
"out_dvars",
"outliers",
"out_spikes",
"out_fft",
]),
name="outputnode",
)
# Set FD threshold
inputnode.inputs.fd_thres = config.workflow.fd_thres
# Compute DVARS
dvnode = pe.Node(
ComputeDVARS(save_plot=False, save_all=True),
name="ComputeDVARS",
mem_gb=mem_gb * 3,
)
# AFNI quality measures
fwhm_interface = get_fwhmx()
fwhm = pe.Node(fwhm_interface, name="smoothness")
# fwhm.inputs.acf = True # add when AFNI >= 16
outliers = pe.Node(
OutlierCount(fraction=True, out_file="outliers.out"),
name="outliers",
mem_gb=mem_gb * 2.5,
)
quality = pe.Node(
QualityIndex(automask=True),
out_file="quality.out",
name="quality",
mem_gb=mem_gb * 3,
)
gcor = pe.Node(GCOR(), name="gcor", mem_gb=mem_gb * 2)
measures = pe.Node(FunctionalQC(), name="measures", mem_gb=mem_gb * 3)
# fmt: off
workflow.connect([(inputnode, dvnode, [("hmc_epi", "in_file"),
("brainmask", "in_mask")]),
(inputnode, measures, [("epi_mean", "in_epi"),
("brainmask", "in_mask"),
("hmc_epi", "in_hmc"),
("hmc_fd", "in_fd"),
("fd_thres", "fd_thres"),
("in_tsnr", "in_tsnr")]),
(inputnode, fwhm, [("epi_mean", "in_file"),
("brainmask", "mask")]),
(inputnode, quality, [("hmc_epi", "in_file")]),
(inputnode, outliers, [("hmc_epi", "in_file"),
("brainmask", "mask")]),
(inputnode, gcor, [("hmc_epi", "in_file"),
("brainmask", "mask")]),
(dvnode, measures, [("out_all", "in_dvars")]),
(fwhm, measures, [(("fwhm", _tofloat), "in_fwhm")]),
(dvnode, outputnode, [("out_all", "out_dvars")]),
(outliers, outputnode, [("out_file", "outliers")])])
# fmt: on
# Add metadata
meta = pe.Node(ReadSidecarJSON(),
name="metadata",
run_without_submitting=True)
addprov = pe.Node(
AddProvenance(modality="bold"),
name="provenance",
run_without_submitting=True,
)
# Save to JSON file
datasink = pe.Node(
IQMFileSink(
modality="bold",
out_dir=str(config.execution.output_dir),
dataset=config.execution.dsname,
),
name="datasink",
run_without_submitting=True,
)
# fmt: off
workflow.connect([
(inputnode, datasink, [("in_file", "in_file"),
("exclude_index", "dummy_trs")]),
(inputnode, meta, [("in_file", "in_file")]),
(inputnode, addprov, [("in_file", "in_file")]),
(meta, datasink, [("subject", "subject_id"), ("session", "session_id"),
("task", "task_id"), ("acquisition", "acq_id"),
("reconstruction", "rec_id"), ("run", "run_id"),
("out_dict", "metadata")]),
(addprov, datasink, [("out_prov", "provenance")]),
(outliers, datasink, [(("out_file", _parse_tout), "aor")]),
(gcor, datasink, [(("out", _tofloat), "gcor")]),
(quality, datasink, [(("out_file", _parse_tqual), "aqi")]),
(measures, datasink, [("out_qc", "root")]),
(datasink, outputnode, [("out_file", "out_file")])
])
# fmt: on
# FFT spikes finder
if config.workflow.fft_spikes_detector:
from .utils import slice_wise_fft
spikes_fft = pe.Node(
niu.Function(
input_names=["in_file"],
output_names=["n_spikes", "out_spikes", "out_fft"],
function=slice_wise_fft,
),
name="SpikesFinderFFT",
)
# fmt: off
workflow.connect([
(inputnode, spikes_fft, [("in_ras", "in_file")]),
(spikes_fft, outputnode, [("out_spikes", "out_spikes"),
("out_fft", "out_fft")]),
(spikes_fft, datasink, [("n_spikes", "spikes_num")])
])
# fmt: on
return workflow
def compute_iqms(settings, name='ComputeIQMs'):
"""
Workflow that actually computes the IQMs
.. workflow::
from mriqc.workflows.functional import compute_iqms
wf = compute_iqms(settings={'output_dir': 'out'})
"""
from mriqc.workflows.utils import _tofloat
biggest_file_gb = settings.get("biggest_file_size_gb", 1)
workflow = pe.Workflow(name=name)
inputnode = pe.Node(niu.IdentityInterface(fields=[
'subject_id', 'session_id', 'task_id', 'acq_id', 'rec_id', 'run_id',
'orig', 'epi_mean', 'brainmask', 'hmc_epi', 'hmc_fd', 'fd_thres',
'in_tsnr', 'metadata'
]),
name='inputnode')
outputnode = pe.Node(niu.IdentityInterface(
fields=['out_file', 'out_dvars', 'outliers', 'out_spikes', 'out_fft']),
name='outputnode')
#Set FD threshold
inputnode.inputs.fd_thres = settings.get('fd_thres', 0.2)
deriv_dir = check_folder(
op.abspath(op.join(settings['output_dir'], 'derivatives')))
# Compute DVARS
dvnode = pe.Node(nac.ComputeDVARS(save_plot=False, save_all=True),
name='ComputeDVARS')
dvnode.interface.estimated_memory_gb = biggest_file_gb * 3
# AFNI quality measures
fwhm = pe.Node(afni.FWHMx(combine=True, detrend=True), name='smoothness')
# fwhm.inputs.acf = True # add when AFNI >= 16
outliers = pe.Node(afni.OutlierCount(fraction=True,
out_file='ouliers.out'),
name='outliers')
outliers.interface.estimated_memory_gb = biggest_file_gb * 2.5
quality = pe.Node(afni.QualityIndex(automask=True),
out_file='quality.out',
name='quality')
quality.interface.estimated_memory_gb = biggest_file_gb * 3
measures = pe.Node(FunctionalQC(), name='measures')
measures.interface.estimated_memory_gb = biggest_file_gb * 3
workflow.connect([(inputnode, dvnode, [('hmc_epi', 'in_file'),
('brainmask', 'in_mask')]),
(inputnode, measures, [('epi_mean', 'in_epi'),
('brainmask', 'in_mask'),
('hmc_epi', 'in_hmc'),
('hmc_fd', 'in_fd'),
('fd_thres', 'fd_thres'),
('in_tsnr', 'in_tsnr')]),
(inputnode, fwhm, [('epi_mean', 'in_file'),
('brainmask', 'mask')]),
(inputnode, quality, [('hmc_epi', 'in_file')]),
(inputnode, outliers, [('hmc_epi', 'in_file'),
('brainmask', 'mask')]),
(dvnode, measures, [('out_all', 'in_dvars')]),
(fwhm, measures, [(('fwhm', _tofloat), 'in_fwhm')]),
(dvnode, outputnode, [('out_all', 'out_dvars')]),
(outliers, outputnode, [('out_file', 'outliers')])])
# Save to JSON file
datasink = pe.Node(IQMFileSink(modality='bold', out_dir=deriv_dir),
name='datasink')
workflow.connect([
(inputnode, datasink, [('subject_id', 'subject_id'),
('session_id', 'session_id'),
('task_id', 'task_id'), ('acq_id', 'acq_id'),
('rec_id', 'rec_id'), ('run_id', 'run_id'),
('metadata', 'metadata')]),
(outliers, datasink, [(('out_file', _parse_tout), 'aor')]),
(quality, datasink, [(('out_file', _parse_tqual), 'aqi')]),
(measures, datasink, [('out_qc', 'root')]),
(datasink, outputnode, [('out_file', 'out_file')])
])
if settings.get('fft_spikes_detector', False):
# FFT spikes finder
spikes_fft = pe.Node(niu.Function(
input_names=['in_file'],
output_names=['n_spikes', 'out_spikes', 'out_fft'],
function=slice_wise_fft),
name='SpikesFinderFFT')
workflow.connect([
(inputnode, spikes_fft, [('orig', 'in_file')]),
(spikes_fft, outputnode, [('out_spikes', 'out_spikes'),
('out_fft', 'out_fft')]),
(spikes_fft, datasink, [('n_spikes', 'spikes_num')])
])
return workflow
iterfield=['in_file', 'brightness_threshold'],
name='smooth')
def getbtthresh(medianvals):
return [0.75 * val for val in medianvals]
preprocessing.connect(medianval, ('out_stat', getbtthresh), smooth, 'brightness_threshold')
else:
smooth=pe.Node(interface=fsl.utils.Smooth(), name="smooth")
smooth.inputs.fwhm=6
# Turn off smoothing for now - we will do it later on the constrast images
#preprocessing.connect(rescale,'out_file',smooth,'in_file')
#preprocessing.connect(smooth,'smoothed_file',datasink,'smooth')
fqc=pe.Node(interface=FunctionalQC(),name='fqc')
tsnr = pe.Node(nam.TSNR(), name='compute_tsnr')
preprocessing.connect(mcflirt, 'out_file',tsnr,'in_file')
preprocessing.connect(mcflirt,'mean_img',fqc,'in_epi')
preprocessing.connect(mcflirt, 'out_file',fqc,'in_hmc')
preprocessing.connect(bet_func, 'mask_file',fqc,'in_mask')
preprocessing.connect(tsnr, 'tsnr_file',fqc,'in_tsnr')
preprocessing.connect(mcflirt, 'par_file',fqc,'fd_movpar')
preprocessing.connect(fqc,'dvars',datasink,'mriqc.dvars')
preprocessing.connect(fqc,'summary',datasink,'mriqc.summary')