def vol2png(qcname, tag="", overlay=True, overlayiterated=True):
import PUMI.func_preproc.Onevol as onevol
QCDir = os.path.abspath(globals._SinkDir_ + "/" + globals._QCDir_)
if not os.path.exists(QCDir):
os.makedirs(QCDir)
if tag:
tag = "_" + tag
inputspec = pe.Node(
utility.IdentityInterface(fields=['bg_image', 'overlay_image']),
name='inputspec')
analysisflow = pe.Workflow(name=qcname + tag + '_qc')
myonevol_bg = onevol.onevol_workflow(wf_name="onebg")
analysisflow.connect(inputspec, 'bg_image', myonevol_bg, 'inputspec.func')
if overlay and not overlayiterated:
#myonevol_ol = onevol.onevol_workflow(wf_name="oneol")
#analysisflow.connect(inputspec, 'overlay_image', myonevol_ol, 'inputspec.func')
slicer = pe.MapNode(interface=fsl.Slicer(),
iterfield=['in_file'],
name='slicer')
# Create png images for quality check
if overlay and overlayiterated:
myonevol_ol = onevol.onevol_workflow(wf_name="oneol")
analysisflow.connect(inputspec, 'overlay_image', myonevol_ol,
'inputspec.func')
slicer = pe.MapNode(interface=fsl.Slicer(),
iterfield=['in_file', 'image_edges'],
name='slicer')
if not overlay:
slicer = pe.MapNode(interface=fsl.Slicer(),
iterfield=['in_file'],
name='slicer')
slicer.inputs.image_width = 2000
slicer.inputs.out_file = qcname
# set output all axial slices into one picture
slicer.inputs.sample_axial = 5
#slicer.inputs.middle_slices = True
# Save outputs which are important
ds_qc = pe.Node(interface=io.DataSink(), name='ds_qc')
ds_qc.inputs.base_directory = QCDir
ds_qc.inputs.regexp_substitutions = [("(\/)[^\/]*$", tag + ".ppm")]
analysisflow.connect(myonevol_bg, 'outputspec.func1vol', slicer, 'in_file')
if overlay and not overlayiterated:
analysisflow.connect(inputspec, 'overlay_image', slicer, 'image_edges')
if overlay and overlayiterated:
analysisflow.connect(myonevol_ol, 'outputspec.func1vol', slicer,
'image_edges')
analysisflow.connect(slicer, 'out_file', ds_qc, qcname)
return analysisflow
def create_non_uniformity_correct_4D_file(auto_clip=False, clip_low=7,
clip_high=200, n_procs=12):
"""non_uniformity_correct_4D_file corrects functional files for nonuniformity on a timepoint by timepoint way.
Internally it implements a workflow to split the in_file, correct each separately and then merge them back together.
This is an ugly workaround as we have to find the output of the workflow's datasink somewhere, but it should work.
Parameters
----------
in_file : str
Absolute path to nifti-file.
auto_clip : bool (default: False)
whether to let 3dUniformize decide on clipping boundaries
clip_low : float (default: 7),
lower clipping bound for 3dUniformize
clip_high : float (default: 200),
higher clipping bound for 3dUniformize
n_procs : int (default: 12),
the number of processes to run the internal workflow with
Returns
-------
out_file : non-uniformity corrected file
List of absolute paths to nifti-files. """
# nodes
input_node = pe.Node(IdentityInterface(
fields=['in_file',
'auto_clip',
'clip_low',
'clip_high',
'output_directory',
'sub_id']), name='inputspec')
split = pe.Node(Function(input_names='in_file', output_names=['out_files'],
function=split_4D_to_3D), name='split')
uniformer = pe.MapNode(
Uniformize(clip_high=clip_high, clip_low=clip_low, auto_clip=auto_clip,
outputtype='NIFTI_GZ'), name='uniformer',
iterfield=['in_file'])
merge = pe.MapNode(fsl.Merge(dimension='t'), name='merge',
iterfield=['in_files'])
datasink = pe.Node(nio.DataSink(infields=['topup'], container=''),
name='sinker')
datasink.inputs.parameterization = False
# workflow
nuc_wf = pe.Workflow(name='nuc')
nuc_wf.connect(input_node, 'sub_id', datasink, 'container')
nuc_wf.connect(input_node, 'output_directory', datasink, 'base_directory')
nuc_wf.connect(input_node, 'in_file', split, 'in_file')
nuc_wf.connect(split, 'out_files', uniformer, 'in_file')
nuc_wf.connect(uniformer, 'out_file', merge, 'in_files')
nuc_wf.connect(merge, 'merged_file', datasink, 'uni')
# nuc_wf.run('MultiProc', plugin_args={'n_procs': n_procs})
# out_file = glob.glob(os.path.join(td, 'uni', fn_base + '_0000*.nii.gz'))[0]
return nuc_wf
def create_melodic_workflow(name='melodic', template=None, varnorm=True):
input_node = pe.Node(IdentityInterface(fields=['in_file']),
name='inputspec')
output_node = pe.Node(IdentityInterface(fields=['out_dir']),
name='outputspec')
if template is None:
template = op.join(op.dirname(op.dirname(op.abspath(__file__))),
'data', 'fsf_templates', 'melodic_template.fsf')
melodic4fix_node = pe.MapNode(interface=Melodic4fix,
iterfield=['in_file', 'out_dir'],
name='melodic4fix')
# Don't know if this works. Could also set these defaults inside the
# melodic4fix node definition...
melodic4fix_node.inputs.template = template
melodic4fix_node.inputs.varnorm = varnorm
rename_ica = pe.MapNode(Function(input_names=['in_file'],
output_names=['out_file'],
function=extract_task),
name='rename_ica',
iterfield=['in_file'])
mel4fix_workflow = pe.Workflow(name=name)
mel4fix_workflow.connect(input_node, 'in_file', melodic4fix_node,
'in_file')
mel4fix_workflow.connect(input_node, 'in_file', rename_ica, 'in_file')
mel4fix_workflow.connect(rename_ica, 'out_file', melodic4fix_node,
'out_dir')
mel4fix_workflow.connect(melodic4fix_node, 'out_dir', output_node,
'out_dir')
return mel4fix_workflow
def create_motion_confound_workflow(order=2,
fd_cutoff=.2,
name='motion_confound'):
input_node = pe.Node(interface=IdentityInterface(
fields=['par_file', 'output_directory', 'sub_id']),
name='inputspec')
output_node = pe.Node(
interface=IdentityInterface(fields=['out_fd', 'out_ext_moco']),
name='outputspec')
datasink = pe.Node(DataSink(), name='sinker')
datasink.inputs.parameterization = False
extend_motion_parameters = pe.MapNode(Extend_motion_parameters,
iterfield=['par_file'],
name='extend_motion_parameters')
extend_motion_parameters.inputs.order = order
framewise_disp = pe.MapNode(FramewiseDisplacement(parameter_source='FSL'),
iterfield=['in_file'],
name='framewise_disp')
mcf_wf = pe.Workflow(name=name)
mcf_wf.connect(input_node, 'output_directory', datasink, 'base_directory')
mcf_wf.connect(input_node, 'sub_id', datasink, 'container')
mcf_wf.connect(input_node, 'par_file', extend_motion_parameters,
'par_file')
mcf_wf.connect(input_node, 'par_file', framewise_disp, 'in_file')
mcf_wf.connect(extend_motion_parameters, 'out_ext', output_node,
'out_ext_moco')
mcf_wf.connect(framewise_disp, 'out_file', output_node, 'out_fd')
mcf_wf.connect(extend_motion_parameters, 'out_ext', datasink, 'confounds')
mcf_wf.connect(framewise_disp, 'out_file', datasink, 'confounds.@df')
return mcf_wf
def create_confound_workflow(name='confound'):
input_node = pe.Node(interface=IdentityInterface(fields=[
'in_file', 'par_file', 'fast_files', 'highres2epi_mat',
'n_comp_tcompcor', 'n_comp_acompcor', 'output_directory', 'sub_id'
]),
name='inputspec')
output_node = pe.Node(interface=IdentityInterface(fields=[
'all_confounds',
]),
name='outputspec')
datasink = pe.Node(DataSink(), name='sinker')
datasink.inputs.parameterization = False
compute_DVARS = pe.MapNode(ComputeDVARS(save_all=True,
remove_zerovariance=True),
iterfield=['in_file', 'in_mask'],
name='compute_DVARS')
motion_wf = create_motion_confound_workflow(order=2)
confound_wf = pe.Workflow(name=name)
confound_wf.connect(input_node, 'par_file', motion_wf,
'inputspec.par_file')
confound_wf.connect(input_node, 'sub_id', motion_wf, 'inputspec.sub_id')
confound_wf.connect(input_node, 'output_directory', motion_wf,
'inputspec.output_directory')
compcor_wf = create_compcor_workflow()
confound_wf.connect(input_node, 'in_file', compcor_wf, 'inputspec.in_file')
confound_wf.connect(input_node, 'fast_files', compcor_wf,
'inputspec.fast_files')
confound_wf.connect(input_node, 'highres2epi_mat', compcor_wf,
'inputspec.highres2epi_mat')
confound_wf.connect(input_node, 'n_comp_tcompcor', compcor_wf,
'inputspec.n_comp_tcompcor')
confound_wf.connect(input_node, 'n_comp_acompcor', compcor_wf,
'inputspec.n_comp_acompcor')
confound_wf.connect(input_node, 'sub_id', compcor_wf, 'inputspec.sub_id')
confound_wf.connect(input_node, 'output_directory', compcor_wf,
'inputspec.output_directory')
confound_wf.connect(compcor_wf, 'outputspec.epi_mask', compute_DVARS,
'in_mask')
confound_wf.connect(input_node, 'in_file', compute_DVARS, 'in_file')
concat = pe.MapNode(Concat_confound_files,
iterfield=['ext_par_file', 'fd_file', 'dvars_file'],
name='concat')
confound_wf.connect(motion_wf, 'outputspec.out_ext_moco', concat,
'ext_par_file')
confound_wf.connect(motion_wf, 'outputspec.out_fd', concat, 'fd_file')
confound_wf.connect(compcor_wf, 'outputspec.acompcor_file', concat,
'acompcor_file')
#confound_wf.connect(compcor_wf, 'outputspec.tcompcor_file', concat,
# 'tcompcor_file')
confound_wf.connect(compute_DVARS, 'out_all', concat, 'dvars_file')
confound_wf.connect(input_node, 'sub_id', datasink, 'sub_id')
confound_wf.connect(input_node, 'output_directory', datasink,
'base_directory')
confound_wf.connect(concat, 'out_file', datasink, 'confounds')
return confound_wf
def create_registration_workflow(analysis_info, name='reg'):
"""uses sub-workflows to perform different registration steps.
Requires fsl and freesurfer tools
Parameters
----------
name : string
name of workflow
analysis_info : dict
contains session information needed for workflow, such as
whether to use FreeSurfer or FLIRT etc.
Example
-------
>>> registration_workflow = create_registration_workflow(name = 'registration_workflow', analysis_info = {'use_FS':True})
>>> registration_workflow.inputs.inputspec.output_directory = '/data/project/raw/BIDS/sj_1/'
>>> registration_workflow.inputs.inputspec.EPI_space_file = 'example_func.nii.gz'
>>> registration_workflow.inputs.inputspec.T1_file = 'T1.nii.gz' # if using freesurfer, this file will be created instead of used.
>>> registration_workflow.inputs.inputspec.freesurfer_subject_ID = 'sub_01'
>>> registration_workflow.inputs.inputspec.freesurfer_subject_dir = '$SUBJECTS_DIR'
>>> registration_workflow.inputs.inputspec.reference_file = '/usr/local/fsl/data/standard/standard152_T1_2mm_brain.nii.gz'
Inputs::
inputspec.output_directory : directory in which to sink the result files
inputspec.T1_file : T1 anatomy file
inputspec.EPI_space_file : EPI session file
inputspec.freesurfer_subject_ID : FS subject ID
inputspec.freesurfer_subject_dir : $SUBJECTS_DIR
Outputs::
outputspec.out_reg_file : BBRegister registration file that maps EPI space to T1
outputspec.out_matrix_file : FLIRT registration file that maps EPI space to T1
outputspec.out_inv_matrix_file : FLIRT registration file that maps T1 space to EPI
"""
### NODES
input_node = pe.Node(IdentityInterface(fields=[
'EPI_space_file', 'output_directory', 'freesurfer_subject_ID',
'freesurfer_subject_dir', 'T1_file', 'standard_file', 'sub_id'
]),
name='inputspec')
### Workflow to be returned
registration_workflow = pe.Workflow(name=name)
### sub-workflows
epi_2_T1 = create_epi_to_T1_workflow(name='epi',
use_FS=analysis_info['use_FS'],
do_FAST=analysis_info['do_FAST'])
T1_to_standard = create_T1_to_standard_workflow(
name='T1_to_standard',
use_FS=analysis_info['use_FS'],
do_fnirt=analysis_info['do_fnirt'],
use_AFNI_ss=analysis_info['use_AFNI_ss'])
concat_2_feat = create_concat_2_feat_workflow(name='concat_2_feat')
output_node = pe.Node(IdentityInterface(
fields=('EPI_T1_matrix_file', 'T1_EPI_matrix_file',
'EPI_T1_register_file', 'T1_standard_matrix_file',
'standard_T1_matrix_file', 'EPI_T1_matrix_file',
'T1_EPI_matrix_file', 'T1_file', 'standard_file',
'EPI_space_file')),
name='outputspec')
###########################################################################
# EPI to T1
###########################################################################
registration_workflow.connect([(input_node, epi_2_T1, [
('EPI_space_file', 'inputspec.EPI_space_file'),
('output_directory', 'inputspec.output_directory'),
('freesurfer_subject_ID', 'inputspec.freesurfer_subject_ID'),
('freesurfer_subject_dir', 'inputspec.freesurfer_subject_dir'),
('T1_file', 'inputspec.T1_file')
])])
###########################################################################
# T1 to standard
###########################################################################
registration_workflow.connect([(input_node, T1_to_standard, [
('freesurfer_subject_ID', 'inputspec.freesurfer_subject_ID'),
('freesurfer_subject_dir', 'inputspec.freesurfer_subject_dir'),
('T1_file', 'inputspec.T1_file'),
('standard_file', 'inputspec.standard_file')
])])
###########################################################################
# concatenation of all matrices
###########################################################################
# then, the inputs from the previous sub-workflows
registration_workflow.connect([(epi_2_T1, concat_2_feat, [
('outputspec.EPI_T1_matrix_file', 'inputspec.EPI_T1_matrix_file'),
])])
registration_workflow.connect([(T1_to_standard, concat_2_feat, [
('outputspec.T1_standard_matrix_file',
'inputspec.T1_standard_matrix_file'),
])])
###########################################################################
# Rename nodes, for the datasink
###########################################################################
if analysis_info['use_FS']:
rename_register = pe.Node(Rename(format_string='register.dat',
keep_ext=False),
name='rename_register')
registration_workflow.connect(epi_2_T1,
'outputspec.EPI_T1_register_file',
rename_register, 'in_file')
rename_example_func = pe.Node(Rename(format_string='example_func',
keep_ext=True),
name='rename_example_func')
registration_workflow.connect(input_node, 'EPI_space_file',
rename_example_func, 'in_file')
rename_highres = pe.Node(Rename(format_string='highres', keep_ext=True),
name='rename_highres')
registration_workflow.connect(T1_to_standard, 'outputspec.T1_file',
rename_highres, 'in_file')
rename_standard = pe.Node(Rename(format_string='standard', keep_ext=True),
name='rename_standard')
registration_workflow.connect(input_node, 'standard_file', rename_standard,
'in_file')
rename_example_func2standard = pe.Node(Rename(
format_string='example_func2standard.mat', keep_ext=False),
name='rename_example_func2standard')
registration_workflow.connect(concat_2_feat,
'outputspec.EPI_standard_matrix_file',
rename_example_func2standard, 'in_file')
rename_example_func2highres = pe.Node(Rename(
format_string='example_func2highres.mat', keep_ext=False),
name='rename_example_func2highres')
registration_workflow.connect(epi_2_T1, 'outputspec.EPI_T1_matrix_file',
rename_example_func2highres, 'in_file')
rename_highres2standard = pe.Node(Rename(
format_string='highres2standard.mat', keep_ext=False),
name='rename_highres2standard')
registration_workflow.connect(T1_to_standard,
'outputspec.T1_standard_matrix_file',
rename_highres2standard, 'in_file')
rename_standard2example_func = pe.Node(Rename(
format_string='standard2example_func.mat', keep_ext=False),
name='rename_standard2example_func')
registration_workflow.connect(concat_2_feat,
'outputspec.standard_EPI_matrix_file',
rename_standard2example_func, 'in_file')
rename_highres2example_func = pe.Node(Rename(
format_string='highres2example_func.mat', keep_ext=False),
name='rename_highres2example_func')
registration_workflow.connect(epi_2_T1, 'outputspec.T1_EPI_matrix_file',
rename_highres2example_func, 'in_file')
rename_standard2highres = pe.Node(Rename(
format_string='standard2highres.mat', keep_ext=False),
name='rename_standard2highres')
registration_workflow.connect(T1_to_standard,
'outputspec.standard_T1_matrix_file',
rename_standard2highres, 'in_file')
# outputs via datasink
datasink = pe.Node(DataSink(infields=['reg']), name='sinker')
datasink.inputs.parameterization = False
registration_workflow.connect(input_node, 'output_directory', datasink,
'base_directory')
registration_workflow.connect(input_node, 'sub_id', datasink, 'container')
# NEW SETUP WITH RENAME (WITHOUT MERGER)
if analysis_info['use_FS']:
registration_workflow.connect(rename_register, 'out_file', datasink,
'reg.@dat')
registration_workflow.connect(rename_example_func, 'out_file', datasink,
'reg.@example_func')
registration_workflow.connect(rename_standard, 'out_file', datasink,
'reg.@standard')
registration_workflow.connect(rename_highres, 'out_file', datasink,
'reg.@highres')
registration_workflow.connect(rename_example_func2highres, 'out_file',
datasink, 'reg.@example_func2highres')
registration_workflow.connect(rename_highres2example_func, 'out_file',
datasink, 'reg.@highres2example_func')
registration_workflow.connect(rename_highres2standard, 'out_file',
datasink, 'reg.@highres2standard')
registration_workflow.connect(rename_standard2highres, 'out_file',
datasink, 'reg.@standard2highres')
registration_workflow.connect(rename_standard2example_func, 'out_file',
datasink, 'reg.@standard2example_func')
registration_workflow.connect(rename_example_func2standard, 'out_file',
datasink, 'reg.@example_func2standard')
registration_workflow.connect(rename_highres, 'out_file', output_node,
'T1_file')
# put the nifti and mat files, renamed above, in the reg/feat directory.
# don't yet know what's wrong with this merge to datasink
# registration_workflow.connect(merge_for_reg_N, 'out', datasink, 'reg')
return registration_workflow
def extract_timeseries(SinkTag="connectivity",
wf_name="extract_timeseries",
modularise=True):
########################################################################
# Extract timeseries
########################################################################
import nipype.interfaces.nilearn as learn
import nipype.pipeline as pe
import nipype.interfaces.utility as utility
import nipype.interfaces.io as io
from nipype.interfaces.utility import Function
import PUMI.utils.globals as globals
import PUMI.utils.QC as qc
import os
SinkDir = os.path.abspath(globals._SinkDir_ + "/" + SinkTag)
if not os.path.exists(SinkDir):
os.makedirs(SinkDir)
# Identitiy mapping for input variables
inputspec = pe.Node(
utility.IdentityInterface(fields=[
'std_func',
'atlas_file', # nii labelmap (or 4D probmaps)
'labels', # list of short names to regions
'modules' # list of modules of regions
]),
name='inputspec')
# re-label atlas, so that regions corresponding to the same modules follow each other
if modularise:
relabel_atls = pe.Node(interface=Function(
input_names=['atlas_file', 'modules', 'labels'],
output_names=[
'relabelled_atlas_file', 'reordered_modules',
'reordered_labels', 'newlabels_file'
],
function=relabel_atlas),
name='relabel_atlas')
# Save outputs which are important
ds_nii = pe.Node(interface=io.DataSink(), name='ds_relabeled_atlas')
ds_nii.inputs.base_directory = SinkDir
ds_nii.inputs.regexp_substitutions = [("(\/)[^\/]*$", ".nii.gz")]
# Save outputs which are important
ds_newlabels = pe.Node(interface=io.DataSink(), name='ds_newlabels')
ds_newlabels.inputs.base_directory = SinkDir
ds_newlabels.inputs.regexp_substitutions = [("(\/)[^\/]*$", ".tsv")]
extract_timesereies = pe.MapNode(
interface=learn.SignalExtraction(detrend=False),
iterfield=['in_file'],
name='extract_timeseries')
# Save outputs which are important
ds_txt = pe.Node(interface=io.DataSink(), name='ds_txt')
ds_txt.inputs.base_directory = SinkDir
ds_txt.inputs.regexp_substitutions = [("(\/)[^\/]*$", wf_name + ".tsv")]
#QC
timeseries_qc = qc.regTimeseriesQC("regional_timeseries", tag=wf_name)
outputspec = pe.Node(utility.IdentityInterface(fields=[
'timeseries_file', 'relabelled_atlas_file', 'reordered_modules',
'reordered_labels'
]),
name='outputspec')
# Create workflow
analysisflow = pe.Workflow(wf_name)
analysisflow.connect(inputspec, 'std_func', extract_timesereies, 'in_file')
if modularise:
analysisflow.connect(inputspec, 'atlas_file', relabel_atls,
'atlas_file')
analysisflow.connect(inputspec, 'modules', relabel_atls, 'modules')
analysisflow.connect(inputspec, 'labels', relabel_atls, 'labels')
analysisflow.connect(relabel_atls, 'relabelled_atlas_file',
extract_timesereies, 'label_files')
analysisflow.connect(relabel_atls, 'reordered_labels',
extract_timesereies, 'class_labels')
analysisflow.connect(relabel_atls, 'reordered_modules', timeseries_qc,
'inputspec.modules')
analysisflow.connect(relabel_atls, 'relabelled_atlas_file',
timeseries_qc, 'inputspec.atlas')
analysisflow.connect(relabel_atls, 'relabelled_atlas_file', ds_nii,
'atlas_relabeled')
analysisflow.connect(relabel_atls, 'newlabels_file', ds_newlabels,
'atlas_relabeled')
analysisflow.connect(relabel_atls, 'relabelled_atlas_file', outputspec,
'relabelled_atlas_file')
analysisflow.connect(relabel_atls, 'reordered_labels', outputspec,
'reordered_labels')
analysisflow.connect(relabel_atls, 'reordered_modules', outputspec,
'reordered_modules')
else:
analysisflow.connect(inputspec, 'atlas_file', extract_timesereies,
'label_files')
analysisflow.connect(inputspec, 'labels', extract_timesereies,
'class_labels')
analysisflow.connect(inputspec, 'modules', timeseries_qc,
'inputspec.modules')
analysisflow.connect(inputspec, 'atlas_file', timeseries_qc,
'inputspec.atlas')
analysisflow.connect(inputspec, 'atlas_file', outputspec,
'relabelled_atlas_file')
analysisflow.connect(inputspec, 'labels', outputspec,
'reordered_labels')
analysisflow.connect(inputspec, 'modules', outputspec,
'reordered_modules')
analysisflow.connect(extract_timesereies, 'out_file', ds_txt,
'regional_timeseries')
analysisflow.connect(extract_timesereies, 'out_file', timeseries_qc,
'inputspec.timeseries')
analysisflow.connect(extract_timesereies, 'out_file', outputspec,
'timeseries_file')
return analysisflow
def create_all_calcarine_reward_preprocessing_workflow(
analysis_info, name='all_calcarine_reward'):
import os.path as op
import tempfile
import nipype.pipeline as pe
from nipype.interfaces import fsl
from nipype.interfaces.utility import Function, Merge, IdentityInterface
from spynoza.nodes.utils import get_scaninfo, dyns_min_1, topup_scan_params, apply_scan_params
from nipype.interfaces.io import SelectFiles, DataSink
# Importing of custom nodes from spynoza packages; assumes that spynoza is installed:
# pip install git+https://github.com/spinoza-centre/spynoza.git@develop
from spynoza.nodes.filtering import savgol_filter
from spynoza.nodes.utils import get_scaninfo, pickfirst, percent_signal_change, average_over_runs, pickle_to_json, set_nifti_intercept_slope
from spynoza.workflows.topup_unwarping import create_topup_workflow
from spynoza.workflows.B0_unwarping import create_B0_workflow
from spynoza.workflows.registration import create_registration_workflow
from spynoza.workflows.retroicor import create_retroicor_workflow
from spynoza.workflows.sub_workflows.masks import create_masks_from_surface_workflow
from spynoza.nodes.fit_nuisances import fit_nuisances
from motion_correction import create_motion_correction_workflow
from utils.utils import convert_edf_2_hdf5, mask_nii_2_hdf5
from utils.utils import convert_hdf_eye_to_tsv
########################################################################################
# nodes
########################################################################################
input_node = pe.Node(IdentityInterface(fields=[
'raw_directory', 'output_directory', 'FS_ID', 'FS_subject_dir',
'sub_id', 'sess_id', 'which_file_is_EPI_space', 'standard_file',
'psc_func', 'MB_factor', 'tr', 'slice_direction', 'phys_sample_rate',
'slice_timing', 'slice_order', 'nr_dummies', 'wfs', 'epi_factor',
'acceleration', 'te_diff', 'echo_time', 'phase_encoding_direction'
]),
name='inputspec')
# i/o node
datasource_templates = dict(
func='{sub_id}/{sess_id}/func/*bold.nii.gz',
physio='{sub_id}/{sess_id}/func/*.log',
events='{sub_id}/{sess_id}/func/*.pickle',
eye='{sub_id}/{sess_id}/func/*.edf',
anat='{sub_id}/{sess_id}/anat/*_inplaneT2.nii.gz',
reg='{sub_id}/{sess_id}/anat/*_inplaneT2.mat') # ,
datasource = pe.Node(SelectFiles(datasource_templates,
sort_filelist=True,
raise_on_empty=False),
name='datasource')
output_node = pe.Node(IdentityInterface(
fields=(['temporal_filtered_files', 'percent_signal_change_files'])),
name='outputspec')
# node for temporal filtering
sgfilter = pe.MapNode(Function(input_names=['in_file'],
output_names=['out_file'],
function=savgol_filter),
name='sgfilter',
iterfield=['in_file'])
# node for converting pickle files to json
pj = pe.MapNode(Function(input_names=['in_file'],
output_names=['out_file'],
function=pickle_to_json),
name='pj',
iterfield=['in_file'])
# node for percent signal change
psc = pe.MapNode(Function(input_names=['in_file', 'func'],
output_names=['out_file'],
function=percent_signal_change),
name='percent_signal_change',
iterfield=['in_file'])
# node to select the nii files that have physio information
physio_for_niis = pe.Node(Function(
input_names=['all_input_files', 'all_physio_files'],
output_names=['files_with_physio'],
function=which_files_have_physio),
name='physio_for_niis')
physio_for_mocos = pe.Node(Function(
input_names=['all_input_files', 'all_physio_files', 'input_extension'],
output_names=['files_with_physio'],
function=which_files_have_physio),
name='physio_for_mocos')
physio_for_mocos.inputs.input_extension = '_bold_brain_mcf.niiext_moco_pars.par'
# node for nuisance regression
fit_nuis = pe.MapNode(
Function(
input_names=['in_file', 'slice_regressor_list', 'vol_regressors'],
output_names=['res_file', 'rsq_file', 'beta_file'],
function=fit_nuisances),
name='fit_nuisances',
iterfield=['in_file', 'slice_regressor_list', 'vol_regressors'])
edf_converter = pe.MapNode(Function(input_names=['edf_file'],
output_names=['hdf5_file'],
function=convert_edf_2_hdf5),
name='edf_converter',
iterfield=['edf_file'])
hdf_tsv_converter = pe.MapNode(Function(input_names=['hdf5_file'],
output_names=['tsv_file'],
function=convert_hdf_eye_to_tsv),
name='hdf_tsv_converter',
iterfield=['hdf5_file'])
behavior_tsv_converter = pe.Node(Function(
input_names=['hdf5_files', 'reward_signal_unpredictable'],
output_names=['tsv_files'],
function=convert_behavior),
name='behavior_tsv_converter')
behavior_tsv_converter.inputs.reward_signal_unpredictable = analysis_info[
'which_reward_sound_unpredictable']
# node for datasinking
datasink = pe.Node(DataSink(), name='sinker')
datasink.inputs.parameterization = False
########################################################################################
# workflow
########################################################################################
# the actual top-level workflow
all_calcarine_reward_workflow = pe.Workflow(name=name)
all_calcarine_reward_workflow.connect(input_node, 'raw_directory',
datasource, 'base_directory')
all_calcarine_reward_workflow.connect(input_node, 'sub_id', datasource,
'sub_id')
all_calcarine_reward_workflow.connect(input_node, 'sess_id', datasource,
'sess_id')
# behavioral pickle to json
all_calcarine_reward_workflow.connect(datasource, 'events', pj, 'in_file')
all_calcarine_reward_workflow.connect(datasource, 'eye', edf_converter,
'edf_file')
all_calcarine_reward_workflow.connect(edf_converter, 'hdf5_file',
hdf_tsv_converter, 'hdf5_file')
all_calcarine_reward_workflow.connect(edf_converter, 'hdf5_file',
behavior_tsv_converter, 'hdf5_files')
# motion correction, using T2 inplane anatomicals to prime
# the motion correction to the standard EPI space
motion_proc = create_motion_correction_workflow(analysis_info, 'moco')
all_calcarine_reward_workflow.connect(input_node, 'tr', motion_proc,
'inputspec.tr')
all_calcarine_reward_workflow.connect(input_node, 'output_directory',
motion_proc,
'inputspec.output_directory')
all_calcarine_reward_workflow.connect(input_node,
'which_file_is_EPI_space',
motion_proc,
'inputspec.which_file_is_EPI_space')
all_calcarine_reward_workflow.connect(datasource, 'func', motion_proc,
'inputspec.in_files')
all_calcarine_reward_workflow.connect(datasource, 'anat', motion_proc,
'inputspec.inplane_T2_files')
all_calcarine_reward_workflow.connect(datasource, 'reg', motion_proc,
'inputspec.T2_files_reg_matrices')
# registration
reg = create_registration_workflow(analysis_info, name='reg')
all_calcarine_reward_workflow.connect(input_node, 'output_directory', reg,
'inputspec.output_directory')
all_calcarine_reward_workflow.connect(motion_proc,
'outputspec.EPI_space_file', reg,
'inputspec.EPI_space_file')
all_calcarine_reward_workflow.connect(input_node, 'FS_ID', reg,
'inputspec.freesurfer_subject_ID')
all_calcarine_reward_workflow.connect(input_node, 'FS_subject_dir', reg,
'inputspec.freesurfer_subject_dir')
all_calcarine_reward_workflow.connect(input_node, 'standard_file', reg,
'inputspec.standard_file')
# the T1_file entry could be empty sometimes, depending on the output of the
# datasource. Check this.
# all_calcarine_reward_workflow.connect(reg, 'outputspec.T1_file', reg, 'inputspec.T1_file')
# temporal filtering
all_calcarine_reward_workflow.connect(motion_proc,
'outputspec.motion_corrected_files',
sgfilter, 'in_file')
# node for percent signal change
all_calcarine_reward_workflow.connect(input_node, 'psc_func', psc, 'func')
all_calcarine_reward_workflow.connect(sgfilter, 'out_file', psc, 'in_file')
# connect filtering and psc results to output node
all_calcarine_reward_workflow.connect(sgfilter, 'out_file', output_node,
'temporal_filtered_files')
all_calcarine_reward_workflow.connect(psc, 'out_file', output_node,
'percent_signal_change_files')
# retroicor functionality
retr = create_retroicor_workflow(
name='retroicor',
order_or_timing=analysis_info['retroicor_order_or_timing'])
# select those nii files with physio
all_calcarine_reward_workflow.connect(datasource, 'func', physio_for_niis,
'all_input_files')
all_calcarine_reward_workflow.connect(datasource, 'physio',
physio_for_niis, 'all_physio_files')
all_calcarine_reward_workflow.connect(physio_for_niis, 'files_with_physio',
retr, 'inputspec.in_files')
all_calcarine_reward_workflow.connect(datasource, 'physio', retr,
'inputspec.phys_files')
all_calcarine_reward_workflow.connect(input_node, 'nr_dummies', retr,
'inputspec.nr_dummies')
all_calcarine_reward_workflow.connect(input_node, 'MB_factor', retr,
'inputspec.MB_factor')
all_calcarine_reward_workflow.connect(input_node, 'tr', retr,
'inputspec.tr')
all_calcarine_reward_workflow.connect(input_node, 'slice_direction', retr,
'inputspec.slice_direction')
all_calcarine_reward_workflow.connect(input_node, 'slice_timing', retr,
'inputspec.slice_timing')
all_calcarine_reward_workflow.connect(input_node, 'slice_order', retr,
'inputspec.slice_order')
all_calcarine_reward_workflow.connect(input_node, 'phys_sample_rate', retr,
'inputspec.phys_sample_rate')
# fit nuisances from retroicor
# all_calcarine_reward_workflow.connect(retr, 'outputspec.evs', fit_nuis, 'slice_regressor_list')
# select the relevant motion correction files, using selection function
# all_calcarine_reward_workflow.connect(motion_proc, 'outputspec.extended_motion_correction_parameters', physio_for_mocos, 'all_input_files')
# all_calcarine_reward_workflow.connect(datasource, 'physio', physio_for_mocos, 'all_physio_files')
# all_calcarine_reward_workflow.connect(physio_for_mocos, 'files_with_physio', fit_nuis, 'vol_regressors')
# all_calcarine_reward_workflow.connect(physio_for_niis, 'files_with_physio', fit_nuis, 'in_file')
# surface-based label import in to EPI space
masks_from_surface = create_masks_from_surface_workflow(
name='masks_from_surface')
masks_from_surface.inputs.inputspec.label_directory = 'retmap'
masks_from_surface.inputs.inputspec.fill_thresh = 0.005
masks_from_surface.inputs.inputspec.re = '*.label'
all_calcarine_reward_workflow.connect(motion_proc,
'outputspec.EPI_space_file',
masks_from_surface,
'inputspec.EPI_space_file')
all_calcarine_reward_workflow.connect(input_node, 'output_directory',
masks_from_surface,
'inputspec.output_directory')
all_calcarine_reward_workflow.connect(input_node, 'FS_subject_dir',
masks_from_surface,
'inputspec.freesurfer_subject_dir')
all_calcarine_reward_workflow.connect(input_node, 'FS_ID',
masks_from_surface,
'inputspec.freesurfer_subject_ID')
all_calcarine_reward_workflow.connect(reg, 'rename_register.out_file',
masks_from_surface,
'inputspec.reg_file')
# ########################################################################################
# # outputs via datasink
# ########################################################################################
all_calcarine_reward_workflow.connect(input_node, 'output_directory',
datasink, 'base_directory')
# # sink out events and eyelink files
all_calcarine_reward_workflow.connect(pj, 'out_file', datasink, 'events')
all_calcarine_reward_workflow.connect(sgfilter, 'out_file', datasink, 'tf')
all_calcarine_reward_workflow.connect(psc, 'out_file', datasink, 'psc')
all_calcarine_reward_workflow.connect(retr, 'outputspec.new_phys',
datasink, 'phys.log')
all_calcarine_reward_workflow.connect(retr, 'outputspec.fig_file',
datasink, 'phys.figs')
all_calcarine_reward_workflow.connect(retr, 'outputspec.evs', datasink,
'phys.evs')
# all_calcarine_reward_workflow.connect(fit_nuis, 'res_file', datasink, 'phys.res')
# all_calcarine_reward_workflow.connect(fit_nuis, 'rsq_file', datasink, 'phys.rsq')
# all_calcarine_reward_workflow.connect(fit_nuis, 'beta_file', datasink, 'phys.betas')
all_calcarine_reward_workflow.connect(masks_from_surface,
'outputspec.masks', datasink,
'masks')
all_calcarine_reward_workflow.connect(datasource, 'eye', datasink, 'eye')
all_calcarine_reward_workflow.connect(edf_converter, 'hdf5_file', datasink,
'eye.h5')
all_calcarine_reward_workflow.connect(hdf_tsv_converter, 'tsv_file',
datasink, 'eye.tsv')
all_calcarine_reward_workflow.connect(behavior_tsv_converter, 'tsv_files',
datasink, 'events.tsv')
return all_calcarine_reward_workflow
def create_extended_susan_workflow(name='extended_susan', separate_masks=True):
input_node = pe.Node(IdentityInterface(fields=['in_file',
'fwhm',
'EPI_session_space',
'output_directory',
'sub_id']), name='inputspec')
output_node = pe.Node(interface=IdentityInterface(fields=['smoothed_files',
'mask',
'mean']), name='outputspec')
datasink = pe.Node(DataSink(), name='sinker')
datasink.inputs.parameterization = False
# first link the workflow's output_directory into the datasink.
esw = pe.Workflow(name=name)
esw.connect(input_node, 'output_directory', datasink, 'base_directory')
esw.connect(input_node, 'sub_id', datasink, 'container')
meanfuncmask = pe.Node(interface=fsl.BET(mask=True,
no_output=True,
frac=0.3),
name='meanfuncmask')
esw.connect(input_node, 'EPI_session_space', meanfuncmask, 'in_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')
esw.connect(input_node, 'in_file', maskfunc, 'in_file')
esw.connect(meanfuncmask, 'mask_file', maskfunc, 'in_file2')
"""
Determine the 2nd and 98th percentile intensities of each functional run
"""
getthresh = pe.MapNode(interface=fsl.ImageStats(op_string='-p 2 -p 98'),
iterfield=['in_file'],
name='getthreshold')
esw.connect(maskfunc, 'out_file', getthresh, 'in_file')
"""
Threshold the first run of the functional data at 10% of the 98th percentile
"""
threshold = pe.MapNode(interface=fsl.ImageMaths(out_data_type='char',
suffix='_thresh'),
iterfield=['in_file', 'op_string'],
name='threshold')
esw.connect(maskfunc, 'out_file', threshold, 'in_file')
"""
Define a function to get 10% of the intensity
"""
esw.connect(getthresh, ('out_stat', getthreshop), threshold, 'op_string')
"""
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', 'mask_file'],
name='medianval')
esw.connect(input_node, 'in_file', medianval, 'in_file')
esw.connect(threshold, 'out_file', medianval, 'mask_file')
"""
Dilate the mask
"""
dilatemask = pe.MapNode(interface=fsl.ImageMaths(suffix='_dil',
op_string='-dilF'),
iterfield=['in_file'],
name='dilatemask')
esw.connect(threshold, 'out_file', dilatemask, 'in_file')
esw.connect(dilatemask, 'out_file', output_node, 'mask')
"""
Mask the motion corrected functional runs with the dilated mask
"""
maskfunc2 = pe.MapNode(interface=fsl.ImageMaths(suffix='_mask',
op_string='-mas'),
iterfield=['in_file', 'in_file2'],
name='maskfunc2')
esw.connect(input_node, 'in_file', maskfunc2, 'in_file')
esw.connect(dilatemask, 'out_file', maskfunc2, 'in_file2')
"""
Smooth each run using SUSAN with the brightness threshold set to 75%
of the median value for each run and a mask constituting the mean
functional
"""
smooth = create_susan_smooth(separate_masks=separate_masks)
esw.connect(input_node, 'fwhm', smooth, 'inputnode.fwhm')
esw.connect(maskfunc2, 'out_file', smooth, 'inputnode.in_files')
esw.connect(dilatemask, 'out_file', 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', 'in_file2'],
name='maskfunc3')
esw.connect(smooth, 'outputnode.smoothed_files', maskfunc3, 'in_file')
esw.connect(dilatemask, 'out_file', maskfunc3, 'in_file2')
concatnode = pe.Node(interface=Merge(2),
name='concat')
esw.connect(maskfunc2, ('out_file', tolist), concatnode, 'in1')
esw.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=Select(), name='select')
esw.connect(concatnode, 'out', selectnode, 'inlist')
esw.connect(input_node, ('fwhm', chooseindex), selectnode, 'index')
esw.connect(selectnode, 'out', output_node, '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')
esw.connect(selectnode, 'out', meanscale, 'in_file')
"""
Define a function to get the scaling factor for intensity normalization
"""
esw.connect(medianval, ('out_stat', getmeanscale), meanscale, 'op_string')
"""
Generate a mean functional image from the first run
"""
meanfunc3 = pe.Node(interface=fsl.ImageMaths(op_string='-Tmean',
suffix='_mean'),
iterfield=['in_file'],
name='meanfunc3')
esw.connect(meanscale, ('out_file', pickfirst), meanfunc3, 'in_file')
esw.connect(meanfunc3, 'out_file', output_node, 'mean')
# Datasink
esw.connect(meanscale, 'out_file', datasink, 'filtering')
esw.connect(selectnode, 'out', datasink, 'filtering.@smoothed')
esw.connect(dilatemask, 'out_file', datasink, 'filtering.@mask')
return esw
def create_motion_correction_workflow(name='moco',
method='AFNI',
extend_moco_params=False):
"""uses sub-workflows to perform different registration steps.
Requires fsl and freesurfer tools
Parameters
----------
name : string
name of workflow
Example
-------
>>> motion_correction_workflow = create_motion_correction_workflow('motion_correction_workflow')
>>> motion_correction_workflow.inputs.inputspec.output_directory = '/data/project/raw/BIDS/sj_1/'
>>> motion_correction_workflow.inputs.inputspec.in_files = ['sub-001.nii.gz','sub-002.nii.gz']
>>> motion_correction_workflow.inputs.inputspec.which_file_is_EPI_space = 'middle'
Inputs::
inputspec.output_directory : directory in which to sink the result files
inputspec.in_files : list of functional files
inputspec.which_file_is_EPI_space : determines which file is the 'standard EPI space'
Outputs::
outputspec.EPI_space_file : standard EPI space file, one timepoint
outputspec.motion_corrected_files : motion corrected files
outputspec.motion_correction_plots : motion correction plots
outputspec.motion_correction_parameters : motion correction parameters
"""
### NODES
input_node = pe.Node(IdentityInterface(fields=[
'in_files', 'output_directory', 'which_file_is_EPI_space', 'sub_id',
'tr'
]),
name='inputspec')
output_node = pe.Node(IdentityInterface(fields=([
'motion_corrected_files', 'EPI_space_file', 'mask_EPI_space_file',
'motion_correction_plots', 'motion_correction_parameters',
'extended_motion_correction_parameters',
'new_motion_correction_parameters'
])),
name='outputspec')
########################################################################################
# Invariant nodes
########################################################################################
EPI_file_selector_node = pe.Node(interface=EPI_file_selector,
name='EPI_file_selector_node')
mean_bold = pe.Node(interface=fsl.maths.MeanImage(dimension='T'),
name='mean_space')
rename_mean_bold = pe.Node(niu.Rename(format_string='session_EPI_space',
keep_ext=True),
name='rename_mean_bold')
########################################################################################
# Workflow
########################################################################################
motion_correction_workflow = pe.Workflow(name=name)
motion_correction_workflow.connect(input_node, 'which_file_is_EPI_space',
EPI_file_selector_node, 'which_file')
motion_correction_workflow.connect(input_node, 'in_files',
EPI_file_selector_node, 'in_files')
########################################################################################
# outputs via datasink
########################################################################################
datasink = pe.Node(nio.DataSink(), name='sinker')
datasink.inputs.parameterization = False
# first link the workflow's output_directory into the datasink.
motion_correction_workflow.connect(input_node, 'output_directory',
datasink, 'base_directory')
motion_correction_workflow.connect(input_node, 'sub_id', datasink,
'container')
########################################################################################
# FSL MCFlirt
########################################################################################
# new approach, which should aid in the joint motion correction of
# multiple sessions together, by pre-registering each run.
# the strategy would be to, for each run, take the first TR
# and FLIRT-align (6dof) it to the EPI_space file.
# then we can use this as an --infile argument to mcflirt.
if method == 'FSL':
rename_motion_files = pe.MapNode(
niu.Rename(keep_ext=False),
name='rename_motion_files',
iterfield=['in_file', 'format_string'])
remove_niigz_ext = pe.MapNode(interface=Remove_extension,
name='remove_niigz_ext',
iterfield=['in_file'])
motion_correct_EPI_space = pe.Node(interface=fsl.MCFLIRT(
cost='normcorr', interpolation='sinc', mean_vol=True),
name='motion_correct_EPI_space')
motion_correct_all = pe.MapNode(interface=fsl.MCFLIRT(
save_mats=True,
save_plots=True,
cost='normcorr',
interpolation='sinc',
stats_imgs=True),
name='motion_correct_all',
iterfield=['in_file'])
plot_motion = pe.MapNode(
interface=fsl.PlotMotionParams(in_source='fsl'),
name='plot_motion',
iterfield=['in_file'])
if extend_moco_params:
# make extend_motion_pars node here
# extend_motion_pars = pe.MapNode(Function(input_names=['moco_par_file', 'tr'], output_names=['new_out_file', 'ext_out_file'],
# function=_extend_motion_parameters), name='extend_motion_pars', iterfield = ['moco_par_file'])
pass
# create reference:
motion_correction_workflow.connect(EPI_file_selector_node, 'out_file',
motion_correct_EPI_space, 'in_file')
motion_correction_workflow.connect(motion_correct_EPI_space,
'out_file', mean_bold, 'in_file')
motion_correction_workflow.connect(mean_bold, 'out_file',
motion_correct_all, 'ref_file')
# motion correction across runs
motion_correction_workflow.connect(input_node, 'in_files',
motion_correct_all, 'in_file')
#motion_correction_workflow.connect(motion_correct_all, 'out_file', output_node, 'motion_corrected_files')
# motion_correction_workflow.connect(motion_correct_all, 'par_file', extend_motion_pars, 'moco_par_file')
# motion_correction_workflow.connect(input_node, 'tr', extend_motion_pars, 'tr')
# motion_correction_workflow.connect(extend_motion_pars, 'ext_out_file', output_node, 'extended_motion_correction_parameters')
# motion_correction_workflow.connect(extend_motion_pars, 'new_out_file', output_node, 'new_motion_correction_parameters')
########################################################################################
# Plot the estimated motion parameters
########################################################################################
# rename:
motion_correction_workflow.connect(mean_bold, 'out_file',
rename_mean_bold, 'in_file')
motion_correction_workflow.connect(motion_correct_all, 'par_file',
rename_motion_files, 'in_file')
motion_correction_workflow.connect(motion_correct_all, 'par_file',
remove_niigz_ext, 'in_file')
motion_correction_workflow.connect(remove_niigz_ext, 'out_file',
rename_motion_files,
'format_string')
# plots:
plot_motion.iterables = ('plot_type', ['rotations', 'translations'])
motion_correction_workflow.connect(rename_motion_files, 'out_file',
plot_motion, 'in_file')
motion_correction_workflow.connect(plot_motion, 'out_file',
output_node,
'motion_correction_plots')
# output node:
motion_correction_workflow.connect(mean_bold, 'out_file', output_node,
'EPI_space_file')
motion_correction_workflow.connect(rename_motion_files, 'out_file',
output_node,
'motion_correction_parameters')
motion_correction_workflow.connect(motion_correct_all, 'out_file',
output_node,
'motion_corrected_files')
# datasink:
motion_correction_workflow.connect(rename_mean_bold, 'out_file',
datasink, 'reg')
motion_correction_workflow.connect(motion_correct_all, 'out_file',
datasink, 'mcf')
motion_correction_workflow.connect(rename_motion_files, 'out_file',
datasink, 'mcf.motion_pars')
motion_correction_workflow.connect(plot_motion, 'out_file', datasink,
'mcf.motion_plots')
# motion_correction_workflow.connect(extend_motion_pars, 'ext_out_file', datasink, 'mcf.ext_motion_pars')
# motion_correction_workflow.connect(extend_motion_pars, 'new_out_file', datasink, 'mcf.new_motion_pars')
########################################################################################
# AFNI 3DVolReg
########################################################################################
# for speed, we use AFNI's 3DVolReg brute-force.
# this loses plotting of motion parameters but increases speed
# we hold on to the same setup, first moco the selected run
# and then moco everything to that image, but without the
# intermediate FLIRT step.
if method == 'AFNI':
motion_correct_EPI_space = pe.Node(
interface=afni.Volreg(
outputtype='NIFTI_GZ',
zpad=5,
args=' -cubic ' # -twopass -Fourier
),
name='motion_correct_EPI_space')
motion_correct_all = pe.MapNode(
interface=afni.Volreg(
outputtype='NIFTI_GZ',
zpad=5,
args=' -cubic ' # -twopass
),
name='motion_correct_all',
iterfield=['in_file'])
# for renaming *_volreg.nii.gz to *_mcf.nii.gz
set_postfix_mcf = pe.MapNode(interface=Set_postfix,
name='set_postfix_mcf',
iterfield=['in_file'])
set_postfix_mcf.inputs.postfix = 'mcf'
rename_volreg = pe.MapNode(interface=Rename(keep_ext=True),
name='rename_volreg',
iterfield=['in_file', 'format_string'])
# curate for moco between sessions
motion_correction_workflow.connect(EPI_file_selector_node, 'out_file',
motion_correct_EPI_space, 'in_file')
motion_correction_workflow.connect(motion_correct_EPI_space,
'out_file', mean_bold, 'in_file')
# motion correction across runs
motion_correction_workflow.connect(input_node, 'in_files',
motion_correct_all, 'in_file')
motion_correction_workflow.connect(mean_bold, 'out_file',
motion_correct_all, 'basefile')
# motion_correction_workflow.connect(mean_bold, 'out_file', motion_correct_all, 'rotparent')
# motion_correction_workflow.connect(mean_bold, 'out_file', motion_correct_all, 'gridparent')
# output node:
motion_correction_workflow.connect(mean_bold, 'out_file', output_node,
'EPI_space_file')
motion_correction_workflow.connect(motion_correct_all, 'md1d_file',
output_node,
'max_displacement_info')
motion_correction_workflow.connect(motion_correct_all, 'oned_file',
output_node,
'motion_correction_parameter_info')
motion_correction_workflow.connect(
motion_correct_all, 'oned_matrix_save', output_node,
'motion_correction_parameter_matrix')
motion_correction_workflow.connect(input_node, 'in_files',
set_postfix_mcf, 'in_file')
motion_correction_workflow.connect(set_postfix_mcf, 'out_file',
rename_volreg, 'format_string')
motion_correction_workflow.connect(motion_correct_all, 'out_file',
rename_volreg, 'in_file')
motion_correction_workflow.connect(rename_volreg, 'out_file',
output_node,
'motion_corrected_files')
# datasink:
motion_correction_workflow.connect(mean_bold, 'out_file',
rename_mean_bold, 'in_file')
motion_correction_workflow.connect(rename_mean_bold, 'out_file',
datasink, 'reg')
motion_correction_workflow.connect(rename_volreg, 'out_file', datasink,
'mcf')
motion_correction_workflow.connect(motion_correct_all, 'md1d_file',
datasink,
'mcf.max_displacement_info')
motion_correction_workflow.connect(motion_correct_all, 'oned_file',
datasink, 'mcf.parameter_info')
motion_correction_workflow.connect(motion_correct_all,
'oned_matrix_save', datasink,
'mcf.motion_pars')
return motion_correction_workflow
def create_T1_to_standard_workflow(name='T1_to_standard', use_FS = True,
do_fnirt = False, use_AFNI_ss=False):
"""Registers subject's T1 to standard space using FLIRT and FNIRT.
Requires fsl tools
Parameters
----------
name : string
name of workflow
use_FS : bool
whether to use freesurfer's T1
Example
-------
>>> T1_to_standard = create_T1_to_standard_workflow()
>>> T1_to_standard.inputs.inputspec.T1_file = 'T1.nii.gz'
>>> T1_to_standard.inputs.inputspec.standard_file = 'standard.nii.gz'
>>> T1_to_standard.inputs.inputspec.freesurfer_subject_ID = 'sub_01'
>>> T1_to_standard.inputs.inputspec.freesurfer_subject_dir = '$SUBJECTS_DIR'
Inputs::
inputspec.T1_file : T1 anatomy file
inputspec.standard_file : MNI? standard file
inputspec.freesurfer_subject_ID : FS subject ID
inputspec.freesurfer_subject_dir : $SUBJECTS_DIR
Outputs::
outputspec.T1_MNI_file : T1 converted to standard
outputspec.out_matrix_file : mat file specifying how to convert T1 to standard
outputspec.out_inv_matrix_file : mat file specifying how to convert standard to T1
outputspec.warp_field_file : FNIRT warp field
outputspec.warp_fieldcoeff_file : FNIRT warp coeff field
outputspec.warped_file : FNIRT warped T1
outputspec.out_intensitymap_file : FNIRT intensity map
"""
### NODES
input_node = pe.Node(IdentityInterface(
fields=['freesurfer_subject_ID', 'freesurfer_subject_dir', 'T1_file', 'standard_file']), name='inputspec')
# still have to choose which of these two output methods to use.
datasink = pe.Node(nio.DataSink(), name='sinker')
output_node = pe.Node(IdentityInterface(fields=['T1_standard_file',
'T1_standard_matrix_file',
'standard_T1_matrix_file',
'warp_field_file'
'warp_fieldcoeff_file',
'warped_file',
'modulatedref_file',
'out_intensitymap_file',
'T1_file'
]), name='outputspec')
# housekeeping function for finding T1 file in FS directory
def FS_T1_file(freesurfer_subject_ID, freesurfer_subject_dir):
import os.path as op
return op.join(freesurfer_subject_dir, freesurfer_subject_ID, 'mri', 'T1.mgz')
FS_T1_file_node = pe.Node(Function(input_names=('freesurfer_subject_ID', 'freesurfer_subject_dir'), output_names='T1_mgz_path',
function=FS_T1_file), name='FS_T1_file_node')
T1_to_standard_workflow = pe.Workflow(name='T1_to_standard')
# first link the workflow's output_directory into the datasink.
# and immediately attempt to datasink the standard file
T1_to_standard_workflow.connect(input_node, 'standard_file', datasink, 'reg.feat.standard.@nii.@gz')
########################################################################################
# create FLIRT/FNIRT nodes
########################################################################################
if use_AFNI_ss:
bet_N = pe.Node(interface=SkullStrip(args='-orig_vol', outputtype='NIFTI_GZ'), name='bet_N_afni')
else:
bet_N = pe.Node(interface=fsl.BET(vertical_gradient = -0.1, functional=False, mask=True), name='bet_N_fsl')
flirt_t2s = pe.Node(fsl.FLIRT(cost_func='normmi', output_type = 'NIFTI_GZ', dof = 12, interp = 'sinc'),
name='flirt_t2s')
if do_fnirt:
fnirt_N = pe.Node(fsl.FNIRT(in_fwhm=[8, 4, 2, 2],
subsampling_scheme=[4, 2, 1, 1],
warp_resolution =(6, 6, 6),
output_type='NIFTI_GZ'),
name='fnirt_N')
########################################################################################
# first take file from freesurfer subject directory, if necessary
# in which case we assume that there is no T1_file at present and overwrite it
########################################################################################
if use_FS:
mriConvert_N = pe.Node(freesurfer.MRIConvert(out_type = 'niigz'),
name = 'mriConvert_N')
T1_to_standard_workflow.connect(input_node, 'freesurfer_subject_ID', FS_T1_file_node, 'freesurfer_subject_ID')
T1_to_standard_workflow.connect(input_node, 'freesurfer_subject_dir', FS_T1_file_node, 'freesurfer_subject_dir')
T1_to_standard_workflow.connect(FS_T1_file_node, 'T1_mgz_path', mriConvert_N, 'in_file')
# and these are input into the flirt and fnirt operators, as below.
T1_to_standard_workflow.connect(mriConvert_N, 'out_file', bet_N, 'in_file')
T1_to_standard_workflow.connect(bet_N, 'out_file', flirt_t2s, 'in_file')
T1_to_standard_workflow.connect(mriConvert_N, 'out_file', output_node, 'T1_file')
if do_fnirt:
T1_to_standard_workflow.connect(bet_N, 'out_file', fnirt_N, 'in_file')
else:
T1_to_standard_workflow.connect(input_node, 'T1_file', bet_N, 'in_file')
T1_to_standard_workflow.connect(bet_N, 'out_file', flirt_t2s, 'in_file')
T1_to_standard_workflow.connect(input_node, 'T1_file', output_node, 'T1_file')
if do_fnirt:
T1_to_standard_workflow.connect(bet_N, 'out_file', fnirt_N, 'in_file')
########################################################################################
# continue with FLIRT step
########################################################################################
T1_to_standard_workflow.connect(input_node, 'standard_file', flirt_t2s, 'reference')
T1_to_standard_workflow.connect(flirt_t2s, 'out_matrix_file', output_node, 'T1_standard_matrix_file')
T1_to_standard_workflow.connect(flirt_t2s, 'out_file', output_node, 'T1_standard_file')
########################################################################################
# invert step
########################################################################################
invert_N = pe.Node(fsl.ConvertXFM(invert_xfm = True), name = 'invert_N')
T1_to_standard_workflow.connect(flirt_t2s, 'out_matrix_file', invert_N, 'in_file')
T1_to_standard_workflow.connect(invert_N, 'out_file', output_node, 'standard_T1_matrix_file')
if do_fnirt:
########################################################################################
# FNIRT step
########################################################################################
T1_to_standard_workflow.connect(flirt_t2s, 'out_matrix_file', fnirt_N, 'affine_file')
T1_to_standard_workflow.connect(input_node, 'standard_file', fnirt_N, 'ref_file')
########################################################################################
# output node
########################################################################################
T1_to_standard_workflow.connect(fnirt_N, 'field_file', output_node, 'warp_field_file')
T1_to_standard_workflow.connect(fnirt_N, 'fieldcoeff_file', output_node, 'warp_fieldcoeff_file')
T1_to_standard_workflow.connect(fnirt_N, 'warped_file', output_node, 'warped_file')
T1_to_standard_workflow.connect(fnirt_N, 'modulatedref_file', output_node, 'modulatedref_file')
T1_to_standard_workflow.connect(fnirt_N, 'out_intensitymap_file', output_node, 'out_intensitymap_file')
return T1_to_standard_workflow
def spikereg_workflow(SinkTag="func_preproc",
wf_name="data_censoring_despike"):
"""
Description:
Calculates volumes to be excluded, creates the despike regressor matrix
Workflow inputs:
:param FD: the frame wise displacement calculated by the MotionCorrecter.py script
:param threshold: threshold of FD volumes which should be excluded
:param SinkDir:
:param SinkTag: The output directory in which the returned images (see workflow outputs) could be found in a subdirectory directory specific for this workflow..
Workflow outputs:
:return: spikereg_workflow - workflow
Tamas Spisak
[email protected]
2018
References
----------
.. [1] Power, J. D., Barnes, K. A., Snyder, A. Z., Schlaggar, B. L., & Petersen, S. E. (2012). Spurious
but systematic correlations in functional connectivity MRI networks arise from subject motion. NeuroImage, 59(3),
2142-2154. doi:10.1016/j.neuroimage.2011.10.018
.. [2] Power, J. D., Barnes, K. A., Snyder, A. Z., Schlaggar, B. L., & Petersen, S. E. (2012). Steps
toward optimizing motion artifact removal in functional connectivity MRI; a reply to Carp.
NeuroImage. doi:10.1016/j.neuroimage.2012.03.017
.. [3] Jenkinson, M., Bannister, P., Brady, M., Smith, S., 2002. Improved optimization for the robust
and accuratedef datacens_workflow(SinkTag="func_preproc", wf_name="data_censoring"):
"""
import os
import nipype
import nipype.pipeline as pe
import nipype.interfaces.utility as utility
import nipype.interfaces.io as io
import PUMI.utils.globals as globals
import PUMI.utils.QC as qc
SinkDir = os.path.abspath(globals._SinkDir_ + "/" + SinkTag)
if not os.path.exists(SinkDir):
os.makedirs(SinkDir)
# Identitiy mapping for input variables
inputspec = pe.Node(utility.IdentityInterface(fields=[
'func',
'FD',
'threshold',
]),
name='inputspec')
inputspec.inputs.threshold = 5
#TODO_ready check CPAC.generate_motion_statistics.generate_motion_statistics script. It may use the FD of Jenkinson to index volumes which violate the upper threhold limit, no matter what we set.
# - we use the power method to calculate FD
# Determine the indices of the upper part (which is defined by the threshold, deafult 5%) of values based on their FD values
calc_upprperc = pe.MapNode(utility.Function(
input_names=['in_file', 'threshold'],
output_names=[
'frames_in_idx', 'frames_out_idx', 'percentFD', 'out_file', 'nvol'
],
function=calculate_upperpercent),
iterfield=['in_file'],
name='calculate_upperpercent')
#create despiking matrix, to be included into nuisance correction
despike_matrix = pe.MapNode(utility.Function(
input_names=['frames_excluded', 'total_vols'],
output_names=['despike_mat'],
function=create_despike_regressor_matrix),
iterfield=['frames_excluded', 'total_vols'],
name='create_despike_matrix')
outputspec = pe.Node(
utility.IdentityInterface(fields=['despike_mat', 'FD']),
name='outputspec')
# save data out with Datasink
ds = pe.Node(interface=io.DataSink(), name='ds')
ds.inputs.base_directory = SinkDir
#TODO_ready: some plot for qualitiy checking
# Create workflow
analysisflow = pe.Workflow(wf_name)
###Calculating mean Framewise Displacement (FD) as Power et al., 2012
# Calculating frames to exclude and include after scrubbing
analysisflow.connect(inputspec, 'FD', calc_upprperc, 'in_file')
analysisflow.connect(inputspec, 'threshold', calc_upprperc, 'threshold')
# Create the proper format for the scrubbing procedure
analysisflow.connect(calc_upprperc, 'frames_out_idx', despike_matrix,
'frames_excluded')
analysisflow.connect(calc_upprperc, 'nvol', despike_matrix, 'total_vols')
analysisflow.connect(
calc_upprperc, 'out_file', ds,
'percentFD') # TODO save this in separet folder for QC
# Output
analysisflow.connect(despike_matrix, 'despike_mat', outputspec,
'despike_mat')
analysisflow.connect(inputspec, 'FD', outputspec, 'FD')
return analysisflow
def create_B0_workflow(name='b0_unwarping', scanner='philips'):
""" Does B0 field unwarping
Example
-------
>>> nipype_epicorrect = create_unwarping_workflow('unwarp',)
>>> unwarp.inputs.input_node.in_file = 'subj1_run1_bold.nii.gz'
>>> unwarp.inputs.input_node.fieldmap_mag = 'subj1_run1_mag.nii.gz'
>>> unwarp.inputs.input_node.fieldmap_pha = 'subj1_run1_phas.nii.gz'
>>> unwarp.inputs.input_node.wfs = 12.223
>>> unwarp.inputs.input_node.epi_factor = 35.0
>>> unwarp.inputs.input_node.acceleration = 3.0
>>> unwarp.inputs.input_node.te_diff = 0.005
>>> unwarp.inputs.input_node.phase_encoding_direction = 'y'
>>> nipype_epicorrect.run()
Inputs::
input_node.in_file - Volume acquired with EPI sequence
input_node.fieldmap_mag - Magnitude of the fieldmap
input_node.fieldmap_pha - Phase difference of the fieldmap
input_node.wfs - Water-fat-shift in pixels
input_node.epi_factor - EPI factor
input_node.acceleration - Acceleration factor used for EPI parallel imaging (SENSE)
input_node.te_diff - Time difference between TE in seconds.
input_node.phase_encoding_direction - Unwarp direction (default should be "y")
Outputs::
outputnode.epi_corrected
"""
# Nodes:
# ------
# Define input and workflow:
input_node = pe.Node(name='inputspec',
interface=IdentityInterface(fields=[
'in_files', 'fieldmap_mag', 'fieldmap_pha', 'wfs',
'epi_factor', 'acceleration', 'echo_spacing',
'te_diff', 'phase_encoding_direction'
]))
# Normalize phase difference of the fieldmap phase to be [-pi, pi)
norm_pha = pe.Node(interface=Prepare_phasediff, name='normalize_phasediff')
# Mask the magnitude of the fieldmap
mask_mag = pe.Node(fsl.BET(mask=True), name='mask_magnitude')
mask_mag_dil = pe.Node(interface=Dilate_mask, name='mask_dilate')
# Unwrap fieldmap phase using FSL PRELUDE
prelude = pe.Node(fsl.PRELUDE(process3d=True), name='phase_unwrap')
# Convert unwrapped fieldmap phase to radials per second:
radials_per_second = pe.Node(interface=Radials_per_second,
name='radials_ps')
# in case of SIEMENS scanner:
prepare_fieldmap = pe.Node(PrepareFieldmap(), name='prepare_fieldmap')
# Register unwrapped fieldmap (rad/s) to epi, using the magnitude of the fieldmap
registration = pe.MapNode(fsl.FLIRT(bins=256,
cost='corratio',
dof=6,
interp='trilinear',
searchr_x=[-10, 10],
searchr_y=[-10, 10],
searchr_z=[-10, 10]),
iterfield=['reference'],
name='registration')
# transform unwrapped fieldmap (rad/s)
applyxfm = pe.MapNode(fsl.ApplyXFM(interp='trilinear'),
iterfield=['reference', 'in_matrix_file'],
name='apply_xfm')
# compute effective echospacing:
echo_spacing_philips = pe.Node(interface=Compute_echo_spacing_philips,
name='echo_spacing_philips')
echo_spacing_siemens = pe.Node(interface=Compute_echo_spacing_siemens,
name='echo_spacing_siemens')
te_diff_in_ms = pe.Node(interface=TE_diff_ms, name='te_diff_in_ms')
# Unwarp with FSL Fugue
fugue = pe.MapNode(interface=fsl.FUGUE(median_2dfilter=True),
iterfield=['in_file', 'unwarped_file', 'fmap_in_file'],
name='fugue')
# Convert unwrapped fieldmap phase to radials per second:
out_file = pe.MapNode(interface=Make_output_filename,
iterfield=['in_file'],
name='out_file')
# Define output node
outputnode = pe.Node(
IdentityInterface(fields=['out_files', 'field_coefs']),
name='outputspec')
# Workflow:
# ---------
unwarp_workflow = pe.Workflow(name=name)
unwarp_workflow.connect(input_node, 'in_files', out_file, 'in_file')
# registration:
unwarp_workflow.connect(input_node, 'fieldmap_mag', mask_mag, 'in_file')
unwarp_workflow.connect(mask_mag, 'mask_file', mask_mag_dil, 'in_file')
unwarp_workflow.connect(mask_mag, 'out_file', registration, 'in_file')
unwarp_workflow.connect(input_node, 'in_files', registration, 'reference')
if scanner == 'philips':
# prepare fieldmap:
unwarp_workflow.connect(input_node, 'fieldmap_pha', norm_pha,
'in_file')
unwarp_workflow.connect(input_node, 'fieldmap_mag', prelude,
'magnitude_file')
unwarp_workflow.connect(norm_pha, 'out_file', prelude, 'phase_file')
unwarp_workflow.connect(mask_mag_dil, 'out_file', prelude, 'mask_file')
unwarp_workflow.connect(prelude, 'unwrapped_phase_file',
radials_per_second, 'in_file')
unwarp_workflow.connect(input_node, 'te_diff', radials_per_second,
'asym')
# transform fieldmap:
unwarp_workflow.connect(radials_per_second, 'out_file', applyxfm,
'in_file')
unwarp_workflow.connect(registration, 'out_matrix_file', applyxfm,
'in_matrix_file')
unwarp_workflow.connect(input_node, 'in_files', applyxfm, 'reference')
# compute echo spacing:
unwarp_workflow.connect(input_node, 'wfs', echo_spacing_philips, 'wfs')
unwarp_workflow.connect(input_node, 'epi_factor', echo_spacing_philips,
'epi_factor')
unwarp_workflow.connect(input_node, 'acceleration',
echo_spacing_philips, 'acceleration')
unwarp_workflow.connect(echo_spacing_philips, 'echo_spacing', fugue,
'dwell_time')
elif scanner == 'siemens':
unwarp_workflow.connect(input_node, 'te_diff', te_diff_in_ms,
'te_diff')
# prepare fieldmap:
unwarp_workflow.connect(mask_mag, 'out_file', prepare_fieldmap,
'in_magnitude')
unwarp_workflow.connect(input_node, 'fieldmap_pha', prepare_fieldmap,
'in_phase')
unwarp_workflow.connect(te_diff_in_ms, 'te_diff', prepare_fieldmap,
'delta_TE')
# transform fieldmap:
unwarp_workflow.connect(prepare_fieldmap, 'out_fieldmap', applyxfm,
'in_file')
unwarp_workflow.connect(registration, 'out_matrix_file', applyxfm,
'in_matrix_file')
unwarp_workflow.connect(input_node, 'in_files', applyxfm, 'reference')
# compute echo spacing:
unwarp_workflow.connect(input_node, 'acceleration',
echo_spacing_siemens, 'acceleration')
unwarp_workflow.connect(input_node, 'echo_spacing',
echo_spacing_siemens, 'echo_spacing')
unwarp_workflow.connect(echo_spacing_siemens, 'echo_spacing', fugue,
'dwell_time')
unwarp_workflow.connect(input_node, 'in_files', fugue, 'in_file')
unwarp_workflow.connect(out_file, 'out_file', fugue, 'unwarped_file')
unwarp_workflow.connect(applyxfm, 'out_file', fugue, 'fmap_in_file')
unwarp_workflow.connect(input_node, 'te_diff', fugue, 'asym_se_time')
unwarp_workflow.connect(input_node, 'phase_encoding_direction', fugue,
'unwarp_direction')
unwarp_workflow.connect(fugue, 'unwarped_file', outputnode, 'out_files')
unwarp_workflow.connect(applyxfm, 'out_file', outputnode, 'field_coefs')
# # Connect
# unwarp_workflow.connect(input_node, 'in_files', out_file, 'in_file')
# unwarp_workflow.connect(input_node, 'fieldmap_pha', norm_pha, 'in_file')
# unwarp_workflow.connect(input_node, 'fieldmap_mag', mask_mag, 'in_file')
# unwarp_workflow.connect(mask_mag, 'mask_file', mask_mag_dil, 'in_file')
# unwarp_workflow.connect(input_node, 'fieldmap_mag', prelude, 'magnitude_file')
# unwarp_workflow.connect(norm_pha, 'out_file', prelude, 'phase_file')
# unwarp_workflow.connect(mask_mag_dil, 'out_file', prelude, 'mask_file')
# unwarp_workflow.connect(prelude, 'unwrapped_phase_file', radials_per_second, 'in_file')
# unwarp_workflow.connect(input_node, 'te_diff', radials_per_second, 'asym')
# unwarp_workflow.connect(mask_mag, 'out_file', registration, 'in_file')
# unwarp_workflow.connect(input_node, 'in_files', registration, 'reference')
# unwarp_workflow.connect(radials_per_second, 'out_file', applyxfm, 'in_file')
# unwarp_workflow.connect(registration, 'out_matrix_file', applyxfm, 'in_matrix_file')
# unwarp_workflow.connect(input_node, 'in_files', applyxfm, 'reference')
# if compute_echo_spacing:
# unwarp_workflow.connect(input_node, 'wfs', echo_spacing, 'wfs')
# unwarp_workflow.connect(input_node, 'epi_factor', echo_spacing, 'epi_factor')
# unwarp_workflow.connect(input_node, 'acceleration', echo_spacing, 'acceleration')
# unwarp_workflow.connect(echo_spacing, 'echo_spacing', fugue, 'dwell_time')
# else:
# unwarp_workflow.connect(input_node, 'echo_spacing', fugue, 'dwell_time')
# unwarp_workflow.connect(input_node, 'in_files', fugue, 'in_file')
# unwarp_workflow.connect(out_file, 'out_file', fugue, 'unwarped_file')
# unwarp_workflow.connect(applyxfm, 'out_file', fugue, 'fmap_in_file')
# unwarp_workflow.connect(input_node, 'te_diff', fugue, 'asym_se_time')
# unwarp_workflow.connect(input_node, 'phase_encoding_direction', fugue, 'unwarp_direction')
# unwarp_workflow.connect(fugue, 'unwarped_file', outputnode, 'out_files')
# unwarp_workflow.connect(applyxfm, 'out_file', outputnode, 'field_coefs')
return unwarp_workflow
def create_pupil_workflow(analysis_info, name='pupil'):
import nipype.pipeline as pe
from nipype.interfaces.utility import Function, Merge, IdentityInterface
from nipype.interfaces.io import SelectFiles, DataSink
from utils.pupil import fit_FIR_pupil_files
imports = [
'from utils.behavior import behavior_timing',
'from utils.plotting import plot_fir_results_unpredictable',
'from utils.plotting import plot_fir_results_predictable',
'from utils.plotting import plot_fir_results_variable',
]
input_node = pe.Node(
IdentityInterface(fields=['preprocessed_directory', 'sub_id']),
name='inputspec')
# i/o node
datasource_templates = dict(
all_roi_file='{sub_id}/h5/roi.h5',
# predictable reward experiment needs behavior files and moco but no physio
predictable_in_files='{sub_id}/psc/*-predictable_reward_*.nii.gz',
predictable_behavior_tsv_files=
'{sub_id}/events/tsv/*-predictable_reward_*.tsv',
predictable_eye_h5_files='{sub_id}/eye/h5/*-predictable_reward_*.h5',
# unpredictable reward experiment needs behavior files, moco and physio
unpredictable_in_files='{sub_id}/psc/*-unpredictable_reward_*.nii.gz',
unpredictable_behavior_tsv_files=
'{sub_id}/events/tsv/*-unpredictable_reward_*.tsv',
unpredictable_eye_h5_files=
'{sub_id}/eye/h5/*-unpredictable_reward_*.h5',
# variable reward experiment needs behavior files, moco and physio
variable_in_files='{sub_id}/psc/*-variable_*_reward_*.nii.gz',
variable_behavior_tsv_files=
'{sub_id}/events/tsv/*-variable_*_reward_*.tsv',
variable_eye_h5_files='{sub_id}/eye/h5/*-variable_*_reward_*.h5',
)
datasource = pe.Node(SelectFiles(datasource_templates,
sort_filelist=True,
raise_on_empty=False),
name='datasource')
predictable_pupil_FIR = pe.Node(Function(input_names=[
'experiment', 'eye_h5_file_list', 'behavior_file_list', 'h5_file',
'in_files', 'fir_frequency', 'fir_interval', 'data_type',
'lost_signal_rate_threshold'
],
output_names=['out_figures'],
function=fit_FIR_pupil_files,
imports=imports),
name='predictable_pupil_FIR')
predictable_pupil_FIR.inputs.fir_frequency = analysis_info[
'pupil_fir_frequency']
predictable_pupil_FIR.inputs.fir_interval = analysis_info[
'pupil_fir_interval']
predictable_pupil_FIR.inputs.experiment = 'predictable'
predictable_pupil_FIR.inputs.data_type = analysis_info['pupil_data_type']
predictable_pupil_FIR.inputs.lost_signal_rate_threshold = analysis_info[
'pupil_lost_signal_rate_threshold']
unpredictable_pupil_FIR = pe.Node(Function(input_names=[
'experiment', 'eye_h5_file_list', 'behavior_file_list', 'h5_file',
'in_files', 'fir_frequency', 'fir_interval', 'data_type',
'lost_signal_rate_threshold'
],
output_names=['out_figures'],
function=fit_FIR_pupil_files,
imports=imports),
name='unpredictable_pupil_FIR')
unpredictable_pupil_FIR.inputs.fir_frequency = analysis_info[
'pupil_fir_frequency']
unpredictable_pupil_FIR.inputs.fir_interval = analysis_info[
'pupil_fir_interval']
unpredictable_pupil_FIR.inputs.experiment = 'unpredictable'
unpredictable_pupil_FIR.inputs.data_type = analysis_info['pupil_data_type']
unpredictable_pupil_FIR.inputs.lost_signal_rate_threshold = analysis_info[
'pupil_lost_signal_rate_threshold']
variable_pupil_FIR = pe.Node(Function(input_names=[
'experiment', 'eye_h5_file_list', 'behavior_file_list', 'h5_file',
'in_files', 'fir_frequency', 'fir_interval', 'data_type',
'lost_signal_rate_threshold'
],
output_names=['out_figures'],
function=fit_FIR_pupil_files,
imports=imports),
name='variable_pupil_FIR')
variable_pupil_FIR.inputs.fir_frequency = analysis_info[
'pupil_fir_frequency']
variable_pupil_FIR.inputs.fir_interval = analysis_info[
'pupil_fir_interval']
variable_pupil_FIR.inputs.experiment = 'variable'
variable_pupil_FIR.inputs.data_type = analysis_info['pupil_data_type']
variable_pupil_FIR.inputs.lost_signal_rate_threshold = analysis_info[
'pupil_lost_signal_rate_threshold']
# the actual top-level workflow
pupil_analysis_workflow = pe.Workflow(name=name)
pupil_analysis_workflow.connect(input_node, 'preprocessed_directory',
datasource, 'base_directory')
pupil_analysis_workflow.connect(input_node, 'sub_id', datasource, 'sub_id')
# variable reward pupil FIR
pupil_analysis_workflow.connect(datasource, 'variable_eye_h5_files',
variable_pupil_FIR, 'eye_h5_file_list')
pupil_analysis_workflow.connect(datasource, 'variable_behavior_tsv_files',
variable_pupil_FIR, 'behavior_file_list')
pupil_analysis_workflow.connect(datasource, 'all_roi_file',
variable_pupil_FIR, 'h5_file')
pupil_analysis_workflow.connect(datasource, 'variable_in_files',
variable_pupil_FIR, 'in_files')
# predictable reward pupil FIR
pupil_analysis_workflow.connect(datasource, 'predictable_eye_h5_files',
predictable_pupil_FIR, 'eye_h5_file_list')
pupil_analysis_workflow.connect(datasource,
'predictable_behavior_tsv_files',
predictable_pupil_FIR,
'behavior_file_list')
pupil_analysis_workflow.connect(datasource, 'all_roi_file',
predictable_pupil_FIR, 'h5_file')
pupil_analysis_workflow.connect(datasource, 'predictable_in_files',
predictable_pupil_FIR, 'in_files')
# unpredictable reward pupil FIR
pupil_analysis_workflow.connect(datasource, 'unpredictable_eye_h5_files',
unpredictable_pupil_FIR,
'eye_h5_file_list')
pupil_analysis_workflow.connect(datasource,
'unpredictable_behavior_tsv_files',
unpredictable_pupil_FIR,
'behavior_file_list')
pupil_analysis_workflow.connect(datasource, 'all_roi_file',
unpredictable_pupil_FIR, 'h5_file')
pupil_analysis_workflow.connect(datasource, 'unpredictable_in_files',
unpredictable_pupil_FIR, 'in_files')
# datasink
datasink = pe.Node(DataSink(), name='sinker')
datasink.inputs.parameterization = False
pupil_analysis_workflow.connect(input_node, 'preprocessed_directory',
datasink, 'base_directory')
pupil_analysis_workflow.connect(input_node, 'sub_id', datasink,
'container')
pupil_analysis_workflow.connect(unpredictable_pupil_FIR, 'out_figures',
datasink, 'pupil.@unpredictable_pupil_FIR')
pupil_analysis_workflow.connect(predictable_pupil_FIR, 'out_figures',
datasink, 'pupil.@predictable_pupil_FIR')
pupil_analysis_workflow.connect(variable_pupil_FIR, 'out_figures',
datasink, 'pupil.@variable_pupil_FIR')
return pupil_analysis_workflow
def datacens_workflow_threshold(SinkTag="func_preproc",
wf_name="data_censoring",
ex_before=1,
ex_after=2):
"""
Modified version of CPAC.scrubbing.scrubbing +
CPAC.generate_motion_statistics.generate_motion_statistics +
CPAC.func_preproc.func_preproc
`source: https://fcp-indi.github.io/docs/developer/_modules/CPAC/scrubbing/scrubbing.html`
`source: https://fcp-indi.github.io/docs/developer/_modules/CPAC/generate_motion_statistics/generate_motion_statistics.html`
`source: https://fcp-indi.github.io/docs/developer/_modules/CPAC/func_preproc/func_preproc.html`
Description:
Do the data censoring on the 4D functional data. First, it calculates the framewise displacement according to Power's method. Second, it
indexes the volumes which FD is in the upper part in percent(determined by the threshold variable which is 5% by default). Thirdly, it excludes those volumes and one volume
before and 2 volumes after the indexed volume. The workflow returns a 4D scrubbed functional data.
Workflow inputs:
:param func: The reoriented,motion occrected, nuissance removed and bandpass filtered functional file.
:param FD: the frame wise displacement calculated by the MotionCorrecter.py script
:param threshold: threshold of FD volumes which should be excluded
:param SinkDir:
:param SinkTag: The output directory in which the returned images (see workflow outputs) could be found in a subdirectory directory specific for this workflow..
Workflow outputs:
:return: datacens_workflow - workflow
Balint Kincses
[email protected]
2018
References
----------
.. [1] Power, J. D., Barnes, K. A., Snyder, A. Z., Schlaggar, B. L., & Petersen, S. E. (2012). Spurious
but systematic correlations in functional connectivity MRI networks arise from subject motion. NeuroImage, 59(3),
2142-2154. doi:10.1016/j.neuroimage.2011.10.018
.. [2] Power, J. D., Barnes, K. A., Snyder, A. Z., Schlaggar, B. L., & Petersen, S. E. (2012). Steps
toward optimizing motion artifact removal in functional connectivity MRI; a reply to Carp.
NeuroImage. doi:10.1016/j.neuroimage.2012.03.017
.. [3] Jenkinson, M., Bannister, P., Brady, M., Smith, S., 2002. Improved optimization for the robust
and accurate linear registration and motion correction of brain images. Neuroimage 17, 825-841.
"""
import os
import nipype
import nipype.pipeline as pe
import nipype.interfaces.utility as utility
import nipype.interfaces.io as io
import PUMI.utils.utils_convert as utils_convert
import PUMI.utils.globals as globals
import PUMI.utils.QC as qc
SinkDir = os.path.abspath(globals._SinkDir_ + "/" + SinkTag)
if not os.path.exists(SinkDir):
os.makedirs(SinkDir)
# Identitiy mapping for input variables
inputspec = pe.Node(
utility.IdentityInterface(fields=['func', 'FD', 'threshold']),
name='inputspec')
inputspec.inputs.threshold = 0.2 #mm
#TODO_ready check CPAC.generate_motion_statistics.generate_motion_statistics script. It may use the FD of Jenkinson to index volumes which violate the upper threhold limit, no matter what we set.
# - we use the power method to calculate FD
above_thr = pe.MapNode(utility.Function(
input_names=['in_file', 'threshold', 'frames_before', 'frames_after'],
output_names=[
'frames_in_idx', 'frames_out_idx', 'percentFD',
'percent_scrubbed_file', 'fd_scrubbed_file', 'nvol'
],
function=above_threshold),
iterfield=['in_file'],
name='above_threshold')
above_thr.inputs.frames_before = ex_before
above_thr.inputs.frames_after = ex_after
# Save outputs which are important
ds_fd_scrub = pe.Node(interface=io.DataSink(), name='ds_fd_scrub')
ds_fd_scrub.inputs.base_directory = SinkDir
ds_fd_scrub.inputs.regexp_substitutions = [("(\/)[^\/]*$",
"FD_scrubbed.csv")]
pop_perc_scrub = pe.Node(interface=utils_convert.List2TxtFileOpen,
name='pop_perc_scrub')
# save data out with Datasink
ds_pop_perc_scrub = pe.Node(interface=io.DataSink(),
name='ds_pop_perc_scrub')
ds_pop_perc_scrub.inputs.regexp_substitutions = [
("(\/)[^\/]*$", "pop_percent_scrubbed.txt")
]
ds_pop_perc_scrub.inputs.base_directory = SinkDir
# Generate the weird input for the scrubbing procedure which is done in afni
craft_scrub_input = pe.MapNode(
utility.Function(input_names=['scrub_input', 'frames_in_1D_file'],
output_names=['scrub_input_string'],
function=get_indx),
iterfield=['scrub_input', 'frames_in_1D_file'],
name='scrubbing_craft_input_string')
# Scrub the image
scrubbed_preprocessed = pe.MapNode(utility.Function(
input_names=['scrub_input'],
output_names=['scrubbed_image'],
function=scrub_image),
iterfield=['scrub_input'],
name='scrubbed_preprocessed')
myqc = qc.timecourse2png("timeseries", tag="040_censored")
outputspec = pe.Node(
utility.IdentityInterface(fields=['scrubbed_image', 'FD_scrubbed']),
name='outputspec')
# save data out with Datasink
ds = pe.Node(interface=io.DataSink(), name='ds')
ds.inputs.base_directory = SinkDir
#TODO_ready: some plot for qualitiy checking
# Create workflow
analysisflow = pe.Workflow(wf_name)
###Calculating mean Framewise Displacement (FD) as Power et al., 2012
# Calculating frames to exclude and include after scrubbing
analysisflow.connect(inputspec, 'FD', above_thr, 'in_file')
analysisflow.connect(inputspec, 'threshold', above_thr, 'threshold')
# Create the proper format for the scrubbing procedure
analysisflow.connect(above_thr, 'frames_in_idx', craft_scrub_input,
'frames_in_1D_file')
analysisflow.connect(
above_thr, 'percent_scrubbed_file', ds,
'percentFD') # TODO save this in separate folder for QC
analysisflow.connect(inputspec, 'func', craft_scrub_input, 'scrub_input')
# Do the scubbing
analysisflow.connect(craft_scrub_input, 'scrub_input_string',
scrubbed_preprocessed, 'scrub_input')
# Output
analysisflow.connect(scrubbed_preprocessed, 'scrubbed_image', outputspec,
'scrubbed_image')
analysisflow.connect(above_thr, 'fd_scrubbed_file', outputspec,
'FD_scrubbed') #TODO_ready: scrub FD file, as well
analysisflow.connect(above_thr, 'fd_scrubbed_file', ds_fd_scrub,
'FD_scrubbed')
analysisflow.connect(above_thr, 'percent_scrubbed_file', pop_perc_scrub,
'in_list')
analysisflow.connect(pop_perc_scrub, 'txt_file', ds_pop_perc_scrub, 'pop')
# Save a few files
analysisflow.connect(scrubbed_preprocessed, 'scrubbed_image', ds,
'scrubbed_image')
#analysisflow.connect(above_thr, 'percentFD', ds, 'scrubbed_image.@numberofvols')
analysisflow.connect(scrubbed_preprocessed, 'scrubbed_image', myqc,
'inputspec.func')
return analysisflow
def aroma_workflow(fwhm=0, # in mm
SinkTag = "func_preproc", wf_name="ICA_AROMA"):
"""
ICA AROMA method embedded into PUMI
https://github.com/rhr-pruim/ICA-AROMA
function input: fwhm: smoothing FWHM in mm. fwhm=0 means no smoothing
Workflow inputs:
:param mc_func: The reoriented and motion-corrected functional file.
:param mc_params: motion parameters file from mcflirt
:param SinkDir:
:param SinkTag: The output directory in which the returned images (see workflow outputs) could be found in a subdirectory directory specific for this workflow..
Workflow outputs:
:return: aroma_workflow - workflow
Tamas Spisak
[email protected]
2018
"""
from nipype.interfaces.fsl import ICA_AROMA
import nipype.pipeline as pe
from nipype.interfaces import utility
import nipype.interfaces.io as io
import PUMI.utils.QC as qc
from nipype.interfaces.fsl import Smooth
import os
import PUMI.utils.globals as globals
SinkDir = os.path.abspath(globals._SinkDir_ + "/" + SinkTag)
if not os.path.exists(SinkDir):
os.makedirs(SinkDir)
# Define inputs of the workflow
inputspec = pe.Node(utility.IdentityInterface(fields=['mc_func',
'mc_par',
'fnirt_warp_file',
'mat_file',
'mask',
'qc_mask'
]),
name='inputspec')
# build the actual pipeline
if fwhm != 0:
smoother = pe.MapNode(interface=Smooth(fwhm=fwhm),
iterfield=['in_file'],
name="smoother")
myqc_before = qc.timecourse2png("timeseries", tag="1_original")
aroma = pe.MapNode(interface=ICA_AROMA(denoise_type='both'),
iterfield=['in_file',
'motion_parameters',
'mat_file',
'fnirt_warp_file',
'mask'],
name="ICA_AROMA")
aroma.inputs.denoise_type = 'both'
aroma.inputs.out_dir = 'AROMA_out'
myqc_after_nonaggr = qc.timecourse2png("timeseries", tag="2_nonaggressive")
myqc_after_aggr = qc.timecourse2png("timeseries", tag="3_aggressive") # put these in the same QC dir
getMotICs=pe.MapNode(interface=Function(input_names=['aroma_dir'],
output_names=['motion_ICs'],
function=extract_motionICs),
iterfield=['aroma_dir'],
name="get_motion_ICs")
# Save outputs which are important
ds_nii = pe.Node(interface=io.DataSink(),
name='ds_nii')
ds_nii.inputs.base_directory = SinkDir
ds_nii.inputs.regexp_substitutions = [("(\/)[^\/]*$", ".nii.gz")]
ds_txt = pe.Node(interface=io.DataSink(),
name='ds_txt')
ds_txt.inputs.base_directory = SinkDir
ds_txt.inputs.regexp_substitutions = [("(\/)[^\/]*$", ".txt")]
# Define outputs of the workflow
outputspec = pe.Node(utility.IdentityInterface(fields=['aggr_denoised_file',
'nonaggr_denoised_file',
'motion_ICs',
'out_dir',
'fwhm']),
name='outputspec')
outputspec.inputs.fwhm = fwhm
analysisflow = pe.Workflow(name=wf_name)
if fwhm != 0:
analysisflow.connect(inputspec, 'mc_func', smoother, 'in_file')
analysisflow.connect(smoother, 'smoothed_file', aroma, 'in_file')
analysisflow.connect(smoother, 'smoothed_file', myqc_before, 'inputspec.func')
else:
analysisflow.connect(inputspec, 'mc_func', aroma, 'in_file')
analysisflow.connect(inputspec, 'mc_func', myqc_before, 'inputspec.func')
analysisflow.connect(inputspec, 'mc_par', aroma, 'motion_parameters')
analysisflow.connect(inputspec, 'mat_file', aroma, 'mat_file')
analysisflow.connect(inputspec, 'fnirt_warp_file', aroma, 'fnirt_warp_file')
analysisflow.connect(inputspec, 'mask', aroma, 'mask')
analysisflow.connect(aroma, 'out_dir', getMotICs, 'aroma_dir')
analysisflow.connect(getMotICs, 'motion_ICs', ds_txt, 'motion_ICs')
analysisflow.connect(aroma, 'aggr_denoised_file', ds_nii, 'AROMA_aggr_denoised')
analysisflow.connect(aroma, 'nonaggr_denoised_file', ds_nii, 'AROMA_nonaggr_denoised')
analysisflow.connect(inputspec, 'qc_mask', myqc_before, 'inputspec.mask')
analysisflow.connect(aroma, 'aggr_denoised_file', myqc_after_aggr, 'inputspec.func')
#analysisflow.connect(inputspec, 'qc_mask', myqc_after_aggr, 'inputspec.mask')
analysisflow.connect(aroma, 'nonaggr_denoised_file', myqc_after_nonaggr, 'inputspec.func')
#analysisflow.connect(inputspec, 'qc_mask', myqc_after_nonaggr, 'inputspec.mask')
analysisflow.connect(aroma, 'aggr_denoised_file', outputspec, 'aggr_denoised_file')
analysisflow.connect(aroma, 'nonaggr_denoised_file', outputspec, 'nonaggr_denoised_file')
analysisflow.connect(aroma, 'out_dir', outputspec, 'out_dir')
analysisflow.connect(getMotICs, 'motion_ICs', outputspec, 'motion_ICs')
return analysisflow
def create_epi_to_T1_workflow(name='epi_to_T1', use_FS=True, do_FAST=True):
"""Registers session's EPI space to subject's T1 space
uses either FLIRT or, when a FS segmentation is present, BBRegister
Requires fsl and freesurfer tools
Parameters
----------
name : string
name of workflow
use_FS : bool
whether to use freesurfer's segmentation and BBRegister
Example
-------
>>> epi_to_T1 = create_epi_to_T1_workflow('epi_to_T1', use_FS = True)
>>> epi_to_T1.inputs.inputspec.EPI_space_file = 'example_Func.nii.gz'
>>> epi_to_T1.inputs.inputspec.T1_file = 'T1.nii.gz'
>>> epi_to_T1.inputs.inputspec.freesurfer_subject_ID = 'sub_01'
>>> epi_to_T1.inputs.inputspec.freesurfer_subject_dir = '$SUBJECTS_DIR'
Inputs::
inputspec.T1_file : T1 anatomy file
inputspec.EPI_space_file : EPI session file
inputspec.freesurfer_subject_ID : FS subject ID
inputspec.freesurfer_subject_dir : $SUBJECTS_DIR
Outputs::
outputspec.EPI_T1_register_file : BBRegister registration file that maps EPI space to T1
outputspec.EPI_T1_matrix_file : FLIRT registration file that maps EPI space to T1
outputspec.T1_EPI_matrix_file : FLIRT registration file that maps T1 space to EPI
"""
input_node = pe.Node(IdentityInterface(fields=[
'EPI_space_file', 'output_directory', 'freesurfer_subject_ID',
'freesurfer_subject_dir', 'T1_file'
]),
name='inputspec')
# Idea: also output FAST outputs for later use?
output_node = pe.Node(IdentityInterface(fields=('EPI_T1_matrix_file',
'T1_EPI_matrix_file',
'EPI_T1_register_file')),
name='outputspec')
epi_to_T1_workflow = pe.Workflow(name=name)
if use_FS: # do BBRegister
bbregister_N = pe.Node(freesurfer.BBRegister(init='fsl',
contrast_type='t2',
out_fsl_file=True),
name='bbregister_N')
epi_to_T1_workflow.connect(input_node, 'EPI_space_file', bbregister_N,
'source_file')
epi_to_T1_workflow.connect(input_node, 'freesurfer_subject_ID',
bbregister_N, 'subject_id')
epi_to_T1_workflow.connect(input_node, 'freesurfer_subject_dir',
bbregister_N, 'subjects_dir')
epi_to_T1_workflow.connect(bbregister_N, 'out_fsl_file', output_node,
'EPI_T1_matrix_file')
epi_to_T1_workflow.connect(bbregister_N, 'out_reg_file', output_node,
'EPI_T1_register_file')
# the final invert node
invert_EPI_N = pe.Node(fsl.ConvertXFM(invert_xfm=True),
name='invert_EPI_N')
epi_to_T1_workflow.connect(bbregister_N, 'out_fsl_file', invert_EPI_N,
'in_file')
epi_to_T1_workflow.connect(invert_EPI_N, 'out_file', output_node,
'T1_EPI_matrix_file')
else: # do FAST + FLIRT
flirt_e2t = pe.Node(fsl.FLIRT(cost_func='bbr',
output_type='NIFTI_GZ',
dof=12,
interp='sinc'),
name='flirt_e2t')
epi_to_T1_workflow.connect(input_node, 'EPI_space_file', flirt_e2t,
'in_file')
if do_FAST:
fast = pe.Node(fsl.FAST(no_pve=True, img_type=1, segments=True),
name='fast')
epi_to_T1_workflow.connect(input_node, 'T1_file', fast, 'in_files')
epi_to_T1_workflow.connect(fast, ('tissue_class_files', pick_last),
flirt_e2t, 'wm_seg')
elif not do_FAST and flirt_e2t.inputs.cost_func == 'bbr':
print(
'You indicated not wanting to do FAST, but still wanting to do a'
' BBR epi-to-T1 registration. That is probably not going to work ...'
)
epi_to_T1_workflow.connect(input_node, 'T1_file', flirt_e2t,
'reference')
epi_to_T1_workflow.connect(flirt_e2t, 'out_matrix_file', output_node,
'EPI_T1_matrix_file')
# the final invert node
invert_EPI_N = pe.Node(fsl.ConvertXFM(invert_xfm=True),
name='invert_EPI_N')
epi_to_T1_workflow.connect(flirt_e2t, 'out_matrix_file', invert_EPI_N,
'in_file')
epi_to_T1_workflow.connect(invert_EPI_N, 'out_file', output_node,
'T1_EPI_matrix_file')
return epi_to_T1_workflow
def create_whole_brain_GLM_workflow(analysis_info, name='GLM'):
import nipype.pipeline as pe
from nipype.interfaces.utility import Function, Merge, IdentityInterface
from nipype.interfaces.io import SelectFiles, DataSink
from utils.GLM import fit_glm_nuisances_single_file, fit_FIR_nuisances_all_files
imports = ['from utils.behavior import behavior_timing']
input_node = pe.Node(
IdentityInterface(fields=['preprocessed_directory', 'sub_id']),
name='inputspec')
# i/o node
datasource_templates = dict(
example_func='{sub_id}/reg/example_func.nii.gz',
# predictable experiment has no physiology
predictable_mapper_in_file=
'{sub_id}/psc/*-predictable_mapper_1_*.nii.gz',
predictable_mapper_tsv_file=
'{sub_id}/events/tsv/*-predictable_mapper_1_*.tsv',
predictable_mapper_mcf_par=
'{sub_id}/mcf/ext_motion_pars/*-predictable_mapper_1_*.par',
# predictable reward experiment needs behavior files and moco but no physio
predictable_in_files='{sub_id}/psc/*-predictable_reward_*.nii.gz',
predictable_behavior_tsv_file=
'{sub_id}/events/tsv/*-predictable_reward_*.tsv',
predictable_mcf_pars=
'{sub_id}/mcf/ext_motion_pars/*-predictable_reward_*.par',
# unpredictable experiment has physiology but no behavior because: block design
unpredictable_mapper_in_file=
'{sub_id}/psc/*-unpredictable_mapper_1_*.nii.gz',
unpredictable_mapper_physio_files=
'{sub_id}/phys/evs/*-unpredictable_mapper_1_*.nii.gz',
unpredictable_mapper_mcf_par=
'{sub_id}/mcf/ext_motion_pars/*-unpredictable_mapper_1_*.par',
# unpredictable reward experiment needs behavior files, moco and physio
unpredictable_in_files='{sub_id}/psc/*-unpredictable_reward_*.nii.gz',
unpredictable_behavior_tsv_file=
'{sub_id}/events/tsv/*-unpredictable_reward_*.tsv',
unpredictable_physio_files=
'{sub_id}/phys/evs/*-unpredictable_reward_*.nii.gz',
unpredictable_mcf_pars=
'{sub_id}/mcf/ext_motion_pars/*-unpredictable_reward_*.par',
# variable reward experiment needs behavior files, moco and physio
variable_in_files='{sub_id}/psc/*-variable_*_reward_*.nii.gz',
variable_behavior_tsv_file=
'{sub_id}/events/tsv/*-variable_*_reward_*.tsv',
variable_physio_files='{sub_id}/phys/evs/*-variable_*_reward_*.nii.gz',
variable_mcf_pars=
'{sub_id}/mcf/ext_motion_pars/*-variable_*_reward_*.par')
datasource = pe.Node(SelectFiles(datasource_templates,
sort_filelist=True,
raise_on_empty=False),
name='datasource')
unpredictable_split_phys_list = pe.Node(
Function(input_names=['slice_regressor_list', 'in_files'],
output_names=['slice_regressor_lists'],
function=sublists_for_phys),
name='unpredictable_split_phys_list')
variable_split_phys_list = pe.Node(Function(
input_names=['slice_regressor_list', 'in_files'],
output_names=['slice_regressor_lists'],
function=sublists_for_phys),
name='variable_split_phys_list')
unpredictable_GLM = pe.Node(Function(
input_names=[
'in_file', 'slice_regressor_list', 'vol_regressors',
'num_components', 'method', 'mapper', 'dm_upscale_factor',
'tsv_behavior_file'
],
output_names=['out_files'],
function=fit_glm_nuisances_single_file),
name='unpredictable_GLM')
unpredictable_GLM.inputs.mapper = 'unpredictable'
unpredictable_GLM.inputs.num_components = 6
unpredictable_GLM.inputs.method = 'PCA'
unpredictable_GLM.inputs.dm_upscale_factor = 10
predictable_GLM = pe.Node(Function(input_names=[
'in_file', 'slice_regressor_list', 'vol_regressors', 'num_components',
'method', 'mapper', 'dm_upscale_factor', 'tsv_behavior_file'
],
output_names=['out_files'],
function=fit_glm_nuisances_single_file),
name='predictable_GLM')
predictable_GLM.inputs.mapper = 'predictable'
predictable_GLM.inputs.num_components = 4 # no physio, just motion correction nuisances
predictable_GLM.inputs.method = 'PCA'
predictable_GLM.inputs.dm_upscale_factor = 10
unpredictable_FIR = pe.Node(
Function(input_names=[
'experiment', 'example_func', 'in_files', 'slice_regressor_lists',
'vol_regressor_list', 'behavior_file_list', 'fir_frequency',
'fir_interval', 'num_components', 'method'
],
output_names=['out_files'],
function=fit_FIR_nuisances_all_files,
imports=imports),
name='unpredictable_FIR',
)
unpredictable_FIR.inputs.fir_frequency = analysis_info['fir_frequency']
unpredictable_FIR.inputs.fir_interval = analysis_info['fir_interval']
unpredictable_FIR.inputs.num_components = 6
unpredictable_FIR.inputs.method = 'PCA'
unpredictable_FIR.inputs.experiment = 'unpredictable'
predictable_FIR = pe.Node(Function(input_names=[
'experiment', 'example_func', 'in_files', 'slice_regressor_lists',
'vol_regressor_list', 'behavior_file_list', 'fir_frequency',
'fir_interval', 'num_components', 'method'
],
output_names=['out_files'],
function=fit_FIR_nuisances_all_files,
imports=imports),
name='predictable_FIR')
predictable_FIR.inputs.fir_frequency = analysis_info['fir_frequency']
predictable_FIR.inputs.fir_interval = analysis_info['fir_interval']
predictable_FIR.inputs.num_components = 6
predictable_FIR.inputs.method = 'PCA'
predictable_FIR.inputs.experiment = 'predictable'
predictable_FIR.inputs.slice_regressor_lists = [[]] # no physio regressors
variable_FIR = pe.Node(Function(input_names=[
'experiment', 'example_func', 'in_files', 'slice_regressor_lists',
'vol_regressor_list', 'behavior_file_list', 'fir_frequency',
'fir_interval', 'num_components', 'method'
],
output_names=['out_files'],
function=fit_FIR_nuisances_all_files,
imports=imports),
name='variable_FIR')
variable_FIR.inputs.fir_frequency = analysis_info['fir_frequency']
variable_FIR.inputs.fir_interval = analysis_info['fir_interval']
variable_FIR.inputs.num_components = 6
variable_FIR.inputs.method = 'PCA'
variable_FIR.inputs.experiment = 'variable'
# the actual top-level workflow
whole_brain_analysis_workflow = pe.Workflow(name=name)
whole_brain_analysis_workflow.connect(input_node, 'preprocessed_directory',
datasource, 'base_directory')
whole_brain_analysis_workflow.connect(input_node, 'sub_id', datasource,
'sub_id')
# predictable mapper GLM
whole_brain_analysis_workflow.connect(datasource,
'predictable_mapper_in_file',
predictable_GLM, 'in_file')
whole_brain_analysis_workflow.connect(datasource,
'predictable_mapper_mcf_par',
predictable_GLM, 'vol_regressors')
whole_brain_analysis_workflow.connect(datasource,
'predictable_mapper_tsv_file',
predictable_GLM, 'tsv_behavior_file')
# predictable reward FIR
whole_brain_analysis_workflow.connect(datasource, 'predictable_in_files',
predictable_FIR, 'in_files')
whole_brain_analysis_workflow.connect(datasource, 'predictable_mcf_pars',
predictable_FIR,
'vol_regressor_list')
whole_brain_analysis_workflow.connect(datasource,
'predictable_behavior_tsv_file',
predictable_FIR,
'behavior_file_list')
whole_brain_analysis_workflow.connect(datasource, 'example_func',
predictable_FIR, 'example_func')
# unpredictable mapper GLM
whole_brain_analysis_workflow.connect(datasource,
'unpredictable_mapper_in_file',
unpredictable_GLM, 'in_file')
whole_brain_analysis_workflow.connect(datasource,
'unpredictable_mapper_mcf_par',
unpredictable_GLM, 'vol_regressors')
whole_brain_analysis_workflow.connect(datasource,
'unpredictable_mapper_physio_files',
unpredictable_GLM,
'slice_regressor_list')
# unpredictable reward FIR; first split the 1D slice regressor list to 2D
whole_brain_analysis_workflow.connect(datasource,
'unpredictable_physio_files',
unpredictable_split_phys_list,
'slice_regressor_list')
whole_brain_analysis_workflow.connect(datasource, 'unpredictable_in_files',
unpredictable_split_phys_list,
'in_files')
whole_brain_analysis_workflow.connect(unpredictable_split_phys_list,
'slice_regressor_lists',
unpredictable_FIR,
'slice_regressor_lists')
whole_brain_analysis_workflow.connect(datasource, 'unpredictable_in_files',
unpredictable_FIR, 'in_files')
whole_brain_analysis_workflow.connect(datasource, 'unpredictable_mcf_pars',
unpredictable_FIR,
'vol_regressor_list')
whole_brain_analysis_workflow.connect(datasource,
'unpredictable_behavior_tsv_file',
unpredictable_FIR,
'behavior_file_list')
whole_brain_analysis_workflow.connect(datasource, 'example_func',
unpredictable_FIR, 'example_func')
# variable reward FIR; first split the 1D slice regressor list to 2D
whole_brain_analysis_workflow.connect(datasource, 'variable_physio_files',
variable_split_phys_list,
'slice_regressor_list')
whole_brain_analysis_workflow.connect(datasource, 'variable_in_files',
variable_split_phys_list, 'in_files')
whole_brain_analysis_workflow.connect(variable_split_phys_list,
'slice_regressor_lists',
variable_FIR,
'slice_regressor_lists')
whole_brain_analysis_workflow.connect(datasource, 'variable_in_files',
variable_FIR, 'in_files')
whole_brain_analysis_workflow.connect(datasource, 'variable_mcf_pars',
variable_FIR, 'vol_regressor_list')
whole_brain_analysis_workflow.connect(datasource,
'variable_behavior_tsv_file',
variable_FIR, 'behavior_file_list')
whole_brain_analysis_workflow.connect(datasource, 'example_func',
variable_FIR, 'example_func')
# datasink
datasink = pe.Node(DataSink(), name='sinker')
datasink.inputs.parameterization = False
whole_brain_analysis_workflow.connect(input_node, 'preprocessed_directory',
datasink, 'base_directory')
whole_brain_analysis_workflow.connect(input_node, 'sub_id', datasink,
'container')
whole_brain_analysis_workflow.connect(predictable_GLM, 'out_files',
datasink, 'GLM.@predictable_GLM')
whole_brain_analysis_workflow.connect(predictable_FIR, 'out_files',
datasink, 'GLM.@predictable_FIR')
whole_brain_analysis_workflow.connect(unpredictable_GLM, 'out_files',
datasink, 'GLM.@unpredictable_GLM')
whole_brain_analysis_workflow.connect(unpredictable_FIR, 'out_files',
datasink, 'GLM.@unpredictable_FIR')
whole_brain_analysis_workflow.connect(variable_FIR, 'out_files', datasink,
'GLM.@variable_FIR')
return whole_brain_analysis_workflow
def build_netmat(SinkTag="connectivity", wf_name="build_network"):
########################################################################
# Extract timeseries
########################################################################
import nipype.pipeline as pe
import nipype.interfaces.utility as utility
from nipype.interfaces.utility import Function
import nipype.interfaces.io as io
import PUMI.utils.globals as globals
import PUMI.utils.QC as qc
import os
SinkDir = os.path.abspath(globals._SinkDir_ + "/" + SinkTag)
if not os.path.exists(SinkDir):
os.makedirs(SinkDir)
# Identitiy mapping for input variables
inputspec = pe.Node(
utility.IdentityInterface(fields=[
'timeseries', #contains labels
'modules', # optional
'measure',
'atlas' # optional, only for plotting purposes
]),
name='inputspec')
inputspec.inputs.atlas = False # default value
inputspec.inputs.measure = "partial correlation"
# This is not a map node, since it takes all the subject-level regional timseries in a list and does population-level modelling
# if measure == "tangent"
estimate_network_mtx = pe.Node(interface=Function(
input_names=['timeseries_list', 'modules', 'measure'],
output_names=['mean_mtx', 'subject_matrix_list'],
function=netmat),
name='estimate_network_mtx')
matrix_qc_mean = qc.matrixQC("group_mean_matrix", tag=wf_name + "_")
matrix_qc = qc.matrixQC("matrices", tag=wf_name)
# Save outputs which are important
ds_meanmat = pe.Node(interface=io.DataSink(), name='ds_meanmat')
ds_meanmat.inputs.base_directory = SinkDir
ds_meanmat.inputs.regexp_substitutions = [("(\/)[^\/]*$", ".tsv")]
# Save outputs which are important
ds_mat = pe.Node(interface=io.DataSink(), name='ds_mats')
ds_mat.inputs.base_directory = SinkDir
ds_mat.inputs.regexp_substitutions = [("(\/)[^\/]*$", ".tsv")]
analysisflow = pe.Workflow(wf_name)
analysisflow.connect(inputspec, 'timeseries', estimate_network_mtx,
'timeseries_list')
analysisflow.connect(inputspec, 'measure', estimate_network_mtx, 'measure')
analysisflow.connect(estimate_network_mtx, 'mean_mtx', ds_meanmat,
'mean_connectivity_mat')
analysisflow.connect(estimate_network_mtx, 'subject_matrix_list', ds_mat,
'connectivity_matrices')
analysisflow.connect(estimate_network_mtx, 'mean_mtx', matrix_qc_mean,
'inputspec.matrix_file')
analysisflow.connect(inputspec, 'modules', matrix_qc_mean,
'inputspec.modules')
analysisflow.connect(inputspec, 'atlas', matrix_qc_mean, 'inputspec.atlas')
analysisflow.connect(estimate_network_mtx, 'subject_matrix_list',
matrix_qc, 'inputspec.matrix_file')
analysisflow.connect(inputspec, 'modules', matrix_qc, 'inputspec.modules')
analysisflow.connect(inputspec, 'atlas', matrix_qc, 'inputspec.atlas')
return analysisflow
def func2mni(stdreg,
carpet_plot="",
wf_name='func2mni',
SinkTag="func_preproc"):
"""
stdreg: either globals._RegType_.ANTS or globals._RegType_.FSL (do default value to make sure the user has to decide explicitly)
Transaform 4D functional image to MNI space.
carpet_plot: string specifying the tag parameter for carpet plot of the standardized MRI measurement
(default is "": no carpet plot)
if not "", inputs atlaslabels and confounds should be defined (it might work with defaults, though)
Workflow inputs:
:param func
:param linear_reg_mtrx
:param nonlinear_reg_mtrx
:param reference_brain
:param atlas (optional)
:param confounds (optional)
:param confound_names (optional)
Workflow outputs:
:return: anat2mni_workflow - workflow
anat="/home/balint/Dokumentumok/phd/essen/PAINTER/probe/MS001/highres.nii.gz",
brain="/home/balint/Dokumentumok/phd/essen/PAINTER/probe/MS001/highres_brain.nii.gz",
Balint Kincses
[email protected]
2018
"""
import os
import nipype.pipeline as pe
import nipype.interfaces.utility as utility
import nipype.interfaces.fsl as fsl
import nipype.interfaces.fsl as fsl
import nipype.interfaces.ants as ants
from nipype.interfaces.c3 import C3dAffineTool
import PUMI.utils.globals as globals
import PUMI.func_preproc.Onevol as onevol
import PUMI.utils.QC as qc
import nipype.interfaces.io as io
from nipype.interfaces.utility import Function
SinkDir = os.path.abspath(globals._SinkDir_ + "/" + SinkTag)
if not os.path.exists(SinkDir):
os.makedirs(SinkDir)
inputspec = pe.Node(
utility.IdentityInterface(fields=[
'func',
'anat', # only obligatory if stdreg==globals._RegType_.ANTS
'linear_reg_mtrx',
'nonlinear_reg_mtrx',
'reference_brain',
'atlas',
'confounds',
'confound_names'
]),
name='inputspec')
inputspec.inputs.atlas = globals._FSLDIR_ + '/data/atlases/HarvardOxford/HarvardOxford-cort-maxprob-thr25-2mm.nii.gz'
inputspec.inputs.reference_brain = globals._FSLDIR_ + "/data/standard/MNI152_T1_3mm_brain.nii.gz" #3mm by default
# TODO: this does not work with the iterfiled definition for ref_file below:
# TODO: it should be sepcified in a function argument, whether it shopuld be iterated
#TODO_ready: ANTS
#TODO: make resampling voxel size for func parametrizable
# apply transformation martices
if stdreg == globals._RegType_.FSL:
applywarp = pe.MapNode(interface=fsl.ApplyWarp(interp="spline", ),
iterfield=['in_file', 'field_file', 'premat'],
name='applywarp')
myqc = qc.vol2png("func2mni", wf_name + "_FSL", overlayiterated=False)
myqc.inputs.slicer.image_width = 500 # 500 # for the 2mm template
myqc.inputs.slicer.threshold_edges = 0.1 # 0.1 # for the 2mm template
else: #ANTs
# source file for C3dAffineToolmust not be 4D, so we extract the one example vol
myonevol = onevol.onevol_workflow()
# concat premat and ants transform
bbr2ants = pe.MapNode(
interface=C3dAffineTool(fsl2ras=True, itk_transform=True),
iterfield=['source_file', 'transform_file',
'reference_file'], # output: 'itk_transform'
name="bbr2ants")
#concat trfs into a list
trflist = pe.MapNode(interface=Function(
input_names=['trf_first', 'trf_second'],
output_names=['trflist'],
function=transformlist),
iterfield=['trf_first', 'trf_second'],
name="collect_trf")
applywarp = pe.MapNode(interface=ants.ApplyTransforms(
interpolation="BSpline", input_image_type=3),
iterfield=['input_image', 'transforms'],
name='applywarp')
myqc = qc.vol2png("func2mni",
wf_name + "_ANTS3",
overlayiterated=False)
myqc.inputs.slicer.image_width = 500 # 500 # for the 2mm template
myqc.inputs.slicer.threshold_edges = 0.1 # 0.1 # for the 2mm template
if carpet_plot:
fmri_qc = qc.fMRI2QC("carpet_plots", tag=carpet_plot)
outputspec = pe.Node(utility.IdentityInterface(fields=['func_std']),
name='outputspec')
# Save outputs which are important
ds_nii = pe.Node(interface=io.DataSink(), name='ds_nii')
ds_nii.inputs.base_directory = SinkDir
ds_nii.inputs.regexp_substitutions = [("(\/)[^\/]*$", wf_name + ".nii.gz")]
analysisflow = pe.Workflow(wf_name)
analysisflow.base_dir = '.'
if stdreg == globals._RegType_.FSL:
analysisflow.connect(inputspec, 'func', applywarp, 'in_file')
analysisflow.connect(inputspec, 'linear_reg_mtrx', applywarp, 'premat')
analysisflow.connect(inputspec, 'nonlinear_reg_mtrx', applywarp,
'field_file')
analysisflow.connect(inputspec, 'reference_brain', applywarp,
'ref_file')
analysisflow.connect(applywarp, 'out_file', outputspec, 'func_std')
analysisflow.connect(applywarp, 'out_file', myqc, 'inputspec.bg_image')
analysisflow.connect(inputspec, 'reference_brain', myqc,
'inputspec.overlay_image')
analysisflow.connect(applywarp, 'out_file', ds_nii, 'func2mni')
else: # ANTs
analysisflow.connect(inputspec, 'func', myonevol, 'inputspec.func')
analysisflow.connect(myonevol, 'outputspec.func1vol', bbr2ants,
'source_file')
analysisflow.connect(inputspec, 'linear_reg_mtrx', bbr2ants,
'transform_file')
analysisflow.connect(inputspec, 'anat', bbr2ants, 'reference_file')
analysisflow.connect(bbr2ants, 'itk_transform', trflist, 'trf_first')
analysisflow.connect(inputspec, 'nonlinear_reg_mtrx', trflist,
'trf_second')
analysisflow.connect(trflist, 'trflist', applywarp, 'transforms')
analysisflow.connect(inputspec, 'func', applywarp, 'input_image')
analysisflow.connect(inputspec, 'reference_brain', applywarp,
'reference_image')
analysisflow.connect(applywarp, 'output_image', outputspec, 'func_std')
analysisflow.connect(applywarp, 'output_image', myqc,
'inputspec.bg_image')
analysisflow.connect(inputspec, 'reference_brain', myqc,
'inputspec.overlay_image')
analysisflow.connect(applywarp, 'output_image', ds_nii, 'func2mni')
if carpet_plot:
if stdreg == globals._RegType_.FSL:
analysisflow.connect(applywarp, 'out_file', fmri_qc,
'inputspec.func')
else: # ANTs
analysisflow.connect(applywarp, 'output_image', fmri_qc,
'inputspec.func')
analysisflow.connect(inputspec, 'atlas', fmri_qc, 'inputspec.atlas')
analysisflow.connect(inputspec, 'confounds', fmri_qc,
'inputspec.confounds')
return analysisflow
def create_VWM_anti_pp_workflow(analysis_info, name='VWM-anti'):
"""Summary
Parameters
----------
analysis_info : TYPE
Description
name : str, optional
Description
Returns
-------
TYPE
Description
"""
import os.path as op
import nipype.pipeline as pe
import tempfile
import glob
from nipype.interfaces import fsl
from nipype.interfaces.utility import Function, Merge, IdentityInterface
from nipype.interfaces.io import SelectFiles, DataSink
from nipype.interfaces.ants import ApplyTransforms
from bids.grabbids import BIDSLayout
# Importing of custom nodes from spynoza packages; assumes that spynoza is installed:
# pip install git+https://github.com/spinoza-centre/spynoza.git@develop
from spynoza.filtering.nodes import Savgol_filter, Savgol_filter_confounds
from spynoza.conversion.nodes import psc
from spynoza.utils import get_scaninfo, pickfirst
from utils import mask_nii_2_hdf5, nistats_confound_glm, mask_to_tsv
input_node = pe.Node(IdentityInterface(
fields=['bids_directory', 'fmriprep_directory', 'output_directory', 'mask_directory', 'sub_id']), name='inputspec')
BIDSNiiGrabber = pe.Node(Function(function=get_niftis, input_names=["subject_id",
"data_dir", "task", "space"],
output_names=["nii_files"]), name="BIDSNiiGrabber")
BIDSNiiGrabber.inputs.space = 'mni'
BIDSEventsGrabber = pe.Node(Function(function=get_events, input_names=["subject_id",
"data_dir", "task"],
output_names=["event_files"]), name="BIDSEventsGrabber")
BIDSConfoundsGrabber = pe.Node(Function(function=get_confounds, input_names=["subject_id",
"data_dir", "task"],
output_names=["confounds_tsv_files"]), name="BIDSConfoundsGrabber")
MaskGrabber = pe.Node(Function(function=get_masks, input_names=["mask_directory"],
output_names=["mask_files"]), name="MaskGrabber")
HDF5PSCMasker = pe.Node(Function(input_names=['in_files', 'mask_files', 'hdf5_file', 'folder_alias'], output_names=['hdf5_file'],
function=mask_nii_2_hdf5),
name='hdf5_psc_masker')
HDF5PSCMasker.inputs.folder_alias = 'psc'
HDF5PSCMasker.inputs.hdf5_file = op.join(tempfile.mkdtemp(), 'roi.h5')
HDF5PSCNuisMasker = pe.Node(Function(input_names=['in_files', 'mask_files', 'hdf5_file', 'folder_alias'], output_names=['hdf5_file'],
function=mask_nii_2_hdf5),
name='hdf5_psc_nuis_masker')
HDF5PSCNuisMasker.inputs.folder_alias = 'psc_nuis'
# HDF5StatsMasker = pe.Node(Function(input_names = ['in_files', 'mask_files', 'hdf5_file', 'folder_alias'], output_names = ['hdf5_file'],
# function = mask_nii_2_hdf5),
# name = 'hdf5_stats_masker')
# HDF5StatsMasker.inputs.folder_alias = 'stats'
HDF5ROIMasker = pe.Node(Function(input_names=['in_files', 'mask_files', 'hdf5_file', 'folder_alias'], output_names=['hdf5_file'],
function=mask_nii_2_hdf5),
name='hdf5_roi_masker')
HDF5ROIMasker.inputs.folder_alias = 'rois'
ConfoundGLM = pe.MapNode(Function(input_names=['nifti_file', 'confounds_file', 'which_confounds'], output_names=['output_pdf', 'output_nifti'],
function=nistats_confound_glm),
name='nistats_confound_glm', iterfield=["nifti_file", "confounds_file"])
ConfoundGLM.inputs.which_confounds = analysis_info['nuisance_columns']
# VolTransNode = pe.MapNode(interface=fsl.preprocess.ApplyXFM(apply_xfm=False, apply_isoxfm=True, interp='sinc'),
# name='vol_trans', iterfield = ['in_file'])
# VolTransNode = pe.MapNode(interface=ApplyTransforms(transforms='identity', interpolation='LanczosWindowedSinc'),
# name='vol_trans', iterfield = ['input_image'])
ThreshNode = pe.MapNode(fsl.Threshold(thresh=analysis_info['MNI_mask_threshold'], args='-bin', output_datatype='int'),
name='thresh', iterfield=['in_file'])
TSVMasker = pe.MapNode(Function(input_names=['in_file', 'mask_files'], output_names=['out_file'],
function=mask_to_tsv), iterfield=['in_file'],
name='tsv_masker')
ROIResampler = pe.Node(Function(input_names=['mni_roi_files', 'mni_epi_space_file'], output_names=['output_roi_files'],
function=resample_rois),
name='roi_resampler')
sgfilter = pe.MapNode(interface=Savgol_filter,
name='sgfilter',
iterfield=['in_file'])
sgfilter_confounds = pe.MapNode(interface=Savgol_filter_confounds,
name='sgfilter_confounds',
iterfield=['confounds'])
# Both fmri data and nuisances are filtered with identical parameters
sgfilter.inputs.polyorder = sgfilter_confounds.inputs.polyorder = analysis_info[
'sgfilter_polyorder']
sgfilter.inputs.deriv = sgfilter_confounds.inputs.deriv = analysis_info['sgfilter_deriv']
sgfilter.inputs.window_length = sgfilter_confounds.inputs.window_length = analysis_info[
'sgfilter_window_length']
sgfilter.inputs.tr = sgfilter_confounds.inputs.tr = analysis_info['RepetitionTime']
# set the psc function
psc.inputs.func = analysis_info['psc_function']
datasink = pe.Node(DataSink(), name='sinker')
datasink.inputs.parameterization = False
########################################################################################
# workflow
########################################################################################
# the actual top-level workflow
VWM_anti_pp_workflow = pe.Workflow(name=name)
# data source
VWM_anti_pp_workflow.connect(
input_node, 'bids_directory', BIDSEventsGrabber, 'data_dir')
VWM_anti_pp_workflow.connect(input_node, 'sub_id',
BIDSEventsGrabber, 'subject_id')
VWM_anti_pp_workflow.connect(
input_node, 'fmriprep_directory', BIDSNiiGrabber, 'data_dir')
VWM_anti_pp_workflow.connect(input_node, 'sub_id',
BIDSNiiGrabber, 'subject_id')
VWM_anti_pp_workflow.connect(
input_node, 'fmriprep_directory', BIDSConfoundsGrabber, 'data_dir')
VWM_anti_pp_workflow.connect(input_node, 'sub_id',
BIDSConfoundsGrabber, 'subject_id')
VWM_anti_pp_workflow.connect(
input_node, 'mask_directory', MaskGrabber, 'mask_directory')
# filter and psc
VWM_anti_pp_workflow.connect(BIDSNiiGrabber, 'nii_files', sgfilter, 'in_file')
VWM_anti_pp_workflow.connect(sgfilter, 'out_file', psc, 'in_file')
# do the same filtering on confounds
VWM_anti_pp_workflow.connect(BIDSConfoundsGrabber, 'confounds_tsv_files', sgfilter_confounds, 'confounds')
# cleanup GLM
VWM_anti_pp_workflow.connect(psc, 'out_file', ConfoundGLM, 'nifti_file')
VWM_anti_pp_workflow.connect(
sgfilter_confounds, 'out_file', ConfoundGLM, 'confounds_file')
# preparing masks, ANTS and fsl not working correctly
# ANTs
# pearl_pp_workflow.connect(BIDSNiiGrabber, ('nii_files', pickfirst), VolTransNode, 'reference_image')
# pearl_pp_workflow.connect(MaskGrabber, 'mask_files', VolTransNode, 'input_image')
# fsl
# pearl_pp_workflow.connect(BIDSNiiGrabber, ('nii_files', pickfirst), VolTransNode, 'reference')
# pearl_pp_workflow.connect(MaskGrabber, 'mask_files', VolTransNode, 'in_file')
# pearl_pp_workflow.connect(VolTransNode, 'output_image', ThreshNode, 'in_file')
VWM_anti_pp_workflow.connect(
BIDSNiiGrabber, ('nii_files', pickfirst), ROIResampler, 'mni_epi_space_file')
VWM_anti_pp_workflow.connect(
MaskGrabber, 'mask_files', ROIResampler, 'mni_roi_files')
VWM_anti_pp_workflow.connect(
ROIResampler, 'output_roi_files', ThreshNode, 'in_file')
# masking data
VWM_anti_pp_workflow.connect(psc, 'out_file', HDF5PSCMasker, 'in_files')
VWM_anti_pp_workflow.connect(ThreshNode, 'out_file',
HDF5PSCMasker, 'mask_files')
VWM_anti_pp_workflow.connect(
ConfoundGLM, 'output_nifti', HDF5PSCNuisMasker, 'in_files')
VWM_anti_pp_workflow.connect(ThreshNode, 'out_file',
HDF5PSCNuisMasker, 'mask_files')
VWM_anti_pp_workflow.connect(
HDF5PSCMasker, 'hdf5_file', HDF5PSCNuisMasker, 'hdf5_file')
# needs stats before we do a masker....
# pearl_pp_workflow.connect(VolTransNode, 'out_file', HDF5StatsMasker, 'in_files')
# pearl_pp_workflow.connect(ThreshNode, 'out_file', HDF5StatsMasker, 'mask_files')
# pearl_pp_workflow.connect(HDF5PSCNuisMasker, 'hdf5_file', HDF5StatsMasker, 'hdf5_file')
VWM_anti_pp_workflow.connect(
ROIResampler, 'output_roi_files', HDF5ROIMasker, 'in_files')
VWM_anti_pp_workflow.connect(ThreshNode, 'out_file',
HDF5ROIMasker, 'mask_files')
VWM_anti_pp_workflow.connect(
HDF5PSCNuisMasker, 'hdf5_file', HDF5ROIMasker, 'hdf5_file')
# mask to .tsv, for one timecourse per roi
VWM_anti_pp_workflow.connect(
ROIResampler, 'output_roi_files', TSVMasker, 'mask_files')
VWM_anti_pp_workflow.connect(
ConfoundGLM, 'output_nifti', TSVMasker, 'in_file')
# set up output folder
VWM_anti_pp_workflow.connect(
input_node, 'output_directory', datasink, 'base_directory')
# connect all outputs to datasink
VWM_anti_pp_workflow.connect(
ConfoundGLM, 'output_nifti', datasink, 'confound_glm')
VWM_anti_pp_workflow.connect(
BIDSEventsGrabber, 'event_files', datasink, 'events')
VWM_anti_pp_workflow.connect(sgfilter, 'out_file', datasink, 'sg_filter')
VWM_anti_pp_workflow.connect(
sgfilter_confounds, 'out_file', datasink, 'sg_filter_confound')
VWM_anti_pp_workflow.connect(psc, 'out_file', datasink, 'psc')
VWM_anti_pp_workflow.connect(
ROIResampler, 'output_roi_files', datasink, 'masks_f')
VWM_anti_pp_workflow.connect(ThreshNode, 'out_file', datasink, 'masks_b')
VWM_anti_pp_workflow.connect(TSVMasker, 'out_file', datasink, 'tsv')
VWM_anti_pp_workflow.connect(HDF5PSCNuisMasker, 'hdf5_file', datasink, 'h5')
VWM_anti_pp_workflow.connect(
ConfoundGLM, 'output_pdf', datasink, 'confound_glm_report')
return VWM_anti_pp_workflow
def create_retroicor_workflow(name = 'retroicor', order_or_timing = 'order'):
"""
Creates RETROICOR regressors
Example
-------
Inputs::
inputnode.in_file - The .log file acquired together with EPI sequence
Outputs::
outputnode.regressor_files
"""
# Define nodes:
input_node = pe.Node(niu.IdentityInterface(fields=['in_files',
'phys_files',
'nr_dummies',
'MB_factor',
'tr',
'slice_direction',
'phys_sample_rate',
'slice_timing',
'slice_order',
'hr_rvt',
]), name='inputspec')
# the slice time preprocessing node before we go into popp (PreparePNM)
slice_times_from_gradients = pe.MapNode(niu.Function(input_names=['in_file', 'phys_file', 'nr_dummies', 'MB_factor', 'sample_rate'],
output_names=['out_file', 'fig_file'],
function=_distill_slice_times_from_gradients), name='slice_times_from_gradients', iterfield = ['in_file','phys_file'])
slice_times_to_txt_file = pe.Node(niu.Function(input_names=['slice_times'],
output_names=['out_file'],
function=_slice_times_to_txt_file), name='slice_times_to_txt_file')
pnm_prefixer = pe.MapNode(niu.Function(input_names=['filename'],
output_names=['out_string'],
function=_preprocess_nii_files_to_pnm_evs_prefix), name='pnm_prefixer', iterfield = ['filename'])
prepare_pnm = pe.MapNode(PreparePNM(), name='prepare_pnm', iterfield = ['in_file'])
pnm_evs = pe.MapNode(PNMtoEVs(), name='pnm_evs', iterfield = ['functional_epi', 'cardiac', 'resp', 'hr', 'rvt', 'prefix'])
# Define output node
output_node = pe.Node(niu.IdentityInterface(fields=['new_phys', 'fig_file', 'evs']), name='outputspec')
########################################################################################
# workflow
########################################################################################
retroicor_workflow = pe.Workflow(name=name)
# align phys-log data to nifti
retroicor_workflow.connect(input_node, 'in_files', slice_times_from_gradients, 'in_file')
retroicor_workflow.connect(input_node, 'phys_files', slice_times_from_gradients, 'phys_file')
retroicor_workflow.connect(input_node, 'nr_dummies', slice_times_from_gradients, 'nr_dummies')
retroicor_workflow.connect(input_node, 'MB_factor', slice_times_from_gradients, 'MB_factor')
retroicor_workflow.connect(input_node, 'phys_sample_rate', slice_times_from_gradients, 'sample_rate')
# conditional here, for the creation of a separate slice timing file if order_or_timing is 'timing'
# order_or_timing can also be 'order'
if order_or_timing == 'timing':
retroicor_workflow.connect(input_node, 'slice_timing', slice_times_to_txt_file, 'slice_times')
# prepare pnm:
retroicor_workflow.connect(input_node, 'phys_sample_rate', prepare_pnm, 'sampling_rate')
retroicor_workflow.connect(input_node, 'tr', prepare_pnm, 'tr')
retroicor_workflow.connect(slice_times_from_gradients, 'out_file', prepare_pnm, 'in_file')
retroicor_workflow.connect(input_node, 'hr_rvt', prepare_pnm, 'hr_rvt')
# pnm evs:
retroicor_workflow.connect(input_node, 'in_files', pnm_prefixer, 'filename')
retroicor_workflow.connect(pnm_prefixer, 'out_string', pnm_evs, 'prefix')
retroicor_workflow.connect(input_node, 'in_files', pnm_evs, 'functional_epi')
retroicor_workflow.connect(input_node, 'slice_direction', pnm_evs, 'slice_dir')
retroicor_workflow.connect(input_node, 'tr', pnm_evs, 'tr')
if order_or_timing == 'timing':
retroicor_workflow.connect(slice_times_to_txt_file, 'out_file', pnm_evs, 'slice_timing')
elif order_or_timing == 'order':
retroicor_workflow.connect(input_node, 'slice_order', pnm_evs, 'slice_order')
retroicor_workflow.connect(prepare_pnm, 'card', pnm_evs, 'cardiac')
retroicor_workflow.connect(prepare_pnm, 'resp', pnm_evs, 'resp')
retroicor_workflow.connect(prepare_pnm, 'hr', pnm_evs, 'hr')
retroicor_workflow.connect(prepare_pnm, 'rvt', pnm_evs, 'rvt')
retroicor_workflow.connect(slice_times_from_gradients, 'out_file', output_node, 'new_phys')
retroicor_workflow.connect(slice_times_from_gradients, 'fig_file', output_node, 'fig_file')
retroicor_workflow.connect(pnm_evs, 'evs', output_node, 'evs')
return retroicor_workflow
def create_preprocessing_workflow(analysis_params, name='yesno_3T'):
import os.path as op
import nipype.pipeline as pe
from nipype.interfaces import fsl
from nipype.interfaces.utility import Function, Merge, IdentityInterface
from nipype.interfaces.io import SelectFiles, DataSink
from IPython import embed as shell
# Importing of custom nodes from spynoza packages; assumes that spynoza is installed:
# pip install git+https://github.com/spinoza-centre/spynoza.git@develop
from spynoza.utils import get_scaninfo, pickfirst, average_over_runs, set_nifti_intercept_slope
from spynoza.uniformization.workflows import create_non_uniformity_correct_4D_file
from spynoza.unwarping.b0.workflows import create_B0_workflow
from spynoza.motion_correction.workflows import create_motion_correction_workflow
from spynoza.registration.workflows import create_registration_workflow
from spynoza.filtering.nodes import sgfilter
from spynoza.conversion.nodes import psc
from spynoza.denoising.retroicor.workflows import create_retroicor_workflow
from spynoza.masking.workflows import create_masks_from_surface_workflow
from spynoza.glm.nodes import fit_nuisances
########################################################################################
# nodes
########################################################################################
input_node = pe.Node(
IdentityInterface(fields=[
'task', # main
'sub_id', # main
'ses_id', # main
'raw_data_dir', # main
'output_directory', # main
'sub_FS_id', # main
'FS_subject_dir', # motion correction
'RepetitionTime', # motion correction
'which_file_is_EPI_space', # motion correction
'standard_file', # registration
'topup_conf_file', # unwarping
'EchoTimeDiff', # unwarping
'EpiFactor', # unwarping
'SenseFactor', # unwarping
'WaterFatShift', # unwarping
'PhaseEncodingDirection', # unwarping
'EchoSpacing' # unwarping
'psc_func', # percent signal change
'sg_filter_window_length', # temporal filtering
'sg_filter_order', # temporal filtering
'SliceEncodingDirection', # retroicor
'PhysiologySampleRate', # retroicor
'SliceTiming', # retroicor
'SliceOrder', # retroicor
'NumberDummyScans', # retroicor
'MultiBandFactor', # retroicor
'hr_rvt', # retroicor
'av_func', # extra
'EchoTime', # extra
'bd_design_matrix_file', # extra
]),
name='inputspec')
for param in analysis_params:
exec('input_node.inputs.{} = analysis_params[param]'.format(param))
# i/o node
datasource_templates = dict(
func=
'{sub_id}/{ses_id}/func/{sub_id}_{ses_id}_task-{task}*_bold.nii.gz',
magnitude='{sub_id}/{ses_id}/fmap/{sub_id}_{ses_id}*magnitude.nii.gz',
phasediff='{sub_id}/{ses_id}/fmap/{sub_id}_{ses_id}*phasediff.nii.gz',
#physio='{sub_id}/{ses_id}/func/*{task}*physio.*',
#events='{sub_id}/{ses_id}/func/*{task}*_events.pickle',
#eye='{sub_id}/{ses_id}/func/*{task}*_eyedata.edf'
)
datasource = pe.Node(SelectFiles(datasource_templates,
sort_filelist=True,
raise_on_empty=False),
name='datasource')
output_node = pe.Node(IdentityInterface(
fields=(['temporal_filtered_files', 'percent_signal_change_files'])),
name='outputspec')
# nodes for setting the slope/intercept of incoming niftis to (1, 0)
# this is apparently necessary for the B0 map files
int_slope_B0_magnitude = pe.Node(Function(
input_names=['in_file'],
output_names=['out_file'],
function=set_nifti_intercept_slope),
name='int_slope_B0_magnitude')
int_slope_B0_phasediff = pe.Node(Function(
input_names=['in_file'],
output_names=['out_file'],
function=set_nifti_intercept_slope),
name='int_slope_B0_phasediff')
# reorient nodes
reorient_epi = pe.MapNode(interface=fsl.Reorient2Std(),
name='reorient_epi',
iterfield=['in_file'])
reorient_B0_magnitude = pe.Node(interface=fsl.Reorient2Std(),
name='reorient_B0_magnitude')
reorient_B0_phasediff = pe.Node(interface=fsl.Reorient2Std(),
name='reorient_B0_phasediff')
# bet_epi = pe.MapNode(interface=
# fsl.BET(frac=analysis_parameters['bet_f_value'], vertical_gradient = analysis_parameters['bet_g_value'],
# functional=True, mask = True), name='bet_epi', iterfield=['in_file'])
datasink = pe.Node(DataSink(), name='sinker')
datasink.inputs.parameterization = False
########################################################################################
# workflow
########################################################################################
# the actual top-level workflow
preprocessing_workflow = pe.Workflow(name=name)
preprocessing_workflow.base_dir = op.join(analysis_params['base_dir'],
'temp/')
# data source
preprocessing_workflow.connect(input_node, 'raw_data_dir', datasource,
'base_directory')
preprocessing_workflow.connect(input_node, 'sub_id', datasource, 'sub_id')
preprocessing_workflow.connect(input_node, 'ses_id', datasource, 'ses_id')
preprocessing_workflow.connect(input_node, 'task', datasource, 'task')
# and data sink
preprocessing_workflow.connect(input_node, 'output_directory', datasink,
'base_directory')
# BET (we don't do this, because we expect the raw data in the bids folder to be betted
# already for anonymization purposes)
# preprocessing_workflow.connect(datasource, 'func', bet_epi, 'in_file')
# non-uniformity correction
# preprocessing_workflow.connect(bet_epi, 'out_file', nuc, 'in_file')
# preprocessing_workflow.connect(datasource, 'func', nuc, 'in_file')
# reorient images
preprocessing_workflow.connect(datasource, 'func', reorient_epi, 'in_file')
preprocessing_workflow.connect(datasource, 'magnitude',
reorient_B0_magnitude, 'in_file')
preprocessing_workflow.connect(datasource, 'phasediff',
reorient_B0_phasediff, 'in_file')
preprocessing_workflow.connect(reorient_epi, 'out_file', datasink,
'reorient')
#B0 field correction:
if analysis_params['B0_or_topup'] == 'B0':
# set slope/intercept to unity for B0 map
preprocessing_workflow.connect(reorient_B0_magnitude, 'out_file',
int_slope_B0_magnitude, 'in_file')
preprocessing_workflow.connect(reorient_B0_phasediff, 'out_file',
int_slope_B0_phasediff, 'in_file')
#B0 field correction:
if 'EchoSpacing' in analysis_params:
B0_wf = create_B0_workflow(name='B0', scanner='siemens')
preprocessing_workflow.connect(input_node, 'EchoSpacing', B0_wf,
'inputspec.echo_spacing')
else:
B0_wf = create_B0_workflow(name='B0', scanner='philips')
preprocessing_workflow.connect(input_node, 'WaterFatShift', B0_wf,
'inputspec.wfs')
preprocessing_workflow.connect(input_node, 'EpiFactor', B0_wf,
'inputspec.epi_factor')
preprocessing_workflow.connect(input_node, 'SenseFactor', B0_wf,
'inputspec.acceleration')
preprocessing_workflow.connect(reorient_epi, 'out_file', B0_wf,
'inputspec.in_files')
preprocessing_workflow.connect(int_slope_B0_magnitude, 'out_file',
B0_wf, 'inputspec.fieldmap_mag')
preprocessing_workflow.connect(int_slope_B0_phasediff, 'out_file',
B0_wf, 'inputspec.fieldmap_pha')
preprocessing_workflow.connect(input_node, 'EchoTimeDiff', B0_wf,
'inputspec.te_diff')
preprocessing_workflow.connect(input_node, 'PhaseEncodingDirection',
B0_wf,
'inputspec.phase_encoding_direction')
preprocessing_workflow.connect(B0_wf, 'outputspec.field_coefs',
datasink, 'B0.fieldcoef')
preprocessing_workflow.connect(B0_wf, 'outputspec.out_files', datasink,
'B0')
# motion correction
motion_proc = create_motion_correction_workflow(
'moco', method=analysis_params['moco_method'])
if analysis_params['B0_or_topup'] == 'B0':
preprocessing_workflow.connect(B0_wf, 'outputspec.out_files',
motion_proc, 'inputspec.in_files')
elif analysis_params['B0_or_topup'] == 'neither':
preprocessing_workflow.connect(bet_epi, 'out_file', motion_proc,
'inputspec.in_files')
preprocessing_workflow.connect(input_node, 'RepetitionTime', motion_proc,
'inputspec.tr')
preprocessing_workflow.connect(input_node, 'output_directory', motion_proc,
'inputspec.output_directory')
preprocessing_workflow.connect(input_node, 'which_file_is_EPI_space',
motion_proc,
'inputspec.which_file_is_EPI_space')
# registration
reg = create_registration_workflow(analysis_params, name='reg')
preprocessing_workflow.connect(input_node, 'output_directory', reg,
'inputspec.output_directory')
preprocessing_workflow.connect(motion_proc, 'outputspec.EPI_space_file',
reg, 'inputspec.EPI_space_file')
preprocessing_workflow.connect(input_node, 'sub_FS_id', reg,
'inputspec.freesurfer_subject_ID')
preprocessing_workflow.connect(input_node, 'FS_subject_dir', reg,
'inputspec.freesurfer_subject_dir')
preprocessing_workflow.connect(input_node, 'standard_file', reg,
'inputspec.standard_file')
# temporal filtering
preprocessing_workflow.connect(input_node, 'sg_filter_window_length',
sgfilter, 'window_length')
preprocessing_workflow.connect(input_node, 'sg_filter_order', sgfilter,
'polyorder')
preprocessing_workflow.connect(motion_proc,
'outputspec.motion_corrected_files',
sgfilter, 'in_file')
preprocessing_workflow.connect(sgfilter, 'out_file', datasink, 'tf')
# node for percent signal change
preprocessing_workflow.connect(input_node, 'psc_func', psc, 'func')
preprocessing_workflow.connect(sgfilter, 'out_file', psc, 'in_file')
preprocessing_workflow.connect(psc, 'out_file', datasink, 'psc')
# # retroicor functionality
# if analysis_params['perform_physio'] == 1:
# retr = create_retroicor_workflow(name = 'retroicor', order_or_timing = analysis_params['retroicor_order_or_timing'])
#
# # # retroicor can take the crudest form of epi file, so that it proceeds quickly
# preprocessing_workflow.connect(datasource, 'func', retr, 'inputspec.in_files')
# preprocessing_workflow.connect(datasource, 'physio', retr, 'inputspec.phys_files')
# preprocessing_workflow.connect(input_node, 'analysis_params.nr_dummies', retr, 'inputspec.nr_dummies')
# preprocessing_workflow.connect(input_node, 'analysis_params.MultiBandFactor', retr, 'inputspec.MB_factor')
# preprocessing_workflow.connect(input_node, 'analysis_params.tr', retr, 'inputspec.tr')
# preprocessing_workflow.connect(input_node, 'analysis_params.SliceEncodingDirection', retr, 'inputspec.slice_direction')
# preprocessing_workflow.connect(input_node, 'analysis_params.SliceTiming', retr, 'inputspec.slice_timing')
# preprocessing_workflow.connect(input_node, 'analysis_params.SliceOrder', retr, 'inputspec.slice_order')
# preprocessing_workflow.connect(input_node, 'analysis_params.PhysiologySampleRate', retr, 'inputspec.phys_sample_rate')
# preprocessing_workflow.connect(input_node, 'analysis_params.hr_rvt', retr, 'inputspec.hr_rvt')
#
# # fit nuisances from retroicor
# # preprocessing_workflow.connect(retr, 'outputspec.evs', fit_nuis, 'slice_regressor_list')
# # preprocessing_workflow.connect(motion_proc, 'outputspec.extended_motion_correction_parameters', fit_nuis, 'vol_regressors')
# # preprocessing_workflow.connect(psc, 'out_file', fit_nuis, 'in_file')
#
# # preprocessing_workflow.connect(fit_nuis, 'res_file', av_r, 'in_files')
#
# preprocessing_workflow.connect(retr, 'outputspec.new_phys', datasink, 'phys.log')
# preprocessing_workflow.connect(retr, 'outputspec.fig_file', datasink, 'phys.figs')
# preprocessing_workflow.connect(retr, 'outputspec.evs', datasink, 'phys.evs')
# # preprocessing_workflow.connect(fit_nuis, 'res_file', datasink, 'phys.res')
# # preprocessing_workflow.connect(fit_nuis, 'rsq_file', datasink, 'phys.rsq')
# # preprocessing_workflow.connect(fit_nuis, 'beta_file', datasink, 'phys.betas')
#
# # preprocessing_workflow.connect(av_r, 'out_file', datasink, 'av_r')
#
# ########################################################################################
# # masking stuff if doing mri analysis
# ########################################################################################
#
# all_mask_opds = ['dc'] + analysis_parameters[u'avg_subject_RS_label_folders']
# all_mask_lds = [''] + analysis_parameters[u'avg_subject_RS_label_folders']
#
# # loop across different folders to mask
# # untested as yet.
# masking_list = []
# dilate_list = []
# for opd, label_directory in zip(all_mask_opds,all_mask_lds):
# dilate_list.append(
# pe.MapNode(interface=fsl.maths.DilateImage(
# operation = 'mean', kernel_shape = 'sphere', kernel_size = analysis_parameters['dilate_kernel_size']),
# name='dilate_'+label_directory, iterfield=['in_file']))
#
# masking_list.append(create_masks_from_surface_workflow(name = 'masks_from_surface_'+label_directory))
#
# masking_list[-1].inputs.inputspec.label_directory = label_directory
# masking_list[-1].inputs.inputspec.fill_thresh = 0.005
# masking_list[-1].inputs.inputspec.re = '*.label'
#
# preprocessing_workflow.connect(motion_proc, 'outputspec.EPI_space_file', masking_list[-1], 'inputspec.EPI_space_file')
# preprocessing_workflow.connect(input_node, 'output_directory', masking_list[-1], 'inputspec.output_directory')
# preprocessing_workflow.connect(input_node, 'FS_subject_dir', masking_list[-1], 'inputspec.freesurfer_subject_dir')
# preprocessing_workflow.connect(input_node, 'FS_ID', masking_list[-1], 'inputspec.freesurfer_subject_ID')
# preprocessing_workflow.connect(reg, 'rename_register.out_file', masking_list[-1], 'inputspec.reg_file')
#
# preprocessing_workflow.connect(masking_list[-1], 'outputspec.masks', dilate_list[-1], 'in_file')
# preprocessing_workflow.connect(dilate_list[-1], 'out_file', datasink, 'masks.'+opd)
#
# # # surface-based label import in to EPI space, but now for RS labels
# # these should have been imported to the subject's FS folder,
# # see scripts/annot_conversion.sh
# RS_masks_from_surface = create_masks_from_surface_workflow(name = 'RS_masks_from_surface')
# RS_masks_from_surface.inputs.inputspec.label_directory = analysis_parameters['avg_subject_label_folder']
# RS_masks_from_surface.inputs.inputspec.fill_thresh = 0.005
# RS_masks_from_surface.inputs.inputspec.re = '*.label'
#
# preprocessing_workflow.connect(motion_proc, 'outputspec.EPI_space_file', RS_masks_from_surface, 'inputspec.EPI_space_file')
# preprocessing_workflow.connect(input_node, 'output_directory', RS_masks_from_surface, 'inputspec.output_directory')
# preprocessing_workflow.connect(input_node, 'FS_subject_dir', RS_masks_from_surface, 'inputspec.freesurfer_subject_dir')
# preprocessing_workflow.connect(input_node, 'FS_ID', RS_masks_from_surface, 'inputspec.freesurfer_subject_ID')
# preprocessing_workflow.connect(reg, 'rename_register.out_file', RS_masks_from_surface, 'inputspec.reg_file')
#
# preprocessing_workflow.connect(RS_masks_from_surface, 'outputspec.masks', RS_dilate_cortex, 'in_file')
# preprocessing_workflow.connect(RS_dilate_cortex, 'out_file', datasink, 'masks.'+analysis_parameters['avg_subject_label_folder'])
########################################################################################
# wrapping up, sending data to datasink
########################################################################################
# preprocessing_workflow.connect(bet_epi, 'out_file', datasink, 'bet.epi')
# preprocessing_workflow.connect(bet_epi, 'mask_file', datasink, 'bet.epimask')
# preprocessing_workflow.connect(bet_topup, 'out_file', datasink, 'bet.topup')
# preprocessing_workflow.connect(bet_topup, 'mask_file', datasink, 'bet.topupmask')
# preprocessing_workflow.connect(nuc, 'out_file', datasink, 'nuc')
# preprocessing_workflow.connect(sgfilter, 'out_file', datasink, 'tf')
# preprocessing_workflow.connect(psc, 'out_file', datasink, 'psc')
# preprocessing_workflow.connect(datasource, 'physio', datasink, 'phys')
return preprocessing_workflow
def create_compcor_workflow(name='compcor'):
""" Creates A/T compcor workflow. """
input_node = pe.Node(interface=IdentityInterface(fields=[
'in_file', 'fast_files', 'highres2epi_mat', 'n_comp_tcompcor',
'n_comp_acompcor', 'output_directory', 'sub_id'
]),
name='inputspec')
output_node = pe.Node(interface=IdentityInterface(
fields=['tcompcor_file', 'acompcor_file', 'epi_mask']),
name='outputspec')
extract_task = pe.MapNode(interface=Extract_task,
iterfield=['in_file'],
name='extract_task')
rename_acompcor = pe.MapNode(interface=Rename(
format_string='task-%(task)s_acompcor.tsv', keepext=True),
iterfield=['task', 'in_file'],
name='rename_acompcor')
datasink = pe.Node(DataSink(), name='sinker')
datasink.inputs.parameterization = False
average_func = pe.MapNode(interface=fsl.maths.MeanImage(dimension='T'),
name='average_func',
iterfield=['in_file'])
epi_mask = pe.MapNode(interface=fsl.BET(frac=.3,
mask=True,
no_output=True,
robust=True),
iterfield=['in_file'],
name='epi_mask')
wm2epi = pe.MapNode(fsl.ApplyXFM(interp='nearestneighbour'),
iterfield=['reference'],
name='wm2epi')
csf2epi = pe.MapNode(fsl.ApplyXFM(interp='nearestneighbour'),
iterfield=['reference'],
name='csf2epi')
erode_csf = pe.MapNode(interface=Erode_mask,
name='erode_csf',
iterfield=['epi_mask', 'in_file'])
erode_csf.inputs.erosion_mm = 0
erode_csf.inputs.epi_mask_erosion_mm = 30
erode_wm = pe.MapNode(interface=Erode_mask,
name='erode_wm',
iterfield=['epi_mask', 'in_file'])
erode_wm.inputs.erosion_mm = 6
erode_wm.inputs.epi_mask_erosion_mm = 10
merge_wm_and_csf_masks = pe.MapNode(Merge(2),
name='merge_wm_and_csf_masks',
iterfield=['in1', 'in2'])
# This should be fit on the 30mm eroded mask from CSF
tcompcor = pe.MapNode(TCompCor(components_file='tcomcor_comps.txt'),
iterfield=['realigned_file', 'mask_files'],
name='tcompcor')
# WM + CSF mask
acompcor = pe.MapNode(ACompCor(components_file='acompcor_comps.txt',
merge_method='union'),
iterfield=['realigned_file', 'mask_files'],
name='acompcor')
compcor_wf = pe.Workflow(name=name)
compcor_wf.connect(input_node, 'in_file', extract_task, 'in_file')
compcor_wf.connect(extract_task, 'task_name', rename_acompcor, 'task')
compcor_wf.connect(acompcor, 'components_file', rename_acompcor, 'in_file')
compcor_wf.connect(input_node, 'sub_id', datasink, 'container')
compcor_wf.connect(input_node, 'output_directory', datasink,
'base_directory')
compcor_wf.connect(input_node, ('fast_files', pick_wm), wm2epi, 'in_file')
compcor_wf.connect(epi_mask, 'mask_file', wm2epi, 'reference')
compcor_wf.connect(input_node, 'highres2epi_mat', wm2epi, 'in_matrix_file')
compcor_wf.connect(input_node, ('fast_files', pick_csf), csf2epi,
'in_file')
compcor_wf.connect(epi_mask, 'mask_file', csf2epi, 'reference')
compcor_wf.connect(input_node, 'highres2epi_mat', csf2epi,
'in_matrix_file')
compcor_wf.connect(input_node, 'n_comp_tcompcor', tcompcor,
'num_components')
compcor_wf.connect(input_node, 'n_comp_acompcor', acompcor,
'num_components')
compcor_wf.connect(input_node, 'in_file', average_func, 'in_file')
compcor_wf.connect(average_func, 'out_file', epi_mask, 'in_file')
compcor_wf.connect(epi_mask, 'mask_file', erode_csf, 'epi_mask')
compcor_wf.connect(epi_mask, 'mask_file', erode_wm, 'epi_mask')
compcor_wf.connect(wm2epi, 'out_file', erode_wm, 'in_file')
compcor_wf.connect(csf2epi, 'out_file', erode_csf, 'in_file')
compcor_wf.connect(erode_wm, 'roi_eroded', merge_wm_and_csf_masks, 'in1')
compcor_wf.connect(erode_csf, 'roi_eroded', merge_wm_and_csf_masks, 'in2')
compcor_wf.connect(merge_wm_and_csf_masks, 'out', acompcor, 'mask_files')
compcor_wf.connect(input_node, 'in_file', acompcor, 'realigned_file')
compcor_wf.connect(input_node, 'in_file', tcompcor, 'realigned_file')
compcor_wf.connect(erode_csf, 'epi_mask_eroded', tcompcor, 'mask_files')
#compcor_wf.connect(tcompcor, 'components_file', output_node, 'acompcor_file')
#compcor_wf.connect(acompcor, 'components_file', output_node, 'tcompcor_file')
compcor_wf.connect(epi_mask, 'mask_file', output_node, 'epi_mask')
compcor_wf.connect(rename_acompcor, 'out_file', datasink, 'acompcor_file')
#compcor_wf.connect(tcompcor, 'components_file', combine_files, 'tcomp')
#compcor_wf.connect(acompcor, 'components_file', combine_files, 'acomp')
#compcor_wf.connect(combine_files, 'out_file', datasink, 'confounds')
return compcor_wf
def anat2mni_fsl_workflow(SinkTag="anat_preproc", wf_name="anat2mni_fsl"):
"""
Modified version of CPAC.registration.registration:
`source: https://fcp-indi.github.io/docs/developer/_modules/CPAC/registration/registration.html`
Register skull and brain extracted image to MNI space and return the transformation martices.
Workflow inputs:
:param skull: The reoriented anatomical file.
:param brain: The brain extracted anat.
:param ref_skull: MNI152 skull file.
:param ref_brain: MNI152 brain file.
:param ref_mask: CSF mask of the MNI152 file.
:param fnirt config: Parameters which specifies FNIRT options.
:param SinkDir:
:param SinkTag: The output directiry in which the returned images (see workflow outputs) could be found.
Workflow outputs:
:return: anat2mni_workflow - workflow
anat="/home/balint/Dokumentumok/phd/essen/PAINTER/probe/MS001/highres.nii.gz",
brain="/home/balint/Dokumentumok/phd/essen/PAINTER/probe/MS001/highres_brain.nii.gz",
Balint Kincses
[email protected]
2018
"""
SinkDir = os.path.abspath(globals._SinkDir_ + "/" + SinkTag)
if not os.path.exists(SinkDir):
os.makedirs(SinkDir)
# Define inputs of workflow
inputspec = pe.Node(utility.IdentityInterface(fields=[
'brain', 'skull', 'reference_brain', 'reference_skull', 'ref_mask',
'fnirt_config'
]),
name='inputspec')
inputspec.inputs.reference_brain = globals._FSLDIR_ + globals._brainref
inputspec.inputs.reference_skull = globals._FSLDIR_ + globals._headref
inputspec.inputs.ref_mask = globals._FSLDIR_ + globals._brainref_mask
# inputspec.inputs.fnirt_config = "T1_2_MNI152_2mm"
# Linear registration node
linear_reg = pe.MapNode(interface=fsl.FLIRT(),
iterfield=['in_file'],
name='linear_reg_0')
linear_reg.inputs.cost = 'corratio'
# Non-linear registration node
nonlinear_reg = pe.MapNode(interface=fsl.FNIRT(),
iterfield=['in_file', 'affine_file'],
name='nonlinear_reg_1')
nonlinear_reg.inputs.fieldcoeff_file = True
nonlinear_reg.inputs.jacobian_file = True
# Applying warp field
brain_warp = pe.MapNode(interface=fsl.ApplyWarp(),
iterfield=['in_file', 'field_file'],
name='brain_warp')
# Calculate the invers of the linear transformation
inv_flirt_xfm = pe.MapNode(interface=fsl.utils.ConvertXFM(),
iterfield=['in_file'],
name='inv_linear_reg0_xfm')
inv_flirt_xfm.inputs.invert_xfm = True
# Calculate inverse of the nonlinear warping field
inv_fnirt_xfm = pe.MapNode(interface=fsl.utils.InvWarp(),
iterfield=['warp', 'reference'],
name="inv_nonlinear_xfm")
# Create png images for quality check
myqc = qc.vol2png("anat2mni", "FSL2", overlayiterated=False)
myqc.inputs.inputspec.overlay_image = globals._FSLDIR_ + globals._brainref
myqc.inputs.slicer.image_width = 500
myqc.inputs.slicer.threshold_edges = 0.1
# Save outputs which are important
ds = pe.Node(interface=io.DataSink(), name='ds')
ds.inputs.base_directory = SinkDir
ds.inputs.regexp_substitutions = [("(\/)[^\/]*$", ".nii.gz")]
# Define outputs of the workflow
outputspec = pe.Node(utility.IdentityInterface(fields=[
'output_brain', 'linear_xfm', 'invlinear_xfm', 'nonlinear_xfm',
'invnonlinear_xfm', 'std_template'
]),
name='outputspec')
# Create workflow nad connect nodes
analysisflow = pe.Workflow(name=wf_name)
analysisflow.connect(inputspec, 'brain', linear_reg, 'in_file')
analysisflow.connect(inputspec, 'reference_brain', linear_reg, 'reference')
analysisflow.connect(inputspec, 'skull', nonlinear_reg, 'in_file')
analysisflow.connect(inputspec, 'reference_skull', nonlinear_reg,
'ref_file')
analysisflow.connect(inputspec, 'ref_mask', nonlinear_reg, 'refmask_file')
# FNIRT parameters are specified by FSL config file
# ${FSLDIR}/etc/flirtsch/TI_2_MNI152_2mm.cnf (or user-specified)
analysisflow.connect(inputspec, 'fnirt_config', nonlinear_reg,
'config_file')
analysisflow.connect(linear_reg, 'out_matrix_file', nonlinear_reg,
'affine_file')
analysisflow.connect(nonlinear_reg, 'fieldcoeff_file', outputspec,
'nonlinear_xfm')
analysisflow.connect(nonlinear_reg, 'field_file', outputspec, 'field_file')
analysisflow.connect(inputspec, 'brain', brain_warp, 'in_file')
analysisflow.connect(nonlinear_reg, 'fieldcoeff_file', brain_warp,
'field_file')
analysisflow.connect(inputspec, 'reference_brain', brain_warp, 'ref_file')
analysisflow.connect(brain_warp, 'out_file', outputspec, 'output_brain')
analysisflow.connect(linear_reg, 'out_matrix_file', inv_flirt_xfm,
'in_file')
analysisflow.connect(inv_flirt_xfm, 'out_file', outputspec,
'invlinear_xfm')
analysisflow.connect(nonlinear_reg, 'fieldcoeff_file', inv_fnirt_xfm,
'warp')
analysisflow.connect(inputspec, 'brain', inv_fnirt_xfm, 'reference')
analysisflow.connect(inv_fnirt_xfm, 'inverse_warp', outputspec,
'invnonlinear_xfm')
analysisflow.connect(linear_reg, 'out_matrix_file', outputspec,
'linear_xfm')
analysisflow.connect(inputspec, 'reference_brain', outputspec,
'std_template')
analysisflow.connect(brain_warp, 'out_file', ds, 'anat2mni_std')
analysisflow.connect(nonlinear_reg, 'fieldcoeff_file', ds,
'anat2mni_warpfield')
analysisflow.connect(brain_warp, 'out_file', myqc, 'inputspec.bg_image')
return analysisflow
def anat2mni_ants_workflow_nipype(SinkTag="anat_preproc",
wf_name="anat2mni_ants"):
"""
Register skull and brain extracted image to MNI space and return the transformation martices.
Using ANTS, doing it in the nipype way.
Workflow inputs:
:param skull: The reoriented anatomical file.
:param brain: The brain extracted anat.
:param ref_skull: MNI152 skull file.
:param ref_brain: MNI152 brain file.
:param SinkDir:
:param SinkTag: The output directiry in which the returned images (see workflow outputs) could be found.
Workflow outputs:
:return: anat2mni_workflow - workflow
anat="/home/balint/Dokumentumok/phd/essen/PAINTER/probe/MS001/highres.nii.gz",
brain="/home/balint/Dokumentumok/phd/essen/PAINTER/probe/MS001/highres_brain.nii.gz",
Tamas Spisak
[email protected]
2018
"""
SinkDir = os.path.abspath(globals._SinkDir_ + "/" + SinkTag)
if not os.path.exists(SinkDir):
os.makedirs(SinkDir)
# Define inputs of workflow
inputspec = pe.Node(utility.IdentityInterface(
fields=['brain', 'skull', 'reference_brain', 'reference_skull']),
name='inputspec')
inputspec.inputs.reference_brain = globals._FSLDIR_ + globals._brainref #TODO_ready: 1 or 2mm???
inputspec.inputs.reference_skull = globals._FSLDIR_ + globals._headref
# Multi-stage registration node with ANTS
reg = pe.MapNode(
interface=Registration(),
iterfield=['moving_image'], # 'moving_image_mask'],
name="ANTS")
"""
reg.inputs.transforms = ['Affine', 'SyN']
reg.inputs.transform_parameters = [(2.0,), (0.1, 3.0, 0.0)]
reg.inputs.number_of_iterations = [[1500, 200], [100, 50, 30]]
reg.inputs.dimension = 3
reg.inputs.write_composite_transform = True
reg.inputs.collapse_output_transforms = False
reg.inputs.initialize_transforms_per_stage = False
reg.inputs.metric = ['Mattes', 'Mattes']
reg.inputs.metric_weight = [1] * 2 # Default (value ignored currently by ANTs)
reg.inputs.radius_or_number_of_bins = [32] * 2
reg.inputs.sampling_strategy = ['Random', None]
reg.inputs.sampling_percentage = [0.05, None]
reg.inputs.convergence_threshold = [1.e-8, 1.e-9]
reg.inputs.convergence_window_size = [20] * 2
reg.inputs.smoothing_sigmas = [[1, 0], [2, 1, 0]]
reg.inputs.sigma_units = ['vox'] * 2
reg.inputs.shrink_factors = [[2, 1], [4, 2, 1]]
reg.inputs.use_estimate_learning_rate_once = [True, True]
reg.inputs.use_histogram_matching = [True, True] # This is the default
reg.inputs.output_warped_image = 'output_warped_image.nii.gz'
reg.inputs.winsorize_lower_quantile = 0.01
reg.inputs.winsorize_upper_quantile = 0.99
"""
#satra says:
reg.inputs.transforms = ['Rigid', 'Affine', 'SyN']
reg.inputs.transform_parameters = [(0.1, ), (0.1, ), (0.2, 3.0, 0.0)]
reg.inputs.number_of_iterations = ([[10000, 111110, 11110]] * 2 +
[[100, 50, 30]])
reg.inputs.dimension = 3
reg.inputs.write_composite_transform = True
reg.inputs.collapse_output_transforms = True
reg.inputs.initial_moving_transform_com = True
reg.inputs.metric = ['Mattes'] * 2 + [['Mattes', 'CC']]
reg.inputs.metric_weight = [1] * 2 + [[0.5, 0.5]]
reg.inputs.radius_or_number_of_bins = [32] * 2 + [[32, 4]]
reg.inputs.sampling_strategy = ['Regular'] * 2 + [[None, None]]
reg.inputs.sampling_percentage = [0.3] * 2 + [[None, None]]
reg.inputs.convergence_threshold = [1.e-8] * 2 + [-0.01]
reg.inputs.convergence_window_size = [20] * 2 + [5]
reg.inputs.smoothing_sigmas = [[4, 2, 1]] * 2 + [[1, 0.5, 0]]
reg.inputs.sigma_units = ['vox'] * 3
reg.inputs.shrink_factors = [[3, 2, 1]] * 2 + [[4, 2, 1]]
reg.inputs.use_estimate_learning_rate_once = [True] * 3
reg.inputs.use_histogram_matching = [False] * 2 + [True]
reg.inputs.winsorize_lower_quantile = 0.005
reg.inputs.winsorize_upper_quantile = 0.995
reg.inputs.args = '--float'
# Create png images for quality check
myqc = qc.vol2png("anat2mni", "ANTS3", overlayiterated=False)
myqc.inputs.inputspec.overlay_image = globals._FSLDIR_ + globals._brainref #TODO_ready: 1 or 2mm???
myqc.inputs.slicer.image_width = 500 # 5000 # for the 1mm template
myqc.inputs.slicer.threshold_edges = 0.1 # 0.1 # for the 1mm template
# Save outputs which are important
ds = pe.Node(interface=io.DataSink(), name='ds_nii')
ds.inputs.base_directory = SinkDir
ds.inputs.regexp_substitutions = [("(\/)[^\/]*$", ".nii.gz")]
# Define outputs of the workflow
outputspec = pe.Node(utility.IdentityInterface(fields=[
'output_brain', 'linear_xfm', 'invlinear_xfm', 'nonlinear_xfm',
'invnonlinear_xfm', 'std_template'
]),
name='outputspec')
outputspec.inputs.std_template = inputspec.inputs.reference_brain
# Create workflow nad connect nodes
analysisflow = pe.Workflow(name=wf_name)
analysisflow.connect(inputspec, 'reference_skull', reg, 'fixed_image')
#analysisflow.connect(inputspec, 'reference_brain', reg, 'fixed_image_mask')
analysisflow.connect(inputspec, 'skull', reg, 'moving_image')
#analysisflow.connect(inputspec, 'brain', reg, 'moving_image_mask')
analysisflow.connect(reg, 'composite_transform', outputspec,
'nonlinear_xfm')
analysisflow.connect(reg, 'inverse_composite_transform', outputspec,
'invnonlinear_xfm')
analysisflow.connect(reg, 'warped_image', outputspec, 'output_brain')
analysisflow.connect(reg, 'warped_image', ds, 'anat2mni_std')
analysisflow.connect(reg, 'composite_transform', ds, 'anat2mni_warpfield')
analysisflow.connect(reg, 'warped_image', myqc, 'inputspec.bg_image')
return analysisflow
def bbr_workflow(SinkTag="func_preproc", wf_name="func2anat"):
"""
Modified version of CPAC.registration.registration:
`source: https://fcp-indi.github.io/docs/developer/_modules/CPAC/registration/registration.html`
BBR registration of functional image to anat.
Workflow inputs:
:param func: One volume of the 4D fMRI (The one which is the closest to the fieldmap recording in time should be chosen- e.g: if fieldmap was recorded after the fMRI the last volume of it should be chosen).
:param skull: The oriented high res T1w image.
:param anat_wm_segmentation: WM probability mask in .
:param anat_csf_segmentation: CSF probability mask in
:param bbr_schedule: Parameters which specifies BBR options.
:param SinkDir:
:param SinkTag: The output directory in which the returned images (see workflow outputs) could be found.
Workflow outputs:
:return: bbreg_workflow - workflow
func="/home/balint/Dokumentumok/phd/essen/PAINTER/probe/s002/func_data.nii.gz",
skull="/home/balint/Dokumentumok/phd/essen/PAINTER/probe/MS001/highres.nii.gz",
anat_wm_segmentation="/home/balint/Dokumentumok/phd/essen/PAINTER/probe/anat_preproc/fast/fast__prob_2.nii.gz",
Balint Kincses
[email protected]
2018
"""
import os
import nipype.pipeline as pe
from nipype.interfaces.utility import Function
import nipype.interfaces.utility as utility
import nipype.interfaces.fsl as fsl
import nipype.interfaces.io as io
import PUMI.func_preproc.Onevol as onevol
import PUMI.utils.QC as qc
import PUMI.utils.globals as globals
SinkDir = os.path.abspath(globals._SinkDir_ + "/" + SinkTag)
if not os.path.exists(SinkDir):
os.makedirs(SinkDir)
# Define inputs of the workflow
inputspec = pe.Node(utility.IdentityInterface(fields=[
'func', 'skull', 'anat_wm_segmentation', 'anat_gm_segmentation',
'anat_csf_segmentation', 'anat_ventricle_segmentation'
]),
name='inputspec')
myonevol = onevol.onevol_workflow()
# trilinear interpolation is used by default in linear registration for func to anat
linear_reg = pe.MapNode(interface=fsl.FLIRT(),
iterfield=['in_file', 'reference'],
name='linear_func_to_anat')
linear_reg.inputs.cost = 'corratio'
linear_reg.inputs.dof = 6
linear_reg.inputs.out_matrix_file = "lin_mat"
# WM probability map is thresholded and masked
wm_bb_mask = pe.MapNode(interface=fsl.ImageMaths(),
iterfield=['in_file'],
name='wm_bb_mask')
wm_bb_mask.inputs.op_string = '-thr 0.5 -bin'
# CSf probability map is thresholded and masked
csf_bb_mask = pe.MapNode(interface=fsl.ImageMaths(),
iterfield=['in_file'],
name='csf_bb_mask')
csf_bb_mask.inputs.op_string = '-thr 0.5 -bin'
# GM probability map is thresholded and masked
gm_bb_mask = pe.MapNode(interface=fsl.ImageMaths(),
iterfield=['in_file'],
name='gm_bb_mask')
gm_bb_mask.inputs.op_string = '-thr 0.1 -bin' # liberal mask to capture all gm signal
# ventricle probability map is thresholded and masked
vent_bb_mask = pe.MapNode(interface=fsl.ImageMaths(),
iterfield=['in_file'],
name='vent_bb_mask')
vent_bb_mask.inputs.op_string = '-thr 0.8 -bin -ero -dilM' # stricter threshold and some morphology for compcor
# add the CSF and WM masks
#add_masks=pe.MapNode(interface=fsl.ImageMaths(),
# iterfield=['in_file','in_file2'],
# name='add_masks')
#add_masks.inputs.op_string = ' -add'
# A function is defined for define bbr argumentum which says flirt to perform bbr registration
# for each element of the list, due to MapNode
def bbreg_args(bbreg_target):
return '-cost bbr -wmseg ' + bbreg_target
bbreg_arg_convert = pe.MapNode(interface=Function(
input_names=["bbreg_target"],
output_names=["arg"],
function=bbreg_args),
iterfield=['bbreg_target'],
name="bbr_arg_converter")
# BBR registration within the FLIRT node
bbreg_func_to_anat = pe.MapNode(
interface=fsl.FLIRT(),
iterfield=['in_file', 'reference', 'in_matrix_file', 'args'],
name='bbreg_func_to_anat')
bbreg_func_to_anat.inputs.dof = 6
# calculate the inverse of the transformation matrix (of func to anat)
convertmatrix = pe.MapNode(interface=fsl.ConvertXFM(),
iterfield=['in_file'],
name="convertmatrix")
convertmatrix.inputs.invert_xfm = True
# use the invers registration (anat to func) to transform anatomical csf mask
reg_anatmask_to_func1 = pe.MapNode(
interface=fsl.FLIRT(apply_xfm=True, interp='nearestneighbour'),
iterfield=['in_file', 'reference', 'in_matrix_file'],
name='anatmasks_to_func1')
#reg_anatmask_to_func1.inputs.apply_xfm = True
# use the invers registration (anat to func) to transform anatomical wm mask
reg_anatmask_to_func2 = pe.MapNode(
interface=fsl.FLIRT(apply_xfm=True, interp='nearestneighbour'),
iterfield=['in_file', 'reference', 'in_matrix_file'],
name='anatmasks_to_func2')
#reg_anatmask_to_func2.inputs.apply_xfm = True
# use the invers registration (anat to func) to transform anatomical gm mask
reg_anatmask_to_func3 = pe.MapNode(
interface=fsl.FLIRT(apply_xfm=True, interp='nearestneighbour'),
iterfield=['in_file', 'reference', 'in_matrix_file'],
name='anatmasks_to_func3')
# reg_anatmask_to_func2.inputs.apply_xfm = True
# use the invers registration (anat to func) to transform anatomical gm mask
reg_anatmask_to_func4 = pe.MapNode(
interface=fsl.FLIRT(apply_xfm=True, interp='nearestneighbour'),
iterfield=['in_file', 'reference', 'in_matrix_file'],
name='anatmasks_to_func4')
# reg_anatmask_to_func2.inputs.apply_xfm = True
# Create png images for quality check
myqc = qc.vol2png("func2anat")
# Save outputs which are important
ds = pe.Node(interface=io.DataSink(), name='ds_nii')
ds.inputs.base_directory = SinkDir
ds.inputs.regexp_substitutions = [("(\/)[^\/]*$", ".nii.gz")]
# Define outputs of the workflow
outputspec = pe.Node(utility.IdentityInterface(fields=[
'func_sample2anat', 'example_func', 'func_to_anat_linear_xfm',
'anat_to_func_linear_xfm', 'csf_mask_in_funcspace',
'wm_mask_in_funcspace', 'gm_mask_in_funcspace',
'ventricle_mask_in_funcspace'
]),
name='outputspec')
analysisflow = pe.Workflow(name=wf_name)
analysisflow.base_dir = '.'
analysisflow.connect(inputspec, 'func', myonevol, 'inputspec.func')
analysisflow.connect(myonevol, 'outputspec.func1vol', linear_reg,
'in_file')
analysisflow.connect(inputspec, 'skull', linear_reg, 'reference')
analysisflow.connect(linear_reg, 'out_matrix_file', bbreg_func_to_anat,
'in_matrix_file')
analysisflow.connect(myonevol, 'outputspec.func1vol', bbreg_func_to_anat,
'in_file')
analysisflow.connect(inputspec, 'anat_wm_segmentation', bbreg_arg_convert,
'bbreg_target')
analysisflow.connect(bbreg_arg_convert, 'arg', bbreg_func_to_anat, 'args')
analysisflow.connect(inputspec, 'skull', bbreg_func_to_anat, 'reference')
analysisflow.connect(bbreg_func_to_anat, 'out_matrix_file', convertmatrix,
'in_file')
analysisflow.connect(convertmatrix, 'out_file', reg_anatmask_to_func1,
'in_matrix_file')
analysisflow.connect(myonevol, 'outputspec.func1vol',
reg_anatmask_to_func1, 'reference')
analysisflow.connect(csf_bb_mask, 'out_file', reg_anatmask_to_func1,
'in_file')
analysisflow.connect(convertmatrix, 'out_file', reg_anatmask_to_func2,
'in_matrix_file')
analysisflow.connect(myonevol, 'outputspec.func1vol',
reg_anatmask_to_func2, 'reference')
analysisflow.connect(wm_bb_mask, 'out_file', reg_anatmask_to_func2,
'in_file')
analysisflow.connect(convertmatrix, 'out_file', reg_anatmask_to_func3,
'in_matrix_file')
analysisflow.connect(myonevol, 'outputspec.func1vol',
reg_anatmask_to_func3, 'reference')
analysisflow.connect(gm_bb_mask, 'out_file', reg_anatmask_to_func3,
'in_file')
analysisflow.connect(convertmatrix, 'out_file', reg_anatmask_to_func4,
'in_matrix_file')
analysisflow.connect(myonevol, 'outputspec.func1vol',
reg_anatmask_to_func4, 'reference')
analysisflow.connect(vent_bb_mask, 'out_file', reg_anatmask_to_func4,
'in_file')
analysisflow.connect(inputspec, 'anat_wm_segmentation', wm_bb_mask,
'in_file')
analysisflow.connect(inputspec, 'anat_csf_segmentation', csf_bb_mask,
'in_file')
analysisflow.connect(inputspec, 'anat_gm_segmentation', gm_bb_mask,
'in_file')
analysisflow.connect(inputspec, 'anat_ventricle_segmentation',
vent_bb_mask, 'in_file')
analysisflow.connect(bbreg_func_to_anat, 'out_file', outputspec,
'func_sample2anat')
analysisflow.connect(bbreg_func_to_anat, 'out_matrix_file', outputspec,
'func_to_anat_linear_xfm')
analysisflow.connect(reg_anatmask_to_func1, 'out_file', outputspec,
'csf_mask_in_funcspace')
analysisflow.connect(reg_anatmask_to_func2, 'out_file', outputspec,
'wm_mask_in_funcspace')
analysisflow.connect(reg_anatmask_to_func3, 'out_file', outputspec,
'gm_mask_in_funcspace')
analysisflow.connect(reg_anatmask_to_func4, 'out_file', outputspec,
'ventricle_mask_in_funcspace')
analysisflow.connect(myonevol, 'outputspec.func1vol', outputspec,
'example_func')
analysisflow.connect(convertmatrix, 'out_file', outputspec,
'anat_to_func_linear_xfm')
analysisflow.connect(bbreg_func_to_anat, 'out_file', ds, "func2anat")
analysisflow.connect(bbreg_func_to_anat, 'out_file', myqc,
'inputspec.bg_image')
analysisflow.connect(wm_bb_mask, 'out_file', myqc,
'inputspec.overlay_image')
return analysisflow
def anat2mni_ants_workflow_harcoded(SinkTag="anat_preproc",
wf_name="anat2mni_ants"):
"""
Register skull and brain extracted image to MNI space and return the transformation martices.
Using ANTS, doing it with a hardcoded function, a'la C-PAC.
This uses brain masks and full head images, as well.
Workflow inputs:
:param skull: The reoriented anatomical file.
:param brain: The brain extracted anat.
:param ref_skull: MNI152 skull file.
:param ref_brain: MNI152 brain file.
:param SinkDir:
:param SinkTag: The output directiry in which the returned images (see workflow outputs) could be found.
Workflow outputs:
:return: anat2mni_workflow - workflow
anat="/home/balint/Dokumentumok/phd/essen/PAINTER/probe/MS001/highres.nii.gz",
brain="/home/balint/Dokumentumok/phd/essen/PAINTER/probe/MS001/highres_brain.nii.gz",
Tamas Spisak
[email protected]
2018
"""
from nipype.interfaces.utility import Function
SinkDir = os.path.abspath(globals._SinkDir_ + "/" + SinkTag)
if not os.path.exists(SinkDir):
os.makedirs(SinkDir)
# Define inputs of workflow
inputspec = pe.Node(utility.IdentityInterface(
fields=['brain', 'skull', 'reference_brain', 'reference_skull']),
name='inputspec')
inputspec.inputs.reference_brain = globals._FSLDIR_ + globals._brainref #TODO_ready: 1 or 2mm???
inputspec.inputs.reference_skull = globals._FSLDIR_ + globals._headref
# Multi-stage registration node with ANTS
reg = pe.MapNode(interface=Function(input_names=[
'anatomical_brain', 'reference_brain', 'anatomical_skull',
'reference_skull'
],
output_names=[
'transform_composite',
'transform_inverse_composite',
'warped_image'
],
function=hardcoded_reg_fast),
iterfield=['anatomical_brain', 'anatomical_skull'],
name="ANTS_hardcoded",
mem_gb=4.1)
# Calculate linear transformation with FSL. This matrix has to be used in segmentation with fast if priors are set. (the default).
# Linear registration node
linear_reg = pe.MapNode(interface=fsl.FLIRT(),
iterfield=['in_file'],
name='linear_reg_0')
linear_reg.inputs.cost = 'corratio'
# Calculate the invers of the linear transformation
inv_flirt_xfm = pe.MapNode(interface=fsl.utils.ConvertXFM(),
iterfield=['in_file'],
name='inv_linear_reg0_xfm')
inv_flirt_xfm.inputs.invert_xfm = True
# # or hardcoded_reg_cpac
# Create png images for quality check
myqc = qc.vol2png("anat2mni", "ANTS", overlayiterated=False)
myqc.inputs.inputspec.overlay_image = globals._FSLDIR_ + globals._brainref #TODO_ready: 1 or 2mm???
myqc.inputs.slicer.image_width = 500 # 5000 # for the 1mm template
myqc.inputs.slicer.threshold_edges = 0.1 # 0.1 # for the 1mm template
# Save outputs which are important
ds = pe.Node(interface=io.DataSink(), name='ds_nii')
ds.inputs.base_directory = SinkDir
ds.inputs.regexp_substitutions = [("(\/)[^\/]*$", ".nii.gz")]
# Define outputs of the workflow
outputspec = pe.Node(utility.IdentityInterface(fields=[
'output_brain', 'linear_xfm', 'invlinear_xfm', 'nonlinear_xfm',
'invnonlinear_xfm', 'std_template'
]),
name='outputspec')
outputspec.inputs.std_template = inputspec.inputs.reference_brain
# Create workflow nad connect nodes
analysisflow = pe.Workflow(name=wf_name)
# FSL part for the transformation matrix
analysisflow.connect(inputspec, 'brain', linear_reg, 'in_file')
analysisflow.connect(inputspec, 'reference_brain', linear_reg, 'reference')
analysisflow.connect(linear_reg, 'out_matrix_file', inv_flirt_xfm,
'in_file')
analysisflow.connect(inv_flirt_xfm, 'out_file', outputspec,
'invlinear_xfm')
analysisflow.connect(inputspec, 'reference_skull', reg, 'reference_skull')
analysisflow.connect(inputspec, 'reference_brain', reg, 'reference_brain')
analysisflow.connect(inputspec, 'skull', reg, 'anatomical_skull')
analysisflow.connect(inputspec, 'brain', reg, 'anatomical_brain')
analysisflow.connect(reg, 'transform_composite', outputspec,
'nonlinear_xfm')
analysisflow.connect(reg, 'transform_inverse_composite', outputspec,
'invnonlinear_xfm')
analysisflow.connect(reg, 'warped_image', outputspec, 'output_brain')
analysisflow.connect(reg, 'warped_image', ds, 'anat2mni_std')
analysisflow.connect(reg, 'transform_composite', ds, 'anat2mni_warpfield')
analysisflow.connect(reg, 'warped_image', myqc, 'inputspec.bg_image')
return analysisflow
def create_all_calcarine_reward_2_h5_workflow(
analysis_info, name='all_calcarine_reward_nii_2_h5'):
import os.path as op
import tempfile
import nipype.pipeline as pe
from nipype.interfaces import fsl
from nipype.interfaces.utility import Function, Merge, IdentityInterface
from spynoza.nodes.utils import get_scaninfo, dyns_min_1, topup_scan_params, apply_scan_params
from nipype.interfaces.io import SelectFiles, DataSink
# Importing of custom nodes from spynoza packages; assumes that spynoza is installed:
# pip install git+https://github.com/spinoza-centre/spynoza.git@develop
from utils.utils import mask_nii_2_hdf5, combine_eye_hdfs_to_nii_hdf
input_node = pe.Node(
IdentityInterface(fields=['sub_id', 'preprocessed_data_dir']),
name='inputspec')
# i/o node
datasource_templates = dict(mcf='{sub_id}/mcf/*.nii.gz',
psc='{sub_id}/psc/*.nii.gz',
tf='{sub_id}/tf/*.nii.gz',
GLM='{sub_id}/GLM/*.nii.gz',
eye='{sub_id}/eye/h5/*.h5',
rois='{sub_id}/roi/*_vol.nii.gz')
datasource = pe.Node(SelectFiles(datasource_templates,
sort_filelist=True,
raise_on_empty=False),
name='datasource')
hdf5_psc_masker = pe.Node(Function(
input_names=['in_files', 'mask_files', 'hdf5_file', 'folder_alias'],
output_names=['hdf5_file'],
function=mask_nii_2_hdf5),
name='hdf5_psc_masker')
hdf5_psc_masker.inputs.folder_alias = 'psc'
hdf5_psc_masker.inputs.hdf5_file = op.join(tempfile.mkdtemp(), 'roi.h5')
hdf5_tf_masker = pe.Node(Function(
input_names=['in_files', 'mask_files', 'hdf5_file', 'folder_alias'],
output_names=['hdf5_file'],
function=mask_nii_2_hdf5),
name='hdf5_tf_masker')
hdf5_tf_masker.inputs.folder_alias = 'tf'
hdf5_psc_masker.inputs.hdf5_file = op.join(tempfile.mkdtemp(), 'roi.h5')
hdf5_mcf_masker = pe.Node(Function(
input_names=['in_files', 'mask_files', 'hdf5_file', 'folder_alias'],
output_names=['hdf5_file'],
function=mask_nii_2_hdf5),
name='hdf5_mcf_masker')
hdf5_mcf_masker.inputs.folder_alias = 'mcf'
hdf5_GLM_masker = pe.Node(Function(
input_names=['in_files', 'mask_files', 'hdf5_file', 'folder_alias'],
output_names=['hdf5_file'],
function=mask_nii_2_hdf5),
name='hdf5_GLM_masker')
hdf5_GLM_masker.inputs.folder_alias = 'GLM'
eye_hdfs_to_nii_masker = pe.Node(Function(
input_names=['nii_hdf5_file', 'eye_hdf_filelist', 'new_alias'],
output_names=['nii_hdf5_file'],
function=combine_eye_hdfs_to_nii_hdf),
name='eye_hdfs_to_nii_masker')
eye_hdfs_to_nii_masker.inputs.new_alias = 'eye'
# node for datasinking
datasink = pe.Node(DataSink(), name='sinker')
datasink.inputs.parameterization = False
all_calcarine_reward_nii_2_h5_workflow = pe.Workflow(name=name)
all_calcarine_reward_nii_2_h5_workflow.connect(input_node,
'preprocessed_data_dir',
datasink, 'base_directory')
all_calcarine_reward_nii_2_h5_workflow.connect(input_node, 'sub_id',
datasink, 'container')
all_calcarine_reward_nii_2_h5_workflow.connect(input_node,
'preprocessed_data_dir',
datasource,
'base_directory')
all_calcarine_reward_nii_2_h5_workflow.connect(input_node, 'sub_id',
datasource, 'sub_id')
all_calcarine_reward_nii_2_h5_workflow.connect(datasource, 'psc',
hdf5_psc_masker, 'in_files')
all_calcarine_reward_nii_2_h5_workflow.connect(datasource, 'rois',
hdf5_psc_masker,
'mask_files')
# the hdf5_file is created by the psc node, and then passed from masker to masker on into the datasink.
all_calcarine_reward_nii_2_h5_workflow.connect(hdf5_psc_masker,
'hdf5_file', hdf5_tf_masker,
'hdf5_file')
all_calcarine_reward_nii_2_h5_workflow.connect(datasource, 'tf',
hdf5_tf_masker, 'in_files')
all_calcarine_reward_nii_2_h5_workflow.connect(datasource, 'rois',
hdf5_tf_masker,
'mask_files')
all_calcarine_reward_nii_2_h5_workflow.connect(hdf5_tf_masker, 'hdf5_file',
hdf5_mcf_masker,
'hdf5_file')
all_calcarine_reward_nii_2_h5_workflow.connect(datasource, 'mcf',
hdf5_mcf_masker, 'in_files')
all_calcarine_reward_nii_2_h5_workflow.connect(datasource, 'rois',
hdf5_mcf_masker,
'mask_files')
all_calcarine_reward_nii_2_h5_workflow.connect(datasource, 'GLM',
hdf5_GLM_masker, 'in_files')
all_calcarine_reward_nii_2_h5_workflow.connect(datasource, 'rois',
hdf5_GLM_masker,
'mask_files')
all_calcarine_reward_nii_2_h5_workflow.connect(hdf5_mcf_masker,
'hdf5_file',
hdf5_GLM_masker,
'hdf5_file')
all_calcarine_reward_nii_2_h5_workflow.connect(hdf5_GLM_masker,
'hdf5_file',
eye_hdfs_to_nii_masker,
'nii_hdf5_file')
all_calcarine_reward_nii_2_h5_workflow.connect(datasource, 'eye',
eye_hdfs_to_nii_masker,
'eye_hdf_filelist')
all_calcarine_reward_nii_2_h5_workflow.connect(eye_hdfs_to_nii_masker,
'nii_hdf5_file', datasink,
'h5')
return all_calcarine_reward_nii_2_h5_workflow
def create_topup_workflow(analysis_info, name='topup'):
###########################################################################
# NODES
###########################################################################
input_node = pe.Node(IdentityInterface(fields=[
'in_files', 'alt_files', 'conf_file', 'output_directory', 'echo_time',
'phase_encoding_direction', 'epi_factor'
]),
name='inputspec')
output_node = pe.Node(
IdentityInterface(fields=['out_files', 'field_coefs']),
name='outputspec')
get_info = pe.MapNode(interface=Get_scaninfo,
name='get_scaninfo',
iterfield=['in_file'])
dyns_min_1_node = pe.MapNode(interface=Dyns_min_1,
name='dyns_min_1_node',
iterfield=['dyns'])
topup_scan_params_node = pe.Node(interface=Topup_scan_params,
name='topup_scan_params')
apply_scan_params_node = pe.MapNode(interface=Apply_scan_params,
name='apply_scan_params',
iterfield=['nr_trs'])
PE_ref = pe.MapNode(fsl.ExtractROI(t_size=1),
name='PE_ref',
iterfield=['in_file', 't_min'])
# hard-coded the timepoint for this node, no more need for alt_t.
PE_alt = pe.MapNode(fsl.ExtractROI(t_min=0, t_size=1),
name='PE_alt',
iterfield=['in_file'])
PE_comb = pe.MapNode(Merge(2), name='PE_list', iterfield=['in1', 'in2'])
PE_merge = pe.MapNode(fsl.Merge(dimension='t'),
name='PE_merged',
iterfield=['in_files'])
# implementing the contents of b02b0.cnf in the args,
# while supplying an emtpy text file as a --config option
# gets topup going on our server.
topup_args = """--warpres=20,16,14,12,10,6,4,4,4
--subsamp=1,1,1,1,1,1,1,1,1
--fwhm=8,6,4,3,3,2,1,0,0
--miter=5,5,5,5,5,10,10,20,20
--lambda=0.005,0.001,0.0001,0.000015,0.000005,0.0000005,0.00000005,0.0000000005,0.00000000001
--ssqlambda=1
--regmod=bending_energy
--estmov=1,1,1,1,1,0,0,0,0
--minmet=0,0,0,0,0,1,1,1,1
--splineorder=3
--numprec=double
--interp=spline
--scale=1 -v"""
topup_node = pe.MapNode(fsl.TOPUP(args=topup_args),
name='topup',
iterfield=['in_file'])
unwarp = pe.MapNode(fsl.ApplyTOPUP(in_index=[1], method='jac'),
name='unwarp',
iterfield=[
'in_files', 'in_topup_fieldcoef',
'in_topup_movpar', 'encoding_file'
])
###########################################################################
# WORKFLOW
###########################################################################
topup_workflow = pe.Workflow(name=name)
# these are now mapnodes because they split up over files
topup_workflow.connect(input_node, 'in_files', get_info, 'in_file')
topup_workflow.connect(input_node, 'in_files', PE_ref, 'in_file')
topup_workflow.connect(input_node, 'alt_files', PE_alt, 'in_file')
# this is a simple node, connecting to the input node
topup_workflow.connect(input_node, 'phase_encoding_direction',
topup_scan_params_node, 'pe_direction')
topup_workflow.connect(input_node, 'echo_time', topup_scan_params_node,
'te')
topup_workflow.connect(input_node, 'epi_factor', topup_scan_params_node,
'epi_factor')
# preparing a node here, which automatically iterates over dyns output of the get_info mapnode
topup_workflow.connect(input_node, 'echo_time', apply_scan_params_node,
'te')
topup_workflow.connect(input_node, 'phase_encoding_direction',
apply_scan_params_node, 'pe_direction')
topup_workflow.connect(input_node, 'epi_factor', apply_scan_params_node,
'epi_factor')
topup_workflow.connect(get_info, 'dyns', apply_scan_params_node, 'nr_trs')
# the nr_trs and in_files both propagate into the PR_ref node
topup_workflow.connect(get_info, 'dyns', dyns_min_1_node, 'dyns')
topup_workflow.connect(dyns_min_1_node, 'dyns_1', PE_ref, 't_min')
topup_workflow.connect(PE_ref, 'roi_file', PE_comb, 'in1')
topup_workflow.connect(PE_alt, 'roi_file', PE_comb, 'in2')
topup_workflow.connect(PE_comb, 'out', PE_merge, 'in_files')
topup_workflow.connect(topup_scan_params_node, 'fn', topup_node,
'encoding_file')
topup_workflow.connect(PE_merge, 'merged_file', topup_node, 'in_file')
topup_workflow.connect(input_node, 'conf_file', topup_node, 'config')
topup_workflow.connect(input_node, 'in_files', unwarp, 'in_files')
topup_workflow.connect(apply_scan_params_node, 'fn', unwarp,
'encoding_file')
topup_workflow.connect(topup_node, 'out_fieldcoef', unwarp,
'in_topup_fieldcoef')
topup_workflow.connect(topup_node, 'out_movpar', unwarp, 'in_topup_movpar')
topup_workflow.connect(unwarp, 'out_corrected', output_node, 'out_files')
topup_workflow.connect(topup_node, 'out_fieldcoef', output_node,
'field_coefs')
# ToDo: automatic datasink?
return topup_workflow
