def test_surfxfm(create_surf_file_in_directory):
xfm = fs.SurfaceTransform()
# Test underlying command
assert xfm.cmd == "mri_surf2surf"
# Test mandatory args exception
with pytest.raises(ValueError):
xfm.run()
# Create testing files
surf, cwd = create_surf_file_in_directory
# Test input settings
xfm.inputs.source_file = surf
xfm.inputs.source_subject = "my_subject"
xfm.inputs.target_subject = "fsaverage"
xfm.inputs.hemi = "lh"
# Test the command line
assert xfm.cmdline == \
("mri_surf2surf --hemi lh --tval %s/lh.a.fsaverage.nii --sval %s --srcsubject my_subject --trgsubject fsaverage" %
(cwd, surf))
# Test identity
xfmish = fs.SurfaceTransform(source_subject="fsaverage",
target_subject="my_subject",
source_file=surf,
hemi="lh")
assert xfm != xfmish
def test_surfxfm():
xfm = fs.SurfaceTransform()
# Test underlying command
yield assert_equal, xfm.cmd, "mri_surf2surf"
# Test mandatory args exception
yield assert_raises, ValueError, xfm.run
# Create testing files
surf, cwd, oldwd = create_surf_file()
# Test input settings
xfm.inputs.source_file = surf
xfm.inputs.source_subject = "my_subject"
xfm.inputs.target_subject = "fsaverage"
xfm.inputs.hemi = "lh"
# Test the command line
yield assert_equal, xfm.cmdline, \
("mri_surf2surf --hemi lh --tval %s/lh.a.fsaverage.nii --sval %s --srcsubject my_subject --trgsubject fsaverage" %
(cwd, surf))
# Test identity
xfmish = fs.SurfaceTransform(source_subject="fsaverage",
target_subject="my_subject",
source_file=surf,
hemi="lh")
yield assert_not_equal, xfm, xfmish
# Clean up
clean_directory(cwd, oldwd)
def nipype_mri_surf2surf(t1path, hemi):
splitpath = t1path.split(os.sep)
fsdir = os.path.join(BIDS_DATA_DIR, "derivatives",
"freesurfer_{0}".format(splitpath[-3]))
outdir = os.path.join(BIDS_DATA_DIR, "derivatives",
"freesurfer_projection_{0}".format(splitpath[-3]),
splitpath[-4])
funcpath = os.path.join(
BIDS_DATA_DIR, "derivatives", "spmpreproc_{0}".format(splitpath[-3]),
splitpath[-4],
"wrr{0}_{1}_task-localizer_bold.nii.gz".format(splitpath[-4],
splitpath[-3]))
assert os.path.isfile(funcpath), funcpath
basename = os.path.basename(funcpath).replace(".nii.gz", "")
texturefile = os.path.join(outdir, basename + ".{0}.gii".format(hemi))
smoothfile = os.path.join(outdir, basename + ".s5.{0}.gii".format(hemi))
if not os.path.isfile(texturefile):
raise ValueError("Oups!: {0}".format(path))
if not os.path.isfile(smoothfile):
open(smoothfile, "wt").close()
surf2surf = freesurfer.SurfaceSmooth(in_file=texturefile,
hemi=hemi,
subject_id=splitpath[-4],
fwhm=5,
out_file=smoothfile,
subjects_dir=fsdir)
print(surf2surf.cmdline)
if PROCESS:
surf2surf.run()
surf2surf = freesurfer.SurfaceTransform(
hemi=hemi,
source_subject=splitpath[-4],
source_file=smoothfile,
target_subject="ico",
target_ico_order=7,
out_file=os.path.join(outdir,
basename + ".ico7.s5.{0}.gii".format(hemi)),
subjects_dir=fsdir)
print(surf2surf.cmdline)
if PROCESS:
surf2surf.run()
def segstats_workflow(c, name='segstats'):
import nipype.interfaces.fsl as fsl
import nipype.interfaces.freesurfer as fs
import nipype.interfaces.io as nio
import nipype.pipeline.engine as pe
import nipype.interfaces.utility as niu
from .scripts.u0a14c5b5899911e1bca80023dfa375f2.modified_nipype_workflows import create_get_stats_flow
from .scripts.u0a14c5b5899911e1bca80023dfa375f2.utils import tolist, pickidx
if not c.use_annotation:
workflow = create_get_stats_flow(name='segstats', withreg=c.use_reg)
else:
workflow = create_get_stats_flow(name='segstats')
workflow.inputs.segstats.avgwf_txt_file = True
datagrabber = c.datagrabber.create_dataflow()
merge = pe.Node(fsl.Merge(dimension='t'), name='merge_files')
inputspec = workflow.get_node('inputspec')
subject_iterable = datagrabber.get_node("subject_id_iterable")
# merge files grabbed
stats = workflow.get_node('segstats')
print "colortablefile:", c.color_table_file
if c.color_table_file == "Default":
stats.inputs.default_color_table = True
elif c.color_table_file == "Color_Table":
stats.inputs.color_table_file = c.color_file
elif c.color_table_file == "GCA_color_table":
stats.inputs.gca_color_table = c.color_file
workflow.connect(datagrabber, ('datagrabber.in_files', tolist), merge,
'in_files')
doubler = lambda x: [x, x]
# This means you're using an annotation from a standard surface
if c.use_annotation:
surf2surf = pe.MapNode(fs.SurfaceTransform(
source_subject=c.annot_space, subjects_dir=c.surf_dir),
name="surf2surf",
iterfield=['hemi', 'source_annot_file'])
surf2surf.inputs.source_annot_file = [c.lh_annotation, c.rh_annotation]
workflow.connect(subject_iterable, "subject_id", surf2surf,
"target_subject")
surf2surf.inputs.hemi = ['lh', 'rh']
#add = pe.Node(fsl.BinaryMaths(operation='add'),name="add")
#workflow.connect(add,'out_file',inputspec,"label_file")
label2vol = pe.MapNode(fs.Label2Vol(subjects_dir=c.surf_dir,
proj=c.proj),
name='label2vol',
iterfield=["hemi", "annot_file"])
workflow.connect(surf2surf, "out_file", label2vol, "annot_file")
workflow.connect(subject_iterable, "subject_id", label2vol,
"subject_id")
workflow.connect(merge, "merged_file", label2vol, "template_file")
label2vol.inputs.hemi = ['lh', 'rh']
workflow.connect(datagrabber, 'datagrabber.reg_file', label2vol,
'reg_file')
if c.inverse_reg:
label2vol.inputs.invert_mtx = c.inverse_reg
workflow.connect(label2vol, 'vol_label_file', inputspec, 'label_file')
workflow.connect(merge, ('merged_file', doubler), inputspec,
'source_file')
#This means you're using annotations on the subjects surface
if c.use_subject_annotation:
label2vol = pe.MapNode(fs.Label2Vol(subjects_dir=c.surf_dir,
proj=c.proj),
name='label2vol',
iterfield=["hemi", "annot_file"])
label2vol.inputs.hemi = ['lh', 'rh']
workflow.connect(datagrabber, "datagrabber.label_file", label2vol,
"annot_file")
workflow.connect(subject_iterable, "subject_id", label2vol,
"subject_id")
workflow.connect(merge, "merged_file", label2vol, "template_file")
workflow.connect(label2vol, 'vol_label_file', inputspec, "label_file")
workflow.connect(merge, ('merged_file', doubler), inputspec,
'source_file')
workflow.connect(datagrabber, 'datagrabber.reg_file', label2vol,
'reg_file')
if c.inverse_reg:
label2vol.inputs.invert_mtx = c.inverse_reg
if not c.use_subject_annotation and not c.use_annotation:
workflow.connect(merge, 'merged_file', inputspec, 'source_file')
# This means you're using a labeled volume like aparc+aseg
if c.use_reg and not c.use_annotation and not c.use_subject_annotation:
workflow.connect(datagrabber, 'datagrabber.reg_file', inputspec,
'reg_file')
workflow.inputs.inputspec.subjects_dir = c.surf_dir
workflow.inputs.inputspec.inverse = c.inverse_reg
if c.use_standard_label and not c.use_annotation and not c.use_subject_annotation:
workflow.inputs.inputspec.label_file = c.label_file
elif not c.use_standard_label and not c.use_annotation and not c.use_subject_annotation:
workflow.connect(datagrabber, 'datagrabber.label_file', inputspec,
"label_file")
sinker = pe.Node(nio.DataSink(), name='sinker')
sinker.inputs.base_directory = os.path.join(c.sink_dir)
workflow.connect(subject_iterable, 'subject_id', sinker, 'container')
def get_subs(subject_id, subject_annot):
subs = [('_subject_id_%s' % subject_id, '')]
if subject_annot:
subs.append(('_segstats0/summary.stats', 'lh.summary.stats'))
subs.append(('_segstats1/summary.stats', 'rh.summary.stats'))
subs.append(('_segstats0', ''))
subs.append(('_segstats1', ''))
else:
subs.append(('_segstats0', ''))
return subs
workflow.connect(
subject_iterable,
('subject_id', get_subs, c.use_subject_annotation or c.use_annotation),
sinker, 'substitutions')
outputspec = workflow.get_node('outputspec')
workflow.connect(outputspec, 'stats_file', sinker,
'segstats.%s.@stats' % c.statname)
workflow.connect(stats, "avgwf_txt_file", sinker,
'segstats.%s.@avg' % c.statname)
return workflow
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
def create_surface_projection_workflow(name="surface_projection"):
# Define the workflow inputs
inputnode = pe.Node(util.IdentityInterface(
fields=["subject_id", "timeseries", "tkreg_affine", "smooth_fwhm"]),
name="inputs")
# Set up a hemisphere iterable
hemisource = pe.Node(util.IdentityInterface(fields=["hemi"]),
iterables=("hemi", ["lh", "rh"]),
name="hemisource")
# Project data onto the surface mesh
surfproject = pe.MapNode(fs.SampleToSurface(sampling_range=(0, 1, .1),
sampling_units="frac",
cortex_mask=True),
iterfield=["source_file", "reg_file"],
name="surfproject")
surfproject.inputs.sampling_method = "average"
# Apply the spherical warp to the data to bring into fsaverage space
surftransform = pe.MapNode(fs.SurfaceTransform(target_subject="fsaverage",
reshape=True),
iterfield=["source_file"],
name="surftransform")
# Smooth the data along the surface
smoothnormsurf = pe.MapNode(fs.SurfaceSmooth(subject_id="fsaverage",
reshape=True),
iterfield=["in_file"],
name="smoothnormsurf")
# Convert the fsaverage surface to nifti
cvtnormsurf = pe.MapNode(fs.MRIConvert(out_type="niigz"),
iterfield=["in_file"],
name="convertnormsurf")
# Rename the timeseries
rename = pe.MapNode(util.Rename(
format_string="%(hemi)s.timeseries.fsaverage", keep_ext=True),
iterfield=["in_file"],
name="rename")
# Define the outputs
outputnode = pe.Node(util.IdentityInterface(fields=["timeseries"]),
name="outputs")
# Define and connect the workflow
tosurf = pe.Workflow(name=name)
tosurf.connect([
(inputnode, surfproject, [("timeseries", "source_file"),
("subject_id", "subject_id"),
("tkreg_affine", "reg_file")]),
(hemisource, surfproject, [("hemi", "hemi")]),
(surfproject, surftransform, [("out_file", "source_file")]),
(inputnode, surftransform, [("subject_id", "source_subject")]),
(hemisource, surftransform, [("hemi", "hemi")]),
(surftransform, smoothnormsurf, [("out_file", "in_file")]),
(hemisource, smoothnormsurf, [("hemi", "hemi")]),
(inputnode, smoothnormsurf, [("smooth_fwhm", "fwhm")]),
(smoothnormsurf, cvtnormsurf, [("out_file", "in_file")]),
(cvtnormsurf, rename, [("out_file", "in_file")]),
(hemisource, rename, [("hemi", "hemi")]),
(rename, outputnode, [("out_file", "timeseries")]),
])
return tosurf
def segstats_workflow(c, name='segstats'):
import nipype.interfaces.fsl as fsl
import nipype.interfaces.freesurfer as fs
import nipype.interfaces.io as nio
import nipype.pipeline.engine as pe
from .scripts.u0a14c5b5899911e1bca80023dfa375f2.modified_nipype_workflows import create_get_stats_flow
from .scripts.u0a14c5b5899911e1bca80023dfa375f2.utils import tolist, pickidx
if not c.use_annotation:
workflow = create_get_stats_flow(name='segstats', withreg=c.use_reg)
else:
workflow = create_get_stats_flow(name='segstats')
workflow.inputs.segstats.avgwf_txt_file = True
datagrabber = c.datagrabber.create_dataflow()
merge = pe.Node(fsl.Merge(dimension='t'), name='merge_files')
inputspec = workflow.get_node('inputspec')
subject_iterable = datagrabber.get_node("subject_id_iterable")
# merge files grabbed
stats = workflow.get_node('segstats')
print "colortablefile:", c.color_table_file
if c.color_table_file == "Default":
stats.inputs.default_color_table = True
elif c.color_table_file == "Color_Table":
stats.inputs.color_table_file = c.color_file
elif c.color_table_file == "GCA_color_table":
stats.inputs.gca_color_table = c.color_file
workflow.connect(datagrabber, ('datagrabber.in_files', tolist), merge,
'in_files')
if c.use_annotation:
surf2surf = pe.MapNode(fs.SurfaceTransform(
source_subject=c.annot_space, subjects_dir=c.surf_dir),
name="surf2surf",
iterfield=['hemi', 'source_annot_file'])
surf2surf.inputs.source_annot_file = [c.lh_annotation, c.rh_annotation]
workflow.connect(subject_iterable, "subject_id", surf2surf,
"target_subject")
surf2surf.inputs.hemi = ['lh', 'rh']
add = pe.Node(fsl.BinaryMaths(operation='add'), name="add")
workflow.connect(add, 'out_file', inputspec, "label_file")
label2vol = pe.MapNode(fs.Label2Vol(subjects_dir=c.surf_dir,
proj=c.proj),
name='label2vol',
iterfield=["hemi", "annot_file"])
workflow.connect(surf2surf, "out_file", label2vol, "annot_file")
workflow.connect(subject_iterable, "subject_id", label2vol,
"subject_id")
#fssource = pe.Node(nio.FreeSurferSource(subjects_dir = c.surf_dir),name='fssource')
#workflow.connect(subject_iterable,"subject_id",fssource,"subject_id")
#workflow.connect(subject_iterable,"subject_id",label2vol,"reg_header")
#workflow.connect(fssource,"orig",label2vol,"template_file")
workflow.connect(merge, "merged_file", label2vol, "template_file")
label2vol.inputs.hemi = ['lh', 'rh']
workflow.connect(datagrabber, 'datagrabber.reg_file', label2vol,
'reg_file')
if c.inverse_reg:
label2vol.inputs.invert_mtx = c.inverse_reg
workflow.connect(label2vol, ('vol_label_file', pickidx, 0), add,
'in_file')
workflow.connect(label2vol, ('vol_label_file', pickidx, 1), add,
'operand_file')
workflow.connect(merge, 'merged_file', inputspec, 'source_file')
if c.use_reg and not c.use_annotation:
workflow.connect(datagrabber, 'datagrabber.reg_file', inputspec,
'reg_file')
workflow.inputs.inputspec.subjects_dir = c.surf_dir
workflow.inputs.inputspec.inverse = c.inverse_reg
if c.use_standard_label and not c.use_annotation:
workflow.inputs.inputspec.label_file = c.label_file
elif not c.use_standard_label and not c.use_annotation:
workflow.connect(datagrabber, 'datagrabber.label_file', inputspec,
"label_file")
sinker = pe.Node(nio.DataSink(), name='sinker')
sinker.inputs.base_directory = c.sink_dir
workflow.connect(subject_iterable, 'subject_id', sinker, 'container')
def get_subs(subject_id):
subs = [('_subject_id_%s' % subject_id, '')]
return subs
workflow.connect(subject_iterable, ('subject_id', get_subs), sinker,
'substitutions')
outputspec = workflow.get_node('outputspec')
workflow.connect(outputspec, 'stats_file', sinker, 'segstats.@stats')
workflow.connect(stats, "avgwf_txt_file", sinker, 'segstats.@avg')
return workflow
def get_wf():
import numpy as np
wf = pe.Workflow(name="main_workflow")
wf.base_dir = os.path.join(workingdir, "rs_preprocessing/")
wf.config['execution']['crashdump_dir'] = wf.base_dir + "crash_files/"
##Infosource##
subject_id_infosource = pe.Node(
util.IdentityInterface(fields=['subject_id']),
name="subject_id_infosource")
subject_id_infosource.iterables = ('subject_id', subjects)
session_infosource = pe.Node(util.IdentityInterface(fields=['session']),
name="session_infosource")
session_infosource.iterables = ('session', sessions)
hemi_infosource = pe.Node(util.IdentityInterface(fields=['hemi']),
name="hemi_infosource")
hemi_infosource.iterables = ('hemi', hemispheres)
fs_infosource = pe.Node(util.IdentityInterface(fields=['fs']),
name="fs_infosource")
fs_infosource.iterables = ('fs', fsaverage)
##Datagrabber##
datagrabber = pe.Node(nio.DataGrabber(
infields=['subject_id'],
outfields=['resting_nifti', 't1_nifti', 'dicoms']),
name="datagrabber",
overwrite=True)
datagrabber.inputs.base_directory = '/'
datagrabber.inputs.template = '*'
datagrabber.inputs.field_template = rs_preprocessing_dg_template
datagrabber.inputs.template_args = rs_preprocessing_dg_args
datagrabber.inputs.sort_filelist = True
wf.connect(subject_id_infosource, 'subject_id', datagrabber, 'subject_id')
wf.connect(session_infosource, 'session', datagrabber, 'session')
##DcmStack & MetaData##
dicom_filedir = pe.Node(name='dicom_filedir',
interface=util.Function(
input_names=['subject_id', 'session'],
output_names=['filedir'],
function=construct_dicomfiledir))
stack = pe.Node(dcm.DcmStack(), name='stack')
stack.inputs.embed_meta = True
tr_lookup = pe.Node(dcm.LookupMeta(), name='tr_lookup')
tr_lookup.inputs.meta_keys = {'RepetitionTime': 'TR'}
wf.connect(subject_id_infosource, 'subject_id', dicom_filedir,
'subject_id')
wf.connect(session_infosource, 'session', dicom_filedir, 'session')
wf.connect(dicom_filedir, 'filedir', stack, 'dicom_files')
wf.connect(stack, 'out_file', tr_lookup, 'in_file')
##Preproc from BIPs##
preproc = create_rest_prep(name="bips_resting_preproc", fieldmap=False)
zscore = preproc.get_node('z_score')
preproc.remove_nodes([zscore])
mod_realign = preproc.get_node('mod_realign')
mod_realign.plugin_args = {'submit_specs': 'request_memory=4000\n'}
#workaround for realignment crashing in multiproc environment
mod_realign.run_without_submitting = True
# inputs
preproc.inputs.inputspec.motion_correct_node = 'nipy'
ad = preproc.get_node('artifactdetect')
preproc.disconnect(mod_realign, 'parameter_source', ad, 'parameter_source')
ad.inputs.parameter_source = 'NiPy'
preproc.inputs.inputspec.realign_parameters = {
"loops": [5],
"speedup": [5]
}
preproc.inputs.inputspec.do_whitening = False
preproc.inputs.inputspec.timepoints_to_remove = 4
preproc.inputs.inputspec.smooth_type = 'susan'
preproc.inputs.inputspec.do_despike = False
preproc.inputs.inputspec.surface_fwhm = 0.0
preproc.inputs.inputspec.num_noise_components = 6
preproc.inputs.inputspec.regress_before_PCA = False
preproc.get_node('fwhm_input').iterables = ('fwhm', [0, 5])
preproc.get_node('take_mean_art').get_node(
'strict_artifact_detect').inputs.save_plot = True
preproc.inputs.inputspec.ad_normthresh = 1
preproc.inputs.inputspec.ad_zthresh = 3
preproc.inputs.inputspec.do_slicetime = True
preproc.inputs.inputspec.compcor_select = [True, True]
preproc.inputs.inputspec.filter_type = 'fsl'
preproc.get_node('bandpass_filter').iterables = [('highpass_freq', [0.01]),
('lowpass_freq', [0.1])]
preproc.inputs.inputspec.reg_params = [
True, True, True, False, True, False
]
preproc.inputs.inputspec.fssubject_dir = freesurferdir
#preproc.inputs.inputspec.tr = 1400/1000
#preproc.inputs.inputspec.motion_correct_node = 'afni'
#preproc.inputs.inputspec.sliceorder = slicetime_file
#preproc.inputs.inputspec.sliceorder = list(np.linspace(0,1.4,64))
def convert_units(tr):
mstr = (tr * .001)
return tr
def get_sliceorder(in_file):
import nipype.interfaces.dcmstack as dcm
import numpy as np
nii_wrp = dcm.NiftiWrapper.from_filename(in_file)
sliceorder = np.argsort(
np.argsort(
nii_wrp.meta_ext.get_values('CsaImage.MosaicRefAcqTimes')
[0])).tolist()
return sliceorder
wf.connect(tr_lookup, ("TR", convert_units), preproc, "inputspec.tr")
wf.connect(stack, ('out_file', get_sliceorder), preproc,
"inputspec.sliceorder")
wf.connect(subject_id_infosource, 'subject_id', preproc,
"inputspec.fssubject_id")
wf.connect(datagrabber, "resting_nifti", preproc, "inputspec.func")
##Sampler##
sampler = pe.Node(fs.SampleToSurface(), name='sampler')
sampler.inputs.sampling_method = 'average'
sampler.inputs.sampling_range = (0.2, 0.8, 0.1)
sampler.inputs.sampling_units = 'frac'
sampler.inputs.interp_method = 'nearest'
sampler.inputs.out_type = 'nii'
wf.connect(preproc, ('bandpass_filter.out_file', list_to_filename),
sampler, 'source_file')
wf.connect(preproc, ('getmask.register.out_reg_file', list_to_filename),
sampler, 'reg_file')
wf.connect(hemi_infosource, 'hemi', sampler, 'hemi')
##SXFM##
sxfm = pe.Node(fs.SurfaceTransform(), name='sxfm')
sxfm.inputs.args = '--cortex --fwhm-src 5 --noreshape'
sxfm.inputs.target_type = 'nii'
wf.connect(sampler, 'out_file', sxfm, 'source_file')
wf.connect(subject_id_infosource, 'subject_id', sxfm, 'source_subject')
wf.connect(hemi_infosource, 'hemi', sxfm, 'hemi')
wf.connect(fs_infosource, 'fs', sxfm, 'target_subject')
###########
#report_wf = create_preproc_report_wf(os.path.join(preprocdir, "reports"))
#report_wf.inputs.inputspec.fssubjects_dir = preproc.inputs.inputspec.fssubject_dir
def pick_full_brain_ribbon(l):
import os
for path in l:
if os.path.split(path)[1] == "ribbon.mgz":
return path
#wf.connect(preproc,"artifactdetect.plot_files", report_wf, "inputspec.art_detect_plot")
#wf.connect(preproc,"take_mean_art.weighted_mean.mean_image", report_wf, "inputspec.mean_epi")
#wf.connect(preproc,("getmask.register.out_reg_file", list_to_filename), report_wf, "inputspec.reg_file")
#wf.connect(preproc,("getmask.fssource.ribbon",pick_full_brain_ribbon), report_wf, "inputspec.ribbon")
#wf.connect(preproc,("CompCor.tsnr.tsnr_file", list_to_filename), report_wf, "inputspec.tsnr_file")
#wf.connect(subject_id_infosource, 'subject_id', report_wf, "inputspec.subject_id")
##Datasink##
ds = pe.Node(nio.DataSink(), name="datasink")
ds.inputs.base_directory = os.path.join(preprocdir, "aimivolumes")
wf.connect(preproc, 'bandpass_filter.out_file', ds, "preprocessed_resting")
wf.connect(preproc, 'getmask.register.out_fsl_file', ds,
"func2anat_transform")
wf.connect(sampler, 'out_file', ds, 'sampledtosurf')
wf.connect(sxfm, 'out_file', ds, 'sxfmout')
#wf.write_graph()
return wf
def create_ml_preprocess_workflow(
name,
project_dir,
work_dir,
sessions_file,
session_template,
fs_dir,
annot_template='{subject_id}/label/{hemi}.aparc.a2009s.annot',
fwhm_vals=[2],
ico_order_vals=[4],
do_save_vol_ds=False,
do_save_smooth_vol_ds=False,
do_save_surface_smooth_vol_ds=False,
do_save_surface_ds=False,
do_save_smooth_surface_ds=False,
do_save_sphere_nifti=False,
do_save_sphere_ds=True,
do_save_join_sessions_ds=True,
do_save_join_subjects_ds=True):
#initialize workflow
workflow = pe.Workflow(name=name)
workflow.base_dir = work_dir
sessions_info = ColumnData(sessions_file, dtype=str)
subject_ids = set(sessions_info['subject_id'])
session_map = [
(sid, [s for i, s, r in zip(*sessions_info.values()) if i == sid])
for sid in subject_ids
]
##for each subject
subjects = pe.Node(interface=util.IdentityInterface(fields=['subject_id']),
name='subjects')
subjects.iterables = [('subject_id', subject_ids)]
##for each session
sessions = pe.Node(
interface=util.IdentityInterface(fields=['subject_id', 'session_dir']),
name='sessions')
sessions.itersource = ('subjects', 'subject_id')
sessions.iterables = [('session_dir', dict(session_map))]
workflow.connect(subjects, 'subject_id', sessions, 'subject_id')
#get session directory
get_session_dir = pe.Node(interface=nio.SelectFiles(session_template),
name='get_session_dir')
workflow.connect(sessions, 'session_dir', get_session_dir, 'session_dir')
#save outputs
datasink = pe.Node(nio.DataSink(), name='datasink')
datasink.inputs.parameterization = False
workflow.connect(get_session_dir, 'session_dir', datasink,
'base_directory')
template = {
'nifti_file': 'mri/f.nii.gz',
'attributes_file': 'attributes.txt',
'reg_file': 'mri/transforms/functional_to_anatomy.dat'
}
get_files = pe.Node(nio.SelectFiles(template), name='get_files')
workflow.connect(get_session_dir, 'session_dir', get_files,
'base_directory')
vol_to_ds = pe.Node(nmutil.NiftiToDataset(), name='vol_to_ds')
vol_to_ds.inputs.ds_file = 'vol.hdf5'
workflow.connect(get_files, 'nifti_file', vol_to_ds, 'nifti_file')
workflow.connect(get_files, 'attributes_file', vol_to_ds,
'attributes_file')
workflow.connect(subjects, 'subject_id', vol_to_ds, 'subject_id')
workflow.connect(sessions, 'session_dir', vol_to_ds, 'session_id')
if do_save_vol_ds:
workflow.connect(vol_to_ds, 'ds_file', datasink, 'ml.@vol')
fwhm = pe.Node(util.IdentityInterface(fields=['fwhm']), name='fwhm')
fwhm.iterables = [('fwhm', fwhm_vals)]
if do_save_smooth_vol_ds:
smooth_vol = pe.Node(interface=fs.MRIConvert(), name='smooth_vol')
workflow.connect(get_files, 'nifti_file', smooth_vol, 'in_file')
workflow.connect(fwhm, 'fwhm', smooth_vol, 'fwhm')
smooth_vol_to_ds = pe.Node(nmutil.NiftiToDataset(),
name='smooth_vol_to_ds')
smooth_vol_to_ds.inputs.ds_file = 'smooth_vol.hdf5'
workflow.connect(smooth_vol, 'out_file', smooth_vol_to_ds,
'nifti_file')
workflow.connect(get_files, 'attributes_file', smooth_vol_to_ds,
'attributes_file')
workflow.connect(subjects, 'subject_id', smooth_vol_to_ds,
'subject_id')
workflow.connect(sessions, 'session_dir', smooth_vol_to_ds,
'session_id')
workflow.connect(smooth_vol_to_ds, 'ds_file', datasink,
'ml.@smooth_vol')
if do_save_surface_smooth_vol_ds:
surface_smooth_vol = pe.Node(interface=fs.Smooth(),
name='surface_smooth_vol')
workflow.connect(get_files, 'reg_file', surface_smooth_vol, 'reg_file')
workflow.connect(get_files, 'nifti_file', surface_smooth_vol,
'in_file')
workflow.connect(fwhm, 'fwhm', surface_smooth_vol, 'surface_fwhm')
surface_smooth_vol_to_ds = pe.Node(nmutil.NiftiToDataset(),
name='surface_smooth_vol_to_ds')
surface_smooth_vol_to_ds.inputs.ds_file = 'surface_smooth_vol.hdf5'
workflow.connect(surface_smooth_vol, 'out_file',
surface_smooth_vol_to_ds, 'nifti_file')
workflow.connect(get_files, 'attributes_file',
surface_smooth_vol_to_ds, 'attributes_file')
workflow.connect(subjects, 'subject_id', surface_smooth_vol_to_ds,
'subject_id')
workflow.connect(sessions, 'session_dir', surface_smooth_vol_to_ds,
'session_id')
workflow.connect(surface_smooth_vol_to_ds, 'ds_file', datasink,
'ml.@surface_smooth_vol')
hemi = pe.Node(util.IdentityInterface(fields=['hemi']), name='hemi')
hemi.iterables = [('hemi', ['lh', 'rh'])]
to_surface = pe.Node(fs.SampleToSurface(), name='to_surface')
to_surface.inputs.sampling_method = 'average'
to_surface.inputs.sampling_range = (0., 1., 0.1)
to_surface.inputs.sampling_units = 'frac'
to_surface.inputs.subjects_dir = fs_dir
workflow.connect(hemi, 'hemi', to_surface, 'hemi')
workflow.connect(get_files, 'nifti_file', to_surface, 'source_file')
workflow.connect(get_files, 'reg_file', to_surface, 'reg_file')
if do_save_surface_ds:
surface_to_ds = pe.Node(nmutil.NiftiToDataset(), name='surface_to_ds')
workflow.connect(to_surface, 'out_file', surface_to_ds, 'nifti_file')
workflow.connect(get_files, 'attributes_file', surface_to_ds,
'attributes_file')
workflow.connect(subjects, 'subject_id', surface_to_ds, 'subject_id')
workflow.connect(sessions, 'session_dir', surface_to_ds, 'session_id')
join_surfaces = pe.JoinNode(nmutil.JoinDatasets(),
name='join_surfaces',
joinsource='hemi',
joinfield='input_datasets')
join_surfaces.inputs.joined_dataset = 'surface.hdf5'
join_surfaces.inputs.join_hemispheres = True
workflow.connect(surface_to_ds, 'ds_file', join_surfaces,
'input_datasets')
workflow.connect(join_surfaces, 'joined_dataset', datasink,
'ml.@surface')
smooth_surface = pe.Node(fs.SurfaceSmooth(), name='smooth_surface')
smooth_surface.inputs.subjects_dir = fs_dir
workflow.connect(to_surface, 'out_file', smooth_surface, 'in_file')
workflow.connect(sessions, 'subject_id', smooth_surface, 'subject_id')
workflow.connect(hemi, 'hemi', smooth_surface, 'hemi')
workflow.connect(fwhm, 'fwhm', smooth_surface, 'fwhm')
if do_save_smooth_surface_ds:
smooth_surface_to_ds = pe.Node(nmutil.NiftiToDataset(),
name='smooth_surface_to_ds')
workflow.connect(smooth_surface, 'out_file', smooth_surface_to_ds,
'nifti_file')
workflow.connect(get_files, 'attributes_file', smooth_surface_to_ds,
'attributes_file')
workflow.connect(subjects, 'subject_id', smooth_surface_to_ds,
'subject_id')
workflow.connect(sessions, 'session_dir', smooth_surface_to_ds,
'session_id')
join_smooth_surfaces = pe.JoinNode(nmutil.JoinDatasets(),
name='join_smooth_surfaces',
joinsource='hemi',
joinfield='input_datasets')
join_smooth_surfaces.inputs.joined_dataset = 'smooth_surface.hdf5'
join_smooth_surfaces.inputs.join_hemispheres = True
workflow.connect(smooth_surface_to_ds, 'ds_file', join_smooth_surfaces,
'input_datasets')
workflow.connect(join_smooth_surfaces, 'joined_dataset', datasink,
'ml.@smooth_surface')
ico_order = pe.Node(util.IdentityInterface(fields=['ico_order']),
name='ico_order')
ico_order.iterables = [('ico_order', ico_order_vals)]
to_sphere = pe.Node(fs.SurfaceTransform(), name='to_sphere')
to_sphere.inputs.target_subject = 'ico'
to_sphere.inputs.subjects_dir = fs_dir
workflow.connect(hemi, 'hemi', to_sphere, 'hemi')
workflow.connect(smooth_surface, 'out_file', to_sphere, 'source_file')
workflow.connect(subjects, 'subject_id', to_sphere, 'source_subject')
workflow.connect(ico_order, 'ico_order', to_sphere, 'target_ico_order')
if do_save_sphere_nifti:
workflow.connect(to_sphere, 'out_file', datasink, 'surf.@sphere')
template = {'annot_file': annot_template}
get_annot_file = pe.Node(nio.SelectFiles(template), name='get_annot_file')
get_annot_file.inputs.base_directory = fs_dir
get_annot_file.inputs.subject_id = 'fsaverage'
workflow.connect(hemi, 'hemi', get_annot_file, 'hemi')
transform_annot = pe.Node(fs.SurfaceTransform(), name='transform_annot')
transform_annot.inputs.source_subject = 'fsaverage'
transform_annot.inputs.target_subject = 'ico'
transform_annot.inputs.subjects_dir = fs_dir
workflow.connect(hemi, 'hemi', transform_annot, 'hemi')
workflow.connect(get_annot_file, 'annot_file', transform_annot,
'source_annot_file')
workflow.connect(ico_order, 'ico_order', transform_annot,
'target_ico_order')
sphere_to_ds = pe.Node(nmutil.NiftiToDataset(), name='sphere_to_ds')
workflow.connect(to_sphere, 'out_file', sphere_to_ds, 'nifti_file')
workflow.connect(get_files, 'attributes_file', sphere_to_ds,
'attributes_file')
workflow.connect(transform_annot, 'out_file', sphere_to_ds, 'annot_file')
workflow.connect(subjects, 'subject_id', sphere_to_ds, 'subject_id')
workflow.connect(sessions, 'session_dir', sphere_to_ds, 'session_id')
join_hemispheres = pe.JoinNode(nmutil.JoinDatasets(),
name='join_hemispheres',
joinsource='hemi',
joinfield='input_datasets')
join_hemispheres.inputs.joined_dataset = 'sphere.hdf5'
join_hemispheres.inputs.join_hemispheres = True
workflow.connect(sphere_to_ds, 'ds_file', join_hemispheres,
'input_datasets')
if do_save_sphere_ds:
workflow.connect(join_hemispheres, 'joined_dataset', datasink,
'ml.@sphere')
join_sessions = pe.JoinNode(nmutil.JoinDatasets(),
name='join_sessions',
joinsource='sessions',
joinfield='input_datasets')
workflow.connect(join_hemispheres, 'joined_dataset', join_sessions,
'input_datasets')
if do_save_join_sessions_ds:
join_sessions_sink = pe.Node(nio.DataSink(), name='join_sessions_sink')
join_sessions_sink.inputs.parameterization = False
join_sessions_sink.inputs.base_directory = os.path.join(
project_dir, 'ml')
workflow.connect(subjects, 'subject_id', join_sessions_sink,
'container')
workflow.connect(join_sessions, 'joined_dataset', join_sessions_sink,
'@join_sessions')
join_subjects = pe.JoinNode(nmutil.JoinDatasets(),
name='join_subjects',
joinsource='subjects',
joinfield='input_datasets')
workflow.connect(join_sessions, 'joined_dataset', join_subjects,
'input_datasets')
if do_save_join_subjects_ds:
join_subjects_sink = pe.Node(nio.DataSink(), name='join_subjects_sink')
join_subjects_sink.inputs.parameterization = False
join_subjects_sink.inputs.base_directory = os.path.join(
project_dir, 'ml')
workflow.connect(join_subjects, 'joined_dataset', join_subjects_sink,
'@join_subjects')
return workflow