def MNI_reorient(structural_nifti_file, out_file):
"""This function swaps the dimensions of the file by doing 90, 180, 0r 270 degree
rotations. The final product is in the RAS+ orientation (Right, Anterior, and Superior parts of the brain
are the positive values).
- in order to swap the dimensions, fsl.Reorient2Std calls fsl.SwapDimensions. In other words,
it is a specified version of Reorient2Std. For more info on Reorient2Std, look at RPI_reorient.py
input
------
structural_nifti_file: nifti/nifti.gz file
The original T1 weighted anatomical file
output
------
out_file: nifti.gz file
an MNI reoriented image in the RAS+ orientation
"""
MNI = fsl.Reorient2Std()
MNI.inputs.in_file = structural_nifti_file
MNI.inputs.out_file = out_file
MNI_results = MNI.run()
return MNI_results
def make_segment(self):
# Ref: http://nipype.readthedocs.io/en/0.12.1/interfaces/generated/nipype.interfaces.fsl.utils.html#reorient2std
ro = Node(interface=fsl.Reorient2Std(), name='ro')
# Ref: http://nipype.readthedocs.io/en/latest/interfaces/generated/interfaces.spm/preprocess.html#segment
seg = Node(interface=spm.NewSegment(channel_info=(0.0001, 60, (True,
True))),
name="seg")
spm_tissues_split = Node(Function(['in_list'], ['gm', 'wm', 'csf'],
self.spm_tissues),
name='spm_tissues_split')
gzip = Node(Function(['in_list'], ['out_list'], self.gzip_spm),
name='gzip')
segment = Workflow(name='Segment', base_dir=self.temp_dir)
gunzip = Node(interface=Gunzip(), name='gunzip')
# for new segment
segment.connect(ro, 'out_file', gunzip, 'in_file')
segment.connect(gunzip, 'out_file', seg, 'channel_files')
segment.connect(seg, 'native_class_images', spm_tissues_split,
'in_list')
return segment
def reorient_img(in_file, out_dir):
out_file = os.path.join(out_dir, 'T1w_reorient.nii.gz')
# Ensure in standard orientation
reorient = fsl.Reorient2Std()
reorient.inputs.in_file = in_file
reorient.inputs.out_file = out_file
reorient.run()
def create_converter_diffusion_pipeline(working_dir,
ds_dir,
name='converter_diffusion'):
# initiate workflow
converter_wf = Workflow(name=name)
converter_wf.base_dir = os.path.join(working_dir, 'LeiCA_resting')
# set fsl output
fsl.FSLCommand.set_default_output_type('NIFTI_GZ')
# inputnode
inputnode = Node(util.IdentityInterface(fields=['dMRI_dicom']),
name='inputnode')
outputnode = Node(util.IdentityInterface(fields=['dMRI']),
name='outputnode')
niftisink = Node(nio.DataSink(), name='niftisink')
niftisink.inputs.base_directory = os.path.join(ds_dir, 'raw_niftis')
#######
converter_dMRI = Node(Dcm2nii(), name="converter_dMRI")
converter_dMRI.inputs.gzip_output = True
converter_dMRI.inputs.nii_output = True
converter_dMRI.inputs.anonymize = False
converter_dMRI.plugin_args = {'submit_specs': 'request_memory = 2000'}
converter_wf.connect(inputnode, 'dMRI_dicom', converter_dMRI,
'source_names')
dMRI_rename = Node(util.Rename(format_string='DTI_mx_137.nii.gz'),
name='dMRI_rename')
converter_wf.connect(converter_dMRI, 'converted_files', dMRI_rename,
'in_file')
bvecs_rename = Node(util.Rename(format_string='DTI_mx_137.bvecs'),
name='bvecs_rename')
converter_wf.connect(converter_dMRI, 'bvecs', bvecs_rename, 'in_file')
bvals_rename = Node(util.Rename(format_string='DTI_mx_137.bvals'),
name='bvals_rename')
converter_wf.connect(converter_dMRI, "bvals", bvals_rename, 'in_file')
# reorient to standard orientation
reor_2_std = Node(fsl.Reorient2Std(), name='reor_2_std')
converter_wf.connect(dMRI_rename, 'out_file', reor_2_std, 'in_file')
converter_wf.connect(reor_2_std, 'out_file', outputnode, 'dMRI')
# save original niftis
converter_wf.connect(reor_2_std, 'out_file', niftisink, 'dMRI.@dwi')
converter_wf.connect(bvals_rename, 'out_file', niftisink, 'dMRI.@bvals')
converter_wf.connect(bvecs_rename, 'out_file', niftisink, 'dMRI.@bvecs')
converter_wf.write_graph(dotfilename='converter_struct',
graph2use='flat',
format='pdf')
return converter_wf
def results(cenc_participant_id, cenc_participant_dir, cenc_freesurfer_dir,cenc_results_dir, verbose):
util.mkcd_dir( [ cenc_results_dir ], True)
files_to_convert = [ os.path.join( cenc_freesurfer_dir, cenc_participant_id, 'mri', 'nu.mgz'),
os.path.join( cenc_freesurfer_dir, cenc_participant_id, 'mri', 'aseg.mgz'),
os.path.join( cenc_freesurfer_dir, cenc_participant_id, 'mri', 'brainmask.mgz'),
os.path.join( cenc_freesurfer_dir, cenc_participant_id, 'mri', 'aparc.a2009s+aseg.mgz'),
os.path.join( cenc_freesurfer_dir, cenc_participant_id, 'mri', 'wmparc.mgz')
]
# Check if files exist
print files_to_convert
if util.check_files(files_to_convert, True) == False:
sys.exit()
# Create link to directory
freesurfer_results_dir = os.path.abspath(os.path.join( cenc_participant_dir, 'freesurfer','results'))
if not os.path.exists(freesurfer_results_dir):
util.force_symbolic_link( os.path.join( cenc_freesurfer_dir, cenc_participant_id ), freesurfer_results_dir)
# TODO use input node to run this instead of a loop. The trick part is to have the files named correctly.
for ii in files_to_convert:
mc = fs.MRIConvert( in_file = ii,
out_file = os.path.join( cenc_results_dir, str.replace( os.path.basename(ii),'.mgz','.nii.gz')),
out_type = 'niigz'
)
mc.run()
reorient = fsl.Reorient2Std( in_file = mc.inputs.out_file, out_file = mc.inputs.out_file)
reorient.run()
# Create final brain mask.
cenc.create_mask( os.path.join( cenc_results_dir, 'brainmask.nii.gz'),
os.path.join( cenc_results_dir, 'aparc.a2009s+aseg.nii.gz'),
os.path.join( cenc_results_dir, 'mask.nii.gz')
)
# Extract labels for Further processing
cenc_results_labels_dir = os.path.join(cenc_results_dir, 'labels')
util.mkcd_dir( cenc_results_labels_dir, 'labels') )
def results(cenc_participant_id, cenc_participant_dir, cenc_freesurfer_dir,cenc_results_dir, verbose):
util.mkcd_dir( [ cenc_results_dir ], True)
files_to_convert = [ os.path.join( cenc_freesurfer_dir, cenc_participant_id, 'mri', 'nu.mgz'),
os.path.join( cenc_freesurfer_dir, cenc_participant_id, 'mri', 'aseg.mgz'),
os.path.join( cenc_freesurfer_dir, cenc_participant_id, 'mri', 'brainmask.mgz'),
os.path.join( cenc_freesurfer_dir, cenc_participant_id, 'mri', 'aparc.a2009s+aseg.mgz'),
os.path.join( cenc_freesurfer_dir, cenc_participant_id, 'mri', 'wmparc.mgz')
]
# Check if files exist
print files_to_convert
if util.check_files(files_to_convert, True) == False:
sys.exit()
# Create link to directory
freesurfer_results_dir = os.path.abspath(os.path.join( cenc_participant_dir, 'freesurfer','results'))
if not os.path.exists(freesurfer_results_dir):
util.force_symbolic_link( os.path.join( cenc_freesurfer_dir, cenc_participant_id ), freesurfer_results_dir)
# TODO use input node to run this instead of a loop
mc = Node( fs.MRIConvert( out_type = 'niigz'
),
name="mri_convert"
)
mc.iterables = ( "in_file", files_to_convert )
reorient = Node( fsl.Reorient2Std(), name="reorient" )
workflow_convert = Workflow(name='cenc_freesurfer_nipype_workflow')
workflow_convert.base_dir = cenc_results_dir
workflow_convert.connect( [ (mc, reorient, [('out_file', 'in_file')] )]
)
workflow_convert.run()
# Create final brain mask. This takes forever. Speeding it up would be helpful.
cenc.create_mask( os.path.join( cenc_results_dir, 'brainmask.nii.gz'),
os.path.join( cenc_results_dir, 'aparc.a2009s+aseg.nii.gz'),
os.path.join( cenc_results_dir, 'mask.nii.gz')
)
def create_images_workflow():
# Correct for the sphinx position and use reorient to standard.
workflow = Workflow(name='minimal_proc')
inputs = Node(IdentityInterface(fields=['images']), name="in")
outputs = Node(IdentityInterface(fields=['images']), name="out")
sphinx = MapNode(fs.MRIConvert(sphinx=True),
iterfield=['in_file'],
name='sphinx')
workflow.connect(inputs, 'images', sphinx, 'in_file')
ro = MapNode(fsl.Reorient2Std(), iterfield=['in_file'], name='ro')
workflow.connect(sphinx, 'out_file', ro, 'in_file')
workflow.connect(ro, 'out_file', outputs, 'images')
return workflow
def create_converter_structural_pipeline(working_dir,
ds_dir,
name='converter_struct'):
# initiate workflow
converter_wf = Workflow(name=name)
converter_wf.base_dir = os.path.join(working_dir, 'LeiCA_resting')
# set fsl output
fsl.FSLCommand.set_default_output_type('NIFTI_GZ')
# inputnode
inputnode = Node(util.IdentityInterface(fields=['t1w_dicom']),
name='inputnode')
outputnode = Node(util.IdentityInterface(fields=['t1w']),
name='outputnode')
niftisink = Node(nio.DataSink(), name='niftisink')
niftisink.inputs.base_directory = os.path.join(ds_dir, 'raw_niftis')
# convert to nifti
# todo check if geometry bugs attac. use dcm2nii?
converter_t1w = Node(DcmStack(embed_meta=True), name='converter_t1w')
converter_t1w.plugin_args = {'submit_specs': 'request_memory = 2000'}
converter_t1w.inputs.out_format = 't1w'
converter_wf.connect(inputnode, 't1w_dicom', converter_t1w, 'dicom_files')
# reorient to standard orientation
reor_2_std = Node(fsl.Reorient2Std(), name='reor_2_std')
converter_wf.connect(converter_t1w, 'out_file', reor_2_std, 'in_file')
converter_wf.connect(reor_2_std, 'out_file', outputnode, 't1w')
# save original niftis
converter_wf.connect(reor_2_std, 'out_file', niftisink, 'sMRI')
converter_wf.write_graph(dotfilename='converter_struct',
graph2use='flat',
format='pdf')
return converter_wf
def nipype_reconall(t1path, t2path=None):
splitpath = t1path.split(os.sep)
# Reorientation using FSL
reodir = os.path.join(BIDS_DATA_DIR, "derivatives",
"reorient_{0}".format(splitpath[-3]), splitpath[-4])
if not os.path.isdir(reodir):
os.makedirs(reodir)
reopath = []
for path in (t1path, t2path):
if path is not None:
reopath.append(os.path.join(reodir, os.path.basename(path)))
else:
reopath.append(None)
continue
reorient = fsl.Reorient2Std(in_file=path, out_file=reopath[-1])
if PROCESS:
reorient.run()
t1path, t2path = reopath
# Segmentation using FreeSurfer
fsdir = os.path.join(BIDS_DATA_DIR, "derivatives",
"freesurfer_{0}".format(splitpath[-3]))
if not os.path.isdir(fsdir):
os.makedirs(fsdir)
reconall = freesurfer.ReconAll(subject_id=splitpath[-4],
directive="all",
subjects_dir=fsdir,
T1_files=t1path)
if t2path is not None:
reconall.inputs.T2_file = t2path
reconall.inputs.use_T2 = True
if PROCESS:
reconall.run()
return reconall.cmdline
def do_pipe3_projection(subject_ID,
freesurfer_dir,
workflow_dir,
output_dir,
tract_number,
use_sample=False):
"""
Packages and Data Setup
=======================
Import necessary modules from nipype.
"""
import nipype.interfaces.io as io # Data i/o
import nipype.interfaces.utility as util # utility
import nipype.pipeline.engine as pe # pipeline engine
import nipype.interfaces.fsl as fsl
import nipype.interfaces.freesurfer as fsurf # freesurfer
import nipype.interfaces.ants as ants
import os.path as op # system functions
from nipype.interfaces.utility import Function
from dmri_pipe_aux import get_connectivity_matrix
from dmri_pipe_aux import surf2file
from dmri_pipe_aux import voxels2nii
from dmri_pipe_aux import normalize_matrix
from dmri_pipe_aux import interface2surf
from dmri_pipe_aux import read_voxels
from dmri_pipe_aux import downsample_matrix
from dmri_pipe_aux import merge_matrices
"""""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """
Point to the freesurfer subjects directory (Recon-all must have been run on the subjects)
""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """"""
subjects_dir = op.abspath(freesurfer_dir)
fsurf.FSCommand.set_default_subjects_dir(subjects_dir)
fsl.FSLCommand.set_default_output_type('NIFTI')
"""""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """
define the workflow
""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """"""
dmripipeline = pe.Workflow(name='pipe3_projection')
"""""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """
Use datasource node to perform the actual data grabbing.
Templates for the associated images are used to obtain the correct images.
""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """"""
data_template = subject_ID + "/%s/" + "%s" + "%s"
info = dict(
wm=[['fa_masking', subject_ID, '_mask_wm.nii']],
seeds_left=[['fa_masking', subject_ID, '_interface_left_voxels.txt']],
seeds_right=[['fa_masking', subject_ID,
'_interface_right_voxels.txt']],
index_left=[['fa_masking', subject_ID, '_interface_left_index.nii']],
index_right=[['fa_masking', subject_ID, '_interface_right_index.nii']],
fa=[['fa_masking', subject_ID, '_fa_masked.nii']],
t1=[['anatomy', subject_ID, '_t1_masked.nii']],
inv_flirt_mat=[['anatomy', '', 'flirt_t1_2_fa_inv.mat']],
warp=[['anatomy', '', 'ants_fa_2_regt1_Warp.nii.gz']])
datasource = pe.Node(interface=io.DataGrabber(outfields=info.keys()),
name='datasource')
datasource.inputs.template = data_template
datasource.inputs.base_directory = output_dir
datasource.inputs.template_args = info
datasource.inputs.sort_filelist = True
datasource.run_without_submitting = True
tracts_left_source = pe.Node(
interface=io.DataGrabber(outfields=['tracts_left']),
name='tracts_left_source')
tracts_left_source.inputs.template = subject_ID + '/raw_tracts/lh/probtract_*.nii'
tracts_left_source.inputs.base_directory = output_dir
tracts_left_source.inputs.sort_filelist = True
tracts_left_source.run_without_submitting = True
tracts_right_source = pe.Node(
interface=io.DataGrabber(outfields=['tracts_right']),
name='tracts_right_source')
tracts_right_source.inputs.template = subject_ID + '/raw_tracts/rh/probtract_*.nii'
tracts_right_source.inputs.base_directory = output_dir
tracts_right_source.inputs.sort_filelist = True
tracts_right_source.run_without_submitting = True
"""""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """
The input node declared here will be the main
conduits for the raw data to the rest of the processing pipeline.
""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """"""
inputnode = pe.Node(interface=util.IdentityInterface(fields=[
"wm", "seeds_left", "seeds_right", "index_left", "index_right", "fa",
"t1", "inv_flirt_mat", "warp", "tracts_left", "tracts_right"
]),
name="inputnode")
"""
read seed coordinates
"""
interface_voxels_left = pe.Node(interface=Function(
input_names=["seed_file", "use_sample"],
output_names=["seed_list"],
function=read_voxels),
name='70_interface_voxels_left')
interface_voxels_left.inputs.use_sample = use_sample
dmripipeline.connect(inputnode, "seeds_left", interface_voxels_left,
"seed_file")
interface_voxels_right = interface_voxels_left.clone(
name='70_interface_voxels_right')
dmripipeline.connect(inputnode, "seeds_right", interface_voxels_right,
"seed_file")
"""
Get the direct connectivity matrix
"""
connectivity_matrix = pe.Node(interface=Function(
input_names=[
"tract_list_left", "tract_list_right", "voxel_list_left",
"voxel_list_right", "max_value"
],
output_names=[
"submatrix_left_left", "submatrix_left_right",
"submatrix_right_left", "submatrix_right_right", "exclusion_list"
],
function=get_connectivity_matrix),
name='71_direct_connect_array')
connectivity_matrix.inputs.max_value = tract_number
connectivity_matrix.run_without_submitting = True
# connectivity_matrix.plugin_args={'override_specs': 'requirements = Machine == "kalifornien.cbs.mpg.de"'}
dmripipeline.connect(inputnode, "tracts_left", connectivity_matrix,
"tract_list_left")
dmripipeline.connect(inputnode, "tracts_right", connectivity_matrix,
"tract_list_right")
dmripipeline.connect(interface_voxels_left, "seed_list",
connectivity_matrix, "voxel_list_left")
dmripipeline.connect(interface_voxels_right, "seed_list",
connectivity_matrix, "voxel_list_right")
tract_exclusion_mask = pe.Node(interface=Function(
input_names=["voxel_list", "ref_image", "outfile"],
output_names=["outfile"],
function=voxels2nii),
name='72_tract_exclusion_mask')
tract_exclusion_mask.inputs.outfile = subject_ID + '_tractseed_exclusion_mask.nii'
dmripipeline.connect(inputnode, "wm", tract_exclusion_mask, "ref_image")
dmripipeline.connect(connectivity_matrix, "exclusion_list",
tract_exclusion_mask, "voxel_list")
submatrix_left_left = pe.Node(interface=Function(
input_names=["in_array", "max_value", "outfile_prefix"],
output_names=[
"mat_matrix_nat", "mat_matrix_log", "nii_matrix_nat",
"nii_matrix_log"
],
function=normalize_matrix),
name='73_submatrix_left_left')
submatrix_left_left.run_without_submitting = True
submatrix_left_left.inputs.max_value = tract_number
submatrix_left_left.inputs.outfile_prefix = 'directconnect_left_left'
dmripipeline.connect(connectivity_matrix, "submatrix_left_left",
submatrix_left_left, "in_array")
submatrix_left_right = submatrix_left_left.clone(
name='73_submatrix_left_right')
submatrix_left_right.inputs.outfile_prefix = 'directconnect_left_right'
dmripipeline.connect(connectivity_matrix, "submatrix_left_right",
submatrix_left_right, "in_array")
submatrix_right_left = submatrix_left_left.clone(
name='73_submatrix_right_left')
submatrix_right_left.inputs.outfile_prefix = 'directconnect_right_left'
dmripipeline.connect(connectivity_matrix, "submatrix_right_left",
submatrix_right_left, "in_array")
submatrix_right_right = submatrix_left_left.clone(
name='73_submatrix_right_right')
submatrix_right_right.inputs.outfile_prefix = 'directconnect_right_right'
dmripipeline.connect(connectivity_matrix, "submatrix_right_right",
submatrix_right_right, "in_array")
# full_matrix_nat = pe.Node(interface=Function(input_names=["sm_left_left", "sm_left_right","sm_right_left", "sm_right_right", "out_filename"], output_names=["out_file"], function=merge_matrices), name='73_full_matrix_nat')
# full_matrix_nat.inputs.out_filename = 'directconnect_full_nat.mat'
# full_matrix_nat.run_without_submitting = True
# dmripipeline.connect(submatrix_left_left, "nii_matrix_nat", full_matrix_nat, "sm_left_left")
# dmripipeline.connect(submatrix_left_right, "nii_matrix_nat", full_matrix_nat, "sm_left_right")
# dmripipeline.connect(submatrix_right_left, "nii_matrix_nat", full_matrix_nat, "sm_right_left")
# dmripipeline.connect(submatrix_right_right, "nii_matrix_nat", full_matrix_nat, "sm_right_right")
#
# full_matrix_log = full_matrix_nat.clone(name='73_full_matrix_log')
# full_matrix_log.inputs.out_filename = 'directconnect_full_log.mat'
# full_matrix_log.run_without_submitting = True
# dmripipeline.connect(submatrix_left_left, "nii_matrix_log", full_matrix_log, "sm_left_left")
# dmripipeline.connect(submatrix_left_right, "nii_matrix_log", full_matrix_log, "sm_left_right")
# dmripipeline.connect(submatrix_right_left, "nii_matrix_log", full_matrix_log, "sm_right_left")
# dmripipeline.connect(submatrix_right_right, "nii_matrix_log", full_matrix_log, "sm_right_right")
"""
# invert and binarize tract exclusion mask and remove those voxels from the index interfaces
"""
tract_denoise_mask = pe.Node(interface=fsl.maths.MathsCommand(),
name='74_tract_denoise_mask')
tract_denoise_mask.inputs.args = '-binv'
tract_denoise_mask.run_without_submitting = True
dmripipeline.connect(tract_exclusion_mask, "outfile", tract_denoise_mask,
"in_file")
index_pruned_left = pe.Node(interface=fsl.maths.ApplyMask(),
name='75_interface_pruned_left')
index_pruned_left.inputs.out_file = subject_ID + '_interface_pruned_left.nii'
index_pruned_left.run_without_submitting = True
dmripipeline.connect(inputnode, "index_left", index_pruned_left, "in_file")
dmripipeline.connect(tract_denoise_mask, "out_file", index_pruned_left,
"mask_file")
index_pruned_right = index_pruned_left.clone(
name='75_interface_pruned_right')
index_pruned_right.inputs.out_file = subject_ID + '_interface_pruned_right.nii'
dmripipeline.connect(inputnode, "index_right", index_pruned_right,
"in_file")
dmripipeline.connect(tract_denoise_mask, "out_file", index_pruned_right,
"mask_file")
"""
# warp index image to t1 space
"""
index_warped_2_t1_left = pe.Node(interface=ants.WarpImageMultiTransform(),
name='76_index_warped_2_t1_left')
index_warped_2_t1_left.inputs.use_nearest = True
index_warped_2_t1_left.run_without_submitting = True
dmripipeline.connect([(index_pruned_left, index_warped_2_t1_left,
[('out_file', 'input_image')])])
dmripipeline.connect([(inputnode, index_warped_2_t1_left,
[('fa', 'reference_image')])])
dmripipeline.connect([(inputnode, index_warped_2_t1_left,
[('warp', 'transformation_series')])])
index_warped_2_t1_right = index_warped_2_t1_left.clone(
name='76_index_warped_2_t1_right')
dmripipeline.connect([(index_pruned_right, index_warped_2_t1_right,
[('out_file', 'input_image')])])
dmripipeline.connect([(inputnode, index_warped_2_t1_right,
[('fa', 'reference_image')])])
dmripipeline.connect([(inputnode, index_warped_2_t1_right,
[('warp', 'transformation_series')])])
index_final_2_t1_left = pe.Node(interface=fsl.ApplyXfm(),
name='77_index_final_2_t1_left')
index_final_2_t1_left.inputs.apply_xfm = True
index_final_2_t1_left.run_without_submitting = True
index_final_2_t1_left.inputs.interp = 'nearestneighbour'
index_final_2_t1_left.inputs.out_file = subject_ID + '_index_seedt1_left.nii'
dmripipeline.connect([(index_warped_2_t1_left, index_final_2_t1_left,
[("output_image", "in_file")])])
dmripipeline.connect([(inputnode, index_final_2_t1_left,
[("inv_flirt_mat", "in_matrix_file")])])
dmripipeline.connect([(inputnode, index_final_2_t1_left, [("t1",
"reference")])])
index_final_2_t1_right = index_final_2_t1_left.clone(
name='77_index_final_2_t1_right')
index_final_2_t1_right.inputs.out_file = subject_ID + '_index_seedt1_right.nii'
dmripipeline.connect([(index_warped_2_t1_right, index_final_2_t1_right,
[("output_image", "in_file")])])
dmripipeline.connect([(inputnode, index_final_2_t1_right,
[("inv_flirt_mat", "in_matrix_file")])])
dmripipeline.connect([(inputnode, index_final_2_t1_right,
[("t1", "reference")])])
"""
extra processing
"""
index_vol2surf_left = pe.Node(interface=fsurf.SampleToSurface(),
name='78_index_vol2surf_left')
index_vol2surf_left.inputs.hemi = 'lh'
index_vol2surf_left.inputs.subject_id = subject_ID
index_vol2surf_left.inputs.reg_header = True
index_vol2surf_left.inputs.interp_method = 'nearest'
index_vol2surf_left.inputs.sampling_method = 'point'
index_vol2surf_left.inputs.sampling_range = 0
index_vol2surf_left.inputs.sampling_units = 'frac'
index_vol2surf_left.inputs.surface = 'orig'
#index_vol2surf_left.inputs.cortex_mask = True
index_vol2surf_left.inputs.terminal_output = 'file'
index_vol2surf_left.inputs.out_file = subject_ID + '_index_seedt1_2surf_left.mgz'
index_vol2surf_left.run_without_submitting = True
dmripipeline.connect([(index_final_2_t1_left, index_vol2surf_left,
[('out_file', 'source_file')])])
index_vol2surf_right = index_vol2surf_left.clone(
name='78_index_vol2surf_right')
index_vol2surf_right.inputs.hemi = 'rh'
index_vol2surf_right.inputs.out_file = subject_ID + '_index_seedt1_2surf_right.mgz'
dmripipeline.connect([(index_final_2_t1_right, index_vol2surf_right,
[('out_file', 'source_file')])])
index_2_t1_reorient_left = pe.Node(interface=fsl.Reorient2Std(),
name='79_next_2_t1_reorient_left')
index_2_t1_reorient_left.inputs.out_file = subject_ID + '_index_seedt1_reorient_left.nii'
index_2_t1_reorient_left.run_without_submitting = True
dmripipeline.connect(index_final_2_t1_left, 'out_file',
index_2_t1_reorient_left, 'in_file')
index_2_t1_reorient_right = index_2_t1_reorient_left.clone(
name='79_next_2_t1_reorient_right')
index_2_t1_reorient_right.inputs.out_file = subject_ID + '_index_seedt1_reorient_right.nii'
dmripipeline.connect(index_final_2_t1_right, 'out_file',
index_2_t1_reorient_right, 'in_file')
index_interface2surf_left = pe.Node(interface=Function(
input_names=[
"interface_image", "surface_file", "cortex_label", "ref_mgz",
"out_file"
],
output_names=["out_file"],
function=interface2surf),
name='80_index_interface2surf_left')
index_interface2surf_left.inputs.surface_file = subjects_dir + '/' + subject_ID + '/surf/lh.orig'
index_interface2surf_left.inputs.cortex_label = subjects_dir + '/' + subject_ID + '/label/lh.cortex.label'
index_interface2surf_left.inputs.out_file = subject_ID + '_index_seedt1_2surf_left.mgz'
dmripipeline.connect(index_2_t1_reorient_left, 'out_file',
index_interface2surf_left, 'interface_image')
dmripipeline.connect(index_vol2surf_left, 'out_file',
index_interface2surf_left, 'ref_mgz')
index_interface2surf_right = index_interface2surf_left.clone(
name='80_index_interface2surf_right')
index_interface2surf_right.inputs.surface_file = subjects_dir + '/' + subject_ID + '/surf/rh.orig'
index_interface2surf_right.inputs.cortex_label = subjects_dir + '/' + subject_ID + '/label/rh.cortex.label'
index_interface2surf_right.inputs.out_file = subject_ID + '_index_seedt1_2surf_right.mgz'
dmripipeline.connect(index_2_t1_reorient_right, 'out_file',
index_interface2surf_right, 'interface_image')
dmripipeline.connect(index_vol2surf_right, 'out_file',
index_interface2surf_right, 'ref_mgz')
fs_indexlist_left = pe.Node(interface=Function(
input_names=["in_surface_values", "cortex_label", "out_file"],
output_names=["out_file"],
function=surf2file),
name='81_index_fsnative_left')
fs_indexlist_left.inputs.cortex_label = op.join(
freesurfer_dir, subject_ID + '/label/lh.cortex.label')
fs_indexlist_left.inputs.out_file = subject_ID + '_seed_index_fsnative_left.txt'
fs_indexlist_left.run_without_submitting = True
dmripipeline.connect([(index_interface2surf_left, fs_indexlist_left,
[("out_file", "in_surface_values")])])
fs_indexlist_right = fs_indexlist_left.clone(
name='81_index_fsnative_right')
fs_indexlist_right.inputs.cortex_label = op.join(
freesurfer_dir, subject_ID + '/label/rh.cortex.label')
fs_indexlist_right.inputs.out_file = subject_ID + '_seed_index_fsnative_right.txt'
dmripipeline.connect([(index_interface2surf_right, fs_indexlist_right,
[("out_file", "in_surface_values")])])
"""""" """""" """""" """""" """
""" """""" """""" """""" """"""
index_fsaverage5_left = pe.Node(interface=fsurf.SurfaceTransform(),
name='81_index_fsaverage5_left')
index_fsaverage5_left.inputs.hemi = 'lh'
index_fsaverage5_left.inputs.source_subject = subject_ID
index_fsaverage5_left.inputs.target_subject = 'fsaverage5'
index_fsaverage5_left.inputs.args = '--mapmethod nnf --label-src lh.cortex.label --label-trg lh.cortex.label'
index_fsaverage5_left.inputs.out_file = subject_ID + '_index_seedt1_fsaverage5_left.mgz'
#index_fsaverage5_left.run_without_submitting = True
dmripipeline.connect([(index_interface2surf_left, index_fsaverage5_left,
[('out_file', 'source_file')])])
index_fsaverage5_right = index_fsaverage5_left.clone(
name='81_index_fsaverage5_right')
index_fsaverage5_right.inputs.hemi = 'rh'
index_fsaverage5_left.inputs.args = '--mapmethod nnf --label-src rh.cortex.label --label-trg rh.cortex.label'
index_fsaverage5_right.inputs.out_file = subject_ID + '_index_seedt1_fsaverage5_right.mgz'
dmripipeline.connect([(index_interface2surf_right, index_fsaverage5_right,
[('out_file', 'source_file')])])
fs5_indexlist_left = pe.Node(interface=Function(
input_names=["in_surface_values", "cortex_label", "out_file"],
output_names=["out_file"],
function=surf2file),
name='82_index_fsav5_left')
fs5_indexlist_left.inputs.cortex_label = op.join(
freesurfer_dir, 'fsaverage5/label/lh.cortex.label')
fs5_indexlist_left.inputs.out_file = subject_ID + '_seed_index_fs5_left.txt'
#fs5_indexlist_left.run_without_submitting = True
dmripipeline.connect([(index_fsaverage5_left, fs5_indexlist_left,
[("out_file", "in_surface_values")])])
fs5_indexlist_right = fs5_indexlist_left.clone(name='82_index_fsav5_right')
fs5_indexlist_right.inputs.cortex_label = op.join(
freesurfer_dir, 'fsaverage5/label/rh.cortex.label')
fs5_indexlist_right.inputs.out_file = subject_ID + '_seed_index_fs5_right.txt'
dmripipeline.connect([(index_fsaverage5_right, fs5_indexlist_right,
[("out_file", "in_surface_values")])])
index_fsaverage4_left = pe.Node(interface=fsurf.SurfaceTransform(),
name='81_index_fsaverage4_left')
index_fsaverage4_left.inputs.hemi = 'lh'
index_fsaverage4_left.inputs.source_subject = subject_ID
index_fsaverage4_left.inputs.target_subject = 'fsaverage4'
index_fsaverage4_left.inputs.args = '--mapmethod nnf --label-src lh.cortex.label --label-trg lh.cortex.label'
index_fsaverage4_left.inputs.out_file = subject_ID + '_index_seedt1_fsaverage4_left.mgz'
#index_fsaverage4_left.run_without_submitting = True
dmripipeline.connect([(index_interface2surf_left, index_fsaverage4_left,
[('out_file', 'source_file')])])
index_fsaverage4_right = index_fsaverage4_left.clone(
name='81_index_fsaverage4_right')
index_fsaverage4_right.inputs.hemi = 'rh'
index_fsaverage4_left.inputs.args = '--mapmethod nnf --label-src rh.cortex.label --label-trg rh.cortex.label'
index_fsaverage4_right.inputs.out_file = subject_ID + '_index_seedt1_fsaverage4_right.mgz'
dmripipeline.connect([(index_interface2surf_right, index_fsaverage4_right,
[('out_file', 'source_file')])])
fs4_indexlist_left = pe.Node(interface=Function(
input_names=["in_surface_values", "cortex_label", "out_file"],
output_names=["out_file"],
function=surf2file),
name='82_index_fsav4_left')
fs4_indexlist_left.inputs.cortex_label = op.join(
freesurfer_dir, 'fsaverage4/label/lh.cortex.label')
fs4_indexlist_left.inputs.out_file = subject_ID + '_seed_index_fs4_left.txt'
#fs4_indexlist_left.run_without_submitting = True
dmripipeline.connect([(index_fsaverage4_left, fs4_indexlist_left,
[("out_file", "in_surface_values")])])
fs4_indexlist_right = fs4_indexlist_left.clone(name='82_index_fsav4_right')
fs4_indexlist_right.inputs.cortex_label = op.join(
freesurfer_dir, 'fsaverage4/label/rh.cortex.label')
fs4_indexlist_right.inputs.out_file = subject_ID + '_seed_index_fs4_right.txt'
dmripipeline.connect([(index_fsaverage4_right, fs4_indexlist_right,
[("out_file", "in_surface_values")])])
"""
downsample matrices according to fsaverage projections
"""
if (not use_sample):
connect_mat_fs4_nat_left_left = pe.Node(
interface=Function(input_names=[
"index_row_file", "index_col_file", "matrix_file",
"out_prefix", "dist2sim"
],
output_names=["out_mat", "out_nii"],
function=downsample_matrix),
name='83_connect_mat_fs4_nat_left_left')
connect_mat_fs4_nat_left_left.inputs.out_prefix = subject_ID + '_connect_fs4_nat_left_left'
connect_mat_fs4_nat_left_left.inputs.dist2sim = False
dmripipeline.connect(fs4_indexlist_left, "out_file",
connect_mat_fs4_nat_left_left, "index_row_file")
dmripipeline.connect(fs4_indexlist_left, "out_file",
connect_mat_fs4_nat_left_left, "index_col_file")
dmripipeline.connect(submatrix_left_left, "mat_matrix_nat",
connect_mat_fs4_nat_left_left, "matrix_file")
connect_mat_fs4_nat_left_right = connect_mat_fs4_nat_left_left.clone(
name='83_connect_mat_fs4_nat_left_right')
connect_mat_fs4_nat_left_right.inputs.out_prefix = subject_ID + '_connect_fs4_nat_left_right'
dmripipeline.connect(fs4_indexlist_left, "out_file",
connect_mat_fs4_nat_left_right, "index_row_file")
dmripipeline.connect(fs4_indexlist_right, "out_file",
connect_mat_fs4_nat_left_right, "index_col_file")
dmripipeline.connect(submatrix_left_right, "mat_matrix_nat",
connect_mat_fs4_nat_left_right, "matrix_file")
connect_mat_fs4_nat_right_left = connect_mat_fs4_nat_left_left.clone(
name='83_connect_mat_fs4_nat_right_left')
connect_mat_fs4_nat_right_left.inputs.out_prefix = subject_ID + '_connect_fs4_nat_right_left'
dmripipeline.connect(fs4_indexlist_right, "out_file",
connect_mat_fs4_nat_right_left, "index_row_file")
dmripipeline.connect(fs4_indexlist_left, "out_file",
connect_mat_fs4_nat_right_left, "index_col_file")
dmripipeline.connect(submatrix_right_left, "mat_matrix_nat",
connect_mat_fs4_nat_right_left, "matrix_file")
connect_mat_fs4_nat_right_right = connect_mat_fs4_nat_left_left.clone(
name='83_connect_mat_fs4_nat_right_right')
connect_mat_fs4_nat_right_right.inputs.out_prefix = subject_ID + '_connect_fs4_nat_right_right'
dmripipeline.connect(fs4_indexlist_right, "out_file",
connect_mat_fs4_nat_right_right, "index_row_file")
dmripipeline.connect(fs4_indexlist_right, "out_file",
connect_mat_fs4_nat_right_right, "index_col_file")
dmripipeline.connect(submatrix_right_right, "mat_matrix_nat",
connect_mat_fs4_nat_right_right, "matrix_file")
connect_mat_fs4_log_left_left = connect_mat_fs4_nat_left_left.clone(
name='83_connect_mat_fs4_log_left_left')
connect_mat_fs4_log_left_left.inputs.out_prefix = subject_ID + '_connect_fs4_log_left_left'
dmripipeline.connect(fs4_indexlist_left, "out_file",
connect_mat_fs4_log_left_left, "index_row_file")
dmripipeline.connect(fs4_indexlist_left, "out_file",
connect_mat_fs4_log_left_left, "index_col_file")
dmripipeline.connect(submatrix_left_left, "mat_matrix_log",
connect_mat_fs4_log_left_left, "matrix_file")
connect_mat_fs4_log_left_right = connect_mat_fs4_log_left_left.clone(
name='83_connect_mat_fs4_log_left_right')
connect_mat_fs4_log_left_right.inputs.out_prefix = subject_ID + '_connect_fs4_log_left_right'
dmripipeline.connect(fs4_indexlist_left, "out_file",
connect_mat_fs4_log_left_right, "index_row_file")
dmripipeline.connect(fs4_indexlist_right, "out_file",
connect_mat_fs4_log_left_right, "index_col_file")
dmripipeline.connect(submatrix_left_right, "mat_matrix_log",
connect_mat_fs4_log_left_right, "matrix_file")
connect_mat_fs4_log_right_left = connect_mat_fs4_log_left_left.clone(
name='83_connect_mat_fs4_log_right_left')
connect_mat_fs4_log_right_left.inputs.out_prefix = subject_ID + '_connect_fs4_log_right_left'
dmripipeline.connect(fs4_indexlist_right, "out_file",
connect_mat_fs4_log_right_left, "index_row_file")
dmripipeline.connect(fs4_indexlist_left, "out_file",
connect_mat_fs4_log_right_left, "index_col_file")
dmripipeline.connect(submatrix_right_left, "mat_matrix_log",
connect_mat_fs4_log_right_left, "matrix_file")
connect_mat_fs4_log_right_right = connect_mat_fs4_log_left_left.clone(
name='83_connect_mat_fs4_log_right_right')
connect_mat_fs4_log_right_right.inputs.out_prefix = subject_ID + '_connect_fs4_log_right_right'
dmripipeline.connect(fs4_indexlist_right, "out_file",
connect_mat_fs4_log_right_right, "index_row_file")
dmripipeline.connect(fs4_indexlist_right, "out_file",
connect_mat_fs4_log_right_right, "index_col_file")
dmripipeline.connect(submatrix_right_right, "mat_matrix_log",
connect_mat_fs4_log_right_right, "matrix_file")
# connect_mat_fs4_nat_full = pe.Node(interface=Function(input_names=["sm_left_left", "sm_left_right","sm_right_left", "sm_right_right", "out_filename"], output_names=["out_file"], function=merge_matrices), name='83_connect_mat_fs4_nat_full')
# connect_mat_fs4_nat_full.inputs.out_filename = subject_ID + '_connect_fs4_nat_full.mat'
# connect_mat_fs4_nat_full.run_without_submitting = True
# dmripipeline.connect(connect_mat_fs4_nat_left_left, "out_nii", connect_mat_fs4_nat_full, "sm_left_left")
# dmripipeline.connect(connect_mat_fs4_nat_left_right, "out_nii", connect_mat_fs4_nat_full, "sm_left_right")
# dmripipeline.connect(connect_mat_fs4_nat_right_left, "out_nii", connect_mat_fs4_nat_full, "sm_right_left")
# dmripipeline.connect(connect_mat_fs4_nat_right_right, "out_nii", connect_mat_fs4_nat_full, "sm_right_right")
#
# connect_mat_fs4_log_full = connect_mat_fs4_nat_full.clone(name='83_connect_mat_fs4_log_full')
# connect_mat_fs4_log_full.inputs.outfile_prefix = subject_ID + '_connect_fs4_log_full.mat'
# connect_mat_fs4_log_full.run_without_submitting = True
# dmripipeline.connect(connect_mat_fs4_log_left_left, "out_nii", connect_mat_fs4_log_full, "sm_left_left")
# dmripipeline.connect(connect_mat_fs4_log_left_right, "out_nii", connect_mat_fs4_log_full, "sm_left_right")
# dmripipeline.connect(connect_mat_fs4_log_right_left, "out_nii", connect_mat_fs4_log_full, "sm_right_left")
# dmripipeline.connect(connect_mat_fs4_log_right_right, "out_nii", connect_mat_fs4_log_full, "sm_right_right")
connect_mat_fs5_nat_left_left = connect_mat_fs4_nat_left_left.clone(
name='83_connect_mat_fs5_nat_left_left')
connect_mat_fs5_nat_left_left.inputs.out_prefix = subject_ID + '_connect_fs5_nat_left_left'
dmripipeline.connect(fs5_indexlist_left, "out_file",
connect_mat_fs5_nat_left_left, "index_row_file")
dmripipeline.connect(fs5_indexlist_left, "out_file",
connect_mat_fs5_nat_left_left, "index_col_file")
dmripipeline.connect(submatrix_left_left, "mat_matrix_nat",
connect_mat_fs5_nat_left_left, "matrix_file")
connect_mat_fs5_nat_left_right = connect_mat_fs5_nat_left_left.clone(
name='83_connect_mat_fs5_nat_left_right')
connect_mat_fs5_nat_left_right.inputs.out_prefix = subject_ID + '_connect_fs5_nat_left_right'
dmripipeline.connect(fs5_indexlist_left, "out_file",
connect_mat_fs5_nat_left_right, "index_row_file")
dmripipeline.connect(fs5_indexlist_right, "out_file",
connect_mat_fs5_nat_left_right, "index_col_file")
dmripipeline.connect(submatrix_left_right, "mat_matrix_nat",
connect_mat_fs5_nat_left_right, "matrix_file")
connect_mat_fs5_nat_right_left = connect_mat_fs5_nat_left_left.clone(
name='83_connect_mat_fs5_nat_right_left')
connect_mat_fs5_nat_right_left.inputs.out_prefix = subject_ID + '_connect_fs5_nat_right_left'
dmripipeline.connect(fs5_indexlist_right, "out_file",
connect_mat_fs5_nat_right_left, "index_row_file")
dmripipeline.connect(fs5_indexlist_left, "out_file",
connect_mat_fs5_nat_right_left, "index_col_file")
dmripipeline.connect(submatrix_right_left, "mat_matrix_nat",
connect_mat_fs5_nat_right_left, "matrix_file")
connect_mat_fs5_nat_right_right = connect_mat_fs5_nat_left_left.clone(
name='83_connect_mat_fs5_nat_right_right')
connect_mat_fs5_nat_right_right.inputs.out_prefix = subject_ID + '_connect_fs5_nat_right_right'
dmripipeline.connect(fs5_indexlist_right, "out_file",
connect_mat_fs5_nat_right_right, "index_row_file")
dmripipeline.connect(fs5_indexlist_right, "out_file",
connect_mat_fs5_nat_right_right, "index_col_file")
dmripipeline.connect(submatrix_right_right, "mat_matrix_nat",
connect_mat_fs5_nat_right_right, "matrix_file")
connect_mat_fs5_log_left_left = connect_mat_fs5_nat_left_left.clone(
name='83_connect_mat_fs5_log_left_left')
connect_mat_fs5_log_left_left.inputs.out_prefix = subject_ID + '_connect_fs5_log_left_left'
dmripipeline.connect(fs5_indexlist_left, "out_file",
connect_mat_fs5_log_left_left, "index_row_file")
dmripipeline.connect(fs5_indexlist_left, "out_file",
connect_mat_fs5_log_left_left, "index_col_file")
dmripipeline.connect(submatrix_left_left, "mat_matrix_log",
connect_mat_fs5_log_left_left, "matrix_file")
connect_mat_fs5_log_left_right = connect_mat_fs5_log_left_left.clone(
name='83_connect_mat_fs5_log_left_right')
connect_mat_fs5_log_left_right.inputs.out_prefix = subject_ID + '_connect_fs5_log_left_right'
dmripipeline.connect(fs5_indexlist_left, "out_file",
connect_mat_fs5_log_left_right, "index_row_file")
dmripipeline.connect(fs5_indexlist_right, "out_file",
connect_mat_fs5_log_left_right, "index_col_file")
dmripipeline.connect(submatrix_left_right, "mat_matrix_log",
connect_mat_fs5_log_left_right, "matrix_file")
connect_mat_fs5_log_right_left = connect_mat_fs5_log_left_left.clone(
name='83_connect_mat_fs5_log_right_left')
connect_mat_fs5_log_right_left.inputs.out_prefix = subject_ID + '_connect_fs5_log_right_left'
dmripipeline.connect(fs5_indexlist_right, "out_file",
connect_mat_fs5_log_right_left, "index_row_file")
dmripipeline.connect(fs5_indexlist_left, "out_file",
connect_mat_fs5_log_right_left, "index_col_file")
dmripipeline.connect(submatrix_right_left, "mat_matrix_log",
connect_mat_fs5_log_right_left, "matrix_file")
connect_mat_fs5_log_right_right = connect_mat_fs5_log_left_left.clone(
name='83_connect_mat_fs5_log_right_right')
connect_mat_fs5_log_right_right.inputs.out_prefix = subject_ID + '_connect_fs5_log_right_right'
dmripipeline.connect(fs5_indexlist_right, "out_file",
connect_mat_fs5_log_right_right, "index_row_file")
dmripipeline.connect(fs5_indexlist_right, "out_file",
connect_mat_fs5_log_right_right, "index_col_file")
dmripipeline.connect(submatrix_right_right, "mat_matrix_log",
connect_mat_fs5_log_right_right, "matrix_file")
# connect_mat_fs5_nat_full = connect_mat_fs4_nat_full.clone(name='83_connect_mat_fs5_nat_full')
# connect_mat_fs5_nat_full.inputs.outfile_prefix = subject_ID + '_connect_fs5_nat_full.mat'
# connect_mat_fs5_nat_full.run_without_submitting = True
# dmripipeline.connect(connect_mat_fs5_nat_left_left, "out_nii", connect_mat_fs5_nat_full, "sm_left_left")
# dmripipeline.connect(connect_mat_fs5_nat_left_right, "out_nii", connect_mat_fs5_nat_full, "sm_left_right")
# dmripipeline.connect(connect_mat_fs5_nat_right_left, "out_nii", connect_mat_fs5_nat_full, "sm_right_left")
# dmripipeline.connect(connect_mat_fs5_nat_right_right, "out_nii", connect_mat_fs5_nat_full, "sm_right_right")
#
# connect_mat_fs5_log_full = connect_mat_fs5_nat_full.clone(name='83_connect_mat_fs5_log_full')
# connect_mat_fs5_log_full.inputs.out_filename = subject_ID + '_connect_fs5_log_full.mat'
# connect_mat_fs5_log_full.run_without_submitting = True
# dmripipeline.connect(connect_mat_fs5_log_left_left, "out_nii", connect_mat_fs5_log_full, "sm_left_left")
# dmripipeline.connect(connect_mat_fs5_log_left_right, "out_nii", connect_mat_fs5_log_full, "sm_left_right")
# dmripipeline.connect(connect_mat_fs5_log_right_left, "out_nii", connect_mat_fs5_log_full, "sm_right_left")
# dmripipeline.connect(connect_mat_fs5_log_right_right, "out_nii", connect_mat_fs5_log_full, "sm_right_right")
#
"""
use a sink to save outputs
"""
datasink = pe.Node(io.DataSink(), name='99_datasink')
datasink.inputs.base_directory = output_dir
datasink.inputs.container = subject_ID
datasink.inputs.parameterization = True
#datasink.run_without_submitting = True
dmripipeline.connect(index_pruned_left, 'out_file', datasink,
'interface_index.@3')
dmripipeline.connect(index_pruned_right, 'out_file', datasink,
'interface_index.@4')
dmripipeline.connect(index_final_2_t1_left, 'out_file', datasink,
'interface_index.@5')
dmripipeline.connect(index_final_2_t1_right, 'out_file', datasink,
'interface_index.@6')
dmripipeline.connect(index_interface2surf_left, 'out_file', datasink,
'interface_index.@7')
dmripipeline.connect(index_interface2surf_right, 'out_file', datasink,
'interface_index.@8')
dmripipeline.connect(index_fsaverage5_left, 'out_file', datasink,
'interface_index.@9')
dmripipeline.connect(index_fsaverage5_right, 'out_file', datasink,
'interface_index.@10')
dmripipeline.connect(fs5_indexlist_left, 'out_file', datasink,
'interface_index.@11')
dmripipeline.connect(fs5_indexlist_right, 'out_file', datasink,
'interface_index.@12')
dmripipeline.connect(index_fsaverage4_left, 'out_file', datasink,
'interface_index.@13')
dmripipeline.connect(index_fsaverage4_right, 'out_file', datasink,
'interface_index.@14')
dmripipeline.connect(fs4_indexlist_left, 'out_file', datasink,
'interface_index.@15')
dmripipeline.connect(fs4_indexlist_right, 'out_file', datasink,
'interface_index.@16')
dmripipeline.connect(fs_indexlist_left, 'out_file', datasink,
'interface_index.@17')
dmripipeline.connect(fs_indexlist_right, 'out_file', datasink,
'interface_index.@18')
dmripipeline.connect(tract_exclusion_mask, 'outfile', datasink,
'interface_index.@19')
# dmripipeline.connect(submatrix_left_left, 'mat_matrix_nat', datasink, 'connect_matrix.native.mat')
# dmripipeline.connect(submatrix_left_left, 'mat_matrix_log', datasink, 'connect_matrix.native.mat.@2')
dmripipeline.connect(submatrix_left_left, 'nii_matrix_nat', datasink,
'connect_matrix.native.@3')
dmripipeline.connect(submatrix_left_left, 'nii_matrix_log', datasink,
'connect_matrix.native.@4')
# dmripipeline.connect(submatrix_right_right, 'mat_matrix_nat', datasink, 'connect_matrix.native.mat.@5')
# dmripipeline.connect(submatrix_right_right, 'mat_matrix_log', datasink, 'connect_matrix.native.mat.@6')
dmripipeline.connect(submatrix_right_right, 'nii_matrix_nat', datasink,
'connect_matrix.native.@7')
dmripipeline.connect(submatrix_right_right, 'nii_matrix_log', datasink,
'connect_matrix.native.@8')
# dmripipeline.connect(submatrix_left_right, 'mat_matrix_nat', datasink, 'connect_matrix.native.mat')
# dmripipeline.connect(submatrix_left_right, 'mat_matrix_log', datasink, 'connect_matrix.native.mat.@2')
dmripipeline.connect(submatrix_left_right, 'nii_matrix_nat', datasink,
'connect_matrix.native.@9')
dmripipeline.connect(submatrix_left_right, 'nii_matrix_log', datasink,
'connect_matrix.native.@10')
# dmripipeline.connect(submatrix_right_left, 'mat_matrix_nat', datasink, 'connect_matrix.native.mat')
# dmripipeline.connect(submatrix_right_left, 'mat_matrix_log', datasink, 'connect_matrix.native.mat.@2')
dmripipeline.connect(submatrix_right_left, 'nii_matrix_nat', datasink,
'connect_matrix.native.@11')
dmripipeline.connect(submatrix_right_left, 'nii_matrix_log', datasink,
'connect_matrix.native.@12')
# dmripipeline.connect(full_matrix_nat, 'out_file', datasink, 'connect_matrix.native.@9')
# dmripipeline.connect(full_matrix_log, 'out_file', datasink, 'connect_matrix.native.@11')
if (not use_sample):
# dmripipeline.connect(connect_mat_fs4_nat_left_left, 'out_mat', datasink, 'connect_matrix.fs4.mat.@1')
# dmripipeline.connect(connect_mat_fs4_log_left_left, 'out_mat', datasink, 'connect_matrix.fs4.mat.@2')
# dmripipeline.connect(connect_mat_fs4_nat_right_right, 'out_mat', datasink, 'connect_matrix.fs4.mat.@3')
# dmripipeline.connect(connect_mat_fs4_log_right_right, 'out_mat', datasink, 'connect_matrix.fs4.mat.@4')
# dmripipeline.connect(connect_mat_fs4_nat_left_right, 'out_mat', datasink, 'connect_matrix.fs4.mat.@5')
# dmripipeline.connect(connect_mat_fs4_log_left_right, 'out_mat', datasink, 'connect_matrix.fs4.mat.@6')
# dmripipeline.connect(connect_mat_fs4_nat_right_left, 'out_mat', datasink, 'connect_matrix.fs4.mat.@7')
# dmripipeline.connect(connect_mat_fs4_log_right_left, 'out_mat', datasink, 'connect_matrix.fs4.mat.@8')
dmripipeline.connect(connect_mat_fs4_nat_left_left, 'out_nii',
datasink, 'connect_matrix.fs4.@1')
dmripipeline.connect(connect_mat_fs4_log_left_left, 'out_nii',
datasink, 'connect_matrix.fs4.@2')
dmripipeline.connect(connect_mat_fs4_nat_right_right, 'out_nii',
datasink, 'connect_matrix.fs4.@3')
dmripipeline.connect(connect_mat_fs4_log_right_right, 'out_nii',
datasink, 'connect_matrix.fs4.@4')
dmripipeline.connect(connect_mat_fs4_nat_left_right, 'out_nii',
datasink, 'connect_matrix.fs4.@5')
dmripipeline.connect(connect_mat_fs4_log_left_right, 'out_nii',
datasink, 'connect_matrix.fs4.@6')
dmripipeline.connect(connect_mat_fs4_nat_right_left, 'out_nii',
datasink, 'connect_matrix.fs4.@7')
dmripipeline.connect(connect_mat_fs4_log_right_left, 'out_nii',
datasink, 'connect_matrix.fs4.@8')
# dmripipeline.connect(connect_mat_fs4_nat_full, 'out_file', datasink, 'connect_matrix.@28')
# dmripipeline.connect(connect_mat_fs4_log_full, 'out_file', datasink, 'connect_matrix.@30')
# dmripipeline.connect(connect_mat_fs5_nat_left_left, 'out_mat', datasink, 'connect_matrix.fs5.mat.@1')
# dmripipeline.connect(connect_mat_fs5_log_left_left, 'out_mat', datasink, 'connect_matrix.fs5.mat.@2')
# dmripipeline.connect(connect_mat_fs5_nat_right_right, 'out_mat', datasink, 'connect_matrix.fs5.mat.@3')
# dmripipeline.connect(connect_mat_fs5_log_right_right, 'out_mat', datasink, 'connect_matrix.fs5.mat.@4')
# dmripipeline.connect(connect_mat_fs5_nat_left_right, 'out_mat', datasink, 'connect_matrix.fs5.mat.@5')
# dmripipeline.connect(connect_mat_fs5_log_left_right, 'out_mat', datasink, 'connect_matrix.fs5.mat.@6')
# dmripipeline.connect(connect_mat_fs5_nat_right_left, 'out_mat', datasink, 'connect_matrix.fs5.mat.@7')
# dmripipeline.connect(connect_mat_fs5_log_right_left, 'out_mat', datasink, 'connect_matrix.fs5.mat.@8')
dmripipeline.connect(connect_mat_fs5_nat_left_left, 'out_nii',
datasink, 'connect_matrix.fs5.@1')
dmripipeline.connect(connect_mat_fs5_log_left_left, 'out_nii',
datasink, 'connect_matrix.fs5.@2')
dmripipeline.connect(connect_mat_fs5_nat_right_right, 'out_nii',
datasink, 'connect_matrix.fs5.@3')
dmripipeline.connect(connect_mat_fs5_log_right_right, 'out_nii',
datasink, 'connect_matrix.fs5.@4')
dmripipeline.connect(connect_mat_fs5_nat_left_right, 'out_nii',
datasink, 'connect_matrix.fs5.@5')
dmripipeline.connect(connect_mat_fs5_log_left_right, 'out_nii',
datasink, 'connect_matrix.fs5.@6')
dmripipeline.connect(connect_mat_fs5_nat_right_left, 'out_nii',
datasink, 'connect_matrix.fs5.@7')
dmripipeline.connect(connect_mat_fs5_log_right_left, 'out_nii',
datasink, 'connect_matrix.fs5.@8')
# dmripipeline.connect(connect_mat_fs5_nat_full, 'out_file', datasink, 'connect_matrix.@40')
# dmripipeline.connect(connect_mat_fs5_log_full, 'out_file', datasink, 'connect_matrix.@42')
"""""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """
===============================================================================
Connecting the workflow
===============================================================================
""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """"""
"""
Create a higher-level workflow
------------------------------
Finally, we create another higher-level workflow to connect our dmripipeline workflow with the info and datagrabbing nodes
declared at the beginning. Our tutorial is now extensible to any arbitrary number of subjects by simply adding
their names to the subject list and their data to the proper folders.
"""
connectprepro = pe.Workflow(name="dmri_pipe3_projection")
connectprepro.base_dir = op.abspath(workflow_dir + "/workflow_" +
subject_ID)
connectprepro.connect([(datasource, dmripipeline,
[('wm', 'inputnode.wm'),
('seeds_left', 'inputnode.seeds_left'),
('seeds_right', 'inputnode.seeds_right'),
('t1', 'inputnode.t1'),
('warp', 'inputnode.warp'),
('inv_flirt_mat', 'inputnode.inv_flirt_mat'),
('fa', 'inputnode.fa'),
('index_left', 'inputnode.index_left'),
('index_right', 'inputnode.index_right')]),
(tracts_left_source, dmripipeline,
[('tracts_left', 'inputnode.tracts_left')]),
(tracts_right_source, dmripipeline,
[('tracts_right', 'inputnode.tracts_right')])])
return connectprepro
output_dir = 'datasink'
working_dir = '/media/harryzhang/VolumeWD/'
# list of subject identifiers
patient_list = ['540335']
# list of session identifiers
task_list = ['DWI', 'ADC', 'FLAIR', 'TTP']
# Smoothing widths to apply
fwhm = [2, 3, 4]
# main workflow
# Reorient
reorient = Node(fsl.Reorient2Std(output_type='NIFTI_GZ',
ignore_exception=True),
name='reorient')
# Bias Field Correction
N4_BFC = Node(ants.N4BiasFieldCorrection(dimension=3), name='N4_BFC')
# Smooth - image smoothing
smooth = Node(Smooth(), name="smooth")
smooth.iterables = ("fwhm", fwhm)
# coregistration Workflow
def coreg_workflow():
# BET - Skull-stripping
bet_anat = Node(fsl.BET(frac=0.2,
infosource_baseline = Node(interface=IdentityInterface(fields=['idvi']),
name="infosource_baseline")
infosource_baseline.iterables = ('idvi', idvi_baseline_list)
# get full path to MRI corresponding to idvi
getmusemri_baseline = Node(Function(input_names=['key', 'dict'],
output_names=['musemri'],
function=get_value),
name='getmusemri_baseline')
getmusemri_baseline.inputs.dict = musemri_dict
# Step 1: Spatial normalization of baseline MPRAGE onto study-specific template
# Reorient: this simply applies 90, 180, or 270 degree rotations about each axis to make the image orientation
# the same as the FSL standard
reorient = Node(interface=fsl.Reorient2Std(output_type='NIFTI'),
name="reorient")
# Use antsRegistration to compute registration between subject's baseline MPRAGE and study-specific template
antsreg = Node(ants.Registration(
args='--float',
collapse_output_transforms=True,
fixed_image=blsa_template,
initial_moving_transform_com=True,
num_threads=1,
output_inverse_warped_image=True,
output_warped_image=True,
smoothing_sigmas=[[3, 2, 1, 0]] * 3,
sigma_units=['vox'] * 3,
transforms=['Rigid', 'Affine', 'SyN'],
terminal_output='file',
def preprocess_channels_pipeline(self, **name_maps):
pipeline = self.new_pipeline(
'preprocess_channels',
name_maps=name_maps,
desc=("Convert channel signals in complex coords to polar coords "
"and combine"))
if (self.provided('header_image') or
self.branch('reorient_to_std') or
self.parameter('force_channel_flip') is not None):
# Read channel files reorient them into standard space and then
# write back to directory
list_channels = pipeline.add(
'list_channels',
ListDir(),
inputs={
'directory': ('channels', multi_nifti_gz_format)})
if self.parameter('force_channel_flip') is not None:
force_flip = pipeline.add(
'flip_dims',
fsl.SwapDimensions(
new_dims=tuple(self.parameter('force_channel_flip'))),
inputs={
'in_file': (list_channels, 'files')},
iterfield=['in_file'])
geom_dest_file = (force_flip, 'out_file')
else:
geom_dest_file = (list_channels, 'files')
if self.provided('header_image'):
# If header image is provided stomp its geometry over the
# acquired channels
copy_geom = pipeline.add(
'qsm_copy_geometry',
fsl.CopyGeom(
output_type='NIFTI_GZ'),
inputs={
'in_file': ('header_image', nifti_gz_format),
'dest_file': geom_dest_file},
iterfield=(['dest_file']),
requirements=[fsl_req.v('5.0.8')])
reorient_in_file = (copy_geom, 'out_file')
else:
reorient_in_file = geom_dest_file
if self.branch('reorient_to_std'):
reorient = pipeline.add(
'reorient_channel',
fsl.Reorient2Std(
output_type='NIFTI_GZ'),
inputs={
'in_file': reorient_in_file},
iterfield=['in_file'],
requirements=[fsl_req.v('5.0.8')])
copy_to_dir_in_files = (reorient, 'out_file')
else:
copy_to_dir_in_files = reorient_in_file
copy_to_dir = pipeline.add(
'copy_to_dir',
CopyToDir(),
inputs={
'in_files': copy_to_dir_in_files,
'file_names': (list_channels, 'files')})
to_polar_in_dir = (copy_to_dir, 'out_dir')
else:
to_polar_in_dir = ('channels', multi_nifti_gz_format)
pipeline.add(
'to_polar',
ToPolarCoords(
in_fname_re=self.parameter('channel_fname_regex'),
real_label=self.parameter('channel_real_label'),
imaginary_label=self.parameter('channel_imag_label')),
inputs={
'in_dir': to_polar_in_dir},
outputs={
'mag_channels': ('magnitudes_dir', multi_nifti_gz_format),
'phase_channels': ('phases_dir', multi_nifti_gz_format)})
return pipeline
# Initialize workflow workflow = pe.Workflow(name='anat') workflow.base_dir = '.' # Reference brain images 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' anat = data_path + subj_dirs[k] + '/session1/lesion_seg.nii.gz' # 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(in_file=anat, output_type='NIFTI_GZ'), name='reorient') #workflow.connect(deoblique, 'out_file', reorient, 'in_file') # AFNI skullstrip #skullstrip = pe.Node(interface=afni.SkullStrip(args='-no_use_edge -ld 20', 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') #workflow.connect(skullstrip, 'out_file', segmentation, 'in_files')
def define_template_workflow(info, subjects, qc=True):
# --- Workflow parameterization
subject_source = Node(IdentityInterface(["subject"]),
name="subject_source",
iterables=("subject", subjects))
# Data input
template_input = Node(TemplateInput(data_dir=info.data_dir),
"template_input")
# --- Definition of functional template space
crop_image = Node(fs.ApplyMask(args="-bb 4"), "crop_image")
zoom_image = Node(fs.MRIConvert(resample_type="cubic",
out_type="niigz",
vox_size=info.voxel_size,
),
"zoom_image")
reorient_image = Node(fsl.Reorient2Std(out_file="anat.nii.gz"),
"reorient_image")
generate_reg = Node(fs.Tkregister2(fsl_out="anat2func.mat",
reg_file="anat2func.dat",
reg_header=True),
"generate_reg")
invert_reg = Node(fs.Tkregister2(reg_file="func2anat.dat",
reg_header=True),
"invert_reg")
# --- Identification of surface vertices
hemi_source = Node(IdentityInterface(["hemi"]), "hemi_source",
iterables=("hemi", ["lh", "rh"]))
tag_surf = Node(fs.Surface2VolTransform(surf_name="graymid",
transformed_file="ribbon.nii.gz",
vertexvol_file="vertices.nii.gz",
mkmask=True),
"tag_surf")
mask_cortex = Node(MaskWithLabel(fill_value=-1), "mask_cortex")
combine_hemis = JoinNode(fsl.Merge(dimension="t",
merged_file="surf.nii.gz"),
name="combine_hemis",
joinsource="hemi_source",
joinfield="in_files")
make_ribbon = Node(MakeRibbon(), "make_ribbon")
# --- Segementation of anatomical tissue in functional space
transform_wmparc = Node(fs.ApplyVolTransform(inverse=True,
interp="nearest",
args="--keep-precision"),
"transform_wmparc")
anat_segment = Node(AnatomicalSegmentation(), "anat_segment")
# --- Template QC
template_qc = Node(TemplateReport(), "template_qc")
# --- Workflow ouptut
save_info = Node(SaveInfo(info_dict=info.trait_get()), "save_info")
template_output = Node(DataSink(base_directory=info.proc_dir,
parameterization=False),
"template_output")
# === Assemble pipeline
workflow = Workflow(name="template", base_dir=info.cache_dir)
processing_edges = [
(subject_source, template_input,
[("subject", "subject")]),
(template_input, crop_image,
[("norm_file", "in_file"),
("wmparc_file", "mask_file")]),
(crop_image, zoom_image,
[("out_file", "in_file")]),
(zoom_image, reorient_image,
[("out_file", "in_file")]),
(subject_source, generate_reg,
[("subject", "subject_id")]),
(template_input, generate_reg,
[("norm_file", "moving_image")]),
(reorient_image, generate_reg,
[("out_file", "target_image")]),
(subject_source, invert_reg,
[("subject", "subject_id")]),
(template_input, invert_reg,
[("norm_file", "target_image")]),
(reorient_image, invert_reg,
[("out_file", "moving_image")]),
(hemi_source, tag_surf,
[("hemi", "hemi")]),
(invert_reg, tag_surf,
[("reg_file", "reg_file")]),
(reorient_image, tag_surf,
[("out_file", "template_file")]),
(template_input, mask_cortex,
[("label_files", "label_files")]),
(hemi_source, mask_cortex,
[("hemi", "hemi")]),
(tag_surf, mask_cortex,
[("vertexvol_file", "in_file")]),
(mask_cortex, combine_hemis,
[("out_file", "in_files")]),
(combine_hemis, make_ribbon,
[("merged_file", "in_file")]),
(reorient_image, transform_wmparc,
[("out_file", "source_file")]),
(template_input, transform_wmparc,
[("wmparc_file", "target_file")]),
(invert_reg, transform_wmparc,
[("reg_file", "reg_file")]),
(reorient_image, anat_segment,
[("out_file", "anat_file")]),
(transform_wmparc, anat_segment,
[("transformed_file", "wmparc_file")]),
(combine_hemis, anat_segment,
[("merged_file", "surf_file")]),
(template_input, template_output,
[("output_path", "container")]),
(reorient_image, template_output,
[("out_file", "@anat")]),
(generate_reg, template_output,
[("fsl_file", "@anat2func")]),
(anat_segment, template_output,
[("seg_file", "@seg"),
("lut_file", "@lut"),
("edge_file", "@edge"),
("mask_file", "@mask")]),
(combine_hemis, template_output,
[("merged_file", "@surf")]),
(make_ribbon, template_output,
[("out_file", "@ribon")]),
]
workflow.connect(processing_edges)
# Optionally connect QC nodes
qc_edges = [
(reorient_image, template_qc,
[("out_file", "anat_file")]),
(combine_hemis, template_qc,
[("merged_file", "surf_file")]),
(anat_segment, template_qc,
[("lut_file", "lut_file"),
("seg_file", "seg_file"),
("edge_file", "edge_file"),
("mask_file", "mask_file")]),
(subject_source, save_info,
[("subject", "parameterization")]),
(save_info, template_output,
[("info_file", "qc.@info_json")]),
(template_qc, template_output,
[("seg_plot", "qc.@seg_plot"),
("mask_plot", "qc.@mask_plot"),
("edge_plot", "qc.@edge_plot"),
("surf_plot", "qc.@surf_plot"),
("anat_plot", "qc.@anat_plot")]),
]
if qc:
workflow.connect(qc_edges)
return workflow
from nipype.pipeline.engine import Workflow, Node, MapNode
import nipype.interfaces.fsl as fsl
import nipype.interfaces.spm as spm
#Matlab and SPM configuration
# Set the way matlab should be called
# mlab.MatlabCommand.set_default_matlab_cmd("matlab -nodesktop -nosplash -nojvm -noFigureWindows")
spm_path = '/opt/spm12'
mlab.MatlabCommand.set_default_matlab_cmd("matlab -nodesktop -nosplash")
mlab.MatlabCommand.set_default_paths(spm_path)
# Nodes
ro = Node(interface=fsl.Reorient2Std(output_type='NIFTI'), name='ro')
seg = Node(interface=spm.Segment(csf_output_type=[False, False, True],
gm_output_type=[False, False, True],
wm_output_type=[False, False, True],
save_bias_corrected=True),
name="segment")
# Connections:
segment = Workflow(name='Segment', base_dir='./')
segment.connect(ro, 'out_file', seg, 'data')
# Example connection to the main Workflow:
# main = Workflow(name='main', base_dir=w_dir)
# main.connect(infosource, 'subject_id', datasource, 'subject_id')
# main.connect(datasource, 'nii', segment, 'ro.in_file')
# main.connect(segment, 'seg.bias_corrected_image', sink, '@bias_corr')
# main.connect(segment, 'seg.native_csf_image', sink, '@csf')
# main.connect(segment, 'seg. native_gm_image', sink, '@gm')
def make_workflow(self):
# Infosource: Iterate through subject names
infosource = Node(interface=IdentityInterface(fields=['subject_str']),
name="infosource")
infosource.iterables = ('subject_str', self.subject_list)
# Infosource: Iterate through subject names
#imgsrc = Node(interface=IdentityInterface(fields=['img']), name="imgsrc")
#imgsrc.iterables = ('img', ['uni'])
parse_scanner_dir = Node(
interface=ParseScannerDir(raw_data_dir=self.raw_data_dir),
name='parse_scanner_dir')
ro = Node(interface=fsl.Reorient2Std(), name='ro')
mv_uni = Node(interface=Rename(format_string='uni_'), name='mv_uni')
mv_uniden = Node(interface=Rename(format_string='uniden'),
name='mv_uniden')
mv_flair = Node(interface=Rename(format_string='flair'),
name='mv_flair')
mv_bold = Node(interface=Rename(format_string='bold_'), name='mv_bold')
mv_boldmag1 = Node(interface=Rename(format_string='boldmag1'),
name='mv_boldmag1')
mv_boldmag2 = Node(interface=Rename(format_string='boldmag2'),
name='mv_boldmag2')
mv_phasediff = Node(interface=Rename(format_string='boldphdiff'),
name='mv_phasediff')
sink = Node(interface=DataSink(), name='sink')
sink.inputs.base_directory = self.bids_root
#sink.inputs.substitutions = [('mp2rage075iso', '{}'.format(str(sink.inputs._outputs.keys()))),
# ('uni', 'uni.nii.gz')]#,
# ('_uniden_DEN', ''),
# ('DEN_mp2rage_orig_reoriented_masked_maths', 'mUNIbrain_DENskull_SPMmasked'),
# ('_mp2rage_orig_reoriented_maths_maths_bin', '_brain_bin')]
sink.inputs.regexp_substitutions = [
(r'_subject_str_2(?P<subid>[0-9][0-9][0-9])T(?P<sesid>[0-9])/uni_',
r'sub-NeuroMET\g<subid>/ses-0\g<sesid>/anat/sub-NeuroMET\g<subid>_ses-0\g<sesid>_T1w.nii.gz'
),
(r'_subject_str_2(?P<subid>[0-9][0-9][0-9])T(?P<sesid>[0-9])/uniden',
r'/derivatives/Siemens/sub-NeuroMET\g<subid>/ses-0\g<sesid>/anat/sub-NeuroMET\g<subid>_ses-0\g<sesid>_desc-UNIDEN.nii.gz'
),
(r'_subject_str_2(?P<subid>[0-9][0-9][0-9])T(?P<sesid>[0-9])/flair',
r'sub-NeuroMET\g<subid>/ses-0\g<sesid>/anat/sub-NeuroMET\g<subid>_ses-0\g<sesid>_FLAIR.nii.gz'
),
(r'_subject_str_2(?P<subid>[0-9][0-9][0-9])T(?P<sesid>[0-9])/bold_',
r'sub-NeuroMET\g<subid>/ses-0\g<sesid>/func/sub-NeuroMET\g<subid>_ses-0\g<sesid>_task-rest_bold.nii.gz'
),
(r'_subject_str_2(?P<subid>[0-9][0-9][0-9])T(?P<sesid>[0-9])/boldmag1',
r'sub-NeuroMET\g<subid>/ses-0\g<sesid>/fmap/sub-NeuroMET\g<subid>_ses-0\g<sesid>_magnitude1.nii.gz'
),
(r'_subject_str_2(?P<subid>[0-9][0-9][0-9])T(?P<sesid>[0-9])/boldmag2',
r'sub-NeuroMET\g<subid>/ses-0\g<sesid>/fmap/sub-NeuroMET\g<subid>_ses-0\g<sesid>_magnitude2.nii.gz'
),
(r'_subject_str_2(?P<subid>[0-9][0-9][0-9])T(?P<sesid>[0-9])/boldphdiff',
r'sub-NeuroMET\g<subid>/ses-0\g<sesid>/fmap/sub-NeuroMET\g<subid>_ses-0\g<sesid>_phasediff.nii.gz'
),
]
# (r'c1{prefix}(.*).UNI_brain_bin.nii.gz'.format(prefix=self.project_prefix),
# r'{prefix}\1.UNI_brain_bin.nii.gz'.format(prefix=self.project_prefix)),
# (r'c1{prefix}(.*).DEN_brain_bin.nii.gz'.format(prefix=self.project_prefix),
# r'{prefix}\1.DEN_brain_bin.nii.gz'.format(prefix=self.project_prefix))]
scanner_to_bids = Workflow(name='scanner_to_bids',
base_dir=self.temp_dir)
#scanner_to_bids.connect(imgsrc, 'img', mv, 'format_string')
scanner_to_bids.connect(infosource, 'subject_str', parse_scanner_dir,
'subject_id')
scanner_to_bids.connect(parse_scanner_dir, 'uni', mv_uni, 'in_file')
scanner_to_bids.connect(parse_scanner_dir, 'uniden', mv_uniden,
'in_file')
scanner_to_bids.connect(parse_scanner_dir, 'flair', mv_flair,
'in_file')
scanner_to_bids.connect(parse_scanner_dir, 'bold', mv_bold, 'in_file')
scanner_to_bids.connect(parse_scanner_dir, 'boldmag1', mv_boldmag1,
'in_file')
scanner_to_bids.connect(parse_scanner_dir, 'boldmag2', mv_boldmag2,
'in_file')
scanner_to_bids.connect(parse_scanner_dir, 'boldphdiff', mv_phasediff,
'in_file')
scanner_to_bids.connect(mv_uni, 'out_file', sink, '@uni')
scanner_to_bids.connect(mv_uniden, 'out_file', sink, '@uniden')
scanner_to_bids.connect(mv_flair, 'out_file', sink, '@flair')
scanner_to_bids.connect(mv_bold, 'out_file', sink, '@bold')
scanner_to_bids.connect(mv_boldmag1, 'out_file', sink, '@boldmag1')
scanner_to_bids.connect(mv_boldmag2, 'out_file', sink, '@boldmag2')
scanner_to_bids.connect(mv_phasediff, 'out_file', sink, '@phasediff')
return scanner_to_bids
subject = input('Please enter the subject ID: ')
home = '/Volumes/iang/active/BABIES/BABIES_MAMA'
t1w = home + '/' + subject + '/t1w'
dest = home + '/' + subject + '/anat'
func1 = home + '/' + subject + '/func/run1'
func2 = home + '/' + subject + '/func/run2'
copyfile((t1w + '/t1w_raw.nii.gz'), (dest + '/t1w_raw.nii.gz'))
# In[10]:
reorient = Node(fsl.Reorient2Std(in_file=(dest + '/t1w_raw.nii.gz'),
out_file=(dest + '/spgrorient.nii.gz'),
output_type='NIFTI_GZ'),
name='reorient')
reorient.run()
# In[11]:
skullstrip = Node(fsl.BET(in_file=(dest + '/spgrorient.nii.gz'),
out_file=(dest + '/spgrbrain.nii.gz'),
robust=True,
frac=0.5,
vertical_gradient=0),
name='skullstrip')
skullstrip.run()
# In[13]:
def create_resting():
# main workflow
func_preproc = Workflow(name='resting')
inputnode = Node(util.IdentityInterface(fields=[
'subject_id', 'out_dir', 'freesurfer_dir', 'func', 'rs_mag', 'rs_ph',
'anat_head', 'anat_brain', 'anat_brain_mask', 'wmseg', 'csfseg',
'vol_to_remove', 'TR', 'highpass_freq', 'epi_resolution', 'echo_space',
'te_diff', 'fwhm', 'pe_dir', 'composite_transform', 'standard_brain',
'standard_downsampled'
]),
name='inputnode')
#Use correct subject ID from long timepoint for bbregister
def change_subject_id(subject):
import re
[subj, ses] = re.split("_", subject)
new_subject_id = subject + '.long.' + subj
return new_subject_id
change_subject_id = Node(util.Function(input_names=["subject"],
output_names=["new_subject_id"],
function=change_subject_id),
name="change_subject_id")
outputnode = Node(util.IdentityInterface(fields=[
'brain', 'brainmask', 'anat2std_transforms', 'std2anat_transforms',
'anat2std', 'anat_head', 'wmseg', 'csfseg', 'wmedge', 'subject_id'
]),
name='outputnode')
##PREPROCESSING FOR AROMA (Steps 1 - 7)
def merge_if_list(in_file):
if type(in_file) == list:
import numpy as np
import nibabel as nb
import os
from nipype.utils.filemanip import split_filename
nii1 = nb.load(in_file[0])
nii1d = nii1.get_data()
nii2 = nb.load(in_file[1])
nii2d = nii2.get_data()
x = np.concatenate((nii1d, nii2d), axis=3)
new_nii = nb.Nifti1Image(x, nii1.get_affine(), nii1.get_header())
new_nii.set_data_dtype(np.float32)
_, base, _ = split_filename(in_file[0])
nb.save(new_nii, base + "_merged.nii.gz")
return os.path.abspath(base + "_merged.nii.gz")
else:
return in_file
#if rsfmri is a list -> merge files, otherwise return single list.
merge_rs = Node(util.Function(input_names=['in_file'],
output_names=["out_file"],
function=merge_if_list),
name='merge_rs')
# node to remove first volumes
remove_vol = Node(util.Function(input_names=['in_file', 't_min'],
output_names=["out_file"],
function=strip_rois_func),
name='remove_vol')
# workflow for motion correction
moco = create_moco_pipeline()
# workflow for fieldmap correction and coregistration
fmap_coreg = create_fmap_coreg_pipeline()
# workflow for applying transformations to timeseries
transform_ts = create_transform_pipeline()
#mean intensity normalization
meanintensnorm = Node(fsl.ImageMaths(op_string='-ing 10000'),
name='meanintensnorm')
smoothing = create_smoothing_pipeline()
# connections
func_preproc.connect([
(inputnode, merge_rs, [('func', 'in_file')]),
(merge_rs, remove_vol, [('out_file', 'in_file')]),
(inputnode, remove_vol, [('vol_to_remove', 't_min')]),
(inputnode, moco, [('anat_brain_mask', 'inputnode.brainmask')]),
(remove_vol, moco, [('out_file', 'inputnode.epi')]),
(inputnode, change_subject_id, [('subject_id', 'subject')]),
(change_subject_id, fmap_coreg, [('new_subject_id',
'inputnode.fs_subject_id')]),
(inputnode, fmap_coreg, [('rs_mag', 'inputnode.mag'),
('rs_ph', 'inputnode.phase'),
('freesurfer_dir',
'inputnode.fs_subjects_dir'),
('echo_space', 'inputnode.echo_space'),
('te_diff', 'inputnode.te_diff'),
('pe_dir', 'inputnode.pe_dir'),
('anat_head', 'inputnode.anat_head'),
('anat_brain', 'inputnode.anat_brain')]),
(moco, fmap_coreg, [('outputnode.epi_mean', 'inputnode.epi_mean')]),
(remove_vol, transform_ts, [('out_file', 'inputnode.orig_ts')]),
(inputnode, transform_ts, [('anat_head', 'inputnode.anat_head')]),
(inputnode, transform_ts, [('anat_brain_mask', 'inputnode.brain_mask')
]),
(inputnode, transform_ts, [('epi_resolution', 'inputnode.resolution')
]),
(moco, transform_ts, [('outputnode.mat_moco', 'inputnode.mat_moco')]),
(fmap_coreg, transform_ts, [('outputnode.fmap_fullwarp',
'inputnode.fullwarp')]),
(transform_ts, meanintensnorm, [('outputnode.trans_ts', 'in_file')]),
(meanintensnorm, smoothing, [('out_file', 'inputnode.ts_transformed')
]),
(inputnode, smoothing, [('fwhm', 'inputnode.fwhm')])
])
##CALCULATE TRANSFORM from anatomical to standard space with FSL tools
# Anat > Standard
# register high-resolution to standard template with non-linear transform
# flirt serves as preparation for fnirt)
#reorient brain to standard (because Freesurfer space can cause problems)
reorient2std = Node(fsl.Reorient2Std(), name="reorient2std")
reorient2std_rs = Node(fsl.Reorient2Std(), name="reorient2std_rs")
reorient2std_mask = Node(fsl.Reorient2Std(), name="reorient2std_mask")
flirt_prep = Node(fsl.FLIRT(cost_func='mutualinfo', interp='trilinear'),
name='flirt_prep')
flirt_prep.inputs.interp = 'trilinear'
flirt_prep.inputs.dof = 12
fnirt = Node(fsl.FNIRT(), name='fnirt')
fnirt.inputs.field_file = True
fnirt.inputs.fieldcoeff_file = True
func_preproc.connect([
(inputnode, reorient2std, [('anat_brain', 'in_file')]),
(reorient2std, flirt_prep, [('out_file', 'in_file')]),
#(inputnode, flirt_prep, [('anat_brain', 'in_file')]),
(inputnode, flirt_prep, [('standard_brain', 'reference')]),
(flirt_prep, fnirt, [('out_matrix_file', 'affine_file')]),
(reorient2std, fnirt, [('out_file', 'in_file')]),
(inputnode, fnirt, [('standard_brain', 'ref_file')]),
])
def getcwd(subject_id):
import os
tmp = os.getcwd()
tmp = tmp[:-6]
tmp = tmp + 'ica_aroma/out' #%(subject_id)
return tmp
get_wd = Node(util.Function(input_names=['subject_id'],
output_names=["d"],
function=getcwd),
name='get_wd')
ica_aroma = Node(ICA_AROMA(), name="ica_aroma")
ica_aroma.inputs.denoise_type = 'both'
#ica_aroma.inputs.out_dir = os.getcwd()
func_preproc.connect([
(moco, ica_aroma, [('outputnode.par_moco', 'motion_parameters')]),
(smoothing, reorient2std_rs, [('outputnode.ts_smoothed', 'in_file')]),
(reorient2std_rs, ica_aroma, [('out_file', 'in_file')]),
(fnirt, ica_aroma, [('field_file', 'fnirt_warp_file')]),
(transform_ts, reorient2std_mask, [('outputnode.comb_mask_resamp',
'in_file')]),
(reorient2std_mask, ica_aroma, [('out_file', 'mask')]),
(inputnode, get_wd, [('subject_id', 'subject_id')]),
(get_wd, ica_aroma, [('d', 'out_dir')])
])
##POSTPROCESSING
postprocess = create_denoise_pipeline()
func_preproc.connect([
(reorient2std_mask, postprocess, [
('out_file', 'inputnode.brain_mask')
]), #use the correctly oriented mask
(ica_aroma, postprocess, [
('nonaggr_denoised_file', 'inputnode.epi_coreg')
]), #use the nonaggr_denoised_file
(inputnode, postprocess, [('TR', 'inputnode.tr')]),
(inputnode, postprocess, [('highpass_freq', 'inputnode.highpass_freq')
]),
(inputnode, postprocess, [('wmseg', 'inputnode.wmseg')]),
(inputnode, postprocess, [('csfseg', 'inputnode.csfseg')]),
])
#outputnode
outputnode = Node(util.IdentityInterface(fields=[
'par', 'rms', 'mean_epi', 'tsnr', 'stddev_file', 'realigned_ts',
'fmap', 'unwarped_mean_epi2fmap', 'coregistered_epi2fmap',
'fmap_fullwarp', 'epi2anat', 'epi2anat_mat', 'epi2anat_dat',
'epi2anat_mincost', 'full_transform_ts', 'full_transform_mean',
'resamp_t1', 'comb_mask_resamp', 'dvars_file', 'out_flirt_prep',
'out_matrix_flirt_prep', 'out_warped', 'out_warp_field',
'aggr_denoised_file', 'nonaggr_denoised_file', 'out_dir', 'wmcsf_mask',
'combined_motion', 'comp_regressor', 'comp_F', 'comp_pF', 'out_betas',
'ts_fullspectrum', 'ts_filtered'
]),
name='outputnode')
# connections
func_preproc.connect([
(
moco,
outputnode,
[ #('outputnode.epi_moco', 'realign.@realigned_ts'),
('outputnode.par_moco', 'par'),
('outputnode.rms_moco', 'rms'),
('outputnode.epi_moco', 'realigned_ts'),
('outputnode.epi_mean', 'mean_epi'),
('outputnode.tsnr_file', 'tsnr'),
('outputnode.stddev_file', 'stddev'),
]),
(fmap_coreg, outputnode,
[('outputnode.fmap', 'fmap'),
('outputnode.unwarped_mean_epi2fmap', 'unwarped_mean_epi2fmap'),
('outputnode.epi2fmap', 'coregistered_epi2fmap'),
('outputnode.fmap_fullwarp', 'fmap_fullwarp'),
('outputnode.epi2anat', 'epi2anat'),
('outputnode.epi2anat_mat', 'epi2anat_mat'),
('outputnode.epi2anat_dat', 'epi2anat_dat'),
('outputnode.epi2anat_mincost', 'epi2anat_mincost')]),
(transform_ts, outputnode,
[('outputnode.trans_ts', 'full_transform_ts'),
('outputnode.trans_ts_mean', 'full_transform_mean'),
('outputnode.resamp_t1', 'resamp_t1'),
('outputnode.comb_mask_resamp', 'comb_mask_resamp'),
('outputnode.out_dvars', 'dvars_file')]),
(flirt_prep, outputnode, [('out_file', 'out_flirt_prep'),
('out_matrix_file', 'out_matrix_flirt_prep')
]),
(fnirt, outputnode, [('warped_file', 'out_warped'),
('field_file', 'out_warp_field')]),
(ica_aroma, outputnode, [('aggr_denoised_file', 'aggr_denoised_file'),
('nonaggr_denoised_file',
'nonaggr_denoised_file'),
('out_dir', 'out_dir')]),
(postprocess, outputnode,
[('outputnode.wmcsf_mask', 'wmcsf_mask'),
('outputnode.combined_motion', 'combined_motion'),
('outputnode.comp_regressor', 'comp_regressor'),
('outputnode.comp_F', 'comp_F'), ('outputnode.comp_pF', 'comp_pF'),
('outputnode.out_betas', 'out_betas'),
('outputnode.ts_fullspectrum', 'ts_fullspectrum'),
('outputnode.ts_filtered', 'ts_filtered')])
])
return func_preproc
def create_converter_functional_pipeline(working_dir,
ds_dir,
name='converter_funct'):
# initiate workflow
converter_wf = Workflow(name=name)
converter_wf.base_dir = os.path.join(working_dir, 'LeiCA_resting')
# set fsl output
fsl.FSLCommand.set_default_output_type('NIFTI_GZ')
# I/O NODE
inputnode = Node(
util.IdentityInterface(fields=['epi_dicom', 'out_format']),
name='inputnode')
outputnode = Node(util.IdentityInterface(fields=['epi', 'TR_ms']),
name='outputnode')
niftisink = Node(nio.DataSink(), name='niftisink')
niftisink.inputs.base_directory = os.path.join(ds_dir, 'raw_niftis')
niftisink.inputs.substitutions = [('_TR_id_', 'TR_')]
# convert to nifti
# todo check if geometry bugs attac. use dcm2nii?
converter_epi = Node(DcmStack(embed_meta=True), name='converter_epi')
converter_epi.plugin_args = {'submit_specs': 'request_memory = 2000'}
def reformat_filename_fct(TR_str):
return 'rsfMRI_' + TR_str
reformat_filename = Node(util.Function(input_names=['TR_str'],
output_names=['filename'],
function=reformat_filename_fct),
name='reformat_filename')
converter_wf.connect(inputnode, 'out_format', reformat_filename, 'TR_str')
converter_wf.connect(inputnode, 'epi_dicom', converter_epi, 'dicom_files')
converter_wf.connect(reformat_filename, 'filename', converter_epi,
'out_format')
# reorient to standard orientation
reor_2_std = Node(fsl.Reorient2Std(), name='reor_2_std')
converter_wf.connect(converter_epi, 'out_file', reor_2_std, 'in_file')
converter_wf.connect(reor_2_std, 'out_file', outputnode, 'epi')
# save original niftis
converter_wf.connect(reor_2_std, 'out_file', niftisink, 'rsfMRI')
# GET TR FROM .nii
def check_TR_fct(TR):
print ' '
print 'check_TR_fct checks validity of TR'
print('imported TR is %s' % TR)
print ' '
try:
float(TR)
except ValueError:
isvalid_TR = 0
raise Exception(
'ERROR: TR COULD NOT AUTOMATICALLY BE EXTRACTED FROM EPI.\nEXECUTION STOPPED'
)
else:
isvalid_TR = 1
print 'TR is valid'
if isvalid_TR:
if float(TR <= 0):
raise Exception(
'ERROR: TR NOT VALID (<=0).\nEXECUTION STOPPED')
return float(TR)
get_TR = Node(ImageInfo(), name='get_TR')
converter_wf.connect(reor_2_std, 'out_file', get_TR, 'in_file')
check_TR = Node(util.Function(input_names=['TR'],
output_names=['TR_ms'],
function=check_TR_fct),
name='check_TR')
converter_wf.connect(get_TR, 'TR', check_TR, 'TR')
converter_wf.connect(check_TR, 'TR_ms', outputnode, 'TR_ms')
converter_wf.write_graph(dotfilename=converter_wf.name,
graph2use='flat',
format='pdf')
return converter_wf
def create_preprocessing_workflow(analysis_params, name='yesno_3T'):
import os.path as op
import nipype.pipeline as pe
from nipype.interfaces import fsl
from nipype.interfaces.utility import Function, Merge, IdentityInterface
from nipype.interfaces.io import SelectFiles, DataSink
from IPython import embed as shell
# Importing of custom nodes from spynoza packages; assumes that spynoza is installed:
# pip install git+https://github.com/spinoza-centre/spynoza.git@develop
from spynoza.utils import get_scaninfo, pickfirst, average_over_runs, set_nifti_intercept_slope
from spynoza.uniformization.workflows import create_non_uniformity_correct_4D_file
from spynoza.unwarping.b0.workflows import create_B0_workflow
from spynoza.motion_correction.workflows import create_motion_correction_workflow
from spynoza.registration.workflows import create_registration_workflow
from spynoza.filtering.nodes import sgfilter
from spynoza.conversion.nodes import psc
from spynoza.denoising.retroicor.workflows import create_retroicor_workflow
from spynoza.masking.workflows import create_masks_from_surface_workflow
from spynoza.glm.nodes import fit_nuisances
########################################################################################
# nodes
########################################################################################
input_node = pe.Node(
IdentityInterface(fields=[
'task', # main
'sub_id', # main
'ses_id', # main
'raw_data_dir', # main
'output_directory', # main
'sub_FS_id', # main
'FS_subject_dir', # motion correction
'RepetitionTime', # motion correction
'which_file_is_EPI_space', # motion correction
'standard_file', # registration
'topup_conf_file', # unwarping
'EchoTimeDiff', # unwarping
'EpiFactor', # unwarping
'SenseFactor', # unwarping
'WaterFatShift', # unwarping
'PhaseEncodingDirection', # unwarping
'EchoSpacing' # unwarping
'psc_func', # percent signal change
'sg_filter_window_length', # temporal filtering
'sg_filter_order', # temporal filtering
'SliceEncodingDirection', # retroicor
'PhysiologySampleRate', # retroicor
'SliceTiming', # retroicor
'SliceOrder', # retroicor
'NumberDummyScans', # retroicor
'MultiBandFactor', # retroicor
'hr_rvt', # retroicor
'av_func', # extra
'EchoTime', # extra
'bd_design_matrix_file', # extra
]),
name='inputspec')
for param in analysis_params:
exec('input_node.inputs.{} = analysis_params[param]'.format(param))
# i/o node
datasource_templates = dict(
func=
'{sub_id}/{ses_id}/func/{sub_id}_{ses_id}_task-{task}*_bold.nii.gz',
magnitude='{sub_id}/{ses_id}/fmap/{sub_id}_{ses_id}*magnitude.nii.gz',
phasediff='{sub_id}/{ses_id}/fmap/{sub_id}_{ses_id}*phasediff.nii.gz',
#physio='{sub_id}/{ses_id}/func/*{task}*physio.*',
#events='{sub_id}/{ses_id}/func/*{task}*_events.pickle',
#eye='{sub_id}/{ses_id}/func/*{task}*_eyedata.edf'
)
datasource = pe.Node(SelectFiles(datasource_templates,
sort_filelist=True,
raise_on_empty=False),
name='datasource')
output_node = pe.Node(IdentityInterface(
fields=(['temporal_filtered_files', 'percent_signal_change_files'])),
name='outputspec')
# nodes for setting the slope/intercept of incoming niftis to (1, 0)
# this is apparently necessary for the B0 map files
int_slope_B0_magnitude = pe.Node(Function(
input_names=['in_file'],
output_names=['out_file'],
function=set_nifti_intercept_slope),
name='int_slope_B0_magnitude')
int_slope_B0_phasediff = pe.Node(Function(
input_names=['in_file'],
output_names=['out_file'],
function=set_nifti_intercept_slope),
name='int_slope_B0_phasediff')
# reorient nodes
reorient_epi = pe.MapNode(interface=fsl.Reorient2Std(),
name='reorient_epi',
iterfield=['in_file'])
reorient_B0_magnitude = pe.Node(interface=fsl.Reorient2Std(),
name='reorient_B0_magnitude')
reorient_B0_phasediff = pe.Node(interface=fsl.Reorient2Std(),
name='reorient_B0_phasediff')
# bet_epi = pe.MapNode(interface=
# fsl.BET(frac=analysis_parameters['bet_f_value'], vertical_gradient = analysis_parameters['bet_g_value'],
# functional=True, mask = True), name='bet_epi', iterfield=['in_file'])
datasink = pe.Node(DataSink(), name='sinker')
datasink.inputs.parameterization = False
########################################################################################
# workflow
########################################################################################
# the actual top-level workflow
preprocessing_workflow = pe.Workflow(name=name)
preprocessing_workflow.base_dir = op.join(analysis_params['base_dir'],
'temp/')
# data source
preprocessing_workflow.connect(input_node, 'raw_data_dir', datasource,
'base_directory')
preprocessing_workflow.connect(input_node, 'sub_id', datasource, 'sub_id')
preprocessing_workflow.connect(input_node, 'ses_id', datasource, 'ses_id')
preprocessing_workflow.connect(input_node, 'task', datasource, 'task')
# and data sink
preprocessing_workflow.connect(input_node, 'output_directory', datasink,
'base_directory')
# BET (we don't do this, because we expect the raw data in the bids folder to be betted
# already for anonymization purposes)
# preprocessing_workflow.connect(datasource, 'func', bet_epi, 'in_file')
# non-uniformity correction
# preprocessing_workflow.connect(bet_epi, 'out_file', nuc, 'in_file')
# preprocessing_workflow.connect(datasource, 'func', nuc, 'in_file')
# reorient images
preprocessing_workflow.connect(datasource, 'func', reorient_epi, 'in_file')
preprocessing_workflow.connect(datasource, 'magnitude',
reorient_B0_magnitude, 'in_file')
preprocessing_workflow.connect(datasource, 'phasediff',
reorient_B0_phasediff, 'in_file')
preprocessing_workflow.connect(reorient_epi, 'out_file', datasink,
'reorient')
#B0 field correction:
if analysis_params['B0_or_topup'] == 'B0':
# set slope/intercept to unity for B0 map
preprocessing_workflow.connect(reorient_B0_magnitude, 'out_file',
int_slope_B0_magnitude, 'in_file')
preprocessing_workflow.connect(reorient_B0_phasediff, 'out_file',
int_slope_B0_phasediff, 'in_file')
#B0 field correction:
if 'EchoSpacing' in analysis_params:
B0_wf = create_B0_workflow(name='B0', scanner='siemens')
preprocessing_workflow.connect(input_node, 'EchoSpacing', B0_wf,
'inputspec.echo_spacing')
else:
B0_wf = create_B0_workflow(name='B0', scanner='philips')
preprocessing_workflow.connect(input_node, 'WaterFatShift', B0_wf,
'inputspec.wfs')
preprocessing_workflow.connect(input_node, 'EpiFactor', B0_wf,
'inputspec.epi_factor')
preprocessing_workflow.connect(input_node, 'SenseFactor', B0_wf,
'inputspec.acceleration')
preprocessing_workflow.connect(reorient_epi, 'out_file', B0_wf,
'inputspec.in_files')
preprocessing_workflow.connect(int_slope_B0_magnitude, 'out_file',
B0_wf, 'inputspec.fieldmap_mag')
preprocessing_workflow.connect(int_slope_B0_phasediff, 'out_file',
B0_wf, 'inputspec.fieldmap_pha')
preprocessing_workflow.connect(input_node, 'EchoTimeDiff', B0_wf,
'inputspec.te_diff')
preprocessing_workflow.connect(input_node, 'PhaseEncodingDirection',
B0_wf,
'inputspec.phase_encoding_direction')
preprocessing_workflow.connect(B0_wf, 'outputspec.field_coefs',
datasink, 'B0.fieldcoef')
preprocessing_workflow.connect(B0_wf, 'outputspec.out_files', datasink,
'B0')
# motion correction
motion_proc = create_motion_correction_workflow(
'moco', method=analysis_params['moco_method'])
if analysis_params['B0_or_topup'] == 'B0':
preprocessing_workflow.connect(B0_wf, 'outputspec.out_files',
motion_proc, 'inputspec.in_files')
elif analysis_params['B0_or_topup'] == 'neither':
preprocessing_workflow.connect(bet_epi, 'out_file', motion_proc,
'inputspec.in_files')
preprocessing_workflow.connect(input_node, 'RepetitionTime', motion_proc,
'inputspec.tr')
preprocessing_workflow.connect(input_node, 'output_directory', motion_proc,
'inputspec.output_directory')
preprocessing_workflow.connect(input_node, 'which_file_is_EPI_space',
motion_proc,
'inputspec.which_file_is_EPI_space')
# registration
reg = create_registration_workflow(analysis_params, name='reg')
preprocessing_workflow.connect(input_node, 'output_directory', reg,
'inputspec.output_directory')
preprocessing_workflow.connect(motion_proc, 'outputspec.EPI_space_file',
reg, 'inputspec.EPI_space_file')
preprocessing_workflow.connect(input_node, 'sub_FS_id', reg,
'inputspec.freesurfer_subject_ID')
preprocessing_workflow.connect(input_node, 'FS_subject_dir', reg,
'inputspec.freesurfer_subject_dir')
preprocessing_workflow.connect(input_node, 'standard_file', reg,
'inputspec.standard_file')
# temporal filtering
preprocessing_workflow.connect(input_node, 'sg_filter_window_length',
sgfilter, 'window_length')
preprocessing_workflow.connect(input_node, 'sg_filter_order', sgfilter,
'polyorder')
preprocessing_workflow.connect(motion_proc,
'outputspec.motion_corrected_files',
sgfilter, 'in_file')
preprocessing_workflow.connect(sgfilter, 'out_file', datasink, 'tf')
# node for percent signal change
preprocessing_workflow.connect(input_node, 'psc_func', psc, 'func')
preprocessing_workflow.connect(sgfilter, 'out_file', psc, 'in_file')
preprocessing_workflow.connect(psc, 'out_file', datasink, 'psc')
# # retroicor functionality
# if analysis_params['perform_physio'] == 1:
# retr = create_retroicor_workflow(name = 'retroicor', order_or_timing = analysis_params['retroicor_order_or_timing'])
#
# # # retroicor can take the crudest form of epi file, so that it proceeds quickly
# preprocessing_workflow.connect(datasource, 'func', retr, 'inputspec.in_files')
# preprocessing_workflow.connect(datasource, 'physio', retr, 'inputspec.phys_files')
# preprocessing_workflow.connect(input_node, 'analysis_params.nr_dummies', retr, 'inputspec.nr_dummies')
# preprocessing_workflow.connect(input_node, 'analysis_params.MultiBandFactor', retr, 'inputspec.MB_factor')
# preprocessing_workflow.connect(input_node, 'analysis_params.tr', retr, 'inputspec.tr')
# preprocessing_workflow.connect(input_node, 'analysis_params.SliceEncodingDirection', retr, 'inputspec.slice_direction')
# preprocessing_workflow.connect(input_node, 'analysis_params.SliceTiming', retr, 'inputspec.slice_timing')
# preprocessing_workflow.connect(input_node, 'analysis_params.SliceOrder', retr, 'inputspec.slice_order')
# preprocessing_workflow.connect(input_node, 'analysis_params.PhysiologySampleRate', retr, 'inputspec.phys_sample_rate')
# preprocessing_workflow.connect(input_node, 'analysis_params.hr_rvt', retr, 'inputspec.hr_rvt')
#
# # fit nuisances from retroicor
# # preprocessing_workflow.connect(retr, 'outputspec.evs', fit_nuis, 'slice_regressor_list')
# # preprocessing_workflow.connect(motion_proc, 'outputspec.extended_motion_correction_parameters', fit_nuis, 'vol_regressors')
# # preprocessing_workflow.connect(psc, 'out_file', fit_nuis, 'in_file')
#
# # preprocessing_workflow.connect(fit_nuis, 'res_file', av_r, 'in_files')
#
# preprocessing_workflow.connect(retr, 'outputspec.new_phys', datasink, 'phys.log')
# preprocessing_workflow.connect(retr, 'outputspec.fig_file', datasink, 'phys.figs')
# preprocessing_workflow.connect(retr, 'outputspec.evs', datasink, 'phys.evs')
# # preprocessing_workflow.connect(fit_nuis, 'res_file', datasink, 'phys.res')
# # preprocessing_workflow.connect(fit_nuis, 'rsq_file', datasink, 'phys.rsq')
# # preprocessing_workflow.connect(fit_nuis, 'beta_file', datasink, 'phys.betas')
#
# # preprocessing_workflow.connect(av_r, 'out_file', datasink, 'av_r')
#
# ########################################################################################
# # masking stuff if doing mri analysis
# ########################################################################################
#
# all_mask_opds = ['dc'] + analysis_parameters[u'avg_subject_RS_label_folders']
# all_mask_lds = [''] + analysis_parameters[u'avg_subject_RS_label_folders']
#
# # loop across different folders to mask
# # untested as yet.
# masking_list = []
# dilate_list = []
# for opd, label_directory in zip(all_mask_opds,all_mask_lds):
# dilate_list.append(
# pe.MapNode(interface=fsl.maths.DilateImage(
# operation = 'mean', kernel_shape = 'sphere', kernel_size = analysis_parameters['dilate_kernel_size']),
# name='dilate_'+label_directory, iterfield=['in_file']))
#
# masking_list.append(create_masks_from_surface_workflow(name = 'masks_from_surface_'+label_directory))
#
# masking_list[-1].inputs.inputspec.label_directory = label_directory
# masking_list[-1].inputs.inputspec.fill_thresh = 0.005
# masking_list[-1].inputs.inputspec.re = '*.label'
#
# preprocessing_workflow.connect(motion_proc, 'outputspec.EPI_space_file', masking_list[-1], 'inputspec.EPI_space_file')
# preprocessing_workflow.connect(input_node, 'output_directory', masking_list[-1], 'inputspec.output_directory')
# preprocessing_workflow.connect(input_node, 'FS_subject_dir', masking_list[-1], 'inputspec.freesurfer_subject_dir')
# preprocessing_workflow.connect(input_node, 'FS_ID', masking_list[-1], 'inputspec.freesurfer_subject_ID')
# preprocessing_workflow.connect(reg, 'rename_register.out_file', masking_list[-1], 'inputspec.reg_file')
#
# preprocessing_workflow.connect(masking_list[-1], 'outputspec.masks', dilate_list[-1], 'in_file')
# preprocessing_workflow.connect(dilate_list[-1], 'out_file', datasink, 'masks.'+opd)
#
# # # surface-based label import in to EPI space, but now for RS labels
# # these should have been imported to the subject's FS folder,
# # see scripts/annot_conversion.sh
# RS_masks_from_surface = create_masks_from_surface_workflow(name = 'RS_masks_from_surface')
# RS_masks_from_surface.inputs.inputspec.label_directory = analysis_parameters['avg_subject_label_folder']
# RS_masks_from_surface.inputs.inputspec.fill_thresh = 0.005
# RS_masks_from_surface.inputs.inputspec.re = '*.label'
#
# preprocessing_workflow.connect(motion_proc, 'outputspec.EPI_space_file', RS_masks_from_surface, 'inputspec.EPI_space_file')
# preprocessing_workflow.connect(input_node, 'output_directory', RS_masks_from_surface, 'inputspec.output_directory')
# preprocessing_workflow.connect(input_node, 'FS_subject_dir', RS_masks_from_surface, 'inputspec.freesurfer_subject_dir')
# preprocessing_workflow.connect(input_node, 'FS_ID', RS_masks_from_surface, 'inputspec.freesurfer_subject_ID')
# preprocessing_workflow.connect(reg, 'rename_register.out_file', RS_masks_from_surface, 'inputspec.reg_file')
#
# preprocessing_workflow.connect(RS_masks_from_surface, 'outputspec.masks', RS_dilate_cortex, 'in_file')
# preprocessing_workflow.connect(RS_dilate_cortex, 'out_file', datasink, 'masks.'+analysis_parameters['avg_subject_label_folder'])
########################################################################################
# wrapping up, sending data to datasink
########################################################################################
# preprocessing_workflow.connect(bet_epi, 'out_file', datasink, 'bet.epi')
# preprocessing_workflow.connect(bet_epi, 'mask_file', datasink, 'bet.epimask')
# preprocessing_workflow.connect(bet_topup, 'out_file', datasink, 'bet.topup')
# preprocessing_workflow.connect(bet_topup, 'mask_file', datasink, 'bet.topupmask')
# preprocessing_workflow.connect(nuc, 'out_file', datasink, 'nuc')
# preprocessing_workflow.connect(sgfilter, 'out_file', datasink, 'tf')
# preprocessing_workflow.connect(psc, 'out_file', datasink, 'psc')
# preprocessing_workflow.connect(datasource, 'physio', datasink, 'phys')
return preprocessing_workflow
def create_pipeline_SS_TV(bids_dir,
work_dir,
out_dir,
subjects,
sessions,
mag_match_pattern,
phase_match_pattern,
mask_match_pattern,
keep_unnecessary_outputs,
FAST_bias_iters,
FAST_bias_lowpass,
FAST_num_classes,
skip_fast,
brain_extract_method,
BET_frac,
single_subject_custom_mask,
freq_weights__snr_window_sz,
truncate_echo,
SS_TV_lagrange_parameter,
B0_dir,
scnd_diff_reliability_thresh_noise,
trim_radius_sz,
scnd_diff_reliability_thresh_trim,
skip_qsm,
skip_r2star,
matlab_executable,
mcr_location,
run_mode):
layout = BIDSLayout(bids_dir)
### CREATE PIPELINE OBJECT
pipelineDir = work_dir
wf = pe.Workflow(name="SS_TV")
wf.base_dir = pipelineDir
wf.config['execution']['remove_unnecessary_outputs'] = not keep_unnecessary_outputs
### GET MULTI-ECHO DATA
# can we do this more elegantly?
first_echo_files = []
for subject in subjects:
if layout.get_sessions(subject=subject) == []:
if sessions == ['.*']:
first_echo_files = first_echo_files + layout.get(subject=subject, modality='anat',
extensions='.*part-phase.*echo-0*1.*.nii.*', )
else:
print(
"Warning: Session filter applied, but subject " + subject + " has no bids session information. This subject has been ignored.")
else:
for session in sessions:
first_echo_files = first_echo_files + layout.get(subject=subject, session=session, modality='anat',
extensions='.*part-phase.*echo-0*1.*.nii.*', )
anat_folders = []
for img in first_echo_files:
full_dirname = os.path.dirname(img.filename)
remove_base_dir = full_dirname.replace(bids_dir, '')
remove_leading_slash = remove_base_dir.lstrip(os.sep)
anat_folders.append(remove_leading_slash)
anat_folders = list(set(anat_folders))
anat_folders.sort()
# IdentityInterface is useful for passing subject directory structure to datasink
infosource = pe.Node(niu.IdentityInterface(fields=['subject_id']), name="infosource")
infosource.iterables = ('subject_id', anat_folders)
### NODES AND PARAMETERS
if brain_extract_method == BrainExtractMethod.BIDS:
datasource = pe.Node(
nio.DataGrabber(infields=['subject_id'],
outfields=['phase_images', 'mag_images', 'phase_jsons', 'mag_jsons', 'brain_mask']),
name='datasource')
datasource.inputs.field_template = dict(
phase_images='%s/' + phase_match_pattern + '.nii*',
phase_jsons='%s/' + phase_match_pattern + '.json',
mag_images='%s/' + mag_match_pattern + '.nii*',
mag_jsons='%s/' + mag_match_pattern + '.json',
brain_mask='%s/' + mask_match_pattern + '.nii*',
)
else:
datasource = pe.Node(
nio.DataGrabber(infields=['subject_id'],
outfields=['phase_images', 'mag_images', 'phase_jsons', 'mag_jsons']),
name='datasource')
datasource.inputs.field_template = dict(
phase_images='%s/' + phase_match_pattern + '.nii*',
phase_jsons='%s/' + phase_match_pattern + '.json',
mag_images='%s/' + mag_match_pattern + '.nii*',
mag_jsons='%s/' + mag_match_pattern + '.json',
)
datasource.inputs.sort_filelist = True
datasource.inputs.template = "*"
datasource.inputs.base_directory = bids_dir
# this node must change depending on the scanner vendor
susc_phase_preprocess = pe.Node(SiemensPhasePreprocess(), name='susc_phase_preprocess')
avg_and_freq_estimate_weights = pe.Node(GetAvgAndSNRMap(), name='avg_and_freq_estimate_weights')
avg_and_freq_estimate_weights.inputs.snr_window_sz = freq_weights__snr_window_sz
avg_and_freq_estimate_weights.inputs.avg_out_filename = "avg.nii.gz"
avg_and_freq_estimate_weights.inputs.snr_map_out_filename = "weights.nii.gz"
wf.connect([
(infosource, datasource, [('subject_id', 'subject_id')]),
(datasource, avg_and_freq_estimate_weights, [('mag_images', 'mag')]),
(datasource, susc_phase_preprocess, [('phase_images', 'infiles')])
])
if brain_extract_method == BrainExtractMethod.BET:
brain_extract = pe.Node(fsl.BET(), name='brain_extract_bet')
brain_extract.inputs.frac = BET_frac
brain_extract.inputs.mask = True
brain_extract.inputs.robust = True
if skip_fast:
# connect avg directly to bet (skip FAST if image uniform enough for brain extraction)
wf.connect([
(avg_and_freq_estimate_weights, brain_extract, [('avg_out_filename', 'in_file')])
])
else:
# connect avg to nu correction, connect nu correction to bet
"""
#spm worked better for varian 7T data
#if using spm, these prameters are needed
bias_regularization=.001
sampling_distance=2.0
bias_fwhm=30
nonuniformityCorrect_spm=pe.Node(spm.preprocess.Segment(),name='nonuniformityCorrect_spm')
nonuniformityCorrect_spm.inputs.bias_regularization=bias_regularization
nonuniformityCorrect_spm.inputs.sampling_distance=sampling_distance
nonuniformityCorrect_spm.inputs.bias_fwhm=bias_fwhm
nonuniformityCorrect_spm.inputs.save_bias_corrected=True
"""
nonuniformity_correct_fsl = pe.Node(fsl.FAST(), name='nonuniformity_correct_fsl')
nonuniformity_correct_fsl.inputs.img_type = 2 # 1 for t1, 2 for t2
nonuniformity_correct_fsl.inputs.bias_iters = FAST_bias_iters # higher for larger nonuniformity
nonuniformity_correct_fsl.inputs.bias_lowpass = FAST_bias_lowpass # spm uses 30
nonuniformity_correct_fsl.inputs.number_classes = FAST_num_classes # spm uses 5
nonuniformity_correct_fsl.inputs.output_biasfield = True
nonuniformity_correct_fsl.inputs.output_biascorrected = True
nonuniformity_correct_fsl.interface.estimated_memory_gb = 10
wf.connect([
# spm requires matlab
# (avg_and_freq_estimate_weights, nonuniformityCorrect_spm, [('avgOutFilename', 'data')]),
# (nonuniformityCorrect_spm, brain_extract, [('bias_corrected_image', 'in_file')]),
(avg_and_freq_estimate_weights, nonuniformity_correct_fsl, [('avg_out_filename', 'in_files')]),
(nonuniformity_correct_fsl, brain_extract, [('restored_image', 'in_file')])
])
elif brain_extract_method == BrainExtractMethod.BIDS:
brain_extract = pe.Node(
nio.DataGrabber(infields=['subject_id'],
outfields=['mask_file']),
name='bids_brain_mask')
brain_extract.inputs.field_template = dict(
mask_file='%s/' + mask_match_pattern + '.nii*',
)
brain_extract.inputs.sort_filelist = False
brain_extract.inputs.template = "*"
brain_extract.inputs.base_directory = bids_dir
wf.connect([
(infosource, brain_extract, [('subject_id', 'subject_id')]),
])
elif brain_extract_method == BrainExtractMethod.SINGLE_SUBJECT_FULL_PATH:
brain_extract = pe.Node(niu.IdentityInterface(fields=['mask_file']), name="fullpath_brain_mask")
brain_extract.inputs.mask_file = single_subject_custom_mask
freq_est = pe.Node(EstimateFrequencyFromWrappedPhase(), 'freq_est')
freq_est.inputs.truncate_echo = truncate_echo
freq_est.inputs.freq_filename = "freq_est.nii.gz"
freq_est.interface.estimated_memory_gb = 4
fieldmap_reorient = pe.Node(fsl.Reorient2Std(), name='fieldmap_reorient')
datasink = pe.Node(nio.DataSink(), name="datasink")
datasink.inputs.base_directory = out_dir + '/qsm_sstv/'
datasink.inputs.parameterization = False
rename_infosource = pe.Node(replace_slash, "rename_infosource")
rename_fieldmap = pe.Node(niu.Rename(format_string="%(subject_id)s-fieldmap", keep_ext=True), "rename_fieldmap")
wf.connect([
(susc_phase_preprocess, freq_est, [('outfiles', 'phase')]),
(datasource, freq_est, [('phase_jsons', 'json')]),
(brain_extract, freq_est, [('mask_file', 'mask')]),
(avg_and_freq_estimate_weights, freq_est, [('snr_map_out_filename', 'weight')]),
(freq_est, fieldmap_reorient, [('freq_filename', 'in_file')]),
# rename files and data sink
(infosource, rename_infosource, [('subject_id', 'filename')]),
# fieldmap
(rename_infosource, rename_fieldmap, [('renamed', 'subject_id')]),
(fieldmap_reorient, rename_fieldmap, [('out_file', 'in_file')]),
(rename_fieldmap, datasink, [('out_file', '@')]),
(infosource, datasink, [('subject_id', 'container')]),
])
if not (skip_qsm and skip_r2star):
trim_mask = pe.Node(TrimMaskUsingReliability(), name='trim_mask')
trim_mask.inputs.erosion_sz = trim_radius_sz # in mm
trim_mask.inputs.threshold = scnd_diff_reliability_thresh_trim
trim_mask.inputs.trimmed_mask_filename = "trim_mask.nii.gz"
trim_mask.inputs.reliability_filename = "unreliableMap.nii.gz"
trim_mask.interface.estimated_memory_gb = 25
wf.connect([
(freq_est, trim_mask, [('freq_filename', 'phase')]),
(brain_extract, trim_mask, [('mask_file', 'mask')])
])
if not skip_qsm:
unreliable_fieldmap_voxels = pe.Node(CalculateReliabilityMask(), name='unreliable_fieldmap_voxels')
unreliable_fieldmap_voxels.inputs.threshold = scnd_diff_reliability_thresh_noise
unreliable_fieldmap_voxels.inputs.reliability_mask_filename = "unreliableMask.nii.gz"
unreliable_fieldmap_voxels.inputs.reliability_filename = "unreliableMap.nii.gz"
CF_value = pe.Node(GetCFFromJson, name='CFValue')
susceptibility = pe.Node(SS_TV(run_mode, matlab_executable, mcr_location), name='susceptibility')
susceptibility.inputs.alpha = SS_TV_lagrange_parameter
susceptibility.inputs.B0_dir = B0_dir
susceptibility.inputs.susceptibility_filename = 'susceptibilityMap.nii.gz'
susceptibility.interface.estimated_memory_gb = 10
QSM_reorient = pe.Node(fsl.Reorient2Std(), name='QSM_reorient')
QSM_brain_mask_reorient = pe.Node(fsl.Reorient2Std(), name='QSM_brain_mask_reorient')
QSM_noise_mask_reorient = pe.Node(fsl.Reorient2Std(), name='QSM_noise_mask_reorient')
rename_QSM = pe.Node(niu.Rename(format_string="%(subject_id)s-QSM", keep_ext=True), "rename_QSM")
rename_QSM_brain_mask = pe.Node(niu.Rename(format_string="%(subject_id)s-QSM_brainMask", keep_ext=True),
"rename_QSM_brain_mask")
rename_QSM_noise_mask = pe.Node(niu.Rename(format_string="%(subject_id)s-QSM_noiseMask", keep_ext=True),
"rename_QSM_noise_mask")
wf.connect([
(freq_est, unreliable_fieldmap_voxels, [('freq_filename', 'phase')]),
(brain_extract, unreliable_fieldmap_voxels, [('mask_file', 'mask')]),
(freq_est, susceptibility, [('freq_filename', 'freq_loc')]),
(datasource, CF_value, [('mag_jsons', 'filename')]),
(unreliable_fieldmap_voxels, susceptibility, [('reliability_mask_filename', 'reliability_mask_loc')]),
(trim_mask, susceptibility, [('trimmed_mask_filename', 'mask_loc')]),
(CF_value, susceptibility, [('CF_value', 'CF')]),
(susceptibility, QSM_reorient, [('susceptibility_filename', 'in_file')]),
(trim_mask, QSM_brain_mask_reorient, [('trimmed_mask_filename', 'in_file')]),
(unreliable_fieldmap_voxels, QSM_noise_mask_reorient, [('reliability_mask_filename', 'in_file')]),
# qsm
(rename_infosource, rename_QSM, [('renamed', 'subject_id')]),
(QSM_reorient, rename_QSM, [('out_file', 'in_file')]),
(rename_QSM, datasink, [('out_file', '@.@qsm')]),
# qsm brain mask
(rename_infosource, rename_QSM_brain_mask, [('renamed', 'subject_id')]),
(QSM_brain_mask_reorient, rename_QSM_brain_mask, [('out_file', 'in_file')]),
(rename_QSM_brain_mask, datasink, [('out_file', '@.@qsm_brain')]),
# qsm noisey voxels in fieldmap
(rename_infosource, rename_QSM_noise_mask, [('renamed', 'subject_id')]),
(QSM_noise_mask_reorient, rename_QSM_noise_mask, [('out_file', 'in_file')]),
(rename_QSM_noise_mask, datasink, [('out_file', '@.@qsm_noise')]),
])
if not skip_r2star:
R2Star = pe.Node(CalcR2Star(), 'R2Star')
R2Star.inputs.R2star = 'R2star.nii.gz'
R2Star.inputs.neg_mask = 'negMask.nii.gz'
R2Star.inputs.nan_mask = 'nanMask.nii.gz'
# R2Star.interface.estimated_memory_gb = 5
R2star_reorient = pe.Node(fsl.Reorient2Std(), name='R2star_reorient')
R2star_fit_reorient = pe.Node(fsl.Reorient2Std(), name='R2star_fit_reorient')
R2star_neg_mask_reorient = pe.Node(fsl.Reorient2Std(), name='R2star_neg_mask_reorient')
rename_R2star = pe.Node(niu.Rename(format_string="%(subject_id)s-R2star", keep_ext=True), "rename_R2star")
rename_R2star_fit = pe.Node(niu.Rename(format_string="%(subject_id)s-R2star_fit", keep_ext=True),
"rename_R2star_fit")
rename_R2star_neg_mask = pe.Node(niu.Rename(format_string="%(subject_id)s-R2star_negMask", keep_ext=True),
"rename_R2star_neg_mask")
wf.connect([
(datasource, R2Star, [('mag_images', 'mag')]),
(susc_phase_preprocess, R2Star, [('outfiles', 'phase')]),
(freq_est, R2Star, [('freq_filename', 'freq_loc')]),
(trim_mask, R2Star, [('trimmed_mask_filename', 'mask')]),
(datasource, R2Star, [('mag_jsons', 'json')]),
(R2Star, R2star_reorient, [('R2star', 'in_file')]),
(R2Star, R2star_fit_reorient, [('R2star_fit', 'in_file')]),
(R2Star, R2star_neg_mask_reorient, [('neg_mask', 'in_file')]),
# r2star
(rename_infosource, rename_R2star, [('renamed', 'subject_id')]),
(R2star_reorient, rename_R2star, [('out_file', 'in_file')]),
(rename_R2star, datasink, [('out_file', '@.@r2star')]),
# r2star fit map
(rename_infosource, rename_R2star_fit, [('renamed', 'subject_id')]),
(R2star_fit_reorient, rename_R2star_fit, [('out_file', 'in_file')]),
(rename_R2star_fit, datasink, [('out_file', '@.@r2starfit')]),
# r2star negative values that were set to 0
(rename_infosource, rename_R2star_neg_mask, [('renamed', 'subject_id')]),
(R2star_neg_mask_reorient, rename_R2star_neg_mask, [('out_file', 'in_file')]),
(rename_R2star_neg_mask, datasink, [('out_file', '@.@r2starneg')]),
])
return wf
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(realign4d, '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_reoriented.nii.gz'
physsig_a = physsig1
if not os.path.isfile(physsig1):
print "MISSING PULS DATA!"
def prepro_func(i):
try:
subj = i
for s in (['session2']):
# Define input files: 2xfMRI + 1xMPRAGE
func1 = data_path + subj + '/Functional_scans/' + s[:-2] + s[
-1] + '_a/epi.nii.gz' #choose this for patients
func2 = data_path + subj + '/Functional_scans/' + s[:-2] + s[
-1] + '_b/epi.nii.gz' #choose this for patients
#anat = glob.glob(anat_path + subj +'/'+ s + '/anat/reorient/anat_*.nii.gz') #choose this for session 1
lesion_mask_file = anat_path + subj + '/session1/anat/reorient/lesion_seg.nii.gz'
old_lesion_mask_file = glob.glob(
anat_path + subj +
'/session1/anat/reorient/old_lesion_seg.nii.gz'
) #choose this for ones with no old lesion
#old_lesion_mask_file = anat_path + subj +'/session1/anat/reorient/old_lesion_seg.nii.gz' #choose this for ones with old lesion
anat = glob.glob(anat_path + subj + '/' + s +
'/anat/anat2hr/anat_*.nii.gz'
) #choose this for sessions 2 and 3
anat_CSF = glob.glob(
anat_path + subj +
'/session1/seg_anat/segmentation/anat_*_pve_0.nii.gz'
) # don't change, same for all sessions
anat_WM = glob.glob(
anat_path + subj +
'/session1/seg_anat/segmentation/anat_*_pve_2.nii.gz'
) # don't change, same for all sessions
anat_GM = glob.glob(
anat_path + subj +
'/session1/seg_anat/segmentation/anat_*_pve_1.nii.gz'
) # don't change, same for all sessions
anat2MNI_fieldwarp = glob.glob(
anat_path + subj +
'/session1/anat/nonlinear_reg/anat_*_fieldwarp.nii.gz'
) # don't change, same for all sessions
if not os.path.isdir(data_path + subj + '/' + s): # No data exists
continue
if not os.path.isfile(func1):
print '1. functional file ' + func1 + ' not found. Skipping!'
continue
if not os.path.isfile(func2):
print '2. functional file ' + func2 + ' not found. Skipping!'
continue
if not anat:
print 'Preprocessed anatomical file not found. Skipping!'
continue
if len(anat) > 1:
print 'WARNING: found multiple files of preprocessed anatomical image!'
continue
anat = anat[0]
if not anat2MNI_fieldwarp:
print 'Anatomical registration to MNI152-space field file not found. Skipping!'
continue
if len(anat2MNI_fieldwarp) > 1:
print 'WARNING: found multiple files of anat2MNI fieldwarp!'
continue
anat2MNI_fieldwarp = anat2MNI_fieldwarp[0]
if not anat_CSF:
anat_CSF = glob.glob(
anat_path + subj + '/' + s +
'/seg_anat/segmentation/anat_*_pve_0.nii.gz')
if not anat_CSF:
print 'Anatomical segmentation CSF file not found. Skipping!'
continue
if len(anat_CSF) > 1:
print 'WARNING: found multiple files of anatomical CSF file!'
continue
anat_CSF = anat_CSF[0]
if not anat_WM:
anat_WM = glob.glob(
anat_path + subj + '/' + s +
'/seg_anat/segmentation/anat_*_pve_2.nii.gz')
if not anat_WM:
print 'Anatomical segmentation WM file not found. Skipping!'
continue
if len(anat_WM) > 1:
print 'WARNING: found multiple files of anatomical WM file!'
continue
anat_WM = anat_WM[0]
if not anat_GM:
anat_GM = glob.glob(
anat_path + subj + '/' + s +
'/seg_anat/segmentation/anat_*_pve_1.nii.gz')
if not anat_GM:
print 'Anatomical segmentation GM file not found. Skipping!'
continue
if len(anat_GM) > 1:
print 'WARNING: found multiple files of anatomical GM file!'
continue
anat_GM = anat_GM[0]
if not os.path.isdir(results_path + subj):
os.mkdir(results_path + subj)
if not os.path.isdir(results_path + subj + '/' + s):
os.mkdir(results_path + subj + '/' + s)
for data in acquisitions:
os.chdir(results_path + subj + '/' + s)
print "Currently processing subject: " + subj + '/' + s + ' ' + data
#Initialize workflows
workflow = pe.Workflow(name=data)
workflow.base_dir = '.'
inputnode = pe.Node(
interface=util.IdentityInterface(fields=['source_file']),
name='inputspec')
outputnode = pe.Node(
interface=util.IdentityInterface(fields=['result_func']),
name='outputspec')
if data == 'func1':
inputnode.inputs.source_file = func1
else:
inputnode.inputs.source_file = func2
# Remove n_dummies first volumes
trim = pe.Node(interface=Trim(begin_index=n_dummies),
name='trim')
workflow.connect(inputnode, 'source_file', trim, 'in_file')
# 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 # horizontal slices
realign4d.inputs.tr = mytr # TR in seconds
workflow.connect(trim, 'out_file', realign4d, 'in_file')
# Reorient
#deoblique = pe.Node(interface=afni.Warp(deoblique=True, outputtype='NIFTI_GZ'), name='deoblique') #leave out if you don't need this
#workflow.connect(realign4d, 'out_file', deoblique, 'in_file')
reorient = pe.Node(
interface=fsl.Reorient2Std(output_type='NIFTI_GZ'),
name='reorient')
workflow.connect(realign4d, 'out_file', reorient, 'in_file')
# AFNI skullstrip and mean image skullstrip
tstat1 = pe.Node(interface=afni.TStat(args='-mean',
outputtype="NIFTI_GZ"),
name='tstat1')
automask = pe.Node(interface=afni.Automask(
dilate=1, outputtype="NIFTI_GZ"),
name='automask')
skullstrip = pe.Node(interface=afni.Calc(
expr='a*b', outputtype="NIFTI_GZ"),
name='skullstrip')
tstat2 = pe.Node(interface=afni.TStat(args='-mean',
outputtype="NIFTI_GZ"),
name='tstat2')
workflow.connect(reorient, 'out_file', tstat1, 'in_file')
workflow.connect(tstat1, 'out_file', automask, 'in_file')
workflow.connect(automask, 'out_file', skullstrip, 'in_file_b')
workflow.connect(reorient, 'out_file', skullstrip, 'in_file_a')
workflow.connect(skullstrip, 'out_file', tstat2, 'in_file')
# Register to anatomical space #can be changed
#mean2anat = pe.Node(fsl.FLIRT(bins=40, cost='normmi', dof=7, interp='nearestneighbour', searchr_x=[-180,180], searchr_y=[-180,180], searchr_z=[-180,180]), name='mean2anat')
mean2anat = pe.Node(fsl.FLIRT(bins=40,
cost='normmi',
dof=7,
interp='nearestneighbour'),
name='mean2anat')
#mean2anat = pe.Node(fsl.FLIRT(no_search=True), name='mean2anat')
mean2anat.inputs.reference = anat
workflow.connect(tstat2, 'out_file', mean2anat, 'in_file')
# Transform mean functional image
warpmean = pe.Node(interface=fsl.ApplyWarp(), name='warpmean')
warpmean.inputs.ref_file = MNI_brain
warpmean.inputs.field_file = anat2MNI_fieldwarp
workflow.connect(mean2anat, 'out_matrix_file', warpmean,
'premat')
workflow.connect(tstat2, 'out_file', warpmean, 'in_file')
# ----- inversion matrix and eroded brain mask for regression -----
# create inverse matrix from mean2anat registration
invmat = pe.Node(fsl.ConvertXFM(), name='invmat')
invmat.inputs.invert_xfm = True
workflow.connect(mean2anat, 'out_matrix_file', invmat,
'in_file')
# erode functional brain mask
erode_brain = pe.Node(fsl.ImageMaths(), name='erode_brain')
erode_brain.inputs.args = '-kernel boxv 3 -ero'
workflow.connect(automask, 'out_file', erode_brain, 'in_file')
# register GM mask to functional image space, this is done for quality control
reg_GM = pe.Node(fsl.preprocess.ApplyXFM(), name='register_GM')
reg_GM.inputs.apply_xfm = True
reg_GM.inputs.in_file = anat_GM
workflow.connect(tstat2, 'out_file', reg_GM, 'reference')
workflow.connect(invmat, 'out_file', reg_GM, 'in_matrix_file')
# --------- motion regression and censor signals ------------------
# normalize motion parameters
norm_motion = pe.Node(interface=Function(
input_names=['in_file'],
output_names=['out_file'],
function=normalize_motion_data),
name='normalize_motion')
workflow.connect(realign4d, 'par_file', norm_motion, 'in_file')
# create censor file, for censoring motion
get_censor = pe.Node(afni.OneDToolPy(), name='motion_censors')
get_censor.inputs.set_nruns = 1
get_censor.inputs.censor_motion = (censor_thr, 'motion')
get_censor.inputs.show_censor_count = True
if overwrite: get_censor.inputs.args = '-overwrite'
workflow.connect(norm_motion, 'out_file', get_censor,
'in_file')
# compute motion parameter derivatives (for use in regression)
deriv_motion = pe.Node(afni.OneDToolPy(), name='deriv_motion')
deriv_motion.inputs.set_nruns = 1
deriv_motion.inputs.derivative = True
if overwrite: deriv_motion.inputs.args = '-overwrite'
deriv_motion.inputs.out_file = 'motion_derivatives.txt'
workflow.connect(norm_motion, 'out_file', deriv_motion,
'in_file')
# scale motion parameters and get quadratures
quadr_motion = pe.Node(interface=Function(
input_names=['in_file', 'multicol'],
output_names=['out_file', 'out_quadr_file'],
function=scale_and_quadrature),
name='quadr_motion')
quadr_motion.inputs.multicol = True
workflow.connect(norm_motion, 'out_file', quadr_motion,
'in_file')
# scale motion derivatives and get quadratures
quadr_motion_deriv = pe.Node(interface=Function(
input_names=['in_file', 'multicol'],
output_names=['out_file', 'out_quadr_file'],
function=scale_and_quadrature),
name='quadr_motion_deriv')
quadr_motion_deriv.inputs.multicol = True
workflow.connect(deriv_motion, 'out_file', quadr_motion_deriv,
'in_file')
# -------- CSF regression signals ---------------
# threshold and erode CSF mask
erode_CSF_mask = pe.Node(fsl.ImageMaths(),
name='erode_CSF_mask')
erode_CSF_mask.inputs.args = '-thr 0.5 -kernel boxv 3 -ero'
erode_CSF_mask.inputs.in_file = anat_CSF
# register CSF mask to functional image space
reg_CSF_mask = pe.Node(fsl.preprocess.ApplyXFM(),
name='register_CSF_mask')
reg_CSF_mask.inputs.apply_xfm = True
workflow.connect(tstat2, 'out_file', reg_CSF_mask, 'reference')
workflow.connect(invmat, 'out_file', reg_CSF_mask,
'in_matrix_file')
# inverse lesion mask and remove it from CSF mask #remove this if you don't have a lesion mask
inverse_lesion_mask = pe.Node(fsl.ImageMaths(),
name='inverse_lesion_mask')
inverse_lesion_mask.inputs.args = '-add 1 -rem 2'
inverse_lesion_mask.inputs.in_file = lesion_mask_file
rem_lesion = pe.Node(fsl.ImageMaths(), name='remove_lesion')
workflow.connect(erode_CSF_mask, 'out_file', rem_lesion,
'in_file')
workflow.connect(inverse_lesion_mask, 'out_file', rem_lesion,
'mask_file')
'''
# Transform lesion mask to MNI152 space #remove if lesion masks are already in MNI152 space
warp_lesion = pe.Node(interface=fsl.ApplyWarp(), name='warp_lesion')
warp_lesion.inputs.ref_file = MNI_brain
warp_lesion.inputs.field_file = anat2MNI_fieldwarp
warp_lesion.inputs.in_file = lesion_mask_file
warp_lesion.inputs.out_file = anat_path + subj +'/'+ s + '/anat/nonlinear_reg/lesion_seg_warp.nii.gz'
warp_lesion.run()
'''
# inverse old lesion mask and remove it from CSF mask #remove this if you don't have a lesion mask
if old_lesion_mask_file:
inverse_old_lesion_mask = pe.Node(
fsl.ImageMaths(), name='inverse_old_lesion_mask')
inverse_old_lesion_mask.inputs.args = '-add 1 -rem 3'
#inverse_old_lesion_mask.inputs.in_file = old_lesion_mask_file[0]
inverse_old_lesion_mask.inputs.in_file = old_lesion_mask_file
rem_old_lesion = pe.Node(fsl.ImageMaths(),
name='remove_old_lesion')
workflow.connect(rem_lesion, 'out_file', rem_old_lesion,
'in_file')
workflow.connect(inverse_old_lesion_mask, 'out_file',
rem_old_lesion, 'mask_file')
workflow.connect(rem_old_lesion, 'out_file', reg_CSF_mask,
'in_file')
'''
# Transform old lesion mask to MNI152 space #remove if lesion masks are already in MNI152 space
warp_old_lesion = pe.Node(interface=fsl.ApplyWarp(), name='warp_old_lesion')
warp_old_lesion.inputs.ref_file = MNI_brain
warp_old_lesion.inputs.field_file = anat2MNI_fieldwarp
warp_old_lesion.inputs.in_file = old_lesion_mask_file
warp_old_lesion.inputs.out_file = anat_path + subj +'/'+ s + '/anat/nonlinear_reg/old_lesion_seg_warp.nii.gz'
warp_old_lesion.run()
'''
else:
workflow.connect(rem_lesion, 'out_file', reg_CSF_mask,
'in_file')
# threshold CSF mask and intersect with functional brain mask
thr_CSF_mask = pe.Node(fsl.ImageMaths(),
name='threshold_CSF_mask')
thr_CSF_mask.inputs.args = '-thr 0.25'
workflow.connect(reg_CSF_mask, 'out_file', thr_CSF_mask,
'in_file')
workflow.connect(erode_brain, 'out_file', thr_CSF_mask,
'mask_file')
# extract CSF values
get_CSF_noise = pe.Node(fsl.ImageMeants(),
name='get_CSF_noise')
workflow.connect(skullstrip, 'out_file', get_CSF_noise,
'in_file')
workflow.connect(thr_CSF_mask, 'out_file', get_CSF_noise,
'mask')
# compute CSF noise derivatives
deriv_CSF = pe.Node(afni.OneDToolPy(), name='deriv_CSF')
deriv_CSF.inputs.set_nruns = 1
deriv_CSF.inputs.derivative = True
if overwrite: deriv_CSF.inputs.args = '-overwrite'
deriv_CSF.inputs.out_file = 'CSF_derivatives.txt'
workflow.connect(get_CSF_noise, 'out_file', deriv_CSF,
'in_file')
# scale SCF noise and get quadratures
quadr_CSF = pe.Node(interface=Function(
input_names=['in_file', 'multicol'],
output_names=['out_file', 'out_quadr_file'],
function=scale_and_quadrature),
name='quadr_CSF')
quadr_CSF.inputs.multicol = False
workflow.connect(get_CSF_noise, 'out_file', quadr_CSF,
'in_file')
# scale CSF noise derivatives and get quadratures
quadr_CSF_deriv = pe.Node(interface=Function(
input_names=['in_file', 'multicol'],
output_names=['out_file', 'out_quadr_file'],
function=scale_and_quadrature),
name='quadr_CSF_deriv')
quadr_CSF_deriv.inputs.multicol = False
workflow.connect(deriv_CSF, 'out_file', quadr_CSF_deriv,
'in_file')
# -------- WM regression signals -----------------
# threshold and erode WM mask
erode_WM_mask = pe.Node(fsl.ImageMaths(), name='erode_WM_mask')
erode_WM_mask.inputs.args = '-thr 0.5 -kernel boxv 7 -ero'
erode_WM_mask.inputs.in_file = anat_WM
# registrer WM mask to functional image space
reg_WM_mask = pe.Node(fsl.preprocess.ApplyXFM(),
name='register_WM_mask')
reg_WM_mask.inputs.apply_xfm = True
workflow.connect(tstat2, 'out_file', reg_WM_mask, 'reference')
workflow.connect(invmat, 'out_file', reg_WM_mask,
'in_matrix_file')
workflow.connect(erode_WM_mask, 'out_file', reg_WM_mask,
'in_file')
# create inverse nonlinear registration MNI2anat
invwarp = pe.Node(fsl.InvWarp(output_type='NIFTI_GZ'),
name='invwarp')
invwarp.inputs.warp = anat2MNI_fieldwarp
invwarp.inputs.reference = anat
# transform ventricle mask to functional space
reg_ventricles = pe.Node(fsl.ApplyWarp(),
name='register_ventricle_mask')
reg_ventricles.inputs.in_file = ventricle_mask
workflow.connect(tstat2, 'out_file', reg_ventricles,
'ref_file')
workflow.connect(invwarp, 'inverse_warp', reg_ventricles,
'field_file')
workflow.connect(invmat, 'out_file', reg_ventricles, 'postmat')
# threshold WM mask and intersect with functional brain mask
thr_WM_mask = pe.Node(fsl.ImageMaths(),
name='threshold_WM_mask')
thr_WM_mask.inputs.args = '-thr 0.25'
workflow.connect(reg_WM_mask, 'out_file', thr_WM_mask,
'in_file')
workflow.connect(erode_brain, 'out_file', thr_WM_mask,
'mask_file')
# remove ventricles from WM mask
exclude_ventricles = pe.Node(fsl.ImageMaths(),
name='exclude_ventricles')
workflow.connect(thr_WM_mask, 'out_file', exclude_ventricles,
'in_file')
workflow.connect(reg_ventricles, 'out_file',
exclude_ventricles, 'mask_file')
# check that WM is collected from both hemispheres
check_WM_bilat = pe.Node(interface=Function(
input_names=['in_file'],
output_names=['errors'],
function=check_bilateralism),
name='check_WM_bilateralism')
workflow.connect(exclude_ventricles, 'out_file',
check_WM_bilat, 'in_file')
# extract WM values
get_WM_noise = pe.Node(fsl.ImageMeants(), name='get_WM_noise')
workflow.connect(skullstrip, 'out_file', get_WM_noise,
'in_file')
workflow.connect(exclude_ventricles, 'out_file', get_WM_noise,
'mask')
# compute WM noise derivatives
deriv_WM = pe.Node(afni.OneDToolPy(), name='deriv_WM')
deriv_WM.inputs.set_nruns = 1
deriv_WM.inputs.derivative = True
if overwrite: deriv_WM.inputs.args = '-overwrite'
deriv_WM.inputs.out_file = 'WM_derivatives.txt'
workflow.connect(get_WM_noise, 'out_file', deriv_WM, 'in_file')
# scale WM noise and get quadratures
quadr_WM = pe.Node(interface=Function(
input_names=['in_file', 'multicol'],
output_names=['out_file', 'out_quadr_file'],
function=scale_and_quadrature),
name='quadr_WM')
quadr_WM.inputs.multicol = False
workflow.connect(get_WM_noise, 'out_file', quadr_WM, 'in_file')
# scale WM noise derivatives and get quadratures
quadr_WM_deriv = pe.Node(interface=Function(
input_names=['in_file', 'multicol'],
output_names=['out_file', 'out_quadr_file'],
function=scale_and_quadrature),
name='quadr_WM_deriv')
quadr_WM_deriv.inputs.multicol = False
workflow.connect(deriv_WM, 'out_file', quadr_WM_deriv,
'in_file')
# ---------- global regression signals ----------------
if global_reg:
# register anatomical whole brain mask to functional image space
reg_glob_mask = pe.Node(fsl.preprocess.ApplyXFM(),
name='register_global_mask')
reg_glob_mask.inputs.apply_xfm = True
reg_glob_mask.inputs.in_file = anat
workflow.connect(tstat2, 'out_file', reg_glob_mask,
'reference')
workflow.connect(invmat, 'out_file', reg_glob_mask,
'in_matrix_file')
# threshold anatomical brain mask and intersect with functional brain mask
thr_glob_mask = pe.Node(fsl.ImageMaths(),
name='threshold_global_mask')
thr_glob_mask.inputs.args = '-thr -0.1'
workflow.connect(reg_glob_mask, 'out_file', thr_glob_mask,
'in_file')
workflow.connect(erode_brain, 'out_file', thr_glob_mask,
'mask_file')
# extract global signal values
get_glob_noise = pe.Node(fsl.ImageMeants(),
name='get_global_noise')
workflow.connect(skullstrip, 'out_file', get_glob_noise,
'in_file')
workflow.connect(thr_glob_mask, 'out_file', get_glob_noise,
'mask')
# compute global noise derivative
deriv_glob = pe.Node(afni.OneDToolPy(),
name='deriv_global')
deriv_glob.inputs.set_nruns = 1
deriv_glob.inputs.derivative = True
if overwrite: deriv_glob.inputs.args = '-overwrite'
deriv_glob.inputs.out_file = 'global_derivatives.txt'
workflow.connect(get_glob_noise, 'out_file', deriv_glob,
'in_file')
# scale global noise and get quadratures
quadr_glob = pe.Node(interface=Function(
input_names=['in_file', 'multicol'],
output_names=['out_file', 'out_quadr_file'],
function=scale_and_quadrature),
name='quadr_glob')
quadr_glob.inputs.multicol = False
workflow.connect(get_glob_noise, 'out_file', quadr_glob,
'in_file')
# scale global noise derivatives and get quadratures
quadr_glob_deriv = pe.Node(interface=Function(
input_names=['in_file', 'multicol'],
output_names=['out_file', 'out_quadr_file'],
function=scale_and_quadrature),
name='quadr_glob_deriv')
quadr_glob_deriv.inputs.multicol = False
workflow.connect(deriv_glob, 'out_file', quadr_glob_deriv,
'in_file')
# ---------- regression matrix ----------
# create bandpass regressors, can not be easily implemented to workflow
get_bandpass = pe.Node(interface=Function(
input_names=['minf', 'maxf', 'example_file', 'tr'],
output_names=['out_tuple'],
function=bandpass),
name='bandpass_regressors')
get_bandpass.inputs.minf = myminf
get_bandpass.inputs.maxf = mymaxf
get_bandpass.inputs.tr = mytr
workflow.connect(norm_motion, 'out_file', get_bandpass,
'example_file')
# concatenate regressor time series
cat_reg_name = 'cat_regressors'
if global_reg: cat_reg_name = cat_reg_name + '_global'
cat_reg = pe.Node(interface=Function(
input_names=[
'mot', 'motd', 'motq', 'motdq', 'CSF', 'CSFd', 'CSFq',
'CSFdq', 'WM', 'WMd', 'WMq', 'WMdq', 'include_global',
'glob', 'globd', 'globq', 'globdq'
],
output_names=['reg_file_args'],
function=concatenate_regressors),
name=cat_reg_name)
cat_reg.inputs.include_global = global_reg
workflow.connect(quadr_motion, 'out_file', cat_reg, 'mot')
workflow.connect(quadr_motion_deriv, 'out_file', cat_reg,
'motd')
workflow.connect(quadr_motion, 'out_quadr_file', cat_reg,
'motq')
workflow.connect(quadr_motion_deriv, 'out_quadr_file', cat_reg,
'motdq')
workflow.connect(quadr_CSF, 'out_file', cat_reg, 'CSF')
workflow.connect(quadr_CSF_deriv, 'out_file', cat_reg, 'CSFd')
workflow.connect(quadr_CSF, 'out_quadr_file', cat_reg, 'CSFq')
workflow.connect(quadr_CSF_deriv, 'out_quadr_file', cat_reg,
'CSFdq')
workflow.connect(quadr_WM, 'out_file', cat_reg, 'WM')
workflow.connect(quadr_WM_deriv, 'out_file', cat_reg, 'WMd')
workflow.connect(quadr_WM, 'out_quadr_file', cat_reg, 'WMq')
workflow.connect(quadr_WM_deriv, 'out_quadr_file', cat_reg,
'WMdq')
if global_reg:
workflow.connect(quadr_glob, 'out_file', cat_reg, 'glob')
workflow.connect(quadr_glob_deriv, 'out_file', cat_reg,
'globd')
workflow.connect(quadr_glob, 'out_quadr_file', cat_reg,
'globq')
workflow.connect(quadr_glob_deriv, 'out_quadr_file',
cat_reg, 'globdq')
else:
cat_reg.inputs.glob = None
cat_reg.inputs.globd = None
cat_reg.inputs.globq = None
cat_reg.inputs.globdq = None
# create regression matrix
deconvolve_name = 'deconvolve'
if global_reg: deconvolve_name = deconvolve_name + '_global'
deconvolve = pe.Node(afni.Deconvolve(), name=deconvolve_name)
deconvolve.inputs.polort = 2 # contstant, linear and quadratic background signals removed
deconvolve.inputs.fout = True
deconvolve.inputs.tout = True
deconvolve.inputs.x1D_stop = True
deconvolve.inputs.force_TR = mytr
workflow.connect(cat_reg, 'reg_file_args', deconvolve, 'args')
workflow.connect(get_bandpass, 'out_tuple', deconvolve,
'ortvec')
workflow.connect([(skullstrip, deconvolve,
[(('out_file', str2list), 'in_files')])])
# regress out motion and other unwanted signals
tproject_name = 'tproject'
if global_reg: tproject_name = tproject_name + '_global'
tproject = pe.Node(afni.TProject(outputtype="NIFTI_GZ"),
name=tproject_name)
tproject.inputs.TR = mytr
tproject.inputs.polort = 0 # use matrix created with 3dDeconvolve, higher order polynomials not needed
tproject.inputs.cenmode = 'NTRP' # interpolate removed time points
workflow.connect(get_censor, 'out_file', tproject, 'censor')
workflow.connect(skullstrip, 'out_file', tproject, 'in_file')
workflow.connect(automask, 'out_file', tproject, 'mask')
workflow.connect(deconvolve, 'x1D', tproject, 'ort')
# Transform all images
warpall_name = 'warpall'
if global_reg: warpall_name = warpall_name + '_global'
warpall = pe.Node(interface=fsl.ApplyWarp(), name=warpall_name)
warpall.inputs.ref_file = MNI_brain
warpall.inputs.field_file = anat2MNI_fieldwarp
workflow.connect(mean2anat, 'out_matrix_file', warpall,
'premat')
workflow.connect(tproject, 'out_file', warpall, 'in_file')
workflow.connect(warpall, 'out_file', outputnode,
'result_func')
# Run workflow
workflow.write_graph()
workflow.run()
print "FUNCTIONAL PREPROCESSING DONE! Results in ", results_path + subj + '/' + s
except:
print "Error with patient: ", subj
traceback.print_exc()
def native_to_tal_fsl(
path_to_img,
force_new_transform=False,
dof=6,
output_folder='/home/gustav/Desktop/data_processed/mta_data/native',
guid='',
remove_tmp_files=True):
'''
path_to_img - input image in native space
force_new_transform - if True, the native image will be transformed regardless of if
a transformed image exists
returns ac/pc alinged imaged by taliarach transformation with voxel size of 1x1x1mm3
Function that inputs a native image of the brain and
1) conforms it to 1x1x1mm3 voxel size + lrflip if needed
2) performs rigid talariach transformation for ac/pc-alignment and centering of brain.
3) if to_nifti: convert to nii
'''
native_img = os.path.basename(path_to_img)
if not guid: # if no output guid soecified
if 'nii.gz' in native_img:
guid = os.path.splitext(os.path.splitext(native_img)[0])[0]
else:
guid = os.path.splitext(native_img)[0]
tal_img = guid + '_mni_dof_' + str(dof) + '.nii'
bet_img = guid + '_bet.nii'
bet_img_cp = guid + '_bet_cp.nii'
tmp_img = guid + '_tmp.nii'
path_to_folder = os.path.dirname(path_to_img)
tmp_img_path = os.path.join(output_folder, tmp_img)
tal_img_path = os.path.join(output_folder, tal_img)
bet_img_path = os.path.join(output_folder, bet_img)
bet_img_path_cp = os.path.join(output_folder, bet_img_cp)
xfm_path = os.path.join(output_folder,
guid + '_mni_dof_' + str(dof) + '.mat')
xfm_path_cp = os.path.join(output_folder,
guid + '_mni_dof_' + str(dof) + '_cp.mat')
xfm_path2 = os.path.join(output_folder,
guid + '_mni_dof_' + str(dof) + '_2.mat')
try:
fsl_path = os.environ['FSLDIR']
except:
fsl_path = '/usr/local/fsl'
print('please install fsl and test $FSLDIR. Trying default path: ' +
fsl_path)
template_img = os.path.join(fsl_path, 'data', 'standard',
'MNI152_T1_1mm.nii.gz')
tal_img_exist = os.path.exists(tal_img_path)
xfm_exist = os.path.exists(xfm_path)
fsl_1 = fsl.FLIRT()
fsl_2 = fsl.FLIRT()
fsl_pre = fsl.Reorient2Std()
if not tal_img_exist or force_new_transform:
# pre-reorient first images
fsl_pre.inputs.in_file = path_to_img
fsl_pre.inputs.out_file = tmp_img_path
fsl_pre.inputs.output_type = 'NIFTI'
fsl_pre.run()
# run skull strip to calculate transformation matrix
btr = fsl.BET()
btr.inputs.in_file = tmp_img_path
btr.inputs.frac = 0.7
btr.inputs.out_file = bet_img_path
btr.inputs.output_type = 'NIFTI'
#btr.inputs.reduce_bias = True
btr.inputs.robust = True
btr.cmdline
btr.run()
# calculate transformation matrix - 1st attempt
fsl_1.inputs.in_file = bet_img_path
fsl_1.inputs.reference = template_img
fsl_1.inputs.out_file = bet_img_path
fsl_1.inputs.output_type = 'NIFTI'
fsl_1.inputs.dof = dof
fsl_1.inputs.out_matrix_file = xfm_path
fsl_1.run()
# read .mat file to assess if AC-PC alignment failed completely by looking at the diagonal elements (should be close to 1's)
f = open(xfm_path, 'r')
l = [[num for num in line.split(' ')] for line in f]
matrix_1 = np.zeros((4, 4))
for m in range(4):
for n in range(4):
matrix_1[m, n] = float(l[m][n])
dist_1 = np.sum(np.square(np.diag(matrix_1) - 1))
print('Dist (below 0.01 generally OK): ' + str(dist_1))
print('Transformation matrix path: ' + xfm_path)
dist_lim = .01
translate_lim = 30
if dist_1 > dist_lim or matrix_1[
2, 3] > translate_lim: # if ac-PC failed, run without bet
# copy bet files for debuging
copyfile(bet_img_path, bet_img_path_cp)
copyfile(xfm_path, xfm_path_cp)
print('------ Rerunning registration without bet ---')
fsl_1.inputs.in_file = tmp_img_path
fsl_1.run()
f = open(xfm_path, 'r')
l = [[num for num in line.split(' ')] for line in f]
matrix_2 = np.zeros((4, 4))
for m in range(4):
for n in range(4):
matrix_2[m, n] = float(l[m][n])
dist_2 = np.sum(np.square(np.diag(matrix_2) - 1))
print([dist_1, dist_2])
if (dist_1 < dist_lim and dist_2 < dist_lim):
if matrix_1[2, 3] < matrix_2[2, 3]:
# use the transform from the bet image if that was "better"
xfm_path = xfm_path_cp
print(
'Using bet transform, both below dist and translate smaller'
)
elif dist_1 < dist_2:
xfm_path = xfm_path_cp
print('Using bet transform, bet dist smaller')
# apply transform
fsl_2.inputs.in_file = tmp_img_path
fsl_2.inputs.reference = template_img
fsl_2.inputs.out_file = tal_img_path
fsl_2.inputs.output_type = 'NIFTI'
fsl_2.inputs.in_matrix_file = xfm_path
fsl_2.inputs.apply_xfm = True
fsl_2.inputs.out_matrix_file = xfm_path2
fsl_2.run()
if remove_tmp_files:
for img in [
tmp_img_path, bet_img_path, xfm_path2, bet_img_path_cp,
xfm_path_cp
]: #,xfm_path
if os.path.exists(img):
os.remove(img)
else:
print('OBS: NOT REMOVING TEMPORARY TRANSFORM FILES ')
preproc.connect(datasource, 'fm_pos', inputnode, 'fm_pos')
preproc.connect(datasource, 'fm_neg', inputnode, 'fm_neg')
# ------------- prepare anatomical data -------------
prep_anatomicals = pe.Workflow(name='prep_anatomicals')
prep_anatomicals.base_dir = os.path.abspath('./nipype')
# reorient t1 to standard
T1_to_standard = pe.Node(interface=fsl.Reorient2Std(output_type = "NIFTI_GZ"), name='T1_to_standard')
preproc.connect(inputnode, 't1', T1_to_standard, 'in_file')
# reorient t2 to standard
T2_to_standard = pe.Node(interface=fsl.Reorient2Std(output_type = "NIFTI_GZ"), name='T2_to_standard')
preproc.connect(inputnode, 't2', T2_to_standard, 'in_file')
# coreg t2 to t1
t2tot1 = pe.Node(interface=fsl.FLIRT(dof=6, output_type = "NIFTI_GZ"), name='t2tot1')
preproc.connect(T2_to_standard, 'out_file', t2tot1, 'in_file')
preproc.connect(T1_to_standard, 'out_file', t2tot1, 'reference')
# downsample caltech atlas t1 to t1/t2 resolution
]
TissueList = [os.path.abspath(Atlas2) + '/' + tissue for tissue in tissuelist]
config.set('execution', 'crashdump_dir', parent_dir)
cropT2 = pe.Node(interface=fsl.ExtractROI(), name='cropT2')
cropT2.inputs.x_min = cfg['T2_crop_box'][0]
cropT2.inputs.x_size = cfg['T2_crop_box'][1] - cfg['T2_crop_box'][0]
cropT2.inputs.y_min = cfg['T2_crop_box'][2]
cropT2.inputs.y_size = cfg['T2_crop_box'][3] - cfg['T2_crop_box'][2]
cropT2.inputs.z_min = cfg['T2_crop_box'][4]
cropT2.inputs.z_size = cfg['T2_crop_box'][5] - cfg['T2_crop_box'][4]
cropT2.inputs.in_file = cfg['T2_struct']
reorientT2 = pe.Node(interface=fsl.Reorient2Std(), name='reorientT2')
betT2 = pe.Node(interface=fsl.BET(), name='betT2')
betT2.inputs.frac = 0.2
#betT2.inputs.robust=True
#betT2.inputs.center = cfg['T2_center']
FastSeg = pe.Node(interface=fsl.FAST(), name='FastSeg')
#FastSeg.inputs.terminal_output = 'stream'
FastSeg.inputs.output_biascorrected = True
FastSeg.inputs.img_type = 2
get_T2_template = pe.Node(interface=fsl.ExtractROI(), name='get_T2_template')
get_T2_template.inputs.t_size = 1
get_T2_template.inputs.in_file = T2_Template
## ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ INPUTS ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ##
# placeholder Node to enable iteration over scans
infosource_baseline = Node(interface=IdentityInterface(fields=['idvi']), name="infosource_baseline")
infosource_baseline.iterables = ('idvi', idvi_baseline_list)
# get full path to MRI corresponding to idvi
getmusemri_baseline = Node(Function(input_names=['key','dict'],output_names=['musemri'],function=get_value),
name='getmusemri_baseline')
getmusemri_baseline.inputs.dict = musemri_dict
# Step 1: Spatial normalization of baseline 1.5T MRI onto study-specific template
# Reorient: this simply applies 90, 180, or 270 degree rotations about each axis to make the image orientation
# the same as the FSL standard
reorient = Node(interface=fsl.Reorient2Std(output_type='NIFTI'), name="reorient")
# Use antsRegistration to compute registration between subject's baseline 1.5T MRI and study-specific template
antsreg = Node(ants.Registration(args='--float',
collapse_output_transforms=True,
fixed_image=blsa_template,
initial_moving_transform_com=True,
num_threads=1,
output_inverse_warped_image=True,
output_warped_image=True,
smoothing_sigmas=[[3, 2, 1, 0]]*3,
sigma_units=['vox']*3,
transforms=['Rigid', 'Affine', 'SyN'],
terminal_output='file',
winsorize_lower_quantile=0.005,
winsorize_upper_quantile=0.995,
def img2img_register(
img_file,
ref_file,
wf_base_dir,
wf_name,
input_reorient2std=False,
ref_reorient2std=False,
method='linear',
flirt_out_reg_file='linear_reg.mat',
flirt_out_file='img2img_linear.nii.gz',
fnirt_out_file='img2img_nonlinear.nii.gz',
fnirt_fieldcoeff_file='img2img_nonlinear_fieldcoeff.nii.gz'):
img_file = os.path.abspath(img_file)
ref_file = os.path.abspath(ref_file)
wf_base_dir = os.path.abspath(wf_base_dir)
if not img_file.endswith(('.nii', '.nii.gz')):
raise ("input file should be in nifti format (.nii or .nii.gz)!")
if not ref_file.endswith(('.nii', '.nii.gz')):
raise (
"destination file (ref_file) should be in nifti format (.nii or .nii.gz)!"
)
### reorient2std
### reorient img_file
if input_reorient2std:
reorient = fsl.Reorient2Std()
reorient.inputs.in_file = img_file
reorient.inputs.out_file = 'input_img_reorient2std.nii.gz'
reorient_Node = pe.Node(reorient, 'input_file')
wf = pe.Workflow(name='reorient2std', base_dir=wf_base_dir)
wf.add_nodes([reorient_Node])
wf.run()
img_file = os.path.join(wf_base_dir, 'reorient2std', 'input_file',
'input_img_reorient2std.nii.gz')
### reorient ref_file if config is not MNI
if ref_reorient2std and config != 'MNI':
reorient = fsl.Reorient2Std()
reorient.inputs.in_file = ref_file
reorient.inputs.out_file = 'ref_img_reorient2std.nii.gz'
reorient_Node = pe.Node(reorient, 'ref_file')
wf = pe.Workflow(name='reorient2std', base_dir=wf_base_dir)
wf.add_nodes([reorient_Node])
wf.run()
ref_file = os.path.join(wf_base_dir, 'reorient2std', 'ref_file',
'ref_img_reorient2std.nii.gz')
if method == 'linear':
flirt = pe.Node(interface=fsl.FLIRT(in_file=img_file,
reference=ref_file,
out_matrix_file=flirt_out_reg_file,
out_file=flirt_out_file),
name='linear')
wf = pe.Workflow(name=wf_name, base_dir=wf_base_dir)
wf.add_nodes([flirt])
wf.run()
if method == 'nonlinear':
flirt = pe.Node(interface=fsl.FLIRT(in_file=img_file,
reference=ref_file,
out_matrix_file=flirt_out_reg_file,
out_file=flirt_out_file),
name='linear')
fnirt = pe.Node(interface=fsl.FNIRT(
in_file=img_file,
ref_file=ref_file,
warped_file=fnirt_out_file,
fieldcoeff_file=fnirt_fieldcoeff_file),
name='nonlinear')
wf = pe.Workflow(name=wf_name, base_dir=wf_base_dir)
## adding nodes to workflows
wf.add_nodes([flirt, fnirt])
wf.connect([(flirt, fnirt, [('out_matrix_file', 'affine_file')])])
wf.run()
linear_reg_file = os.path.join(wf_base_dir, wf_name, method,
flirt_out_reg_file)
nonlinear_warp_field_file = os.path.join(wf_base_dir, wf_name, method,
fnirt_fieldcoeff_file)
return {
'img_file': img_file,
'ref_file': ref_file,
'linear_reg_file': linear_reg_file,
'warp_field_file': nonlinear_warp_field_file
}
# Infosource - function free node to iterate over the list of subject names (and/or sessions)
infosource = Node(IdentityInterface(fields=['subject_id']), name="infosource")
infosource.iterables = [('subject_id', subject_list)]
# SelectFiles - uses glob and regex to find your files
templates = dict(struct='{subject_id}/structural/structural.nii.gz',
func='{subject_id}/functional/*.nii.gz')
selectfiles = Node(SelectFiles(templates), "selectfiles")
selectfiles.inputs.base_directory = DATA_DIR
# Node which might come in handy when piping data to interfaces that are incompatible with gzipped format
gunzip_struct = Node(Gunzip(), name="gunzip_struct")
# Reorient images to match approximate orientation of the standard template images (MNI152)
reorient_func = Node(fsl.Reorient2Std(output_type='NIFTI_GZ'),
name='reorient_func')
reorient_struct = Node(fsl.Reorient2Std(output_type='NIFTI_GZ'),
name='reorient_struct')
# Convert functional images to float representation (FLOAT32)
img2float = Node(fsl.ImageMaths(out_data_type='float',
op_string='',
suffix='_dtype'),
name='img2float')
# Return the volume index of a file
def select_volume(filename, which):
from nibabel import load
import numpy as np
