def init_fmap_unwarp_report_wf(reportlets_dir, name='fmap_unwarp_report_wf'):
from nipype.interfaces import ants
from nipype.interfaces import utility as niu
from niworkflows.interfaces import SimpleBeforeAfter
def _getwm(in_seg, wm_label=3):
import os.path as op
import nibabel as nb
import numpy as np
nii = nb.load(in_seg)
data = np.zeros(nii.shape, dtype=np.uint8)
data[nii.get_data() == wm_label] = 1
hdr = nii.header.copy()
hdr.set_data_dtype(np.uint8)
nb.Nifti1Image(data, nii.affine, hdr).to_filename('wm.nii.gz')
return op.abspath('wm.nii.gz')
workflow = pe.Workflow(name=name)
inputnode = pe.Node(niu.IdentityInterface(
fields=['in_pre', 'in_post', 'in_seg', 'in_xfm',
'name_source']), name='inputnode')
map_seg = pe.Node(ants.ApplyTransforms(
dimension=3, float=True, interpolation='NearestNeighbor'),
name='map_seg')
sel_wm = pe.Node(niu.Function(function=_getwm), name='sel_wm')
epi_rpt = pe.Node(SimpleBeforeAfter(), name='epi_rpt')
epi_rpt_ds = pe.Node(
DerivativesDataSink(base_directory=reportlets_dir,
suffix='variant-hmcsdc_preproc'), name='epi_rpt_ds'
)
workflow.connect([
(inputnode, epi_rpt, [('in_post', 'after'),
('in_pre', 'before')]),
(inputnode, epi_rpt_ds, [('name_source', 'source_file')]),
(epi_rpt, epi_rpt_ds, [('out_report', 'in_file')]),
(inputnode, map_seg, [('in_post', 'reference_image'),
('in_seg', 'input_image'),
('in_xfm', 'transforms')]),
(map_seg, sel_wm, [('output_image', 'in_seg')]),
(sel_wm, epi_rpt, [('out', 'wm_seg')]),
])
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 niworkflows.nipype.algorithms.confounds import TSNR
from niworkflows.interfaces import SimpleBeforeAfter
from ...interfaces import DerivativesDataSink
workflow = pe.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)
bold_rpt_ds = pe.Node(DerivativesDataSink(base_directory=reportlets_dir,
suffix='variant-preproc'),
name='bold_rpt_ds',
mem_gb=DEFAULT_MEMORY_MIN_GB,
run_without_submitting=True)
workflow.connect([
(inputnode, bold_rpt_ds, [('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, bold_rpt_ds, [('out_report', 'in_file')]),
])
return workflow
def init_anat_reports_wf(*, freesurfer, output_dir, name='anat_reports_wf'):
"""
Set up a battery of datasinks to store reports in the right location.
Parameters
----------
freesurfer : :obj:`bool`
FreeSurfer was enabled
output_dir : :obj:`str`
Directory in which to save derivatives
name : :obj:`str`
Workflow name (default: anat_reports_wf)
Inputs
------
source_file
Input T1w image
std_t1w
T1w image resampled to standard space
std_mask
Mask of skull-stripped template
subject_dir
FreeSurfer SUBJECTS_DIR
subject_id
FreeSurfer subject ID
t1w_conform_report
Conformation report
t1w_preproc
The T1w reference map, which is calculated as the average of bias-corrected
and preprocessed T1w images, defining the anatomical space.
t1w_dseg
Segmentation in T1w space
t1w_mask
Brain (binary) mask estimated by brain extraction.
template
Template space and specifications
"""
from niworkflows.interfaces import SimpleBeforeAfter
from niworkflows.interfaces.masks import ROIsPlot
from ..interfaces.templateflow import TemplateFlowSelect
workflow = Workflow(name=name)
inputfields = [
'source_file', 't1w_conform_report', 't1w_preproc', 't1w_dseg',
't1w_mask', 'template', 'std_t1w', 'std_mask', 'subject_id',
'subjects_dir'
]
inputnode = pe.Node(niu.IdentityInterface(fields=inputfields),
name='inputnode')
seg_rpt = pe.Node(ROIsPlot(colors=['b', 'magenta'], levels=[1.5, 2.5]),
name='seg_rpt')
t1w_conform_check = pe.Node(niu.Function(function=_empty_report),
name='t1w_conform_check',
run_without_submitting=True)
ds_t1w_conform_report = pe.Node(DerivativesDataSink(
base_directory=output_dir,
desc='conform',
datatype="figures",
dismiss_entities=("session", )),
name='ds_t1w_conform_report',
run_without_submitting=True)
ds_t1w_dseg_mask_report = pe.Node(DerivativesDataSink(
base_directory=output_dir,
suffix='dseg',
datatype="figures",
dismiss_entities=("session", )),
name='ds_t1w_dseg_mask_report',
run_without_submitting=True)
workflow.connect([
(inputnode, t1w_conform_check, [('t1w_conform_report', 'in_file')]),
(t1w_conform_check, ds_t1w_conform_report, [('out', 'in_file')]),
(inputnode, ds_t1w_conform_report, [('source_file', 'source_file')]),
(inputnode, ds_t1w_dseg_mask_report, [('source_file', 'source_file')]),
(inputnode, seg_rpt, [('t1w_preproc', 'in_file'),
('t1w_mask', 'in_mask'),
('t1w_dseg', 'in_rois')]),
(seg_rpt, ds_t1w_dseg_mask_report, [('out_report', 'in_file')]),
])
# Generate reportlets showing spatial normalization
tf_select = pe.Node(TemplateFlowSelect(resolution=1),
name='tf_select',
run_without_submitting=True)
norm_msk = pe.Node(niu.Function(
function=_rpt_masks,
output_names=['before', 'after'],
input_names=['mask_file', 'before', 'after', 'after_mask']),
name='norm_msk')
norm_rpt = pe.Node(SimpleBeforeAfter(), name='norm_rpt', mem_gb=0.1)
norm_rpt.inputs.after_label = 'Participant' # after
ds_std_t1w_report = pe.Node(DerivativesDataSink(
base_directory=output_dir,
suffix='T1w',
datatype="figures",
dismiss_entities=("session", )),
name='ds_std_t1w_report',
run_without_submitting=True)
workflow.connect([
(inputnode, tf_select, [('template', 'template')]),
(inputnode, norm_rpt, [('template', 'before_label')]),
(inputnode, norm_msk, [('std_t1w', 'after'),
('std_mask', 'after_mask')]),
(tf_select, norm_msk, [('t1w_file', 'before'),
('brain_mask', 'mask_file')]),
(norm_msk, norm_rpt, [('before', 'before'), ('after', 'after')]),
(inputnode, ds_std_t1w_report, [(('template', _fmt_cohort), 'space'),
('source_file', 'source_file')]),
(norm_rpt, ds_std_t1w_report, [('out_report', 'in_file')]),
])
if freesurfer:
from ..interfaces.reports import FSSurfaceReport
recon_report = pe.Node(FSSurfaceReport(), name='recon_report')
recon_report.interface._always_run = True
ds_recon_report = pe.Node(DerivativesDataSink(
base_directory=output_dir,
desc='reconall',
datatype="figures",
dismiss_entities=("session", )),
name='ds_recon_report',
run_without_submitting=True)
workflow.connect([
(inputnode, recon_report, [('subjects_dir', 'subjects_dir'),
('subject_id', 'subject_id')]),
(recon_report, ds_recon_report, [('out_report', 'in_file')]),
(inputnode, ds_recon_report, [('source_file', 'source_file')])
])
return workflow
def test_registration_wf(tmpdir, datadir, workdir, outdir):
"""Test fieldmap-to-target alignment workflow."""
epi_ref_wf = init_magnitude_wf(2, name="epi_ref_wf")
epi_ref_wf.inputs.inputnode.magnitude = (
datadir
/ "HCP101006"
/ "sub-101006"
/ "func"
/ "sub-101006_task-rest_dir-LR_sbref.nii.gz"
)
magnitude = (
datadir / "HCP101006" / "sub-101006" / "fmap" / "sub-101006_magnitude1.nii.gz"
)
fmap_ref_wf = init_magnitude_wf(2, name="fmap_ref_wf")
fmap_ref_wf.inputs.inputnode.magnitude = magnitude
gen_coeff = pe.Node(niu.Function(function=_gen_coeff), name="gen_coeff")
reg_wf = init_coeff2epi_wf(2, debug=True, write_coeff=True)
workflow = pe.Workflow(name="test_registration_wf")
# fmt: off
workflow.connect([
(epi_ref_wf, reg_wf, [
("outputnode.fmap_ref", "inputnode.target_ref"),
("outputnode.fmap_mask", "inputnode.target_mask"),
]),
(fmap_ref_wf, reg_wf, [
("outputnode.fmap_ref", "inputnode.fmap_ref"),
("outputnode.fmap_mask", "inputnode.fmap_mask"),
]),
(fmap_ref_wf, gen_coeff, [("outputnode.fmap_ref", "img")]),
(gen_coeff, reg_wf, [("out", "inputnode.fmap_coeff")]),
])
# fmt: on
if outdir:
from niworkflows.interfaces import SimpleBeforeAfter
from ...outputs import DerivativesDataSink
report = pe.Node(
SimpleBeforeAfter(
after_label="Target EPI",
before_label="B0 Reference",
),
name="report",
mem_gb=0.1,
)
ds_report = pe.Node(
DerivativesDataSink(
base_directory=str(outdir),
suffix="fieldmap",
space="sbref",
datatype="figures",
dismiss_entities=("fmap",),
source_file=magnitude,
),
name="ds_report",
run_without_submitting=True,
)
# fmt: off
workflow.connect([
(fmap_ref_wf, report, [("outputnode.fmap_ref", "before")]),
(reg_wf, report, [("outputnode.target_ref", "after")]),
(report, ds_report, [("out_report", "in_file")]),
])
# fmt: on
if workdir:
workflow.base_dir = str(workdir)
workflow.run(plugin="Linear")
def init_anat_reports_wf(reportlets_dir, freesurfer, name='anat_reports_wf'):
"""Set up a battery of datasinks to store reports in the right location."""
from niworkflows.interfaces import SimpleBeforeAfter
from niworkflows.interfaces.masks import ROIsPlot
from ..interfaces.templateflow import TemplateFlowSelect
workflow = Workflow(name=name)
inputfields = [
'source_file', 't1w_conform_report', 't1w_preproc', 't1w_dseg',
't1w_mask', 'template', 'template_spec', 'std_t1w', 'std_mask',
'subject_id', 'subjects_dir'
]
inputnode = pe.Node(niu.IdentityInterface(fields=inputfields),
name='inputnode')
seg_rpt = pe.Node(ROIsPlot(colors=['magenta', 'b'], levels=[1.5, 2.5]),
name='seg_rpt')
ds_t1w_conform_report = pe.Node(DerivativesDataSink(
base_directory=reportlets_dir, desc='conform', keep_dtype=True),
name='ds_t1w_conform_report',
run_without_submitting=True)
ds_t1w_dseg_mask_report = pe.Node(DerivativesDataSink(
base_directory=reportlets_dir, suffix='dseg'),
name='ds_t1w_dseg_mask_report',
run_without_submitting=True)
workflow.connect([
(inputnode, ds_t1w_conform_report, [('source_file', 'source_file'),
('t1w_conform_report', 'in_file')
]),
(inputnode, ds_t1w_dseg_mask_report, [('source_file', 'source_file')]),
(inputnode, seg_rpt, [('t1w_preproc', 'in_file'),
('t1w_mask', 'in_mask'),
('t1w_dseg', 'in_rois')]),
(seg_rpt, ds_t1w_dseg_mask_report, [('out_report', 'in_file')]),
])
# Generate reportlets showing spatial normalization
tf_select = pe.Node(TemplateFlowSelect(resolution=1),
name='tf_select',
run_without_submitting=True)
norm_msk = pe.Node(niu.Function(
function=_rpt_masks,
output_names=['before', 'after'],
input_names=['mask_file', 'before', 'after', 'after_mask']),
name='norm_msk')
norm_rpt = pe.Node(SimpleBeforeAfter(), name='norm_rpt', mem_gb=0.1)
norm_rpt.inputs.after_label = 'Participant' # after
ds_std_t1w_report = pe.Node(DerivativesDataSink(
base_directory=reportlets_dir, suffix='T1w'),
name='ds_std_t1w_report',
run_without_submitting=True)
workflow.connect([
(inputnode, tf_select, [('template', 'template'),
('template_spec', 'template_spec')]),
(inputnode, norm_rpt, [('template', 'before_label')]),
(inputnode, norm_msk, [('std_t1w', 'after'),
('std_mask', 'after_mask')]),
(tf_select, norm_msk, [('t1w_file', 'before'),
('brain_mask', 'mask_file')]),
(norm_msk, norm_rpt, [('before', 'before'), ('after', 'after')]),
(inputnode, ds_std_t1w_report, [('template', 'space'),
('source_file', 'source_file')]),
(norm_rpt, ds_std_t1w_report, [('out_report', 'in_file')]),
])
if freesurfer:
from ..interfaces.reports import FSSurfaceReport
recon_report = pe.Node(FSSurfaceReport(), name='recon_report')
recon_report.interface._always_run = True
ds_recon_report = pe.Node(DerivativesDataSink(
base_directory=reportlets_dir, desc='reconall', keep_dtype=True),
name='ds_recon_report',
run_without_submitting=True)
workflow.connect([
(inputnode, recon_report, [('subjects_dir', 'subjects_dir'),
('subject_id', 'subject_id')]),
(recon_report, ds_recon_report, [('out_report', 'in_file')]),
(inputnode, ds_recon_report, [('source_file', 'source_file')])
])
return workflow
def init_fmap_unwarp_report_wf(reportlets_dir, name='fmap_unwarp_report_wf'):
"""
This workflow generates and saves a reportlet showing the effect of fieldmap
unwarping a BOLD image.
.. workflow::
:graph2use: orig
:simple_form: yes
from fmriprep.workflows.fieldmap.base import init_fmap_unwarp_report_wf
wf = init_fmap_unwarp_report_wf(reportlets_dir='.')
**Parameters**
reportlets_dir : str
Directory in which to save reportlets
name : str, optional
Workflow name (default: fmap_unwarp_report_wf)
**Inputs**
in_pre
Reference image, before unwarping
in_post
Reference image, after unwarping
in_seg
Segmentation of preprocessed structural image, including
gray-matter (GM), white-matter (WM) and cerebrospinal fluid (CSF)
in_xfm
Affine transform from T1 space to BOLD space (ITK format)
"""
from niworkflows.nipype.pipeline import engine as pe
from niworkflows.nipype.interfaces import utility as niu
from niworkflows.interfaces.fixes import FixHeaderApplyTransforms as ApplyTransforms
from niworkflows.interfaces import SimpleBeforeAfter
from ...interfaces.images import extract_wm
from ...interfaces import DerivativesDataSink
DEFAULT_MEMORY_MIN_GB = 0.01
workflow = pe.Workflow(name=name)
inputnode = pe.Node(niu.IdentityInterface(
fields=['in_pre', 'in_post', 'in_seg', 'in_xfm', 'name_source']),
name='inputnode')
map_seg = pe.Node(ApplyTransforms(dimension=3,
float=True,
interpolation='NearestNeighbor'),
name='map_seg',
mem_gb=0.3)
sel_wm = pe.Node(niu.Function(function=extract_wm),
name='sel_wm',
mem_gb=DEFAULT_MEMORY_MIN_GB)
bold_rpt = pe.Node(SimpleBeforeAfter(), name='bold_rpt', mem_gb=0.1)
bold_rpt_ds = pe.Node(DerivativesDataSink(base_directory=reportlets_dir,
suffix='variant-hmcsdc_preproc'),
name='bold_rpt_ds',
mem_gb=DEFAULT_MEMORY_MIN_GB,
run_without_submitting=True)
workflow.connect([
(inputnode, bold_rpt, [('in_post', 'after'), ('in_pre', 'before')]),
(inputnode, bold_rpt_ds, [('name_source', 'source_file')]),
(bold_rpt, bold_rpt_ds, [('out_report', 'in_file')]),
(inputnode, map_seg, [('in_post', 'reference_image'),
('in_seg', 'input_image'),
('in_xfm', 'transforms')]),
(map_seg, sel_wm, [('output_image', 'in_seg')]),
(sel_wm, bold_rpt, [('out', 'wm_seg')]),
])
return workflow
def init_fmap_unwarp_report_wf(name='fmap_unwarp_report_wf', forcedsyn=False):
"""
Save a reportlet showing how SDC unwarping performed.
This workflow generates and saves a reportlet showing the effect of fieldmap
unwarping a BOLD image.
.. workflow::
:graph2use: orig
:simple_form: yes
from sdcflows.workflows.unwarp import init_fmap_unwarp_report_wf
wf = init_fmap_unwarp_report_wf()
**Parameters**
name : str, optional
Workflow name (default: fmap_unwarp_report_wf)
forcedsyn : bool, optional
Whether SyN-SDC was forced.
**Inputs**
in_pre
Reference image, before unwarping
in_post
Reference image, after unwarping
in_seg
Segmentation of preprocessed structural image, including
gray-matter (GM), white-matter (WM) and cerebrospinal fluid (CSF)
in_xfm
Affine transform from T1 space to BOLD space (ITK format)
"""
from niworkflows.interfaces import SimpleBeforeAfter
from niworkflows.interfaces.fixes import FixHeaderApplyTransforms as ApplyTransforms
from niworkflows.interfaces.images import extract_wm
DEFAULT_MEMORY_MIN_GB = 0.01
workflow = Workflow(name=name)
inputnode = pe.Node(niu.IdentityInterface(
fields=['in_pre', 'in_post', 'in_seg', 'in_xfm']),
name='inputnode')
map_seg = pe.Node(ApplyTransforms(dimension=3,
float=True,
interpolation='MultiLabel'),
name='map_seg',
mem_gb=0.3)
sel_wm = pe.Node(niu.Function(function=extract_wm),
name='sel_wm',
mem_gb=DEFAULT_MEMORY_MIN_GB)
bold_rpt = pe.Node(SimpleBeforeAfter(), name='bold_rpt', mem_gb=0.1)
ds_report_sdc = pe.Node(DerivativesDataSink(
desc='sdc' if not forcedsyn else 'forcedsyn', suffix='bold'),
name='ds_report_sdc',
mem_gb=DEFAULT_MEMORY_MIN_GB,
run_without_submitting=True)
workflow.connect([
(inputnode, bold_rpt, [('in_post', 'after'), ('in_pre', 'before')]),
(bold_rpt, ds_report_sdc, [('out_report', 'in_file')]),
(inputnode, map_seg, [('in_post', 'reference_image'),
('in_seg', 'input_image'),
('in_xfm', 'transforms')]),
(map_seg, sel_wm, [('output_image', 'in_seg')]),
(sel_wm, bold_rpt, [('out', 'wm_seg')]),
])
return workflow
def init_bold_preproc_report_wf(mem_gb, reportlets_dir, name='bold_preproc_report_wf'):
"""
Generate a visual report.
This workflow generates and saves a reportlet showing the effect of resampling
the BOLD signal using the standard deviation maps.
Workflow Graph
.. 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 : :obj:`float`
Size of BOLD file in GB
reportlets_dir : :obj:`str`
Directory in which to save reportlets
name : :obj:`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.engine.workflows import LiterateWorkflow as Workflow
from niworkflows.interfaces import SimpleBeforeAfter
from ...interfaces import DerivativesDataSink
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',
datatype="figures", dismiss_entities=("echo",)),
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_nonlinear_sdc_wf(bold_file,
freesurfer,
bold2t1w_dof,
template,
omp_nthreads,
bold_pe='j',
atlas_threshold=3,
name='nonlinear_sdc_wf'):
"""
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 ::
:graph2use: orig
:simple_form: yes
from fmriprep.workflows.fieldmap.syn import init_nonlinear_sdc_wf
wf = init_nonlinear_sdc_wf(
bold_file='/dataset/sub-01/func/sub-01_task-rest_bold.nii.gz',
bold_pe='j',
freesurfer=True,
bold2t1w_dof=9,
template='MNI152NLin2009cAsym',
omp_nthreads=8)
**Inputs**
t1_brain
skull-stripped, bias-corrected structural image
bold_ref
skull-stripped reference image
t1_seg
FAST segmentation white and gray matter, in native T1w space
t1_2_mni_reverse_transform
inverse registration transform of T1w image to MNI template
**Outputs**
out_reference_brain
the ``bold_ref`` image after unwarping
out_warp
the corresponding :abbr:`DFM (displacements field map)` compatible with
ANTs
out_mask
mask of the unwarped input file
out_mask_report
reportlet for the skullstripping
.. [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>`_.
.. [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>`_.
"""
workflow = pe.Workflow(name=name)
inputnode = pe.Node(niu.IdentityInterface(
['t1_brain', 'bold_ref', 't1_2_mni_reverse_transform', 't1_seg']),
name='inputnode')
outputnode = pe.Node(niu.IdentityInterface([
'out_reference_brain', 'out_mask', 'out_warp', 'out_warp_report',
'out_mask_report'
]),
name='outputnode')
if bold_pe is None or bold_pe[0] not in ['i', 'j']:
LOGGER.warning(
'Incorrect phase-encoding direction, assuming PA (posterior-to-anterior'
)
bold_pe = 'j'
# Collect predefined data
# Atlas image and registration affine
atlas_img = pkgr.resource_filename('fmriprep', 'data/fmap_atlas.nii.gz')
atlas_2_template_affine = pkgr.resource_filename(
'fmriprep', 'data/fmap_atlas_2_{}_affine.mat'.format(template))
# Registration specifications
affine_transform = pkgr.resource_filename('fmriprep', 'data/affine.json')
syn_transform = pkgr.resource_filename('fmriprep',
'data/susceptibility_syn.json')
invert_t1w = pe.Node(InvertT1w(), 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 = atlas_2_template_affine
# 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(bold_pe[0] == 'i'), int(bold_pe[0] == 'j'), 0]] * 2
syn = pe.Node(Registration(from_file=syn_transform,
restrict_deformation=restrict),
name='syn',
n_procs=omp_nthreads)
seg_2_ref = pe.Node(ApplyTransforms(interpolation='NearestNeighbor',
float=True,
invert_transform_flags=[True]),
name='seg_2_ref',
n_procs=omp_nthreads,
mem_gb=0.3)
sel_wm = pe.Node(niu.Function(function=extract_wm),
name='sel_wm',
mem_gb=DEFAULT_MEMORY_MIN_GB)
syn_rpt = pe.Node(SimpleBeforeAfter(), name='syn_rpt', mem_gb=0.1)
skullstrip_bold_wf = init_skullstrip_bold_wf()
workflow.connect([
(inputnode, invert_t1w, [('t1_brain', 'in_file'),
('bold_ref', 'ref_file')]),
(inputnode, ref_2_t1, [('bold_ref', 'moving_image')]),
(invert_t1w, ref_2_t1, [('out_file', 'fixed_image')]),
(inputnode, t1_2_ref, [('bold_ref', '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, [('t1_2_mni_reverse_transform', 'in2')]),
(inputnode, atlas_2_ref, [('bold_ref', '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, [('bold_ref', 'moving_image')]),
(t1_2_ref, syn, [('output_image', 'fixed_image')]),
(fixed_image_masks, syn, [('out', 'fixed_image_masks')]),
(inputnode, seg_2_ref, [('t1_seg', 'input_image')]),
(ref_2_t1, seg_2_ref, [('forward_transforms', 'transforms')]),
(syn, seg_2_ref, [('warped_image', 'reference_image')]),
(seg_2_ref, sel_wm, [('output_image', 'in_seg')]),
(inputnode, syn_rpt, [('bold_ref', 'before')]),
(syn, syn_rpt, [('warped_image', 'after')]),
(sel_wm, syn_rpt, [('out', 'wm_seg')]),
(syn, skullstrip_bold_wf, [('warped_image', 'inputnode.in_file')]),
(syn, outputnode, [('forward_transforms', 'out_warp')]),
(skullstrip_bold_wf, outputnode,
[('outputnode.skull_stripped_file', 'out_reference_brain'),
('outputnode.mask_file', 'out_mask'),
('outputnode.out_report', 'out_mask_report')]),
(syn_rpt, outputnode, [('out_report', 'out_warp_report')])
])
return workflow
def test_unwarp_wf(tmpdir, datadir, workdir, outdir):
"""Test the unwarping workflow."""
distorted = (
datadir
/ "HCP101006"
/ "sub-101006"
/ "func"
/ "sub-101006_task-rest_dir-LR_sbref.nii.gz"
)
magnitude = (
datadir / "HCP101006" / "sub-101006" / "fmap" / "sub-101006_magnitude1.nii.gz"
)
fmap_ref_wf = init_magnitude_wf(2, name="fmap_ref_wf")
fmap_ref_wf.inputs.inputnode.magnitude = magnitude
epi_ref_wf = init_magnitude_wf(2, name="epi_ref_wf")
epi_ref_wf.inputs.inputnode.magnitude = distorted
reg_wf = init_coeff2epi_wf(2, debug=True, write_coeff=True)
reg_wf.inputs.inputnode.fmap_coeff = [Path(__file__).parent / "fieldcoeff.nii.gz"]
unwarp_wf = init_unwarp_wf(omp_nthreads=2, debug=True)
unwarp_wf.inputs.inputnode.metadata = {
"EffectiveEchoSpacing": 0.00058,
"PhaseEncodingDirection": "i",
}
workflow = pe.Workflow(name="test_unwarp_wf")
# fmt: off
workflow.connect([
(epi_ref_wf, unwarp_wf, [("outputnode.fmap_ref", "inputnode.distorted")]),
(epi_ref_wf, reg_wf, [
("outputnode.fmap_ref", "inputnode.target_ref"),
("outputnode.fmap_mask", "inputnode.target_mask"),
]),
(fmap_ref_wf, reg_wf, [
("outputnode.fmap_ref", "inputnode.fmap_ref"),
("outputnode.fmap_mask", "inputnode.fmap_mask"),
]),
(reg_wf, unwarp_wf, [("outputnode.fmap_coeff", "inputnode.fmap_coeff")]),
])
# fmt:on
if outdir:
from niworkflows.interfaces import SimpleBeforeAfter
from ...outputs import DerivativesDataSink
from ....interfaces.reportlets import FieldmapReportlet
report = pe.Node(
SimpleBeforeAfter(
before_label="Distorted",
after_label="Corrected",
),
name="report",
mem_gb=0.1,
)
ds_report = pe.Node(
DerivativesDataSink(
base_directory=str(outdir),
suffix="bold",
desc="corrected",
datatype="figures",
dismiss_entities=("fmap",),
source_file=distorted,
),
name="ds_report",
run_without_submitting=True,
)
rep = pe.Node(FieldmapReportlet(apply_mask=True), "simple_report")
rep.interface._always_run = True
ds_fmap_report = pe.Node(
DerivativesDataSink(
base_directory=str(outdir),
datatype="figures",
suffix="bold",
desc="fieldmap",
dismiss_entities=("fmap",),
source_file=distorted,
),
name="ds_fmap_report",
)
# fmt: off
workflow.connect([
(epi_ref_wf, report, [("outputnode.fmap_ref", "before")]),
(unwarp_wf, report, [("outputnode.corrected", "after"),
("outputnode.corrected_mask", "wm_seg")]),
(report, ds_report, [("out_report", "in_file")]),
(epi_ref_wf, rep, [("outputnode.fmap_ref", "reference"),
("outputnode.fmap_mask", "mask")]),
(unwarp_wf, rep, [("outputnode.fieldmap", "fieldmap")]),
(rep, ds_fmap_report, [("out_report", "in_file")]),
])
# fmt: on
if workdir:
workflow.base_dir = str(workdir)
workflow.run(plugin="Linear")
def init_anat_norm_wf(
debug,
omp_nthreads,
reportlets_dir,
template_list,
template_specs=None,
):
"""
An individual spatial normalization workflow using ``antsRegistration``.
.. workflow ::
:graph2use: orig
:simple_form: yes
from smriprep.workflows.norm import init_anat_norm_wf
wf = init_anat_norm_wf(
debug=False,
omp_nthreads=1,
reportlets_dir='.',
template_list=['MNI152NLin2009cAsym', 'MNI152NLin6Asym'],
)
**Parameters**
debug : bool
Apply sloppy arguments to speed up processing. Use with caution,
registration processes will be very inaccurate.
omp_nthreads : int
Maximum number of threads an individual process may use.
reportlets_dir : str
Directory in which to save reportlets.
template_list : list of str
List of TemplateFlow identifiers (e.g. ``MNI152NLin6Asym``) that
specifies the target template for spatial normalization. In the
future, this parameter should accept also paths to custom/private
templates with TemplateFlow's organization.
**Inputs**
moving_image
The input image that will be normalized to standard space.
moving_mask
A precise brain mask separating skull/skin/fat from brain
structures.
moving_segmentation
A brain tissue segmentation of the ``moving_image``.
moving_tpms
tissue probability maps (TPMs) corresponding to the
``moving_segmentation``.
lesion_mask
(optional) A mask to exclude regions from the cost-function
input domain to enable standardization of lesioned brains.
orig_t1w
The original T1w image from the BIDS structure.
**Outputs**
warped
The T1w after spatial normalization, in template space.
forward_transform
The T1w-to-template transform.
reverse_transform
The template-to-T1w transform.
tpl_mask
The ``moving_mask`` in template space (matches ``warped`` output).
tpl_seg
The ``moving_segmentation`` in template space (matches ``warped``
output).
tpl_tpms
The ``moving_tpms`` in template space (matches ``warped`` output).
template
The input parameter ``template`` for further use in nodes depending
on this
workflow.
"""
if not isinstance(template_list, (list, tuple)):
template_list = [template_list]
templateflow = templates()
if any(template not in templateflow for template in template_list):
raise NotImplementedError(
'This is embarrassing - custom templates are not (yet) supported.'
'Please make sure none of the options already available via TemplateFlow '
'fit your needs.')
workflow = Workflow('anat_norm_wf')
workflow.__desc__ = """\
Volume-based spatial normalization to {targets} ({targets_id}) was performed through
nonlinear registration with `antsRegistration` (ANTs {ants_ver}),
using brain-extracted versions of both T1w reference and the T1w template.
The following template{tpls} selected for spatial normalization:
""".format(ants_ver=ANTsInfo.version() or '(version unknown)',
targets='%s standard space%s' %
(defaultdict('several'.format, {
1: 'one',
2: 'two',
3: 'three',
4: 'four'
})[len(template_list)], 's' * (len(template_list) != 1)),
targets_id=', '.join(template_list),
tpls=(' was', 's were')[len(template_list) != 1])
if not template_specs:
template_specs = [{}] * len(template_list)
if len(template_list) != len(template_specs):
raise RuntimeError(
'Number of templates (%d) doesn\'t match the number of specs '
'(%d) provided.' % (len(template_list), len(template_specs)))
# Append template citations to description
for template in template_list:
template_meta = get_metadata(template)
template_refs = ['@%s' % template.lower()]
if template_meta.get('RRID', None):
template_refs += ['RRID:%s' % template_meta['RRID']]
workflow.__desc__ += """\
*{template_name}* [{template_refs}; TemplateFlow ID: {template}]""".format(
template=template,
template_name=template_meta['Name'],
template_refs=', '.join(template_refs))
workflow.__desc__ += (', ', '.')[template == template_list[-1]]
inputnode = pe.Node(niu.IdentityInterface(fields=[
'moving_image', 'moving_mask', 'moving_segmentation', 'moving_tpms',
'lesion_mask', 'orig_t1w', 'template'
]),
name='inputnode')
inputnode.iterables = [('template', template_list)]
out_fields = [
'warped', 'forward_transform', 'reverse_transform', 'tpl_mask',
'tpl_seg', 'tpl_tpms', 'template'
]
poutputnode = pe.Node(niu.IdentityInterface(fields=out_fields),
name='poutputnode')
tpl_specs = pe.Node(niu.Function(function=_select_specs),
name='tpl_specs',
run_without_submitting=True)
tpl_specs.inputs.template_list = template_list
tpl_specs.inputs.template_specs = template_specs
tpl_select = pe.Node(niu.Function(function=_get_template),
name='tpl_select',
run_without_submitting=True)
# With the improvements from poldracklab/niworkflows#342 this truncation is now necessary
trunc_mov = pe.Node(ImageMath(operation='TruncateImageIntensity',
op2='0.01 0.999 256'),
name='trunc_mov')
registration = pe.Node(RobustMNINormalization(
float=True,
flavor=['precise', 'testing'][debug],
),
name='registration',
n_procs=omp_nthreads,
mem_gb=2)
# Resample T1w-space inputs
tpl_moving = pe.Node(ApplyTransforms(dimension=3,
default_value=0,
float=True,
interpolation='LanczosWindowedSinc'),
name='tpl_moving')
tpl_mask = pe.Node(ApplyTransforms(dimension=3,
default_value=0,
float=True,
interpolation='MultiLabel'),
name='tpl_mask')
tpl_seg = pe.Node(ApplyTransforms(dimension=3,
default_value=0,
float=True,
interpolation='MultiLabel'),
name='tpl_seg')
tpl_tpms = pe.MapNode(ApplyTransforms(dimension=3,
default_value=0,
float=True,
interpolation='Gaussian'),
iterfield=['input_image'],
name='tpl_tpms')
workflow.connect([
(inputnode, tpl_specs, [('template', 'template')]),
(inputnode, tpl_select, [('template', 'template')]),
(inputnode, registration, [('template', 'template')]),
(inputnode, trunc_mov, [('moving_image', 'op1')]),
(inputnode, registration, [('moving_mask', 'moving_mask'),
('lesion_mask', 'lesion_mask')]),
(inputnode, tpl_moving, [('moving_image', 'input_image')]),
(inputnode, tpl_mask, [('moving_mask', 'input_image')]),
(tpl_specs, tpl_select, [('out', 'template_spec')]),
(tpl_specs, registration, [(('out', _drop_res), 'template_spec')]),
(tpl_select, tpl_moving, [('out', 'reference_image')]),
(tpl_select, tpl_mask, [('out', 'reference_image')]),
(tpl_select, tpl_seg, [('out', 'reference_image')]),
(tpl_select, tpl_tpms, [('out', 'reference_image')]),
(trunc_mov, registration, [('output_image', 'moving_image')]),
(registration, tpl_moving, [('composite_transform', 'transforms')]),
(registration, tpl_mask, [('composite_transform', 'transforms')]),
(inputnode, tpl_seg, [('moving_segmentation', 'input_image')]),
(registration, tpl_seg, [('composite_transform', 'transforms')]),
(inputnode, tpl_tpms, [('moving_tpms', 'input_image')]),
(registration, tpl_tpms, [('composite_transform', 'transforms')]),
(registration, poutputnode,
[('composite_transform', 'forward_transform'),
('inverse_composite_transform', 'reverse_transform')]),
(tpl_moving, poutputnode, [('output_image', 'warped')]),
(tpl_mask, poutputnode, [('output_image', 'tpl_mask')]),
(tpl_seg, poutputnode, [('output_image', 'tpl_seg')]),
(tpl_tpms, poutputnode, [('output_image', 'tpl_tpms')]),
(inputnode, poutputnode, [('template', 'template')]),
])
# Generate and store report
msk_select = pe.Node(niu.Function(
function=_get_template,
input_names=['template', 'template_spec', 'suffix', 'desc']),
name='msk_select',
run_without_submitting=True)
msk_select.inputs.desc = 'brain'
msk_select.inputs.suffix = 'mask'
norm_msk = pe.Node(niu.Function(
function=_rpt_masks,
output_names=['before', 'after'],
input_names=['mask_file', 'before', 'after', 'after_mask']),
name='norm_msk')
norm_rpt = pe.Node(SimpleBeforeAfter(), name='norm_rpt', mem_gb=0.1)
norm_rpt.inputs.after_label = 'Participant' # after
ds_t1_2_tpl_report = pe.Node(DerivativesDataSink(
base_directory=reportlets_dir, keep_dtype=True),
name='ds_t1_2_tpl_report',
run_without_submitting=True)
workflow.connect([
(inputnode, msk_select, [('template', 'template')]),
(inputnode, norm_rpt, [('template', 'before_label')]),
(tpl_mask, norm_msk, [('output_image', 'after_mask')]),
(tpl_specs, msk_select, [('out', 'template_spec')]),
(msk_select, norm_msk, [('out', 'mask_file')]),
(tpl_select, norm_msk, [('out', 'before')]),
(tpl_moving, norm_msk, [('output_image', 'after')]),
(norm_msk, norm_rpt, [('before', 'before'), ('after', 'after')]),
(inputnode, ds_t1_2_tpl_report, [('template', 'space'),
('orig_t1w', 'source_file')]),
(norm_rpt, ds_t1_2_tpl_report, [('out_report', 'in_file')]),
])
# Provide synchronized output
outputnode = pe.JoinNode(niu.IdentityInterface(fields=out_fields),
name='outputnode',
joinsource='inputnode')
workflow.connect([
(poutputnode, outputnode, [(f, f) for f in out_fields]),
])
return workflow
def init_dwi_preproc_wf(dwi_file, has_fieldmap=False):
"""
Build a preprocessing workflow for one DWI run.
Workflow Graph
.. workflow::
:graph2use: orig
:simple_form: yes
from dmriprep.config.testing import mock_config
from dmriprep import config
from dmriprep.workflows.dwi.base import init_dwi_preproc_wf
with mock_config():
wf = init_dwi_preproc_wf(
f"{config.execution.layout.root}/"
"sub-THP0005/dwi/sub-THP0005_dwi.nii.gz"
)
Parameters
----------
dwi_file : :obj:`os.PathLike`
One diffusion MRI dataset to be processed.
has_fieldmap : :obj:`bool`
Build the workflow with a path to register a fieldmap to the DWI.
Inputs
------
dwi_file
dwi NIfTI file
in_bvec
File path of the b-vectors
in_bval
File path of the b-values
fmap
File path of the fieldmap
fmap_ref
File path of the fieldmap reference
fmap_coeff
File path of the fieldmap coefficients
fmap_mask
File path of the fieldmap mask
fmap_id
The BIDS modality label of the fieldmap being used
Outputs
-------
dwi_reference
A 3D :math:`b = 0` reference, before susceptibility distortion correction.
dwi_mask
A 3D, binary mask of the ``dwi_reference`` above.
gradients_rasb
A *RASb* (RAS+ coordinates, scaled b-values, normalized b-vectors, BIDS-compatible)
gradient table.
See Also
--------
* :py:func:`~dmriprep.workflows.dwi.util.init_dwi_reference_wf`
* :py:func:`~dmriprep.workflows.dwi.outputs.init_reportlets_wf`
"""
from ...interfaces.vectors import CheckGradientTable
from .util import init_dwi_reference_wf
from .outputs import init_reportlets_wf
layout = config.execution.layout
dwi_file = Path(dwi_file)
config.loggers.workflow.debug(
f"Creating DWI preprocessing workflow for <{dwi_file.name}>"
)
if has_fieldmap:
import re
from sdcflows.fieldmaps import get_identifier
dwi_rel = re.sub(
r"^sub-[a-zA-Z0-9]*/", "", str(dwi_file.relative_to(layout.root))
)
estimator_key = get_identifier(dwi_rel)
if not estimator_key:
has_fieldmap = False
config.loggers.workflow.critical(
f"None of the available B0 fieldmaps are associated to <{dwi_rel}>"
)
# Build workflow
workflow = Workflow(name=_get_wf_name(dwi_file.name))
inputnode = pe.Node(
niu.IdentityInterface(
fields=[
# DWI
"dwi_file",
"in_bvec",
"in_bval",
# From SDCFlows
"fmap",
"fmap_ref",
"fmap_coeff",
"fmap_mask",
"fmap_id",
# From anatomical
"t1w_preproc",
"t1w_mask",
"t1w_dseg",
"t1w_aseg",
"t1w_aparc",
"t1w_tpms",
"template",
"anat2std_xfm",
"std2anat_xfm",
"subjects_dir",
"subject_id",
"t1w2fsnative_xfm",
"fsnative2t1w_xfm",
]
),
name="inputnode",
)
inputnode.inputs.dwi_file = str(dwi_file.absolute())
inputnode.inputs.in_bvec = str(layout.get_bvec(dwi_file))
inputnode.inputs.in_bval = str(layout.get_bval(dwi_file))
outputnode = pe.Node(
niu.IdentityInterface(fields=["dwi_reference", "dwi_mask", "gradients_rasb"]),
name="outputnode",
)
gradient_table = pe.Node(CheckGradientTable(), name="gradient_table")
dwi_reference_wf = init_dwi_reference_wf(
mem_gb=config.DEFAULT_MEMORY_MIN_GB, omp_nthreads=config.nipype.omp_nthreads
)
# MAIN WORKFLOW STRUCTURE
# fmt: off
workflow.connect([
(inputnode, gradient_table, [("dwi_file", "dwi_file"),
("in_bvec", "in_bvec"),
("in_bval", "in_bval")]),
(inputnode, dwi_reference_wf, [("dwi_file", "inputnode.dwi_file")]),
(gradient_table, dwi_reference_wf, [("b0_ixs", "inputnode.b0_ixs")]),
(gradient_table, outputnode, [("out_rasb", "gradients_rasb")]),
])
# fmt: on
if config.workflow.run_reconall:
from niworkflows.interfaces.nibabel import ApplyMask
from niworkflows.anat.coregistration import init_bbreg_wf
from ...utils.misc import sub_prefix as _prefix
# Mask the T1w
t1w_brain = pe.Node(ApplyMask(), name="t1w_brain")
bbr_wf = init_bbreg_wf(
debug=config.execution.debug,
epi2t1w_init=config.workflow.dwi2t1w_init,
omp_nthreads=config.nipype.omp_nthreads,
)
ds_report_reg = pe.Node(
DerivativesDataSink(
base_directory=str(config.execution.output_dir),
datatype="figures",
),
name="ds_report_reg",
run_without_submitting=True,
)
def _bold_reg_suffix(fallback):
return "coreg" if fallback else "bbregister"
# fmt: off
workflow.connect([
(inputnode, bbr_wf, [
("fsnative2t1w_xfm", "inputnode.fsnative2t1w_xfm"),
(("subject_id", _prefix), "inputnode.subject_id"),
("subjects_dir", "inputnode.subjects_dir"),
]),
# T1w Mask
(inputnode, t1w_brain, [("t1w_preproc", "in_file"),
("t1w_mask", "in_mask")]),
(inputnode, ds_report_reg, [("dwi_file", "source_file")]),
# BBRegister
(dwi_reference_wf, bbr_wf, [
("outputnode.ref_image", "inputnode.in_file")
]),
(bbr_wf, ds_report_reg, [
('outputnode.out_report', 'in_file'),
(('outputnode.fallback', _bold_reg_suffix), 'desc')]),
])
# fmt: on
# REPORTING ############################################################
reportlets_wf = init_reportlets_wf(
str(config.execution.output_dir),
sdc_report=has_fieldmap,
)
# fmt: off
workflow.connect([
(inputnode, reportlets_wf, [("dwi_file", "inputnode.source_file")]),
(dwi_reference_wf, reportlets_wf, [
("outputnode.validation_report", "inputnode.validation_report"),
]),
(outputnode, reportlets_wf, [
("dwi_reference", "inputnode.dwi_ref"),
("dwi_mask", "inputnode.dwi_mask"),
]),
])
# fmt: on
if not has_fieldmap:
# fmt: off
workflow.connect([
(dwi_reference_wf, outputnode, [("outputnode.ref_image", "dwi_reference"),
("outputnode.dwi_mask", "dwi_mask")]),
])
# fmt: on
return workflow
from niworkflows.interfaces import SimpleBeforeAfter
from niworkflows.interfaces.utility import KeySelect
from sdcflows.workflows.apply.registration import init_coeff2epi_wf
from sdcflows.workflows.apply.correction import init_unwarp_wf
coeff2epi_wf = init_coeff2epi_wf(
debug=config.execution.debug,
omp_nthreads=config.nipype.omp_nthreads,
write_coeff=True,
)
unwarp_wf = init_unwarp_wf(
debug=config.execution.debug,
omp_nthreads=config.nipype.omp_nthreads
)
unwarp_wf.inputs.inputnode.metadata = layout.get_metadata(str(dwi_file))
output_select = pe.Node(
KeySelect(fields=["fmap", "fmap_ref", "fmap_coeff", "fmap_mask"]),
name="output_select",
run_without_submitting=True,
)
output_select.inputs.key = estimator_key[0]
if len(estimator_key) > 1:
config.loggers.workflow.warning(
f"Several fieldmaps <{', '.join(estimator_key)}> are "
f"'IntendedFor' <{dwi_file}>, using {estimator_key[0]}"
)
sdc_report = pe.Node(
SimpleBeforeAfter(before_label="Distorted", after_label="Corrected",),
name="sdc_report",
mem_gb=0.1,
)
# fmt: off
workflow.connect([
(inputnode, output_select, [("fmap", "fmap"),
("fmap_ref", "fmap_ref"),
("fmap_coeff", "fmap_coeff"),
("fmap_mask", "fmap_mask"),
("fmap_id", "keys")]),
(output_select, coeff2epi_wf, [
("fmap_ref", "inputnode.fmap_ref"),
("fmap_coeff", "inputnode.fmap_coeff"),
("fmap_mask", "inputnode.fmap_mask")]),
(dwi_reference_wf, coeff2epi_wf, [
("outputnode.ref_image", "inputnode.target_ref"),
("outputnode.dwi_mask", "inputnode.target_mask")]),
(dwi_reference_wf, unwarp_wf, [("outputnode.ref_image", "inputnode.distorted")]),
(coeff2epi_wf, unwarp_wf, [
("outputnode.fmap_coeff", "inputnode.fmap_coeff")]),
(dwi_reference_wf, sdc_report, [("outputnode.ref_image", "before")]),
(unwarp_wf, sdc_report, [("outputnode.corrected", "after"),
("outputnode.corrected_mask", "wm_seg")]),
(sdc_report, reportlets_wf, [("out_report", "inputnode.sdc_report")]),
(unwarp_wf, outputnode, [("outputnode.corrected", "dwi_reference"),
("outputnode.corrected_mask", "dwi_mask")]),
])
# fmt: on
return workflow