def test_warp():
input_map = dict(
args=dict(argstr='%s', ),
deoblique=dict(argstr='-deoblique', ),
environ=dict(usedefault=True, ),
gridset=dict(argstr='-gridset %s', ),
ignore_exception=dict(usedefault=True, ),
in_file=dict(
argstr='%s',
mandatory=True,
),
interp=dict(argstr='-%s', ),
matparent=dict(argstr='-matparent %s', ),
mni2tta=dict(argstr='-mni2tta', ),
out_file=dict(argstr='-prefix %s', ),
outputtype=dict(),
suffix=dict(),
tta2mni=dict(argstr='-tta2mni', ),
zpad=dict(argstr='-zpad %d', ),
)
instance = afni.Warp()
for key, metadata in input_map.items():
for metakey, value in metadata.items():
yield assert_equal, getattr(instance.inputs.traits()[key],
metakey), value
def afni_deoblique(in_file=traits.Undefined,
out_file=traits.Undefined,
out_type='NIFTI_GZ'):
""" Return a nipype interface for AFNI '3dWarp -deoblique'.
Parameters
----------
in_file: str
Path to the input file
out_file: str
Path to the output file.
out_type: str
('NIFTI_GZ' or 'AFNI' or 'NIFTI')
AFNI output filetype
Returns
-------
deob: nipype.interfaces.afni.Warp
"""
deob = afni.Warp()
deob.inputs.in_file = in_file
deob.inputs.deoblique = True
deob.inputs.out_file = out_file
deob.inputs.outputtype = out_type
return deob
def warp(self,
fileobj1=None,
fileobj2=None,
out_file=None,
transformation=None,
args=None,
saved_mat_file=None,
suffix=None):
#setting files
if fileobj2 is not None:
fileobj2, _ = self.FuncHandler(fileobj2, out_file, suffix)
fileobj1, out_file = self.FuncHandler(fileobj1, out_file, suffix)
ThreeDWarp = afni.Warp(in_file=fileobj1, out_file=out_file)
#https://nipype.readthedocs.io/en/latest/interfaces/generated/interfaces.afni/preprocess.html#warp
if args is not None:
ThreeDWarp.inputs.args = args
if transformation == 'card2oblique':
ThreeDWarp.inputs.oblique_parent = fileobj2
elif transformation == 'deoblique':
ThreeDWarp.inputs.deoblique = True
elif transformation == 'mni2tta':
ThreeDWarp.inputs.mni2tta = True
elif transformation == 'tta2mni':
ThreeDWarp.inputs.tta2mni = True
elif transformation == 'matrix':
ThreeDWarp.inputs.matparent = fileobj2
elif transformation == None:
print("Warning: no transformation input given")
else:
print(
"Warning: none of the transformation options given match the possible arguments. Matching arguments are card2oblique,"
+ " deoblique, mni2tta, tta2mni, and matrix")
#ThreeDWarp.inputs.num_threads = cpu_count()
if saved_mat_file: #this is for if the pipline requires saving the 1D matrix tranformation information
print('saving matrix')
ThreeDWarp.inputs.verbose = True
ThreeDWarp.inputs.save_warp = True
ThreeDWarp.run()
#remove temp files
if type(fileobj1) == models.BIDSImageFile:
fileobj1 = os.path.join(self._output_dir, fileobj1.filename)
if "_desc-temp" in fileobj1:
os.remove(fileobj1)
def _warp(to_warp_file,
reference_file,
write_dir=None,
caching=False,
terminal_output='allatonce',
verbose=True,
environ=None):
if write_dir is None:
write_dir = os.path.dirname(to_warp_file)
if environ is None:
environ = {'AFNI_DECONFLICT': 'OVERWRITE'}
if caching:
memory = Memory(write_dir)
warp = memory.cache(afni.Warp)
else:
warp = afni.Warp().run
out_warp = warp(in_file=to_warp_file,
oblique_parent=reference_file,
interp='quintic',
gridset=reference_file,
out_file=fname_presuffix(to_warp_file,
suffix='_warped',
newpath=write_dir),
verbose=True,
save_warp=True,
environ=environ)
# 3dWarp doesn't put the obliquity in the header, so do it manually
warped_oblique_file = fix_obliquity(out_warp.outputs.out_file,
reference_file,
verbose=verbose,
caching=caching,
caching_dir=write_dir,
environ=environ)
return warped_oblique_file, out_warp.outputs.warp_file
def run(options):
# fix!
out_dir = os.path.join('option', '1')
err_dir = os.path.join('option', '2')
data_dir = os.path.join('option', '3')
work_dir = os.path.join('something', 'else')
# Workflow
merica_wf = pe.Workflow('merica_wf')
merica_wf.base_dir = work_dir
inputspec = pe.Node(util.IdentityInterface(fields=options.keys()),
name='inputspec')
# Node: subject_iterable
run_iterable = pe.Node(util.IdentityInterface(fields=['run'],
mandatory_inputs=True),
name='run_iterable')
run_iterable.iterables = ('run', runs)
info = dict(mri_files=[['run']])
# Create a datasource node to get the mri files
datasource = pe.Node(nio.DataGrabber(infields=['run'],
outfields=info.keys()),
name='datasource')
datasource.inputs.template = '*'
datasource.inputs.base_directory = abspath(data_dir)
datasource.inputs.field_template = dict(mri_files='%s/func/*.nii.gz')
datasource.inputs.template_args = info
datasource.inputs.sort_filelist = True
datasource.inputs.ignore_exception = False
datasource.inputs.raise_on_empty = True
meica_wf.connect(run_iterable, 'run', datasource, 'run')
# Create a Function node to rename output files
getsubs = pe.Node(util.Function(input_names=['run', 'mri_files'],
output_names=['subs'],
function=get_subs),
name='getsubs')
getsubs.inputs.ignore_exception = False
meica_wf.connect(run_iterable, 'run', getsubs, 'run')
meica_wf.connect(datasource, 'mri_files', getsubs, 'mri_files')
get_cm = pe.Node(util.Function(input_names=['fname'],
output_names=['x', 'y', 'z'],
function=find_CM),
name='get_cm')
get_obliquity = pe.Node(util.Function(input_names=['fname'],
output_names=['angmerit'],
function=check_obliquity),
name='get_cm')
if get_obliquity.is_oblique == True:
deoblique = pe.Node(afni.Warp(deoblique=True)
name='deoblique')
merica_wf.connect(upstream, 't1', deoblique, 'in_file')
warpspeed = pe.Node(afni.Warp(args='-card2oblique -newgrid 1.0'))
if skull-stripped == False:
unifeyes = pe.Node(afni.Unifize()
name='unifeyes')
if get_obliquity.is_oblique == True:
merica_wf.connect(deoblique, 'out_file', unifeyes, 'in_file')
else:
merica_wf.connect(upstream, 't1', unifeyes, 'in_file')
skullstrip = pe.Node(afni.SkullStrip(args='-shrink_fac_bot_lim 0.3 -orig_vol')
name='skullstrip')
autobots = pe.Node(afni.Autobox()
name='autobots')
merica_wf.connect(skullstrip, 'out_file', autobots, 'in_file')
# Moving on to functional preprocessing, be back later!
if despike == True:
despike = pe.Node(afni.Despike()
name='despike')
if skull-stripped == False:
merica_wf.connect(autobots, 'out_file', despike, 'in_file')
else:
merica_wf.connect(upstream, 't1', despike, 'in_file')
meica_wf.connect(run_iterable, 'run', get_cm, 'fname')
meica_wf.connect(run_iterable, 'run', get_cm, 'fname')
def coregister_fmri_session(session_data,
t_r,
write_dir,
brain_volume,
use_rats_tool=True,
slice_timing=True,
prior_rigid_body_registration=False,
caching=False,
voxel_size_x=.1,
voxel_size_y=.1,
verbose=True,
**environ_kwargs):
"""
Coregistration of the subject's functional and anatomical images.
The functional volume is aligned to the anatomical, first with a rigid body
registration and then on a per-slice basis (only a fine correction, this is
mostly for correction of EPI distortion).
Parameters
----------
session_data : sammba.registration.SessionData
Single animal data, giving paths to its functional and anatomical
image, as well as it identifier.
t_r : float
Repetition time for the EPI, in seconds.
write_dir : str
Directory to save the output and temporary images.
brain_volume : int
Volume of the brain in mm3 used for brain extraction.
Typically 400 for mouse and 1800 for rat.
use_rats_tool : bool, optional
If True, brain mask is computed using RATS Mathematical Morphology.
Otherwise, a histogram-based brain segmentation is used.
prior_rigid_body_registration : bool, optional
If True, a rigid-body registration of the anat to the func is performed
prior to the warp. Useful if the images headers have missing/wrong
information.
voxel_size_x : float, optional
Resampling resolution for the x-axis, in mm.
voxel_size_y : float, optional
Resampling resolution for the y-axis, in mm.
caching : bool, optional
Wether or not to use caching.
verbose : bool, optional
If True, all steps are verbose. Note that caching implies some
verbosity in any case.
environ_kwargs : extra arguments keywords
Extra arguments keywords, passed to interfaces environ variable.
Returns
-------
the same sequence with each animal_data updated: the following attributes
are added
- `output_dir_` : str
Path to the output directory.
- `coreg_func_` : str
Path to paths to the coregistered functional image.
- `coreg_anat_` : str
Path to paths to the coregistered functional image.
- `coreg_transform_` : str
Path to the transform from anat to func.
Notes
-----
If `use_rats_tool` is turned on, RATS tool is used for brain extraction
and has to be cited. For more information, see
`RATS <http://www.iibi.uiowa.edu/content/rats-overview/>`_
"""
func_filename = session_data.func
anat_filename = session_data.anat
environ = {'AFNI_DECONFLICT': 'OVERWRITE'}
for (key, value) in environ_kwargs.items():
environ[key] = value
if verbose:
terminal_output = 'allatonce'
else:
terminal_output = 'none'
if use_rats_tool:
if segmentation.interfaces.Info().version() is None:
raise ValueError('Can not locate RATS')
else:
ComputeMask = segmentation.MathMorphoMask
else:
ComputeMask = segmentation.HistogramMask
if ants.base.Info().version is None:
raise ValueError('Can not locate ANTS')
if caching:
memory = Memory(write_dir)
tshift = memory.cache(afni.TShift)
clip_level = memory.cache(afni.ClipLevel)
volreg = memory.cache(afni.Volreg)
allineate = memory.cache(afni.Allineate)
tstat = memory.cache(afni.TStat)
compute_mask = memory.cache(ComputeMask)
calc = memory.cache(afni.Calc)
allineate = memory.cache(afni.Allineate)
allineate2 = memory.cache(afni.Allineate)
unifize = memory.cache(afni.Unifize)
bias_correct = memory.cache(ants.N4BiasFieldCorrection)
catmatvec = memory.cache(afni.CatMatvec)
warp = memory.cache(afni.Warp)
resample = memory.cache(afni.Resample)
slicer = memory.cache(afni.ZCutUp)
warp_apply = memory.cache(afni.NwarpApply)
qwarp = memory.cache(afni.Qwarp)
merge = memory.cache(afni.Zcat)
copy_geom = memory.cache(fsl.CopyGeom)
overwrite = False
for step in [
tshift, volreg, allineate, allineate2, tstat, compute_mask,
calc, unifize, resample, slicer, warp_apply, qwarp, merge
]:
step.interface().set_default_terminal_output(terminal_output)
else:
tshift = afni.TShift(terminal_output=terminal_output).run
clip_level = afni.ClipLevel().run
volreg = afni.Volreg(terminal_output=terminal_output).run
allineate = afni.Allineate(terminal_output=terminal_output).run
allineate2 = afni.Allineate(terminal_output=terminal_output
).run # TODO: remove after fixed bug
tstat = afni.TStat(terminal_output=terminal_output).run
compute_mask = ComputeMask().run
calc = afni.Calc(terminal_output=terminal_output).run
unifize = afni.Unifize(terminal_output=terminal_output).run
bias_correct = ants.N4BiasFieldCorrection(
terminal_output=terminal_output).run
catmatvec = afni.CatMatvec().run
warp = afni.Warp().run
resample = afni.Resample(terminal_output=terminal_output).run
slicer = afni.ZCutUp(terminal_output=terminal_output).run
warp_apply = afni.NwarpApply(terminal_output=terminal_output).run
qwarp = afni.Qwarp(terminal_output=terminal_output).run
merge = afni.Zcat(terminal_output=terminal_output).run
copy_geom = fsl.CopyGeom(terminal_output=terminal_output).run
overwrite = True
session_data._check_inputs()
output_dir = os.path.join(os.path.abspath(write_dir),
session_data.animal_id)
session_data._set_output_dir_(output_dir)
current_dir = os.getcwd()
os.chdir(output_dir)
output_files = []
#######################################
# Correct functional for slice timing #
#######################################
if slice_timing:
out_tshift = tshift(in_file=func_filename,
outputtype='NIFTI_GZ',
tpattern='altplus',
tr=str(t_r),
environ=environ)
func_filename = out_tshift.outputs.out_file
output_files.append(func_filename)
################################################
# Register functional volumes to the first one #
################################################
# XXX why do you need a thresholded image ?
out_clip_level = clip_level(in_file=func_filename)
out_calc_threshold = calc(in_file_a=func_filename,
expr='ispositive(a-{0}) * a'.format(
out_clip_level.outputs.clip_val),
outputtype='NIFTI_GZ')
thresholded_filename = out_calc_threshold.outputs.out_file
out_volreg = volreg( # XXX dfile not saved
in_file=thresholded_filename,
outputtype='NIFTI_GZ',
environ=environ,
oned_file=fname_presuffix(thresholded_filename,
suffix='Vr.1Dfile.1D',
use_ext=False),
oned_matrix_save=fname_presuffix(thresholded_filename,
suffix='Vr.aff12.1D',
use_ext=False))
# Apply the registration to the whole head
out_allineate = allineate(in_file=func_filename,
master=func_filename,
in_matrix=out_volreg.outputs.oned_matrix_save,
out_file=fname_presuffix(func_filename,
suffix='Av'),
environ=environ)
# 3dAllineate removes the obliquity. This is not a good way to readd it as
# removes motion correction info in the header if it were an AFNI file...as
# it happens it's NIfTI which does not store that so irrelevant!
out_copy_geom = copy_geom(dest_file=out_allineate.outputs.out_file,
in_file=out_volreg.outputs.out_file)
allineated_filename = out_copy_geom.outputs.out_file
# Create a (hopefully) nice mean image for use in the registration
out_tstat = tstat(in_file=allineated_filename,
args='-mean',
outputtype='NIFTI_GZ',
environ=environ)
# Update outputs
output_files.extend([
thresholded_filename, out_volreg.outputs.oned_matrix_save,
out_volreg.outputs.out_file, out_volreg.outputs.md1d_file,
allineated_filename, out_tstat.outputs.out_file
])
###########################################
# Corret anat and func for intensity bias #
###########################################
# Correct the functional average for intensities bias
out_bias_correct = bias_correct(input_image=out_tstat.outputs.out_file)
unbiased_func_filename = out_bias_correct.outputs.output_image
# Bias correct the antomical image
out_unifize = unifize(in_file=anat_filename,
outputtype='NIFTI_GZ',
environ=environ)
unbiased_anat_filename = out_unifize.outputs.out_file
# Update outputs
output_files.extend([unbiased_func_filename, unbiased_anat_filename])
#############################################
# Rigid-body registration anat -> mean func #
#############################################
if prior_rigid_body_registration:
# Mask the mean functional volume outside the brain.
out_clip_level = clip_level(in_file=unbiased_func_filename)
out_compute_mask_func = compute_mask(
in_file=unbiased_func_filename,
volume_threshold=brain_volume,
intensity_threshold=int(out_clip_level.outputs.clip_val))
out_cacl_func = calc(in_file_a=unbiased_func_filename,
in_file_b=out_compute_mask_func.outputs.out_file,
expr='a*b',
outputtype='NIFTI_GZ',
environ=environ)
# Mask the anatomical volume outside the brain.
out_clip_level = clip_level(in_file=unbiased_anat_filename)
out_compute_mask_anat = compute_mask(
in_file=unbiased_anat_filename,
volume_threshold=brain_volume,
intensity_threshold=int(out_clip_level.outputs.clip_val))
out_cacl_anat = calc(in_file_a=unbiased_anat_filename,
in_file_b=out_compute_mask_anat.outputs.out_file,
expr='a*b',
outputtype='NIFTI_GZ',
environ=environ)
# Compute the transformation from functional to anatomical brain
# XXX: why in this sense
out_allineate = allineate2(
in_file=out_cacl_func.outputs.out_file,
reference=out_cacl_anat.outputs.out_file,
out_matrix=fname_presuffix(out_cacl_func.outputs.out_file,
suffix='_shr.aff12.1D',
use_ext=False),
center_of_mass='',
warp_type='shift_rotate',
out_file=fname_presuffix(out_cacl_func.outputs.out_file,
suffix='_shr'),
environ=environ)
rigid_transform_file = out_allineate.outputs.out_matrix
output_files.extend([
out_compute_mask_func.outputs.out_file,
out_cacl_func.outputs.out_file,
out_compute_mask_anat.outputs.out_file,
out_cacl_anat.outputs.out_file, rigid_transform_file,
out_allineate.outputs.out_file
])
# apply the inverse transform to register the anatomical to the func
catmatvec_out_file = fname_presuffix(rigid_transform_file,
suffix='INV')
out_catmatvec = catmatvec(in_file=[(rigid_transform_file, 'I')],
oneline=True,
out_file=catmatvec_out_file)
output_files.append(out_catmatvec.outputs.out_file)
out_allineate = allineate(in_file=unbiased_anat_filename,
master=unbiased_func_filename,
in_matrix=out_catmatvec.outputs.out_file,
out_file=fname_presuffix(
unbiased_anat_filename,
suffix='_shr_in_func_space'),
environ=environ)
allineated_anat_filename = out_allineate.outputs.out_file
output_files.append(allineated_anat_filename)
else:
allineated_anat_filename = unbiased_anat_filename
############################################
# Nonlinear registration anat -> mean func #
############################################
# 3dWarp doesn't put the obliquity in the header, so do it manually
# This step generates one file per slice and per time point, so we are
# making sure they are removed at the end
out_warp = warp(in_file=allineated_anat_filename,
oblique_parent=unbiased_func_filename,
interp='quintic',
gridset=unbiased_func_filename,
outputtype='NIFTI_GZ',
verbose=True,
environ=environ)
registered_anat_filename = out_warp.outputs.out_file
registered_anat_oblique_filename = fix_obliquity(registered_anat_filename,
unbiased_func_filename,
verbose=verbose)
# Concatenate all the anat to func tranforms
mat_filename = fname_presuffix(registered_anat_filename,
suffix='_warp.mat',
use_ext=False)
# XXX Handle this correctly according to caching
if not os.path.isfile(mat_filename):
np.savetxt(mat_filename, [out_warp.runtime.stdout], fmt='%s')
output_files.append(mat_filename)
transform_filename = fname_presuffix(registered_anat_filename,
suffix='_anat_to_func.aff12.1D',
use_ext=False)
if prior_rigid_body_registration:
_ = catmatvec(in_file=[(mat_filename, 'ONELINE'),
(rigid_transform_file, 'ONELINE')],
oneline=True,
out_file=transform_filename)
else:
_ = catmatvec(in_file=[(mat_filename, 'ONELINE')],
oneline=True,
out_file=transform_filename)
##################################################
# Per-slice non-linear registration func -> anat #
##################################################
# Slice anatomical image
anat_img = nibabel.load(registered_anat_oblique_filename)
anat_n_slices = anat_img.header.get_data_shape()[2]
sliced_registered_anat_filenames = []
for slice_n in range(anat_n_slices):
out_slicer = slicer(in_file=registered_anat_oblique_filename,
keep='{0} {0}'.format(slice_n),
out_file=fname_presuffix(
registered_anat_oblique_filename,
suffix='Sl%d' % slice_n),
environ=environ)
oblique_slice = fix_obliquity(out_slicer.outputs.out_file,
registered_anat_oblique_filename,
verbose=verbose)
sliced_registered_anat_filenames.append(oblique_slice)
# Slice mean functional
sliced_bias_corrected_filenames = []
img = nibabel.load(func_filename)
n_slices = img.header.get_data_shape()[2]
for slice_n in range(n_slices):
out_slicer = slicer(in_file=unbiased_func_filename,
keep='{0} {0}'.format(slice_n),
out_file=fname_presuffix(unbiased_func_filename,
suffix='Sl%d' % slice_n),
environ=environ)
oblique_slice = fix_obliquity(out_slicer.outputs.out_file,
unbiased_func_filename,
verbose=verbose)
sliced_bias_corrected_filenames.append(oblique_slice)
# Below line is to deal with slices where there is no signal (for example
# rostral end of some anatomicals)
# The inverse warp frequently fails, Resampling can help it work better
# XXX why specifically .1 in voxel_size ?
voxel_size_z = anat_img.header.get_zooms()[2]
resampled_registered_anat_filenames = []
for sliced_registered_anat_filename in sliced_registered_anat_filenames:
out_resample = resample(in_file=sliced_registered_anat_filename,
voxel_size=(voxel_size_x, voxel_size_y,
voxel_size_z),
outputtype='NIFTI_GZ',
environ=environ)
resampled_registered_anat_filenames.append(
out_resample.outputs.out_file)
resampled_bias_corrected_filenames = []
for sliced_bias_corrected_filename in sliced_bias_corrected_filenames:
out_resample = resample(in_file=sliced_bias_corrected_filename,
voxel_size=(voxel_size_x, voxel_size_y,
voxel_size_z),
outputtype='NIFTI_GZ',
environ=environ)
resampled_bias_corrected_filenames.append(
out_resample.outputs.out_file)
# single slice non-linear functional to anatomical registration
warped_slices = []
warp_filenames = []
for (resampled_bias_corrected_filename,
resampled_registered_anat_filename) in zip(
resampled_bias_corrected_filenames,
resampled_registered_anat_filenames):
warped_slice = fname_presuffix(resampled_bias_corrected_filename,
suffix='_qw')
out_qwarp = qwarp(
in_file=resampled_bias_corrected_filename,
base_file=resampled_registered_anat_filename,
iwarp=True, # XXX: is this necessary
noneg=True,
blur=[0],
nmi=True,
noXdis=True,
allineate=True,
allineate_opts='-parfix 1 0 -parfix 2 0 -parfix 3 0 '
'-parfix 4 0 -parfix 5 0 -parfix 6 0 '
'-parfix 7 0 -parfix 9 0 '
'-parfix 10 0 -parfix 12 0',
out_file=warped_slice,
environ=environ)
warped_slices.append(out_qwarp.outputs.warped_source)
warp_filenames.append(out_qwarp.outputs.source_warp)
output_files.append(out_qwarp.outputs.base_warp)
# There are files geenrated by the allineate option
output_files.extend([
fname_presuffix(out_qwarp.outputs.warped_source, suffix='_Allin'),
fname_presuffix(out_qwarp.outputs.warped_source,
suffix='_Allin.nii',
use_ext=False),
fname_presuffix(out_qwarp.outputs.warped_source,
suffix='_Allin.aff12.1D',
use_ext=False)
])
# Resample the mean volume back to the initial resolution,
voxel_size = nibabel.load(unbiased_func_filename).header.get_zooms()
resampled_warped_slices = []
for warped_slice in warped_slices:
out_resample = resample(in_file=warped_slice,
voxel_size=voxel_size,
outputtype='NIFTI_GZ',
environ=environ)
resampled_warped_slices.append(out_resample.outputs.out_file)
# fix the obliquity
resampled_warped_slices_oblique = []
for (sliced_registered_anat_filename,
resampled_warped_slice) in zip(sliced_registered_anat_filenames,
resampled_warped_slices):
oblique_slice = fix_obliquity(resampled_warped_slice,
sliced_registered_anat_filename,
verbose=verbose)
resampled_warped_slices_oblique.append(oblique_slice)
# slice functional
sliced_func_filenames = []
for slice_n in range(n_slices):
out_slicer = slicer(in_file=allineated_filename,
keep='{0} {0}'.format(slice_n),
out_file=fname_presuffix(allineated_filename,
suffix='Sl%d' % slice_n),
environ=environ)
oblique_slice = fix_obliquity(out_slicer.outputs.out_file,
allineated_filename,
verbose=verbose)
sliced_func_filenames.append(oblique_slice)
# Apply the precomputed warp slice by slice
warped_func_slices = []
for (sliced_func_filename, warp_filename) in zip(sliced_func_filenames,
warp_filenames):
out_warp_apply = warp_apply(in_file=sliced_func_filename,
master=sliced_func_filename,
warp=warp_filename,
out_file=fname_presuffix(
sliced_func_filename, suffix='_qw'),
environ=environ)
warped_func_slices.append(out_warp_apply.outputs.out_file)
# Finally, merge all slices !
out_merge_func = merge(in_files=warped_func_slices,
outputtype='NIFTI_GZ',
environ=environ)
# Fix the obliquity
merged_oblique = fix_obliquity(out_merge_func.outputs.out_file,
allineated_filename,
verbose=verbose)
# Update the fmri data
setattr(session_data, "coreg_func_", merged_oblique)
setattr(session_data, "coreg_anat_", registered_anat_oblique_filename)
setattr(session_data, "coreg_transform_", transform_filename)
os.chdir(current_dir)
# Collect the outputs
output_files.extend(sliced_registered_anat_filenames +
sliced_bias_corrected_filenames +
resampled_registered_anat_filenames +
resampled_bias_corrected_filenames + warped_slices +
warp_filenames + resampled_warped_slices_oblique +
sliced_func_filenames + warped_func_slices)
if not caching:
for out_file in output_files:
if os.path.isfile(out_file):
os.remove(out_file)
os.chdir(results_path+subj) print "Currently processing subject: ", subj anat = data_path + subj + '/anat/t1_mpr_sag_p2_iso.nii.gz' # Initialize workflow workflow = pe.Workflow(name='anat') workflow.base_dir = '.' ref_brain = '/usr/share/fsl/5.0/data/standard/MNI152_T1_2mm_brain.nii.gz' ref_mask = '/usr/share/fsl/5.0/data/standard/MNI152_T1_2mm_brain_mask.nii.gz' reference_skull = '/usr/share/fsl/5.0/data/standard/MNI152_T1_2mm.nii.gz' fnirt_config = '/usr/share/fsl/5.0/etc/flirtsch/T1_2_MNI152_2mm.cnf' # Reorient to FSL standard orientation deoblique = pe.Node(interface=afni.Warp(in_file=anat, deoblique=True, outputtype='NIFTI_GZ'), name='deoblique') reorient = pe.Node(interface=fsl.Reorient2Std(output_type='NIFTI_GZ'), name='reorient') workflow.connect(deoblique, 'out_file', reorient, 'in_file') # AFNI skullstrip skullstrip = pe.Node(interface=afni.SkullStrip(args='-push_to_edge -ld 30', outputtype='NIFTI_GZ'), name='skullstrip') workflow.connect(reorient, 'out_file', skullstrip, 'in_file') # Segment with FSL FAST #tissue priors #tissue_path = '/usr/share/fsl/5.0/data/standard/tissuepriors/2mm/' #csf_prior = tissue_path + 'avg152T1_csf_bin.nii.gz' #white_prior = tissue_path + 'avg152T1_white_bin.nii.gz' #gray_prior = tissue_path + 'avg152T1_gray_bin.nii.gz' #segmentation = pe.Node(interface=fsl.FAST(number_classes=3, use_priors=True, img_type=1), name='segmentation')
inputnode.inputs.source_file = func1
else:
inputnode.inputs.source_file = func2
# Motion correction + slice timing correction
realign4d = pe.Node(interface=SpaceTimeRealigner(), name='realign4d')
realign4d.inputs.ignore_exception = True
realign4d.inputs.slice_times = 'asc_alt_siemens'
realign4d.inputs.slice_info = 2
realign4d.inputs.tr = 2.00
workflow1.connect(inputnode, 'source_file', realign4d, 'in_file')
workflow1.connect(realign4d, 'par_file', outputnode, 'move_par')
# Reorient
deoblique = pe.Node(interface=afni.Warp(deoblique=True,
outputtype='NIFTI_GZ'),
name='deoblique')
workflow1.connect(realign4d, 'out_file', deoblique, 'in_file')
reorient = pe.Node(interface=fsl.Reorient2Std(output_type='NIFTI_GZ'),
name='reorient')
workflow1.connect(deoblique, 'out_file', reorient, 'in_file')
workflow1.connect(reorient, 'out_file', outputnode, 'out_file')
# Run workflow1
workflow1.write_graph()
workflow1.run()
# Initialize DRIFTER
if data == 'func1':
#check is physiological signals exist, if not, then None
infile = results_path + '/' + data + '_1/reorient/corr_epi_warp_reoriented.nii.gz'
def prepro_anat(k):
try:
subj = k
for s in (['session2']):
if (not os.path.isdir(data_path + subj + '/' + s)):
continue
if (os.path.isfile(
results_path + subj + '/' + s +
'/anat/nonlinear_reg/anat_HR_reoriented_warped.nii.gz')):
print "Skipping " + subj + '/' + s
continue
'''
if (os.path.isfile(pilot_path +subj +'/anat/nonlinear_reg/anat_reoriented_skullstrip_warped.nii.gz')):
print "Skipping "+ subj +'/' + s
continue
'''
try:
os.stat(results_path)
except:
os.mkdir(results_path)
try:
os.stat(results_path + subj)
except:
os.mkdir(results_path + subj)
try:
os.stat(results_path + subj + '/' + s)
except:
os.mkdir(results_path + subj + '/' + s)
os.chdir(results_path + subj + '/' + s)
print "Currently processing subject: ", subj + '/' + s
anat = data_path + subj + '/' + s + '/anat_HR.nii.gz'
# Initialize workflow
workflow = pe.Workflow(name='anat')
workflow.base_dir = '.'
# Reorient to FSL standard orientation
deoblique = pe.Node(
interface=afni.Warp(in_file=anat,
deoblique=True,
outputtype='NIFTI_GZ'),
name='deoblique') #leave out if you don't need this
reorient = pe.Node(
interface=fsl.Reorient2Std(output_type='NIFTI_GZ'),
name='reorient')
workflow.connect(deoblique, 'out_file', reorient, 'in_file')
# AFNI skullstrip
skullstrip = pe.Node(
interface=afni.SkullStrip(outputtype='NIFTI_GZ'),
name='skullstrip')
workflow.connect(reorient, 'out_file', skullstrip, 'in_file')
# Segment with FSL FAST
segmentation = pe.Node(interface=fsl.FAST(number_classes=3,
use_priors=True,
img_type=1),
name='segmentation')
segmentation.segments = True
segmentation.probability_maps = True
workflow.connect(skullstrip, 'out_file', segmentation, 'in_files')
# Register to HR anatomical
hranat = results_path + subj + '/session1/anat/reorient/anat_HR_brain_reoriented.nii.gz'
#anat2hr = pe.Node(interface=fsl.FLIRT(no_search=True, reference=hranat), name='anat2hr')
anat2hr = pe.Node(interface=fsl.FLIRT(dof=6, reference=hranat),
name='anat2hr')
workflow.connect(reorient, 'out_file', anat2hr, 'in_file')
# Register to standard MNI template
#1. linear
linear_reg = pe.Node(interface=fsl.FLIRT(cost='corratio',
reference=ref_brain),
name='linear_reg')
#2.nonlinear
nonlinear_reg = pe.Node(interface=fsl.FNIRT(fieldcoeff_file=True,
jacobian_file=True,
ref_file=ref_brain,
refmask_file=ref_mask),
name='nonlinear_reg')
inv_flirt_xfm = pe.Node(
interface=fsl.utils.ConvertXFM(invert_xfm=True),
name='inv_linear_xfm')
workflow.connect(skullstrip, 'out_file', linear_reg, 'in_file')
#workflow.connect(anat2hr, 'out_matrix_file', linear_reg, 'in_matrix_file')
workflow.connect(linear_reg, 'out_matrix_file', nonlinear_reg,
'affine_file')
workflow.connect(skullstrip, 'out_file', nonlinear_reg, 'in_file')
workflow.connect(linear_reg, 'out_matrix_file', inv_flirt_xfm,
'in_file')
# Run workflow
workflow.write_graph()
workflow.run()
print "ANATOMICAL PREPROCESSING DONE! Results in ", results_path + subj + '/' + s
except:
print "Error with patient: ", subj
traceback.print_exc()
