def test_flirt():
# setup
tmpdir, infile, reffile = setup_flirt()
flirter = fsl.FLIRT()
yield assert_equal, flirter.cmd, 'flirt'
flirter.inputs.bins = 256
flirter.inputs.cost = 'mutualinfo'
flirted = fsl.FLIRT(in_file=infile,
reference=reffile,
out_file='outfile',
out_matrix_file='outmat.mat',
bins=256,
cost='mutualinfo')
flirt_est = fsl.FLIRT(in_file=infile,
reference=reffile,
out_matrix_file='outmat.mat',
bins=256,
cost='mutualinfo')
yield assert_not_equal, flirter.inputs, flirted.inputs
yield assert_not_equal, flirted.inputs, flirt_est.inputs
yield assert_equal, flirter.inputs.bins, flirted.inputs.bins
yield assert_equal, flirter.inputs.cost, flirt_est.inputs.cost
realcmd = 'flirt -in %s -ref %s -out outfile -omat outmat.mat ' \
'-bins 256 -cost mutualinfo' % (infile, reffile)
yield assert_equal, flirted.cmdline, realcmd
flirter = fsl.FLIRT()
# infile not specified
yield assert_raises, ValueError, flirter.run
flirter.inputs.in_file = infile
# reference not specified
yield assert_raises, ValueError, flirter.run
flirter.inputs.reference = reffile
# Generate outfile and outmatrix
pth, fname, ext = split_filename(infile)
outfile = fsl_name(flirter, '%s_flirt' % fname)
outmat = '%s_flirt.mat' % fname
realcmd = 'flirt -in %s -ref %s -out %s -omat %s' % (infile, reffile,
outfile, outmat)
yield assert_equal, flirter.cmdline, realcmd
_, tmpfile = tempfile.mkstemp(suffix='.nii', dir=tmpdir)
# Loop over all inputs, set a reasonable value and make sure the
# cmdline is updated correctly.
for key, trait_spec in sorted(fsl.FLIRT.input_spec().traits().items()):
# Skip mandatory inputs and the trait methods
if key in ('trait_added', 'trait_modified', 'in_file', 'reference',
'environ', 'output_type', 'out_file', 'out_matrix_file',
'in_matrix_file', 'apply_xfm', 'ignore_exception',
'terminal_output', 'out_log', 'save_log'):
continue
param = None
value = None
if key == 'args':
param = '-v'
value = '-v'
elif isinstance(trait_spec.trait_type, File):
value = tmpfile
param = trait_spec.argstr % value
elif trait_spec.default is False:
param = trait_spec.argstr
value = True
elif key in ('searchr_x', 'searchr_y', 'searchr_z'):
value = [-45, 45]
param = trait_spec.argstr % ' '.join(str(elt) for elt in value)
else:
value = trait_spec.default
param = trait_spec.argstr % value
cmdline = 'flirt -in %s -ref %s' % (infile, reffile)
# Handle autogeneration of outfile
pth, fname, ext = split_filename(infile)
outfile = fsl_name(fsl.FLIRT(), '%s_flirt' % fname)
outfile = ' '.join(['-out', outfile])
# Handle autogeneration of outmatrix
outmatrix = '%s_flirt.mat' % fname
outmatrix = ' '.join(['-omat', outmatrix])
# Build command line
cmdline = ' '.join([cmdline, outfile, outmatrix, param])
flirter = fsl.FLIRT(in_file=infile, reference=reffile)
setattr(flirter.inputs, key, value)
yield assert_equal, flirter.cmdline, cmdline
# Test OutputSpec
flirter = fsl.FLIRT(in_file=infile, reference=reffile)
pth, fname, ext = split_filename(infile)
flirter.inputs.out_file = ''.join(['foo', ext])
flirter.inputs.out_matrix_file = ''.join(['bar', ext])
outs = flirter._list_outputs()
yield assert_equal, outs['out_file'], \
os.path.join(os.getcwd(), flirter.inputs.out_file)
yield assert_equal, outs['out_matrix_file'], \
os.path.join(os.getcwd(), flirter.inputs.out_matrix_file)
teardown_flirt(tmpdir)
def create_B0_workflow(name='b0_unwarping', scanner='philips'):
""" Does B0 field unwarping
Example
-------
>>> nipype_epicorrect = create_unwarping_workflow('unwarp',)
>>> unwarp.inputs.input_node.in_file = 'subj1_run1_bold.nii.gz'
>>> unwarp.inputs.input_node.fieldmap_mag = 'subj1_run1_mag.nii.gz'
>>> unwarp.inputs.input_node.fieldmap_pha = 'subj1_run1_phas.nii.gz'
>>> unwarp.inputs.input_node.wfs = 12.223
>>> unwarp.inputs.input_node.epi_factor = 35.0
>>> unwarp.inputs.input_node.acceleration = 3.0
>>> unwarp.inputs.input_node.te_diff = 0.005
>>> unwarp.inputs.input_node.phase_encoding_direction = 'y'
>>> nipype_epicorrect.run()
Inputs::
input_node.in_file - Volume acquired with EPI sequence
input_node.fieldmap_mag - Magnitude of the fieldmap
input_node.fieldmap_pha - Phase difference of the fieldmap
input_node.wfs - Water-fat-shift in pixels
input_node.epi_factor - EPI factor
input_node.acceleration - Acceleration factor used for EPI parallel imaging (SENSE)
input_node.te_diff - Time difference between TE in seconds.
input_node.phase_encoding_direction - Unwarp direction (default should be "y")
Outputs::
outputnode.epi_corrected
"""
# Nodes:
# ------
# Define input and workflow:
input_node = pe.Node(name='inputspec',
interface=IdentityInterface(fields=[
'in_files', 'fieldmap_mag', 'fieldmap_pha', 'wfs',
'epi_factor', 'acceleration', 'echo_spacing',
'te_diff', 'phase_encoding_direction'
]))
# Normalize phase difference of the fieldmap phase to be [-pi, pi)
norm_pha = pe.Node(interface=Prepare_phasediff, name='normalize_phasediff')
# Mask the magnitude of the fieldmap
mask_mag = pe.Node(fsl.BET(mask=True), name='mask_magnitude')
mask_mag_dil = pe.Node(interface=Dilate_mask, name='mask_dilate')
# Unwrap fieldmap phase using FSL PRELUDE
prelude = pe.Node(fsl.PRELUDE(process3d=True), name='phase_unwrap')
# Convert unwrapped fieldmap phase to radials per second:
radials_per_second = pe.Node(interface=Radials_per_second,
name='radials_ps')
# in case of SIEMENS scanner:
prepare_fieldmap = pe.Node(PrepareFieldmap(), name='prepare_fieldmap')
# Register unwrapped fieldmap (rad/s) to epi, using the magnitude of the fieldmap
registration = pe.MapNode(fsl.FLIRT(bins=256,
cost='corratio',
dof=6,
interp='trilinear',
searchr_x=[-10, 10],
searchr_y=[-10, 10],
searchr_z=[-10, 10]),
iterfield=['reference'],
name='registration')
# transform unwrapped fieldmap (rad/s)
applyxfm = pe.MapNode(fsl.ApplyXFM(interp='trilinear'),
iterfield=['reference', 'in_matrix_file'],
name='apply_xfm')
# compute effective echospacing:
echo_spacing_philips = pe.Node(interface=Compute_echo_spacing_philips,
name='echo_spacing_philips')
echo_spacing_siemens = pe.Node(interface=Compute_echo_spacing_siemens,
name='echo_spacing_siemens')
te_diff_in_ms = pe.Node(interface=TE_diff_ms, name='te_diff_in_ms')
# Unwarp with FSL Fugue
fugue = pe.MapNode(interface=fsl.FUGUE(median_2dfilter=True),
iterfield=['in_file', 'unwarped_file', 'fmap_in_file'],
name='fugue')
# Convert unwrapped fieldmap phase to radials per second:
out_file = pe.MapNode(interface=Make_output_filename,
iterfield=['in_file'],
name='out_file')
# Define output node
outputnode = pe.Node(
IdentityInterface(fields=['out_files', 'field_coefs']),
name='outputspec')
# Workflow:
# ---------
unwarp_workflow = pe.Workflow(name=name)
unwarp_workflow.connect(input_node, 'in_files', out_file, 'in_file')
# registration:
unwarp_workflow.connect(input_node, 'fieldmap_mag', mask_mag, 'in_file')
unwarp_workflow.connect(mask_mag, 'mask_file', mask_mag_dil, 'in_file')
unwarp_workflow.connect(mask_mag, 'out_file', registration, 'in_file')
unwarp_workflow.connect(input_node, 'in_files', registration, 'reference')
if scanner == 'philips':
# prepare fieldmap:
unwarp_workflow.connect(input_node, 'fieldmap_pha', norm_pha,
'in_file')
unwarp_workflow.connect(input_node, 'fieldmap_mag', prelude,
'magnitude_file')
unwarp_workflow.connect(norm_pha, 'out_file', prelude, 'phase_file')
unwarp_workflow.connect(mask_mag_dil, 'out_file', prelude, 'mask_file')
unwarp_workflow.connect(prelude, 'unwrapped_phase_file',
radials_per_second, 'in_file')
unwarp_workflow.connect(input_node, 'te_diff', radials_per_second,
'asym')
# transform fieldmap:
unwarp_workflow.connect(radials_per_second, 'out_file', applyxfm,
'in_file')
unwarp_workflow.connect(registration, 'out_matrix_file', applyxfm,
'in_matrix_file')
unwarp_workflow.connect(input_node, 'in_files', applyxfm, 'reference')
# compute echo spacing:
unwarp_workflow.connect(input_node, 'wfs', echo_spacing_philips, 'wfs')
unwarp_workflow.connect(input_node, 'epi_factor', echo_spacing_philips,
'epi_factor')
unwarp_workflow.connect(input_node, 'acceleration',
echo_spacing_philips, 'acceleration')
unwarp_workflow.connect(echo_spacing_philips, 'echo_spacing', fugue,
'dwell_time')
elif scanner == 'siemens':
unwarp_workflow.connect(input_node, 'te_diff', te_diff_in_ms,
'te_diff')
# prepare fieldmap:
unwarp_workflow.connect(mask_mag, 'out_file', prepare_fieldmap,
'in_magnitude')
unwarp_workflow.connect(input_node, 'fieldmap_pha', prepare_fieldmap,
'in_phase')
unwarp_workflow.connect(te_diff_in_ms, 'te_diff', prepare_fieldmap,
'delta_TE')
# transform fieldmap:
unwarp_workflow.connect(prepare_fieldmap, 'out_fieldmap', applyxfm,
'in_file')
unwarp_workflow.connect(registration, 'out_matrix_file', applyxfm,
'in_matrix_file')
unwarp_workflow.connect(input_node, 'in_files', applyxfm, 'reference')
# compute echo spacing:
unwarp_workflow.connect(input_node, 'acceleration',
echo_spacing_siemens, 'acceleration')
unwarp_workflow.connect(input_node, 'echo_spacing',
echo_spacing_siemens, 'echo_spacing')
unwarp_workflow.connect(echo_spacing_siemens, 'echo_spacing', fugue,
'dwell_time')
unwarp_workflow.connect(input_node, 'in_files', fugue, 'in_file')
unwarp_workflow.connect(out_file, 'out_file', fugue, 'unwarped_file')
unwarp_workflow.connect(applyxfm, 'out_file', fugue, 'fmap_in_file')
unwarp_workflow.connect(input_node, 'te_diff', fugue, 'asym_se_time')
unwarp_workflow.connect(input_node, 'phase_encoding_direction', fugue,
'unwarp_direction')
unwarp_workflow.connect(fugue, 'unwarped_file', outputnode, 'out_files')
unwarp_workflow.connect(applyxfm, 'out_file', outputnode, 'field_coefs')
# # Connect
# unwarp_workflow.connect(input_node, 'in_files', out_file, 'in_file')
# unwarp_workflow.connect(input_node, 'fieldmap_pha', norm_pha, 'in_file')
# unwarp_workflow.connect(input_node, 'fieldmap_mag', mask_mag, 'in_file')
# unwarp_workflow.connect(mask_mag, 'mask_file', mask_mag_dil, 'in_file')
# unwarp_workflow.connect(input_node, 'fieldmap_mag', prelude, 'magnitude_file')
# unwarp_workflow.connect(norm_pha, 'out_file', prelude, 'phase_file')
# unwarp_workflow.connect(mask_mag_dil, 'out_file', prelude, 'mask_file')
# unwarp_workflow.connect(prelude, 'unwrapped_phase_file', radials_per_second, 'in_file')
# unwarp_workflow.connect(input_node, 'te_diff', radials_per_second, 'asym')
# unwarp_workflow.connect(mask_mag, 'out_file', registration, 'in_file')
# unwarp_workflow.connect(input_node, 'in_files', registration, 'reference')
# unwarp_workflow.connect(radials_per_second, 'out_file', applyxfm, 'in_file')
# unwarp_workflow.connect(registration, 'out_matrix_file', applyxfm, 'in_matrix_file')
# unwarp_workflow.connect(input_node, 'in_files', applyxfm, 'reference')
# if compute_echo_spacing:
# unwarp_workflow.connect(input_node, 'wfs', echo_spacing, 'wfs')
# unwarp_workflow.connect(input_node, 'epi_factor', echo_spacing, 'epi_factor')
# unwarp_workflow.connect(input_node, 'acceleration', echo_spacing, 'acceleration')
# unwarp_workflow.connect(echo_spacing, 'echo_spacing', fugue, 'dwell_time')
# else:
# unwarp_workflow.connect(input_node, 'echo_spacing', fugue, 'dwell_time')
# unwarp_workflow.connect(input_node, 'in_files', fugue, 'in_file')
# unwarp_workflow.connect(out_file, 'out_file', fugue, 'unwarped_file')
# unwarp_workflow.connect(applyxfm, 'out_file', fugue, 'fmap_in_file')
# unwarp_workflow.connect(input_node, 'te_diff', fugue, 'asym_se_time')
# unwarp_workflow.connect(input_node, 'phase_encoding_direction', fugue, 'unwarp_direction')
# unwarp_workflow.connect(fugue, 'unwarped_file', outputnode, 'out_files')
# unwarp_workflow.connect(applyxfm, 'out_file', outputnode, 'field_coefs')
return unwarp_workflow
def create_register_structural_to_diff(name='structural_to_diff'):
"""Co-register images using an affine transformation.
Example
-------
>>> from tn_image_processing.workflows import registration
>>> registration = registration.create_affine_registration()
>>> registration.inputs.inputnode.structural = ['sub
>>> registration.inputs.inputnode.dwi = ['DTI.nii.gz']
Inputs::
[Mandatory]
inputnode.structural_list: list of hi-resolution structural
images
inputnode.dwi_list: list of 4dim diffusion volumes
Outputs::
outputnode.struct_to_b0: structural image registered to b0
space
outputnode.struct_to_b0_mat: affine matrix used to register
structural image to b0 space
"""
# Define the inputnode
inputnode = pe.Node(interface=util.IdentityInterface(
fields=["structural_list", "dwi_list"]),
name="inputnode")
# Get first volume from 4d diffusion image (we assume this is b0)
extract_b0 = pe.MapNode(interface=fslutil.ExtractROI(
roi_file='DTI_first.nii.gz', t_min=0, t_size=1),
iterfield=['in_file'],
name='extract_b0')
# Align structural image to b0
flirt = pe.MapNode(interface=fslpre.FLIRT(dof=6,
cost='mutualinfo',
usesqform=True,
out_file="T1_to_b0.nii.gz",
out_matrix_file="T1_to_b0.mat"),
iterfield=['in_file', 'ref_file'],
name="flirt")
# Define this workflow
structural_to_diff = pe.Workflow(name=name)
# Connect components of this workflow
structural_to_diff.connect([
(inputnode, extract_b0, [("dwi", "in_file")]),
(inputnode, flirt, [("structural", "in_file")]),
(extract_b0, flirt, [("roi_file", "ref_file")]),
])
# Define the outputnode
outputnode = pe.Node(interface=util.IdentityInterface(
fields=['struct_to_b0', 'struct_to_b0_mat']))
# Connect the output
structural_to_diff.connect([
(flirt, outputnode, [('out_file', 'struct_to_b0'),
('out_matrix_file', 'struct_to_b0_mat')]),
])
return structural_to_diff
def create_registration(name='registration'):
"""Create a workflow designed to register structural image to dwi.
Example
-------
>>> import tn_image_processing.workflows as pipes
>>> registration = pipes.create_registration()
>>> registration.inputnode.dwi_image = ['path/to/dwi/image']
>>> registration.inputnode.struct_image = ['path/to/struct/image']
>>> registration.run()
Inputs::
[mandatory]
inputnode.dwi_image
inputnode.structural_image
inputnode.working_dir
Outputs::
outputnode.dwi_first
outputnode.dwi_resampled
outputnode.struct_to_dwi_image
outputnode.struct_to_dwi_mat
"""
import nipype.pipeline.engine as pe
import nipype.interfaces.utility as util
import nipype.interfaces.fsl.utils as fslutil
import nipype.interfaces.fsl.preprocess as fslpre
# Setup input node
inputnode = pe.Node(interface=util.IdentityInterface(
fields=['dwi_image', 'structural_image']),
name='inputnode')
# Get first volume from 4d diffusion image (we assume this is b0)
extract_b0 = pe.Node(interface=fslutil.ExtractROI(t_min=0, t_size=1),
name='extract_b0')
# TODO: debug runtime error caused when specifying name of output roi file
# extract_b0.inputs.roi_file = 'DTI_first.nii.gz'
#
# Resample b0 to voxel size of 1mm
import nipype.interfaces.freesurfer.preprocess as fspre
resample_b0 = pe.Node(interface=fspre.Resample(), name='resample_b0')
resample_b0.inputs.voxel_size = tuple((1., 1., 1.))
# resample_b0.inputs.resampled_file = 'Diffusion_b0_resampled.nii.gz'
# Align structural image to b0
flirt = pe.Node(interface=fslpre.FLIRT(dof=6,
cost='mutualinfo',
uses_qform=True),
name="flirt")
# flirt.inputs.out_file = 'T1-TO-b0.nii.gz'
# flirt.inputs.out_matrix_file = 'T1-TO-b0.mat'
# Setup output node
outputnode = pe.Node(interface=util.IdentityInterface(fields=[
'dwi_first', 'dwi_resampled', 'struct_to_dwi_image',
'struct_to_dwi_mat'
]),
name='outputnode')
# Create workflow
this_workflow = pe.Workflow(name=name)
# Connect workflow
this_workflow.connect(inputnode, "dwi_image", extract_b0, "in_file")
this_workflow.connect(inputnode, "structural_image", flirt, "in_file")
this_workflow.connect(extract_b0, "roi_file", resample_b0, "in_file")
this_workflow.connect(resample_b0, "resampled_file", flirt, "reference")
this_workflow.connect(extract_b0, "roi_file", outputnode, "dwi_first")
this_workflow.connect(resample_b0, "resampled_file", outputnode,
"dwi_resampled")
this_workflow.connect(flirt, "out_file", outputnode, "struct_to_dwi_image")
this_workflow.connect(flirt, "out_matrix_file", outputnode,
"struct_to_dwi_mat")
# Return workflow
return this_workflow
def NORMPIPE():
#--- 1) Import modules
from nipype.interfaces.ants import Registration, ApplyTransforms
import nipype.pipeline.engine as pe
import matplotlib
import os
from glob import glob
from nilearn import plotting
from nilearn import image
from nipype.interfaces.utility import Function
import nipype.interfaces.fsl.preprocess as fsl
import nipype.interfaces.fsl as fslbase
import nipype.interfaces.fsl.utils as fslu
from nipype.interfaces.fsl import Info
import nipype.interfaces.utility as util
INITDIR = os.getcwd()
#--- 2) Define input node
template = Info.standard_image('MNI152_T1_2mm_brain.nii.gz')
inputnode = pe.Node(interface=util.IdentityInterface(fields=['standard']),
name='inputspec')
inputnode.inputs.standard = template
#--- 3) Get inputs and define node for registering EPI to structural.
alsonorm = bool(input('Also normalise?\n'))
epireg = pe.Node(interface=fslbase.EpiReg(), name='EPIREG')
t1_brain = raw_input(
'Please drag in the brain-extracted structural volume\n')
t1_head = raw_input(
'Please drag in the non-brain extracted structural volume\n')
epi = raw_input('Please drag in the mean functional volume.\n')
epireg.inputs.t1_brain = t1_brain.strip('\'"')
epireg.inputs.t1_head = t1_head.strip('\'"')
epireg.inputs.epi = epi.strip('\'"')
NIFTIDIR = os.path.split(epireg.inputs.t1_brain)[0]
#--- 4) Register the T1 to the MNI
registerT12S = pe.Node(interface=fsl.FLIRT(), name='REGISTEREDT12MNI')
registerT12S.inputs.dof = int(12)
registerT12S.inputs.reference = template
registerT12S.inputs.in_file = epireg.inputs.t1_brain
#--- 5) Concatenate the two transformation matrices from 3 and 4.
concatxfm = pe.Node(interface=fslbase.ConvertXFM(), name='CONCATMATRICES')
concatxfm.inputs.concat_xfm = bool(1)
#--- 6) Register the EPI to the standard, using the combined transformation matrix
registerF2S = pe.Node(interface=fsl.ApplyXFM(), name='REGISTEREDF2MNI')
registerF2S.inputs.reference = template
registerF2S.inputs.in_file = epireg.inputs.epi
#--- 7) Use ANTS to normalise the structural to the MNI
antsregfast = pe.Node(Registration(
args='--float',
collapse_output_transforms=True,
fixed_image=template,
initial_moving_transform_com=True,
output_inverse_warped_image=True,
output_warped_image=True,
sigma_units=['vox'] * 3,
transforms=['Rigid', 'Affine', 'SyN'],
terminal_output='file',
winsorize_lower_quantile=0.005,
winsorize_upper_quantile=0.995,
convergence_threshold=[1e-08, 1e-08, -0.01],
convergence_window_size=[20, 20, 5],
metric=['Mattes', 'Mattes', ['Mattes', 'CC']],
metric_weight=[1.0, 1.0, [0.5, 0.5]],
number_of_iterations=[[10000, 11110, 11110], [10000, 11110, 11110],
[100, 30, 20]],
radius_or_number_of_bins=[32, 32, [32, 4]],
sampling_percentage=[0.3, 0.3, [None, None]],
sampling_strategy=['Regular', 'Regular', [None, None]],
shrink_factors=[[3, 2, 1], [3, 2, 1], [4, 2, 1]],
smoothing_sigmas=[[4.0, 2.0, 1.0], [4.0, 2.0, 1.0], [1.0, 0.5, 0.0]],
transform_parameters=[(0.1, ), (0.1, ), (0.2, 3.0, 0.0)],
use_estimate_learning_rate_once=[True] * 3,
use_histogram_matching=[False, False, True],
write_composite_transform=True),
name='NORMSTRUCT')
#--- 8) Apply the same warping to the EPI
apply2mean = pe.Node(ApplyTransforms(args='--float',
input_image_type=3,
interpolation='Linear',
invert_transform_flags=[False],
num_threads=1,
reference_image=template,
terminal_output='file'),
name='NORMFUNC')
#--- 9) Also need an outputnode, since otherwise some outputs may be binned.
outputnode = pe.Node(interface=util.IdentityInterface(fields=[
'warped', 'structmat', 'funcmat', 'epimat', 'funcreg', 'structreg'
]),
name='outputnode')
#--- 10) Custom plotting functions.
def bplot(in_file, MNI):
from nilearn import image
from nilearn import plotting
import matplotlib
niftifiledim = len(image.load_img(in_file).shape)
display = plotting.plot_anat(template)
display.add_edges(in_file)
matplotlib.pyplot.show()
return niftifiledim
def bplotN(in_file, MNI):
from nilearn import image
from nilearn import plotting
import matplotlib
niftifiledim = len(image.load_img(in_file).shape)
display = plotting.plot_anat(MNI)
display.add_edges(in_file)
matplotlib.pyplot.show()
return niftifiledim
showregL = pe.Node(Function(input_names=['in_file', 'MNI'],
output_names=['niftifiledim'],
function=bplot),
name='SHOWREG')
showregNL = pe.Node(Function(input_names=['in_file', 'MNI'],
output_names=['niftifiledim'],
function=bplotN),
name='SHOWREG')
#--- 11) Setup workflow
workflow = pe.Workflow(name='NORMPIPE')
workflow.base_dir = NIFTIDIR
#--- 12) Connect nodes, depending on whether we want to do normalisation too.
if alsonorm == bool(0):
workflow.connect(epireg, 'epi2str_mat', outputnode, 'epimat')
workflow.connect(epireg, 'epi2str_mat', concatxfm, 'in_file')
workflow.connect(registerT12S, 'out_matrix_file', concatxfm,
'in_file2')
workflow.connect(concatxfm, 'out_file', registerF2S, 'in_matrix_file')
workflow.connect(registerT12S, 'out_matrix_file', outputnode,
'structmat')
workflow.connect(registerF2S, 'out_matrix_file', outputnode, 'funcmat')
workflow.connect(registerF2S, 'out_file', outputnode, 'funcreg')
workflow.connect(registerT12S, 'out_file', outputnode, 'structreg')
workflow.connect(registerT12S, 'out_file', showregL, 'in_file')
workflow.connect(inputnode, 'standard', showregL, 'MNI')
workflow.write_graph(graph2use='exec')
workflow.run()
elif alsonorm == bool(1):
workflow.connect(epireg, 'epi2str_mat', outputnode, 'epimat')
workflow.connect(epireg, 'epi2str_mat', concatxfm, 'in_file')
workflow.connect(registerT12S, 'out_matrix_file', concatxfm,
'in_file2')
workflow.connect(concatxfm, 'out_file', registerF2S, 'in_matrix_file')
workflow.connect(registerT12S, 'out_matrix_file', outputnode,
'structmat')
workflow.connect(registerF2S, 'out_matrix_file', outputnode, 'funcmat')
workflow.connect(registerF2S, 'out_file', outputnode, 'funcreg')
workflow.connect(registerT12S, 'out_file', outputnode, 'structreg')
workflow.connect(registerF2S, 'out_file', apply2mean, 'input_image')
workflow.connect(registerT12S, 'out_file', antsregfast, 'moving_image')
workflow.connect(antsregfast, 'warped_image', outputnode, 'warped')
workflow.connect([(antsregfast, apply2mean, [('composite_transform',
'transforms')])])
workflow.connect(antsregfast, 'warped_image', showregNL, 'in_file')
workflow.connect(inputnode, 'standard', showregNL, 'MNI')
workflow.write_graph(graph2use='exec')
workflow.run()
print "Node completed. Returning to intital directory\n"
os.chdir(INITDIR)