def make_sub_cnxn_visitation_map(sub,dpy_file,parc_file,warp_file,ref_file,
cnxn_inds_file,cnxn_name,vismap_fstr):
overwrite=True
import os,h5py,numpy as np,nibabel as nib
from dipy.io import Dpy
from dipy.tracking.utils import connectivity_matrix,length,density_map
from nipype.interfaces.fsl import ApplyWarp
F = h5py.File(cnxn_inds_file, 'r')
if cnxn_name in F.keys():
stream_idxs = F[cnxn_name].value
F.close()
D = Dpy(dpy_file, 'r')
streams = D.read_tracksi(stream_idxs)
D.close()
parc_img = nib.load(parc_file)
affine = np.eye(4)
outfile_nat = os.path.abspath('vismap_nat_%s.nii.gz' %cnxn_name)
outfile_std = os.path.abspath(vismap_fstr %cnxn_name)
dm = density_map(streams,parc_img.shape,affine=affine)
dm_img = nib.Nifti1Image(dm.astype("int16"), parc_img.affine)
dm_img.to_filename(outfile_nat)
print 'warping cnxn image to standard space'
aw = ApplyWarp(in_file=outfile_nat,
out_file=outfile_std,
ref_file =ref_file,
field_file =warp_file)
aw.run()
else:
outfile_std = 'cnxn not found'
F.close()
return outfile_std
def init_hcp_segment_anat_wf(name='hcp_segment_anat_wf'):
"""
This workflow generates WM, CSF and GM masks using the same
pipeline from the HCP pipeline. The wm and csf masks are created by
importing the appropriate freesurfer parcellations from the wmparc
file and subtracting out the voxel marked as gm.
**Paramters**
name
Name for the workflow hierarchy of Niype
**Inputs**
brainmask_fs
freesurfer brain in MNI space with anat dims
l_atlasroi
left vertex mask
l_midthickness
left midthickness surface
l_white
left white matter surface
l_pial
left pial surface
r_atlasroi
right vertex mask
r_midthickness
right midthickness surface
r_white
right white matter surface
r_pial
right pial surface
wmparc
gyral white matter segmentation generated by freesurfer warped
MNI space
ROIs
subcortical parcellation of brain warped into MNI space
**Outputs**
brain_gm_mask
whole brain gm mask dilated twice in MNI 2mm space brainmasked
cortical_gm_mask
coritcal gm mask in MNI 2mm space brainmasked
subcortical_gm_mask
subcortical gm mask in MNI 2mm space brainmasked
wm_mask
white matter mask in MNI 2mm space brainmasked
csf_mask
csf mask in MNI 2mm space brainmasked
"""
wf = Workflow(name='hcp_segment')
with pkg_resources.path(data, 'FreeSurferCSFRegLut.txt') as tmp:
csf_rois = str(tmp)
with pkg_resources.path(data, 'FreeSurferWMRegLut.txt') as tmp:
wm_rois = str(tmp)
with pkg_resources.path(data, 'fsl_identity.mat') as tmp:
fsl_identity = str(tmp)
inputnode = Node(IdentityInterface(
fields=['brainmask_fs', 'wmparc', 'l_atlasroi', 'l_midthickness', 'l_white',
'l_pial', 'r_atlasroi', 'r_midthickness', 'r_white', 'r_pial',
'ROIs']),
name='inputnode')
outputnode = Node(IdentityInterface(
fields=['cort_gm_mask', 'subcort_gm_mask', 'gm_mask',
'wm_mask', 'csf_mask']),
name='outputnode')
# resample gm mask to 2mm MNI space
resample_mask = Node(ApplyWarp(relwarp=True, interp='nn',
premat=fsl_identity, out_file='brainmask_fs.2.nii.gz'),
name='resample_mask')
# gm mask nodes
l_gm_mask = Node(wb.MetricToVolumeMappingRC(out_file='l_gm_mask.nii.gz'),
name='l_gm_mask')
r_gm_mask = Node(wb.MetricToVolumeMappingRC(out_file='r_gm_mask.nii.gz'),
name='r_gm_mask')
cort_gm = Node(ImageMaths(out_file='cortical_gm.nii.gz',
op_string='-add',
args='-bin'),
name='cort_gm')
cort_gm_mask = Node(ImageMaths(out_file='cortical_gm_mask.nii.gz',
op_string='-mul'),
name='cort_gm_mask')
subcort_gm_mask = Node(ImageMaths(out_file='subcortical_gm_mask.nii.gz',
op_string='-mul',
args='-bin'),
name='subcort_gm_mask')
brain_gm_mask = Node(ImageMaths(out_file='brain_gm_mask.nii.gz',
op_string='-add',
args='-dilD -dilD'),
name='brain_gm_mask')
# wm mask nodes
wm_vol = Node(wb.VolumeLabelImport(out_file='wm_vol.nii.gz',
label_list_file=wm_rois,
discard_others=True,
drop_unused_labels=True),
name='wm_vol')
wm = Node(ImageMaths(out_file='wm.nii.gz',
op_string='-bin -sub',
args='-bin'),
name='wm')
wm_mask = Node(ImageMaths(out_file='wm_mask.nii.gz',
op_string='-mul',
args='-bin'),
name='wm_mask')
# csf mask nodes
csf_vol = Node(wb.VolumeLabelImport(out_file='csf_vol.nii.gz',
label_list_file=csf_rois,
discard_others=True,
drop_unused_labels=True),
name='csf_vol')
csf = Node(ImageMaths(out_file='csf.nii.gz',
op_string='-bin -sub',
args='-bin'),
name='csf')
csf_mask = Node(ImageMaths(out_file='csf_mask.nii.gz',
op_string='-mul',
args='-bin'),
name='csf_mask')
wf.connect([
# gm
(inputnode, resample_mask, [('brainmask_fs', 'in_file'),
('wmparc', 'ref_file')]),
(inputnode, l_gm_mask, [('l_atlasroi', 'in_file'),
('l_midthickness', 'surface'),
('wmparc', 'volume_space'),
('l_pial', 'inner_surf'),
('l_white', 'outer_surf')]),
(inputnode, r_gm_mask, [('r_atlasroi', 'in_file'),
('r_midthickness', 'surface'),
('wmparc', 'volume_space'),
('r_pial', 'inner_surf'),
('r_white', 'outer_surf')]),
(l_gm_mask, cort_gm, [('out_file', 'in_file')]),
(r_gm_mask, cort_gm, [('out_file', 'in_file2')]),
(cort_gm, cort_gm_mask, [('out_file', 'in_file')]),
(resample_mask, cort_gm_mask, [('out_file', 'in_file2')]),
(inputnode, subcort_gm_mask, [('ROIs', 'in_file')]),
(resample_mask, subcort_gm_mask, [('out_file', 'in_file2')]),
(cort_gm_mask, brain_gm_mask, [('out_file', 'in_file')]),
(subcort_gm_mask, brain_gm_mask, [('out_file', 'in_file2')]),
# wm
(inputnode, wm_vol, [('wmparc', 'in_file')]),
(wm_vol, wm, [('out_file', 'in_file')]),
(brain_gm_mask, wm, [('out_file', 'in_file2')]),
(wm, wm_mask, [('out_file', 'in_file')]),
(resample_mask, wm_mask, [('out_file', 'in_file2')]),
# csf
(inputnode, csf_vol, [('wmparc', 'in_file')]),
(csf_vol, csf, [('out_file', 'in_file')]),
(brain_gm_mask, csf, [('out_file', 'in_file2')]),
(csf, csf_mask, [('out_file', 'in_file')]),
(resample_mask, csf_mask, [('out_file', 'in_file2')]),
# output
(cort_gm_mask, outputnode, [('out_file', 'cort_gm_mask')]),
(subcort_gm_mask, outputnode, [('out_file', 'subcort_gm_mask')]),
(brain_gm_mask, outputnode, [('out_file', 'brain_gm_mask')]),
(wm_mask, outputnode, [('out_file', 'wm_mask')]),
(csf_mask, outputnode, [('out_file', 'csf_mask')])
])
return wf
def preproc(data_dir, sink_dir, subject, task, session, run, masks,
motion_thresh, moco):
from nipype.interfaces.fsl import MCFLIRT, FLIRT, FNIRT, ExtractROI, ApplyWarp, MotionOutliers, InvWarp, FAST
#from nipype.interfaces.afni import AlignEpiAnatPy
from nipype.interfaces.utility import Function
from nilearn.plotting import plot_anat
from nilearn import input_data
#WRITE A DARA GRABBER
def get_niftis(subject_id, data_dir, task, run, session):
from os.path import join, exists
t1 = join(data_dir, subject_id, 'session-{0}'.format(session),
'anatomical', 'anatomical-0', 'anatomical.nii.gz')
#t1_brain_mask = join(data_dir, subject_id, 'session-1', 'anatomical', 'anatomical-0', 'fsl', 'anatomical-bet.nii.gz')
epi = join(data_dir, subject_id, 'session-{0}'.format(session), task,
'{0}-{1}'.format(task, run), '{0}.nii.gz'.format(task))
assert exists(t1), "t1 does not exist at {0}".format(t1)
assert exists(epi), "epi does not exist at {0}".format(epi)
standard = '/home/applications/fsl/5.0.8/data/standard/MNI152_T1_2mm.nii.gz'
return t1, epi, standard
data = Function(
function=get_niftis,
input_names=["subject_id", "data_dir", "task", "run", "session"],
output_names=["t1", "epi", "standard"])
data.inputs.data_dir = data_dir
data.inputs.subject_id = subject
data.inputs.run = run
data.inputs.session = session
data.inputs.task = task
grabber = data.run()
if session == 0:
sesh = 'pre'
if session == 1:
sesh = 'post'
#reg_dir = '/home/data/nbc/physics-learning/data/first-level/{0}/session-1/retr/retr-{1}/retr-5mm.feat/reg'.format(subject, run)
#set output paths for quality assurance pngs
qa1 = join(
sink_dir, 'qa',
'{0}-session-{1}_{2}-{3}_t1_flirt.png'.format(subject, session, task,
run))
qa2 = join(
sink_dir, 'qa',
'{0}-session-{1}_{2}-{3}_mni_flirt.png'.format(subject, session, task,
run))
qa3 = join(
sink_dir, 'qa',
'{0}-session-{1}_{2}-{3}_mni_fnirt.png'.format(subject, session, task,
run))
confound_file = join(
sink_dir, sesh, subject,
'{0}-session-{1}_{2}-{3}_confounds.txt'.format(subject, session, task,
run))
#run motion correction if indicated
if moco == True:
mcflirt = MCFLIRT(ref_vol=144, save_plots=True, output_type='NIFTI_GZ')
mcflirt.inputs.in_file = grabber.outputs.epi
#mcflirt.inputs.in_file = join(data_dir, subject, 'session-1', 'retr', 'retr-{0}'.format(run), 'retr.nii.gz')
mcflirt.inputs.out_file = join(
sink_dir, sesh, subject,
'{0}-session-{1}_{2}-{3}_mcf.nii.gz'.format(
subject, session, task, run))
flirty = mcflirt.run()
motion = np.genfromtxt(flirty.outputs.par_file)
else:
print "no moco needed"
motion = 0
#calculate motion outliers
try:
mout = MotionOutliers(metric='fd', threshold=motion_thresh)
mout.inputs.in_file = grabber.outputs.epi
mout.inputs.out_file = join(
sink_dir, sesh, subject,
'{0}-session-{1}_{2}-{3}_fd-gt-{3}mm'.format(
subject, session, task, run, motion_thresh))
mout.inputs.out_metric_plot = join(
sink_dir, sesh, subject,
'{0}-session-{1}_{2}-{3}_metrics.png'.format(
subject, session, task, run))
mout.inputs.out_metric_values = join(
sink_dir, sesh, subject,
'{0}-session-{1}_{2}-{3}_fd.txt'.format(subject, session, task,
run))
moutliers = mout.run()
outliers = np.genfromtxt(moutliers.outputs.out_file)
e = 'no errors in motion outliers, yay'
except Exception as e:
print(e)
outliers = np.genfromtxt(mout.inputs.out_metric_values)
#set everything above the threshold to 1 and everything below to 0
outliers[outliers > motion_thresh] = 1
outliers[outliers < motion_thresh] = 0
#concatenate motion parameters and motion outliers to form confounds file
#outliers = outliers.reshape((outliers.shape[0],1))
conf = outliers
np.savetxt(confound_file, conf, delimiter=',')
#extract an example volume for normalization
ex_fun = ExtractROI(t_min=144, t_size=1)
ex_fun.inputs.in_file = flirty.outputs.out_file
ex_fun.inputs.roi_file = join(
sink_dir, sesh, subject,
'{0}-session-{1}_{2}-{3}-example_func.nii.gz'.format(
subject, session, task, run))
fun = ex_fun.run()
warp = ApplyWarp(interp="nn", abswarp=True)
if not exists(
'/home/data/nbc/physics-learning/data/first-level/{0}/session-{1}/{2}/{2}-{3}/{2}-5mm.feat/reg/example_func2standard_warp.nii.gz'
.format(subject, session, task, run)):
#two-step normalization using flirt and fnirt, outputting qa pix
flit = FLIRT(cost_func="corratio", dof=12)
reg_func = flit.run(
reference=fun.outputs.roi_file,
in_file=grabber.outputs.t1,
searchr_x=[-180, 180],
searchr_y=[-180, 180],
out_file=join(
sink_dir, sesh, subject,
'{0}-session-{1}_{2}-{3}_t1-flirt.nii.gz'.format(
subject, session, task, run)),
out_matrix_file=join(
sink_dir, sesh, subject,
'{0}-session-{1}_{2}-{3}_t1-flirt.mat'.format(
subject, session, task, run)))
reg_mni = flit.run(
reference=grabber.outputs.t1,
in_file=grabber.outputs.standard,
searchr_y=[-180, 180],
searchr_z=[-180, 180],
out_file=join(
sink_dir, sesh, subject,
'{0}-session-{1}_{2}-{3}_mni-flirt-t1.nii.gz'.format(
subject, session, task, run)),
out_matrix_file=join(
sink_dir, sesh, subject,
'{0}-session-{1}_{2}-{3}_mni-flirt-t1.mat'.format(
subject, session, task, run)))
#plot_stat_map(aligner.outputs.out_file, bg_img=fun.outputs.roi_file, colorbar=True, draw_cross=False, threshold=1000, output_file=qa1a, dim=-2)
display = plot_anat(fun.outputs.roi_file, dim=-1)
display.add_edges(reg_func.outputs.out_file)
display.savefig(qa1, dpi=300)
display.close()
display = plot_anat(grabber.outputs.t1, dim=-1)
display.add_edges(reg_mni.outputs.out_file)
display.savefig(qa2, dpi=300)
display.close()
perf = FNIRT(output_type='NIFTI_GZ')
perf.inputs.warped_file = join(
sink_dir, sesh, subject,
'{0}-session-{1}_{2}-{3}_mni-fnirt-t1.nii.gz'.format(
subject, session, task, run))
perf.inputs.affine_file = reg_mni.outputs.out_matrix_file
perf.inputs.in_file = grabber.outputs.standard
perf.inputs.subsampling_scheme = [8, 4, 2, 2]
perf.inputs.fieldcoeff_file = join(
sink_dir, sesh, subject,
'{0}-session-{1}_{2}-{3}_mni-fnirt-t1-warpcoeff.nii.gz'.format(
subject, session, task, run))
perf.inputs.field_file = join(
sink_dir, sesh, subject,
'{0}-session-{1}_{2}-{3}_mni-fnirt-t1-warp.nii.gz'.format(
subject, session, task, run))
perf.inputs.ref_file = grabber.outputs.t1
reg2 = perf.run()
warp.inputs.field_file = reg2.outputs.field_file
#plot fnirted MNI overlaid on example func
display = plot_anat(grabber.outputs.t1, dim=-1)
display.add_edges(reg2.outputs.warped_file)
display.savefig(qa3, dpi=300)
display.close()
else:
warpspeed = InvWarp(output_type='NIFTI_GZ')
warpspeed.inputs.warp = '/home/data/nbc/physics-learning/data/first-level/{0}/session-{1}/{2}/{2}-{3}/{2}-5mm.feat/reg/example_func2standard_warp.nii.gz'.format(
subject, session, task, run)
warpspeed.inputs.reference = fun.outputs.roi_file
warpspeed.inputs.inverse_warp = join(
sink_dir, sesh, subject,
'{0}-session-{1}_{2}-{3}_mni-fnirt-t1-warp.nii.gz'.format(
subject, session, task, run))
mni2epiwarp = warpspeed.run()
warp.inputs.field_file = mni2epiwarp.outputs.inverse_warp
for key in masks.keys():
#warp takes us from mni to epi
warp.inputs.in_file = masks[key]
warp.inputs.ref_file = fun.outputs.roi_file
warp.inputs.out_file = join(
sink_dir, sesh, subject,
'{0}-session-{1}_{2}-{3}_{4}.nii.gz'.format(
subject, session, task, run, key))
net_warp = warp.run()
qa_file = join(
sink_dir, 'qa', '{0}-session-{1}_{2}-{3}_qa_{4}.png'.format(
subject, session, task, run, key))
display = plotting.plot_roi(net_warp.outputs.out_file,
bg_img=fun.outputs.roi_file,
colorbar=True,
vmin=0,
vmax=18,
draw_cross=False)
display.savefig(qa_file, dpi=300)
display.close()
return flirty.outputs.out_file, confound_file, e
subjects = ['101', '102']
data_dir = '/home/data/nbc/physics-learning/data/pre-processed/'
sink_dir = '/home/data/nbc/physics-learning/retrieval-graphtheory/output'
shen = '/home/kbott006/physics-retrieval/shen2015_2mm_268_parcellation.nii.gz'
craddock = '/home/kbott006/physics-retrieval/craddock2012_tcorr05_2level_270_2mm.nii.gz'
masks = {'shen2015': shen, 'craddock2012': craddock}
sessions = [0,1]
sesh = ['pre', 'post']
correlation_measure = ConnectivityMeasure(kind='correlation')
invert = InvWarp()
warpspeed = ApplyWarp(interp='nn')
index = pd.MultiIndex.from_product([subjects, sessions], names=['subject', 'session'])
df = pd.DataFrame(columns=['shen-efficiency', 'shen-charpath', 'shen-modularity', 'craddock-efficiency', 'craddock-charpath', 'craddock-modularity'], index=index, dtype=np.float64)
for subject in subjects:
for session in sessions:
try:
mni2epiwarp = join(sink_dir, '{2}/{0}/{0}-session-{1}_rest_mni-fnirt-epi-warp.nii.gz'.format(subject, session, sesh[session]))
#invert the epi-to-mni warpfield so you can run these analyses in native space
invert.inputs.warp = join(data_dir, subject, 'session-{0}'.format(session), 'resting-state/resting-state-0/endor1.feat/reg/example_func2standard_warp.nii.gz')
invert.inputs.inverse_warp = mni2epiwarp
invert.inputs.reference = join(data_dir, subject, 'session-{0}'.format(session), 'resting-state/resting-state-0/endor1.feat/reg/example_func.nii.gz')
inverted = invert.run()
"resting-state",
"resting-state-0",
"endor1.feat",
"reg",
"example_func2standard_warp.nii.gz",
)
# invwarp = InvWarp()
# invwarp.inputs.warp = func2mni_warp
# invwarp.inputs.reference = example_func
# invwarp.inputs.output_type = "NIFTI_GZ"
# invwarp.inputs.inverse_warp = join(sink_dir, session, 'resting-state', subject, '{0}-{1}_mni-fnirt-epi-warp.nii.gz'.format(subject, session))
# rev = invwarp.run()
for key in masks.keys():
applywarp = ApplyWarp(interp="nn", abswarp=True)
applywarp.inputs.in_file = masks[key]
applywarp.inputs.ref_file = example_func
applywarp.inputs.field_file = join(
sink_dir,
session,
"resting-state",
subject,
"{0}-{1}_mni-fnirt-epi-warp.nii.gz".format(
subject, session),
)
applywarp.inputs.out_file = join(
sink_dir,
session,
"resting-state",
subject,
eventsfile = os.path.join(BIDSDIR, SUBJECT, 'func',
SUBJECT + "_task-" + TASK + '_events.tsv')
regressors = utils.create_ev_task(eventsfile, eventsdir, TASK)
EVfiles = regressors['EVfiles']
orthogonality = regressors['orthogonal']
contrasts = utils.create_contrasts(TASK)
# START PIPELINE
# inputmask = Node(IdentityInterface(fields=['mask_file']), name='inputmask')
if args.prep_pipeline.startswith("fsl"):
masker = Node(ApplyWarp(
in_file = cf_files['bold'],
field_file=cf_files['warpfile'],
ref_file=cf_files['standard'],
out_file = cf_files['masked'],
mask_file = cf_files['standard_mask']
), name = 'masker')
#inputmask.inputs.mask_file = cf_files['standard_mask']
else:
masker = Node(maths.ApplyMask(
in_file=cf_files['bold'],
out_file=cf_files['masked'],
mask_file=cf_files['standard_mask']
), name='masker')
bim = Node(afni.BlurInMask(
out_file=cf_files['smoothed'],
mask = cf_files['standard_mask'],
try:
mni2epiwarp = join(
data_dir,
sessions[i],
subject,
"{0}-session-{1}_{2}-{3}_mni-fnirt-epi-warp.nii.gz"
.format(subject, i, task, run),
)
example_func_file = "/home/data/nbc/physics-learning/data/pre-processed/{0}/session-{1}/fci/fci-{2}/fci-{2}-ppi.feat/reg/example_func.nii.gz".format(
subject, i, run)
example_func2standard = "/home/data/nbc/physics-learning/data/pre-processed/{0}/session-{1}/fci/fci-{2}/fci-{2}-ppi.feat/reg/example_func2standard_warp.nii.gz".format(
subject, i, run)
print example_func2standard
print mask
print masks[mask]
warpspeed = ApplyWarp(
interp="nn", output_type="NIFTI_GZ")
if not exists(mni2epiwarp):
# invert the epi-to-mni warpfield so you can run these analyses in native space
invert = InvWarp(
output_type="NIFTI_GZ")
invert.inputs.warp = example_func2standard
invert.inputs.inverse_warp = mni2epiwarp
invert.inputs.reference = example_func_file
inverted = invert.run()
warpspeed.inputs.field_file = (
inverted.outputs.inverse_warp)
else:
warpspeed.inputs.ref_file = example_func_file
warpspeed.inputs.field_file = mni2epiwarp
warpspeed.inputs.in_file = masks[mask]
warpspeed.inputs.out_file = mask_file
def fnirt_again(data_dir, sink_dir, subject, run, masks, mask_names):
import numpy as np
def get_niftis(subject, data_dir, sink_dir, run, masks):
from os.path import join, exists
t1 = join(
data_dir,
subject,
"session-1",
"anatomical",
"anatomical-0",
"anatomical.nii.gz",
)
# t1_brain_mask = join(data_dir, subject, 'session-1', 'anatomical', 'anatomical-0', 'fsl', 'anatomical-bet.nii.gz')
example_func = join(
sink_dir, subject,
"{0}-{1}_retr-example_func.nii.gz".format(subject, run))
assert exists(t1), "t1 does not exist"
assert exists(example_func), "example_func does not exist"
standard = "/home/applications/fsl/5.0.8/data/standard/MNI152_T1_2mm.nii.gz"
mni2t1 = join(sink_dir, subject,
"{0}-{1}_mni-flirt-t1.mat".format(subject, run))
t12epi = join(sink_dir, subject,
"{0}-{1}_t1-flirt-retr.mat".format(subject, run))
masks = masks
return t1, example_func, standard, mni2t1, t12epi, masks
data = Function(
function=get_niftis,
input_names=["subject", "data_dir", "sink_dir", "run", "masks"],
output_names=[
"t1", "example_func", "standard", "mni2t1", "t12epi", "masks"
],
)
data.inputs.data_dir = data_dir
data.inputs.sink_dir = sink_dir
data.inputs.subject = subject
data.inputs.masks = masks
data.inputs.run = run
grabber = data.run()
perf = FNIRT(output_type="NIFTI_GZ")
perf.inputs.warped_file = join(
sink_dir, subject, "{0}-{1}_mni-fnirt-t1.nii.gz".format(subject, run))
perf.inputs.affine_file = grabber.outputs.mni2t1
perf.inputs.in_file = grabber.outputs.standard
perf.inputs.subsampling_scheme = [8, 4, 2, 2]
perf.inputs.fieldcoeff_file = join(
sink_dir, subject,
"{0}-{1}_mni-fnirt-t1-warpcoef.nii.gz".format(subject, run))
perf.inputs.field_file = join(
sink_dir, subject,
"{0}-{1}_mni-fnirt-t1-warp.nii.gz".format(subject, run))
perf.inputs.ref_file = grabber.outputs.t1
reg2 = perf.run()
for i in np.arange(0, len(masks)):
# warp takes us from mni to t1, postmat
warp = ApplyWarp(interp="nn", abswarp=True)
warp.inputs.in_file = grabber.outputs.masks[i]
warp.inputs.ref_file = grabber.outputs.example_func
warp.inputs.field_file = reg2.outputs.field_file
warp.inputs.postmat = grabber.outputs.t12epi
warp.inputs.out_file = join(
sink_dir,
subject,
"{0}-{1}_{2}_retr.nii.gz".format(subject, run, mask_names[i]),
)
net_warp = warp.run()
return "yay"
def fsl_motion_correction(name='realign'):
"""Realign a time series to the middle volume using spline interpolation
Uses MCFLIRT to realign the time series and ApplyWarp to apply the rigid
body transformations using spline interpolation (unknown order).
Nipype Inputs
-------------
realign_input.func: exising file
The path to the fMRI file.
Nipype Outputs
--------------
realign_output.realigned_file: exising file
The path to the realigned fMRI file.
realign_output.realign_params: mat file
.mat file with the affine transformation parameters.
Example
-------
>>> wf = fsl_motion_correction()
>>> wf.inputs.inputspec.func = 'f3.nii'
>>> wf.run() # doctest: +SKIP
"""
wf = Workflow(name=name)
# input node
input = setup_node(IdentityInterface(fields=['func']),
name='realign_input')
realigner = setup_node(MCFLIRT(save_mats=True, stats_imgs=True),
name='mcflirt')
splitter = setup_node(Split(dimension='t'), name='splitter')
warper = MapNode(ApplyWarp(interp='spline'),
iterfield=['in_file', 'premat'],
name='warper')
joiner = setup_node(Merge(dimension='t'), name='joiner')
# output node
output = setup_node(IdentityInterface(fields=[
'realigned_file',
'realign_params',
]),
name='realign_output')
wf.connect([
# input
(input, realigner, [
("func", "in_file"),
(("func", select_volume, 'middle'), "ref_vol"),
]),
# split
(realigner, splitter, [("out_file", "in_file")]),
(realigner, warper, [
("mat_file", "premat"),
("variance_img", "ref_file"),
]),
# warp
(splitter, warper, [("out_files", "in_file")]),
(warper, joiner, [("mat_file", "premat")]),
# output
(joiner, output, [("merged_file", "realigned_file")]),
(realigner, output, [("mat_file", "realign_params")]),
])
return wf