def create_spm_preproc(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)
"""
"""
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']),
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')
workflow.connect(inputnode, 'functionals', realign, 'in_files')
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(realign, 'mean_image', maskflow, 'inputspec.source_file')
smooth = pe.Node(spm.Smooth(), name='smooth')
workflow.connect(inputnode, 'fwhm', smooth, 'fwhm')
workflow.connect(realign, 'realigned_files', smooth, 'in_files')
artdetect = pe.Node(ra.ArtifactDetect(mask_type='file',
parameter_source='SPM',
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, [('realigned_files', 'realigned_files'),
('realignment_parameters',
'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",
"reg_file",
"reg_cost",
'outlier_files',
'outlier_stats',
'outlier_plots'
]),
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, [('realignment_parameters', 'realignment_parameters')]),
(smooth, outputnode, [('smoothed_files', 'smoothed_files')]),
(artdetect, outputnode,[('outlier_files', 'outlier_files'),
('statistic_files','outlier_stats'),
('plot_files','outlier_plots')])
])
return workflow
def create_fsl_fs_preproc(name='preproc', highpass=True, whichvol='middle'):
"""Create a FEAT preprocessing workflow together with freesurfer
Parameters
----------
name : name of workflow (default: preproc)
highpass : boolean (default: True)
whichvol : which volume of the first run to register to ('first', 'middle', 'mean')
Inputs::
inputspec.func : functional runs (filename or list of filenames)
inputspec.fwhm : fwhm for smoothing with SUSAN
inputspec.highpass : HWHM in TRs (if created with highpass=True)
inputspec.subject_id : freesurfer subject id
inputspec.subjects_dir : freesurfer subjects dir
Outputs::
outputspec.reference : volume to which runs are realigned
outputspec.motion_parameters : motion correction parameters
outputspec.realigned_files : motion corrected files
outputspec.motion_plots : plots of motion correction parameters
outputspec.mask_file : mask file used to mask the brain
outputspec.smoothed_files : smoothed functional data
outputspec.highpassed_files : highpassed functional data (if highpass=True)
outputspec.reg_file : bbregister registration files
outputspec.reg_cost : bbregister registration cost files
Example
-------
>>> import os
>>> from nipype.workflows.fsl import create_fsl_fs_preproc
>>> preproc = create_fsl_fs_preproc(whichvol='first')
>>> preproc.inputs.inputspec.highpass = 128./(2*2.5)
>>> preproc.inputs.inputspec.func = ['f3.nii', 'f5.nii']
>>> preproc.inputs.inputspec.subjects_dir = '.'
>>> preproc.inputs.inputspec.subject_id = 's1'
>>> preproc.inputs.inputspec.fwhm = 6
>>> preproc.run() # doctest: +SKIP
"""
featpreproc = pe.Workflow(name=name)
"""
Set up a node to define all inputs required for the preprocessing workflow
"""
if highpass:
inputnode = pe.Node(interface=util.IdentityInterface(fields=['func',
'fwhm',
'subject_id',
'subjects_dir',
'highpass']),
name='inputspec')
outputnode = pe.Node(interface=util.IdentityInterface(fields=['reference',
'motion_parameters',
'realigned_files',
'motion_plots',
'mask_file',
'smoothed_files',
'highpassed_files',
'reg_file',
'reg_cost'
]),
name='outputspec')
else:
inputnode = pe.Node(interface=util.IdentityInterface(fields=['func',
'fwhm',
'subject_id',
'subjects_dir'
]),
name='inputspec')
outputnode = pe.Node(interface=util.IdentityInterface(fields=['reference',
'motion_parameters',
'realigned_files',
'motion_plots',
'mask_file',
'smoothed_files',
'reg_file',
'reg_cost'
]),
name='outputspec')
"""
Set up a node to define outputs for the preprocessing workflow
"""
"""
Convert functional images to float representation. Since there can
be more than one functional run we use a MapNode to convert each
run.
"""
img2float = pe.MapNode(interface=fsl.ImageMaths(out_data_type='float',
op_string = '',
suffix='_dtype'),
iterfield=['in_file'],
name='img2float')
featpreproc.connect(inputnode, 'func', img2float, 'in_file')
"""
Extract the first volume of the first run as the reference
"""
if whichvol != 'mean':
extract_ref = pe.Node(interface=fsl.ExtractROI(t_size=1),
iterfield=['in_file'],
name = 'extractref')
featpreproc.connect(img2float, ('out_file', pickfirst), extract_ref, 'in_file')
featpreproc.connect(img2float, ('out_file', pickvol, 0, whichvol), extract_ref, 't_min')
featpreproc.connect(extract_ref, 'roi_file', outputnode, 'reference')
"""
Realign the functional runs to the reference (1st volume of first run)
"""
motion_correct = pe.MapNode(interface=fsl.MCFLIRT(save_mats = True,
save_plots = True,
interpolation = 'sinc'),
name='realign',
iterfield = ['in_file'])
featpreproc.connect(img2float, 'out_file', motion_correct, 'in_file')
if whichvol != 'mean':
featpreproc.connect(extract_ref, 'roi_file', motion_correct, 'ref_file')
else:
motion_correct.inputs.mean_vol = True
featpreproc.connect(motion_correct, 'mean_img', outputnode, 'reference')
featpreproc.connect(motion_correct, 'par_file', outputnode, 'motion_parameters')
featpreproc.connect(motion_correct, 'out_file', outputnode, 'realigned_files')
"""
Plot the estimated motion parameters
"""
plot_motion = pe.MapNode(interface=fsl.PlotMotionParams(in_source='fsl'),
name='plot_motion',
iterfield=['in_file'])
plot_motion.iterables = ('plot_type', ['rotations', 'translations'])
featpreproc.connect(motion_correct, 'par_file', plot_motion, 'in_file')
featpreproc.connect(plot_motion, 'out_file', outputnode, 'motion_plots')
"""Get the mask from subject for each run
"""
maskflow = create_getmask_flow()
featpreproc.connect([(inputnode, maskflow, [('subject_id','inputspec.subject_id'),
('subjects_dir', 'inputspec.subjects_dir')])])
maskflow.inputs.inputspec.contrast_type = 't2'
if whichvol != 'mean':
featpreproc.connect(extract_ref, 'roi_file', maskflow, 'inputspec.source_file')
else:
featpreproc.connect(motion_correct, ('mean_img', pickfirst), maskflow, 'inputspec.source_file')
"""
Mask the functional runs with the extracted mask
"""
maskfunc = pe.MapNode(interface=fsl.ImageMaths(suffix='_bet',
op_string='-mas'),
iterfield=['in_file'],
name = 'maskfunc')
featpreproc.connect(motion_correct, 'out_file', maskfunc, 'in_file')
featpreproc.connect(maskflow, ('outputspec.mask_file', pickfirst), maskfunc, 'in_file2')
"""
Smooth each run using SUSAN with the brightness threshold set to 75%
of the median value for each run and a mask consituting the mean
functional
"""
smooth = create_susan_smooth(separate_masks=False)
featpreproc.connect(inputnode, 'fwhm', smooth, 'inputnode.fwhm')
featpreproc.connect(maskfunc, 'out_file', smooth, 'inputnode.in_files')
featpreproc.connect(maskflow, ('outputspec.mask_file', pickfirst), smooth, 'inputnode.mask_file')
"""
Mask the smoothed data with the dilated mask
"""
maskfunc3 = pe.MapNode(interface=fsl.ImageMaths(suffix='_mask',
op_string='-mas'),
iterfield=['in_file'],
name='maskfunc3')
featpreproc.connect(smooth, 'outputnode.smoothed_files', maskfunc3, 'in_file')
featpreproc.connect(maskflow, ('outputspec.mask_file', pickfirst), maskfunc3, 'in_file2')
concatnode = pe.Node(interface=util.Merge(2),
name='concat')
featpreproc.connect(maskfunc, ('out_file', tolist), concatnode, 'in1')
featpreproc.connect(maskfunc3, ('out_file', tolist), concatnode, 'in2')
"""
The following nodes select smooth or unsmoothed data depending on the
fwhm. This is because SUSAN defaults to smoothing the data with about the
voxel size of the input data if the fwhm parameter is less than 1/3 of the
voxel size.
"""
selectnode = pe.Node(interface=util.Select(),name='select')
featpreproc.connect(concatnode, 'out', selectnode, 'inlist')
featpreproc.connect(inputnode, ('fwhm', chooseindex), selectnode, 'index')
featpreproc.connect(selectnode, 'out', outputnode, 'smoothed_files')
"""
Scale the median value of the run is set to 10000
"""
meanscale = pe.MapNode(interface=fsl.ImageMaths(suffix='_gms'),
iterfield=['in_file','op_string'],
name='meanscale')
featpreproc.connect(selectnode, 'out', meanscale, 'in_file')
"""
Determine the median value of the functional runs using the mask
"""
medianval = pe.MapNode(interface=fsl.ImageStats(op_string='-k %s -p 50'),
iterfield = ['in_file'],
name='medianval')
featpreproc.connect(motion_correct, 'out_file', medianval, 'in_file')
featpreproc.connect(maskflow, ('outputspec.mask_file', pickfirst), medianval, 'mask_file')
"""
Define a function to get the scaling factor for intensity normalization
"""
featpreproc.connect(medianval, ('out_stat', getmeanscale), meanscale, 'op_string')
"""
Perform temporal highpass filtering on the data
"""
if highpass:
highpass = pe.MapNode(interface=fsl.ImageMaths(suffix='_tempfilt'),
iterfield=['in_file'],
name='highpass')
featpreproc.connect(inputnode, ('highpass', highpass_operand), highpass, 'op_string')
featpreproc.connect(meanscale, 'out_file', highpass, 'in_file')
featpreproc.connect(highpass, 'out_file', outputnode, 'highpassed_files')
featpreproc.connect(maskflow, ('outputspec.mask_file', pickfirst), outputnode, 'mask_file')
featpreproc.connect(maskflow, 'outputspec.reg_file', outputnode, 'reg_file')
featpreproc.connect(maskflow, 'outputspec.reg_cost', outputnode, 'reg_cost')
return featpreproc
