def __init__(self, in_file='path', ref_file='path', **options):
from nipype.interfaces.image import Rescale
invert_t1w = Rescale(invert=True)
invert_t1w.inputs.in_file = in_file
invert_t1w.inputs.ref_file = ref_file
for ef in options:
setattr(invert_t1w.inputs, ef, options[ef])
self.res = invert_t1w.run()
def register(warped_dir, subject_Tws, atlas_images, atlas_segmentations, n_jobs):
#create list for subject T1w and T2w because Nipype requires inputs to be in list format specifically fr JLF node
sub_T1w_list = []
sub_T1w_list.append(subject_Tws[0])
sub_T2w_list = []
sub_T2w_list.append(subject_Tws[1])
atlas_forinvert = atlas_images[0] #just use
def main():
# sub_T2w_inverted =
subject_T2w = '/home/exacloud/lustre1/fnl_lab/data/HCP/processed/BCP/BCP_NEO_ATROPOS_4/sub-375518/ses-1m/files/T1w/T1w_acpc_dc_restore_brain.nii.gz'
inv(subject_T2w)
def inv(subject_T2w):
fsl.maths.MathsCommand(in_file=subject_T2w, args="-recip", out_file="T1w_acpc_dc_restore_brain_inverse.nii.gz")
if __name__ == '__main__':
main()
input_spec = pe.Node(
utility.IdentityInterface(fields=['subject_Txw', 'subject_Txw_list', 'subject_dual_Tws', 'atlas_image', 'atlas_segmentation', 'atlas_forinvert']),
#iterables=[('atlas_image', atlas_images), ('atlas_segmentation', atlas_segmentations)],
#synchronize=True,
name='input_spec'
)
# set input_spec
input_spec.inputs.subject_Txw = subject_Tws[1] #using T2w here
input_spec.inputs.subject_Txw_list = sub_T2w_list
input_spec.inputs.subject_dual_Tws = subject_Tws
input_spec.inputs.atlas_forinvert = atlas_forinvert
invert = pe.Node(Rescale(invert=True,
percentile = 1.), name='invert')
wf = pe.Workflow(name='wf', base_dir=warped_dir)
wf.connect(input_spec, "subject_Txw", invert, "in_file")
wf.connect(input_spec, "atlas_forinvert", invert, "ref_file") #should I use the subject or atlas T1w here?
wf.config['execution']['parameterize_dirs'] = False
#create workflow graph
wf.write_graph()
#Nipype plugins specify how workflow should be executed
output = wf.run(plugin='MultiProc', plugin_args={'n_procs' : n_jobs})
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_syn_sdc_wf(omp_nthreads,
bold_pe=None,
atlas_threshold=3,
name='syn_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_syn_sdc_wf
wf = init_syn_sdc_wf(
bold_pe='j',
omp_nthreads=8)
**Inputs**
bold_ref
reference image
bold_ref_brain
skull-stripped reference image
template : str
Name of template targeted by ``template`` output space
t1_brain
skull-stripped, bias-corrected structural image
t1_2_mni_reverse_transform
inverse registration transform of T1w image to MNI template
**Outputs**
out_reference
the ``bold_ref`` image after unwarping
out_reference_brain
the ``bold_ref_brain`` image after unwarping
out_warp
the corresponding :abbr:`DFM (displacements field map)` compatible with
ANTs
out_mask
mask of the unwarped input file
"""
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'
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([
'bold_ref', 'bold_ref_brain', 'template', 't1_brain',
't1_2_mni_reverse_transform'
]),
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 = pkgr.resource_filename('fmriprep', 'data/fmap_atlas.nii.gz')
# 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(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)
# 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)
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, [('t1_brain', 'in_file'),
('bold_ref', 'ref_file')]),
(inputnode, ref_2_t1, [('bold_ref_brain', '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'),
(('template', _prior_path), 'in3')]),
(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_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, [('bold_ref', 'reference_image'),
('bold_ref', '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_syn_sdc_wf(
*,
atlas_threshold=3,
debug=False,
name="syn_sdc_wf",
omp_nthreads=1,
):
"""
Build the *fieldmap-less* susceptibility-distortion estimation workflow.
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.
Workflow Graph
.. workflow ::
:graph2use: orig
:simple_form: yes
from sdcflows.workflows.fit.syn import init_syn_sdc_wf
wf = init_syn_sdc_wf(omp_nthreads=8)
Parameters
----------
atlas_threshold : :obj:`float`
Exclude from the registration metric computation areas with average distortions
below this threshold (in mm).
debug : :obj:`bool`
Whether a fast (less accurate) configuration of the workflow 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
------
epi_ref : :obj:`tuple` (:obj:`str`, :obj:`dict`)
A tuple, where the first element is the path of the distorted EPI
reference map (e.g., an average of *b=0* volumes), and the second
element is a dictionary of associated metadata.
epi_mask : :obj:`str`
A path to a brain mask corresponding to ``epi_ref``.
anat_brain : :obj:`str`
A preprocessed, skull-stripped anatomical (T1w or T2w) image.
std2anat_xfm : :obj:`str`
inverse registration transform of T1w image to MNI template
anat2epi_xfm : :obj:`str`
transform mapping coordinates from the EPI space to the anatomical
space (i.e., the transform to resample anatomical info into EPI space.)
Outputs
-------
fmap : :obj:`str`
The path of the estimated fieldmap.
fmap_ref : :obj:`str`
The path of an unwarped conversion of files in ``epi_ref``.
fmap_coeff : :obj:`str` or :obj:`list` of :obj:`str`
The path(s) of the B-Spline coefficients supporting the fieldmap.
"""
from pkg_resources import resource_filename as pkgrf
from packaging.version import parse as parseversion, Version
from nipype.interfaces.image import Rescale
from niworkflows.interfaces.fixes import (
FixHeaderApplyTransforms as ApplyTransforms,
FixHeaderRegistration as Registration,
)
from niworkflows.interfaces.nibabel import Binarize
from ...utils.misc import front as _pop
from ...interfaces.utils import Deoblique, Reoblique
from ...interfaces.bspline import (
BSplineApprox,
DEFAULT_LF_ZOOMS_MM,
DEFAULT_HF_ZOOMS_MM,
DEFAULT_ZOOMS_MM,
)
from ..ancillary import init_brainextraction_wf
ants_version = Registration().version
if ants_version and parseversion(ants_version) < Version("2.2.0"):
raise RuntimeError(
f"Please upgrade ANTs to 2.2 or older ({ants_version} found).")
workflow = Workflow(name=name)
workflow.__desc__ = f"""\
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 EPI reference
to the same-subject T1w-reference with its intensity inverted [@fieldmapless1;
@fieldmapless2].
Registration is performed with `antsRegistration`
(ANTs {ants_version or "-- version unknown"}), and
the process regularized by constraining deformation to be nonzero only
along the phase-encoding direction, and modulated with an average fieldmap
template [@fieldmapless3].
"""
inputnode = pe.Node(
niu.IdentityInterface([
"epi_ref", "epi_mask", "anat_brain", "std2anat_xfm", "anat2epi_xfm"
]),
name="inputnode",
)
outputnode = pe.Node(
niu.IdentityInterface(["fmap", "fmap_ref", "fmap_coeff", "fmap_mask"]),
name="outputnode",
)
invert_t1w = pe.Node(Rescale(invert=True), name="invert_t1w", mem_gb=0.3)
anat2epi = pe.Node(ApplyTransforms(interpolation="BSpline"),
name="anat2epi",
n_procs=omp_nthreads)
# Mapping & preparing prior knowledge
# Concatenate transform files:
# 1) anat -> EPI; 2) MNI -> anat; 3) ATLAS -> MNI
transform_list = pe.Node(niu.Merge(3),
name="transform_list",
mem_gb=DEFAULT_MEMORY_MIN_GB)
transform_list.inputs.in3 = pkgrf(
"sdcflows", "data/fmap_atlas_2_MNI152NLin2009cAsym_affine.mat")
prior2epi = pe.Node(
ApplyTransforms(
input_image=pkgrf("sdcflows", "data/fmap_atlas.nii.gz")),
name="prior2epi",
n_procs=omp_nthreads,
mem_gb=0.3,
)
atlas_msk = pe.Node(Binarize(thresh_low=atlas_threshold), name="atlas_msk")
deoblique = pe.Node(Deoblique(), name="deoblique")
reoblique = pe.Node(Reoblique(), name="reoblique")
# SyN Registration Core
syn = pe.Node(
Registration(
from_file=pkgrf("sdcflows", "data/susceptibility_syn.json")),
name="syn",
n_procs=omp_nthreads,
)
unwarp_ref = pe.Node(
ApplyTransforms(interpolation="BSpline"),
name="unwarp_ref",
)
brainextraction_wf = init_brainextraction_wf()
# Extract nonzero component
extract_field = pe.Node(niu.Function(function=_extract_field),
name="extract_field")
# Regularize with B-Splines
bs_filter = pe.Node(BSplineApprox(),
n_procs=omp_nthreads,
name="bs_filter")
bs_filter.interface._always_run = debug
bs_filter.inputs.bs_spacing = ([DEFAULT_LF_ZOOMS_MM, DEFAULT_HF_ZOOMS_MM]
if not debug else [DEFAULT_ZOOMS_MM])
bs_filter.inputs.extrapolate = not debug
# fmt: off
workflow.connect([
(inputnode, transform_list, [("anat2epi_xfm", "in1"),
("std2anat_xfm", "in2")]),
(inputnode, invert_t1w, [("anat_brain", "in_file"),
(("epi_ref", _pop), "ref_file")]),
(inputnode, anat2epi, [(("epi_ref", _pop), "reference_image"),
("anat2epi_xfm", "transforms")]),
(inputnode, deoblique, [(("epi_ref", _pop), "in_epi"),
("epi_mask", "mask_epi")]),
(inputnode, reoblique, [(("epi_ref", _pop), "in_epi")]),
(inputnode, syn, [(("epi_ref", _warp_dir), "restrict_deformation")]),
(inputnode, unwarp_ref, [(("epi_ref", _pop), "reference_image"),
(("epi_ref", _pop), "input_image")]),
(inputnode, prior2epi, [(("epi_ref", _pop), "reference_image")]),
(inputnode, extract_field, [("epi_ref", "epi_meta")]),
(invert_t1w, anat2epi, [("out_file", "input_image")]),
(transform_list, prior2epi, [("out", "transforms")]),
(prior2epi, atlas_msk, [("output_image", "in_file")]),
(anat2epi, deoblique, [("output_image", "in_anat")]),
(atlas_msk, deoblique, [("out_mask", "mask_anat")]),
(deoblique, syn, [("out_epi", "moving_image"),
("out_anat", "fixed_image"),
("mask_epi", "moving_image_masks"),
(("mask_anat", _fixed_masks_arg),
"fixed_image_masks")]),
(syn, extract_field, [("forward_transforms", "in_file")]),
(syn, unwarp_ref, [("forward_transforms", "transforms")]),
(unwarp_ref, reoblique, [("output_image", "in_plumb")]),
(reoblique, brainextraction_wf, [("out_epi", "inputnode.in_file")]),
(extract_field, reoblique, [("out", "in_field")]),
(reoblique, bs_filter, [("out_field", "in_data")]),
(brainextraction_wf, bs_filter, [("outputnode.out_mask", "in_mask")]),
(reoblique, outputnode, [("out_epi", "fmap_ref")]),
(brainextraction_wf, outputnode, [("outputnode.out_mask", "fmap_mask")
]),
(bs_filter, outputnode,
[("out_extrapolated" if not debug else "out_field", "fmap"),
("out_coeff", "fmap_coeff")]),
])
# fmt: on
return workflow