def bet_workflow(Robust=True,
fmri=False,
SinkTag="anat_preproc",
wf_name="brain_extraction"):
"""
Modified version of CPAC.anat_preproc.anat_preproc:
`source: https://fcp-indi.github.io/docs/developer/_modules/CPAC/anat_preproc/anat_preproc.html`
Creates a brain extracted image and its mask from a T1w anatomical image.
Workflow inputs:
:param anat: The reoriented anatomical file.
:param SinkDir:
:param SinkTag: The output directiry in which the returned images (see workflow outputs) could be found.
Workflow outputs:
:return: bet_workflow - workflow
Balint Kincses
[email protected]
2018
"""
import os
import nipype
import nipype.pipeline as pe
import nipype.interfaces.utility as utility
import nipype.interfaces.fsl as fsl
import nipype.interfaces.io as io
import PUMI.utils.QC as qc
import PUMI.utils.globals as globals
import PUMI.func_preproc.Onevol as onevol
SinkDir = os.path.abspath(globals._SinkDir_ + "/" + SinkTag)
if not os.path.exists(SinkDir):
os.makedirs(SinkDir)
#Basic interface class generates identity mappings
inputspec = pe.Node(
utility.IdentityInterface(fields=[
'in_file',
'opt_R',
'fract_int_thr', # optional
'vertical_gradient'
]), # optional
name='inputspec')
inputspec.inputs.opt_R = Robust
if fmri:
inputspec.inputs.fract_int_thr = globals._fsl_bet_fract_int_thr_func_
else:
inputspec.inputs.fract_int_thr = globals._fsl_bet_fract_int_thr_anat_
inputspec.inputs.vertical_gradient = globals._fsl_bet_vertical_gradient_
#Wraps command **bet**
bet = pe.MapNode(interface=fsl.BET(), iterfield=['in_file'], name='bet')
bet.inputs.mask = True
# bet.inputs.robust=Robust
if fmri:
bet.inputs.functional = True
myonevol = onevol.onevol_workflow(wf_name="onevol")
applymask = pe.MapNode(fsl.ApplyMask(),
iterfield=['in_file', 'mask_file'],
name="apply_mask")
myqc = qc.vol2png(wf_name, overlay=True)
#Basic interface class generates identity mappings
outputspec = pe.Node(
utility.IdentityInterface(fields=['brain', 'brain_mask']),
name='outputspec')
# Save outputs which are important
ds = pe.Node(interface=io.DataSink(), name='ds')
ds.inputs.base_directory = SinkDir
ds.inputs.regexp_substitutions = [("(\/)[^\/]*$", ".nii.gz")]
#Create a workflow to connect all those nodes
analysisflow = nipype.Workflow(
wf_name) # The name here determine the folder of the workspace
analysisflow.base_dir = '.'
analysisflow.connect(inputspec, 'in_file', bet, 'in_file')
analysisflow.connect(inputspec, 'opt_R', bet, 'robust')
analysisflow.connect(inputspec, 'fract_int_thr', bet, 'frac')
analysisflow.connect(inputspec, 'vertical_gradient', bet,
'vertical_gradient')
analysisflow.connect(bet, 'mask_file', outputspec, 'brain_mask')
if fmri:
analysisflow.connect(bet, 'mask_file', myonevol, 'inputspec.func')
analysisflow.connect(myonevol, 'outputspec.func1vol', applymask,
'mask_file')
analysisflow.connect(inputspec, 'in_file', applymask, 'in_file')
analysisflow.connect(applymask, 'out_file', outputspec, 'brain')
else:
analysisflow.connect(bet, 'out_file', outputspec, 'brain')
analysisflow.connect(bet, 'out_file', ds, 'bet_brain')
analysisflow.connect(bet, 'mask_file', ds, 'brain_mask')
analysisflow.connect(inputspec, 'in_file', myqc, 'inputspec.bg_image')
analysisflow.connect(bet, 'out_file', myqc, 'inputspec.overlay_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 compcor_workflow(SinkTag="func_preproc", wf_name="compcor"):
"""
`source: -`
Component based noise reduction method (Behzadi et al.,2007): Regressing out principal components from noise ROIs.
Here the aCompCor is used.
Workflow inputs:
:param func_aligned: The reoriented and realigned functional image.
:param mask_files: Mask files which determine ROI(s). The default mask is the
:param components_file
:param num_componenets:
:param pre_filter: Detrend time series prior to component extraction.
:param TR
: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: slt_workflow - workflow
Balint Kincses
[email protected]
2018
"""
import os
import nipype
import nipype.pipeline as pe
import nipype.algorithms.confounds as cnf
import PUMI.func_preproc.info.info_get as info_get
import PUMI.utils.utils_convert as utils_convert
import nipype.interfaces.io as io
import nipype.interfaces.utility as utility
import nipype.interfaces.fsl as fsl
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)
# Basic interface class generates identity mappings
inputspec = pe.Node(
utility.IdentityInterface(fields=['func_aligned', 'mask_file']),
name='inputspec')
myqc = qc.vol2png("compcor_noiseroi")
# 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")]
# standardize timeseries prior to compcor. added by tspisak
scale = pe.MapNode(interface=utility.Function(input_names=['in_file'],
output_names=['scaled_file'],
function=scale_vol),
iterfield=['in_file'],
name='scale_func')
# Calculate compcor files
compcor = pe.MapNode(
interface=cnf.ACompCor(pre_filter='polynomial',
header_prefix="",
num_components=5),
iterfield=['realigned_file', 'repetition_time', 'mask_files'],
name='compcor')
# Custom interface wrapping function Float2Str
func_str2float = pe.MapNode(interface=utils_convert.Str2Float,
iterfield=['str'],
name='func_str2float')
# Drop first line of the Acompcor function output
drop_firstline = pe.MapNode(interface=utils_convert.DropFirstLine,
iterfield=['txt'],
name='drop_firstline')
# Custom interface wrapping function TR
TRvalue = pe.MapNode(interface=info_get.TR,
iterfield=['in_file'],
name='TRvalue')
# Basic interface class generates identity mappings
outputspec = pe.Node(utility.IdentityInterface(fields=['components_file']),
name='outputspec')
# save data out with Datasink
ds_text = pe.Node(interface=io.DataSink(), name='ds_txt')
ds_text.inputs.regexp_substitutions = [("(\/)[^\/]*$", ".txt")]
ds_text.inputs.base_directory = SinkDir
# Create a workflow to connect all those nodes
analysisflow = nipype.Workflow(wf_name)
analysisflow.connect(inputspec, 'func_aligned', scale, 'in_file')
analysisflow.connect(scale, 'scaled_file', compcor, 'realigned_file')
analysisflow.connect(inputspec, 'func_aligned', TRvalue, 'in_file')
analysisflow.connect(TRvalue, 'TR', func_str2float, 'str')
analysisflow.connect(func_str2float, 'float', compcor, 'repetition_time')
#analysisflow.connect(TRvalue, 'TR', compcor, 'repetition_time')
analysisflow.connect(inputspec, 'mask_file', compcor, 'mask_files')
analysisflow.connect(compcor, 'components_file', drop_firstline, 'txt')
analysisflow.connect(drop_firstline, 'droppedtxtfloat', outputspec,
'components_file')
analysisflow.connect(compcor, 'components_file', ds_text, 'compcor_noise')
analysisflow.connect(inputspec, 'func_aligned', myqc, 'inputspec.bg_image')
analysisflow.connect(inputspec, 'mask_file', myqc,
'inputspec.overlay_image')
analysisflow.connect(inputspec, 'mask_file', ds_nii, 'compcor_noise_mask')
return analysisflow
def fast_workflow(SinkTag="anat_preproc",
wf_name="tissue_segmentation",
priormap=True):
"""
Modified version of CPAC.seg_preproc.seg_preproc
`source: https://fcp-indi.github.io/docs/developer/_modules/CPAC/seg_preproc/seg_preproc.html`
Do the segmentation of a brain extracted T1w image.
Workflow inputs:
:param brain: The brain extracted image, the output of the better_workflow.
:param init_transform: The standard to anat linear transformation matrix (which is calculated in the Anat2MNI.py script). Beware of the resolution of the reference (standard) image, the default value is 2mm.
:param priorprob: A list of tissue probability maps in the prior (=reference=standard) space. By default it must be 3 element(in T1w images the CSF, GM, WM order is valid)
:param SinkDir:
:param SinkTag: The output directiry in which the returned images (see workflow outputs) could be found.
Workflow outputs:
:return: fast_workflow - workflow
Balint Kincses
[email protected]
2018
"""
#This is a Nipype generator. Warning, here be dragons.
#!/usr/bin/env python
import sys
import os
import nipype
import nipype.pipeline as pe
import nipype.interfaces.utility as utility
import nipype.interfaces.fsl as fsl
import nipype.interfaces.io as io
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)
#Basic interface class generates identity mappings
inputspec = pe.Node(
utility.IdentityInterface(fields=[
'brain',
'stand2anat_xfm', # leave empty for no prior
'priorprob'
]),
name='inputspec')
# inputspec.inputs.stand2anat_xfm='/home/analyser/Documents/PAINTER/probewith2subj/preprocess_solvetodos/anat2mni_fsl/inv_linear_reg0_xfm/mapflow/_inv_linear_reg0_xfm0/anat_brain_flirt_inv.mat'
#TODO_ready set standard mask to 2mm
if priormap:
inputspec.inputs.priorprob = [
globals._FSLDIR_ + '/data/standard/tissuepriors/avg152T1_csf.hdr',
globals._FSLDIR_ + '/data/standard/tissuepriors/avg152T1_gray.hdr',
globals._FSLDIR_ + '/data/standard/tissuepriors/avg152T1_white.hdr'
]
# TODO_ready: use prior probabilioty maps
# Wraps command **fast**
if priormap:
fast = pe.MapNode(interface=fsl.FAST(),
iterfield=['in_files', 'init_transform'],
name='fast')
else:
fast = pe.MapNode(interface=fsl.FAST(),
iterfield=['in_files'],
name='fast')
fast.inputs.img_type = 1
fast.inputs.segments = True
fast.inputs.probability_maps = True
fast.inputs.out_basename = 'fast_'
myqc = qc.vol2png("tissue_segmentation", overlay=False)
myqc.inputs.slicer.colour_map = globals._FSLDIR_ + '/etc/luts/renderjet.lut'
# Basic interface class generates identity mappings
outputspec = pe.Node(utility.IdentityInterface(fields=[
'probmap_csf', 'probmap_gm', 'probmap_wm', 'mixeltype', 'parvol_csf',
'parvol_gm', 'parvol_wm', 'partial_volume_map'
]),
name='outputspec')
# Save outputs which are important
ds = pe.Node(interface=io.DataSink(), name='ds')
ds.inputs.base_directory = SinkDir
ds.inputs.regexp_substitutions = [("(\/)[^\/]*$", ".nii.gz")]
def pickindex(vec, i):
#print "************************************************************************************************************************************************"
#print vec
#print i
return [x[i] for x in vec]
#Create a workflow to connect all those nodes
analysisflow = nipype.Workflow(wf_name)
analysisflow.base_dir = '.'
analysisflow.connect(inputspec, 'brain', fast, 'in_files')
if priormap:
analysisflow.connect(inputspec, 'stand2anat_xfm', fast,
'init_transform')
#analysisflow.connect(inputspec, 'priorprob', fast,'other_priors')
# commented out for compatibility with the original RPN-signature
# analysisflow.connect(inputspec, 'stand_csf' ,fast,('other_priors', pickindex, 0))
# analysisflow.connect(inputspec, 'stand_gm' ,fast,('other_priors', pickindex, 1))
# analysisflow.connect(inputspec, 'stand_wm' ,fast,('other_priors', pickindex, 2))
#nalysisflow.connect(fast, 'probability_maps', outputspec, 'probability_maps')
analysisflow.connect(fast, ('probability_maps', pickindex, 0), outputspec,
'probmap_csf')
analysisflow.connect(fast, ('probability_maps', pickindex, 1), outputspec,
'probmap_gm')
analysisflow.connect(fast, ('probability_maps', pickindex, 2), outputspec,
'probmap_wm')
analysisflow.connect(fast, 'mixeltype', outputspec, 'mixeltype')
#analysisflow.connect(fast, 'partial_volume_files', outputspec, 'partial_volume_files')
analysisflow.connect(fast, ('partial_volume_files', pickindex, 0),
outputspec, 'parvol_csf')
analysisflow.connect(fast, ('partial_volume_files', pickindex, 0),
outputspec, 'parvol_gm')
analysisflow.connect(fast, ('partial_volume_files', pickindex, 0),
outputspec, 'parvol_wm')
analysisflow.connect(fast, 'partial_volume_map', outputspec,
'partial_volume_map')
analysisflow.connect(fast, ('probability_maps', pickindex, 0), ds,
'fast_csf')
analysisflow.connect(fast, ('probability_maps', pickindex, 1), ds,
'fast_gm')
analysisflow.connect(fast, ('probability_maps', pickindex, 2), ds,
'fast_wm')
analysisflow.connect(fast, 'partial_volume_map', myqc,
'inputspec.bg_image')
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 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 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 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
datagrab.inputs.template = "*" # do we need this?
datagrab.inputs.field_template = dict(struct=sys.argv[1]) # specified by command line arguments
datagrab.inputs.sort_filelist = True
reorient_struct = pe.MapNode(fsl.utils.Reorient2Std(),
iterfield=['in_file'],
name="reorient_struct")
bet = pe.MapNode(interface=fsl.BET(),
iterfield=['in_file'],
iterables=[('vertical_gradient',[-0.2,0,0.2])
],
name='bet')
myqc = qc.vol2png("brain_extraction", overlay=True)
totalWorkflow = nipype.Workflow('bet_probe')
totalWorkflow.base_dir = '.'
totalWorkflow.connect([
(datagrab,reorient_struct,
[('struct','in_file')]),
(reorient_struct, bet,
[('out_file', 'in_file')]),
(bet,myqc,
[('out_file', 'inputspec.overlay_image')]),
(reorient_struct, myqc,
[('out_file','inputspec.bg_image')])
])
def fieldmapper(TE1=4.9,
TE2=7.3,
dwell_time=0.00035,
unwarp_direction="y-",
SinkTag="func_fieldmapcorr",
wf_name="fieldmap_correction"):
import os
import PUMI.utils.globals as globals
SinkDir = os.path.abspath(globals._SinkDir_ + "/" + SinkTag)
if not os.path.exists(SinkDir):
os.makedirs(SinkDir)
###########################################
# HERE INSERT PORCUPINE GENERATED CODE
# MUST DEFINE
# OutJSON: file path to JSON file contaioning the output strings to be returned
# variables can (should) use variable SinkDir (defined here as function argument)
###########################################
# To do
###########################################
# adjust number of cores with psutil.cpu_count()
###########################################
# also subtract:
# analysisflow = nipype.Workflow('FieldMapper')
# analysisflow.base_dir = '.'
###########################################
# Here comes the generated code
###########################################
# This is a Nipype generator. Warning, here be dragons.
# !/usr/bin/env python
import sys
import nipype
import nipype.pipeline as pe
import nipype.interfaces.utility as utility
import nipype.interfaces.fsl as fsl
import PUMI.utils.utils_math as utils_math
import nipype.interfaces.io as io
import PUMI.utils.QC as qc
import PUMI.utils.utils_convert as utils_convert
OutJSON = SinkDir + "/outputs.JSON"
# Basic interface class generates identity mappings
inputspec = pe.Node(utility.IdentityInterface(fields=[
'in_file', 'magnitude', 'phase', 'TE1', 'TE2', 'dwell_time',
'unwarp_direction'
]),
name='inputspec')
#defaults:
#inputspec.inputs.func = func
#inputspec.inputs.magnitude = magnitude
#inputspec.inputs.phase = phase
inputspec.inputs.TE1 = TE1
inputspec.inputs.TE2 = TE2
inputspec.inputs.dwell_time = dwell_time
inputspec.inputs.unwarp_direction = unwarp_direction
# Wraps command **bet**
bet = pe.MapNode(interface=fsl.BET(), name='bet', iterfield=['in_file'])
bet.inputs.mask = True
# Wraps command **fslmaths**
erode = pe.MapNode(interface=fsl.ErodeImage(),
name='erode',
iterfield=['in_file'])
# Wraps command **fslmaths**
erode2 = pe.MapNode(interface=fsl.ErodeImage(),
name='erode2',
iterfield=['in_file'])
# Custom interface wrapping function SubTwo
subtract = pe.Node(interface=utils_math.SubTwo, name='subtract')
# Custom interface wrapping function Abs
abs = pe.Node(interface=utils_math.Abs, name='abs')
# Wraps command **fsl_prepare_fieldmap**
preparefm = pe.MapNode(interface=fsl.PrepareFieldmap(),
name='preparefm',
iterfield=['in_phase', 'in_magnitude'])
# Wraps command **fugue**
fugue = pe.MapNode(interface=fsl.FUGUE(),
name='fugue',
iterfield=['in_file', 'fmap_in_file', 'mask_file'])
# Generic datasink module to store structured outputs
outputspec = pe.Node(interface=io.DataSink(), name='outputspec')
outputspec.inputs.base_directory = SinkDir
outputspec.inputs.regexp_substitutions = [
("func_fieldmapcorr/_NodeName_.{13}", "")
]
# Generic datasink module to store structured outputs
outputspec2 = pe.Node(interface=io.DataSink(), name='outputspec2')
outputspec2.inputs.base_directory = SinkDir
outputspec2.inputs.regexp_substitutions = [("_NodeName_.{13}", "")]
myqc_orig = qc.vol2png("fielmap_correction", tag="original")
myqc_unwarp = qc.vol2png("fielmap_correction", tag="unwarped")
# Create a workflow to connect all those nodes
analysisflow = nipype.Workflow(wf_name)
analysisflow.base_dir = '.'
analysisflow.connect(preparefm, 'out_fieldmap', outputspec2, 'fieldmap')
analysisflow.connect(abs, 'abs', preparefm, 'delta_TE')
analysisflow.connect(subtract, 'dif', abs, 'x')
analysisflow.connect(inputspec, 'unwarp_direction', fugue,
'unwarp_direction')
analysisflow.connect(fugue, 'unwarped_file', outputspec,
'func_fieldmapcorr')
analysisflow.connect(preparefm, 'out_fieldmap', fugue, 'fmap_in_file')
analysisflow.connect(erode2, 'out_file', fugue, 'mask_file')
analysisflow.connect(bet, 'mask_file', erode2, 'in_file')
analysisflow.connect(inputspec, 'dwell_time', fugue, 'dwell_time')
analysisflow.connect(inputspec, 'in_file', fugue, 'in_file')
analysisflow.connect(bet, 'out_file', erode, 'in_file')
analysisflow.connect(inputspec, 'TE2', subtract, 'b')
analysisflow.connect(inputspec, 'TE1', subtract, 'a')
analysisflow.connect(inputspec, 'phase', preparefm, 'in_phase')
analysisflow.connect(erode, 'out_file', preparefm, 'in_magnitude')
analysisflow.connect(inputspec, 'magnitude', bet, 'in_file')
analysisflow.connect(inputspec, 'magnitude', myqc_orig,
'inputspec.bg_image')
analysisflow.connect(inputspec, 'in_file', myqc_orig,
'inputspec.overlay_image')
analysisflow.connect(inputspec, 'magnitude', myqc_unwarp,
'inputspec.bg_image')
analysisflow.connect(fugue, 'unwarped_file', myqc_unwarp,
'inputspec.overlay_image')
# Run the workflow
#plugin = 'MultiProc' # adjust your desired plugin here
#plugin_args = {'n_procs': psutil.cpu_count()} # adjust to your number of cores
#analysisflow.write_graph(graph2use='flat', format='png', simple_form=False)
#analysisflow.run(plugin=plugin, plugin_args=plugin_args)
####################################################################################################
# Porcupine generated code ends here
####################################################################################################
#load and return json
# you have to be aware the keys of the json map here
#ret = json.load(open(OutJSON))
#return ret['func_fieldmapcorr'], ret['fieldmap']
return analysisflow