def init_scale_wf(mem_gb,
omp_nthreads,
n_dummy=None,
scale_stat='mean',
name='scale'):
"""
Run afni's voxel level mean scaling
Parameters
----------
mem_gb : :obj:`float`
Size of BOLD file in GB
omp_nthreads : :obj:`int`
Maximum number of threads an individual process may use
n_dummy: :obj: `int`
Number of dummy scans at the begining of the bold to discard when calculating the mean
scale_stat : :obj:`str`
Name of the flag for the statistic to scale relative to (defaul: ``mean``)
name : :obj:`str`
Name of workflow (default: ``bold_std_trans_wf``)
Inputs
------
bold_file
bold image to scale, should probably be head motion corrected first
Outputs
-------
scaled
scaled bold time series
"""
from niworkflows.engine.workflows import LiterateWorkflow as Workflow
from niworkflows.interfaces.fixes import FixHeaderApplyTransforms as ApplyTransforms
from nipype.interfaces.afni import Calc
from ..interfaces.afni import TStat
workflow = Workflow(name=name)
inputnode = pe.Node(niu.IdentityInterface(fields=['bold_file']),
name='inputnode')
outputnode = pe.Node(niu.IdentityInterface(fields=['scaled']),
name='outputnode')
scale_ref = pe.Node(TStat(args=f'-{scale_stat}',
index=f'[{n_dummy}..$]',
outputtype='NIFTI_GZ'),
name='scale_ref',
mem_gb=mem_gb,
n_procs=omp_nthreads)
scale = pe.Node(Calc(outputtype='NIFTI_GZ',
expr='min(200, a/b*100)*step(a)*step(b)'),
name='scale',
mem_gb=mem_gb,
n_procs=omp_nthreads)
workflow.connect([(inputnode, scale_ref, [('bold_file', 'in_file')]),
(inputnode, scale, [('bold_file', 'in_file_a')]),
(scale_ref, scale, [('out_file', 'in_file_b')]),
(scale, outputnode, [('out_file', 'scaled')])])
return workflow
def init_fmriprep_wf():
"""
Build *fMRIPrep*'s pipeline.
This workflow organizes the execution of FMRIPREP, with a sub-workflow for
each subject.
If FreeSurfer's ``recon-all`` is to be run, a corresponding folder is created
and populated with any needed template subjects under the derivatives folder.
Workflow Graph
.. workflow::
:graph2use: orig
:simple_form: yes
from fmriprep.workflows.tests import mock_config
from fmriprep.workflows.base import init_fmriprep_wf
with mock_config():
wf = init_fmriprep_wf()
"""
from niworkflows.engine.workflows import LiterateWorkflow as Workflow
from niworkflows.interfaces.bids import BIDSFreeSurferDir
fmriprep_wf = Workflow(name='fmriprep_wf')
fmriprep_wf.base_dir = config.execution.work_dir
freesurfer = config.workflow.run_reconall
if freesurfer:
fsdir = pe.Node(
BIDSFreeSurferDir(derivatives=config.execution.output_dir,
freesurfer_home=os.getenv('FREESURFER_HOME'),
spaces=config.workflow.spaces.get_fs_spaces()),
name='fsdir_run_%s' % config.execution.run_uuid.replace('-', '_'),
run_without_submitting=True)
if config.execution.fs_subjects_dir is not None:
fsdir.inputs.subjects_dir = str(
config.execution.fs_subjects_dir.absolute())
for subject_id in config.execution.participant_label:
single_subject_wf = init_single_subject_wf(subject_id)
single_subject_wf.config['execution']['crashdump_dir'] = str(
config.execution.output_dir / "fmriprep" / "-".join(
("sub", subject_id)) / "log" / config.execution.run_uuid)
for node in single_subject_wf._get_all_nodes():
node.config = deepcopy(single_subject_wf.config)
if freesurfer:
fmriprep_wf.connect(fsdir, 'subjects_dir', single_subject_wf,
'inputnode.subjects_dir')
else:
fmriprep_wf.add_nodes([single_subject_wf])
# Dump a copy of the config file into the log directory
log_dir = config.execution.output_dir / 'fmriprep' / 'sub-{}'.format(subject_id) \
/ 'log' / config.execution.run_uuid
log_dir.mkdir(exist_ok=True, parents=True)
config.to_filename(log_dir / 'fmriprep.toml')
return fmriprep_wf
def init_reportlets_wf(reportlets_dir, name='reportlets_wf'):
"""Set up a battery of datasinks to store reports in the right location."""
from niworkflows.interfaces.masks import SimpleShowMaskRPT
workflow = Workflow(name=name)
inputnode = pe.Node(niu.IdentityInterface(
fields=['source_file', 'dwi_ref', 'dwi_mask',
'validation_report']),
name='inputnode')
mask_reportlet = pe.Node(SimpleShowMaskRPT(), name='mask_reportlet')
ds_report_mask = pe.Node(
DerivativesDataSink(base_directory=reportlets_dir,
desc='brain', suffix='mask'),
name='ds_report_mask', run_without_submitting=True)
ds_report_validation = pe.Node(
DerivativesDataSink(base_directory=reportlets_dir,
desc='validation', keep_dtype=True),
name='ds_report_validation', run_without_submitting=True)
workflow.connect([
(inputnode, mask_reportlet, [('dwi_ref', 'background_file'),
('dwi_mask', 'mask_file')]),
(inputnode, ds_report_validation, [('source_file', 'source_file')]),
(inputnode, ds_report_mask, [('source_file', 'source_file')]),
(inputnode, ds_report_validation, [('validation_report', 'in_file')]),
(mask_reportlet, ds_report_mask, [('out_report', 'in_file')]),
])
return workflow
def init_reportlets_wf(output_dir, sdc_report=False, name="reportlets_wf"):
"""Set up a battery of datasinks to store reports in the right location."""
from niworkflows.interfaces.reportlets.masks import SimpleShowMaskRPT
workflow = Workflow(name=name)
inputnode = pe.Node(
niu.IdentityInterface(
fields=[
"source_file",
"dwi_ref",
"dwi_mask",
"validation_report",
"sdc_report",
]
),
name="inputnode",
)
mask_reportlet = pe.Node(SimpleShowMaskRPT(), name="mask_reportlet")
ds_report_mask = pe.Node(
DerivativesDataSink(
base_directory=output_dir, desc="brain", suffix="mask", datatype="figures"
),
name="ds_report_mask",
run_without_submitting=True,
)
ds_report_validation = pe.Node(
DerivativesDataSink(
base_directory=output_dir, desc="validation", datatype="figures"
),
name="ds_report_validation",
run_without_submitting=True,
)
# fmt:off
workflow.connect([
(inputnode, mask_reportlet, [("dwi_ref", "background_file"),
("dwi_mask", "mask_file")]),
(inputnode, ds_report_validation, [("source_file", "source_file")]),
(inputnode, ds_report_mask, [("source_file", "source_file")]),
(inputnode, ds_report_validation, [("validation_report", "in_file")]),
(mask_reportlet, ds_report_mask, [("out_report", "in_file")]),
])
# fmt:on
if sdc_report:
ds_report_sdc = pe.Node(
DerivativesDataSink(
base_directory=output_dir, desc="sdc", suffix="dwi", datatype="figures"
),
name="ds_report_sdc",
run_without_submitting=True,
)
# fmt:off
workflow.connect([
(inputnode, ds_report_sdc, [("source_file", "source_file"),
("sdc_report", "in_file")]),
])
# fmt:on
return workflow
def init_dmriprep_wf():
"""
Create the base workflow.
This workflow organizes the execution of *dMRIPrep*, with a sub-workflow for
each subject. If FreeSurfer's recon-all is to be run, a FreeSurfer derivatives folder is
created and populated with any needed template subjects.
Workflow Graph
.. workflow::
:graph2use: orig
:simple_form: yes
from dmriprep.config.testing import mock_config
from dmriprep.workflows.base import init_dmriprep_wf
with mock_config():
wf = init_dmriprep_wf()
"""
dmriprep_wf = Workflow(name="dmriprep_wf")
dmriprep_wf.base_dir = config.execution.work_dir
freesurfer = config.workflow.run_reconall
if freesurfer:
fsdir = pe.Node(
BIDSFreeSurferDir(
derivatives=config.execution.output_dir,
freesurfer_home=os.getenv("FREESURFER_HOME"),
spaces=config.workflow.spaces.get_fs_spaces(),
),
name=f"fsdir_run_{config.execution.run_uuid.replace('-', '_')}",
run_without_submitting=True,
)
if config.execution.fs_subjects_dir is not None:
fsdir.inputs.subjects_dir = str(
config.execution.fs_subjects_dir.absolute())
for subject_id in config.execution.participant_label:
single_subject_wf = init_single_subject_wf(subject_id)
single_subject_wf.config["execution"]["crashdump_dir"] = str(
config.execution.output_dir / "dmriprep" / f"sub-{subject_id}" /
"log" / config.execution.run_uuid)
for node in single_subject_wf._get_all_nodes():
node.config = deepcopy(single_subject_wf.config)
if freesurfer:
dmriprep_wf.connect(fsdir, "subjects_dir", single_subject_wf,
"fsinputnode.subjects_dir")
else:
dmriprep_wf.add_nodes([single_subject_wf])
# Dump a copy of the config file into the log directory
log_dir = (config.execution.output_dir / "dmriprep" /
f"sub-{subject_id}" / "log" / config.execution.run_uuid)
log_dir.mkdir(exist_ok=True, parents=True)
config.to_filename(log_dir / "dmriprep.toml")
return dmriprep_wf
def init_faux_bold_wf(bids_layout, base_dir=None, name="faux_bold"):
# create workflow
wf = Workflow(name=name, base_dir=base_dir)
input_node = pe.Node(
niu.IdentityInterface([
'base_bold_list',
'second_bold_list',
'task_name',
'num_discard',
'num_interp']),
name='input_node',
)
output_node = pe.Node(
niu.IdentityInterface([
'faux_bold_files']),
name='output_node')
combine_bold = pe.MapNode(CombineRestBold(return_type="file"),
iterfield=['base_bold',
'second_bold'],
name='combine_node')
participants = bids_layout.get_subjects()
base_bold_list = []
second_bold_list = []
for participant in participants:
for run, lst in zip([1, 2], [base_bold_list, second_bold_list]):
try:
bold_file = bids_layout.get(
task="rest",
extension=".nii.gz",
run=run,
subject=participant,
return_type='file',
)[0]
except IndexError:
raise IndexError(f"{participant} does not have rest run: {run}")
lst.append(bold_file)
input_node.inputs.base_bold_list = base_bold_list
input_node.inputs.second_bold_list = second_bold_list
wf.connect([
(input_node, combine_bold,
[('base_bold_list', 'base_bold'),
('second_bold_list', 'second_bold'),
('task_name', 'task_name'),
('num_discard', 'num_discard'),
('num_interp', 'num_interp')]),
(combine_bold, output_node,
[('faux_bold', 'faux_bold_files')])
])
return wf
def init_qwarp_inversion_wf(omp_nthreads=1, name="qwarp_invert_wf"):
"""
Invert a warp produced by 3dqwarp and convert it to an ANTS formatted warp
Workflow Graph
.. workflow ::
:graph2use: orig
:simple_form: yes
from sdcflows.workflows.base import init_qwarp_inversion_wf
wf = init_qwarp_inversion_wf()
Parameters
----------
name : str
Name for this workflow
omp_nthreads : int
Parallelize internal tasks across the number of CPUs given by this option.
Inputs
------
warp : pathlike
The warp you want to invert.
in_reference : pathlike
The baseline reference image (must correspond to ``epi_pe_dir``).
Outputs
-------
out_warp : pathlike
The corresponding inverted :abbr:`DFM (displacements field map)` compatible with
ANTs.
"""
from ..interfaces.afni import InvertWarp
workflow = Workflow(name=name)
workflow.__desc__ = """\
A warp produced by 3dQwarp was inverted by `3dNwarpCat` @afni (AFNI {afni_ver}).
""".format(afni_ver=''.join(['%02d' % v for v in afni.Info().version() or []]))
inputnode = pe.Node(niu.IdentityInterface(fields=['warp', 'in_reference']),
name='inputnode')
outputnode = pe.Node(niu.IdentityInterface(fields=['out_warp']),
name='outputnode')
invert = pe.Node(InvertWarp(), name='invert', n_procs=omp_nthreads)
invert.inputs.outputtype = 'NIFTI_GZ'
to_ants = pe.Node(niu.Function(function=_fix_hdr),
name='to_ants',
mem_gb=0.01)
cphdr_warp = pe.Node(CopyHeader(), name='cphdr_warp', mem_gb=0.01)
workflow.connect([
(inputnode, invert, [('warp', 'in_file')]),
(invert, cphdr_warp, [('out_file', 'in_file')]),
(inputnode, cphdr_warp, [('in_reference', 'hdr_file')]),
(cphdr_warp, to_ants, [('out_file', 'in_file')]),
(to_ants, outputnode, [('out', 'out_warp')]),
])
return workflow
def init_anat_reports_wf(reportlets_dir,
template,
freesurfer,
name='anat_reports_wf'):
"""
Set up a battery of datasinks to store reports in the right location
"""
workflow = Workflow(name=name)
inputnode = pe.Node(niu.IdentityInterface(fields=[
'source_file', 't1_conform_report', 'seg_report', 't1_2_mni_report',
'recon_report'
]),
name='inputnode')
ds_t1_conform_report = pe.Node(DerivativesDataSink(
base_directory=reportlets_dir, suffix='conform'),
name='ds_t1_conform_report',
run_without_submitting=True)
ds_t1_2_mni_report = pe.Node(DerivativesDataSink(
base_directory=reportlets_dir, suffix='t1_2_mni'),
name='ds_t1_2_mni_report',
run_without_submitting=True)
ds_t1_seg_mask_report = pe.Node(DerivativesDataSink(
base_directory=reportlets_dir, suffix='seg_brainmask'),
name='ds_t1_seg_mask_report',
run_without_submitting=True)
workflow.connect([
(inputnode, ds_t1_conform_report, [('source_file', 'source_file'),
('t1_conform_report', 'in_file')]),
(inputnode, ds_t1_seg_mask_report, [('source_file', 'source_file'),
('seg_report', 'in_file')]),
(inputnode, ds_t1_2_mni_report, [('source_file', 'source_file'),
('t1_2_mni_report', 'in_file')])
])
if freesurfer:
ds_recon_report = pe.Node(DerivativesDataSink(
base_directory=reportlets_dir, suffix='reconall'),
name='ds_recon_report',
run_without_submitting=True)
workflow.connect([(inputnode, ds_recon_report,
[('source_file', 'source_file'),
('recon_report', 'in_file')])])
return workflow
def init_pepolar_estimate_wf(debug=False, generate_report=True, name="pepolar_estimate_wf"):
"""Initialize a barebones TOPUP implementation."""
from nipype.interfaces.afni import Automask
from nipype.interfaces.fsl.epi import TOPUP
from niworkflows.interfaces.nibabel import MergeSeries
from sdcflows.interfaces.fmap import get_trt
from ...interfaces.images import RescaleB0
wf = Workflow(name=name)
inputnode = pe.Node(niu.IdentityInterface(fields=["metadata", "in_data"]),
name="inputnode")
outputnode = pe.Node(niu.IdentityInterface(fields=["fieldmap", "corrected", "corrected_mask"]),
name="outputnode")
concat_blips = pe.Node(MergeSeries(), name="concat_blips")
readout_time = pe.MapNode(niu.Function(
input_names=["in_meta", "in_file"], function=get_trt), name="readout_time",
iterfield=["in_meta", "in_file"], run_without_submitting=True
)
topup = pe.Node(TOPUP(config=_pkg_fname(
"dmriprep", f"data/flirtsch/b02b0{'_quick' * debug}.cnf")), name="topup")
pre_mask = pe.Node(Automask(dilate=1, outputtype="NIFTI_GZ"),
name="pre_mask")
rescale_corrected = pe.Node(RescaleB0(), name="rescale_corrected")
post_mask = pe.Node(Automask(outputtype="NIFTI_GZ"),
name="post_mask")
wf.connect([
(inputnode, concat_blips, [("in_data", "in_files")]),
(inputnode, readout_time, [("in_data", "in_file"),
("metadata", "in_meta")]),
(inputnode, topup, [(("metadata", _get_pedir), "encoding_direction")]),
(readout_time, topup, [("out", "readout_times")]),
(concat_blips, topup, [("out_file", "in_file")]),
(topup, pre_mask, [("out_corrected", "in_file")]),
(pre_mask, rescale_corrected, [("out_file", "mask_file")]),
(topup, rescale_corrected, [("out_corrected", "in_file")]),
(topup, outputnode, [("out_field", "fieldmap")]),
(rescale_corrected, post_mask, [("out_ref", "in_file")]),
(rescale_corrected, outputnode, [("out_ref", "corrected")]),
(post_mask, outputnode, [("out_file", "corrected_mask")]),
])
return wf
def init_fmriprep_wf():
"""
Build *fMRIPrep*'s pipeline.
This workflow organizes the execution of FMRIPREP, with a sub-workflow for
each subject.
If FreeSurfer's ``recon-all`` is to be run, a corresponding folder is created
and populated with any needed template subjects under the derivatives folder.
Workflow Graph
.. workflow::
:graph2use: orig
:simple_form: yes
from fprodents.workflows.tests import mock_config
from fprodents.workflows.base import init_fmriprep_wf
with mock_config():
wf = init_fmriprep_wf()
"""
from niworkflows.engine.workflows import LiterateWorkflow as Workflow
fmriprep_wf = Workflow(name="fmriprep_wf")
fmriprep_wf.base_dir = config.execution.work_dir
for subject_id in config.execution.participant_label:
single_subject_wf = init_single_subject_wf(subject_id)
# Dump a copy of the config file into the log directory
log_dir = (config.execution.output_dir / "fmriprep" /
f"sub-{subject_id}" / "log" / config.execution.run_uuid)
log_dir.mkdir(exist_ok=True, parents=True)
config.to_filename(log_dir / "fmriprep.toml")
single_subject_wf.config["execution"]["crashdump_dir"] = str(log_dir)
for node in single_subject_wf._get_all_nodes():
node.config = deepcopy(single_subject_wf.config)
fmriprep_wf.add_nodes([single_subject_wf])
return fmriprep_wf
def init_segs_to_native_wf(name='segs_to_native', segmentation='aseg'):
"""
Get a segmentation from FreeSurfer conformed space into native T1w space.
.. workflow::
:graph2use: orig
:simple_form: yes
from smriprep.workflows.surfaces import init_segs_to_native_wf
wf = init_segs_to_native_wf()
**Parameters**
segmentation
The name of a segmentation ('aseg' or 'aparc_aseg' or 'wmparc')
**Inputs**
in_file
Anatomical, merged T1w image after INU correction
subjects_dir
FreeSurfer SUBJECTS_DIR
subject_id
FreeSurfer subject ID
**Outputs**
out_file
The selected segmentation, after resampling in native space
"""
workflow = Workflow(name='%s_%s' % (name, segmentation))
inputnode = pe.Node(niu.IdentityInterface(
['in_file', 'subjects_dir', 'subject_id']),
name='inputnode')
outputnode = pe.Node(niu.IdentityInterface(['out_file']),
name='outputnode')
# Extract the aseg and aparc+aseg outputs
fssource = pe.Node(nio.FreeSurferSource(), name='fs_datasource')
tonative = pe.Node(fs.Label2Vol(), name='tonative')
tonii = pe.Node(fs.MRIConvert(out_type='niigz', resample_type='nearest'),
name='tonii')
if segmentation.startswith('aparc'):
if segmentation == 'aparc_aseg':
def _sel(x):
return [parc for parc in x if 'aparc+' in parc][0]
elif segmentation == 'aparc_a2009s':
def _sel(x):
return [parc for parc in x if 'a2009s+' in parc][0]
elif segmentation == 'aparc_dkt':
def _sel(x):
return [parc for parc in x if 'DKTatlas+' in parc][0]
segmentation = (segmentation, _sel)
workflow.connect([
(inputnode, fssource, [('subjects_dir', 'subjects_dir'),
('subject_id', 'subject_id')]),
(inputnode, tonii, [('in_file', 'reslice_like')]),
(fssource, tonative, [(segmentation, 'seg_file'),
('rawavg', 'template_file'),
('aseg', 'reg_header')]),
(tonative, tonii, [('vol_label_file', 'in_file')]),
(tonii, outputnode, [('out_file', 'out_file')]),
])
return workflow
def init_gifti_surface_wf(name='gifti_surface_wf'):
r"""
Prepare GIFTI surfaces from a FreeSurfer subjects directory.
If midthickness (or graymid) surfaces do not exist, they are generated and
saved to the subject directory as ``lh/rh.midthickness``.
These, along with the gray/white matter boundary (``lh/rh.smoothwm``), pial
sufaces (``lh/rh.pial``) and inflated surfaces (``lh/rh.inflated``) are
converted to GIFTI files.
Additionally, the vertex coordinates are :py:class:`recentered
<smriprep.interfaces.NormalizeSurf>` to align with native T1w space.
.. workflow::
:graph2use: orig
:simple_form: yes
from smriprep.workflows.surfaces import init_gifti_surface_wf
wf = init_gifti_surface_wf()
**Inputs**
subjects_dir
FreeSurfer SUBJECTS_DIR
subject_id
FreeSurfer subject ID
fsnative2t1w_xfm
LTA formatted affine transform file (inverse)
**Outputs**
surfaces
GIFTI surfaces for gray/white matter boundary, pial surface,
midthickness (or graymid) surface, and inflated surfaces
"""
workflow = Workflow(name=name)
inputnode = pe.Node(niu.IdentityInterface(
['subjects_dir', 'subject_id', 'fsnative2t1w_xfm']),
name='inputnode')
outputnode = pe.Node(niu.IdentityInterface(['surfaces']),
name='outputnode')
get_surfaces = pe.Node(nio.FreeSurferSource(), name='get_surfaces')
midthickness = pe.MapNode(MakeMidthickness(thickness=True,
distance=0.5,
out_name='midthickness'),
iterfield='in_file',
name='midthickness')
save_midthickness = pe.Node(nio.DataSink(parameterization=False),
name='save_midthickness')
surface_list = pe.Node(niu.Merge(4, ravel_inputs=True),
name='surface_list',
run_without_submitting=True)
fs2gii = pe.MapNode(fs.MRIsConvert(out_datatype='gii'),
iterfield='in_file',
name='fs2gii')
fix_surfs = pe.MapNode(NormalizeSurf(),
iterfield='in_file',
name='fix_surfs')
workflow.connect([
(inputnode, get_surfaces, [('subjects_dir', 'subjects_dir'),
('subject_id', 'subject_id')]),
(inputnode, save_midthickness, [('subjects_dir', 'base_directory'),
('subject_id', 'container')]),
# Generate midthickness surfaces and save to FreeSurfer derivatives
(get_surfaces, midthickness, [('smoothwm', 'in_file'),
('graymid', 'graymid')]),
(midthickness, save_midthickness, [('out_file', 'surf.@graymid')]),
# Produce valid GIFTI surface files (dense mesh)
(get_surfaces, surface_list, [('smoothwm', 'in1'), ('pial', 'in2'),
('inflated', 'in3')]),
(save_midthickness, surface_list, [('out_file', 'in4')]),
(surface_list, fs2gii, [('out', 'in_file')]),
(fs2gii, fix_surfs, [('converted', 'in_file')]),
(inputnode, fix_surfs, [('fsnative2t1w_xfm', 'transform_file')]),
(fix_surfs, outputnode, [('out_file', 'surfaces')]),
])
return workflow
def init_surface_recon_wf(omp_nthreads, hires, name='surface_recon_wf'):
r"""
Reconstruct anatomical surfaces using FreeSurfer's ``recon-all``.
Reconstruction is performed in three phases.
The first phase initializes the subject with T1w and T2w (if available)
structural images and performs basic reconstruction (``autorecon1``) with the
exception of skull-stripping.
For example, a subject with only one session with T1w and T2w images
would be processed by the following command::
$ recon-all -sd <output dir>/freesurfer -subjid sub-<subject_label> \
-i <bids-root>/sub-<subject_label>/anat/sub-<subject_label>_T1w.nii.gz \
-T2 <bids-root>/sub-<subject_label>/anat/sub-<subject_label>_T2w.nii.gz \
-autorecon1 \
-noskullstrip
The second phase imports an externally computed skull-stripping mask.
This workflow refines the external brainmask using the internal mask
implicit the the FreeSurfer's ``aseg.mgz`` segmentation,
to reconcile ANTs' and FreeSurfer's brain masks.
First, the ``aseg.mgz`` mask from FreeSurfer is refined in two
steps, using binary morphological operations:
1. With a binary closing operation the sulci are included
into the mask. This results in a smoother brain mask
that does not exclude deep, wide sulci.
2. Fill any holes (typically, there could be a hole next to
the pineal gland and the corpora quadrigemina if the great
cerebral brain is segmented out).
Second, the brain mask is grown, including pixels that have a high likelihood
to the GM tissue distribution:
3. Dilate and substract the brain mask, defining the region to search for candidate
pixels that likely belong to cortical GM.
4. Pixels found in the search region that are labeled as GM by ANTs
(during ``antsBrainExtraction.sh``) are directly added to the new mask.
5. Otherwise, estimate GM tissue parameters locally in patches of ``ww`` size,
and test the likelihood of the pixel to belong in the GM distribution.
This procedure is inspired on mindboggle's solution to the problem:
https://github.com/nipy/mindboggle/blob/7f91faaa7664d820fe12ccc52ebaf21d679795e2/mindboggle/guts/segment.py#L1660
The final phase resumes reconstruction, using the T2w image to assist
in finding the pial surface, if available.
See :py:func:`~smriprep.workflows.surfaces.init_autorecon_resume_wf` for details.
Memory annotations for FreeSurfer are based off `their documentation
<https://surfer.nmr.mgh.harvard.edu/fswiki/SystemRequirements>`_.
They specify an allocation of 4GB per subject. Here we define 5GB
to have a certain margin.
.. workflow::
:graph2use: orig
:simple_form: yes
from smriprep.workflows.surfaces import init_surface_recon_wf
wf = init_surface_recon_wf(omp_nthreads=1, hires=True)
**Parameters**
omp_nthreads : int
Maximum number of threads an individual process may use
hires : bool
Enable sub-millimeter preprocessing in FreeSurfer
**Inputs**
t1w
List of T1-weighted structural images
t2w
List of T2-weighted structural images (only first used)
flair
List of FLAIR images
skullstripped_t1
Skull-stripped T1-weighted image (or mask of image)
ants_segs
Brain tissue segmentation from ANTS ``antsBrainExtraction.sh``
corrected_t1
INU-corrected, merged T1-weighted image
subjects_dir
FreeSurfer SUBJECTS_DIR
subject_id
FreeSurfer subject ID
**Outputs**
subjects_dir
FreeSurfer SUBJECTS_DIR
subject_id
FreeSurfer subject ID
t1w2fsnative_xfm
LTA-style affine matrix translating from T1w to FreeSurfer-conformed subject space
fsnative2t1w_xfm
LTA-style affine matrix translating from FreeSurfer-conformed subject space to T1w
surfaces
GIFTI surfaces for gray/white matter boundary, pial surface,
midthickness (or graymid) surface, and inflated surfaces
out_brainmask
Refined brainmask, derived from FreeSurfer's ``aseg`` volume
out_aseg
FreeSurfer's aseg segmentation, in native T1w space
out_aparc
FreeSurfer's aparc+aseg segmentation, in native T1w space
**Subworkflows**
* :py:func:`~smriprep.workflows.surfaces.init_autorecon_resume_wf`
* :py:func:`~smriprep.workflows.surfaces.init_gifti_surface_wf`
"""
workflow = Workflow(name=name)
workflow.__desc__ = """\
Brain surfaces were reconstructed using `recon-all` [FreeSurfer {fs_ver},
RRID:SCR_001847, @fs_reconall], and the brain mask estimated
previously was refined with a custom variation of the method to reconcile
ANTs-derived and FreeSurfer-derived segmentations of the cortical
gray-matter of Mindboggle [RRID:SCR_002438, @mindboggle].
""".format(fs_ver=fs.Info().looseversion() or '<ver>')
inputnode = pe.Node(niu.IdentityInterface(fields=[
't1w', 't2w', 'flair', 'skullstripped_t1', 'corrected_t1', 'ants_segs',
'subjects_dir', 'subject_id'
]),
name='inputnode')
outputnode = pe.Node(niu.IdentityInterface(fields=[
'subjects_dir', 'subject_id', 't1w2fsnative_xfm', 'fsnative2t1w_xfm',
'surfaces', 'out_brainmask', 'out_aseg', 'out_aparc'
]),
name='outputnode')
recon_config = pe.Node(FSDetectInputs(hires_enabled=hires),
name='recon_config')
fov_check = pe.Node(niu.Function(function=_check_cw256), name='fov_check')
autorecon1 = pe.Node(fs.ReconAll(directive='autorecon1',
openmp=omp_nthreads),
name='autorecon1',
n_procs=omp_nthreads,
mem_gb=5)
autorecon1.interface._can_resume = False
autorecon1.interface._always_run = True
skull_strip_extern = pe.Node(FSInjectBrainExtracted(),
name='skull_strip_extern')
fsnative2t1w_xfm = pe.Node(RobustRegister(auto_sens=True,
est_int_scale=True),
name='fsnative2t1w_xfm')
t1w2fsnative_xfm = pe.Node(LTAConvert(out_lta=True, invert=True),
name='t1w2fsnative_xfm')
autorecon_resume_wf = init_autorecon_resume_wf(omp_nthreads=omp_nthreads)
gifti_surface_wf = init_gifti_surface_wf()
aseg_to_native_wf = init_segs_to_native_wf()
aparc_to_native_wf = init_segs_to_native_wf(segmentation='aparc_aseg')
refine = pe.Node(RefineBrainMask(), name='refine')
workflow.connect([
# Configuration
(inputnode, recon_config, [('t1w', 't1w_list'), ('t2w', 't2w_list'),
('flair', 'flair_list')]),
# Passing subjects_dir / subject_id enforces serial order
(inputnode, autorecon1, [('subjects_dir', 'subjects_dir'),
('subject_id', 'subject_id')]),
(autorecon1, skull_strip_extern, [('subjects_dir', 'subjects_dir'),
('subject_id', 'subject_id')]),
(skull_strip_extern, autorecon_resume_wf,
[('subjects_dir', 'inputnode.subjects_dir'),
('subject_id', 'inputnode.subject_id')]),
(autorecon_resume_wf, gifti_surface_wf,
[('outputnode.subjects_dir', 'inputnode.subjects_dir'),
('outputnode.subject_id', 'inputnode.subject_id')]),
# Reconstruction phases
(inputnode, autorecon1, [('t1w', 'T1_files')]),
(inputnode, fov_check, [('t1w', 'in_files')]),
(fov_check, autorecon1, [('out', 'flags')]),
(
recon_config,
autorecon1,
[
('t2w', 'T2_file'),
('flair', 'FLAIR_file'),
('hires', 'hires'),
# First run only (recon-all saves expert options)
('mris_inflate', 'mris_inflate')
]),
(inputnode, skull_strip_extern, [('skullstripped_t1', 'in_brain')]),
(recon_config, autorecon_resume_wf, [('use_t2w', 'inputnode.use_T2'),
('use_flair',
'inputnode.use_FLAIR')]),
# Construct transform from FreeSurfer conformed image to sMRIPrep
# reoriented image
(inputnode, fsnative2t1w_xfm, [('t1w', 'target_file')]),
(autorecon1, fsnative2t1w_xfm, [('T1', 'source_file')]),
(fsnative2t1w_xfm, gifti_surface_wf, [('out_reg_file',
'inputnode.fsnative2t1w_xfm')]),
(fsnative2t1w_xfm, t1w2fsnative_xfm, [('out_reg_file', 'in_lta')]),
# Refine ANTs mask, deriving new mask from FS' aseg
(inputnode, refine, [('corrected_t1', 'in_anat'),
('ants_segs', 'in_ants')]),
(inputnode, aseg_to_native_wf, [('corrected_t1', 'inputnode.in_file')
]),
(autorecon_resume_wf, aseg_to_native_wf,
[('outputnode.subjects_dir', 'inputnode.subjects_dir'),
('outputnode.subject_id', 'inputnode.subject_id')]),
(inputnode, aparc_to_native_wf, [('corrected_t1', 'inputnode.in_file')
]),
(autorecon_resume_wf, aparc_to_native_wf,
[('outputnode.subjects_dir', 'inputnode.subjects_dir'),
('outputnode.subject_id', 'inputnode.subject_id')]),
(aseg_to_native_wf, refine, [('outputnode.out_file', 'in_aseg')]),
# Output
(autorecon_resume_wf, outputnode,
[('outputnode.subjects_dir', 'subjects_dir'),
('outputnode.subject_id', 'subject_id')]),
(gifti_surface_wf, outputnode, [('outputnode.surfaces', 'surfaces')]),
(t1w2fsnative_xfm, outputnode, [('out_lta', 't1w2fsnative_xfm')]),
(fsnative2t1w_xfm, outputnode, [('out_reg_file', 'fsnative2t1w_xfm')]),
(refine, outputnode, [('out_file', 'out_brainmask')]),
(aseg_to_native_wf, outputnode, [('outputnode.out_file', 'out_aseg')]),
(aparc_to_native_wf, outputnode, [('outputnode.out_file', 'out_aparc')
]),
])
return workflow
def init_autorecon_resume_wf(omp_nthreads, name='autorecon_resume_wf'):
r"""
Resume recon-all execution, assuming the `-autorecon1` stage has been completed.
In order to utilize resources efficiently, this is broken down into five
sub-stages; after the first stage, the second and third stages may be run
simultaneously, and the fourth and fifth stages may be run simultaneously,
if resources permit::
$ recon-all -sd <output dir>/freesurfer -subjid sub-<subject_label> \
-autorecon2-volonly
$ recon-all -sd <output dir>/freesurfer -subjid sub-<subject_label> \
-autorecon-hemi lh \
-noparcstats -nocortparc2 -noparcstats2 -nocortparc3 \
-noparcstats3 -nopctsurfcon -nohyporelabel -noaparc2aseg \
-noapas2aseg -nosegstats -nowmparc -nobalabels
$ recon-all -sd <output dir>/freesurfer -subjid sub-<subject_label> \
-autorecon-hemi rh \
-noparcstats -nocortparc2 -noparcstats2 -nocortparc3 \
-noparcstats3 -nopctsurfcon -nohyporelabel -noaparc2aseg \
-noapas2aseg -nosegstats -nowmparc -nobalabels
$ recon-all -sd <output dir>/freesurfer -subjid sub-<subject_label> \
-autorecon3 -hemi lh -T2pial
$ recon-all -sd <output dir>/freesurfer -subjid sub-<subject_label> \
-autorecon3 -hemi rh -T2pial
The excluded steps in the second and third stages (``-no<option>``) are not
fully hemisphere independent, and are therefore postponed to the final two
stages.
.. workflow::
:graph2use: orig
:simple_form: yes
from smriprep.workflows.surfaces import init_autorecon_resume_wf
wf = init_autorecon_resume_wf(omp_nthreads=1)
**Inputs**
subjects_dir
FreeSurfer SUBJECTS_DIR
subject_id
FreeSurfer subject ID
use_T2
Refine pial surface using T2w image
use_FLAIR
Refine pial surface using FLAIR image
**Outputs**
subjects_dir
FreeSurfer SUBJECTS_DIR
subject_id
FreeSurfer subject ID
"""
workflow = Workflow(name=name)
inputnode = pe.Node(niu.IdentityInterface(
fields=['subjects_dir', 'subject_id', 'use_T2', 'use_FLAIR']),
name='inputnode')
outputnode = pe.Node(
niu.IdentityInterface(fields=['subjects_dir', 'subject_id']),
name='outputnode')
autorecon2_vol = pe.Node(fs.ReconAll(directive='autorecon2-volonly',
openmp=omp_nthreads),
n_procs=omp_nthreads,
mem_gb=5,
name='autorecon2_vol')
autorecon2_vol.interface._always_run = True
autorecon_surfs = pe.MapNode(fs.ReconAll(
directive='autorecon-hemi',
flags=[
'-noparcstats', '-nocortparc2', '-noparcstats2', '-nocortparc3',
'-noparcstats3', '-nopctsurfcon', '-nohyporelabel',
'-noaparc2aseg', '-noapas2aseg', '-nosegstats', '-nowmparc',
'-nobalabels'
],
openmp=omp_nthreads),
iterfield='hemi',
n_procs=omp_nthreads,
mem_gb=5,
name='autorecon_surfs')
autorecon_surfs.inputs.hemi = ['lh', 'rh']
autorecon_surfs.interface._always_run = True
autorecon3 = pe.MapNode(fs.ReconAll(directive='autorecon3',
openmp=omp_nthreads),
iterfield='hemi',
n_procs=omp_nthreads,
mem_gb=5,
name='autorecon3')
autorecon3.inputs.hemi = ['lh', 'rh']
autorecon3.interface._always_run = True
def _dedup(in_list):
vals = set(in_list)
if len(vals) > 1:
raise ValueError(
"Non-identical values can't be deduplicated:\n{!r}".format(
in_list))
return vals.pop()
workflow.connect([
(inputnode, autorecon3, [('use_T2', 'use_T2'),
('use_FLAIR', 'use_FLAIR')]),
(inputnode, autorecon2_vol, [('subjects_dir', 'subjects_dir'),
('subject_id', 'subject_id')]),
(autorecon2_vol, autorecon_surfs, [('subjects_dir', 'subjects_dir'),
('subject_id', 'subject_id')]),
(autorecon_surfs, autorecon3,
[(('subjects_dir', _dedup), 'subjects_dir'),
(('subject_id', _dedup), 'subject_id')]),
(autorecon3, outputnode, [(('subjects_dir', _dedup), 'subjects_dir'),
(('subject_id', _dedup), 'subject_id')]),
])
return workflow
def init_fsl_bbr_wf(use_bbr,
bold2t1w_dof,
bold2t1w_init,
sloppy=False,
name='fsl_bbr_wf'):
"""
Build a workflow to run FSL's ``flirt``.
This workflow uses FSL FLIRT to register a BOLD image to a T1-weighted
structural image, using a boundary-based registration (BBR) cost function.
It is a counterpart to :py:func:`~fmriprep.workflows.bold.registration.init_bbreg_wf`,
which performs the same task using FreeSurfer's ``bbregister``.
The ``use_bbr`` option permits a high degree of control over registration.
If ``False``, standard, rigid coregistration will be performed by FLIRT.
If ``True``, FLIRT-BBR will be seeded with the initial transform found by
the rigid coregistration.
If ``None``, after FLIRT-BBR is run, the resulting affine transform
will be compared to the initial transform found by FLIRT.
Excessive deviation will result in rejecting the BBR refinement and
accepting the original, affine registration.
Workflow Graph
.. workflow ::
:graph2use: orig
:simple_form: yes
from fmriprep.workflows.bold.registration import init_fsl_bbr_wf
wf = init_fsl_bbr_wf(use_bbr=True, bold2t1w_dof=9, bold2t1w_init='register')
Parameters
----------
use_bbr : :obj:`bool` or None
Enable/disable boundary-based registration refinement.
If ``None``, test BBR result for distortion before accepting.
bold2t1w_dof : 6, 9 or 12
Degrees-of-freedom for BOLD-T1w registration
bold2t1w_init : str, 'header' or 'register'
If ``'header'``, use header information for initialization of BOLD and T1 images.
If ``'register'``, align volumes by their centers.
name : :obj:`str`, optional
Workflow name (default: fsl_bbr_wf)
Inputs
------
in_file
Reference BOLD image to be registered
t1w_brain
Skull-stripped T1-weighted structural image
t1w_dseg
FAST segmentation of ``t1w_brain``
fsnative2t1w_xfm
Unused (see :py:func:`~fmriprep.workflows.bold.registration.init_bbreg_wf`)
subjects_dir
Unused (see :py:func:`~fmriprep.workflows.bold.registration.init_bbreg_wf`)
subject_id
Unused (see :py:func:`~fmriprep.workflows.bold.registration.init_bbreg_wf`)
Outputs
-------
itk_bold_to_t1
Affine transform from ``ref_bold_brain`` to T1w space (ITK format)
itk_t1_to_bold
Affine transform from T1 space to BOLD space (ITK format)
out_report
Reportlet for assessing registration quality
fallback
Boolean indicating whether BBR was rejected (rigid FLIRT registration returned)
"""
from niworkflows.engine.workflows import LiterateWorkflow as Workflow
from niworkflows.utils.images import dseg_label as _dseg_label
from niworkflows.interfaces.freesurfer import PatchedLTAConvert as LTAConvert
from niworkflows.interfaces.registration import FLIRTRPT
workflow = Workflow(name=name)
workflow.__desc__ = """\
The BOLD reference was then co-registered to the T1w reference using
`flirt` [FSL {fsl_ver}, @flirt] with the boundary-based registration [@bbr]
cost-function.
Co-registration was configured with nine degrees of freedom to account
for distortions remaining in the BOLD reference.
""".format(fsl_ver=FLIRTRPT().version or '<ver>')
inputnode = pe.Node(
niu.IdentityInterface([
'in_file',
'fsnative2t1w_xfm',
'subjects_dir',
'subject_id', # BBRegister
't1w_dseg',
't1w_brain'
]), # FLIRT BBR
name='inputnode')
outputnode = pe.Node(niu.IdentityInterface(
['itk_bold_to_t1', 'itk_t1_to_bold', 'out_report', 'fallback']),
name='outputnode')
wm_mask = pe.Node(niu.Function(function=_dseg_label), name='wm_mask')
wm_mask.inputs.label = 2 # BIDS default is WM=2
flt_bbr_init = pe.Node(FLIRTRPT(dof=6,
generate_report=not use_bbr,
uses_qform=True),
name='flt_bbr_init')
if bold2t1w_init not in ("register", "header"):
raise ValueError(
f"Unknown BOLD-T1w initialization option: {bold2t1w_init}")
if bold2t1w_init == "header":
raise NotImplementedError(
"Header-based registration initialization not supported for FSL")
invt_bbr = pe.Node(fsl.ConvertXFM(invert_xfm=True),
name='invt_bbr',
mem_gb=DEFAULT_MEMORY_MIN_GB)
# BOLD to T1 transform matrix is from fsl, using c3 tools to convert to
# something ANTs will like.
fsl2itk_fwd = pe.Node(c3.C3dAffineTool(fsl2ras=True, itk_transform=True),
name='fsl2itk_fwd',
mem_gb=DEFAULT_MEMORY_MIN_GB)
fsl2itk_inv = pe.Node(c3.C3dAffineTool(fsl2ras=True, itk_transform=True),
name='fsl2itk_inv',
mem_gb=DEFAULT_MEMORY_MIN_GB)
workflow.connect([
(inputnode, flt_bbr_init, [('in_file', 'in_file'),
('t1w_brain', 'reference')]),
(inputnode, fsl2itk_fwd, [('t1w_brain', 'reference_file'),
('in_file', 'source_file')]),
(inputnode, fsl2itk_inv, [('in_file', 'reference_file'),
('t1w_brain', 'source_file')]),
(invt_bbr, fsl2itk_inv, [('out_file', 'transform_file')]),
(fsl2itk_fwd, outputnode, [('itk_transform', 'itk_bold_to_t1')]),
(fsl2itk_inv, outputnode, [('itk_transform', 'itk_t1_to_bold')]),
])
# Short-circuit workflow building, use rigid registration
if use_bbr is False:
workflow.connect([
(flt_bbr_init, invt_bbr, [('out_matrix_file', 'in_file')]),
(flt_bbr_init, fsl2itk_fwd, [('out_matrix_file', 'transform_file')
]),
(flt_bbr_init, outputnode, [('out_report', 'out_report')]),
])
outputnode.inputs.fallback = True
return workflow
flt_bbr = pe.Node(FLIRTRPT(cost_func='bbr',
dof=bold2t1w_dof,
generate_report=True),
name='flt_bbr')
FSLDIR = os.getenv('FSLDIR')
if FSLDIR:
flt_bbr.inputs.schedule = op.join(FSLDIR, 'etc/flirtsch/bbr.sch')
else:
# Should mostly be hit while building docs
LOGGER.warning("FSLDIR unset - using packaged BBR schedule")
flt_bbr.inputs.schedule = pkgr.resource_filename(
'fmriprep', 'data/flirtsch/bbr.sch')
workflow.connect([
(inputnode, wm_mask, [('t1w_dseg', 'in_seg')]),
(inputnode, flt_bbr, [('in_file', 'in_file')]),
(flt_bbr_init, flt_bbr, [('out_matrix_file', 'in_matrix_file')]),
])
if sloppy is True:
downsample = pe.Node(niu.Function(
function=_conditional_downsampling,
output_names=["out_file", "out_mask"]),
name='downsample')
workflow.connect([
(inputnode, downsample, [("t1w_brain", "in_file")]),
(wm_mask, downsample, [("out", "in_mask")]),
(downsample, flt_bbr, [('out_file', 'reference'),
('out_mask', 'wm_seg')]),
])
else:
workflow.connect([
(inputnode, flt_bbr, [('t1w_brain', 'reference')]),
(wm_mask, flt_bbr, [('out', 'wm_seg')]),
])
# Short-circuit workflow building, use boundary-based registration
if use_bbr is True:
workflow.connect([
(flt_bbr, invt_bbr, [('out_matrix_file', 'in_file')]),
(flt_bbr, fsl2itk_fwd, [('out_matrix_file', 'transform_file')]),
(flt_bbr, outputnode, [('out_report', 'out_report')]),
])
outputnode.inputs.fallback = False
return workflow
transforms = pe.Node(niu.Merge(2),
run_without_submitting=True,
name='transforms')
reports = pe.Node(niu.Merge(2),
run_without_submitting=True,
name='reports')
compare_transforms = pe.Node(niu.Function(function=compare_xforms),
name='compare_transforms')
select_transform = pe.Node(niu.Select(),
run_without_submitting=True,
name='select_transform')
select_report = pe.Node(niu.Select(),
run_without_submitting=True,
name='select_report')
fsl_to_lta = pe.MapNode(LTAConvert(out_lta=True),
iterfield=['in_fsl'],
name='fsl_to_lta')
workflow.connect([
(flt_bbr, transforms, [('out_matrix_file', 'in1')]),
(flt_bbr_init, transforms, [('out_matrix_file', 'in2')]),
# Convert FSL transforms to LTA (RAS2RAS) transforms and compare
(inputnode, fsl_to_lta, [('in_file', 'source_file'),
('t1w_brain', 'target_file')]),
(transforms, fsl_to_lta, [('out', 'in_fsl')]),
(fsl_to_lta, compare_transforms, [('out_lta', 'lta_list')]),
(compare_transforms, outputnode, [('out', 'fallback')]),
# Select output transform
(transforms, select_transform, [('out', 'inlist')]),
(compare_transforms, select_transform, [('out', 'index')]),
(select_transform, invt_bbr, [('out', 'in_file')]),
(select_transform, fsl2itk_fwd, [('out', 'transform_file')]),
(flt_bbr, reports, [('out_report', 'in1')]),
(flt_bbr_init, reports, [('out_report', 'in2')]),
(reports, select_report, [('out', 'inlist')]),
(compare_transforms, select_report, [('out', 'index')]),
(select_report, outputnode, [('out', 'out_report')]),
])
return workflow
def init_bold_preproc_report_wf(mem_gb,
reportlets_dir,
name='bold_preproc_report_wf'):
"""
This workflow generates and saves a reportlet showing the effect of resampling
the BOLD signal using the standard deviation maps.
.. workflow::
:graph2use: orig
:simple_form: yes
from fmriprep.workflows.bold.resampling import init_bold_preproc_report_wf
wf = init_bold_preproc_report_wf(mem_gb=1, reportlets_dir='.')
**Parameters**
mem_gb : float
Size of BOLD file in GB
reportlets_dir : str
Directory in which to save reportlets
name : str, optional
Workflow name (default: bold_preproc_report_wf)
**Inputs**
in_pre
BOLD time-series, before resampling
in_post
BOLD time-series, after resampling
name_source
BOLD series NIfTI file
Used to recover original information lost during processing
"""
from nipype.algorithms.confounds import TSNR
from niworkflows.interfaces import SimpleBeforeAfter
workflow = Workflow(name=name)
inputnode = pe.Node(
niu.IdentityInterface(fields=['in_pre', 'in_post', 'name_source']),
name='inputnode')
pre_tsnr = pe.Node(TSNR(), name='pre_tsnr', mem_gb=mem_gb * 4.5)
pos_tsnr = pe.Node(TSNR(), name='pos_tsnr', mem_gb=mem_gb * 4.5)
bold_rpt = pe.Node(SimpleBeforeAfter(), name='bold_rpt', mem_gb=0.1)
ds_report_bold = pe.Node(DerivativesDataSink(base_directory=reportlets_dir,
desc='preproc',
keep_dtype=True),
name='ds_report_bold',
mem_gb=DEFAULT_MEMORY_MIN_GB,
run_without_submitting=True)
workflow.connect([
(inputnode, ds_report_bold, [('name_source', 'source_file')]),
(inputnode, pre_tsnr, [('in_pre', 'in_file')]),
(inputnode, pos_tsnr, [('in_post', 'in_file')]),
(pre_tsnr, bold_rpt, [('stddev_file', 'before')]),
(pos_tsnr, bold_rpt, [('stddev_file', 'after')]),
(bold_rpt, ds_report_bold, [('out_report', 'in_file')]),
])
return workflow
def init_bold_surf_wf(mem_gb,
output_spaces,
medial_surface_nan,
name='bold_surf_wf'):
"""
This workflow samples functional images to FreeSurfer surfaces
For each vertex, the cortical ribbon is sampled at six points (spaced 20% of thickness apart)
and averaged.
Outputs are in GIFTI format.
.. workflow::
:graph2use: colored
:simple_form: yes
from fmriprep.workflows.bold import init_bold_surf_wf
wf = init_bold_surf_wf(mem_gb=0.1,
output_spaces=['T1w', 'fsnative',
'template', 'fsaverage5'],
medial_surface_nan=False)
**Parameters**
output_spaces : list
List of output spaces functional images are to be resampled to
Target spaces beginning with ``fs`` will be selected for resampling,
such as ``fsaverage`` or related template spaces
If the list contains ``fsnative``, images will be resampled to the
individual subject's native surface
medial_surface_nan : bool
Replace medial wall values with NaNs on functional GIFTI files
**Inputs**
source_file
Motion-corrected BOLD series in T1 space
t1_preproc
Bias-corrected structural template image
subjects_dir
FreeSurfer SUBJECTS_DIR
subject_id
FreeSurfer subject ID
t1_2_fsnative_forward_transform
LTA-style affine matrix translating from T1w to FreeSurfer-conformed subject space
**Outputs**
surfaces
BOLD series, resampled to FreeSurfer surfaces
"""
# Ensure volumetric spaces do not sneak into this workflow
spaces = [space for space in output_spaces if space.startswith('fs')]
workflow = Workflow(name=name)
if spaces:
workflow.__desc__ = """\
The BOLD time-series, were resampled to surfaces on the following
spaces: {out_spaces}.
""".format(out_spaces=', '.join(['*%s*' % s for s in spaces]))
inputnode = pe.Node(niu.IdentityInterface(fields=[
'source_file', 't1_preproc', 'subject_id', 'subjects_dir',
't1_2_fsnative_forward_transform'
]),
name='inputnode')
outputnode = pe.Node(niu.IdentityInterface(fields=['surfaces']),
name='outputnode')
def select_target(subject_id, space):
""" Given a source subject ID and a target space, get the target subject ID """
return subject_id if space == 'fsnative' else space
targets = pe.MapNode(niu.Function(function=select_target),
iterfield=['space'],
name='targets',
mem_gb=DEFAULT_MEMORY_MIN_GB)
targets.inputs.space = spaces
# Rename the source file to the output space to simplify naming later
rename_src = pe.MapNode(niu.Rename(format_string='%(subject)s',
keep_ext=True),
iterfield='subject',
name='rename_src',
run_without_submitting=True,
mem_gb=DEFAULT_MEMORY_MIN_GB)
rename_src.inputs.subject = spaces
resampling_xfm = pe.Node(LTAConvert(in_lta='identity.nofile',
out_lta=True),
name='resampling_xfm')
set_xfm_source = pe.Node(ConcatenateLTA(out_type='RAS2RAS'),
name='set_xfm_source')
sampler = pe.MapNode(fs.SampleToSurface(sampling_method='average',
sampling_range=(0, 1, 0.2),
sampling_units='frac',
interp_method='trilinear',
cortex_mask=True,
override_reg_subj=True,
out_type='gii'),
iterfield=['source_file', 'target_subject'],
iterables=('hemi', ['lh', 'rh']),
name='sampler',
mem_gb=mem_gb * 3)
medial_nans = pe.MapNode(MedialNaNs(),
iterfield=['in_file', 'target_subject'],
name='medial_nans',
mem_gb=DEFAULT_MEMORY_MIN_GB)
merger = pe.JoinNode(niu.Merge(1, ravel_inputs=True),
name='merger',
joinsource='sampler',
joinfield=['in1'],
run_without_submitting=True,
mem_gb=DEFAULT_MEMORY_MIN_GB)
update_metadata = pe.MapNode(GiftiSetAnatomicalStructure(),
iterfield='in_file',
name='update_metadata',
mem_gb=DEFAULT_MEMORY_MIN_GB)
workflow.connect([
(inputnode, targets, [('subject_id', 'subject_id')]),
(inputnode, rename_src, [('source_file', 'in_file')]),
(inputnode, resampling_xfm, [('source_file', 'source_file'),
('t1_preproc', 'target_file')]),
(inputnode, set_xfm_source, [('t1_2_fsnative_forward_transform',
'in_lta2')]),
(resampling_xfm, set_xfm_source, [('out_lta', 'in_lta1')]),
(inputnode, sampler, [('subjects_dir', 'subjects_dir'),
('subject_id', 'subject_id')]),
(set_xfm_source, sampler, [('out_file', 'reg_file')]),
(targets, sampler, [('out', 'target_subject')]),
(rename_src, sampler, [('out_file', 'source_file')]),
(merger, update_metadata, [('out', 'in_file')]),
(update_metadata, outputnode, [('out_file', 'surfaces')]),
])
if medial_surface_nan:
workflow.connect([
(inputnode, medial_nans, [('subjects_dir', 'subjects_dir')]),
(sampler, medial_nans, [('out_file', 'in_file')]),
(targets, medial_nans, [('out', 'target_subject')]),
(medial_nans, merger, [('out_file', 'in1')]),
])
else:
workflow.connect(sampler, 'out_file', merger, 'in1')
return workflow
def init_3dQwarp_wf(omp_nthreads=1, debug=False, name="pepolar_estimate_wf"):
"""
Create the PEPOLAR field estimation workflow based on AFNI's ``3dQwarp``.
This workflow takes in two EPI files that MUST have opposed
:abbr:`PE (phase-encoding)` direction.
Therefore, EPIs with orthogonal PE directions are not supported.
Workflow Graph
.. workflow ::
:graph2use: orig
:simple_form: yes
from sdcflows.workflows.fit.pepolar import init_3dQwarp_wf
wf = init_3dQwarp_wf()
Parameters
----------
debug : :obj:`bool`
Whether a fast configuration of topup (less accurate) should be applied.
name : :obj:`str`
Name for this workflow
omp_nthreads : :obj:`int`
Parallelize internal tasks across the number of CPUs given by this option.
Inputs
------
in_data : :obj:`list` of :obj:`str`
A list of two EPI files, the first of which will be taken as reference.
Outputs
-------
fmap : :obj:`str`
The path of the estimated fieldmap.
fmap_ref : :obj:`str`
The path of an unwarped conversion of the first element of ``in_data``.
"""
from nipype.interfaces import afni
from niworkflows.interfaces.header import CopyHeader
from niworkflows.interfaces.fixes import (
FixHeaderRegistration as Registration,
FixHeaderApplyTransforms as ApplyTransforms,
)
from niworkflows.interfaces.freesurfer import StructuralReference
from niworkflows.func.util import init_enhance_and_skullstrip_bold_wf
from ...utils.misc import front as _front, last as _last
from ...interfaces.utils import Flatten, ConvertWarp
workflow = Workflow(name=name)
workflow.__desc__ = f"""{_PEPOLAR_DESC} \
with `3dQwarp` (@afni; AFNI {''.join(['%02d' % v for v in afni.Info().version() or []])}).
"""
inputnode = pe.Node(niu.IdentityInterface(fields=["in_data", "metadata"]),
name="inputnode")
outputnode = pe.Node(niu.IdentityInterface(fields=["fmap", "fmap_ref"]),
name="outputnode")
flatten = pe.Node(Flatten(), name="flatten")
sort_pe = pe.Node(
niu.Function(function=_sorted_pe,
output_names=["sorted", "qwarp_args"]),
name="sort_pe",
run_without_submitting=True,
)
merge_pes = pe.MapNode(
StructuralReference(
auto_detect_sensitivity=True,
initial_timepoint=1,
fixed_timepoint=True, # Align to first image
intensity_scaling=True,
# 7-DOF (rigid + intensity)
no_iteration=True,
subsample_threshold=200,
out_file="template.nii.gz",
),
name="merge_pes",
iterfield=["in_files"],
)
pe0_wf = init_enhance_and_skullstrip_bold_wf(omp_nthreads=omp_nthreads,
name="pe0_wf")
pe1_wf = init_enhance_and_skullstrip_bold_wf(omp_nthreads=omp_nthreads,
name="pe1_wf")
align_pes = pe.Node(
Registration(
from_file=_pkg_fname("sdcflows", "data/translation_rigid.json"),
output_warped_image=True,
),
name="align_pes",
n_procs=omp_nthreads,
)
qwarp = pe.Node(
afni.QwarpPlusMinus(
blur=[-1, -1],
environ={"OMP_NUM_THREADS": f"{min(omp_nthreads, 4)}"},
minpatch=9,
nopadWARP=True,
noweight=True,
pblur=[0.05, 0.05],
),
name="qwarp",
n_procs=min(omp_nthreads, 4),
)
to_ants = pe.Node(ConvertWarp(), name="to_ants", mem_gb=0.01)
cphdr_warp = pe.Node(CopyHeader(), name="cphdr_warp", mem_gb=0.01)
unwarp_reference = pe.Node(
ApplyTransforms(
dimension=3,
float=True,
interpolation="LanczosWindowedSinc",
),
name="unwarp_reference",
)
# fmt: off
workflow.connect([
(inputnode, flatten, [("in_data", "in_data"),
("metadata", "in_meta")]),
(flatten, sort_pe, [("out_list", "inlist")]),
(sort_pe, qwarp, [("qwarp_args", "args")]),
(sort_pe, merge_pes, [("sorted", "in_files")]),
(merge_pes, pe0_wf, [(("out_file", _front), "inputnode.in_file")]),
(merge_pes, pe1_wf, [(("out_file", _last), "inputnode.in_file")]),
(pe0_wf, align_pes, [("outputnode.skull_stripped_file", "fixed_image")
]),
(pe1_wf, align_pes, [("outputnode.skull_stripped_file", "moving_image")
]),
(pe0_wf, qwarp, [("outputnode.skull_stripped_file", "in_file")]),
(align_pes, qwarp, [("warped_image", "base_file")]),
(inputnode, cphdr_warp, [(("in_data", _front), "hdr_file")]),
(qwarp, cphdr_warp, [("source_warp", "in_file")]),
(cphdr_warp, to_ants, [("out_file", "in_file")]),
(to_ants, unwarp_reference, [("out_file", "transforms")]),
(inputnode, unwarp_reference, [("in_reference", "reference_image"),
("in_reference", "input_image")]),
(unwarp_reference, outputnode, [("output_image", "fmap_ref")]),
(to_ants, outputnode, [("out_file", "fmap")]),
])
# fmt: on
return workflow
def init_prepare_epi_wf(omp_nthreads, matched_pe=False, name="prepare_epi_wf"):
"""
Prepare opposed-PE EPI images for PE-POLAR SDC.
This workflow takes in a set of EPI files and returns two 3D volumes with
matching and opposed PE directions, ready to be used in field distortion
estimation.
The procedure involves: estimating a robust template using FreeSurfer's
``mri_robust_template``, bias field correction using ANTs ``N4BiasFieldCorrection``
and AFNI ``3dUnifize``, skullstripping using FSL BET and AFNI ``3dAutomask``,
and rigid coregistration to the reference using ANTs.
.. workflow ::
:graph2use: orig
:simple_form: yes
from sdcflows.workflows.pepolar import init_prepare_epi_wf
wf = init_prepare_epi_wf(omp_nthreads=8)
**Parameters**:
matched_pe : bool
Whether the input ``fmaps_epi`` will contain images with matched
PE blips or not. Please use :func:`sdcflows.workflows.pepolar.check_pes`
to determine whether they exist or not.
name : str
Name for this workflow
omp_nthreads : int
Parallelize internal tasks across the number of CPUs given by this option.
**Inputs**:
epi_pe : str
Phase-encoding direction of the EPI image to be corrected.
maps_pe : list of tuple(pathlike, str)
list of 3D or 4D NIfTI images
ref_brain
coregistration reference (skullstripped and bias field corrected)
**Outputs**:
opposed_pe : pathlike
single 3D NIfTI file
matched_pe : pathlike
single 3D NIfTI file
"""
inputnode = pe.Node(
niu.IdentityInterface(fields=['epi_pe', 'maps_pe', 'ref_brain']),
name='inputnode')
outputnode = pe.Node(
niu.IdentityInterface(fields=['opposed_pe', 'matched_pe']),
name='outputnode')
ants_settings = pkgr.resource_filename('sdcflows',
'data/translation_rigid.json')
split = pe.Node(niu.Function(function=_split_epi_lists), name='split')
merge_op = pe.Node(
StructuralReference(
auto_detect_sensitivity=True,
initial_timepoint=1,
fixed_timepoint=True, # Align to first image
intensity_scaling=True,
# 7-DOF (rigid + intensity)
no_iteration=True,
subsample_threshold=200,
out_file='template.nii.gz'),
name='merge_op')
ref_op_wf = init_enhance_and_skullstrip_bold_wf(omp_nthreads=omp_nthreads,
name='ref_op_wf')
op2ref_reg = pe.Node(ants.Registration(from_file=ants_settings,
output_warped_image=True),
name='op2ref_reg',
n_procs=omp_nthreads)
workflow = Workflow(name=name)
workflow.connect([
(inputnode, split, [('maps_pe', 'in_files'), ('epi_pe', 'pe_dir')]),
(split, merge_op, [(('out', _front), 'in_files')]),
(merge_op, ref_op_wf, [('out_file', 'inputnode.in_file')]),
(ref_op_wf, op2ref_reg, [('outputnode.skull_stripped_file',
'moving_image')]),
(inputnode, op2ref_reg, [('ref_brain', 'fixed_image')]),
(op2ref_reg, outputnode, [('warped_image', 'opposed_pe')]),
])
if not matched_pe:
workflow.connect([
(inputnode, outputnode, [('ref_brain', 'matched_pe')]),
])
return workflow
merge_ma = pe.Node(
StructuralReference(
auto_detect_sensitivity=True,
initial_timepoint=1,
fixed_timepoint=True, # Align to first image
intensity_scaling=True,
# 7-DOF (rigid + intensity)
no_iteration=True,
subsample_threshold=200,
out_file='template.nii.gz'),
name='merge_ma')
ref_ma_wf = init_enhance_and_skullstrip_bold_wf(omp_nthreads=omp_nthreads,
name='ref_ma_wf')
ma2ref_reg = pe.Node(ants.Registration(from_file=ants_settings,
output_warped_image=True),
name='ma2ref_reg',
n_procs=omp_nthreads)
workflow.connect([
(split, merge_ma, [(('out', _last), 'in_files')]),
(merge_ma, ref_ma_wf, [('out_file', 'inputnode.in_file')]),
(ref_ma_wf, ma2ref_reg, [('outputnode.skull_stripped_file',
'moving_image')]),
(inputnode, ma2ref_reg, [('ref_brain', 'fixed_image')]),
(ma2ref_reg, outputnode, [('warped_image', 'matched_pe')]),
])
return workflow
def init_topup_wf(omp_nthreads=1, debug=False, name="pepolar_estimate_wf"):
"""
Create the PEPOLAR field estimation workflow based on FSL's ``topup``.
Workflow Graph
.. workflow ::
:graph2use: orig
:simple_form: yes
from sdcflows.workflows.fit.pepolar import init_topup_wf
wf = init_topup_wf()
Parameters
----------
debug : :obj:`bool`
Whether a fast configuration of topup (less accurate) should be applied.
name : :obj:`str`
Name for this workflow
omp_nthreads : :obj:`int`
Parallelize internal tasks across the number of CPUs given by this option.
Inputs
------
in_data : :obj:`list` of :obj:`str`
A list of EPI files that will be fed into TOPUP.
metadata : :obj:`list` of :obj:`dict`
A list of dictionaries containing the metadata corresponding to each file
in ``in_data``.
Outputs
-------
fmap : :obj:`str`
The path of the estimated fieldmap.
fmap_ref : :obj:`str`
The path of an unwarped conversion of files in ``in_data``.
fmap_mask : :obj:`str`
The path of mask corresponding to the ``fmap_ref`` output.
fmap_coeff : :obj:`str` or :obj:`list` of :obj:`str`
The path(s) of the B-Spline coefficients supporting the fieldmap.
"""
from nipype.interfaces.fsl.epi import TOPUP
from niworkflows.interfaces.nibabel import MergeSeries
from niworkflows.interfaces.images import IntraModalMerge
from ...interfaces.epi import GetReadoutTime
from ...interfaces.utils import Flatten
from ...interfaces.bspline import TOPUPCoeffReorient
from ..ancillary import init_brainextraction_wf
workflow = Workflow(name=name)
workflow.__postdesc__ = f"""\
{_PEPOLAR_DESC} with `topup` (@topup; FSL {TOPUP().version}).
"""
inputnode = pe.Node(niu.IdentityInterface(fields=INPUT_FIELDS),
name="inputnode")
outputnode = pe.Node(
niu.IdentityInterface(fields=[
"fmap",
"fmap_ref",
"fmap_coeff",
"fmap_mask",
"jacobians",
"xfms",
"out_warps",
]),
name="outputnode",
)
flatten = pe.Node(Flatten(), name="flatten")
concat_blips = pe.Node(MergeSeries(), name="concat_blips")
readout_time = pe.MapNode(
GetReadoutTime(),
name="readout_time",
iterfield=["metadata", "in_file"],
run_without_submitting=True,
)
topup = pe.Node(
TOPUP(config=_pkg_fname("sdcflows",
f"data/flirtsch/b02b0{'_quick' * debug}.cnf")),
name="topup",
)
merge_corrected = pe.Node(IntraModalMerge(hmc=False, to_ras=False),
name="merge_corrected")
fix_coeff = pe.Node(TOPUPCoeffReorient(),
name="fix_coeff",
run_without_submitting=True)
brainextraction_wf = init_brainextraction_wf()
# fmt: off
workflow.connect([
(inputnode, flatten, [("in_data", "in_data"),
("metadata", "in_meta")]),
(flatten, readout_time, [("out_data", "in_file"),
("out_meta", "metadata")]),
(flatten, concat_blips, [("out_data", "in_files")]),
(flatten, topup, [(("out_meta", _pe2fsl), "encoding_direction")]),
(readout_time, topup, [("readout_time", "readout_times")]),
(concat_blips, topup, [("out_file", "in_file")]),
(topup, merge_corrected, [("out_corrected", "in_files")]),
(topup, fix_coeff, [("out_fieldcoef", "in_coeff"),
("out_corrected", "fmap_ref")]),
(topup, outputnode, [("out_field", "fmap"), ("out_jacs", "jacobians"),
("out_mats", "xfms"),
("out_warps", "out_warps")]),
(merge_corrected, brainextraction_wf, [("out_avg", "inputnode.in_file")
]),
(merge_corrected, outputnode, [("out_avg", "fmap_ref")]),
(brainextraction_wf, outputnode, [("outputnode.out_mask", "fmap_mask")
]),
(fix_coeff, outputnode, [("out_coeff", "fmap_coeff")]),
])
# fmt: on
return workflow
def init_smriprep_wf(
debug,
fast_track,
freesurfer,
fs_subjects_dir,
hires,
layout,
longitudinal,
low_mem,
omp_nthreads,
output_dir,
run_uuid,
skull_strip_mode,
skull_strip_fixed_seed,
skull_strip_template,
spaces,
subject_list,
work_dir,
bids_filters,
):
"""
Create the execution graph of *sMRIPrep*, with a sub-workflow for each subject.
If FreeSurfer's ``recon-all`` is to be run, a FreeSurfer derivatives folder is
created and populated with any needed template subjects.
Workflow Graph
.. workflow::
:graph2use: orig
:simple_form: yes
import os
from collections import namedtuple
BIDSLayout = namedtuple('BIDSLayout', ['root'])
os.environ['FREESURFER_HOME'] = os.getcwd()
from smriprep.workflows.base import init_smriprep_wf
from niworkflows.utils.spaces import SpatialReferences, Reference
wf = init_smriprep_wf(
debug=False,
fast_track=False,
freesurfer=True,
fs_subjects_dir=None,
hires=True,
layout=BIDSLayout('.'),
longitudinal=False,
low_mem=False,
omp_nthreads=1,
output_dir='.',
run_uuid='testrun',
skull_strip_fixed_seed=False,
skull_strip_mode='force',
skull_strip_template=Reference('OASIS30ANTs'),
spaces=SpatialReferences(spaces=['MNI152NLin2009cAsym', 'fsaverage5']),
subject_list=['smripreptest'],
work_dir='.',
bids_filters=None,
)
Parameters
----------
debug : :obj:`bool`
Enable debugging outputs
fast_track : :obj:`bool`
Fast-track the workflow by searching for existing derivatives.
freesurfer : :obj:`bool`
Enable FreeSurfer surface reconstruction (may increase runtime)
fs_subjects_dir : os.PathLike or None
Use existing FreeSurfer subjects directory if provided
hires : :obj:`bool`
Enable sub-millimeter preprocessing in FreeSurfer
layout : BIDSLayout object
BIDS dataset layout
longitudinal : :obj:`bool`
Treat multiple sessions as longitudinal (may increase runtime)
See sub-workflows for specific differences
low_mem : :obj:`bool`
Write uncompressed .nii files in some cases to reduce memory usage
omp_nthreads : :obj:`int`
Maximum number of threads an individual process may use
output_dir : :obj:`str`
Directory in which to save derivatives
run_uuid : :obj:`str`
Unique identifier for execution instance
skull_strip_fixed_seed : :obj:`bool`
Do not use a random seed for skull-stripping - will ensure
run-to-run replicability when used with --omp-nthreads 1
skull_strip_mode : :obj:`str`
Determiner for T1-weighted skull stripping (`force` ensures skull stripping,
`skip` ignores skull stripping, and `auto` automatically ignores skull stripping
if pre-stripped brains are detected).
skull_strip_template : :py:class:`~niworkflows.utils.spaces.Reference`
Spatial reference to use in atlas-based brain extraction.
spaces : :py:class:`~niworkflows.utils.spaces.SpatialReferences`
Object containing standard and nonstandard space specifications.
subject_list : :obj:`list`
List of subject labels
work_dir : :obj:`str`
Directory in which to store workflow execution state and
temporary files
bids_filters : dict
Provides finer specification of the pipeline input files through pybids entities filters.
A dict with the following structure {<suffix>:{<entity>:<filter>,...},...}
"""
smriprep_wf = Workflow(name='smriprep_wf')
smriprep_wf.base_dir = work_dir
if freesurfer:
fsdir = pe.Node(BIDSFreeSurferDir(
derivatives=output_dir,
freesurfer_home=os.getenv('FREESURFER_HOME'),
spaces=spaces.get_fs_spaces()),
name='fsdir_run_%s' % run_uuid.replace('-', '_'),
run_without_submitting=True)
if fs_subjects_dir is not None:
fsdir.inputs.subjects_dir = str(fs_subjects_dir.absolute())
for subject_id in subject_list:
single_subject_wf = init_single_subject_wf(
debug=debug,
freesurfer=freesurfer,
fast_track=fast_track,
hires=hires,
layout=layout,
longitudinal=longitudinal,
low_mem=low_mem,
name="single_subject_%s_wf" % subject_id,
omp_nthreads=omp_nthreads,
output_dir=output_dir,
skull_strip_fixed_seed=skull_strip_fixed_seed,
skull_strip_mode=skull_strip_mode,
skull_strip_template=skull_strip_template,
spaces=spaces,
subject_id=subject_id,
bids_filters=bids_filters,
)
single_subject_wf.config['execution']['crashdump_dir'] = (os.path.join(
output_dir, "smriprep", "sub-" + subject_id, 'log', run_uuid))
for node in single_subject_wf._get_all_nodes():
node.config = deepcopy(single_subject_wf.config)
if freesurfer:
smriprep_wf.connect(fsdir, 'subjects_dir', single_subject_wf,
'inputnode.subjects_dir')
else:
smriprep_wf.add_nodes([single_subject_wf])
return smriprep_wf
def init_single_subject_wf(
debug,
freesurfer,
fast_track,
hires,
layout,
longitudinal,
low_mem,
name,
omp_nthreads,
output_dir,
skull_strip_fixed_seed,
skull_strip_mode,
skull_strip_template,
spaces,
subject_id,
bids_filters,
):
"""
Create a single subject workflow.
This workflow organizes the preprocessing pipeline for a single subject.
It collects and reports information about the subject, and prepares
sub-workflows to perform anatomical and functional preprocessing.
Anatomical preprocessing is performed in a single workflow, regardless of
the number of sessions.
Functional preprocessing is performed using a separate workflow for each
individual BOLD series.
Workflow Graph
.. workflow::
:graph2use: orig
:simple_form: yes
from collections import namedtuple
from niworkflows.utils.spaces import SpatialReferences, Reference
from smriprep.workflows.base import init_single_subject_wf
BIDSLayout = namedtuple('BIDSLayout', ['root'])
wf = init_single_subject_wf(
debug=False,
freesurfer=True,
fast_track=False,
hires=True,
layout=BIDSLayout('.'),
longitudinal=False,
low_mem=False,
name='single_subject_wf',
omp_nthreads=1,
output_dir='.',
skull_strip_fixed_seed=False,
skull_strip_mode='force',
skull_strip_template=Reference('OASIS30ANTs'),
spaces=SpatialReferences(spaces=['MNI152NLin2009cAsym', 'fsaverage5']),
subject_id='test',
bids_filters=None,
)
Parameters
----------
debug : :obj:`bool`
Enable debugging outputs
freesurfer : :obj:`bool`
Enable FreeSurfer surface reconstruction (may increase runtime)
fast_track : :obj:`bool`
If ``True``, attempt to collect previously run derivatives.
hires : :obj:`bool`
Enable sub-millimeter preprocessing in FreeSurfer
layout : BIDSLayout object
BIDS dataset layout
longitudinal : :obj:`bool`
Treat multiple sessions as longitudinal (may increase runtime)
See sub-workflows for specific differences
low_mem : :obj:`bool`
Write uncompressed .nii files in some cases to reduce memory usage
name : :obj:`str`
Name of workflow
omp_nthreads : :obj:`int`
Maximum number of threads an individual process may use
output_dir : :obj:`str`
Directory in which to save derivatives
skull_strip_fixed_seed : :obj:`bool`
Do not use a random seed for skull-stripping - will ensure
run-to-run replicability when used with --omp-nthreads 1
skull_strip_mode : :obj:`str`
Determiner for T1-weighted skull stripping (`force` ensures skull stripping,
`skip` ignores skull stripping, and `auto` automatically ignores skull stripping
if pre-stripped brains are detected).
skull_strip_template : :py:class:`~niworkflows.utils.spaces.Reference`
Spatial reference to use in atlas-based brain extraction.
spaces : :py:class:`~niworkflows.utils.spaces.SpatialReferences`
Object containing standard and nonstandard space specifications.
subject_id : :obj:`str`
List of subject labels
bids_filters : dict
Provides finer specification of the pipeline input files through pybids entities filters.
A dict with the following structure {<suffix>:{<entity>:<filter>,...},...}
Inputs
------
subjects_dir
FreeSurfer SUBJECTS_DIR
"""
from ..interfaces.reports import AboutSummary, SubjectSummary
if name in ('single_subject_wf', 'single_subject_smripreptest_wf'):
# for documentation purposes
subject_data = {
't1w': ['/completely/made/up/path/sub-01_T1w.nii.gz'],
}
else:
subject_data = collect_data(layout,
subject_id,
bids_filters=bids_filters)[0]
if not subject_data['t1w']:
raise Exception("No T1w images found for participant {}. "
"All workflows require T1w images.".format(subject_id))
workflow = Workflow(name=name)
workflow.__desc__ = """
Results included in this manuscript come from preprocessing
performed using *sMRIPprep* {smriprep_ver}
(@fmriprep1; @fmriprep2; RRID:SCR_016216),
which is based on *Nipype* {nipype_ver}
(@nipype1; @nipype2; RRID:SCR_002502).
""".format(smriprep_ver=__version__, nipype_ver=nipype_ver)
workflow.__postdesc__ = """
For more details of the pipeline, see [the section corresponding
to workflows in *sMRIPrep*'s documentation]\
(https://smriprep.readthedocs.io/en/latest/workflows.html \
"sMRIPrep's documentation").
### References
"""
deriv_cache = None
if fast_track:
from ..utils.bids import collect_derivatives
std_spaces = spaces.get_spaces(nonstandard=False, dim=(3, ))
deriv_cache = collect_derivatives(
Path(output_dir) / 'smriprep', subject_id, std_spaces, freesurfer)
inputnode = pe.Node(niu.IdentityInterface(fields=['subjects_dir']),
name='inputnode')
bidssrc = pe.Node(BIDSDataGrabber(subject_data=subject_data,
anat_only=True),
name='bidssrc')
bids_info = pe.Node(BIDSInfo(bids_dir=layout.root),
name='bids_info',
run_without_submitting=True)
summary = pe.Node(
SubjectSummary(output_spaces=spaces.get_spaces(nonstandard=False)),
name='summary',
run_without_submitting=True)
about = pe.Node(AboutSummary(version=__version__,
command=' '.join(sys.argv)),
name='about',
run_without_submitting=True)
ds_report_summary = pe.Node(DerivativesDataSink(
base_directory=output_dir,
dismiss_entities=("session", ),
desc='summary',
datatype="figures"),
name='ds_report_summary',
run_without_submitting=True)
ds_report_about = pe.Node(DerivativesDataSink(
base_directory=output_dir,
dismiss_entities=("session", ),
desc='about',
datatype="figures"),
name='ds_report_about',
run_without_submitting=True)
# Preprocessing of T1w (includes registration to MNI)
anat_preproc_wf = init_anat_preproc_wf(
bids_root=layout.root,
debug=debug,
existing_derivatives=deriv_cache,
freesurfer=freesurfer,
hires=hires,
longitudinal=longitudinal,
name="anat_preproc_wf",
t1w=subject_data['t1w'],
omp_nthreads=omp_nthreads,
output_dir=output_dir,
skull_strip_fixed_seed=skull_strip_fixed_seed,
skull_strip_mode=skull_strip_mode,
skull_strip_template=skull_strip_template,
spaces=spaces,
)
workflow.connect([
(inputnode, anat_preproc_wf, [('subjects_dir',
'inputnode.subjects_dir')]),
(bidssrc, bids_info, [(('t1w', fix_multi_T1w_source_name), 'in_file')
]),
(inputnode, summary, [('subjects_dir', 'subjects_dir')]),
(bidssrc, summary, [('t1w', 't1w'), ('t2w', 't2w')]),
(bids_info, summary, [('subject', 'subject_id')]),
(bids_info, anat_preproc_wf, [(('subject', _prefix),
'inputnode.subject_id')]),
(bidssrc, anat_preproc_wf, [('t1w', 'inputnode.t1w'),
('t2w', 'inputnode.t2w'),
('roi', 'inputnode.roi'),
('flair', 'inputnode.flair')]),
(bidssrc, ds_report_summary, [(('t1w', fix_multi_T1w_source_name),
'source_file')]),
(summary, ds_report_summary, [('out_report', 'in_file')]),
(bidssrc, ds_report_about, [(('t1w', fix_multi_T1w_source_name),
'source_file')]),
(about, ds_report_about, [('out_report', 'in_file')]),
])
return workflow
def init_phdiff_wf(omp_nthreads, phasetype='phasediff', name='phdiff_wf'):
"""
Estimates the fieldmap using a phase-difference image and one or more
magnitude images corresponding to two or more :abbr:`GRE (Gradient Echo sequence)`
acquisitions. The `original code was taken from nipype
<https://github.com/nipy/nipype/blob/master/nipype/workflows/dmri/fsl/artifacts.py#L514>`_.
.. workflow ::
:graph2use: orig
:simple_form: yes
from fmriprep.workflows.fieldmap.phdiff import init_phdiff_wf
wf = init_phdiff_wf(omp_nthreads=1)
Outputs::
outputnode.fmap_ref - The average magnitude image, skull-stripped
outputnode.fmap_mask - The brain mask applied to the fieldmap
outputnode.fmap - The estimated fieldmap in Hz
"""
workflow = Workflow(name=name)
workflow.__desc__ = """\
A deformation field to correct for susceptibility distortions was estimated
based on a field map that was co-registered to the BOLD reference,
using a custom workflow of *fMRIPrep* derived from D. Greve's `epidewarp.fsl`
[script](http://www.nmr.mgh.harvard.edu/~greve/fbirn/b0/epidewarp.fsl) and
further improvements of HCP Pipelines [@hcppipelines].
"""
inputnode = pe.Node(
niu.IdentityInterface(fields=['magnitude', 'phasediff']),
name='inputnode')
outputnode = pe.Node(
niu.IdentityInterface(fields=['fmap', 'fmap_ref', 'fmap_mask']),
name='outputnode')
def _pick1st(inlist):
return inlist[0]
# Read phasediff echo times
meta = pe.Node(ReadSidecarJSON(),
name='meta',
mem_gb=0.01,
run_without_submitting=True)
# Merge input magnitude images
magmrg = pe.Node(IntraModalMerge(), name='magmrg')
# de-gradient the fields ("bias/illumination artifact")
n4 = pe.Node(ants.N4BiasFieldCorrection(dimension=3, copy_header=True),
name='n4',
n_procs=omp_nthreads)
bet = pe.Node(BETRPT(generate_report=True, frac=0.6, mask=True),
name='bet')
ds_report_fmap_mask = pe.Node(DerivativesDataSink(desc='brain',
suffix='mask'),
name='ds_report_fmap_mask',
mem_gb=0.01,
run_without_submitting=True)
# uses mask from bet; outputs a mask
# dilate = pe.Node(fsl.maths.MathsCommand(
# nan2zeros=True, args='-kernel sphere 5 -dilM'), name='MskDilate')
# phase diff -> radians
pha2rads = pe.Node(niu.Function(function=siemens2rads), name='pha2rads')
# FSL PRELUDE will perform phase-unwrapping
prelude = pe.Node(fsl.PRELUDE(), name='prelude')
denoise = pe.Node(fsl.SpatialFilter(operation='median',
kernel_shape='sphere',
kernel_size=5),
name='denoise')
demean = pe.Node(niu.Function(function=demean_image), name='demean')
cleanup_wf = cleanup_edge_pipeline(name="cleanup_wf")
compfmap = pe.Node(Phasediff2Fieldmap(), name='compfmap')
# The phdiff2fmap interface is equivalent to:
# rad2rsec (using rads2radsec from nipype.workflows.dmri.fsl.utils)
# pre_fugue = pe.Node(fsl.FUGUE(save_fmap=True), name='ComputeFieldmapFUGUE')
# rsec2hz (divide by 2pi)
if phasetype == "phasediff":
# Read phasediff echo times
meta = pe.Node(ReadSidecarJSON(), name='meta', mem_gb=0.01)
# phase diff -> radians
pha2rads = pe.Node(niu.Function(function=siemens2rads),
name='pha2rads')
# Read phasediff echo times
meta = pe.Node(ReadSidecarJSON(),
name='meta',
mem_gb=0.01,
run_without_submitting=True)
workflow.connect([
(meta, compfmap, [('out_dict', 'metadata')]),
(inputnode, pha2rads, [('phasediff', 'in_file')]),
(pha2rads, prelude, [('out', 'phase_file')]),
(inputnode, ds_report_fmap_mask, [('phasediff', 'source_file')]),
])
elif phasetype == "phase":
workflow.__desc__ += """\
The phase difference used for unwarping was calculated using two separate phase measurements
[@pncprocessing].
"""
# Special case for phase1, phase2 images
meta = pe.MapNode(ReadSidecarJSON(),
name='meta',
mem_gb=0.01,
run_without_submitting=True,
iterfield=['in_file'])
phases2fmap = pe.Node(Phases2Fieldmap(), name='phases2fmap')
workflow.connect([
(meta, phases2fmap, [('out_dict', 'metadatas')]),
(inputnode, phases2fmap, [('phasediff', 'phase_files')]),
(phases2fmap, prelude, [('out_file', 'phase_file')]),
(phases2fmap, compfmap, [('phasediff_metadata', 'metadata')]),
(phases2fmap, ds_report_fmap_mask, [('out_file', 'source_file')])
])
workflow.connect([
(inputnode, meta, [('phasediff', 'in_file')]),
(inputnode, magmrg, [('magnitude', 'in_files')]),
(magmrg, n4, [('out_avg', 'input_image')]),
(n4, prelude, [('output_image', 'magnitude_file')]),
(n4, bet, [('output_image', 'in_file')]),
(bet, prelude, [('mask_file', 'mask_file')]),
(prelude, denoise, [('unwrapped_phase_file', 'in_file')]),
(denoise, demean, [('out_file', 'in_file')]),
(demean, cleanup_wf, [('out', 'inputnode.in_file')]),
(bet, cleanup_wf, [('mask_file', 'inputnode.in_mask')]),
(cleanup_wf, compfmap, [('outputnode.out_file', 'in_file')]),
(compfmap, outputnode, [('out_file', 'fmap')]),
(bet, outputnode, [('mask_file', 'fmap_mask'),
('out_file', 'fmap_ref')]),
(bet, ds_report_fmap_mask, [('out_report', 'in_file')]),
])
return workflow
def init_syn_sdc_wf(omp_nthreads, epi_pe=None,
atlas_threshold=3, name='syn_sdc_wf'):
"""
Build the *fieldmap-less* susceptibility-distortion estimation workflow.
This workflow takes a skull-stripped T1w image and reference BOLD image and
estimates a susceptibility distortion correction warp, using ANTs symmetric
normalization (SyN) and the average fieldmap atlas described in
[Treiber2016]_.
SyN deformation is restricted to the phase-encoding (PE) direction.
If no PE direction is specified, anterior-posterior PE is assumed.
SyN deformation is also restricted to regions that are expected to have a
>3mm (approximately 1 voxel) warp, based on the fieldmap atlas.
This technique is a variation on those developed in [Huntenburg2014]_ and
[Wang2017]_.
Workflow Graph
.. workflow ::
:graph2use: orig
:simple_form: yes
from sdcflows.workflows.syn import init_syn_sdc_wf
wf = init_syn_sdc_wf(
epi_pe='j',
omp_nthreads=8)
Inputs
------
in_reference
reference image
in_reference_brain
skull-stripped reference image
t1w_brain
skull-stripped, bias-corrected structural image
std2anat_xfm
inverse registration transform of T1w image to MNI template
Outputs
-------
out_reference
the ``in_reference`` image after unwarping
out_reference_brain
the ``in_reference_brain`` image after unwarping
out_warp
the corresponding :abbr:`DFM (displacements field map)` compatible with
ANTs
out_mask
mask of the unwarped input file
References
----------
.. [Treiber2016] Treiber, J. M. et al. (2016) Characterization and Correction
of Geometric Distortions in 814 Diffusion Weighted Images,
PLoS ONE 11(3): e0152472. doi:`10.1371/journal.pone.0152472
<https://doi.org/10.1371/journal.pone.0152472>`_.
.. [Wang2017] Wang S, et al. (2017) Evaluation of Field Map and Nonlinear
Registration Methods for Correction of Susceptibility Artifacts
in Diffusion MRI. Front. Neuroinform. 11:17.
doi:`10.3389/fninf.2017.00017
<https://doi.org/10.3389/fninf.2017.00017>`_.
.. [Huntenburg2014] Huntenburg, J. M. (2014) Evaluating Nonlinear
Coregistration of BOLD EPI and T1w Images. Berlin: Master
Thesis, Freie Universität. `PDF
<http://pubman.mpdl.mpg.de/pubman/item/escidoc:2327525:5/component/escidoc:2327523/master_thesis_huntenburg_4686947.pdf>`_.
"""
if epi_pe is None or epi_pe[0] not in ['i', 'j']:
LOGGER.warning('Incorrect phase-encoding direction, assuming PA (posterior-to-anterior).')
epi_pe = 'j'
workflow = Workflow(name=name)
workflow.__desc__ = """\
A deformation field to correct for susceptibility distortions was estimated
based on *fMRIPrep*'s *fieldmap-less* approach.
The deformation field is that resulting from co-registering the BOLD reference
to the same-subject T1w-reference with its intensity inverted [@fieldmapless1;
@fieldmapless2].
Registration is performed with `antsRegistration` (ANTs {ants_ver}), and
the process regularized by constraining deformation to be nonzero only
along the phase-encoding direction, and modulated with an average fieldmap
template [@fieldmapless3].
""".format(ants_ver=Registration().version or '<ver>')
inputnode = pe.Node(
niu.IdentityInterface(['in_reference', 'in_reference_brain',
't1w_brain', 'std2anat_xfm']),
name='inputnode')
outputnode = pe.Node(
niu.IdentityInterface(['out_reference', 'out_reference_brain',
'out_mask', 'out_warp']),
name='outputnode')
# Collect predefined data
# Atlas image and registration affine
atlas_img = resource_filename('sdcflows', 'data/fmap_atlas.nii.gz')
# Registration specifications
affine_transform = resource_filename('sdcflows', 'data/affine.json')
syn_transform = resource_filename('sdcflows', 'data/susceptibility_syn.json')
invert_t1w = pe.Node(Rescale(invert=True), name='invert_t1w',
mem_gb=0.3)
ref_2_t1 = pe.Node(Registration(from_file=affine_transform),
name='ref_2_t1', n_procs=omp_nthreads)
t1_2_ref = pe.Node(ApplyTransforms(invert_transform_flags=[True]),
name='t1_2_ref', n_procs=omp_nthreads)
# 1) BOLD -> T1; 2) MNI -> T1; 3) ATLAS -> MNI
transform_list = pe.Node(niu.Merge(3), name='transform_list',
mem_gb=DEFAULT_MEMORY_MIN_GB)
transform_list.inputs.in3 = resource_filename(
'sdcflows', 'data/fmap_atlas_2_MNI152NLin2009cAsym_affine.mat')
# Inverting (1), then applying in reverse order:
#
# ATLAS -> MNI -> T1 -> BOLD
atlas_2_ref = pe.Node(
ApplyTransforms(invert_transform_flags=[True, False, False]),
name='atlas_2_ref', n_procs=omp_nthreads,
mem_gb=0.3)
atlas_2_ref.inputs.input_image = atlas_img
threshold_atlas = pe.Node(
fsl.maths.MathsCommand(args='-thr {:.8g} -bin'.format(atlas_threshold),
output_datatype='char'),
name='threshold_atlas', mem_gb=0.3)
fixed_image_masks = pe.Node(niu.Merge(2), name='fixed_image_masks',
mem_gb=DEFAULT_MEMORY_MIN_GB)
fixed_image_masks.inputs.in1 = 'NULL'
restrict = [[int(epi_pe[0] == 'i'), int(epi_pe[0] == 'j'), 0]] * 2
syn = pe.Node(
Registration(from_file=syn_transform, restrict_deformation=restrict),
name='syn', n_procs=omp_nthreads)
unwarp_ref = pe.Node(ApplyTransforms(
dimension=3, float=True, interpolation='LanczosWindowedSinc'),
name='unwarp_ref')
skullstrip_bold_wf = init_skullstrip_bold_wf()
workflow.connect([
(inputnode, invert_t1w, [('t1w_brain', 'in_file'),
('in_reference', 'ref_file')]),
(inputnode, ref_2_t1, [('in_reference_brain', 'moving_image')]),
(invert_t1w, ref_2_t1, [('out_file', 'fixed_image')]),
(inputnode, t1_2_ref, [('in_reference', 'reference_image')]),
(invert_t1w, t1_2_ref, [('out_file', 'input_image')]),
(ref_2_t1, t1_2_ref, [('forward_transforms', 'transforms')]),
(ref_2_t1, transform_list, [('forward_transforms', 'in1')]),
(inputnode, transform_list, [
('std2anat_xfm', 'in2')]),
(inputnode, atlas_2_ref, [('in_reference', 'reference_image')]),
(transform_list, atlas_2_ref, [('out', 'transforms')]),
(atlas_2_ref, threshold_atlas, [('output_image', 'in_file')]),
(threshold_atlas, fixed_image_masks, [('out_file', 'in2')]),
(inputnode, syn, [('in_reference_brain', 'moving_image')]),
(t1_2_ref, syn, [('output_image', 'fixed_image')]),
(fixed_image_masks, syn, [('out', 'fixed_image_masks')]),
(syn, outputnode, [('forward_transforms', 'out_warp')]),
(syn, unwarp_ref, [('forward_transforms', 'transforms')]),
(inputnode, unwarp_ref, [('in_reference', 'reference_image'),
('in_reference', 'input_image')]),
(unwarp_ref, skullstrip_bold_wf, [
('output_image', 'inputnode.in_file')]),
(unwarp_ref, outputnode, [('output_image', 'out_reference')]),
(skullstrip_bold_wf, outputnode, [
('outputnode.skull_stripped_file', 'out_reference_brain'),
('outputnode.mask_file', 'out_mask')]),
])
return workflow
def init_bold_std_trans_wf(freesurfer,
mem_gb,
omp_nthreads,
standard_spaces,
name='bold_std_trans_wf',
use_compression=True,
use_fieldwarp=False):
"""
This workflow samples functional images into standard space with a single
resampling of the original BOLD series.
.. workflow::
:graph2use: colored
:simple_form: yes
from collections import OrderedDict
from fmriprep.workflows.bold import init_bold_std_trans_wf
wf = init_bold_std_trans_wf(
freesurfer=True,
mem_gb=3,
omp_nthreads=1,
standard_spaces=OrderedDict([('MNI152Lin', {}),
('fsaverage', {'density': '10k'})]),
)
**Parameters**
freesurfer : bool
Whether to generate FreeSurfer's aseg/aparc segmentations on BOLD space.
mem_gb : float
Size of BOLD file in GB
omp_nthreads : int
Maximum number of threads an individual process may use
standard_spaces : OrderedDict
Ordered dictionary where keys are TemplateFlow ID strings (e.g.,
``MNI152Lin``, ``MNI152NLin6Asym``, ``MNI152NLin2009cAsym``, or ``fsLR``),
or paths pointing to custom templates organized in a TemplateFlow-like structure.
Values of the dictionary aggregate modifiers (e.g., the value for the key ``MNI152Lin``
could be ``{'resolution': 2}`` if one wants the resampling to be done on the 2mm
resolution version of the selected template).
name : str
Name of workflow (default: ``bold_std_trans_wf``)
use_compression : bool
Save registered BOLD series as ``.nii.gz``
use_fieldwarp : bool
Include SDC warp in single-shot transform from BOLD to MNI
**Inputs**
anat2std_xfm
List of anatomical-to-standard space transforms generated during
spatial normalization.
bold_aparc
FreeSurfer's ``aparc+aseg.mgz`` atlas projected into the T1w reference
(only if ``recon-all`` was run).
bold_aseg
FreeSurfer's ``aseg.mgz`` atlas projected into the T1w reference
(only if ``recon-all`` was run).
bold_mask
Skull-stripping mask of reference image
bold_split
Individual 3D volumes, not motion corrected
fieldwarp
a :abbr:`DFM (displacements field map)` in ITK format
hmc_xforms
List of affine transforms aligning each volume to ``ref_image`` in ITK format
itk_bold_to_t1
Affine transform from ``ref_bold_brain`` to T1 space (ITK format)
name_source
BOLD series NIfTI file
Used to recover original information lost during processing
templates
List of templates that were applied as targets during
spatial normalization.
**Outputs** - Two outputnodes are available. One output node (with name ``poutputnode``)
will be parameterized in a Nipype sense (see `Nipype iterables
<https://miykael.github.io/nipype_tutorial/notebooks/basic_iteration.html>`__), and a
second node (``outputnode``) will collapse the parameterized outputs into synchronous
lists of the following fields:
bold_std
BOLD series, resampled to template space
bold_std_ref
Reference, contrast-enhanced summary of the BOLD series, resampled to template space
bold_mask_std
BOLD series mask in template space
bold_aseg_std
FreeSurfer's ``aseg.mgz`` atlas, in template space at the BOLD resolution
(only if ``recon-all`` was run)
bold_aparc_std
FreeSurfer's ``aparc+aseg.mgz`` atlas, in template space at the BOLD resolution
(only if ``recon-all`` was run)
templates
Template identifiers synchronized correspondingly to previously
described outputs.
"""
# Filter ``standard_spaces``
vol_std_spaces = [
k for k in standard_spaces.keys() if not k.startswith('fs')
]
workflow = Workflow(name=name)
if len(vol_std_spaces) == 1:
workflow.__desc__ = """\
The BOLD time-series were resampled into standard space,
generating a *preprocessed BOLD run in {tpl} space*.
""".format(tpl=vol_std_spaces)
else:
workflow.__desc__ = """\
The BOLD time-series were resampled into several standard spaces,
correspondingly generating the following *spatially-normalized,
preprocessed BOLD runs*: {tpl}.
""".format(tpl=', '.join(vol_std_spaces))
inputnode = pe.Node(niu.IdentityInterface(fields=[
'anat2std_xfm',
'bold_aparc',
'bold_aseg',
'bold_mask',
'bold_split',
'fieldwarp',
'hmc_xforms',
'itk_bold_to_t1',
'name_source',
'templates',
]),
name='inputnode')
select_std = pe.Node(KeySelect(fields=['resolution', 'anat2std_xfm']),
name='select_std',
run_without_submitting=True)
select_std.inputs.resolution = [
v.get('resolution') or v.get('res') or 'native'
for k, v in list(standard_spaces.items()) if k in vol_std_spaces
]
select_std.iterables = ('key', vol_std_spaces)
select_tpl = pe.Node(niu.Function(function=_select_template),
name='select_tpl',
run_without_submitting=True)
select_tpl.inputs.template_specs = standard_spaces
gen_ref = pe.Node(GenerateSamplingReference(), name='gen_ref',
mem_gb=0.3) # 256x256x256 * 64 / 8 ~ 150MB)
mask_std_tfm = pe.Node(ApplyTransforms(interpolation='MultiLabel',
float=True),
name='mask_std_tfm',
mem_gb=1)
# Write corrected file in the designated output dir
mask_merge_tfms = pe.Node(niu.Merge(2),
name='mask_merge_tfms',
run_without_submitting=True,
mem_gb=DEFAULT_MEMORY_MIN_GB)
workflow.connect([
(inputnode, select_std, [('templates', 'keys'),
('anat2std_xfm', 'anat2std_xfm')]),
(inputnode, mask_std_tfm, [('bold_mask', 'input_image')]),
(inputnode, gen_ref, [(('bold_split', _first), 'moving_image')]),
(inputnode, mask_merge_tfms, [(('itk_bold_to_t1', _aslist), 'in2')]),
(select_std, select_tpl, [('key', 'template')]),
(select_std, mask_merge_tfms, [('anat2std_xfm', 'in1')]),
(select_std, gen_ref, [(('resolution', _is_native), 'keep_native')]),
(select_tpl, gen_ref, [('out', 'fixed_image')]),
(mask_merge_tfms, mask_std_tfm, [('out', 'transforms')]),
(gen_ref, mask_std_tfm, [('out_file', 'reference_image')]),
])
nxforms = 4 if use_fieldwarp else 3
merge_xforms = pe.Node(niu.Merge(nxforms),
name='merge_xforms',
run_without_submitting=True,
mem_gb=DEFAULT_MEMORY_MIN_GB)
workflow.connect([(inputnode, merge_xforms, [('hmc_xforms',
'in%d' % nxforms)])])
if use_fieldwarp:
workflow.connect([(inputnode, merge_xforms, [('fieldwarp', 'in3')])])
bold_to_std_transform = pe.Node(MultiApplyTransforms(
interpolation="LanczosWindowedSinc", float=True, copy_dtype=True),
name='bold_to_std_transform',
mem_gb=mem_gb * 3 * omp_nthreads,
n_procs=omp_nthreads)
merge = pe.Node(Merge(compress=use_compression),
name='merge',
mem_gb=mem_gb * 3)
# Generate a reference on the target T1w space
gen_final_ref = init_bold_reference_wf(omp_nthreads=omp_nthreads,
pre_mask=True)
workflow.connect([
(inputnode, merge_xforms, [(('itk_bold_to_t1', _aslist), 'in2')]),
(inputnode, merge, [('name_source', 'header_source')]),
(inputnode, bold_to_std_transform, [('bold_split', 'input_image')]),
(select_std, merge_xforms, [('anat2std_xfm', 'in1')]),
(merge_xforms, bold_to_std_transform, [('out', 'transforms')]),
(gen_ref, bold_to_std_transform, [('out_file', 'reference_image')]),
(bold_to_std_transform, merge, [('out_files', 'in_files')]),
(merge, gen_final_ref, [('out_file', 'inputnode.bold_file')]),
(mask_std_tfm, gen_final_ref, [('output_image', 'inputnode.bold_mask')
]),
])
# Connect output nodes
output_names = ['bold_std', 'bold_std_ref', 'bold_mask_std', 'templates']
if freesurfer:
output_names += ['bold_aseg_std', 'bold_aparc_std']
# poutputnode - parametric output node
poutputnode = pe.Node(niu.IdentityInterface(fields=output_names),
name='poutputnode')
workflow.connect([
(gen_final_ref, poutputnode, [('outputnode.ref_image', 'bold_std_ref')
]),
(merge, poutputnode, [('out_file', 'bold_std')]),
(mask_std_tfm, poutputnode, [('output_image', 'bold_mask_std')]),
(select_std, poutputnode, [('key', 'templates')]),
])
if freesurfer:
# Sample the parcellation files to functional space
aseg_std_tfm = pe.Node(ApplyTransforms(interpolation='MultiLabel',
float=True),
name='aseg_std_tfm',
mem_gb=1)
aparc_std_tfm = pe.Node(ApplyTransforms(interpolation='MultiLabel',
float=True),
name='aparc_std_tfm',
mem_gb=1)
workflow.connect([
(inputnode, aseg_std_tfm, [('bold_aseg', 'input_image')]),
(inputnode, aparc_std_tfm, [('bold_aparc', 'input_image')]),
(select_std, aseg_std_tfm, [('anat2std_xfm', 'transforms')]),
(select_std, aparc_std_tfm, [('anat2std_xfm', 'transforms')]),
(gen_ref, aseg_std_tfm, [('out_file', 'reference_image')]),
(gen_ref, aparc_std_tfm, [('out_file', 'reference_image')]),
(aseg_std_tfm, poutputnode, [('output_image', 'bold_aseg_std')]),
(aparc_std_tfm, poutputnode, [('output_image', 'bold_aparc_std')]),
])
# Connect outputnode to the parameterized outputnode
outputnode = pe.JoinNode(niu.IdentityInterface(fields=output_names),
name='outputnode',
joinsource='select_std')
workflow.connect([(poutputnode, outputnode, [(f, f)
for f in output_names])])
return workflow
def init_topup_wf(
grid_reference=0,
omp_nthreads=1,
sloppy=False,
debug=False,
name="pepolar_estimate_wf",
):
"""
Create the PEPOLAR field estimation workflow based on FSL's ``topup``.
Workflow Graph
.. workflow ::
:graph2use: orig
:simple_form: yes
from sdcflows.workflows.fit.pepolar import init_topup_wf
wf = init_topup_wf()
Parameters
----------
grid_reference : :obj:`int`
Index of the volume (after flattening) that will be taken for gridding reference.
sloppy : :obj:`bool`
Whether a fast configuration of topup (less accurate) should be applied.
debug : :obj:`bool`
Run in debug mode
name : :obj:`str`
Name for this workflow
omp_nthreads : :obj:`int`
Parallelize internal tasks across the number of CPUs given by this option.
Inputs
------
in_data : :obj:`list` of :obj:`str`
A list of EPI files that will be fed into TOPUP.
metadata : :obj:`list` of :obj:`dict`
A list of dictionaries containing the metadata corresponding to each file
in ``in_data``.
Outputs
-------
fmap : :obj:`str`
The path of the estimated fieldmap.
fmap_ref : :obj:`str`
The path of an unwarped conversion of files in ``in_data``.
fmap_mask : :obj:`str`
The path of mask corresponding to the ``fmap_ref`` output.
fmap_coeff : :obj:`str` or :obj:`list` of :obj:`str`
The path(s) of the B-Spline coefficients supporting the fieldmap.
method: :obj:`str`
Short description of the estimation method that was run.
"""
from nipype.interfaces.fsl.epi import TOPUP
from niworkflows.interfaces.nibabel import MergeSeries
from niworkflows.interfaces.images import RobustAverage
from ...utils.misc import front as _front
from ...interfaces.epi import GetReadoutTime
from ...interfaces.utils import Flatten, UniformGrid, PadSlices
from ...interfaces.bspline import TOPUPCoeffReorient
from ..ancillary import init_brainextraction_wf
workflow = Workflow(name=name)
workflow.__desc__ = f"""\
{_PEPOLAR_DESC} with `topup` (@topup; FSL {TOPUP().version}).
"""
inputnode = pe.Node(niu.IdentityInterface(fields=INPUT_FIELDS),
name="inputnode")
outputnode = pe.Node(
niu.IdentityInterface(fields=[
"fmap",
"fmap_ref",
"fmap_coeff",
"fmap_mask",
"jacobians",
"xfms",
"out_warps",
"method",
]),
name="outputnode",
)
outputnode.inputs.method = "PEB/PEPOLAR (phase-encoding based / PE-POLARity)"
flatten = pe.Node(Flatten(), name="flatten")
regrid = pe.Node(UniformGrid(reference=grid_reference), name="regrid")
concat_blips = pe.Node(MergeSeries(), name="concat_blips")
readout_time = pe.MapNode(
GetReadoutTime(),
name="readout_time",
iterfield=["metadata", "in_file"],
run_without_submitting=True,
)
pad_blip_slices = pe.Node(PadSlices(), name="pad_blip_slices")
pad_ref_slices = pe.Node(PadSlices(), name="pad_ref_slices")
topup = pe.Node(
TOPUP(config=_pkg_fname(
"sdcflows", f"data/flirtsch/b02b0{'_quick' * sloppy}.cnf")),
name="topup",
)
ref_average = pe.Node(RobustAverage(), name="ref_average")
fix_coeff = pe.Node(TOPUPCoeffReorient(),
name="fix_coeff",
run_without_submitting=True)
brainextraction_wf = init_brainextraction_wf()
# fmt: off
workflow.connect([
(inputnode, flatten, [("in_data", "in_data"),
("metadata", "in_meta")]),
(flatten, readout_time, [("out_data", "in_file"),
("out_meta", "metadata")]),
(flatten, regrid, [("out_data", "in_data")]),
(regrid, concat_blips, [("out_data", "in_files")]),
(readout_time, topup, [("readout_time", "readout_times"),
("pe_dir_fsl", "encoding_direction")]),
(regrid, pad_ref_slices, [("reference", "in_file")]),
(pad_ref_slices, fix_coeff, [("out_file", "fmap_ref")]),
(readout_time, fix_coeff, [(("pe_direction", _front), "pe_dir")]),
(topup, fix_coeff, [("out_fieldcoef", "in_coeff")]),
(topup, outputnode, [("out_jacs", "jacobians"), ("out_mats", "xfms")]),
(ref_average, brainextraction_wf, [("out_file", "inputnode.in_file")]),
(brainextraction_wf, outputnode, [("outputnode.out_file", "fmap_ref"),
("outputnode.out_mask", "fmap_mask")
]),
(fix_coeff, outputnode, [("out_coeff", "fmap_coeff")]),
])
# fmt: on
if not debug:
# fmt: off
workflow.connect([
(concat_blips, pad_blip_slices, [("out_file", "in_file")]),
(pad_blip_slices, topup, [("out_file", "in_file")]),
(topup, ref_average, [("out_corrected", "in_file")]),
(topup, outputnode, [("out_field", "fmap"),
("out_warps", "out_warps")]),
])
# fmt: on
return workflow
from nipype.interfaces.afni.preprocess import Volreg
from niworkflows.interfaces.nibabel import SplitSeries
from ...interfaces.bspline import ApplyCoeffsField
realign = pe.Node(
Volreg(args=f"-base {grid_reference}", outputtype="NIFTI_GZ"),
name="realign_blips",
)
split_blips = pe.Node(SplitSeries(), name="split_blips")
unwarp = pe.Node(ApplyCoeffsField(), name="unwarp")
unwarp.interface._always_run = True
concat_corrected = pe.Node(MergeSeries(), name="concat_corrected")
# fmt:off
workflow.connect([
(concat_blips, realign, [("out_file", "in_file")]),
(realign, pad_blip_slices, [("out_file", "in_file")]),
(pad_blip_slices, topup, [("out_file", "in_file")]),
(fix_coeff, unwarp, [("out_coeff", "in_coeff")]),
(realign, split_blips, [("out_file", "in_file")]),
(split_blips, unwarp, [("out_files", "in_data")]),
(readout_time, unwarp, [("readout_time", "ro_time"),
("pe_direction", "pe_dir")]),
(unwarp, outputnode, [("out_warp", "out_warps"),
("out_field", "fmap")]),
(unwarp, concat_corrected, [("out_corrected", "in_files")]),
(concat_corrected, ref_average, [("out_file", "in_file")]),
])
# fmt:on
return workflow
def init_bold_preproc_trans_wf(mem_gb,
omp_nthreads,
name='bold_preproc_trans_wf',
use_compression=True,
use_fieldwarp=False,
split_file=False,
interpolation='LanczosWindowedSinc'):
"""
This workflow resamples the input fMRI in its native (original)
space in a "single shot" from the original BOLD series.
.. workflow::
:graph2use: colored
:simple_form: yes
from fmriprep.workflows.bold import init_bold_preproc_trans_wf
wf = init_bold_preproc_trans_wf(mem_gb=3, omp_nthreads=1)
**Parameters**
mem_gb : float
Size of BOLD file in GB
omp_nthreads : int
Maximum number of threads an individual process may use
name : str
Name of workflow (default: ``bold_std_trans_wf``)
use_compression : bool
Save registered BOLD series as ``.nii.gz``
use_fieldwarp : bool
Include SDC warp in single-shot transform from BOLD to MNI
split_file : bool
Whether the input file should be splitted (it is a 4D file)
or it is a list of 3D files (default ``False``, do not split)
interpolation : str
Interpolation type to be used by ANTs' ``applyTransforms``
(default ``'LanczosWindowedSinc'``)
**Inputs**
bold_file
Individual 3D volumes, not motion corrected
bold_mask
Skull-stripping mask of reference image
name_source
BOLD series NIfTI file
Used to recover original information lost during processing
hmc_xforms
List of affine transforms aligning each volume to ``ref_image`` in ITK format
fieldwarp
a :abbr:`DFM (displacements field map)` in ITK format
**Outputs**
bold
BOLD series, resampled in native space, including all preprocessing
bold_mask
BOLD series mask calculated with the new time-series
bold_ref
BOLD reference image: an average-like 3D image of the time-series
bold_ref_brain
Same as ``bold_ref``, but once the brain mask has been applied
"""
workflow = Workflow(name=name)
workflow.__desc__ = """\
The BOLD time-series (including slice-timing correction when applied)
were resampled onto their original, native space by applying
{transforms}.
These resampled BOLD time-series will be referred to as *preprocessed
BOLD in original space*, or just *preprocessed BOLD*.
""".format(transforms="""\
a single, composite transform to correct for head-motion and
susceptibility distortions""" if use_fieldwarp else """\
the transforms to correct for head-motion""")
inputnode = pe.Node(niu.IdentityInterface(fields=[
'name_source', 'bold_file', 'bold_mask', 'hmc_xforms', 'fieldwarp'
]),
name='inputnode')
outputnode = pe.Node(niu.IdentityInterface(
fields=['bold', 'bold_mask', 'bold_ref', 'bold_ref_brain']),
name='outputnode')
bold_transform = pe.Node(MultiApplyTransforms(interpolation=interpolation,
float=True,
copy_dtype=True),
name='bold_transform',
mem_gb=mem_gb * 3 * omp_nthreads,
n_procs=omp_nthreads)
merge = pe.Node(Merge(compress=use_compression),
name='merge',
mem_gb=mem_gb * 3)
# Generate a new BOLD reference
bold_reference_wf = init_bold_reference_wf(omp_nthreads=omp_nthreads)
bold_reference_wf.__desc__ = None # Unset description to avoid second appearance
workflow.connect([
(inputnode, merge, [('name_source', 'header_source')]),
(bold_transform, merge, [('out_files', 'in_files')]),
(merge, bold_reference_wf, [('out_file', 'inputnode.bold_file')]),
(merge, outputnode, [('out_file', 'bold')]),
(bold_reference_wf, outputnode,
[('outputnode.ref_image', 'bold_ref'),
('outputnode.ref_image_brain', 'bold_ref_brain'),
('outputnode.bold_mask', 'bold_mask')]),
])
# Input file is not splitted
if split_file:
bold_split = pe.Node(FSLSplit(dimension='t'),
name='bold_split',
mem_gb=mem_gb * 3)
workflow.connect([(inputnode, bold_split, [('bold_file', 'in_file')]),
(bold_split, bold_transform, [
('out_files', 'input_image'),
(('out_files', _first), 'reference_image'),
])])
else:
workflow.connect([
(inputnode, bold_transform, [('bold_file', 'input_image'),
(('bold_file', _first),
'reference_image')]),
])
if use_fieldwarp:
merge_xforms = pe.Node(niu.Merge(2),
name='merge_xforms',
run_without_submitting=True,
mem_gb=DEFAULT_MEMORY_MIN_GB)
workflow.connect([
(inputnode, merge_xforms, [('fieldwarp', 'in1'),
('hmc_xforms', 'in2')]),
(merge_xforms, bold_transform, [('out', 'transforms')]),
])
else:
def _aslist(val):
return [val]
workflow.connect([
(inputnode, bold_transform, [(('hmc_xforms', _aslist),
'transforms')]),
])
# Code ready to generate a pre/post processing report
# bold_bold_report_wf = init_bold_preproc_report_wf(
# mem_gb=mem_gb['resampled'],
# reportlets_dir=reportlets_dir
# )
# workflow.connect([
# (inputnode, bold_bold_report_wf, [
# ('bold_file', 'inputnode.name_source'),
# ('bold_file', 'inputnode.in_pre')]), # This should be after STC
# (bold_bold_trans_wf, bold_bold_report_wf, [
# ('outputnode.bold', 'inputnode.in_post')]),
# ])
return workflow
def init_single_subject_wf(
layout, subject_id, task_id, echo_idx, name, reportlets_dir,
output_dir, ignore, debug, low_mem, anat_only, longitudinal, t2s_coreg,
omp_nthreads, skull_strip_template, skull_strip_fixed_seed, freesurfer,
output_spaces, template, medial_surface_nan, cifti_output, hires,
use_bbr, bold2t1w_dof, fmap_bspline, fmap_demean, use_syn, force_syn,
template_out_grid, use_aroma, aroma_melodic_dim, err_on_aroma_warn):
"""
This workflow organizes the preprocessing pipeline for a single subject.
It collects and reports information about the subject, and prepares
sub-workflows to perform anatomical and functional preprocessing.
Anatomical preprocessing is performed in a single workflow, regardless of
the number of sessions.
Functional preprocessing is performed using a separate workflow for each
individual BOLD series.
.. workflow::
:graph2use: orig
:simple_form: yes
from fmriprep.workflows.base import init_single_subject_wf
from collections import namedtuple
BIDSLayout = namedtuple('BIDSLayout', ['root'], defaults='.')
wf = init_single_subject_wf(layout=BIDSLayout(),
subject_id='test',
task_id='',
echo_idx=None,
name='single_subject_wf',
reportlets_dir='.',
output_dir='.',
ignore=[],
debug=False,
low_mem=False,
anat_only=False,
longitudinal=False,
t2s_coreg=False,
omp_nthreads=1,
skull_strip_template='OASIS30ANTs',
skull_strip_fixed_seed=False,
freesurfer=True,
template='MNI152NLin2009cAsym',
output_spaces=['T1w', 'fsnative',
'template', 'fsaverage5'],
medial_surface_nan=False,
cifti_output=False,
hires=True,
use_bbr=True,
bold2t1w_dof=9,
fmap_bspline=False,
fmap_demean=True,
use_syn=True,
force_syn=True,
template_out_grid='native',
use_aroma=False,
aroma_melodic_dim=-200,
err_on_aroma_warn=False)
Parameters
layout : BIDSLayout object
BIDS dataset layout
subject_id : str
List of subject labels
task_id : str or None
Task ID of BOLD series to preprocess, or ``None`` to preprocess all
echo_idx : int or None
Index of echo to preprocess in multiecho BOLD series,
or ``None`` to preprocess all
name : str
Name of workflow
ignore : list
Preprocessing steps to skip (may include "slicetiming", "fieldmaps")
debug : bool
Enable debugging outputs
low_mem : bool
Write uncompressed .nii files in some cases to reduce memory usage
anat_only : bool
Disable functional workflows
longitudinal : bool
Treat multiple sessions as longitudinal (may increase runtime)
See sub-workflows for specific differences
t2s_coreg : bool
For multi-echo EPI, use the calculated T2*-map for T2*-driven coregistration
omp_nthreads : int
Maximum number of threads an individual process may use
skull_strip_template : str
Name of ANTs skull-stripping template ('OASIS30ANTs' or 'NKI')
skull_strip_fixed_seed : bool
Do not use a random seed for skull-stripping - will ensure
run-to-run replicability when used with --omp-nthreads 1
reportlets_dir : str
Directory in which to save reportlets
output_dir : str
Directory in which to save derivatives
freesurfer : bool
Enable FreeSurfer surface reconstruction (may increase runtime)
output_spaces : list
List of output spaces functional images are to be resampled to.
Some parts of pipeline will only be instantiated for some output spaces.
Valid spaces:
- T1w
- template
- fsnative
- fsaverage (or other pre-existing FreeSurfer templates)
template : str
Name of template targeted by ``template`` output space
medial_surface_nan : bool
Replace medial wall values with NaNs on functional GIFTI files
cifti_output : bool
Generate bold CIFTI file in output spaces
hires : bool
Enable sub-millimeter preprocessing in FreeSurfer
use_bbr : bool or None
Enable/disable boundary-based registration refinement.
If ``None``, test BBR result for distortion before accepting.
bold2t1w_dof : 6, 9 or 12
Degrees-of-freedom for BOLD-T1w registration
fmap_bspline : bool
**Experimental**: Fit B-Spline field using least-squares
fmap_demean : bool
Demean voxel-shift map during unwarp
use_syn : bool
**Experimental**: Enable ANTs SyN-based susceptibility distortion correction (SDC).
If fieldmaps are present and enabled, this is not run, by default.
force_syn : bool
**Temporary**: Always run SyN-based SDC
template_out_grid : str
Keyword ('native', '1mm' or '2mm') or path of custom reference
image for normalization
use_aroma : bool
Perform ICA-AROMA on MNI-resampled functional series
err_on_aroma_warn : bool
Do not fail on ICA-AROMA errors
Inputs
subjects_dir
FreeSurfer SUBJECTS_DIR
"""
if name in ('single_subject_wf', 'single_subject_fmripreptest_wf'):
# for documentation purposes
subject_data = {
't1w': ['/completely/made/up/path/sub-01_T1w.nii.gz'],
'bold': ['/completely/made/up/path/sub-01_task-nback_bold.nii.gz']
}
else:
subject_data = collect_data(layout, subject_id, task_id, echo_idx)[0]
# Make sure we always go through these two checks
if not anat_only and subject_data['bold'] == []:
raise Exception("No BOLD images found for participant {} and task {}. "
"All workflows require BOLD images.".format(
subject_id, task_id if task_id else '<all>'))
if not subject_data['t1w']:
raise Exception("No T1w images found for participant {}. "
"All workflows require T1w images.".format(subject_id))
workflow = Workflow(name=name)
workflow.__desc__ = """
Results included in this manuscript come from preprocessing
performed using *fMRIPrep* {fmriprep_ver}
(@fmriprep1; @fmriprep2; RRID:SCR_016216),
which is based on *Nipype* {nipype_ver}
(@nipype1; @nipype2; RRID:SCR_002502).
""".format(fmriprep_ver=__version__, nipype_ver=nipype_ver)
workflow.__postdesc__ = """
Many internal operations of *fMRIPrep* use
*Nilearn* {nilearn_ver} [@nilearn, RRID:SCR_001362],
mostly within the functional processing workflow.
For more details of the pipeline, see [the section corresponding
to workflows in *fMRIPrep*'s documentation]\
(https://fmriprep.readthedocs.io/en/latest/workflows.html \
"FMRIPrep's documentation").
### References
""".format(nilearn_ver=nilearn_ver)
inputnode = pe.Node(niu.IdentityInterface(fields=['subjects_dir']),
name='inputnode')
bidssrc = pe.Node(BIDSDataGrabber(subject_data=subject_data,
anat_only=anat_only),
name='bidssrc')
bids_info = pe.Node(BIDSInfo(bids_dir=layout.root, bids_validate=False),
name='bids_info')
summary = pe.Node(SubjectSummary(output_spaces=output_spaces,
template=template),
name='summary',
run_without_submitting=True)
about = pe.Node(AboutSummary(version=__version__,
command=' '.join(sys.argv)),
name='about',
run_without_submitting=True)
ds_report_summary = pe.Node(DerivativesDataSink(
base_directory=reportlets_dir, suffix='summary'),
name='ds_report_summary',
run_without_submitting=True)
ds_report_about = pe.Node(DerivativesDataSink(
base_directory=reportlets_dir, suffix='about'),
name='ds_report_about',
run_without_submitting=True)
# Preprocessing of T1w (includes registration to MNI)
anat_preproc_wf = init_anat_preproc_wf(
bids_root=layout.root,
debug=debug,
freesurfer=freesurfer,
fs_spaces=output_spaces,
hires=hires,
longitudinal=longitudinal,
name="anat_preproc_wf",
num_t1w=len(subject_data['t1w']),
omp_nthreads=omp_nthreads,
output_dir=output_dir,
reportlets_dir=reportlets_dir,
skull_strip_fixed_seed=skull_strip_fixed_seed,
skull_strip_template=skull_strip_template,
template=template,
)
workflow.connect([
(inputnode, anat_preproc_wf, [('subjects_dir',
'inputnode.subjects_dir')]),
(bidssrc, bids_info, [(('t1w', fix_multi_T1w_source_name), 'in_file')
]),
(inputnode, summary, [('subjects_dir', 'subjects_dir')]),
(bidssrc, summary, [('t1w', 't1w'), ('t2w', 't2w'), ('bold', 'bold')]),
(bids_info, summary, [('subject', 'subject_id')]),
(bids_info, anat_preproc_wf, [(('subject', _prefix),
'inputnode.subject_id')]),
(bidssrc, anat_preproc_wf, [('t1w', 'inputnode.t1w'),
('t2w', 'inputnode.t2w'),
('roi', 'inputnode.roi'),
('flair', 'inputnode.flair')]),
(bidssrc, ds_report_summary, [(('t1w', fix_multi_T1w_source_name),
'source_file')]),
(summary, ds_report_summary, [('out_report', 'in_file')]),
(bidssrc, ds_report_about, [(('t1w', fix_multi_T1w_source_name),
'source_file')]),
(about, ds_report_about, [('out_report', 'in_file')]),
])
# Overwrite ``out_path_base`` of smriprep's DataSinks
for node in workflow.list_node_names():
if node.split('.')[-1].startswith('ds_'):
workflow.get_node(node).interface.out_path_base = 'fmriprep'
if anat_only:
return workflow
for bold_file in subject_data['bold']:
func_preproc_wf = init_func_preproc_wf(
bold_file=bold_file,
layout=layout,
ignore=ignore,
freesurfer=freesurfer,
use_bbr=use_bbr,
t2s_coreg=t2s_coreg,
bold2t1w_dof=bold2t1w_dof,
reportlets_dir=reportlets_dir,
output_spaces=output_spaces,
template=template,
medial_surface_nan=medial_surface_nan,
cifti_output=cifti_output,
output_dir=output_dir,
omp_nthreads=omp_nthreads,
low_mem=low_mem,
fmap_bspline=fmap_bspline,
fmap_demean=fmap_demean,
use_syn=use_syn,
force_syn=force_syn,
debug=debug,
template_out_grid=template_out_grid,
use_aroma=use_aroma,
aroma_melodic_dim=aroma_melodic_dim,
err_on_aroma_warn=err_on_aroma_warn,
num_bold=len(subject_data['bold']))
workflow.connect([
(
anat_preproc_wf,
func_preproc_wf,
[
(('outputnode.t1_preproc', _pop), 'inputnode.t1_preproc'),
('outputnode.t1_brain', 'inputnode.t1_brain'),
('outputnode.t1_mask', 'inputnode.t1_mask'),
('outputnode.t1_seg', 'inputnode.t1_seg'),
('outputnode.t1_aseg', 'inputnode.t1_aseg'),
('outputnode.t1_aparc', 'inputnode.t1_aparc'),
('outputnode.t1_tpms', 'inputnode.t1_tpms'),
('outputnode.t1_2_mni_forward_transform',
'inputnode.t1_2_mni_forward_transform'),
('outputnode.t1_2_mni_reverse_transform',
'inputnode.t1_2_mni_reverse_transform'),
# Undefined if --no-freesurfer, but this is safe
('outputnode.subjects_dir', 'inputnode.subjects_dir'),
('outputnode.subject_id', 'inputnode.subject_id'),
('outputnode.t1_2_fsnative_forward_transform',
'inputnode.t1_2_fsnative_forward_transform'),
('outputnode.t1_2_fsnative_reverse_transform',
'inputnode.t1_2_fsnative_reverse_transform')
]),
])
return workflow
def init_pepolar_unwarp_wf(omp_nthreads=1,
matched_pe=False,
name="pepolar_unwarp_wf"):
"""
Create the PE-Polar field estimation workflow.
This workflow takes in a set of EPI files with opposite phase encoding
direction than the target file and calculates a displacements field
(in other words, an ANTs-compatible warp file).
This procedure works if there is only one '_epi' file is present
(as long as it has the opposite phase encoding direction to the target
file). The target file will be used to estimate the field distortion.
However, if there is another '_epi' file present with a matching
phase encoding direction to the target it will be used instead.
Currently, different phase encoding dimension in the target file and the
'_epi' file(s) (for example 'i' and 'j') is not supported.
The warp field correcting for the distortions is estimated using AFNI's
3dQwarp, with displacement estimation limited to the target file phase
encoding direction.
It also calculates a new mask for the input dataset that takes into
account the distortions.
.. workflow ::
:graph2use: orig
:simple_form: yes
from sdcflows.workflows.pepolar import init_pepolar_unwarp_wf
wf = init_pepolar_unwarp_wf()
**Parameters**:
matched_pe : bool
Whether the input ``fmaps_epi`` will contain images with matched
PE blips or not. Please use :func:`sdcflows.workflows.pepolar.check_pes`
to determine whether they exist or not.
name : str
Name for this workflow
omp_nthreads : int
Parallelize internal tasks across the number of CPUs given by this option.
**Inputs**:
fmaps_epi : list of tuple(pathlike, str)
The list of EPI images that will be used in PE-Polar correction, and
their corresponding ``PhaseEncodingDirection`` metadata.
The workflow will use the ``bold_pe_dir`` input to separate out those
EPI acquisitions with opposed PE blips and those with matched PE blips
(the latter could be none, and ``in_reference_brain`` would then be
used). The workflow raises a ``ValueError`` when no images with
opposed PE blips are found.
bold_pe_dir : str
The baseline PE direction.
in_reference : pathlike
The baseline reference image (must correspond to ``bold_pe_dir``).
in_reference_brain : pathlike
The reference image above, but skullstripped.
in_mask : pathlike
Not used, present only for consistency across fieldmap estimation
workflows.
**Outputs**:
out_reference : pathlike
The ``in_reference`` after unwarping
out_reference_brain : pathlike
The ``in_reference`` after unwarping and skullstripping
out_warp : pathlike
The corresponding :abbr:`DFM (displacements field map)` compatible with
ANTs.
out_mask : pathlike
Mask of the unwarped input file
"""
workflow = Workflow(name=name)
workflow.__desc__ = """\
A deformation field to correct for susceptibility distortions was estimated
based on two echo-planar imaging (EPI) references with opposing phase-encoding
directions, using `3dQwarp` @afni (AFNI {afni_ver}).
""".format(afni_ver=''.join(['%02d' % v for v in afni.Info().version() or []]))
inputnode = pe.Node(niu.IdentityInterface(fields=[
'fmaps_epi', 'in_reference', 'in_reference_brain', 'in_mask',
'bold_pe_dir'
]),
name='inputnode')
outputnode = pe.Node(niu.IdentityInterface(fields=[
'out_reference', 'out_reference_brain', 'out_warp', 'out_mask'
]),
name='outputnode')
prepare_epi_wf = init_prepare_epi_wf(omp_nthreads=omp_nthreads,
matched_pe=matched_pe,
name="prepare_epi_wf")
qwarp = pe.Node(afni.QwarpPlusMinus(
pblur=[0.05, 0.05],
blur=[-1, -1],
noweight=True,
minpatch=9,
nopadWARP=True,
environ={'OMP_NUM_THREADS': '%d' % omp_nthreads}),
name='qwarp',
n_procs=omp_nthreads)
to_ants = pe.Node(niu.Function(function=_fix_hdr),
name='to_ants',
mem_gb=0.01)
cphdr_warp = pe.Node(CopyHeader(), name='cphdr_warp', mem_gb=0.01)
unwarp_reference = pe.Node(ANTSApplyTransformsRPT(
dimension=3,
generate_report=False,
float=True,
interpolation='LanczosWindowedSinc'),
name='unwarp_reference')
enhance_and_skullstrip_bold_wf = init_enhance_and_skullstrip_bold_wf(
omp_nthreads=omp_nthreads)
workflow.connect([
(inputnode, qwarp, [(('bold_pe_dir', _qwarp_args), 'args')]),
(inputnode, cphdr_warp, [('in_reference', 'hdr_file')]),
(inputnode, prepare_epi_wf, [('fmaps_epi', 'inputnode.maps_pe'),
('bold_pe_dir', 'inputnode.epi_pe'),
('in_reference_brain',
'inputnode.ref_brain')]),
(prepare_epi_wf, qwarp, [('outputnode.opposed_pe', 'base_file'),
('outputnode.matched_pe', 'in_file')]),
(qwarp, cphdr_warp, [('source_warp', 'in_file')]),
(cphdr_warp, to_ants, [('out_file', 'in_file')]),
(to_ants, unwarp_reference, [('out', 'transforms')]),
(inputnode, unwarp_reference, [('in_reference', 'reference_image'),
('in_reference', 'input_image')]),
(unwarp_reference, enhance_and_skullstrip_bold_wf,
[('output_image', 'inputnode.in_file')]),
(unwarp_reference, outputnode, [('output_image', 'out_reference')]),
(enhance_and_skullstrip_bold_wf, outputnode,
[('outputnode.mask_file', 'out_mask'),
('outputnode.skull_stripped_file', 'out_reference_brain')]),
(to_ants, outputnode, [('out', 'out_warp')]),
])
return workflow
def init_fmriprep_wf(layout, subject_list, task_id, echo_idx, run_uuid,
work_dir, output_dir, ignore, debug, low_mem, anat_only,
longitudinal, t2s_coreg, omp_nthreads,
skull_strip_template, skull_strip_fixed_seed, freesurfer,
output_spaces, template, medial_surface_nan, cifti_output,
hires, use_bbr, bold2t1w_dof, fmap_bspline, fmap_demean,
use_syn, force_syn, use_aroma, err_on_aroma_warn,
aroma_melodic_dim, template_out_grid):
"""
This workflow organizes the execution of FMRIPREP, with a sub-workflow for
each subject.
If FreeSurfer's recon-all is to be run, a FreeSurfer derivatives folder is
created and populated with any needed template subjects.
.. workflow::
:graph2use: orig
:simple_form: yes
import os
from collections import namedtuple
BIDSLayout = namedtuple('BIDSLayout', ['root'], defaults='.')
from fmriprep.workflows.base import init_fmriprep_wf
os.environ['FREESURFER_HOME'] = os.getcwd()
wf = init_fmriprep_wf(layout=BIDSLayout(),
subject_list=['fmripreptest'],
task_id='',
echo_idx=None,
run_uuid='X',
work_dir='.',
output_dir='.',
ignore=[],
debug=False,
low_mem=False,
anat_only=False,
longitudinal=False,
t2s_coreg=False,
omp_nthreads=1,
skull_strip_template='OASIS30ANTs',
skull_strip_fixed_seed=False,
freesurfer=True,
output_spaces=['T1w', 'fsnative',
'template', 'fsaverage5'],
template='MNI152NLin2009cAsym',
medial_surface_nan=False,
cifti_output=False,
hires=True,
use_bbr=True,
bold2t1w_dof=9,
fmap_bspline=False,
fmap_demean=True,
use_syn=True,
force_syn=True,
use_aroma=False,
err_on_aroma_warn=False,
aroma_melodic_dim=-200,
template_out_grid='native')
Parameters
layout : BIDSLayout object
BIDS dataset layout
subject_list : list
List of subject labels
task_id : str or None
Task ID of BOLD series to preprocess, or ``None`` to preprocess all
echo_idx : int or None
Index of echo to preprocess in multiecho BOLD series,
or ``None`` to preprocess all
run_uuid : str
Unique identifier for execution instance
work_dir : str
Directory in which to store workflow execution state and temporary files
output_dir : str
Directory in which to save derivatives
ignore : list
Preprocessing steps to skip (may include "slicetiming", "fieldmaps")
debug : bool
Enable debugging outputs
low_mem : bool
Write uncompressed .nii files in some cases to reduce memory usage
anat_only : bool
Disable functional workflows
longitudinal : bool
Treat multiple sessions as longitudinal (may increase runtime)
See sub-workflows for specific differences
t2s_coreg : bool
For multi-echo EPI, use the calculated T2*-map for T2*-driven coregistration
omp_nthreads : int
Maximum number of threads an individual process may use
skull_strip_template : str
Name of ANTs skull-stripping template ('OASIS30ANTs' or 'NKI')
skull_strip_fixed_seed : bool
Do not use a random seed for skull-stripping - will ensure
run-to-run replicability when used with --omp-nthreads 1
freesurfer : bool
Enable FreeSurfer surface reconstruction (may increase runtime)
output_spaces : list
List of output spaces functional images are to be resampled to.
Some parts of pipeline will only be instantiated for some output spaces.
Valid spaces:
- T1w
- template
- fsnative
- fsaverage (or other pre-existing FreeSurfer templates)
template : str
Name of template targeted by ``template`` output space
medial_surface_nan : bool
Replace medial wall values with NaNs on functional GIFTI files
cifti_output : bool
Generate bold CIFTI file in output spaces
hires : bool
Enable sub-millimeter preprocessing in FreeSurfer
use_bbr : bool or None
Enable/disable boundary-based registration refinement.
If ``None``, test BBR result for distortion before accepting.
bold2t1w_dof : 6, 9 or 12
Degrees-of-freedom for BOLD-T1w registration
fmap_bspline : bool
**Experimental**: Fit B-Spline field using least-squares
fmap_demean : bool
Demean voxel-shift map during unwarp
use_syn : bool
**Experimental**: Enable ANTs SyN-based susceptibility distortion correction (SDC).
If fieldmaps are present and enabled, this is not run, by default.
force_syn : bool
**Temporary**: Always run SyN-based SDC
use_aroma : bool
Perform ICA-AROMA on MNI-resampled functional series
err_on_aroma_warn : bool
Do not fail on ICA-AROMA errors
template_out_grid : str
Keyword ('native', '1mm' or '2mm') or path of custom reference
image for normalization
"""
fmriprep_wf = Workflow(name='fmriprep_wf')
fmriprep_wf.base_dir = work_dir
if freesurfer:
fsdir = pe.Node(BIDSFreeSurferDir(
derivatives=output_dir,
freesurfer_home=os.getenv('FREESURFER_HOME'),
spaces=output_spaces),
name='fsdir_run_' + run_uuid.replace('-', '_'),
run_without_submitting=True)
reportlets_dir = os.path.join(work_dir, 'reportlets')
for subject_id in subject_list:
single_subject_wf = init_single_subject_wf(
layout=layout,
subject_id=subject_id,
task_id=task_id,
echo_idx=echo_idx,
name="single_subject_" + subject_id + "_wf",
reportlets_dir=reportlets_dir,
output_dir=output_dir,
ignore=ignore,
debug=debug,
low_mem=low_mem,
anat_only=anat_only,
longitudinal=longitudinal,
t2s_coreg=t2s_coreg,
omp_nthreads=omp_nthreads,
skull_strip_template=skull_strip_template,
skull_strip_fixed_seed=skull_strip_fixed_seed,
freesurfer=freesurfer,
output_spaces=output_spaces,
template=template,
medial_surface_nan=medial_surface_nan,
cifti_output=cifti_output,
hires=hires,
use_bbr=use_bbr,
bold2t1w_dof=bold2t1w_dof,
fmap_bspline=fmap_bspline,
fmap_demean=fmap_demean,
use_syn=use_syn,
force_syn=force_syn,
template_out_grid=template_out_grid,
use_aroma=use_aroma,
aroma_melodic_dim=aroma_melodic_dim,
err_on_aroma_warn=err_on_aroma_warn,
)
single_subject_wf.config['execution']['crashdump_dir'] = (os.path.join(
output_dir, "fmriprep", "sub-" + subject_id, 'log', run_uuid))
for node in single_subject_wf._get_all_nodes():
node.config = deepcopy(single_subject_wf.config)
if freesurfer:
fmriprep_wf.connect(fsdir, 'subjects_dir', single_subject_wf,
'inputnode.subjects_dir')
else:
fmriprep_wf.add_nodes([single_subject_wf])
return fmriprep_wf