def test_segment():
if spm.Info.name() == "SPM12":
assert spm.Segment()._jobtype == "tools"
assert spm.Segment()._jobname == "oldseg"
else:
assert spm.Segment()._jobtype == "spatial"
assert spm.Segment()._jobname == "preproc"
def test_segment():
if spm.Info.version()['name'] == "SPM12":
yield assert_equal, spm.Segment()._jobtype, 'tools'
yield assert_equal, spm.Segment()._jobname, 'oldseg'
else:
yield assert_equal, spm.Segment()._jobtype, 'spatial'
yield assert_equal, spm.Segment()._jobname, 'preproc'
def test_segment():
if spm.Info.version()['name'] == "SPM12":
assert spm.Segment()._jobtype == 'tools'
assert spm.Segment()._jobname == 'oldseg'
else:
assert spm.Segment()._jobtype == 'spatial'
assert spm.Segment()._jobname == 'preproc'
def __init__(self, data=['path'], **options):
import nipype.interfaces.spm as spm
seg = spm.Segment()
seg.inputs.data = data
for ef in options:
setattr(seg.inputs, ef, options[ef])
self.res = seg.run()
def __init__(self, name, base_dir=None):
super(BrainExtractionWorkflow, self).__init__(name, base_dir)
# Segmentation
# ============
seg_node = npe.MapNode(name="Segmentation",
iterfield="data",
interface=spm.Segment())
seg_node.inputs.gm_output_type = [False, False, True]
seg_node.inputs.wm_output_type = [False, False, True]
seg_node.inputs.csf_output_type = [False, False, True]
add1_node = npe.MapNode(name="AddGMWM",
iterfield=["in_file", "operand_file"],
interface=fsl.BinaryMaths())
add1_node.inputs.operation = 'add'
add2_node = npe.MapNode(name="AddGMWMCSF",
iterfield=["in_file", "operand_file"],
interface=fsl.BinaryMaths())
add2_node.inputs.operation = 'add'
dil_node = npe.MapNode(name="Dilate",
iterfield="in_file",
interface=fsl.DilateImage())
dil_node.inputs.operation = 'mean'
ero_node = npe.MapNode(name="Erode",
iterfield="in_file",
interface=fsl.ErodeImage())
thre_node = npe.MapNode(name="Threshold",
iterfield="in_file",
interface=fsl.Threshold())
thre_node.inputs.thresh = 0.5
fill_node = npe.MapNode(name="Fill",
iterfield="in_file",
interface=fsl.UnaryMaths())
fill_node.inputs.operation = 'fillh'
mask_node = npe.MapNode(name="ApplyMask",
iterfield=["in_file", "mask_file"],
interface=fsl.ApplyMask())
mask_node.inputs.output_type = str("NIFTI")
self.connect([
(seg_node, add1_node, [('native_gm_image', 'in_file')]),
(seg_node, add1_node, [('native_wm_image', 'operand_file')]),
(seg_node, add2_node, [('native_csf_image', 'in_file')]),
(add1_node, add2_node, [('out_file', 'operand_file')]),
(add2_node, dil_node, [('out_file', 'in_file')]),
(dil_node, ero_node, [('out_file', 'in_file')]),
(ero_node, thre_node, [('out_file', 'in_file')]),
(thre_node, fill_node, [('out_file', 'in_file')]),
(fill_node, mask_node, [('out_file', 'mask_file')]),
])
def __init__(self, experiment_dir, output_dir, working_dir, func_source,
struct_source, datasink):
self.experiment_dir = experiment_dir
self.output_dir = output_dir
self.working_dir = working_dir
# specify input and output nodes
self.func_source = func_source
self.struct_source = struct_source
self.datasink = datasink
# specify workflow instance
self.workflow = pe.Workflow(name='workflow')
# specify nodes
self.realign = pe.Node(interface=spm.Realign(), name='realign')
self.coregister = pe.Node(interface=spm.Coregister(),
name="coregister")
self.coregister.inputs.jobtype = 'estimate'
self.segment = pe.Node(interface=spm.Segment(), name="segment")
self.normalize_func = pe.Node(interface=spm.Normalize(),
name="normalize_func")
self.normalize_func.inputs.jobtype = "write"
self.normalize_struc = pe.Node(interface=spm.Normalize(),
name="normalize_struc")
self.normalize_struc.inputs.jobtype = "write"
self.smooth = pe.Node(interface=spm.Smooth(), name="smooth")
# connect the nodes to complete the workflow
self.workflow.connect([
(self.func_source, self.realign, [('outfiles', 'in_files')]),
(self.struct_source, self.coregister, [('outfiles', 'source')]),
(self.realign, self.coregister, [('mean_image', 'target')]),
(self.coregister, self.segment, [('coregistered_source', 'data')]),
(self.segment, self.normalize_func, [('transformation_mat',
'parameter_file')]),
(self.realign, self.normalize_func, [('realigned_files',
'apply_to_files')]),
(self.normalize_func, self.smooth, [('normalized_files',
'in_files')]),
#(self.realign, self.datasink, [('realigned_files', 'realign')]),
#(self.realign, self.datasink, [('mean_image', 'mean')]),
(self.normalize_func, self.datasink, [('normalized_files', 'norm')]
),
(self.smooth, self.datasink, [('smoothed_files', 'smooth')])
])
def simple_segment(mri):
"""uses spm to segment an mri in native space"""
startdir = os.getcwd()
pth, _ = os.path.split(mri)
os.chdir(pth)
seg = spm.Segment(matlab_cmd='matlab-spm8')
seg.inputs.data = mri
seg.inputs.gm_output_type = [False, False, True]
seg.inputs.wm_output_type = [False, False, True]
seg.inputs.csf_output_type = [False, False, True]
seg.inputs.ignore_exception = True
segout = seg.run()
os.chdir(startdir)
return segout
def test_segment():
yield assert_equal, spm.Segment._jobtype, 'spatial'
yield assert_equal, spm.Segment._jobname, 'preproc'
input_map = dict(data=dict(field='data', copyfile=False, mandatory=True),
gm_output_type=dict(field='output.GM'),
wm_output_type=dict(field='output.WM'),
csf_output_type=dict(field='output.CSF'),
save_bias_corrected=dict(field='output.biascor'),
clean_masks=dict(field='output.cleanup'),
tissue_prob_maps=dict(field='opts.tpm'),
gaussians_per_class=dict(field='opts.ngaus'),
affine_regularization=dict(field='opts.regtype'),
warping_regularization=dict(field='opts.warpreg'),
warp_frequency_cutoff=dict(field='opts.warpco'),
bias_regularization=dict(field='opts.biasreg'),
bias_fwhm=dict(field='opts.biasfwhm'),
sampling_distance=dict(field='opts.samp'),
mask_image=dict(field='opts.msk'))
seg = spm.Segment()
for key, metadata in input_map.items():
for metakey, value in metadata.items():
yield assert_equal, getattr(seg.inputs.traits()[key],
metakey), value
convert = pe.Node(interface=fs.MRIConvert(out_type='nii'), name='convert2nii')
convert2 = pe.MapNode(interface=fs.MRIConvert(out_type='nii'),
iterfield=['in_file'],
name='convertimg2nii')
"""
Use :class:`nipype.interfaces.spm.Segment` to segment the structural image and
generate the transformation file to MNI space.
.. note::
Segment takes longer than usual because the nose is wrapped behind
the head in the structural image.
"""
segment = pe.Node(interface=spm.Segment(), name='segment')
"""
Use :class:`nipype.interfaces.freesurfer.ApplyVolTransform` to convert contrast
images into freesurfer space.
"""
normwreg = pe.MapNode(interface=fs.ApplyVolTransform(),
iterfield=['source_file'],
name='applyreg2con')
"""
Use :class:`nipype.interfaces.spm.Normalize` to normalize the contrast images
to MNI space
"""
normalize = pe.Node(interface=spm.Normalize(jobtype='write'), name='norm2mni')
"""
def create_spm_preproc_func_pipeline(data_dir=None,
subject_id=None,
task_list=None):
###############################
## Set up Nodes
###############################
ds = Node(nio.DataGrabber(infields=['subject_id', 'task_id'],
outfields=['func', 'struc']),
name='datasource')
ds.inputs.base_directory = os.path.abspath(data_dir + '/' + subject_id)
ds.inputs.template = '*'
ds.inputs.sort_filelist = True
ds.inputs.template_args = {'func': [['task_id']], 'struc': []}
ds.inputs.field_template = {
'func': 'Functional/Raw/%s/func.nii',
'struc': 'Structural/SPGR/spgr.nii'
}
ds.inputs.subject_id = subject_id
ds.inputs.task_id = task_list
ds.iterables = ('task_id', task_list)
# ds.run().outputs #show datafiles
# #Setup Data Sinker for writing output files
# datasink = Node(nio.DataSink(), name='sinker')
# datasink.inputs.base_directory = '/path/to/output'
# workflow.connect(realigner, 'realignment_parameters', datasink, 'motion.@par')
# datasink.inputs.substitutions = [('_variable', 'variable'),('file_subject_', '')]
#Get Timing Acquisition for slice timing
tr = 2
ta = Node(interface=util.Function(input_names=['tr', 'n_slices'],
output_names=['ta'],
function=get_ta),
name="ta")
ta.inputs.tr = tr
#Slice Timing: sequential ascending
slice_timing = Node(interface=spm.SliceTiming(), name="slice_timing")
slice_timing.inputs.time_repetition = tr
slice_timing.inputs.ref_slice = 1
#Realignment - 6 parameters - realign to first image of very first series.
realign = Node(interface=spm.Realign(), name="realign")
realign.inputs.register_to_mean = True
#Plot Realignment
plot_realign = Node(interface=PlotRealignmentParameters(),
name="plot_realign")
#Artifact Detection
art = Node(interface=ra.ArtifactDetect(), name="art")
art.inputs.use_differences = [True, False]
art.inputs.use_norm = True
art.inputs.norm_threshold = 1
art.inputs.zintensity_threshold = 3
art.inputs.mask_type = 'file'
art.inputs.parameter_source = 'SPM'
#Coregister - 12 parameters, cost function = 'nmi', fwhm 7, interpolate, don't mask
#anatomical to functional mean across all available data.
coregister = Node(interface=spm.Coregister(), name="coregister")
coregister.inputs.jobtype = 'estimate'
# Segment structural, gray/white/csf,mni,
segment = Node(interface=spm.Segment(), name="segment")
segment.inputs.save_bias_corrected = True
#Normalize - structural to MNI - then apply this to the coregistered functionals
normalize = Node(interface=spm.Normalize(), name="normalize")
normalize.inputs.template = os.path.abspath(t1_template_file)
#Plot normalization Check
plot_normalization_check = Node(interface=Plot_Coregistration_Montage(),
name="plot_normalization_check")
plot_normalization_check.inputs.canonical_img = canonical_file
#Create Mask
compute_mask = Node(interface=ComputeMask(), name="compute_mask")
#remove lower 5% of histogram of mean image
compute_mask.inputs.m = .05
#Smooth
#implicit masking (.im) = 0, dtype = 0
smooth = Node(interface=spm.Smooth(), name="smooth")
fwhmlist = [0, 5, 8]
smooth.iterables = ('fwhm', fwhmlist)
#Create Covariate matrix
make_covariates = Node(interface=Create_Covariates(),
name="make_covariates")
###############################
## Create Pipeline
###############################
Preprocessed = Workflow(name="Preprocessed")
Preprocessed.base_dir = os.path.abspath(data_dir + '/' + subject_id +
'/Functional')
Preprocessed.connect([
(ds, ta, [(('func', get_n_slices), "n_slices")]),
(ta, slice_timing, [("ta", "time_acquisition")]),
(ds, slice_timing, [
('func', 'in_files'),
(('func', get_n_slices), "num_slices"),
(('func', get_slice_order), "slice_order"),
]),
(slice_timing, realign, [('timecorrected_files', 'in_files')]),
(realign, compute_mask, [('mean_image', 'mean_volume')]),
(realign, coregister, [('mean_image', 'target')]),
(ds, coregister, [('struc', 'source')]),
(coregister, segment, [('coregistered_source', 'data')]),
(segment, normalize, [
('transformation_mat', 'parameter_file'),
('bias_corrected_image', 'source'),
]),
(realign, normalize, [('realigned_files', 'apply_to_files'),
(('realigned_files', get_vox_dims),
'write_voxel_sizes')]),
(normalize, smooth, [('normalized_files', 'in_files')]),
(compute_mask, art, [('brain_mask', 'mask_file')]),
(realign, art, [('realignment_parameters', 'realignment_parameters')]),
(realign, art, [('realigned_files', 'realigned_files')]),
(realign, plot_realign, [('realignment_parameters',
'realignment_parameters')]),
(normalize, plot_normalization_check, [('normalized_files', 'wra_img')
]),
(realign, make_covariates, [('realignment_parameters',
'realignment_parameters')]),
(art, make_covariates, [('outlier_files', 'spike_id')]),
])
return Preprocessed
def create_reg_workflow(name='registration'):
"""Create a FEAT preprocessing workflow together with freesurfer
Parameters
----------
::
name : name of workflow (default: 'registration')
Inputs::
inputspec.source_files : files (filename or list of filenames to register)
inputspec.mean_image : reference image to use
inputspec.anatomical_image : anatomical image to coregister to
inputspec.target_image : registration target
Outputs::
outputspec.func2anat_transform : FLIRT transform
outputspec.anat2target_transform : FLIRT+FNIRT transform
outputspec.transformed_files : transformed files in target space
outputspec.transformed_mean : mean image in target space
Example
-------
"""
register = pe.Workflow(name=name)
inputnode = pe.Node(interface=util.IdentityInterface(fields=['source_files',
'mean_image',
'anatomical_image',
'target_image']),
name='inputspec')
outputnode = pe.Node(interface=util.IdentityInterface(fields=['func2anat_transform',
'anat2target_transform',
'transformed_files',
'transformed_mean',
]),
name='outputspec')
"""
Estimate the tissue classes from the anatomical image. But use spm's segment
as FSL appears to be breaking.
"""
#fast = pe.Node(fsl.FAST(), name='fast')
#fast.config = {'execution': {'keep_unncessary_outputs': True}}
#register.connect(inputnode, 'anatomical_image', fast, 'in_files')
convert = pe.Node(fs.MRIConvert(out_type='nii'), name='convert')
register.connect(inputnode, 'anatomical_image', convert, 'in_file')
segment = pe.Node(spm.Segment(), name='segment')
segment.inputs.wm_output_type = [False, False, True]
segment.config = {'execution': {'keep_unnecessary_outputs': 'true'}}
register.connect(convert, 'out_file', segment, 'data')
"""
Binarize the segmentation
"""
binarize = pe.Node(fsl.ImageMaths(op_string='-nan -thr 0.5 -bin'),
name='binarize')
#pickindex = lambda x, i: x[i]
#register.connect(fast, ('partial_volume_files', pickindex, 1),
# binarize, 'in_file')
register.connect(segment, 'native_wm_image', binarize, 'in_file')
"""
Calculate rigid transform from mean image to anatomical image
"""
mean2anat = pe.Node(fsl.FLIRT(), name='mean2anat')
mean2anat.inputs.dof = 6
register.connect(inputnode, 'mean_image', mean2anat, 'in_file')
register.connect(inputnode, 'anatomical_image', mean2anat, 'reference')
"""
Now use bbr cost function to improve the transform
"""
mean2anatbbr = pe.Node(fsl.FLIRT(), name='mean2anatbbr')
mean2anatbbr.inputs.dof = 6
mean2anatbbr.inputs.cost = 'bbr'
os.environ['FSLDIR']
mean2anatbbr.inputs.schedule = os.path.join(os.environ['FSLDIR'],'etc/flirtsch/bbr.sch')
register.connect(inputnode, 'mean_image', mean2anatbbr, 'in_file')
register.connect(binarize, 'out_file', mean2anatbbr, 'wm_seg')
register.connect(inputnode, 'anatomical_image', mean2anatbbr, 'reference')
register.connect(mean2anat, 'out_matrix_file', mean2anatbbr, 'in_matrix_file')
"""
Calculate affine transform from anatomical to target
"""
anat2target_affine = pe.Node(fsl.FLIRT(), name='anat2target_linear')
register.connect(inputnode, 'anatomical_image', anat2target_affine, 'in_file')
register.connect(inputnode, 'target_image', anat2target_affine, 'reference')
"""
Calculate nonlinear transform from anatomical to target
"""
anat2target_nonlinear = pe.Node(fsl.FNIRT(), name='anat2target_nonlinear')
register.connect(anat2target_affine, 'out_matrix_file',
anat2target_nonlinear, 'affine_file')
#anat2target_nonlinear.inputs.in_fwhm = [8, 4, 2, 2]
#anat2target_nonlinear.inputs.subsampling_scheme = [4, 2, 1, 1]
anat2target_nonlinear.inputs.warp_resolution = (8, 8, 8)
register.connect(inputnode, 'anatomical_image', anat2target_nonlinear, 'in_file')
register.connect(inputnode, 'target_image',
anat2target_nonlinear, 'ref_file')
"""
Transform the mean image. First to anatomical and then to target
"""
warp2anat = pe.Node(fsl.ApplyWarp(interp='spline'), name='warp2anat')
register.connect(inputnode, 'mean_image', warp2anat, 'in_file')
register.connect(inputnode, 'anatomical_image', warp2anat, 'ref_file')
register.connect(mean2anatbbr, 'out_matrix_file', warp2anat, 'premat')
warpmean = pe.Node(fsl.ApplyWarp(interp='spline'), name='warpmean')
register.connect(warp2anat, 'out_file', warpmean, 'in_file')
register.connect(inputnode, 'target_image', warpmean, 'ref_file')
register.connect(anat2target_affine, 'out_matrix_file', warpmean, 'premat')
register.connect(anat2target_nonlinear, 'field_file',
warpmean, 'field_file')
"""
Transform the remaining images. First to anatomical and then to target
"""
warpall2anat = pe.MapNode(fsl.ApplyWarp(interp='spline'),
iterfield=['in_file'],
name='warpall2anat')
register.connect(inputnode, 'source_files', warpall2anat, 'in_file')
register.connect(inputnode, 'anatomical_image', warpall2anat, 'ref_file')
register.connect(mean2anatbbr, 'out_matrix_file', warpall2anat, 'premat')
warpall = pe.MapNode(fsl.ApplyWarp(interp='spline'), name='warpall',
iterfield=['in_file'])
register.connect(warpall2anat, 'out_file', warpall, 'in_file')
register.connect(inputnode, 'target_image', warpall, 'ref_file')
register.connect(anat2target_affine, 'out_matrix_file', warpall, 'premat')
register.connect(anat2target_nonlinear, 'field_file',
warpall, 'field_file')
"""
Assign all the output files
"""
register.connect(warpmean, 'out_file', outputnode, 'transformed_mean')
register.connect(warpall, 'out_file', outputnode, 'transformed_files')
register.connect(mean2anatbbr, 'out_matrix_file',
outputnode, 'func2anat_transform')
register.connect(anat2target_nonlinear, 'field_file',
outputnode, 'anat2target_transform')
return register
def create_spm_preproc(c, name='preproc'):
"""
"""
from nipype.workflows.smri.freesurfer.utils import create_getmask_flow
import nipype.algorithms.rapidart as ra
import nipype.interfaces.spm as spm
import nipype.interfaces.utility as niu
import nipype.pipeline.engine as pe
import nipype.interfaces.io as nio
import nipype.interfaces.freesurfer as fs
workflow = pe.Workflow(name=name)
inputnode = pe.Node(niu.IdentityInterface(fields=[
'functionals', 'subject_id', 'subjects_dir', 'fwhm', 'norm_threshold',
'zintensity_threshold', 'tr', 'do_slicetime', 'sliceorder',
'parameters', 'node', 'csf_prob', 'wm_prob', 'gm_prob'
]),
name='inputspec')
poplist = lambda x: x.pop()
sym_func = pe.Node(niu.Function(input_names=['in_file'],
output_names=['out_link'],
function=do_symlink),
name='func_symlink')
# REALIGN
realign = pe.Node(niu.Function(
input_names=[
'node', 'in_file', 'tr', 'do_slicetime', 'sliceorder', 'parameters'
],
output_names=['out_file', 'par_file', 'parameter_source'],
function=mod_realign),
name="mod_realign")
workflow.connect(inputnode, 'parameters', realign, 'parameters')
workflow.connect(inputnode, 'functionals', realign, 'in_file')
workflow.connect(inputnode, 'tr', realign, 'tr')
workflow.connect(inputnode, 'do_slicetime', realign, 'do_slicetime')
workflow.connect(inputnode, 'sliceorder', realign, 'sliceorder')
workflow.connect(inputnode, 'node', realign, 'node')
# TAKE MEAN IMAGE
mean = art_mean_workflow()
workflow.connect(realign, 'out_file', mean, 'inputspec.realigned_files')
workflow.connect(realign, 'par_file', mean,
'inputspec.realignment_parameters')
workflow.connect(realign, 'parameter_source', mean,
'inputspec.parameter_source')
# CREATE BRAIN MASK
maskflow = create_getmask_flow()
workflow.connect([(inputnode, maskflow,
[('subject_id', 'inputspec.subject_id'),
('subjects_dir', 'inputspec.subjects_dir')])])
maskflow.inputs.inputspec.contrast_type = 't2'
workflow.connect(mean, 'outputspec.mean_image', maskflow,
'inputspec.source_file')
# SEGMENT
segment = pe.Node(spm.Segment(csf_output_type=[True, True, False],
gm_output_type=[True, True, False],
wm_output_type=[True, True, False]),
name='segment')
mergefunc = lambda in1, in2, in3: [in1, in2, in3]
merge = pe.Node(niu.Function(input_names=['in1', 'in2', 'in3'],
output_names=['out'],
function=mergefunc),
name='merge')
workflow.connect(inputnode, 'csf_prob', merge, 'in3')
workflow.connect(inputnode, 'wm_prob', merge, 'in2')
workflow.connect(inputnode, 'gm_prob', merge, 'in1')
sym_prob = sym_func
workflow.connect(merge, 'out', sym_prob, 'in_file')
workflow.connect(sym_prob, 'out_link', segment, 'tissue_prob_maps')
xform_mask = pe.Node(fs.ApplyVolTransform(fs_target=True),
name='transform_mask')
workflow.connect(maskflow, ('outputspec.reg_file', pickfirst), xform_mask,
'reg_file')
workflow.connect(maskflow, ('outputspec.mask_file', pickfirst), xform_mask,
'source_file')
workflow.connect(xform_mask, "transformed_file", segment, 'mask_image')
fssource = maskflow.get_node('fssource')
convert2nii = pe.Node(fs.MRIConvert(in_type='mgz', out_type='nii'),
name='convert2nii')
workflow.connect(fssource, 'brain', convert2nii, 'in_file')
workflow.connect(convert2nii, 'out_file', segment, 'data')
# NORMALIZE
normalize = pe.MapNode(spm.Normalize(jobtype='write'),
name='normalize',
iterfield=['apply_to_files'])
normalize_struct = normalize.clone('normalize_struct')
normalize_mask = normalize.clone('normalize_mask')
workflow.connect(segment, 'transformation_mat', normalize,
'parameter_file')
workflow.connect(segment, 'transformation_mat', normalize_mask,
'parameter_file')
workflow.connect(segment, 'transformation_mat', normalize_struct,
'parameter_file')
workflow.connect(convert2nii, 'out_file', normalize_struct,
'apply_to_files')
workflow.connect(xform_mask, "transformed_file", normalize_mask,
'apply_to_files')
xform_image = pe.MapNode(fs.ApplyVolTransform(fs_target=True),
name='xform_image',
iterfield=['source_file'])
workflow.connect(maskflow, ('outputspec.reg_file', pickfirst), xform_image,
'reg_file')
workflow.connect(realign, 'out_file', xform_image, "source_file")
workflow.connect(xform_image, "transformed_file", normalize,
"apply_to_files")
#SMOOTH
smooth = pe.Node(spm.Smooth(), name='smooth')
workflow.connect(inputnode, 'fwhm', smooth, 'fwhm')
workflow.connect(normalize, 'normalized_files', smooth, 'in_files')
# ART
artdetect = pe.Node(ra.ArtifactDetect(mask_type='file',
use_differences=[True, False],
use_norm=True,
save_plot=True),
name='artdetect')
workflow.connect(realign, 'parameter_source', artdetect,
'parameter_source')
workflow.connect([(inputnode, artdetect,
[('norm_threshold', 'norm_threshold'),
('zintensity_threshold', 'zintensity_threshold')])])
workflow.connect([(realign, artdetect, [('out_file', 'realigned_files'),
('par_file',
'realignment_parameters')])])
workflow.connect(maskflow, ('outputspec.mask_file', poplist), artdetect,
'mask_file')
# OUTPUTS
outputnode = pe.Node(niu.IdentityInterface(fields=[
"realignment_parameters", "smoothed_files", "mask_file", "mean_image",
"reg_file", "reg_cost", 'outlier_files', 'outlier_stats',
'outlier_plots', 'norm_components', 'mod_csf', 'unmod_csf', 'mod_wm',
'unmod_wm', 'mod_gm', 'unmod_gm', 'mean', 'normalized_struct',
'normalization_parameters', 'reverse_normalize_parameters'
]),
name="outputspec")
workflow.connect([
(maskflow, outputnode, [("outputspec.reg_file", "reg_file")]),
(maskflow, outputnode, [("outputspec.reg_cost", "reg_cost")]),
(realign, outputnode, [('par_file', 'realignment_parameters')]),
(smooth, outputnode, [('smoothed_files', 'smoothed_files')]),
(artdetect, outputnode, [('outlier_files', 'outlier_files'),
('statistic_files', 'outlier_stats'),
('plot_files', 'outlier_plots'),
('norm_files', 'norm_components')])
])
workflow.connect(normalize_mask, "normalized_files", outputnode,
"mask_file")
workflow.connect(segment, 'modulated_csf_image', outputnode, 'mod_csf')
workflow.connect(segment, 'modulated_wm_image', outputnode, 'mod_wm')
workflow.connect(segment, 'modulated_gm_image', outputnode, 'mod_gm')
workflow.connect(segment, 'normalized_csf_image', outputnode, 'unmod_csf')
workflow.connect(segment, 'normalized_wm_image', outputnode, 'unmod_wm')
workflow.connect(segment, 'normalized_gm_image', outputnode, 'unmod_gm')
workflow.connect(mean, 'outputspec.mean_image', outputnode, 'mean')
workflow.connect(normalize_struct, 'normalized_files', outputnode,
'normalized_struct')
workflow.connect(segment, 'transformation_mat', outputnode,
'normalization_parameters')
workflow.connect(segment, 'inverse_transformation_mat', outputnode,
'reverse_normalize_parameters')
# CONNECT TO CONFIG
workflow.inputs.inputspec.fwhm = c.fwhm
workflow.inputs.inputspec.subjects_dir = c.surf_dir
workflow.inputs.inputspec.norm_threshold = c.norm_thresh
workflow.inputs.inputspec.zintensity_threshold = c.z_thresh
workflow.inputs.inputspec.node = c.motion_correct_node
workflow.inputs.inputspec.tr = c.TR
workflow.inputs.inputspec.do_slicetime = c.do_slicetiming
workflow.inputs.inputspec.sliceorder = c.SliceOrder
workflow.inputs.inputspec.csf_prob = c.csf_prob
workflow.inputs.inputspec.gm_prob = c.grey_prob
workflow.inputs.inputspec.wm_prob = c.white_prob
workflow.inputs.inputspec.parameters = {"order": c.order}
workflow.base_dir = c.working_dir
workflow.config = {'execution': {'crashdump_dir': c.crash_dir}}
datagrabber = get_dataflow(c)
workflow.connect(datagrabber, 'func', inputnode, 'functionals')
infosource = pe.Node(niu.IdentityInterface(fields=['subject_id']),
name='subject_names')
if not c.test_mode:
infosource.iterables = ('subject_id', c.subjects)
else:
infosource.iterables = ('subject_id', c.subjects[:1])
workflow.connect(infosource, 'subject_id', inputnode, 'subject_id')
workflow.connect(infosource, 'subject_id', datagrabber, 'subject_id')
sub = lambda x: [('_subject_id_%s' % x, '')]
sinker = pe.Node(nio.DataSink(), name='sinker')
workflow.connect(infosource, 'subject_id', sinker, 'container')
workflow.connect(infosource, ('subject_id', sub), sinker, 'substitutions')
sinker.inputs.base_directory = c.sink_dir
outputspec = workflow.get_node('outputspec')
workflow.connect(outputspec, 'realignment_parameters', sinker,
'spm_preproc.realignment_parameters')
workflow.connect(outputspec, 'smoothed_files', sinker,
'spm_preproc.smoothed_outputs')
workflow.connect(outputspec, 'outlier_files', sinker,
'spm_preproc.art.@outlier_files')
workflow.connect(outputspec, 'outlier_stats', sinker,
'spm_preproc.art.@outlier_stats')
workflow.connect(outputspec, 'outlier_plots', sinker,
'spm_preproc.art.@outlier_plots')
workflow.connect(outputspec, 'norm_components', sinker,
'spm_preproc.art.@norm')
workflow.connect(outputspec, 'reg_file', sinker,
'spm_preproc.bbreg.@reg_file')
workflow.connect(outputspec, 'reg_cost', sinker,
'spm_preproc.bbreg.@reg_cost')
workflow.connect(outputspec, 'mask_file', sinker,
'spm_preproc.mask.@mask_file')
workflow.connect(outputspec, 'mod_csf', sinker,
'spm_preproc.segment.mod.@csf')
workflow.connect(outputspec, 'mod_wm', sinker,
'spm_preproc.segment.mod.@wm')
workflow.connect(outputspec, 'mod_gm', sinker,
'spm_preproc.segment.mod.@gm')
workflow.connect(outputspec, 'unmod_csf', sinker,
'spm_preproc.segment.unmod.@csf')
workflow.connect(outputspec, 'unmod_wm', sinker,
'spm_preproc.segment.unmod.@wm')
workflow.connect(outputspec, 'unmod_gm', sinker,
'spm_preproc.segment.unmod.@gm')
workflow.connect(outputspec, 'mean', sinker, 'spm_preproc.mean')
workflow.connect(outputspec, 'normalized_struct', sinker,
'spm_preproc.normalized_struct')
workflow.connect(outputspec, 'normalization_parameters', sinker,
'spm_preproc.normalization_parameters.@forward')
workflow.connect(outputspec, 'reverse_normalize_parameters', sinker,
'spm_preproc.normalization_parameters.@reverse')
return workflow
def create_spm_preproc(c, name='preproc'):
"""Create an spm preprocessing workflow with freesurfer registration and
artifact detection.
The workflow realigns and smooths and registers the functional images with
the subject's freesurfer space.
Example
-------
>>> preproc = create_spm_preproc()
>>> preproc.base_dir = '.'
>>> preproc.inputs.inputspec.fwhm = 6
>>> preproc.inputs.inputspec.subject_id = 's1'
>>> preproc.inputs.inputspec.subjects_dir = '.'
>>> preproc.inputs.inputspec.functionals = ['f3.nii', 'f5.nii']
>>> preproc.inputs.inputspec.norm_threshold = 1
>>> preproc.inputs.inputspec.zintensity_threshold = 3
Inputs::
inputspec.functionals : functional runs use 4d nifti
inputspec.subject_id : freesurfer subject id
inputspec.subjects_dir : freesurfer subjects dir
inputspec.fwhm : smoothing fwhm
inputspec.norm_threshold : norm threshold for outliers
inputspec.zintensity_threshold : intensity threshold in z-score
Outputs::
outputspec.realignment_parameters : realignment parameter files
outputspec.smoothed_files : smoothed functional files
outputspec.outlier_files : list of outliers
outputspec.outlier_stats : statistics of outliers
outputspec.outlier_plots : images of outliers
outputspec.mask_file : binary mask file in reference image space
outputspec.reg_file : registration file that maps reference image to
freesurfer space
outputspec.reg_cost : cost of registration (useful for detecting misalignment)
"""
from nipype.workflows.smri.freesurfer.utils import create_getmask_flow
import nipype.algorithms.rapidart as ra
import nipype.interfaces.spm as spm
import nipype.interfaces.utility as niu
import nipype.pipeline.engine as pe
import nipype.interfaces.io as nio
"""
Initialize the workflow
"""
workflow = pe.Workflow(name=name)
"""
Define the inputs to this workflow
"""
inputnode = pe.Node(niu.IdentityInterface(fields=[
'functionals', 'subject_id', 'subjects_dir', 'fwhm', 'norm_threshold',
'zintensity_threshold', 'tr', 'do_slicetime', 'sliceorder', 'node',
'csf_prob', 'wm_prob', 'gm_prob'
]),
name='inputspec')
"""
Setup the processing nodes and create the mask generation and coregistration
workflow
"""
poplist = lambda x: x.pop()
#realign = pe.Node(spm.Realign(), name='realign')
sym_func = pe.Node(niu.Function(input_names=['in_file'],
output_names=['out_link'],
function=do_symlink),
name='func_symlink')
realign = pe.Node(niu.Function(
input_names=['node', 'in_file', 'tr', 'do_slicetime', 'sliceorder'],
output_names=['out_file', 'par_file'],
function=mod_realign),
name="mod_realign")
mean = art_mean_workflow()
workflow.connect(realign, 'out_file', mean, 'inputspec.realigned_files')
workflow.connect(realign, 'par_file', mean,
'inputspec.realignment_parameters')
mean.inputs.inputspec.parameter_source = 'FSL' # Modular realign puts it in FSL format for consistency
#workflow.connect(inputnode, 'functionals', realign, 'in_file')
workflow.connect(inputnode, 'functionals', sym_func, 'in_file')
workflow.connect(sym_func, 'out_link', realign, 'in_file')
workflow.connect(inputnode, 'tr', realign, 'tr')
workflow.connect(inputnode, 'do_slicetime', realign, 'do_slicetime')
workflow.connect(inputnode, 'sliceorder', realign, 'sliceorder')
workflow.connect(inputnode, 'node', realign, 'node')
maskflow = create_getmask_flow()
workflow.connect([(inputnode, maskflow,
[('subject_id', 'inputspec.subject_id'),
('subjects_dir', 'inputspec.subjects_dir')])])
maskflow.inputs.inputspec.contrast_type = 't2'
workflow.connect(mean, 'outputspec.mean_image', maskflow,
'inputspec.source_file')
smooth = pe.Node(spm.Smooth(), name='smooth')
normalize = pe.Node(spm.Normalize(jobtype='write'), name='normalize')
normalize_struct = normalize.clone('normalize_struct')
segment = pe.Node(spm.Segment(csf_output_type=[True, True, False],
gm_output_type=[True, True, False],
wm_output_type=[True, True, False]),
name='segment')
mergefunc = lambda in1, in2, in3: [in1, in2, in3]
# merge = pe.Node(niu.Merge(),name='merge')
merge = pe.Node(niu.Function(input_names=['in1', 'in2', 'in3'],
output_names=['out'],
function=mergefunc),
name='merge')
workflow.connect(inputnode, 'csf_prob', merge, 'in3')
workflow.connect(inputnode, 'wm_prob', merge, 'in2')
workflow.connect(inputnode, 'gm_prob', merge, 'in1')
#workflow.connect(merge,'out', segment,'tissue_prob_maps')
sym_prob = sym_func.clone('sym_prob')
workflow.connect(merge, 'out', sym_prob, 'in_file')
workflow.connect(sym_prob, 'out_link', segment, 'tissue_prob_maps')
workflow.connect(maskflow, ('outputspec.mask_file', pickfirst), segment,
'mask_image')
workflow.connect(inputnode, 'fwhm', smooth, 'fwhm')
#sym_brain = sym_func.clone('sym_brain')
#workflow.connect(realign, 'mean_image', normalize, 'source')
#workflow.connect(maskflow,'fssource.brain',segment,'data')
fssource = maskflow.get_node('fssource')
import nipype.interfaces.freesurfer as fs
convert_brain = pe.Node(interface=fs.ApplyVolTransform(inverse=True),
name='convert')
workflow.connect(fssource, 'brain', convert_brain, 'target_file')
workflow.connect(maskflow, ('outputspec.reg_file', pickfirst),
convert_brain, 'reg_file')
workflow.connect(mean, 'outputspec.mean_image', convert_brain,
'source_file')
convert2nii = pe.Node(fs.MRIConvert(in_type='mgz', out_type='nii'),
name='convert2nii')
workflow.connect(convert_brain, 'transformed_file', convert2nii, 'in_file')
workflow.connect(convert2nii, 'out_file', segment, 'data')
workflow.connect(segment, 'transformation_mat', normalize,
'parameter_file')
workflow.connect(segment, 'transformation_mat', normalize_struct,
'parameter_file')
workflow.connect(convert2nii, 'out_file', normalize_struct,
'apply_to_files')
workflow.connect(realign, 'out_file', normalize, 'apply_to_files')
#normalize.inputs.template='/software/spm8/templates/EPI.nii'
workflow.connect(normalize, 'normalized_files', smooth, 'in_files')
#workflow.connect(realign, 'realigned_files', smooth, 'in_files')
artdetect = pe.Node(ra.ArtifactDetect(mask_type='file',
parameter_source='FSL',
use_differences=[True, False],
use_norm=True,
save_plot=True),
name='artdetect')
workflow.connect([(inputnode, artdetect,
[('norm_threshold', 'norm_threshold'),
('zintensity_threshold', 'zintensity_threshold')])])
workflow.connect([(realign, artdetect, [('out_file', 'realigned_files'),
('par_file',
'realignment_parameters')])])
workflow.connect(maskflow, ('outputspec.mask_file', poplist), artdetect,
'mask_file')
"""
Define the outputs of the workflow and connect the nodes to the outputnode
"""
outputnode = pe.Node(niu.IdentityInterface(fields=[
"realignment_parameters", "smoothed_files", "mask_file", "mean_image",
"reg_file", "reg_cost", 'outlier_files', 'outlier_stats',
'outlier_plots', 'norm_components', 'mod_csf', 'unmod_csf', 'mod_wm',
'unmod_wm', 'mod_gm', 'unmod_gm', 'mean', 'normalized_struct',
'struct_in_functional_space', 'normalization_parameters',
'reverse_normalize_parameters'
]),
name="outputspec")
workflow.connect([
(maskflow, outputnode, [("outputspec.reg_file", "reg_file")]),
(maskflow, outputnode, [("outputspec.reg_cost", "reg_cost")]),
(maskflow, outputnode, [(("outputspec.mask_file", poplist),
"mask_file")]),
(realign, outputnode, [('par_file', 'realignment_parameters')]),
(smooth, outputnode, [('smoothed_files', 'smoothed_files')]),
(artdetect, outputnode, [('outlier_files', 'outlier_files'),
('statistic_files', 'outlier_stats'),
('plot_files', 'outlier_plots'),
('norm_files', 'norm_components')])
])
workflow.connect(segment, 'modulated_csf_image', outputnode, 'mod_csf')
workflow.connect(segment, 'modulated_wm_image', outputnode, 'mod_wm')
workflow.connect(segment, 'modulated_gm_image', outputnode, 'mod_gm')
workflow.connect(segment, 'normalized_csf_image', outputnode, 'unmod_csf')
workflow.connect(segment, 'normalized_wm_image', outputnode, 'unmod_wm')
workflow.connect(segment, 'normalized_gm_image', outputnode, 'unmod_gm')
workflow.connect(mean, 'outputspec.mean_image', outputnode, 'mean')
workflow.connect(normalize_struct, 'normalized_files', outputnode,
'normalized_struct')
workflow.connect(segment, 'transformation_mat', outputnode,
'normalization_parameters')
workflow.connect(segment, 'inverse_transformation_mat', outputnode,
'reverse_normalize_parameters')
workflow.connect(convert2nii, 'out_file', outputnode,
'struct_in_functional_space')
workflow.inputs.inputspec.fwhm = c.fwhm
workflow.inputs.inputspec.subjects_dir = c.surf_dir
workflow.inputs.inputspec.norm_threshold = c.norm_thresh
workflow.inputs.inputspec.zintensity_threshold = c.z_thresh
workflow.inputs.inputspec.node = c.motion_correct_node
workflow.inputs.inputspec.tr = c.TR
workflow.inputs.inputspec.do_slicetime = c.do_slicetiming
workflow.inputs.inputspec.sliceorder = c.SliceOrder
workflow.inputs.inputspec.csf_prob = c.csf_prob
workflow.inputs.inputspec.gm_prob = c.grey_prob
workflow.inputs.inputspec.wm_prob = c.white_prob
workflow.base_dir = c.working_dir
workflow.config = {'execution': {'crashdump_dir': c.crash_dir}}
datagrabber = get_dataflow(c)
workflow.connect(datagrabber, 'func', inputnode, 'functionals')
infosource = pe.Node(niu.IdentityInterface(fields=['subject_id']),
name='subject_names')
if not c.test_mode:
infosource.iterables = ('subject_id', c.subjects)
else:
infosource.iterables = ('subject_id', c.subjects[:1])
workflow.connect(infosource, 'subject_id', inputnode, 'subject_id')
workflow.connect(infosource, 'subject_id', datagrabber, 'subject_id')
sub = lambda x: [('_subject_id_%s' % x, '')]
sinker = pe.Node(nio.DataSink(), name='sinker')
workflow.connect(infosource, 'subject_id', sinker, 'container')
workflow.connect(infosource, ('subject_id', sub), sinker, 'substitutions')
sinker.inputs.base_directory = c.sink_dir
outputspec = workflow.get_node('outputspec')
workflow.connect(outputspec, 'realignment_parameters', sinker,
'spm_preproc.realignment_parameters')
workflow.connect(outputspec, 'smoothed_files', sinker,
'spm_preproc.smoothed_outputs')
workflow.connect(outputspec, 'outlier_files', sinker,
'spm_preproc.art.@outlier_files')
workflow.connect(outputspec, 'outlier_stats', sinker,
'spm_preproc.art.@outlier_stats')
workflow.connect(outputspec, 'outlier_plots', sinker,
'spm_preproc.art.@outlier_plots')
workflow.connect(outputspec, 'norm_components', sinker,
'spm_preproc.art.@norm')
workflow.connect(outputspec, 'reg_file', sinker,
'spm_preproc.bbreg.@reg_file')
workflow.connect(outputspec, 'reg_cost', sinker,
'spm_preproc.bbreg.@reg_cost')
workflow.connect(outputspec, 'mask_file', sinker,
'spm_preproc.mask.@mask_file')
workflow.connect(outputspec, 'mod_csf', sinker,
'spm_preproc.segment.mod.@csf')
workflow.connect(outputspec, 'mod_wm', sinker,
'spm_preproc.segment.mod.@wm')
workflow.connect(outputspec, 'mod_gm', sinker,
'spm_preproc.segment.mod.@gm')
workflow.connect(outputspec, 'unmod_csf', sinker,
'spm_preproc.segment.unmod.@csf')
workflow.connect(outputspec, 'unmod_wm', sinker,
'spm_preproc.segment.unmod.@wm')
workflow.connect(outputspec, 'unmod_gm', sinker,
'spm_preproc.segment.unmod.@gm')
workflow.connect(outputspec, 'mean', sinker, 'spm_preproc.mean')
workflow.connect(outputspec, 'normalized_struct', sinker,
'spm_preproc.normalized_struct')
workflow.connect(outputspec, 'normalization_parameters', sinker,
'spm_preproc.normalization_parameters.@forward')
workflow.connect(outputspec, 'reverse_normalize_parameters', sinker,
'spm_preproc.normalization_parameters.@reverse')
workflow.connect(outputspec, 'struct_in_functional_space', sinker,
'spm_preproc.struct_in_func_space')
return workflow
def create_native_old_segment_pipe(params_template,
params={},
name="native_old_segment_pipe"):
"""
Description: Extract brain using tissues masks output by SPM's old_segment
function:
- Segment the T1 using given priors;
- Threshold GM, WM and CSF maps;
- Compute union of those 3 tissues with indexes;
Params:
- segment (see `Segment <https://nipype.readthedocs.io/en/0.12.1/\
interfaces/generated/nipype.interfaces.spm.preprocess.html#segment>`_)
- threshold_gm, threshold_wm, threshold_csf (see `Threshold \
<https://nipype.readthedocs.io/en/0.12.1/interfaces/generated/nipype.\
interfaces.fsl.maths.html#threshold>`_ for arguments) - also available \
as :ref:`indiv_params <indiv_params>`
Inputs:
inputnode:
T1: T1 file name
arguments:
priors: list of file names
params: dictionary of node sub-parameters (from a json file)
name: pipeline name (default = "old_segment_pipe")
Outputs:
fill_holes.out_file:
filled mask after erode
fill_holes_dil.out_file
filled mask after dilate
threshold_gm, threshold_wm, threshold_csf.out_file:
resp grey matter, white matter, and csf after thresholding
"""
# creating pipeline
seg_pipe = pe.Workflow(name=name)
# Creating inputnode
inputnode = pe.Node(niu.IdentityInterface(
fields=['T1', 'indiv_params', "native_T1", "inv_transfo_file"]),
name='inputnode')
assert set_spm(), \
"Error, SPM was not found, cannot run SPM old segment pipeline"
unzip = pe.Node(interface=niu.Function(input_names=['zipped_file'],
output_names=["unzipped_file"],
function=gunzip),
name="unzip")
seg_pipe.connect(inputnode, 'T1', unzip, 'zipped_file')
# Segment in to 6 tissues
segment = NodeParams(spm.Segment(),
params=parse_key(params, "segment"),
name="old_segment")
segment.inputs.tissue_prob_maps = [
params_template["template_gm"], params_template["template_wm"],
params_template["template_csf"]
]
seg_pipe.connect(unzip, 'unzipped_file', segment, 'data')
# gm
register_gm_to_nat = pe.Node(fsl.ApplyXFM(), name="register_gm_to_nat")
register_gm_to_nat.inputs.output_type = "NIFTI_GZ" # for SPM segment
seg_pipe.connect(segment, 'native_gm_image', register_gm_to_nat, 'in_file')
seg_pipe.connect(inputnode, 'native_T1', register_gm_to_nat, 'reference')
seg_pipe.connect(inputnode, 'inv_transfo_file', register_gm_to_nat,
"in_matrix_file")
# wm
register_wm_to_nat = pe.Node(fsl.ApplyXFM(), name="register_wm_to_nat")
register_wm_to_nat.inputs.output_type = "NIFTI_GZ" # for SPM segment
seg_pipe.connect(segment, 'native_wm_image', register_wm_to_nat, 'in_file')
seg_pipe.connect(inputnode, 'native_T1', register_wm_to_nat, 'reference')
seg_pipe.connect(inputnode, 'inv_transfo_file', register_wm_to_nat,
"in_matrix_file")
# csf
register_csf_to_nat = pe.Node(fsl.ApplyXFM(), name="register_csf_to_nat")
register_csf_to_nat.inputs.output_type = "NIFTI_GZ" # for SPM segment
seg_pipe.connect(segment, 'native_csf_image', register_csf_to_nat,
'in_file')
seg_pipe.connect(inputnode, 'native_T1', register_csf_to_nat, 'reference')
seg_pipe.connect(inputnode, 'inv_transfo_file', register_csf_to_nat,
"in_matrix_file")
# threshold_gm
threshold_gm = NodeParams(fsl.Threshold(),
params=parse_key(params, "threshold_gm"),
name="threshold_gm")
seg_pipe.connect(register_gm_to_nat, 'out_file', threshold_gm, 'in_file')
seg_pipe.connect(inputnode, ('indiv_params', parse_key, "threshold_gm"),
threshold_gm, "indiv_params")
# threshold_wm
threshold_wm = NodeParams(fsl.Threshold(),
params=parse_key(params, "threshold_wm"),
name="threshold_wm")
seg_pipe.connect(register_wm_to_nat, 'out_file', threshold_wm, 'in_file')
seg_pipe.connect(inputnode, ('indiv_params', parse_key, "threshold_wm"),
threshold_wm, "indiv_params")
# threshold_csf
threshold_csf = NodeParams(fsl.Threshold(),
params=parse_key(params, "threshold_csf"),
name="threshold_csf")
seg_pipe.connect(register_csf_to_nat, 'out_file', threshold_csf, 'in_file')
seg_pipe.connect(inputnode, ('indiv_params', parse_key, "threshold_csf"),
threshold_csf, "indiv_params")
# outputnode
outputnode = pe.Node(niu.IdentityInterface(
fields=["threshold_gm", "threshold_wm", "threshold_csf"]),
name='outputnode')
seg_pipe.connect(threshold_gm, 'out_file', outputnode, 'threshold_gm')
seg_pipe.connect(threshold_wm, 'out_file', outputnode, 'threshold_wm')
seg_pipe.connect(threshold_csf, 'out_file', outputnode, 'threshold_csf')
return seg_pipe
def create_old_segment_pipe(params_template,
params={},
name="old_segment_pipe"):
"""
Description: Extract brain using tissues masks output by SPM's old_segment
Function:
- Segment the T1 using given priors;
- Threshold GM, WM and CSF maps;
Params:
- segment (see `Segment <https://nipype.readthedocs.io/en/0.12.1/\
interfaces/generated/nipype.interfaces.spm.preprocess.html#segment>`_)
- threshold_gm, threshold_wm, threshold_csf (see `Threshold \
<https://nipype.readthedocs.io/en/0.12.1/interfaces/generated/nipype.\
interfaces.fsl.maths.html#threshold>`_ for arguments) - also available \
as :ref:`indiv_params <indiv_params>`
- dilate_mask (see `DilateMask <https://nipype.readthedocs.io/en/0.12.1/\
interfaces/generated/nipype.interfaces.fsl.maths.html#dilateimage>`_)
- erode_mask (see `ErodeMask <https://nipype.readthedocs.io/en/0.12.1/\
interfaces/generated/nipype.interfaces.fsl.maths.html#erodeimage>`_)
Inputs:
inputnode:
T1: T1 file name
arguments:
priors: list of file names
params: dictionary of node sub-parameters (from a json file)
name: pipeline name (default = "old_segment_pipe")
Outputs:
fill_holes.out_file:
filled mask after erode
fill_holes_dil.out_file
filled mask after dilate
threshold_gm, threshold_wm, threshold_csf.out_file:
resp grey matter, white matter, and csf after thresholding
"""
# creating pipeline
seg_pipe = pe.Workflow(name=name)
# Creating inputnode
inputnode = pe.Node(niu.IdentityInterface(fields=['T1', 'indiv_params']),
name='inputnode')
assert set_spm(), \
"Error, SPM was not found, cannot run SPM old segment pipeline"
unzip = pe.Node(interface=niu.Function(input_names=['zipped_file'],
output_names=["unzipped_file"],
function=gunzip),
name="unzip")
seg_pipe.connect(inputnode, 'T1', unzip, 'zipped_file')
# Segment in to 6 tissues
segment = NodeParams(spm.Segment(),
params=parse_key(params, "segment"),
name="old_segment")
segment.inputs.tissue_prob_maps = [
params_template["template_gm"], params_template["template_wm"],
params_template["template_csf"]
]
seg_pipe.connect(unzip, 'unzipped_file', segment, 'data')
# Threshold GM, WM and CSF
thd_nodes = {}
for tissue in ['gm', 'wm', 'csf']:
tmp_node = NodeParams(fsl.Threshold(),
params=parse_key(params, "threshold_" + tissue),
name="threshold_" + tissue)
seg_pipe.connect(segment, 'native_' + tissue + '_image', tmp_node,
'in_file')
seg_pipe.connect(inputnode,
('indiv_params', parse_key, "threshold_" + tissue),
tmp_node, "indiv_params")
thd_nodes[tissue] = tmp_node
# Creating output node
outputnode = pe.Node(niu.IdentityInterface(
fields=['threshold_gm', 'threshold_wm', 'threshold_csf']),
name='outputnode')
seg_pipe.connect(thd_nodes['gm'], 'out_file', outputnode, 'threshold_gm')
seg_pipe.connect(thd_nodes['wm'], 'out_file', outputnode, 'threshold_wm')
seg_pipe.connect(thd_nodes['csf'], 'out_file', outputnode, 'threshold_csf')
return seg_pipe
epi_s2_stack.inputs.out_ext = '.nii'
st_corr = Node(spm.SliceTiming(), name='slicetiming_correction')
realign = Node(spm.Realign(), name='realign')
realign.inputs.register_to_mean = True
tsnr = MapNode(confounds.TSNR(), iterfield='in_file', name='tsnr')
tsnr.inputs.mean_file = 'mean.nii'
tsnr.inputs.stddev_file = 'stddev.nii'
tsnr.inputs.tsnr_file = 'tsnr.nii'
despike = MapNode(afni.Despike(), iterfield='in_file', name='despike')
despike.inputs.outputtype = 'NIFTI'
seg = Node(spm.Segment(), name='seg')
seg.inputs.csf_output_type = [False, False, True] #Output native CSF seg
seg.inputs.gm_output_type = [False, False, True] #Output native gm seg
seg.inputs.wm_output_type = [False, False, True] #Output native wm seg
coreg2epi = MapNode(spm.Coregister(), iterfield='target', name='coreg2epi')
#Warps to MNI space using a 3mm template image
antsnorm = MapNode(ants.Registration(),
iterfield='moving_image',
name='antsnorm')
antsnorm.inputs.collapse_output_transforms = True
antsnorm.inputs.initial_moving_transform_com = True
antsnorm.inputs.num_threads = 1
antsnorm.inputs.output_inverse_warped_image = True
antsnorm.inputs.output_warped_image = True
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')
# main.connect(segment, 'seg. native_wm_image', sink, '@wm')
def create_old_segment_pipe(params_template, params={},
name="old_segment_pipe"):
"""
Description: Extract brain using tissues masks output by SPM's old_segment
function:
- Segment the T1 using given priors;
- Threshold GM, WM and CSF maps;
- Compute union of those 3 tissues;
- Apply morphological opening on the union mask
- Fill holes
Inputs:
inputnode:
T1: T1 file name
arguments:
priors: list of file names
params: dictionary of node sub-parameters (from a json file)
name: pipeline name (default = "old_segment_pipe")
Outputs:
fill_holes.out_file:
filled mask after erode
fill_holes_dil.out_file
filled mask after dilate
threshold_gm, threshold_wm, threshold_csf.out_file:
resp grey matter, white matter, and csf after thresholding
"""
# creating pipeline
be_pipe = pe.Workflow(name=name)
# Creating inputnode
inputnode = pe.Node(
niu.IdentityInterface(fields=['T1', 'indiv_params']),
name='inputnode'
)
# Segment in to 6 tissues
segment = NodeParams(spm.Segment(),
params=parse_key(params, "segment"),
name="old_segment")
segment.inputs.tissue_prob_maps = [params_template["template_gm"],
params_template["template_wm"],
params_template["template_csf"]]
be_pipe.connect(inputnode, 'T1', segment, 'data')
# Threshold GM, WM and CSF
thd_nodes = {}
for tissue in ['gm', 'wm', 'csf']:
tmp_node = NodeParams(fsl.Threshold(),
params=parse_key(params, "threshold_" + tissue),
name="threshold_" + tissue)
be_pipe.connect(segment, 'native_' + tissue + '_image',
tmp_node, 'in_file')
be_pipe.connect(
inputnode, ('indiv_params', parse_key, "threshold_" + tissue),
tmp_node, "indiv_params")
thd_nodes[tissue] = tmp_node
# Compute union of the 3 tissues
# Done with 2 fslmaths as it seems to hard to do it
wmgm_union = pe.Node(fsl.BinaryMaths(), name="wmgm_union")
wmgm_union.inputs.operation = "add"
be_pipe.connect(thd_nodes['gm'], 'out_file', wmgm_union, 'in_file')
be_pipe.connect(thd_nodes['wm'], 'out_file', wmgm_union, 'operand_file')
tissues_union = pe.Node(fsl.BinaryMaths(), name="tissues_union")
tissues_union.inputs.operation = "add"
be_pipe.connect(wmgm_union, 'out_file', tissues_union, 'in_file')
be_pipe.connect(thd_nodes['csf'], 'out_file',
tissues_union, 'operand_file')
# Opening
dilate_mask = NodeParams(fsl.DilateImage(),
params=parse_key(params, "dilate_mask"),
name="dilate_mask")
dilate_mask.inputs.operation = "mean" # Arbitrary operation
be_pipe.connect(tissues_union, 'out_file', dilate_mask, 'in_file')
# Eroding mask
erode_mask = NodeParams(fsl.ErodeImage(),
params=parse_key(params, "erode_mask"),
name="erode_mask")
be_pipe.connect(tissues_union, 'out_file', erode_mask, 'in_file')
# fill holes of erode_mask
fill_holes = pe.Node(BinaryFillHoles(), name="fill_holes")
be_pipe.connect(erode_mask, 'out_file', fill_holes, 'in_file')
# fill holes of dilate_mask
fill_holes_dil = pe.Node(BinaryFillHoles(), name="fill_holes_dil")
be_pipe.connect(dilate_mask, 'out_file', fill_holes_dil, 'in_file')
return be_pipe
def __init__(self, func_source, struct_source, datasink):
# specify input and output nodes
self.func_source = func_source
self.struct_source = struct_source
self.datasink = datasink
# specify nodes
# structual process
self.bet_struct = pe.Node(interface=fsl.BET(),
name='non_brain_removal_BET_struct')
self.bet_struct.inputs.output_type = "NIFTI"
# functional process
self.slice_timer = pe.Node(interface=fsl.SliceTimer(),
name='time_slice_correction')
self.mcflirt = pe.Node(interface=fsl.MCFLIRT(),
name='motion_correction')
self.mcflirt.inputs.output_type = "NIFTI"
self.mcflirt.inputs.mean_vol = True
self.fslsplit = pe.Node(interface=fsl.Split(), name='fslsplit')
self.fslsplit.inputs.dimension = 't'
self.fslsplit.inputs.output_type = "NIFTI"
self.fslmerge = pe.Node(interface=fsl.Merge(), name='fslmerge')
self.fslmerge.inputs.dimension = 't'
self.fslmerge.inputs.output_type = "NIFTI"
self.bet_mean = pe.Node(interface=fsl.BET(),
name='non_brain_removal_BET_mean')
self.bet_mean.inputs.output_type = "NIFTI"
# helper function(s)
def bet_each(in_files):
'''
@param in_files: list of image files
@return out_files: list of image files after applied fsl.BET on it
'''
from nipype.interfaces import fsl
import nipype.pipeline.engine as pe
out_files = list()
step_no = 0
for file_ in in_files:
bet = pe.Node(interface=fsl.BET(),
name='BET_for_step_{}'.format(step_no))
bet.inputs.in_file = file_
bet.inputs.out_file = file_[:len(file_) - 4] + '_bet.nii'
bet.inputs.output_type = "NIFTI"
bet.run()
out_files.append(bet.inputs.out_file)
step_no += 1
return out_files
# bet_func return a list of NIFITI files
self.bet_func = pe.Node(interface=Function(input_names=['in_files'],
output_names=['out_files'],
function=bet_each),
name='non_brain_removal_BET_func')
self.coregister = pe.Node(interface=spm.Coregister(),
name="coregister")
self.coregister.inputs.jobtype = 'estimate'
self.segment = pe.Node(interface=spm.Segment(), name="segment")
self.segment.inputs.affine_regularization = 'mni'
self.normalize_func = pe.Node(interface=spm.Normalize(),
name="normalize_func")
self.normalize_func.inputs.jobtype = "write"
# self.fourier = pe.Node(interface=afni.Fourier(), name='temporal_filtering')
# self.fourier.inputs.highpass = 0.01
# self.fourier.inputs.lowpass = 0.1
self.smooth = pe.Node(interface=spm.Smooth(), name="smooth")
self.smooth.inputs.fwhm = [8, 8, 8]
# specify workflow instance
self.workflow = pe.Workflow(name='preprocessing_workflow')
# connect nodes
self.workflow.connect([
(self.struct_source, self.bet_struct, [('outfiles', 'in_file')]),
(self.func_source, self.slice_timer, [('outfiles', 'in_file')]),
(self.slice_timer, self.mcflirt, [('slice_time_corrected_file',
'in_file')]),
(self.mcflirt, self.bet_mean, [('mean_img', 'in_file')]),
(self.mcflirt, self.fslsplit, [('out_file', 'in_file')]),
(self.fslsplit, self.bet_func, [('out_files', 'in_files')]),
(self.bet_func, self.fslmerge, [('out_files', 'in_files')
]), # intersect
(self.bet_struct, self.coregister, [('out_file', 'source')]),
(self.bet_mean, self.coregister, [('out_file', 'target')]),
(self.coregister, self.segment, [('coregistered_source', 'data')]),
(self.segment, self.normalize_func, [('transformation_mat',
'parameter_file')]),
(self.fslmerge, self.normalize_func, [('merged_file',
'apply_to_files')]),
(self.normalize_func, self.smooth, [('normalized_files',
'in_files')]),
(self.coregister, self.datasink, [('coregistered_source',
'registered_file')]),
(self.normalize_func, self.datasink, [('normalized_files',
'before_smooth')]),
(self.smooth, self.datasink, [('smoothed_files', 'final_out')])
])
def __init__(self,
subject,
func_source,
struct_source,
datasink,
TR,
num_slices,
dim=2):
self.subject = subject
# specify input and output nodes
self.func_source = func_source
self.struct_source = struct_source
self.datasink = datasink
self.TR = TR
self.num_slices = num_slices
# specify nodes
# structual process
self.bet_struct = pe.Node(interface=fsl.BET(),
name='non_brain_removal_BET_struct')
self.bet_struct.inputs.output_type = "NIFTI"
self.bet_struct.inputs.frac = 0.3
self.coregister_struct = pe.Node(interface=spm.Coregister(),
name="coregister_struct_to_mni")
self.coregister_struct.inputs.target = '/mnt/Program/python/dev/images/MNI152_T1_2mm_brain.nii'
if dim == 1:
self.coregister_struct.inputs.target = '/mnt/Program/python/dev/images/MNI152_T1_1mm_brain.nii'
self.coregister_struct.inputs.write_interp = 7
self.coregister_struct.inputs.separation = [1.0, 1.0]
self.coregister_struct.inputs.jobtype = 'estwrite'
self.segment_struct = pe.Node(interface=spm.Segment(),
name="segment_struct")
# self.segment_struct.inputs.affine_regularization = 'mni'
self.segment_struct.inputs.csf_output_type = [True, True, True]
self.segment_struct.inputs.gm_output_type = [True, True, True]
self.segment_struct.inputs.wm_output_type = [True, True, True]
self.normalize_struct = pe.Node(interface=spm.Normalize(),
name='normalize_struct')
self.normalize_struct.inputs.jobtype = 'write'
self.normalize_struct.inputs.write_bounding_box = [[-90, -126, -72],
[90, 90, 108]
] # 91, 109, 91
if dim == 1:
self.normalize_struct.inputs.write_bounding_box = [[
-91, -126, -72
], [90, 91, 109]] # 182, 218, 182
self.normalize_struct.inputs.write_voxel_sizes = [1, 1, 1]
self.normalize_gm = pe.Node(interface=spm.Normalize(),
name='normalize_gm')
self.normalize_gm.inputs.jobtype = 'write'
self.normalize_gm.inputs.write_bounding_box = [[-90, -126, -72],
[90, 90,
108]] # 91, 109, 91
if dim == 1:
self.normalize_gm.inputs.write_bounding_box = [[-91, -126, -72],
[90, 91, 109]
] # 182, 218, 182
self.normalize_gm.inputs.write_voxel_sizes = [1, 1, 1]
self.normalize_wm = pe.Node(interface=spm.Normalize(),
name='normalize_wm')
self.normalize_wm.inputs.jobtype = 'write'
self.normalize_wm.inputs.write_bounding_box = [[-90, -126, -72],
[90, 90,
108]] # 91, 109, 91
if dim == 1:
self.normalize_wm.inputs.write_bounding_box = [[-91, -126, -72],
[90, 91, 109]
] # 182, 218, 182
self.normalize_wm.inputs.write_voxel_sizes = [1, 1, 1]
self.normalize_csf = pe.Node(interface=spm.Normalize(),
name='normalize_csf')
self.normalize_csf.inputs.jobtype = 'write'
self.normalize_csf.inputs.write_bounding_box = [[-90, -126, -72],
[90, 90,
108]] # 91, 109, 91
if dim == 1:
self.normalize_csf.inputs.write_bounding_box = [[-91, -126, -72],
[90, 91, 109]
] # 182, 218, 182
self.normalize_csf.inputs.write_voxel_sizes = [1, 1, 1]
###################################################################################################
# functional process
self.fslsplit = pe.Node(interface=fsl.Split(), name='fslsplit')
self.fslsplit.inputs.dimension = 't'
self.fslsplit.inputs.output_type = "NIFTI"
self.fslmerge = pe.Node(interface=fsl.Merge(), name='fslmerge')
self.fslmerge.inputs.dimension = 't'
self.fslmerge.inputs.output_type = "NIFTI"
# helper function(s)
def bet_each(in_files, subject_name):
'''
@param in_files: list of image files
@return out_files: list of image files after applied fsl.BET on it
'''
from nipype.interfaces import fsl
import nipype.pipeline.engine as pe
out_files = list()
step_no = 0
for file_ in in_files:
bet = pe.Node(interface=fsl.BET(),
name='BET_for_step_{}_{}'.format(
step_no, subject_name))
bet.inputs.in_file = file_
bet.inputs.out_file = file_[:len(file_) - 4] + '_bet.nii'
bet.inputs.output_type = "NIFTI"
bet.inputs.frac = 0.5
bet.run()
out_files.append(bet.inputs.out_file)
step_no += 1
return out_files
# bet_func return a list of NIFITI files
self.bet_func = pe.Node(interface=Function(
input_names=['in_files', 'subject_name'],
output_names=['out_files'],
function=bet_each),
name='non_brain_removal_BET_func')
self.bet_func.inputs.subject_name = self.subject
self.realign = pe.Node(interface=spm.Realign(),
name='realign_motion_correction')
self.realign.inputs.register_to_mean = True
self.coregister_func = pe.Node(interface=spm.Coregister(),
name="coregister_func_to_mni")
self.coregister_func.inputs.target = '/mnt/Program/python/dev/images/MNI152_T1_2mm_brain.nii'
self.coregister_func.inputs.write_interp = 7
self.coregister_func.inputs.separation = [1.0, 1.0]
self.coregister_func.inputs.jobtype = 'estwrite'
self.segment = pe.Node(interface=spm.Segment(), name="segment")
self.normalize_func = pe.Node(interface=spm.Normalize(),
name="normalize_func")
self.normalize_func.inputs.jobtype = 'write'
self.normalize_func.inputs.write_bounding_box = [[-90, -126, -72],
[90, 90,
108]] # 91, 109, 91
self.smooth = pe.Node(interface=spm.Smooth(), name="smooth")
self.smooth.inputs.fwhm = [8, 8, 8]
# backup node(s)
self.slice_timing = pe.Node(interface=spm.SliceTiming(),
name='time_slice_correction')
self.slice_timing.inputs.time_repetition = self.TR
self.slice_timing.inputs.num_slices = self.num_slices
self.slice_timing.inputs.time_acquisition = self.TR - (self.TR /
self.num_slices)
self.slice_timing.inputs.slice_order = list(
range(self.num_slices, 0, -1))
self.slice_timing.inputs.ref_slice = 1
self.direct_normalize = pe.Node(interface=spm.Normalize12(),
name='direct_normalize')
self.direct_normalize.inputs.image_to_align = 'images/MNI152_T1_2mm_brain.nii'
self.direct_normalize.inputs.affine_regularization_type = 'size'
# specify workflow instance
self.workflow = pe.Workflow(name='preprocess_workflow')
# connect nodes
self.workflow.connect([
(self.struct_source, self.bet_struct, [('outfiles', 'in_file')]),
(self.bet_struct, self.coregister_struct, [('out_file', 'source')
]),
(self.coregister_struct, self.segment_struct,
[('coregistered_source', 'data')]),
(self.segment_struct, self.normalize_struct,
[('transformation_mat', 'parameter_file')]),
(self.coregister_struct, self.normalize_struct,
[('coregistered_source', 'apply_to_files')]),
(self.segment_struct, self.normalize_gm, [('transformation_mat',
'parameter_file')]),
(self.segment_struct, self.normalize_gm, [('native_gm_image',
'apply_to_files')]),
(self.segment_struct, self.normalize_wm, [('transformation_mat',
'parameter_file')]),
(self.segment_struct, self.normalize_wm, [('native_wm_image',
'apply_to_files')]),
(self.segment_struct, self.normalize_csf, [('transformation_mat',
'parameter_file')]),
(self.segment_struct, self.normalize_csf, [('native_csf_image',
'apply_to_files')]),
(self.func_source, self.fslsplit, [('outfiles', 'in_file')]),
(self.fslsplit, self.bet_func, [('out_files', 'in_files')]),
(self.bet_func, self.fslmerge, [('out_files', 'in_files')]),
(self.fslmerge, self.realign, [('merged_file', 'in_files')]),
(self.realign, self.datasink, [('realignment_parameters',
'realignment_parameters')]),
(self.realign, self.coregister_func, [('mean_image', 'source')]),
(self.realign, self.coregister_func, [('realigned_files',
'apply_to_files')]),
(self.coregister_func, self.segment, [('coregistered_source',
'data')]),
(self.segment, self.normalize_func, [('transformation_mat',
'parameter_file')]),
(self.coregister_func, self.normalize_func, [('coregistered_files',
'apply_to_files')]),
(self.normalize_func, self.smooth, [('normalized_files',
'in_files')]), # end
(self.normalize_func, self.datasink, [('normalized_files',
'before_smooth')]),
(self.smooth, self.datasink, [('smoothed_files', 'final_out')]),
(self.normalize_struct, self.datasink,
[('normalized_files', 'standardized_struct_file')]),
# (self.segment_struct, self.datasink, [('native_csf_image', 'csf'), ('native_gm_image', 'grey_matter'), ('native_wm_image', 'white_matter')])
(self.normalize_gm, self.datasink, [('normalized_files',
'grey_matter')]),
(self.normalize_wm, self.datasink, [('normalized_files',
'white_matter')]),
(self.normalize_csf, self.datasink, [('normalized_files', 'csf')]),
])
# backup workflow(s)
self.workflow_only_fmri = pe.Workflow(name='preprocess_workflow')
# connect nodes
self.workflow_only_fmri.connect([
(self.func_source, self.fslsplit, [('outfiles', 'in_file')]),
(self.fslsplit, self.bet_func, [('out_files', 'in_files')]),
(self.bet_func, self.fslmerge, [('out_files', 'in_files')]),
(self.fslmerge, self.realign, [('merged_file', 'in_files')]),
(self.realign, self.direct_normalize, [('realigned_files',
'apply_to_files')]),
(self.direct_normalize, self.smooth, [('normalized_files',
'in_files')]), # end
(self.direct_normalize, self.datasink, [('normalized_files',
'before_smooth')]),
(self.smooth, self.datasink, [('smoothed_files', 'final_out')])
])
preproc = pe.Workflow(name='preproc') """Use :class:`nipype.interfaces.spm.Realign` for motion correction and register all images to the mean image. """ realign = pe.Node(interface=spm.Realign(), name="realign") slice_timing = pe.Node(interface=spm.SliceTiming(), name="slice_timing") """Use :class:`nipype.interfaces.spm.Coregister` to perform a rigid body registration of the functional data to the structural data. """ coregister = pe.Node(interface=spm.Coregister(), name="coregister") coregister.inputs.jobtype = 'estimate' segment = pe.Node(interface=spm.Segment(), name="segment") segment.inputs.save_bias_corrected = True """Uncomment the following line for faster execution """ # segment.inputs.gaussians_per_class = [1, 1, 1, 4] """Warp functional and structural data to SPM's T1 template using :class:`nipype.interfaces.spm.Normalize`. The tutorial data set includes the template image, T1.nii. """ normalize_func = pe.Node(interface=spm.Normalize(), name="normalize_func") normalize_func.inputs.jobtype = "write" normalize_struc = pe.Node(interface=spm.Normalize(), name="normalize_struc") normalize_struc.inputs.jobtype = "write"
def create_prepare_seeds_from_fmri_pipeline(name="prepare_seeds_from_fmri"):
inputnode = pe.Node(interface=util.IdentityInterface(fields=[
'epi', "stat", "dwi", "mask", "phsamples", "thsamples", "fsamples",
"T1", "stat_labels"
]),
name="inputnode")
first_dwi = pe.Node(interface=fsl.ExtractROI(t_min=0, t_size=1),
name="first_dwi")
first_epi = first_dwi.clone(name="first_epi")
coregister = pe.Node(interface=fsl.FLIRT(), name="coregister_epi2dwi")
reslice_stat = pe.MapNode(interface=fsl.FLIRT(),
name="reslice_stat",
iterfield=["in_file"])
reslice_stat.inputs.apply_xfm = True
reslice_mask = pe.Node(interface=fsl.FLIRT(), name="reslice_mask")
reslice_mask.inputs.interp = "nearestneighbour"
smm = pe.MapNode(interface=fsl.SMM(),
name="smm",
iterfield=['spatial_data_file'])
threshold = pe.MapNode(interface=fsl.Threshold(),
name="threshold",
iterfield=['in_file'])
threshold.inputs.thresh = 0.95
probtractx = pe.Node(interface=fsl.ProbTrackX(),
name="probtractx") #, iterfield=['waypoints'])
probtractx.inputs.opd = True
probtractx.inputs.loop_check = True
probtractx.inputs.c_thresh = 0.2
probtractx.inputs.n_steps = 2000
probtractx.inputs.step_length = 0.5
probtractx.inputs.n_samples = 100
probtractx.inputs.correct_path_distribution = True
probtractx.inputs.verbose = 2
segment = pe.Node(interface=spm.Segment(), name="segment")
segment.inputs.gm_output_type = [False, False, True]
segment.inputs.wm_output_type = [False, False, True]
segment.inputs.csf_output_type = [False, False, False]
th_wm = pe.Node(interface=fsl.Threshold(), name="th_wm")
th_wm.inputs.direction = "below"
th_wm.inputs.thresh = 0.2
th_gm = th_wm.clone("th_gm")
wm_gm_interface = pe.Node(fsl.ApplyMask(), name="wm_gm_interface")
bet_t1 = pe.Node(fsl.BET(), name="bet_t1")
coregister_t1_to_dwi = pe.Node(interface=fsl.FLIRT(),
name="coregister_t1_to_dwi")
invert_dwi_to_t1_xfm = pe.Node(interface=fsl.ConvertXFM(),
name="invert_dwi_to_t1_xfm")
invert_dwi_to_t1_xfm.inputs.invert_xfm = True
reslice_gm = pe.Node(interface=fsl.FLIRT(), name="reslice_gm")
reslice_gm.inputs.apply_xfm = True
reslice_wm = reslice_gm.clone("reslice_wm")
particles2trackvis = pe.Node(interface=neuroutils.Particle2Trackvis(),
name='particles2trackvis')
annotate_trackvis = pe.Node(interface=neuroutils.AnnotateTracts(),
name='annotate_trackvis')
smooth_tracks = pe.Node(interface=dt.SplineFilter(), name="smooth_tracks")
smooth_tracks.inputs.step_length = 0.5
pipeline = pe.Workflow(name=name)
pipeline.connect([
(inputnode, first_dwi, [("dwi", "in_file")]),
(inputnode, first_epi, [("epi", "in_file")]),
(first_epi, coregister, [("roi_file", "in_file")]),
(first_dwi, coregister, [("roi_file", "reference")]),
(inputnode, reslice_stat, [("stat", "in_file"), ("dwi", "reference")]),
(inputnode, reslice_mask, [("mask", "in_file"), ("dwi", "reference")]),
(coregister, reslice_stat, [("out_matrix_file", "in_matrix_file")]),
(coregister, reslice_mask, [("out_matrix_file", "in_matrix_file")]),
(reslice_stat, smm, [("out_file", "spatial_data_file")]),
(reslice_mask, smm, [("out_file", "mask")]),
(smm, threshold, [('activation_p_map', 'in_file')]),
(inputnode, probtractx, [("phsamples", "phsamples"),
("thsamples", "thsamples"),
("fsamples", "fsamples")]),
(reslice_mask, probtractx, [("out_file", "mask")]),
#(threshold, probtractx, [("out_file", "waypoints")]),
(inputnode, segment, [("T1", "data")]),
(inputnode, bet_t1, [("T1", "in_file")]),
(bet_t1, coregister_t1_to_dwi, [("out_file", "reference")]),
(first_dwi, coregister_t1_to_dwi, [("roi_file", "in_file")]),
(coregister_t1_to_dwi, invert_dwi_to_t1_xfm, [("out_matrix_file",
"in_file")]),
(invert_dwi_to_t1_xfm, reslice_gm, [("out_file", "in_matrix_file")]),
(segment, reslice_gm, [("native_gm_image", "in_file")]),
(first_dwi, reslice_gm, [("roi_file", "reference")]),
(reslice_gm, th_gm, [("out_file", "in_file")]),
(th_gm, wm_gm_interface, [("out_file", "in_file")]),
(invert_dwi_to_t1_xfm, reslice_wm, [("out_file", "in_matrix_file")]),
(segment, reslice_wm, [("native_wm_image", "in_file")]),
(first_dwi, reslice_wm, [("roi_file", "reference")]),
(reslice_wm, th_wm, [("out_file", "in_file")]),
(th_wm, wm_gm_interface, [("out_file", "mask_file")]),
(wm_gm_interface, probtractx, [("out_file", "seed")]),
(probtractx, particles2trackvis, [('particle_files', 'particle_files')
]),
(reslice_mask, particles2trackvis, [("out_file", "reference_file")]),
(particles2trackvis, annotate_trackvis, [('trackvis_file',
'trackvis_file')]),
(smm, annotate_trackvis, [('activation_p_map', 'stat_files')]),
(inputnode, annotate_trackvis, [('stat_labels', 'stat_labels')]),
(annotate_trackvis, smooth_tracks, [('annotated_trackvis_file',
'track_file')])
])
return pipeline
