def _fnirt_to_tmpl_pipeline(self, **name_maps):
"""
Registers a MR scan to a refernce MR scan using FSL's nonlinear FNIRT
command
Parameters
----------
template : Which template to use, can be one of 'mni_nl6'
"""
pipeline = self.new_pipeline(
name='mag_coreg_to_tmpl',
name_maps=name_maps,
desc=("Nonlinearly registers a MR scan to a standard space,"
"e.g. MNI-space"),
citations=[fsl_cite])
# Basic reorientation to standard MNI space
reorient = pipeline.add(
'reorient',
Reorient2Std(
output_type='NIFTI_GZ'),
inputs={
'in_file': ('mag_preproc', nifti_gz_format)},
requirements=[fsl_req.v('5.0.8')])
reorient_mask = pipeline.add(
'reorient_mask',
Reorient2Std(
output_type='NIFTI_GZ'),
inputs={
'in_file': ('brain_mask', nifti_gz_format)},
requirements=[fsl_req.v('5.0.8')])
reorient_brain = pipeline.add(
'reorient_brain',
Reorient2Std(
output_type='NIFTI_GZ'),
inputs={
'in_file': ('brain', nifti_gz_format)},
requirements=[fsl_req.v('5.0.8')])
# Affine transformation to MNI space
flirt = pipeline.add(
'flirt',
interface=FLIRT(
dof=12,
output_type='NIFTI_GZ'),
inputs={
'reference': ('template_brain', nifti_gz_format),
'in_file': (reorient_brain, 'out_file')},
requirements=[fsl_req.v('5.0.8')],
wall_time=5)
# Apply mask if corresponding subsampling scheme is 1
# (i.e. 1-to-1 resolution) otherwise don't.
apply_mask = [int(s == 1)
for s in self.parameter('fnirt_subsampling')]
# Nonlinear transformation to MNI space
pipeline.add(
'fnirt',
interface=FNIRT(
output_type='NIFTI_GZ',
intensity_mapping_model=(
self.parameter('fnirt_intensity_model')
if self.parameter('fnirt_intensity_model') is not None else
'none'),
subsampling_scheme=self.parameter('fnirt_subsampling'),
fieldcoeff_file=True,
in_fwhm=[8, 6, 5, 4, 3, 2], # [8, 6, 5, 4.5, 3, 2] This threw an error because of float value @IgnorePep8,
ref_fwhm=[8, 6, 5, 4, 2, 0],
regularization_lambda=[300, 150, 100, 50, 40, 30],
apply_intensity_mapping=[1, 1, 1, 1, 1, 0],
max_nonlin_iter=[5, 5, 5, 5, 5, 10],
apply_inmask=apply_mask,
apply_refmask=apply_mask),
inputs={
'ref_file': ('template', nifti_gz_format),
'refmask': ('template_mask', nifti_gz_format),
'in_file': (reorient, 'out_file'),
'inmask_file': (reorient_mask, 'out_file'),
'affine_file': (flirt, 'out_matrix_file')},
outputs={
'mag_coreg_to_tmpl': ('warped_file', nifti_gz_format),
'coreg_to_tmpl_fsl_coeff': ('fieldcoeff_file',
nifti_gz_format)},
requirements=[fsl_req.v('5.0.8')],
wall_time=60)
# Set registration parameters
# TODO: Need to work out which parameters to use
return pipeline
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
ResponseSD,
)
#: A dictionary that should be imported in the project's settings and included
#: within the *ANALYSIS_INTERFACES* setting.
interfaces = {
"apply_topup": {ApplyTOPUP().version: ApplyTOPUP},
"binary_maths": {BinaryMaths().version: BinaryMaths},
"BET": {BET().version: BET},
"CAT12 Segmentation": {"12.7": Cat12Segmentation},
"fslmerge": {Merge().version: Merge},
"fslreorient2std": {Reorient2Std().version: Reorient2Std},
"fslroi": {ExtractROI().version: ExtractROI},
"FAST": {FastWrapper.version: FastWrapper},
"FLIRT": {FLIRT().version: FLIRT},
"FNIRT": {FNIRT().version: FNIRT},
"FSL Anatomical Processing Script": {FslAnat.__version__: FslAnat},
"mean_image": {MeanImage().version: MeanImage},
"robustfov": {RobustFOV().version: RobustFOV},
"ReconAll": {ReconAll().version: ReconAll},
"SUSAN": {SUSAN().version: SUSAN},
"topup": {TopupWrapper.version: TopupWrapper},
"eddy": {Eddy().version: Eddy},
"denoise": {DWIDenoise().version: DWIDenoise},
"degibbs": {MRDeGibbs().version: MRDeGibbs},
"bias_correct": {DWIBiasCorrect().version: DWIBiasCorrect},
"dwifslpreproc": {DwiFslPreproc.__version__: DwiFslPreproc},
"mrconvert": {MRConvert.__version__: MRConvert},
"dwi2fod": {
ConstrainedSphericalDeconvolution().version: ConstrainedSphericalDeconvolution # noqa: E501
},
"versions": [{
"title": FLIRT().version or "1.0",
"description":
f"Default FLIRT version for nipype {_NIPYPE_VERSION}.", # noqa: E501
"input": FLIRT_INPUT_SPECIFICATION,
"output": FLIRT_OUTPUT_SPECIFICATION,
"nested_results_attribute": "outputs.get_traitsfree",
}],
},
{
"title":
"FNIRT",
"description":
"FSL FNIRT wrapper for non-linear registration.",
"versions": [{
"title": FNIRT().version or "1.0",
"description":
f"Default FNIRT version for nipype {_NIPYPE_VERSION}.", # noqa: E501
"input": FNIRT_INPUT_SPECIFICATION,
"output": FNIRT_OUTPUT_SPECIFICATION,
"nested_results_attribute": "outputs.get_traitsfree",
}],
},
{
"title":
"FSL Anatomical Processing Script",
"description":
"A general pipeline for processing anatomical images (e.g. T1-weighted scans).", # noqa: E501
"versions": [{
"title": FslAnat.__version__,
"description":
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_fnirt_to_atlas_pipeline(self, **kwargs):
"""
Registers a MR scan to a refernce MR scan using FSL's nonlinear FNIRT
command
Parameters
----------
atlas : Which atlas to use, can be one of 'mni_nl6'
"""
pipeline = self.create_pipeline(
name='coregister_to_atlas',
inputs=[
DatasetSpec('preproc', nifti_gz_format),
DatasetSpec('brain_mask', nifti_gz_format),
DatasetSpec('brain', nifti_gz_format)
],
outputs=[
DatasetSpec('coreg_to_atlas', nifti_gz_format),
DatasetSpec('coreg_to_atlas_coeff', nifti_gz_format)
],
desc=("Nonlinearly registers a MR scan to a standard space,"
"e.g. MNI-space"),
version=1,
citations=[fsl_cite],
**kwargs)
# Get the reference atlas from FSL directory
ref_atlas = get_atlas_path(self.parameter('fnirt_atlas'),
'image',
resolution=self.parameter('resolution'))
ref_mask = get_atlas_path(self.parameter('fnirt_atlas'),
'mask_dilated',
resolution=self.parameter('resolution'))
ref_brain = get_atlas_path(self.parameter('fnirt_atlas'),
'brain',
resolution=self.parameter('resolution'))
# Basic reorientation to standard MNI space
reorient = pipeline.create_node(Reorient2Std(),
name='reorient',
requirements=[fsl5_req])
reorient.inputs.output_type = 'NIFTI_GZ'
reorient_mask = pipeline.create_node(Reorient2Std(),
name='reorient_mask',
requirements=[fsl5_req])
reorient_mask.inputs.output_type = 'NIFTI_GZ'
reorient_brain = pipeline.create_node(Reorient2Std(),
name='reorient_brain',
requirements=[fsl5_req])
reorient_brain.inputs.output_type = 'NIFTI_GZ'
# Affine transformation to MNI space
flirt = pipeline.create_node(interface=FLIRT(),
name='flirt',
requirements=[fsl5_req],
wall_time=5)
flirt.inputs.reference = ref_brain
flirt.inputs.dof = 12
flirt.inputs.output_type = 'NIFTI_GZ'
# Nonlinear transformation to MNI space
fnirt = pipeline.create_node(interface=FNIRT(),
name='fnirt',
requirements=[fsl5_req],
wall_time=60)
fnirt.inputs.ref_file = ref_atlas
fnirt.inputs.refmask_file = ref_mask
fnirt.inputs.output_type = 'NIFTI_GZ'
intensity_model = self.parameter('fnirt_intensity_model')
if intensity_model is None:
intensity_model = 'none'
fnirt.inputs.intensity_mapping_model = intensity_model
fnirt.inputs.subsampling_scheme = self.parameter('fnirt_subsampling')
fnirt.inputs.fieldcoeff_file = True
fnirt.inputs.in_fwhm = [8, 6, 5, 4.5, 3, 2]
fnirt.inputs.ref_fwhm = [8, 6, 5, 4, 2, 0]
fnirt.inputs.regularization_lambda = [300, 150, 100, 50, 40, 30]
fnirt.inputs.apply_intensity_mapping = [1, 1, 1, 1, 1, 0]
fnirt.inputs.max_nonlin_iter = [5, 5, 5, 5, 5, 10]
# Apply mask if corresponding subsampling scheme is 1
# (i.e. 1-to-1 resolution) otherwise don't.
apply_mask = [int(s == 1) for s in self.parameter('fnirt_subsampling')]
fnirt.inputs.apply_inmask = apply_mask
fnirt.inputs.apply_refmask = apply_mask
# Connect nodes
pipeline.connect(reorient_brain, 'out_file', flirt, 'in_file')
pipeline.connect(reorient, 'out_file', fnirt, 'in_file')
pipeline.connect(reorient_mask, 'out_file', fnirt, 'inmask_file')
pipeline.connect(flirt, 'out_matrix_file', fnirt, 'affine_file')
# Set registration parameters
# TOD: Need to work out which parameters to use
# Connect inputs
pipeline.connect_input('preproc', reorient, 'in_file')
pipeline.connect_input('brain_mask', reorient_mask, 'in_file')
pipeline.connect_input('brain', reorient_brain, 'in_file')
# Connect outputs
pipeline.connect_output('coreg_to_atlas', fnirt, 'warped_file')
pipeline.connect_output('coreg_to_atlas_coeff', fnirt,
'fieldcoeff_file')
return pipeline
BET().version: BET
},
"CAT12 Segmentation": {
"12.6": Cat12Segmentation
},
"fslreorient2std": {
Reorient2Std().version: Reorient2Std
},
"FAST": {
FAST().version: FastWrapper
},
"FLIRT": {
FLIRT().version: FLIRT
},
"FNIRT": {
FNIRT().version: FNIRT
},
"FSL Anatomical Processing Script": {
FslAnat.__version__: FslAnat
},
"SUSAN": {
SUSAN().version: SUSAN
},
"ReconAll": {
ReconAll().version: ReconAll
},
"robustfov": {
RobustFOV().version: RobustFOV
},
}