def create_workflow(unwarp_direction='y'):
workflow = Workflow(name='func_unwarp')
inputs = Node(
IdentityInterface(fields=[
# 'subject_id',
# 'session_id',
'funcs',
'funcmasks',
'fmap_phasediff',
'fmap_magnitude',
'fmap_mask',
]),
name='in')
outputs = Node(IdentityInterface(fields=[
'funcs',
'funcmasks',
]),
name='out')
# --- --- --- --- --- --- --- Convert to radians --- --- --- --- --- ---
# fslmaths $FUNCDIR/"$SUB"_B0_phase -div 100 -mul 3.141592653589793116
# -odt float $FUNCDIR/"$SUB"_B0_phase_rescaled
# in_file --> out_file
phase_radians = Node(fsl.ImageMaths(
op_string='-mul 3.141592653589793116 -div 100',
out_data_type='float',
suffix='_radians',
),
name='phaseRadians')
workflow.connect(inputs, 'fmap_phasediff', phase_radians, 'in_file')
# --- --- --- --- --- --- --- Unwrap Fieldmap --- --- --- --- --- ---
# --- Unwrap phase
# prelude -p $FUNCDIR/"$SUB"_B0_phase_rescaled
# -a $FUNCDIR/"$SUB"_B0_magnitude
# -o $FUNCDIR/"$SUB"_fmri_B0_phase_rescaled_unwrapped
# -m $FUNCDIR/"$SUB"_B0_magnitude_brain_mask
# magnitude_file, phase_file [, mask_file] --> unwrapped_phase_file
unwrap = MapNode(
PRELUDE(),
name='unwrap',
iterfield=['mask_file'],
)
workflow.connect([
(inputs, unwrap, [('fmap_magnitude', 'magnitude_file')]),
(inputs, unwrap, [('fmap_mask', 'mask_file')]),
(phase_radians, unwrap, [('out_file', 'phase_file')]),
])
# --- --- --- --- --- --- --- Convert to Radians / Sec --- --- --- --- ---
# fslmaths $FUNCDIR/"$SUB"_B0_phase_rescaled_unwrapped
# -mul 200 $FUNCDIR/"$SUB"_B0_phase_rescaled_unwrapped
rescale = MapNode(
fsl.ImageMaths(op_string='-mul 200'),
name='rescale',
iterfield=['in_file'],
)
workflow.connect(unwrap, 'unwrapped_phase_file', rescale, 'in_file')
# --- --- --- --- --- --- --- Unmask fieldmap --- --- --- --- ---
unmask_phase = MapNode(
FUGUE(
save_unmasked_fmap=True,
unwarp_direction=unwarp_direction,
),
name='unmask_phase',
iterfield=['mask_file', 'fmap_in_file'],
)
workflow.connect(rescale, 'out_file', unmask_phase, 'fmap_in_file')
workflow.connect(inputs, 'fmap_mask', unmask_phase, 'mask_file')
# --- --- --- --- --- --- --- Undistort functionals --- --- --- --- ---
# phasemap_in_file = phasediff
# mask_file = mask
# in_file = functional image
# dwell_time = 0.0005585 s
# unwarp_direction
undistort = MapNode(
FUGUE(
dwell_time=0.0005585,
# based on Process-NHP-MRI/Process_functional_data.md:
asym_se_time=0.020,
smooth3d=2.0,
median_2dfilter=True,
unwarp_direction=unwarp_direction,
),
name='undistort',
iterfield=['in_file', 'mask_file', 'fmap_in_file'],
)
workflow.connect(unmask_phase, 'fmap_out_file', undistort, 'fmap_in_file')
workflow.connect(inputs, 'fmap_mask', undistort, 'mask_file')
workflow.connect(inputs, 'funcs', undistort, 'in_file')
undistort_masks = undistort.clone('undistort_masks')
workflow.connect(unmask_phase, 'fmap_out_file', undistort_masks,
'fmap_in_file')
workflow.connect(inputs, 'fmap_mask', undistort_masks, 'mask_file')
workflow.connect(inputs, 'funcmasks', undistort_masks, 'in_file')
workflow.connect(undistort, 'unwarped_file', outputs, 'funcs')
workflow.connect(undistort_masks, 'unwarped_file', outputs, 'funcmasks')
return workflow
iterfield=['in_file', 'out_file'],
name='mean_masked')
mean_masked.inputs.out_file=['lin_groupmean.nii.gz','nonlin_groupmean.nii.gz','fmap_groupmean.nii.gz','topup_groupmean.nii.gz']
mean_masked.inputs.operand_file=std_brain_mask_dil
group.connect([(meaner, mean_masked, [('out_file', 'in_file')])])
# calculate sdv of means
sdv = MapNode(fsl.maths.MathsCommand(args='-Tstd'),
iterfield=['in_file', 'out_file'],
name='sdv')
sdv.inputs.out_file=['lin_groupsdv.nii.gz','nonlin_groupsdv.nii.gz','fmap_groupsdv.nii.gz','topup_groupsdv.nii.gz']
group.connect([(merger, sdv, [('merged_file', 'in_file')])])
# mask sdv file
sdv_masked = mean_masked.clone(name='sdv_masked')
sdv_masked.inputs.out_file=['lin_groupsdv.nii.gz','nonlin_groupsdv.nii.gz','fmap_groupsdv.nii.gz','topup_groupsdv.nii.gz']
sdv_masked.inputs.operand_file=std_brain_mask_dil
group.connect([(sdv, sdv_masked, [('out_file', 'in_file')])])
'''intensity difference
=======================
'''
# merge intensity diffmaps of all subjects for each contrast
diffmap_merger = merger.clone(name='diffmap_merger')
diffmap_merger.inputs.in_files=diffmap_contrastlist
# calculate mean of diffmaps for each contrast
diffmap_meaner=meaner.clone(name='diffmap_meaner')
simulated.connect([(simulation, make_list2, [('outputnode.lin_coreg', 'file1'),
('outputnode.nonlin_coreg', 'file2'),
('outputnode.fmap_coreg', 'file3')]),
(make_list2, corr_epi, [('filelist', 'image2')]),
(groundtruth, corr_epi, [('outputnode.lin_coreg', 'image1')]),
(selectfiles, corr_epi, [('anat_brain_mask', 'mask')]),
(corr_epi, corr_epi_txt, [('linreg_stats', 'stats')])])
# similarity to anatomy
lin_sim = MapNode(interface = nutil.Similarity(),
name = 'similarity_lin',
iterfield=['metric'])
lin_sim.inputs.metric = ['mi','nmi','cc','cr','crl1']
nonlin_sim = lin_sim.clone(name='similarity_nonlin')
nonlin_sim.inputs.metric = ['mi','nmi','cc','cr','crl1']
fmap_sim = lin_sim.clone(name='similarity_fmap')
fmap_sim.inputs.metric = ['mi','nmi','cc','cr','crl1']
def write_simtext(lin_metrics, nonlin_metrics, fmap_metrics, filename):
import numpy as np
import os
lin_array = np.array(lin_metrics)
lin_array=lin_array.reshape(np.size(lin_array),1)
nonlin_array = np.array(nonlin_metrics)
nonlin_array=nonlin_array.reshape(np.size(nonlin_array),1)
fmap_array = np.array(fmap_metrics)
fmap_array=fmap_array.reshape(np.size(fmap_array),1)
metrics=np.concatenate((lin_array, nonlin_array, fmap_array),axis=1)
metrics_file = filename
subject_list = ['sub-01'] # create the subject_list variable
output_dir = 'output_inverse_transform_ROIs_ALPACA' # name of norm output folder
working_dir = 'workingdir_inverse_transform_ROIs_ALPACA' # name of norm working directory
##### Create & specify nodes to be used and connected during the normalization pipeline #####
# Concatenate BBRegister's and ANTS' transforms into a list
merge = Node(Merge(2), iterfield=['in2'], name='mergexfm')
# Binarize node - binarizes mask again after transformation
binarize_post2ant = MapNode(Binarize(min=0.1),
iterfield=['in_file'],
name='binarize_post2ant')
binarize_pt2pp = binarize_post2ant.clone('binarize_pt2pp')
# FreeSurferSource - Data grabber specific for FreeSurfer data
fssource_lh = Node(FreeSurferSource(subjects_dir=fs_dir, hemi='lh'),
run_without_submitting=True,
name='fssource_lh')
fssource_rh = Node(FreeSurferSource(subjects_dir=fs_dir, hemi='rh'),
run_without_submitting=True,
name='fssource_rh')
# Transform the volumetric ROIs to the target space
inverse_transform_mni_volume_post2ant = MapNode(
ApplyTransforms(args='--float',
input_image_type=3,
interpolation='Linear',
def create_similarity_pipeline(name):
similarity=Workflow(name=name)
# inputnode
inputnode=Node(util.IdentityInterface(fields=['anat_brain',
'mask',
'lin_mean',
'nonlin_mean',
'fmap_mean',
'topup_mean',
'filename'
]),
name='inputnode')
# outputnode
outputnode=Node(util.IdentityInterface(fields=['textfile']),
name='outputnode')
# resample all means to make sure they have the same resolution as reference anatomy
resamp_mask = Node(afni.Resample(outputtype='NIFTI_GZ'), name='resample_mask')
resamp_lin = resamp_mask.clone(name = 'resample_lin')
resamp_nonlin = resamp_mask.clone(name='resample_nonlin')
resamp_fmap = resamp_mask.clone(name='resample_fmap')
resamp_topup = resamp_mask.clone(name='resample_topup')
similarity.connect([(inputnode, resamp_mask, [('mask', 'in_file'),
('anat_brain', 'master')]),
(inputnode, resamp_lin, [('lin_mean', 'in_file'),
('anat_brain', 'master')]),
(inputnode, resamp_nonlin, [('nonlin_mean', 'in_file'),
('anat_brain', 'master')]),
(inputnode, resamp_fmap, [('fmap_mean', 'in_file'),
('anat_brain', 'master')]),
(inputnode, resamp_topup, [('topup_mean', 'in_file'),
('anat_brain', 'master')]),
])
# calculate similarity (all possible metrics) for each methods to mni
lin_sim = MapNode(interface = nutil.Similarity(),
name = 'similarity_lin',
iterfield=['metric'])
lin_sim.inputs.metric = ['mi','nmi','cc','cr','crl1']
nonlin_sim = lin_sim.clone(name='similarity_nonlin')
nonlin_sim.inputs.metric = ['mi','nmi','cc','cr','crl1']
fmap_sim = lin_sim.clone(name='similarity_fmap')
fmap_sim.inputs.metric = ['mi','nmi','cc','cr','crl1']
topup_sim = lin_sim.clone(name='similarity_topup')
topup_sim.inputs.metric = ['mi','nmi','cc','cr','crl1']
similarity.connect([(inputnode, lin_sim, [('anat_brain', 'volume1')]),
(resamp_lin, lin_sim, [('out_file', 'volume2')]),
(resamp_mask, lin_sim, [('out_file', 'mask1'),
('out_file', 'mask2')]),
(inputnode, nonlin_sim, [('anat_brain', 'volume1')]),
(resamp_nonlin, nonlin_sim, [('out_file', 'volume2')]),
(resamp_mask, nonlin_sim, [('out_file', 'mask1'),
('out_file', 'mask2')]),
(inputnode, fmap_sim, [('anat_brain', 'volume1')]),
(resamp_fmap, fmap_sim, [('out_file', 'volume2')]),
(resamp_mask, fmap_sim, [('out_file', 'mask1'),
('out_file', 'mask2')]),
(inputnode, topup_sim, [('anat_brain', 'volume1')]),
(resamp_topup, topup_sim, [('out_file', 'volume2')]),
(resamp_mask, topup_sim, [('out_file', 'mask1'),
('out_file', 'mask2')])
])
# write values to one text file per subject
def write_text(lin_metrics, nonlin_metrics, fmap_metrics, topup_metrics, filename):
import numpy as np
import os
lin_array = np.array(lin_metrics)
lin_array=lin_array.reshape(np.size(lin_array),1)
nonlin_array = np.array(nonlin_metrics)
nonlin_array=nonlin_array.reshape(np.size(nonlin_array),1)
fmap_array = np.array(fmap_metrics)
fmap_array=fmap_array.reshape(np.size(fmap_array),1)
topup_array = np.array(topup_metrics)
topup_array=topup_array.reshape(np.size(topup_array),1)
metrics=np.concatenate((lin_array, nonlin_array, fmap_array, topup_array),axis=1)
metrics_file = filename
np.savetxt(metrics_file, metrics, delimiter=' ', fmt='%f')
return os.path.abspath(filename)
write_txt = Node(interface=Function(input_names=['lin_metrics', 'nonlin_metrics', 'fmap_metrics', 'topup_metrics', 'filename'],
output_names=['txtfile'],
function=write_text),
name='write_file')
similarity.connect([(inputnode, write_txt, [('filename', 'filename')]),
(lin_sim, write_txt, [('similarity', 'lin_metrics')]),
(nonlin_sim, write_txt, [('similarity', 'nonlin_metrics')]),
(fmap_sim, write_txt, [('similarity', 'fmap_metrics')]),
(topup_sim, write_txt, [('similarity', 'topup_metrics')]),
(write_txt, outputnode, [('txtfile', 'textfile')])
])
return similarity
