def hmc_afni(name='fMRI_HMC_afni', st_correct=False):
"""A head motion correction (HMC) workflow for functional scans"""
workflow = pe.Workflow(name=name)
inputnode = pe.Node(niu.IdentityInterface(
fields=['in_file', 'fd_radius', 'start_idx', 'stop_idx']),
name='inputnode')
outputnode = pe.Node(
niu.IdentityInterface(fields=['out_file', 'out_movpar']),
name='outputnode')
drop_trs = pe.Node(afp.Calc(expr='a', outputtype='NIFTI_GZ'),
name='drop_trs')
deoblique = pe.Node(afp.Refit(deoblique=True), name='deoblique')
reorient = pe.Node(afp.Resample(orientation='RPI', outputtype='NIFTI_GZ'),
name='reorient')
get_mean_RPI = pe.Node(afp.TStat(options='-mean', outputtype='NIFTI_GZ'),
name='get_mean_RPI')
# calculate hmc parameters
hmc = pe.Node(afp.Volreg(args='-Fourier -twopass',
zpad=4,
outputtype='NIFTI_GZ'),
name='motion_correct')
get_mean_motion = get_mean_RPI.clone('get_mean_motion')
hmc_A = hmc.clone('motion_correct_A')
hmc_A.inputs.md1d_file = 'max_displacement.1D'
movpar = pe.Node(niu.Function(function=fd_jenkinson,
input_names=['in_file', 'rmax'],
output_names=['out_file']),
name='Mat2Movpar')
workflow.connect([(inputnode, drop_trs, [('in_file', 'in_file_a'),
('start_idx', 'start_idx'),
('stop_idx', 'stop_idx')]),
(inputnode, movpar, [('fd_radius', 'rmax')]),
(deoblique, reorient, [('out_file', 'in_file')]),
(reorient, get_mean_RPI, [('out_file', 'in_file')]),
(reorient, hmc, [('out_file', 'in_file')]),
(get_mean_RPI, hmc, [('out_file', 'basefile')]),
(hmc, get_mean_motion, [('out_file', 'in_file')]),
(reorient, hmc_A, [('out_file', 'in_file')]),
(get_mean_motion, hmc_A, [('out_file', 'basefile')]),
(hmc_A, outputnode, [('out_file', 'out_file')]),
(hmc_A, movpar, [('oned_matrix_save', 'in_file')]),
(movpar, outputnode, [('out_file', 'out_movpar')])])
if st_correct:
st_corr = pe.Node(afp.TShift(outputtype='NIFTI_GZ'), name='TimeShifts')
workflow.connect([(drop_trs, st_corr, [('out_file', 'in_file')]),
(st_corr, deoblique, [('out_file', 'in_file')])])
else:
workflow.connect([(drop_trs, deoblique, [('out_file', 'in_file')])])
return workflow
def func_preprocess(name='func_preproc'):
'''
Method to preprocess functional data after warping to anatomical space.
Accomplished after one step Distortion Correction, Motion Correction and Boundary based linear registration to
anatomical space.
Precodure includes:
# 1- skull strip
# 2- Normalize the image intensity values.
# 3- Calculate Mean of Skull stripped image
# 4- Create brain mask from Normalized data.
'''
# Define Workflow
flow = Workflow(name=name)
inputnode = Node(util.IdentityInterface(fields=['func_in']),
name='inputnode')
outputnode = Node(util.IdentityInterface(
fields=['func_preproc', 'func_preproc_mean', 'func_preproc_mask']),
name='outputnode')
# 2- Normalize the image intensity values.
norm = Node(interface=fsl.ImageMaths(), name='func_normalized')
norm.inputs.op_string = '-ing 1000'
norm.out_data_type = 'float'
norm.output_type = 'NIFTI'
# 4- Create brain mask from Normalized data.
mask = Node(interface=fsl.BET(), name='func_preprocessed')
mask.inputs.functional = True
mask.inputs.mask = True
mask.inputs.frac = 0.5
mask.inputs.vertical_gradient = 0
mask.inputs.threshold = True
# 3- Calculate Mean of Skull stripped image
mean = Node(interface=preprocess.TStat(), name='func_preprocessed_mean')
mean.inputs.options = '-mean'
mean.inputs.outputtype = 'NIFTI'
flow.connect(inputnode, 'func_in', norm, 'in_file')
flow.connect(norm, 'out_file', mask, 'in_file')
flow.connect(norm, 'out_file', mean, 'in_file')
flow.connect(mask, 'out_file', outputnode, 'func_preproc')
flow.connect(mask, 'mask_file', outputnode, 'func_preproc_mask')
flow.connect(mean, 'out_file', outputnode, 'func_preproc_mean')
return flow
def mean_functional_workflow(workflow, resource_pool, config):
# resource pool should have:
# func_motion_correct
''' this version does NOT remove background noise '''
import os
import sys
import nipype.interfaces.io as nio
import nipype.pipeline.engine as pe
import nipype.interfaces.utility as util
import nipype.interfaces.fsl.maths as fsl
from nipype.interfaces.afni import preprocess
from workflow_utils import check_input_resources
#check_input_resources(resource_pool, "func_motion_correct")
#check_input_resources(resource_pool, "functional_brain_mask")
if "func_motion_correct" not in resource_pool.keys():
from functional_preproc import func_motion_correct_workflow
workflow, resource_pool = \
func_motion_correct_workflow(workflow, resource_pool, config)
func_mean_skullstrip = pe.Node(interface=preprocess.TStat(),
name='func_mean_skullstrip')
func_mean_skullstrip.inputs.options = '-mean'
func_mean_skullstrip.inputs.outputtype = 'NIFTI_GZ'
if len(resource_pool["func_motion_correct"]) == 2:
node, out_file = resource_pool["func_motion_correct"]
workflow.connect(node, out_file, func_mean_skullstrip,
'in_file') #func_edge_detect, 'in_file_a')
else:
func_mean_skullstrip.inputs.in_file = \
resource_pool["func_motion_correct"]
resource_pool["mean_functional"] = (func_mean_skullstrip, 'out_file')
return workflow, resource_pool
def create_bo_func_preproc(slice_timing_correction = False, wf_name = 'bo_func_preproc'):
"""
The main purpose of this workflow is to process functional data. Raw rest file is deobliqued and reoriented
into RPI. Then take the mean intensity values over all time points for each voxel and use this image
to calculate motion parameters. The image is then skullstripped, normalized and a processed mask is
obtained to use it further in Image analysis.
Parameters
----------
slice_timing_correction : boolean
Slice timing Correction option
wf_name : string
Workflow name
Returns
-------
func_preproc : workflow object
Functional Preprocessing workflow object
Notes
-----
`Source <https://github.com/FCP-INDI/C-PAC/blob/master/CPAC/func_preproc/func_preproc.py>`_
Workflow Inputs::
inputspec.rest : func/rest file or a list of func/rest nifti file
User input functional(T2) Image, in any of the 8 orientations
inputspec.start_idx : string
Starting volume/slice of the functional image (optional)
inputspec.stop_idx : string
Last volume/slice of the functional image (optional)
scan_params.tr : string
Subject TR
scan_params.acquistion : string
Acquisition pattern (interleaved/sequential, ascending/descending)
scan_params.ref_slice : integer
Reference slice for slice timing correction
Workflow Outputs::
outputspec.drop_tr : string (nifti file)
Path to Output image with the initial few slices dropped
outputspec.slice_time_corrected : string (nifti file)
Path to Slice time corrected image
outputspec.refit : string (nifti file)
Path to deobliqued anatomical data
outputspec.reorient : string (nifti file)
Path to RPI oriented anatomical data
outputspec.motion_correct_ref : string (nifti file)
Path to Mean intensity Motion corrected image
(base reference image for the second motion correction run)
outputspec.motion_correct : string (nifti file)
Path to motion corrected output file
outputspec.max_displacement : string (Mat file)
Path to maximum displacement (in mm) for brain voxels in each volume
outputspec.movement_parameters : string (Mat file)
Path to 1D file containing six movement/motion parameters(3 Translation, 3 Rotations)
in different columns (roll pitch yaw dS dL dP)
outputspec.skullstrip : string (nifti file)
Path to skull stripped Motion Corrected Image
outputspec.mask : string (nifti file)
Path to brain-only mask
outputspec.example_func : string (nifti file)
Mean, Skull Stripped, Motion Corrected output T2 Image path
(Image with mean intensity values across voxels)
outputpsec.preprocessed : string (nifti file)
output skull stripped, motion corrected T2 image
with normalized intensity values
outputspec.preprocessed_mask : string (nifti file)
Mask obtained from normalized preprocessed image
Order of commands:
- Get the start and the end volume index of the functional run. If not defined by the user, return the first and last volume.
get_idx(in_files, stop_idx, start_idx)
- Dropping the initial TRs. For details see `3dcalc <http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dcalc.html>`_::
3dcalc -a rest.nii.gz[4..299]
-expr 'a'
-prefix rest_3dc.nii.gz
- Slice timing correction. For details see `3dshift <http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dTshift.html>`_::
3dTshift -TR 2.1s
-slice 18
-tpattern alt+z
-prefix rest_3dc_shift.nii.gz rest_3dc.nii.gz
- Deobliqing the scans. For details see `3drefit <http://afni.nimh.nih.gov/pub/dist/doc/program_help/3drefit.html>`_::
3drefit -deoblique rest_3dc.nii.gz
- Re-orienting the Image into Right-to-Left Posterior-to-Anterior Inferior-to-Superior (RPI) orientation. For details see `3dresample <http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dresample.html>`_::
3dresample -orient RPI
-prefix rest_3dc_RPI.nii.gz
-inset rest_3dc.nii.gz
- Calculate voxel wise statistics. Get the RPI Image with mean intensity values over all timepoints for each voxel. For details see `3dTstat <http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dTstat.html>`_::
3dTstat -mean
-prefix rest_3dc_RPI_3dT.nii.gz
rest_3dc_RPI.nii.gz
- Motion Correction. For details see `3dvolreg <http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dvolreg.html>`_::
3dvolreg -Fourier
-twopass
-base rest_3dc_RPI_3dT.nii.gz/
-zpad 4
-maxdisp1D rest_3dc_RPI_3dvmd1D.1D
-1Dfile rest_3dc_RPI_3dv1D.1D
-prefix rest_3dc_RPI_3dv.nii.gz
rest_3dc_RPI.nii.gz
The base image or the reference image is the mean intensity RPI image obtained in the above the step.For each volume
in RPI-oriented T2 image, the command, aligns the image with the base mean image and calculates the motion, displacement
and movement parameters. It also outputs the aligned 4D volume and movement and displacement parameters for each volume.
- Calculate voxel wise statistics. Get the motion corrected output Image from the above step, with mean intensity values over all timepoints for each voxel.
For details see `3dTstat <http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dTstat.html>`_::
3dTstat -mean
-prefix rest_3dc_RPI_3dv_3dT.nii.gz
rest_3dc_RPI_3dv.nii.gz
- Motion Correction and get motion, movement and displacement parameters. For details see `3dvolreg <http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dvolreg.html>`_::
3dvolreg -Fourier
-twopass
-base rest_3dc_RPI_3dv_3dT.nii.gz
-zpad 4
-maxdisp1D rest_3dc_RPI_3dvmd1D.1D
-1Dfile rest_3dc_RPI_3dv1D.1D
-prefix rest_3dc_RPI_3dv.nii.gz
rest_3dc_RPI.nii.gz
The base image or the reference image is the mean intensity motion corrected image obtained from the above the step (first 3dvolreg run).
For each volume in RPI-oriented T2 image, the command, aligns the image with the base mean image and calculates the motion, displacement
and movement parameters. It also outputs the aligned 4D volume and movement and displacement parameters for each volume.
- Unwarp the motion corrected using a regularized B0 field map that is in RPI space, one of the outputs from the calib_preproc using FSL FUGUE
fugue --nocheck=on
-i rest_3dc_RPI_3dv.nii.gz
--loadfmap=cal_reg_bo_RPI
--unwarpdir=x
--dwell=1
-u rest_3dc_RPI_3dv_unwarped.nii.gz
- Create a brain-only mask. For details see `3dautomask <http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dAutomask.html>`_::
3dAutomask
-prefix rest_3dc_RPI_3dv_unwarped_automask.nii.gz
rest_3dc_RPI_3dv_unwarped.nii.gz
- Edge Detect(remove skull) and get the brain only. For details see `3dcalc <http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dcalc.html>`_::
3dcalc -a rest_3dc_RPI_3dv_unwarped.nii.gz
-b rest_3dc_RPI_3dv_unwarped_automask.nii.gz
-expr 'a*b'
-prefix rest_3dc_RPI_3dv_unwarped_3dc.nii.gz
- Normalizing the image intensity values. For details see `fslmaths <http://www.fmrib.ox.ac.uk/fsl/avwutils/index.html>`_::
fslmaths rest_3dc_RPI_3dv_unwarped_3dc.nii.gz
-ing 10000 rest_3dc_RPI_3dv_unwarped_3dc_maths.nii.gz
-odt float
Normalized intensity = (TrueValue*10000)/global4Dmean
- Calculate mean of skull stripped image. For details see `3dTstat <http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dTstat.html>`_::
3dTstat -mean -prefix rest_3dc_RPI_3dv_unwarped_3dc_3dT.nii.gz rest_3dc_RPI_3dv_unwarped_3dc.nii.gz
- Create Mask (Generate mask from Normalized data). For details see `fslmaths <http://www.fmrib.ox.ac.uk/fsl/avwutils/index.html>`_::
fslmaths rest_3dc_RPI_3dv_unwarped_3dc_maths.nii.gz
-Tmin -bin rest_3dc_RPI_3dv_unwarped_3dc_maths_maths.nii.gz
-odt char
High Level Workflow Graph:
.. image:: ../images/func_preproc.dot.png
:width: 1000
Detailed Workflow Graph:
.. image:: ../images/func_preproc_detailed.dot.png
:width: 1000
Examples
--------
>>> from func_preproc import *
>>> preproc = create_func_preproc(slice_timing_correction=True)
>>> preproc.inputs.inputspec.func='sub1/func/rest.nii.gz'
>>> preproc.inputs.scan_params.TR = '2.0'
>>> preproc.inputs.scan_params.ref_slice = 19
>>> preproc.inputs.scan_params.acquisition = 'alt+z2'
>>> preproc.run() #doctest: +SKIP
>>> from func_preproc import *
>>> preproc = create_func_preproc(slice_timing_correction=False)
>>> preproc.inputs.inputspec.func='sub1/func/rest.nii.gz'
>>> preproc.inputs.inputspec.start_idx = 4
>>> preproc.inputs.inputspec.stop_idx = 250
>>> preproc.run() #doctest: +SKIP
"""
preproc = pe.Workflow(name=wf_name)
inputNode = pe.Node(util.IdentityInterface(fields=['rest',
'calib_reg_bo_RPI',
'start_idx',
'stop_idx']),
name='inputspec')
scan_params = pe.Node(util.IdentityInterface(fields=['tr',
'acquisition',
'ref_slice']),
name = 'scan_params')
outputNode = pe.Node(util.IdentityInterface(fields=['drop_tr',
'refit',
'reorient',
'reorient_mean',
'motion_correct',
'motion_correct_ref',
'movement_parameters',
'max_displacement',
'bo_unwarped',
'mask',
'mask_preunwarp',
'skullstrip',
'example_func',
'preprocessed',
'preprocessed_mask',
'slice_time_corrected']),
name='outputspec')
func_get_idx = pe.Node(util.Function(input_names=['in_files',
'stop_idx',
'start_idx'],
output_names=['stopidx',
'startidx'],
function=get_idx), name='func_get_idx')
preproc.connect(inputNode, 'rest',
func_get_idx, 'in_files')
preproc.connect(inputNode, 'start_idx',
func_get_idx, 'start_idx')
preproc.connect(inputNode, 'stop_idx',
func_get_idx, 'stop_idx')
func_drop_trs = pe.Node(interface=preprocess.Calc(),
name='func_drop_trs')
func_drop_trs.inputs.expr = 'a'
func_drop_trs.inputs.outputtype = 'NIFTI_GZ'
preproc.connect(inputNode, 'rest',
func_drop_trs, 'in_file_a')
preproc.connect(func_get_idx, 'startidx',
func_drop_trs, 'start_idx')
preproc.connect(func_get_idx, 'stopidx',
func_drop_trs, 'stop_idx')
preproc.connect(func_drop_trs, 'out_file',
outputNode, 'drop_tr')
func_slice_timing_correction = pe.Node(interface=preprocess.TShift(),
name = 'func_slice_timing_correction')
func_slice_timing_correction.inputs.outputtype = 'NIFTI_GZ'
func_deoblique = pe.Node(interface=preprocess.Refit(),
name='func_deoblique')
func_deoblique.inputs.deoblique = True
if slice_timing_correction:
preproc.connect(func_drop_trs, 'out_file',
func_slice_timing_correction,'in_file')
preproc.connect(scan_params, 'tr',
func_slice_timing_correction, 'tr')
preproc.connect(scan_params, 'acquisition',
func_slice_timing_correction, 'tpattern')
preproc.connect(scan_params, 'ref_slice',
func_slice_timing_correction, 'tslice')
preproc.connect(func_slice_timing_correction, 'out_file',
func_deoblique, 'in_file')
preproc.connect(func_slice_timing_correction, 'out_file',
outputNode, 'slice_time_corrected')
else:
preproc.connect(func_drop_trs, 'out_file',
func_deoblique, 'in_file')
preproc.connect(func_deoblique, 'out_file',
outputNode, 'refit')
func_reorient = pe.Node(interface=preprocess.Resample(),
name='func_reorient')
func_reorient.inputs.orientation = 'RPI'
func_reorient.inputs.outputtype = 'NIFTI_GZ'
preproc.connect(func_deoblique, 'out_file',
func_reorient, 'in_file')
preproc.connect(func_reorient, 'out_file',
outputNode, 'reorient')
func_get_mean_RPI = pe.Node(interface=preprocess.TStat(),
name='func_get_mean_RPI')
func_get_mean_RPI.inputs.options = '-mean'
func_get_mean_RPI.inputs.outputtype = 'NIFTI_GZ'
preproc.connect(func_reorient, 'out_file',
func_get_mean_RPI, 'in_file')
#calculate motion parameters
func_motion_correct = pe.Node(interface=preprocess.Volreg(),
name='func_motion_correct')
func_motion_correct.inputs.args = '-Fourier -twopass'
func_motion_correct.inputs.zpad = 4
func_motion_correct.inputs.outputtype = 'NIFTI_GZ'
preproc.connect(func_reorient, 'out_file',
func_motion_correct, 'in_file')
preproc.connect(func_get_mean_RPI, 'out_file',
func_motion_correct, 'basefile')
func_get_mean_motion = func_get_mean_RPI.clone('func_get_mean_motion')
preproc.connect(func_motion_correct, 'out_file',
func_get_mean_motion, 'in_file')
preproc.connect(func_get_mean_motion, 'out_file',
outputNode, 'motion_correct_ref')
func_motion_correct_A = func_motion_correct.clone('func_motion_correct_A')
func_motion_correct_A.inputs.md1d_file = 'max_displacement.1D'
preproc.connect(func_reorient, 'out_file',
func_motion_correct_A, 'in_file')
preproc.connect(func_get_mean_motion, 'out_file',
func_motion_correct_A, 'basefile')
preproc.connect(func_motion_correct_A, 'out_file',
outputNode, 'motion_correct')
preproc.connect(func_motion_correct_A, 'md1d_file',
outputNode, 'max_displacement')
preproc.connect(func_motion_correct_A, 'oned_file',
outputNode, 'movement_parameters')
func_get_brain_mask = pe.Node(interface=preprocess.Automask(),
name='func_get_brain_mask')
# func_get_brain_mask.inputs.dilate = 1
func_get_brain_mask.inputs.outputtype = 'NIFTI_GZ'
#-------------------------
func_bo_unwarp = pe.Node(interface=fsl.FUGUE(),name='bo_unwarp')
#func_bo_unwarp.inputs.in_file='lfo_mc'
func_bo_unwarp.inputs.args='--nocheck=on'
#func_bo_unwarp.inputs.fmap_in_file='calib'
func_bo_unwarp.inputs.dwell_time=1.0
func_bo_unwarp.inputs.unwarp_direction='x'
preproc.connect(inputNode, 'calib_reg_bo_RPI',
func_bo_unwarp, 'fmap_in_file')
preproc.connect(func_motion_correct_A, 'out_file',
func_bo_unwarp, 'in_file')
preproc.connect(func_bo_unwarp, 'unwarped_file',
outputNode, 'bo_unwarped')
preproc.connect(func_bo_unwarp, 'unwarped_file',
func_get_brain_mask, 'in_file')
#--------------------------
preproc.connect(func_get_brain_mask, 'out_file',
outputNode, 'mask')
#------------ ALSO give the example_func_preunwarp
func_get_brain_mask_A = func_get_brain_mask.clone('func_get_brain_mask_A')
preproc.connect(func_motion_correct_A, 'out_file',
func_get_brain_mask_A, 'in_file')
preproc.connect(func_get_brain_mask_A, 'out_file',
outputNode, 'mask_preunwarp')
func_edge_detect = pe.Node(interface=preprocess.Calc(),
name='func_edge_detect')
func_edge_detect.inputs.expr = 'a*b'
func_edge_detect.inputs.outputtype = 'NIFTI_GZ'
preproc.connect(func_bo_unwarp, 'unwarped_file',
func_edge_detect, 'in_file_a')
preproc.connect(func_get_brain_mask, 'out_file',
func_edge_detect, 'in_file_b')
preproc.connect(func_edge_detect, 'out_file',
outputNode, 'skullstrip')
func_mean_skullstrip = pe.Node(interface=preprocess.TStat(),
name='func_mean_skullstrip')
func_mean_skullstrip.inputs.options = '-mean'
func_mean_skullstrip.inputs.outputtype = 'NIFTI_GZ'
preproc.connect(func_edge_detect, 'out_file',
func_mean_skullstrip, 'in_file')
preproc.connect(func_mean_skullstrip, 'out_file',
outputNode, 'example_func')
func_normalize = pe.Node(interface=fsl.ImageMaths(),
name='func_normalize')
func_normalize.inputs.op_string = '-ing 10000'
func_normalize.inputs.out_data_type = 'float'
preproc.connect(func_edge_detect, 'out_file',
func_normalize, 'in_file')
preproc.connect(func_normalize, 'out_file',
outputNode, 'preprocessed')
func_mask_normalize = pe.Node(interface=fsl.ImageMaths(),
name='func_mask_normalize')
func_mask_normalize.inputs.op_string = '-Tmin -bin'
func_mask_normalize.inputs.out_data_type = 'char'
preproc.connect(func_normalize, 'out_file',
func_mask_normalize, 'in_file')
preproc.connect(func_mask_normalize, 'out_file',
outputNode, 'preprocessed_mask')
return preproc
def func_motion_correct_workflow(workflow, resource_pool, config):
# resource pool should have:
# functional_scan
import os
import sys
import nipype.interfaces.io as nio
import nipype.pipeline.engine as pe
import nipype.interfaces.utility as util
import nipype.interfaces.fsl.maths as fsl
from nipype.interfaces.afni import preprocess
from workflow_utils import check_input_resources, \
check_config_settings
check_input_resources(resource_pool, "functional_scan")
check_config_settings(config, "start_idx")
check_config_settings(config, "stop_idx")
check_config_settings(config, "slice_timing_correction")
func_get_idx = pe.Node(util.Function(
input_names=['in_files', 'stop_idx', 'start_idx'],
output_names=['stopidx', 'startidx'],
function=get_idx),
name='func_get_idx')
func_get_idx.inputs.in_files = resource_pool["functional_scan"]
func_get_idx.inputs.start_idx = config["start_idx"]
func_get_idx.inputs.stop_idx = config["stop_idx"]
func_drop_trs = pe.Node(interface=preprocess.Calc(), name='func_drop_trs')
func_drop_trs.inputs.in_file_a = resource_pool["functional_scan"]
func_drop_trs.inputs.expr = 'a'
func_drop_trs.inputs.outputtype = 'NIFTI_GZ'
workflow.connect(func_get_idx, 'startidx', func_drop_trs, 'start_idx')
workflow.connect(func_get_idx, 'stopidx', func_drop_trs, 'stop_idx')
#workflow.connect(func_drop_trs, 'out_file',
# outputNode, 'drop_tr')
func_slice_timing_correction = pe.Node(interface=preprocess.TShift(),
name='func_slice_time_correction')
func_slice_timing_correction.inputs.outputtype = 'NIFTI_GZ'
func_deoblique = pe.Node(interface=preprocess.Refit(),
name='func_deoblique')
func_deoblique.inputs.deoblique = True
if config["slice_timing_correction"] == True:
workflow.connect(func_drop_trs, 'out_file',
func_slice_timing_correction, 'in_file')
workflow.connect(func_slice_timing_correction, 'out_file',
func_deoblique, 'in_file')
else:
workflow.connect(func_drop_trs, 'out_file', func_deoblique, 'in_file')
func_reorient = pe.Node(interface=preprocess.Resample(),
name='func_reorient')
func_reorient.inputs.orientation = 'RPI'
func_reorient.inputs.outputtype = 'NIFTI_GZ'
workflow.connect(func_deoblique, 'out_file', func_reorient, 'in_file')
func_get_mean_RPI = pe.Node(interface=preprocess.TStat(),
name='func_get_mean_RPI')
func_get_mean_RPI.inputs.options = '-mean'
func_get_mean_RPI.inputs.outputtype = 'NIFTI_GZ'
workflow.connect(func_reorient, 'out_file', func_get_mean_RPI, 'in_file')
# calculate motion parameters
func_motion_correct = pe.Node(interface=preprocess.Volreg(),
name='func_motion_correct')
func_motion_correct.inputs.args = '-Fourier -twopass'
func_motion_correct.inputs.zpad = 4
func_motion_correct.inputs.outputtype = 'NIFTI_GZ'
workflow.connect(func_reorient, 'out_file', func_motion_correct, 'in_file')
workflow.connect(func_get_mean_RPI, 'out_file', func_motion_correct,
'basefile')
func_get_mean_motion = func_get_mean_RPI.clone('func_get_mean_motion')
workflow.connect(func_motion_correct, 'out_file', func_get_mean_motion,
'in_file')
func_motion_correct_A = func_motion_correct.clone('func_motion_correct_A')
func_motion_correct_A.inputs.md1d_file = 'max_displacement.1D'
workflow.connect(func_reorient, 'out_file', func_motion_correct_A,
'in_file')
workflow.connect(func_get_mean_motion, 'out_file', func_motion_correct_A,
'basefile')
resource_pool["func_motion_correct"] = (func_motion_correct_A, 'out_file')
resource_pool["coordinate_transformation"] = \
(func_motion_correct_A, 'oned_matrix_save')
return workflow, resource_pool
def create_wf_c3d_fsl_to_itk(map_node, input_image_type=0,
name='create_wf_c3d_fsl_to_itk'):
"""
Converts an FSL-format output matrix to an ITK-format (ANTS) matrix
for use with ANTS registration tools.
Parameters
----------
name : string, optional
Name of the workflow.
Returns
-------
fsl_to_itk_conversion : nipype.pipeline.engine.Workflow
Notes
-----
Workflow Inputs::
inputspec.affine_file : string (nifti file)
Output matrix of FSL-based functional to anatomical registration
inputspec.reference_file : string (nifti file)
File of skull-stripped anatomical brain to be used in affine
conversion
inputspec.source_file : string (nifti file)
Should match the input of the apply warp (in_file) unless you are
applying the warp to a 4-d file, in which case this file should
be a mean_functional file
Workflow Outputs::
outputspec.itk_transform : string (nifti file)
Converted affine transform in ITK format usable with ANTS
"""
import nipype.interfaces.c3 as c3
from nipype.interfaces.utility import Function
from CPAC.registration.utils import change_itk_transform_type
from nipype.interfaces.afni import preprocess
fsl_to_itk_conversion = pe.Workflow(name=name)
inputspec = pe.Node(util.IdentityInterface(fields=['affine_file',
'reference_file', 'source_file']), name='inputspec')
# converts FSL-format .mat affine xfm into ANTS-format .txt
# .mat affine comes from Func->Anat registration
if map_node == 0:
fsl_reg_2_itk = pe.Node(c3.C3dAffineTool(), name='fsl_reg_2_itk')
elif map_node == 1:
fsl_reg_2_itk = pe.MapNode(c3.C3dAffineTool(),
name='fsl_reg_2_itk_mapnode', iterfield=['source_file'])
fsl_reg_2_itk.inputs.itk_transform = True
fsl_reg_2_itk.inputs.fsl2ras = True
itk_imports = ['import os']
if map_node == 0:
change_transform = pe.Node(util.Function(
input_names=['input_affine_file'],
output_names=['updated_affine_file'],
function=change_itk_transform_type,
imports=itk_imports),
name='change_transform_type')
elif map_node == 1:
change_transform = pe.MapNode(util.Function(
input_names=['input_affine_file'],
output_names=['updated_affine_file'],
function=change_itk_transform_type,
imports=itk_imports),
name='change_transform_type', iterfield=['input_affine_file'])
outputspec = pe.Node(util.IdentityInterface(fields=['itk_transform']),
name='outputspec')
fsl_to_itk_conversion.connect(inputspec, 'affine_file', fsl_reg_2_itk,
'transform_file')
fsl_to_itk_conversion.connect(inputspec, 'reference_file', fsl_reg_2_itk,
'reference_file')
# source_file input of the conversion must be a 3D file, so if the source
# file is 4D (input_image_type=3), average it into a 3D file first
if input_image_type == 0:
fsl_to_itk_conversion.connect(inputspec, 'source_file', fsl_reg_2_itk,
'source_file')
elif input_image_type == 3:
try:
tstat_source = pe.Node(interface=preprocess.TStat(),
name='fsl_to_itk_tcat_source')
except AttributeError:
from nipype.interfaces.afni import utils as afni_utils
tstat_source = pe.Node(interface=afni_utils.TStat(),
name='fsl_to_itk_tcat_source')
tstat_source.inputs.outputtype = 'NIFTI_GZ'
tstat_source.inputs.options = '-mean'
fsl_to_itk_conversion.connect(inputspec, 'source_file', tstat_source,
'in_file')
fsl_to_itk_conversion.connect(tstat_source, 'out_file', fsl_reg_2_itk,
'source_file')
fsl_to_itk_conversion.connect(fsl_reg_2_itk, 'itk_transform',
change_transform, 'input_affine_file')
fsl_to_itk_conversion.connect(change_transform, 'updated_affine_file',
outputspec, 'itk_transform')
return fsl_to_itk_conversion
def create_func_preproc(use_bet=False, wf_name='func_preproc'):
"""
The main purpose of this workflow is to process functional data. Raw rest file is deobliqued and reoriented
into RPI. Then take the mean intensity values over all time points for each voxel and use this image
to calculate motion parameters. The image is then skullstripped, normalized and a processed mask is
obtained to use it further in Image analysis.
Parameters
----------
wf_name : string
Workflow name
Returns
-------
func_preproc : workflow object
Functional Preprocessing workflow object
Notes
-----
`Source <https://github.com/FCP-INDI/C-PAC/blob/master/CPAC/func_preproc/func_preproc.py>`_
Workflow Inputs::
inputspec.rest : func/rest file or a list of func/rest nifti file
User input functional(T2) Image, in any of the 8 orientations
scan_params.tr : string
Subject TR
scan_params.acquistion : string
Acquisition pattern (interleaved/sequential, ascending/descending)
scan_params.ref_slice : integer
Reference slice for slice timing correction
Workflow Outputs::
outputspec.refit : string (nifti file)
Path to deobliqued anatomical data
outputspec.reorient : string (nifti file)
Path to RPI oriented anatomical data
outputspec.motion_correct_ref : string (nifti file)
Path to Mean intensity Motion corrected image
(base reference image for the second motion correction run)
outputspec.motion_correct : string (nifti file)
Path to motion corrected output file
outputspec.max_displacement : string (Mat file)
Path to maximum displacement (in mm) for brain voxels in each volume
outputspec.movement_parameters : string (Mat file)
Path to 1D file containing six movement/motion parameters(3 Translation, 3 Rotations)
in different columns (roll pitch yaw dS dL dP)
outputspec.skullstrip : string (nifti file)
Path to skull stripped Motion Corrected Image
outputspec.mask : string (nifti file)
Path to brain-only mask
outputspec.example_func : string (nifti file)
Mean, Skull Stripped, Motion Corrected output T2 Image path
(Image with mean intensity values across voxels)
outputpsec.preprocessed : string (nifti file)
output skull stripped, motion corrected T2 image
with normalized intensity values
outputspec.preprocessed_mask : string (nifti file)
Mask obtained from normalized preprocessed image
Order of commands:
- Deobliqing the scans. For details see `3drefit <http://afni.nimh.nih.gov/pub/dist/doc/program_help/3drefit.html>`_::
3drefit -deoblique rest_3dc.nii.gz
- Re-orienting the Image into Right-to-Left Posterior-to-Anterior Inferior-to-Superior (RPI) orientation. For details see `3dresample <http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dresample.html>`_::
3dresample -orient RPI
-prefix rest_3dc_RPI.nii.gz
-inset rest_3dc.nii.gz
- Calculate voxel wise statistics. Get the RPI Image with mean intensity values over all timepoints for each voxel. For details see `3dTstat <http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dTstat.html>`_::
3dTstat -mean
-prefix rest_3dc_RPI_3dT.nii.gz
rest_3dc_RPI.nii.gz
- Motion Correction. For details see `3dvolreg <http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dvolreg.html>`_::
3dvolreg -Fourier
-twopass
-base rest_3dc_RPI_3dT.nii.gz/
-zpad 4
-maxdisp1D rest_3dc_RPI_3dvmd1D.1D
-1Dfile rest_3dc_RPI_3dv1D.1D
-prefix rest_3dc_RPI_3dv.nii.gz
rest_3dc_RPI.nii.gz
The base image or the reference image is the mean intensity RPI image obtained in the above the step.For each volume
in RPI-oriented T2 image, the command, aligns the image with the base mean image and calculates the motion, displacement
and movement parameters. It also outputs the aligned 4D volume and movement and displacement parameters for each volume.
- Calculate voxel wise statistics. Get the motion corrected output Image from the above step, with mean intensity values over all timepoints for each voxel.
For details see `3dTstat <http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dTstat.html>`_::
3dTstat -mean
-prefix rest_3dc_RPI_3dv_3dT.nii.gz
rest_3dc_RPI_3dv.nii.gz
- Motion Correction and get motion, movement and displacement parameters. For details see `3dvolreg <http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dvolreg.html>`_::
3dvolreg -Fourier
-twopass
-base rest_3dc_RPI_3dv_3dT.nii.gz
-zpad 4
-maxdisp1D rest_3dc_RPI_3dvmd1D.1D
-1Dfile rest_3dc_RPI_3dv1D.1D
-prefix rest_3dc_RPI_3dv.nii.gz
rest_3dc_RPI.nii.gz
The base image or the reference image is the mean intensity motion corrected image obtained from the above the step (first 3dvolreg run).
For each volume in RPI-oriented T2 image, the command, aligns the image with the base mean image and calculates the motion, displacement
and movement parameters. It also outputs the aligned 4D volume and movement and displacement parameters for each volume.
- Create a brain-only mask. For details see `3dautomask <http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dAutomask.html>`_::
3dAutomask
-prefix rest_3dc_RPI_3dv_automask.nii.gz
rest_3dc_RPI_3dv.nii.gz
- Edge Detect(remove skull) and get the brain only. For details see `3dcalc <http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dcalc.html>`_::
3dcalc -a rest_3dc_RPI_3dv.nii.gz
-b rest_3dc_RPI_3dv_automask.nii.gz
-expr 'a*b'
-prefix rest_3dc_RPI_3dv_3dc.nii.gz
- Normalizing the image intensity values. For details see `fslmaths <http://www.fmrib.ox.ac.uk/fsl/avwutils/index.html>`_::
fslmaths rest_3dc_RPI_3dv_3dc.nii.gz
-ing 10000 rest_3dc_RPI_3dv_3dc_maths.nii.gz
-odt float
Normalized intensity = (TrueValue*10000)/global4Dmean
- Calculate mean of skull stripped image. For details see `3dTstat <http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dTstat.html>`_::
3dTstat -mean -prefix rest_3dc_RPI_3dv_3dc_3dT.nii.gz rest_3dc_RPI_3dv_3dc.nii.gz
- Create Mask (Generate mask from Normalized data). For details see `fslmaths <http://www.fmrib.ox.ac.uk/fsl/avwutils/index.html>`_::
fslmaths rest_3dc_RPI_3dv_3dc_maths.nii.gz
-Tmin -bin rest_3dc_RPI_3dv_3dc_maths_maths.nii.gz
-odt char
High Level Workflow Graph:
.. image:: ../images/func_preproc.dot.png
:width: 1000
Detailed Workflow Graph:
.. image:: ../images/func_preproc_detailed.dot.png
:width: 1000
Examples
--------
>>> import func_preproc
>>> preproc = create_func_preproc(bet=True)
>>> preproc.inputs.inputspec.func='sub1/func/rest.nii.gz'
>>> preproc.run() #doctest: +SKIP
>>> import func_preproc
>>> preproc = create_func_preproc(bet=False)
>>> preproc.inputs.inputspec.func='sub1/func/rest.nii.gz'
>>> preproc.run() #doctest: +SKIP
"""
preproc = pe.Workflow(name=wf_name)
inputNode = pe.Node(util.IdentityInterface(fields=['func']),
name='inputspec')
outputNode = pe.Node(
util.IdentityInterface(fields=[
'refit',
'reorient',
'reorient_mean',
'motion_correct',
'motion_correct_ref',
'movement_parameters',
'max_displacement',
# 'xform_matrix',
'mask',
'skullstrip',
'example_func',
'preprocessed',
'preprocessed_mask',
'slice_time_corrected',
'oned_matrix_save'
]),
name='outputspec')
try:
from nipype.interfaces.afni import utils as afni_utils
func_deoblique = pe.Node(interface=afni_utils.Refit(),
name='func_deoblique')
except ImportError:
func_deoblique = pe.Node(interface=preprocess.Refit(),
name='func_deoblique')
func_deoblique.inputs.deoblique = True
preproc.connect(inputNode, 'func', func_deoblique, 'in_file')
try:
func_reorient = pe.Node(interface=afni_utils.Resample(),
name='func_reorient')
except UnboundLocalError:
func_reorient = pe.Node(interface=preprocess.Resample(),
name='func_reorient')
func_reorient.inputs.orientation = 'RPI'
func_reorient.inputs.outputtype = 'NIFTI_GZ'
preproc.connect(func_deoblique, 'out_file', func_reorient, 'in_file')
preproc.connect(func_reorient, 'out_file', outputNode, 'reorient')
try:
func_get_mean_RPI = pe.Node(interface=afni_utils.TStat(),
name='func_get_mean_RPI')
except UnboundLocalError:
func_get_mean_RPI = pe.Node(interface=preprocess.TStat(),
name='func_get_mean_RPI')
func_get_mean_RPI.inputs.options = '-mean'
func_get_mean_RPI.inputs.outputtype = 'NIFTI_GZ'
preproc.connect(func_reorient, 'out_file', func_get_mean_RPI, 'in_file')
# calculate motion parameters
func_motion_correct = pe.Node(interface=preprocess.Volreg(),
name='func_motion_correct')
func_motion_correct.inputs.args = '-Fourier -twopass'
func_motion_correct.inputs.zpad = 4
func_motion_correct.inputs.outputtype = 'NIFTI_GZ'
preproc.connect(func_reorient, 'out_file', func_motion_correct, 'in_file')
preproc.connect(func_get_mean_RPI, 'out_file', func_motion_correct,
'basefile')
func_get_mean_motion = func_get_mean_RPI.clone('func_get_mean_motion')
preproc.connect(func_motion_correct, 'out_file', func_get_mean_motion,
'in_file')
preproc.connect(func_get_mean_motion, 'out_file', outputNode,
'motion_correct_ref')
func_motion_correct_A = func_motion_correct.clone('func_motion_correct_A')
func_motion_correct_A.inputs.md1d_file = 'max_displacement.1D'
preproc.connect(func_reorient, 'out_file', func_motion_correct_A,
'in_file')
preproc.connect(func_get_mean_motion, 'out_file', func_motion_correct_A,
'basefile')
preproc.connect(func_motion_correct_A, 'out_file', outputNode,
'motion_correct')
preproc.connect(func_motion_correct_A, 'md1d_file', outputNode,
'max_displacement')
preproc.connect(func_motion_correct_A, 'oned_file', outputNode,
'movement_parameters')
preproc.connect(func_motion_correct_A, 'oned_matrix_save', outputNode,
'oned_matrix_save')
if not use_bet:
func_get_brain_mask = pe.Node(interface=preprocess.Automask(),
name='func_get_brain_mask')
func_get_brain_mask.inputs.outputtype = 'NIFTI_GZ'
preproc.connect(func_motion_correct_A, 'out_file', func_get_brain_mask,
'in_file')
preproc.connect(func_get_brain_mask, 'out_file', outputNode, 'mask')
else:
func_get_brain_mask = pe.Node(interface=fsl.BET(),
name='func_get_brain_mask_BET')
func_get_brain_mask.inputs.mask = True
func_get_brain_mask.inputs.functional = True
erode_one_voxel = pe.Node(interface=fsl.ErodeImage(),
name='erode_one_voxel')
erode_one_voxel.inputs.kernel_shape = 'box'
erode_one_voxel.inputs.kernel_size = 1.0
preproc.connect(func_motion_correct_A, 'out_file', func_get_brain_mask,
'in_file')
preproc.connect(func_get_brain_mask, 'mask_file', erode_one_voxel,
'in_file')
preproc.connect(erode_one_voxel, 'out_file', outputNode, 'mask')
try:
func_edge_detect = pe.Node(interface=afni_utils.Calc(),
name='func_edge_detect')
except UnboundLocalError:
func_edge_detect = pe.Node(interface=preprocess.Calc(),
name='func_edge_detect')
func_edge_detect.inputs.expr = 'a*b'
func_edge_detect.inputs.outputtype = 'NIFTI_GZ'
preproc.connect(func_motion_correct_A, 'out_file', func_edge_detect,
'in_file_a')
if not use_bet:
preproc.connect(func_get_brain_mask, 'out_file', func_edge_detect,
'in_file_b')
else:
preproc.connect(erode_one_voxel, 'out_file', func_edge_detect,
'in_file_b')
preproc.connect(func_edge_detect, 'out_file', outputNode, 'skullstrip')
try:
func_mean_skullstrip = pe.Node(interface=afni_utils.TStat(),
name='func_mean_skullstrip')
except UnboundLocalError:
func_mean_skullstrip = pe.Node(interface=preprocess.TStat(),
name='func_mean_skullstrip')
func_mean_skullstrip.inputs.options = '-mean'
func_mean_skullstrip.inputs.outputtype = 'NIFTI_GZ'
preproc.connect(func_edge_detect, 'out_file', func_mean_skullstrip,
'in_file')
preproc.connect(func_mean_skullstrip, 'out_file', outputNode,
'example_func')
func_normalize = pe.Node(interface=fsl.ImageMaths(), name='func_normalize')
func_normalize.inputs.op_string = '-ing 10000'
func_normalize.inputs.out_data_type = 'float'
preproc.connect(func_edge_detect, 'out_file', func_normalize, 'in_file')
preproc.connect(func_normalize, 'out_file', outputNode, 'preprocessed')
func_mask_normalize = pe.Node(interface=fsl.ImageMaths(),
name='func_mask_normalize')
func_mask_normalize.inputs.op_string = '-Tmin -bin'
func_mask_normalize.inputs.out_data_type = 'char'
preproc.connect(func_normalize, 'out_file', func_mask_normalize, 'in_file')
preproc.connect(func_mask_normalize, 'out_file', outputNode,
'preprocessed_mask')
return preproc
def create_alff(wf_name='alff_workflow'):
"""
Calculate Amplitude of low frequency oscillations (ALFF) and fractional ALFF maps
Parameters
----------
wf_name : string
Workflow name
Returns
-------
alff_workflow : workflow object
ALFF workflow
Notes
-----
`Source <https://github.com/FCP-INDI/C-PAC/blob/master/CPAC/alff/alff.py>`_
Workflow Inputs::
hp_input.hp : list of float
high pass frequencies
lp_input.lp : list of float
low pass frequencies
inputspec.rest_res : string
Path to existing Nifti file. Nuisance signal regressed functional image.
inputspec.rest_mask : string
Path to existing Nifti file. A mask volume(derived by dilating the motion corrected functional volume) in native space
Workflow Outputs::
outputspec.alff_img : string
Path to Nifti file. Image containing the sum of the amplitudes in the low frequency band
outputspec.falff_img : string
Path to Nifti file. Image containing the sum of the amplitudes in the low frequency band divided by the amplitude of the total frequency
outputspec.alff_Z_img : string
Path to Nifti file. Image containing Normalized ALFF Z scores across full brain in native space
outputspec.falff_Z_img : string
Path to Nifti file. Image containing Normalized fALFF Z scores across full brain in native space
Order of Commands:
- Filter the input file rest file( slice-time, motion corrected and nuisance regressed) ::
3dBandpass -prefix residual_filtered.nii.gz
0.009 0.08 residual.nii.gz
- Calculate ALFF by taking the standard deviation of the filtered file ::
3dTstat -stdev
-mask rest_mask.nii.gz
-prefix residual_filtered_3dT.nii.gz
residual_filtered.nii.gz
- Calculate the standard deviation of the unfiltered file ::
3dTstat -stdev
-mask rest_mask.nii.gz
-prefix residual_3dT.nii.gz
residual.nii.gz
- Calculate fALFF ::
3dcalc -a rest_mask.nii.gz
-b residual_filtered_3dT.nii.gz
-c residual_3dT.nii.gz
-expr '(1.0*bool(a))*((1.0*b)/(1.0*c))' -float
- Normalize ALFF/fALFF to Z-score across full brain ::
fslstats
ALFF.nii.gz
-k rest_mask.nii.gz
-m > mean_ALFF.txt ; mean=$( cat mean_ALFF.txt )
fslstats
ALFF.nii.gz
-k rest_mask.nii.gz
-s > std_ALFF.txt ; std=$( cat std_ALFF.txt )
fslmaths
ALFF.nii.gz
-sub ${mean}
-div ${std}
-mas rest_mask.nii.gz ALFF_Z.nii.gz
fslstats
fALFF.nii.gz
-k rest_mask.nii.gz
-m > mean_fALFF.txt ; mean=$( cat mean_fALFF.txt )
fslstats
fALFF.nii.gz
-k rest_mask.nii.gz
-s > std_fALFF.txt
std=$( cat std_fALFF.txt )
fslmaths
fALFF.nii.gz
-sub ${mean}
-div ${std}
-mas rest_mask.nii.gz
fALFF_Z.nii.gz
High Level Workflow Graph:
.. image:: ../images/alff.dot.png
:width: 500
Detailed Workflow Graph:
.. image:: ../images/alff_detailed.dot.png
:width: 500
References
----------
.. [1] Zou, Q.-H., Zhu, C.-Z., Yang, Y., Zuo, X.-N., Long, X.-Y., Cao, Q.-J., Wang, Y.-F., et al. (2008). An improved approach to detection of amplitude of low-frequency fluctuation (ALFF) for resting-state fMRI: fractional ALFF. Journal of neuroscience methods, 172(1), 137-41. doi:10.10
Examples
--------
>>> alff_w = create_alff()
>>> alff_w.inputs.hp_input.hp = [0.01]
>>> alff_w.inputs.lp_input.lp = [0.1]
>>> alff_w.get_node('hp_input').iterables = ('hp', [0.01])
>>> alff_w.get_node('lp_input').iterables = ('lp', [0.1])
>>> alff_w.inputs.inputspec.rest_res = '/home/data/subject/func/rest_bandpassed.nii.gz'
>>> alff_w.inputs.inputspec.rest_mask= '/home/data/subject/func/rest_mask.nii.gz'
>>> alff_w.run() # doctest: +SKIP
"""
wf = pe.Workflow(name=wf_name)
input_node = pe.Node(
util.IdentityInterface(fields=['rest_res', 'rest_mask']),
name='inputspec')
input_node_hp = pe.Node(util.IdentityInterface(fields=['hp']),
name='hp_input')
input_node_lp = pe.Node(util.IdentityInterface(fields=['lp']),
name='lp_input')
output_node = pe.Node(
util.IdentityInterface(fields=['alff_img', 'falff_img']),
name='outputspec')
# filtering
bandpass = pe.Node(interface=preprocess.Bandpass(),
name='bandpass_filtering')
bandpass.inputs.outputtype = 'NIFTI_GZ'
bandpass.inputs.out_file = os.path.join(os.path.curdir,
'residual_filtered.nii.gz')
wf.connect(input_node_hp, 'hp', bandpass, 'highpass')
wf.connect(input_node_lp, 'lp', bandpass, 'lowpass')
wf.connect(input_node, 'rest_res', bandpass, 'in_file')
get_option_string = pe.Node(util.Function(input_names=['mask'],
output_names=['option_string'],
function=get_opt_string),
name='get_option_string')
wf.connect(input_node, 'rest_mask', get_option_string, 'mask')
# standard deviation over frequency
try:
from nipype.interfaces.afni import utils as afni_utils
stddev_filtered = pe.Node(interface=afni_utils.TStat(),
name='stddev_filtered')
except ImportError:
stddev_filtered = pe.Node(interface=preprocess.TStat(),
name='stddev_filtered')
stddev_filtered.inputs.outputtype = 'NIFTI_GZ'
stddev_filtered.inputs.out_file = os.path.join(os.path.curdir,
'alff.nii.gz')
wf.connect(bandpass, 'out_file', stddev_filtered, 'in_file')
wf.connect(get_option_string, 'option_string', stddev_filtered, 'options')
wf.connect(stddev_filtered, 'out_file', output_node, 'alff_img')
# standard deviation of the unfiltered nuisance corrected image
try:
stddev_unfiltered = pe.Node(interface=afni_utils.TStat(),
name='stddev_unfiltered')
except UnboundLocalError:
stddev_unfiltered = pe.Node(interface=preprocess.TStat(),
name='stddev_unfiltered')
stddev_unfiltered.inputs.outputtype = 'NIFTI_GZ'
stddev_unfiltered.inputs.out_file = os.path.join(os.path.curdir,
'residual_3dT.nii.gz')
wf.connect(input_node, 'rest_res', stddev_unfiltered, 'in_file')
wf.connect(get_option_string, 'option_string', stddev_unfiltered,
'options')
# falff calculations
try:
falff = pe.Node(interface=afni_utils.Calc(), name='falff')
except UnboundLocalError:
falff = pe.Node(interface=preprocess.Calc(), name='falff')
falff.inputs.args = '-float'
falff.inputs.expr = '(1.0*bool(a))*((1.0*b)/(1.0*c))'
falff.inputs.outputtype = 'NIFTI_GZ'
falff.inputs.out_file = os.path.join(os.path.curdir, 'falff.nii.gz')
wf.connect(input_node, 'rest_mask', falff, 'in_file_a')
wf.connect(stddev_filtered, 'out_file', falff, 'in_file_b')
wf.connect(stddev_unfiltered, 'out_file', falff, 'in_file_c')
wf.connect(falff, 'out_file', output_node, 'falff_img')
return wf
def fmri_qc_workflow(name='fMRIQC', settings=None):
""" The fMRI qc workflow """
if settings is None:
settings = {}
workflow = pe.Workflow(name=name)
deriv_dir = op.abspath(op.join(settings['output_dir'], 'derivatives'))
if not op.exists(deriv_dir):
os.makedirs(deriv_dir)
# Read FD radius, or default it
fd_radius = settings.get('fd_radius', 50.)
# Define workflow, inputs and outputs
inputnode = pe.Node(niu.IdentityInterface(fields=[
'bids_dir', 'subject_id', 'session_id', 'run_id', 'site_name',
'start_idx', 'stop_idx'
]),
name='inputnode')
get_idx = pe.Node(niu.Function(
input_names=['in_file', 'start_idx', 'stop_idx'],
function=fmri_getidx,
output_names=['start_idx', 'stop_idx']),
name='get_idx')
outputnode = pe.Node(niu.IdentityInterface(fields=[
'qc', 'mosaic', 'out_group', 'out_movpar', 'out_dvars', 'out_fd'
]),
name='outputnode')
# 0. Get data
datasource = pe.Node(niu.Function(input_names=[
'bids_dir', 'data_type', 'subject_id', 'session_id', 'run_id'
],
output_names=['out_file'],
function=bids_getfile),
name='datasource')
datasource.inputs.data_type = 'func'
# Workflow --------------------------------------------------------
# 1. HMC: head motion correct
hmcwf = hmc_mcflirt()
if settings.get('hmc_afni', False):
hmcwf = hmc_afni(
st_correct=settings.get('correct_slice_timing', False))
hmcwf.inputs.inputnode.fd_radius = fd_radius
mean = pe.Node(
afp.TStat( # 2. Compute mean fmri
options='-mean', outputtype='NIFTI_GZ'),
name='mean')
bmw = fmri_bmsk_workflow( # 3. Compute brain mask
use_bet=settings.get('use_bet', False))
# Compute TSNR using nipype implementation
tsnr = pe.Node(nac.TSNR(), name='compute_tsnr')
# Compute DVARS
dvnode = pe.Node(nac.ComputeDVARS(remove_zerovariance=True,
save_plot=True,
save_all=True,
figdpi=200,
figformat='pdf'),
name='ComputeDVARS')
fdnode = pe.Node(nac.FramewiseDisplacement(normalize=True,
save_plot=True,
radius=fd_radius,
figdpi=200),
name='ComputeFD')
# AFNI quality measures
fwhm = pe.Node(afp.FWHMx(combine=True, detrend=True), name='smoothness')
# fwhm.inputs.acf = True # add when AFNI >= 16
outliers = pe.Node(afp.OutlierCount(fraction=True, out_file='ouliers.out'),
name='outliers')
quality = pe.Node(afp.QualityIndex(automask=True),
out_file='quality.out',
name='quality')
measures = pe.Node(FunctionalQC(), name='measures')
# Link images that should be reported
dsreport = pe.Node(nio.DataSink(base_directory=settings['report_dir'],
parameterization=True),
name='dsreport')
dsreport.inputs.container = 'func'
dsreport.inputs.substitutions = [
('_data', ''), ('fd_power_2012', 'plot_fd'),
('tsnr.nii.gz', 'mosaic_TSNR.nii.gz'),
('mean.nii.gz', 'mosaic_TSNR_mean.nii.gz'),
('stdev.nii.gz', 'mosaic_TSNR_stdev.nii.gz')
]
dsreport.inputs.regexp_substitutions = [
('_u?(sub-[\\w\\d]*)\\.([\\w\\d_]*)(?:\\.([\\w\\d_-]*))+',
'\\1_ses-\\2_\\3'), ('sub-[^/.]*_dvars_std', 'plot_dvars'),
('sub-[^/.]*_mask', 'mask'),
('sub-[^/.]*_mcf_tstat', 'mosaic_epi_mean')
]
workflow.connect([
(inputnode, datasource, [('bids_dir', 'bids_dir'),
('subject_id', 'subject_id'),
('session_id', 'session_id'),
('run_id', 'run_id')]),
(inputnode, get_idx, [('start_idx', 'start_idx'),
('stop_idx', 'stop_idx')]),
(datasource, get_idx, [('out_file', 'in_file')]),
(datasource, hmcwf, [('out_file', 'inputnode.in_file')]),
(get_idx, hmcwf, [('start_idx', 'inputnode.start_idx'),
('stop_idx', 'inputnode.stop_idx')]),
(hmcwf, bmw, [('outputnode.out_file', 'inputnode.in_file')]),
(hmcwf, mean, [('outputnode.out_file', 'in_file')]),
(hmcwf, tsnr, [('outputnode.out_file', 'in_file')]),
(hmcwf, fdnode, [('outputnode.out_movpar', 'in_plots')]),
(mean, fwhm, [('out_file', 'in_file')]),
(bmw, fwhm, [('outputnode.out_file', 'mask')]),
(hmcwf, outliers, [('outputnode.out_file', 'in_file')]),
(bmw, outliers, [('outputnode.out_file', 'mask')]),
(hmcwf, quality, [('outputnode.out_file', 'in_file')]),
(hmcwf, dvnode, [('outputnode.out_file', 'in_file')]),
(bmw, dvnode, [('outputnode.out_file', 'in_mask')]),
(mean, measures, [('out_file', 'in_epi')]),
(hmcwf, measures, [('outputnode.out_file', 'in_hmc')]),
(bmw, measures, [('outputnode.out_file', 'in_mask')]),
(tsnr, measures, [('tsnr_file', 'in_tsnr')]),
(dvnode, measures, [('out_all', 'in_dvars')]),
(fdnode, measures, [('out_file', 'in_fd')]),
(fdnode, outputnode, [('out_file', 'out_fd')]),
(dvnode, outputnode, [('out_all', 'out_dvars')]),
(hmcwf, outputnode, [('outputnode.out_movpar', 'out_movpar')]),
(mean, dsreport, [('out_file', '@meanepi')]),
(tsnr, dsreport, [('tsnr_file', '@tsnr'), ('stddev_file', '@tsnr_std'),
('mean_file', '@tsnr_mean')]),
(bmw, dsreport, [('outputnode.out_file', '@mask')]),
(fdnode, dsreport, [('out_figure', '@fdplot')]),
(dvnode, dsreport, [('fig_std', '@dvars')]),
])
# Format name
out_name = pe.Node(niu.Function(
input_names=['subid', 'sesid', 'runid', 'prefix', 'out_path'],
output_names=['out_file'],
function=bids_path),
name='FormatName')
out_name.inputs.out_path = deriv_dir
out_name.inputs.prefix = 'func'
# Save to JSON file
datasink = pe.Node(nio.JSONFileSink(), name='datasink')
datasink.inputs.qc_type = 'func'
workflow.connect([
(inputnode, out_name, [('subject_id', 'subid'),
('session_id', 'sesid'), ('run_id', 'runid')]),
(inputnode, datasink, [('subject_id', 'subject_id'),
('session_id', 'session_id'),
('run_id', 'run_id')]),
(fwhm, datasink, [(('fwhm', fwhm_dict), 'fwhm')]),
(outliers, datasink, [(('out_file', _parse_tout), 'outlier')]),
(quality, datasink, [(('out_file', _parse_tqual), 'quality')]),
(measures, datasink, [('summary', 'summary'), ('spacing', 'spacing'),
('size', 'size'), ('fber', 'fber'),
('efc', 'efc'), ('snr', 'snr'), ('gsr', 'gsr'),
('m_tsnr', 'm_tsnr'), ('fd', 'fd'),
('dvars', 'dvars'), ('gcor', 'gcor')]),
(out_name, datasink, [('out_file', 'out_file')]),
(datasink, outputnode, [('out_file', 'out_file')])
])
return workflow
def fmri_qc_workflow(name='fMRIQC', settings=None):
""" The fMRI qc workflow """
if settings is None:
settings = {}
workflow = pe.Workflow(name=name)
deriv_dir = op.abspath('./derivatives')
if 'work_dir' in settings.keys():
deriv_dir = op.abspath(op.join(settings['work_dir'], 'derivatives'))
if not op.exists(deriv_dir):
os.makedirs(deriv_dir)
# Read FD radius, or default it
fd_radius = settings.get('fd_radius', 80.)
# Define workflow, inputs and outputs
inputnode = pe.Node(niu.IdentityInterface(fields=[
'bids_root', 'subject_id', 'session_id', 'run_id', 'site_name',
'start_idx', 'stop_idx'
]),
name='inputnode')
get_idx = pe.Node(niu.Function(
input_names=['in_file', 'start_idx', 'stop_idx'],
function=fmri_getidx,
output_names=['start_idx', 'stop_idx']),
name='get_idx')
outputnode = pe.Node(niu.IdentityInterface(
fields=['qc', 'mosaic', 'out_group', 'out_movpar', 'out_dvars']),
name='outputnode')
# 0. Get data
datasource = pe.Node(niu.Function(input_names=[
'bids_root', 'data_type', 'subject_id', 'session_id', 'run_id'
],
output_names=['out_file'],
function=bids_getfile),
name='datasource')
datasource.inputs.data_type = 'func'
# Workflow --------------------------------------------------------
# 1. HMC: head motion correct
hmcwf = hmc_mcflirt()
if settings.get('hmc_afni', False):
hmcwf = hmc_afni(
st_correct=settings.get('correct_slice_timing', False))
hmcwf.inputs.inputnode.fd_radius = fd_radius
mean = pe.Node(
afp.TStat( # 2. Compute mean fmri
options='-mean', outputtype='NIFTI_GZ'),
name='mean')
bmw = fmri_bmsk_workflow( # 3. Compute brain mask
use_bet=settings.get('use_bet', False))
# Compute TSNR using nipype implementation
tsnr = pe.Node(nam.TSNR(), name='compute_tsnr')
# Compute DVARS
dvnode = pe.Node(ComputeDVARS(), name='ComputeDVARS')
# AFNI quality measures
fwhm = pe.Node(afp.FWHMx(combine=True, detrend=True), name='smoothness')
# fwhm.inputs.acf = True # add when AFNI >= 16
outliers = pe.Node(afp.OutlierCount(fraction=True, out_file='ouliers.out'),
name='outliers')
quality = pe.Node(afp.QualityIndex(automask=True),
out_file='quality.out',
name='quality')
measures = pe.Node(FunctionalQC(), name='measures')
# Plots
plot_mean = pe.Node(PlotMosaic(title='Mean fMRI'), name='plot_mean')
plot_tsnr = pe.Node(PlotMosaic(title='tSNR volume'), name='plot_tSNR')
plot_fd = pe.Node(PlotFD(), name='plot_fd')
plot_fd.inputs.fd_radius = fd_radius
merg = pe.Node(niu.Merge(3), name='plot_metadata')
workflow.connect([
(inputnode, datasource, [('bids_root', 'bids_root'),
('subject_id', 'subject_id'),
('session_id', 'session_id'),
('run_id', 'run_id')]),
(inputnode, get_idx, [('start_idx', 'start_idx'),
('stop_idx', 'stop_idx')]),
(datasource, get_idx, [('out_file', 'in_file')]),
(inputnode, merg, [('session_id', 'in1'), ('run_id', 'in2'),
('site_name', 'in3')]),
(datasource, hmcwf, [('out_file', 'inputnode.in_file')]),
(get_idx, hmcwf, [('start_idx', 'inputnode.start_idx'),
('stop_idx', 'inputnode.stop_idx')]),
(hmcwf, bmw, [('outputnode.out_file', 'inputnode.in_file')]),
(hmcwf, mean, [('outputnode.out_file', 'in_file')]),
(hmcwf, tsnr, [('outputnode.out_file', 'in_file')]),
(mean, plot_mean, [('out_file', 'in_file')]),
(tsnr, plot_tsnr, [('tsnr_file', 'in_file')]),
(hmcwf, plot_fd, [('outputnode.out_movpar', 'in_file')]),
(inputnode, plot_mean, [('subject_id', 'subject')]),
(inputnode, plot_tsnr, [('subject_id', 'subject')]),
(inputnode, plot_fd, [('subject_id', 'subject')]),
(merg, plot_mean, [('out', 'metadata')]),
(merg, plot_tsnr, [('out', 'metadata')]),
(merg, plot_fd, [('out', 'metadata')]),
(mean, fwhm, [('out_file', 'in_file')]),
(bmw, fwhm, [('outputnode.out_file', 'mask')]),
(hmcwf, outliers, [('outputnode.out_file', 'in_file')]),
(bmw, outliers, [('outputnode.out_file', 'mask')]),
(hmcwf, quality, [('outputnode.out_file', 'in_file')]),
(hmcwf, dvnode, [('outputnode.out_file', 'in_file')]),
(bmw, dvnode, [('outputnode.out_file', 'in_mask')]),
(mean, measures, [('out_file', 'in_epi')]),
(hmcwf, measures, [('outputnode.out_file', 'in_hmc'),
('outputnode.out_movpar', 'fd_movpar')]),
(bmw, measures, [('outputnode.out_file', 'in_mask')]),
(tsnr, measures, [('tsnr_file', 'in_tsnr')]),
(dvnode, measures, [('out_file', 'in_dvars')]),
(dvnode, outputnode, [('out_file', 'out_dvars')]),
(hmcwf, outputnode, [('outputnode.out_movpar', 'out_movpar')]),
])
if settings.get('mosaic_mask', False):
workflow.connect(bmw, 'outputnode.out_file', plot_mean, 'in_mask')
workflow.connect(bmw, 'outputnode.out_file', plot_tsnr, 'in_mask')
# Save mean mosaic to well-formed path
mvmean = pe.Node(niu.Rename(
format_string='meanepi_%(subject_id)s_%(session_id)s_%(run_id)s',
keep_ext=True),
name='rename_mean_mosaic')
dsmean = pe.Node(nio.DataSink(base_directory=settings['work_dir'],
parameterization=False),
name='ds_mean')
workflow.connect([(inputnode, mvmean, [('subject_id', 'subject_id'),
('session_id', 'session_id'),
('run_id', 'run_id')]),
(plot_mean, mvmean, [('out_file', 'in_file')]),
(mvmean, dsmean, [('out_file', '@mosaic')])])
# Save tSNR mosaic to well-formed path
mvtsnr = pe.Node(niu.Rename(
format_string='tsnr_%(subject_id)s_%(session_id)s_%(run_id)s',
keep_ext=True),
name='rename_tsnr_mosaic')
dstsnr = pe.Node(nio.DataSink(base_directory=settings['work_dir'],
parameterization=False),
name='ds_tsnr')
workflow.connect([(inputnode, mvtsnr, [('subject_id', 'subject_id'),
('session_id', 'session_id'),
('run_id', 'run_id')]),
(plot_tsnr, mvtsnr, [('out_file', 'in_file')]),
(mvtsnr, dstsnr, [('out_file', '@mosaic')])])
# Save FD plot to well-formed path
mvfd = pe.Node(niu.Rename(
format_string='fd_%(subject_id)s_%(session_id)s_%(run_id)s',
keep_ext=True),
name='rename_fd_mosaic')
dsfd = pe.Node(nio.DataSink(base_directory=settings['work_dir'],
parameterization=False),
name='ds_fd')
workflow.connect([(inputnode, mvfd, [('subject_id', 'subject_id'),
('session_id', 'session_id'),
('run_id', 'run_id')]),
(plot_fd, mvfd, [('out_file', 'in_file')]),
(mvfd, dsfd, [('out_file', '@mosaic')])])
# Format name
out_name = pe.Node(niu.Function(
input_names=['subid', 'sesid', 'runid', 'prefix', 'out_path'],
output_names=['out_file'],
function=bids_path),
name='FormatName')
out_name.inputs.out_path = deriv_dir
out_name.inputs.prefix = 'func'
# Save to JSON file
datasink = pe.Node(nio.JSONFileSink(), name='datasink')
datasink.inputs.qc_type = 'func'
workflow.connect([
(inputnode, out_name, [('subject_id', 'subid'),
('session_id', 'sesid'), ('run_id', 'runid')]),
(inputnode, datasink, [('subject_id', 'subject_id'),
('session_id', 'session_id'),
('run_id', 'run_id')]),
(plot_mean, datasink, [('out_file', 'mean_plot')]),
(plot_tsnr, datasink, [('out_file', 'tsnr_plot')]),
(plot_fd, datasink, [('out_file', 'fd_plot')]),
(fwhm, datasink, [(('fwhm', fwhm_dict), 'fwhm')]),
(outliers, datasink, [(('out_file', _parse_tout), 'outlier')]),
(quality, datasink, [(('out_file', _parse_tqual), 'quality')]),
(measures, datasink, [('summary', 'summary'), ('spacing', 'spacing'),
('size', 'size'), ('fber', 'fber'),
('efc', 'efc'), ('snr', 'snr'), ('gsr', 'gsr'),
('m_tsnr', 'm_tsnr'), ('fd_stats', 'fd_stats'),
('dvars', 'dvars'), ('gcor', 'gcor')]),
(out_name, datasink, [('out_file', 'out_file')]),
(datasink, outputnode, [('out_file', 'out_file')])
])
return workflow
def create_asl_preproc(c, strat, wf_name='asl_preproc'):
# resource_pool = strat?
# print('resource pool asl preproc: ', str(strat.get_resource_pool()))
# allocate a workflow object
asl_workflow = pe.Workflow(name=wf_name)
asl_workflow.base_dir = c.workingDirectory
# configure the workflow's input spec
inputNode = pe.Node(util.IdentityInterface(fields=[
'asl_file', 'anatomical_skull', 'anatomical_brain', 'seg_wm_pve'
]),
name='inputspec')
# configure the workflow's output spec
outputNode = pe.Node(util.IdentityInterface(
fields=['meanasl', 'perfusion_image', 'diffdata', 'diffdata_mean']),
name='outputspec')
# get segmentation output dir and file stub
# create nodes for de-obliquing and reorienting
try:
from nipype.interfaces.afni import utils as afni_utils
func_deoblique = pe.Node(interface=afni_utils.Refit(),
name='func_deoblique')
except ImportError:
func_deoblique = pe.Node(interface=preprocess.Refit(),
name='func_deoblique')
func_deoblique.inputs.deoblique = True
asl_workflow.connect(inputNode, 'asl_file', func_deoblique, 'in_file')
try:
func_reorient = pe.Node(interface=afni_utils.Resample(),
name='func_reorient')
except UnboundLocalError:
func_reorient = pe.Node(interface=preprocess.Resample(),
name='func_reorient')
func_reorient.inputs.orientation = 'RPI'
func_reorient.inputs.outputtype = 'NIFTI_GZ'
# connect deoblique to reorient
asl_workflow.connect(func_deoblique, 'out_file', func_reorient, 'in_file')
# create node for splitting control and label pairs (unused currently)
split_pairs_imports = ['import os', 'import subprocess']
split_ASL_pairs = pe.Node(interface=util.Function(
input_names=['asl_file'],
output_names=['control_image', 'label_image'],
function=split_pairs,
imports=split_pairs_imports),
name='split_pairs')
# create node for calculating subtracted images
diffdata_imports = ['import os', 'import subprocess']
run_diffdata = pe.Node(interface=util.Function(
input_names=['asl_file'],
output_names=['diffdata_image', 'diffdata_mean'],
function=diffdata,
imports=diffdata_imports),
name='diffdata')
asl_workflow.connect(func_reorient, 'out_file', run_diffdata, 'asl_file')
asl_workflow.connect(run_diffdata, 'diffdata_image', outputNode,
'diffdata')
asl_workflow.connect(run_diffdata, 'diffdata_mean', outputNode,
'diffdata_mean')
# create node for oxford_asl (perfusion image)
asl_imports = ['import os', 'import subprocess']
run_oxford_asl = pe.Node(interface=util.Function(
input_names=[
'asl_file', 'anatomical_skull', 'anatomical_brain', 'seg'
],
output_names=['perfusion_image', 'asl2anat_linear_xfm', 'asl2anat'],
function=oxford_asl,
imports=asl_imports),
name='run_oxford_asl')
# wire inputs from resource pool to ASL preprocessing FSL script
# connect output of reorient to run_oxford_asl
asl_workflow.connect(func_reorient, 'out_file', run_oxford_asl, 'asl_file')
asl_workflow.connect(inputNode, 'seg_wm_pve', run_oxford_asl, 'seg')
# pass the anatomical to the workflow
asl_workflow.connect(inputNode, 'anatomical_skull', run_oxford_asl,
'anatomical_skull')
# pass the anatomical to the workflow
asl_workflow.connect(inputNode, 'anatomical_brain', run_oxford_asl,
'anatomical_brain')
# connect oxford_asl outputs to outputNode
asl_workflow.connect(run_oxford_asl, 'asl2anat_linear_xfm', outputNode,
'asl2anat_linear_xfm')
asl_workflow.connect(run_oxford_asl, 'asl2anat', outputNode, 'asl2anat')
asl_workflow.connect(run_oxford_asl, 'perfusion_image', outputNode,
'perfusion_image')
strat.update_resource_pool({
'mean_asl_in_anat': (run_oxford_asl, 'anat_asl'),
'asl_to_anat_linear_xfm': (run_oxford_asl, 'asl2anat_linear_xfm')
})
# Take mean of the asl data for registration
try:
get_mean_asl = pe.Node(interface=afni_utils.TStat(),
name='get_mean_asl')
except UnboundLocalError:
get_mean_asl = pe.Node(interface=preprocess.TStat(),
name='get_mean_asl')
get_mean_asl.inputs.options = '-mean'
get_mean_asl.inputs.outputtype = 'NIFTI_GZ'
asl_workflow.connect(func_reorient, 'out_file', get_mean_asl, 'in_file')
asl_workflow.connect(get_mean_asl, 'out_file', outputNode, 'meanasl')
return asl_workflow
def mean_functional_workflow(workflow, resource_pool, config, name="_"):
"""Build and run a Nipype workflow to generate a one-volume image from a
functional timeseries comprising of the mean of its timepoint values,
using AFNI's 3dTstat.
- If any resources/outputs required by this workflow are not in the
resource pool, this workflow will call pre-requisite workflow builder
functions to further populate the pipeline with workflows which will
calculate/generate these necessary pre-requisites.
- For QAP: This workflow will NOT remove background noise from the
image, to maintain as accurate of a quality metric as possible.
Expected Resources in Resource Pool
- func_reorient: The deobliqued, reoriented functional timeseries.
New Resources Added to Resource Pool
- mean_functional: The one-volume image of the averaged timeseries.
Workflow Steps:
1. AFNI 3dTstat to calculate the mean of the functional timeseries.
:type workflow: Nipype workflow object
:param workflow: A Nipype workflow object which can already contain other
connected nodes; this function will insert the following
workflow into this one provided.
:type resource_pool: dict
:param resource_pool: A dictionary defining input files and pointers to
Nipype node outputs / workflow connections; the keys
are the resource names.
:type config: dict
:param config: A dictionary defining the configuration settings for the
workflow, such as directory paths or toggled options.
:type name: str
:param name: (default: "_") A string to append to the end of each node
name.
:rtype: Nipype workflow object
:return: The Nipype workflow originally provided, but with this function's
sub-workflow connected into it.
:rtype: dict
:return: The resource pool originally provided, but updated (if
applicable) with the newest outputs and connections.
"""
import copy
import nipype.pipeline.engine as pe
from nipype.interfaces.afni import preprocess
if "func_reorient" not in resource_pool.keys():
from functional_preproc import func_preproc_workflow
old_rp = copy.copy(resource_pool)
workflow, resource_pool = \
func_preproc_workflow(workflow, resource_pool, config, name)
if resource_pool == old_rp:
return workflow, resource_pool
func_mean_tstat = pe.Node(interface=preprocess.TStat(),
name='func_mean_tstat%s' % name)
func_mean_tstat.inputs.options = '-mean'
func_mean_tstat.inputs.outputtype = 'NIFTI_GZ'
if len(resource_pool["func_reorient"]) == 2:
node, out_file = resource_pool["func_reorient"]
workflow.connect(node, out_file, func_mean_tstat, 'in_file')
else:
func_mean_tstat.inputs.in_file = \
resource_pool["func_reorient"]
resource_pool["mean_functional"] = (func_mean_tstat, 'out_file')
return workflow, resource_pool
