def _run_interface(self, runtime):
mni_template = os.path.join(os.environ['FSLDIR'], 'data', 'standard',
'MNI152_T1_2mm.nii.gz')
mni_template_mask = os.path.join(os.environ['FSLDIR'], 'data',
'standard',
'MNI152_T1_2mm_brain_mask.nii.gz')
in_file = self.inputs.in_file
mni2input = niftyreg.RegAladin()
mni2input.inputs.verbosity_off_flag = True
mni2input.inputs.ref_file = in_file
mni2input.inputs.flo_file = mni_template
mni2input_res = mni2input.run()
mask_resample = niftyreg.RegResample(inter_val='NN')
if self.inputs.use_nrr:
mni2input_nrr = niftyreg.RegF3D()
mni2input_nrr.inputs.verbosity_off_flag = True
mni2input_nrr.inputs.ref_file = in_file
mni2input_nrr.inputs.flo_file = mni_template
mni2input_nrr.inputs.aff_file = mni2input_res.outputs.aff_file
mni2input_nrr.inputs.vel_flag = True
mni2input_nrr_res = mni2input_nrr.run()
mask_resample.inputs.trans_file = mni2input_nrr_res.outputs.cpp_file
else:
mask_resample.inputs.trans_file = mni2input_res.outputs.aff_file
mask_resample.inputs.ref_file = in_file
mask_resample.inputs.flo_file = mni_template_mask
mask_resample_res = mask_resample.run()
fill_mask = niftyseg.UnaryMaths(operation='fill')
fill_mask.inputs.in_file = mask_resample_res.outputs.out_file
fill_mask.run()
return runtime
def resample(flo_path, ref_path, trsf_path, res_path, interpolation=SINC):
node = niftyreg.RegResample()
node.inputs.ref_file = str(ref_path)
node.inputs.flo_file = str(flo_path)
node.inputs.trans_file = str(trsf_path)
node.inputs.out_file = str(res_path)
node.inputs.inter_val = interpolation
ensure_dir(res_path)
node.run()
return node
def create_gradient_unwarp_workflow(in_file,
in_coeff,
output_dir,
offsets=[0, 0, 0],
scanner='siemens',
radius=0.225,
interp='CUB',
throughplaneonly=False,
inplaneonly=False):
_, subject_id, _ = split_filename(os.path.basename(in_file))
# Create a workflow to process the images
workflow = pe.Workflow(name='gradwarp_correction')
workflow.base_output_dir = 'gradwarp_correction'
# The gradwarp field is computed.
gradwarp = pe.Node(interface=GradwarpCorrection(), name='gradwarp')
gradwarp.inputs.offset_x = -1 * offsets[0]
gradwarp.inputs.offset_y = -1 * offsets[1]
gradwarp.inputs.offset_z = -1 * offsets[2]
gradwarp.inputs.radius = radius
gradwarp.inputs.scanner_type = scanner
gradwarp.inputs.in_file = in_file
gradwarp.inputs.coeff_file = in_coeff
if throughplaneonly:
gradwarp.inputs.throughplaneonly = True
if inplaneonly:
gradwarp.inputs.inplaneonly = True
# The obtained deformation field is used the resample the input image
resampling = pe.Node(interface=niftyreg.RegResample(inter_val=interp,
ref_file=in_file,
flo_file=in_file),
name='resampling')
workflow.connect(gradwarp, 'out_file', resampling, 'trans_file')
renamer = pe.Node(interface=niu.Rename(format_string=subject_id +
"_gradwarp",
keep_ext=True),
name='renamer')
workflow.connect(resampling, 'out_file', renamer, 'in_file')
# Create a data sink
ds = pe.Node(nio.DataSink(parameterization=False), name='ds')
ds.inputs.base_directory = output_dir
workflow.connect(renamer, 'out_file', ds, '@img')
return workflow
def create_workflow(name='simple_workflow'):
input_node = pe.Node(
interface=niu.IdentityInterface(fields=['ref_file', 'flo_file']),
name='input_node')
aladin = pe.MapNode(interface=niftyreg.RegAladin(),
name='aladin',
iterfield=['flo_file'])
resample = pe.MapNode(interface=niftyreg.RegResample(),
name='resample',
iterfield=['flo_file', 'aff_file'])
output_node = pe.Node(
interface=niu.IdentityInterface(fields=['res_file', 'aff_file']),
name='output_node')
w = pe.Workflow(name=name)
w.base_output_dir = name
w.connect(input_node, 'ref_file', aladin, 'ref_file')
w.connect(input_node, 'flo_file', aladin, 'flo_file')
w.connect(aladin, 'aff_file', resample, 'aff_file')
w.connect(input_node, 'ref_file', resample, 'ref_file')
w.connect(input_node, 'flo_file', resample, 'flo_file')
w.connect(resample, 'res_file', output_node, 'res_file')
w.connect(aladin, 'aff_file', output_node, 'aff_file')
return w
def create_tensor_groupwise_and_feature_extraction_workflow(input_tensor_fields, output_dir,
rig_iteration=3, aff_iteration=3, nrr_iteration=6,
biomarkers=['fa', 'tr', 'ad', 'rd']):
subject_ids = [split_filename(os.path.basename(f))[1] for f in input_tensor_fields]
pipeline_name = 'dti_wm_regional_analysis'
workflow = create_dtitk_groupwise_workflow(in_files=input_tensor_fields,
name=pipeline_name,
rig_iteration=rig_iteration,
aff_iteration=aff_iteration,
nrr_iteration=nrr_iteration)
workflow.base_output_dir = pipeline_name
workflow.base_dir = output_dir
groupwise_fa = pe.Node(interface=dtitk.TVtool(operation='fa'), name='groupwise_fa')
workflow.connect(workflow.get_node('output_node'), 'out_template', groupwise_fa, 'in_file')
aff_jhu_to_groupwise = pe.Node(interface=niftyreg.RegAladin(flo_file=jhu_atlas_fa), name='aff_jhu_to_groupwise')
workflow.connect(groupwise_fa, 'out_file', aff_jhu_to_groupwise, 'ref_file')
nrr_jhu_to_groupwise = pe.Node(interface=niftyreg.RegF3D(vel_flag=True, lncc_val=-5, maxit_val=150, be_val=0.025,
flo_file=jhu_atlas_fa), name='nrr_jhu_to_groupwise')
workflow.connect(groupwise_fa, 'out_file', nrr_jhu_to_groupwise, 'ref_file')
workflow.connect(aff_jhu_to_groupwise, 'aff_file', nrr_jhu_to_groupwise, 'aff_file')
resample_labels = pe.Node(interface=niftyreg.RegResample(inter_val='NN', flo_file=jhu_atlas_labels),
name='resample_labels')
workflow.connect(groupwise_fa, 'out_file', resample_labels, 'ref_file')
workflow.connect(nrr_jhu_to_groupwise, 'cpp_file', resample_labels, 'trans_file')
iterator = pe.Node(interface=niu.IdentityInterface(fields=['biomarker']), name='iterator')
iterator.iterables = ('biomarker', biomarkers)
tvtool = pe.MapNode(interface=dtitk.TVtool(), name='tvtool', iterfield=['in_file'])
workflow.connect(workflow.get_node('output_node'), 'out_res', tvtool, 'in_file')
workflow.connect(iterator, 'biomarker', tvtool, 'operation')
stats_extractor = pe.MapNode(interface=niu.Function(input_names=['in_file', 'roi_file'],
output_names=['out_file'],
function=extract_statistics_extended_function),
name='stats_extractor', iterfield=['in_file'])
workflow.connect(resample_labels, 'out_file', stats_extractor, 'roi_file')
workflow.connect(tvtool, 'out_file', stats_extractor, 'in_file')
tensors_renamer = pe.MapNode(interface=niu.Rename(format_string='%(subject_id)s_tensors', keep_ext=True),
name='tensors_renamer', iterfield=['in_file', 'subject_id'])
workflow.connect(workflow.get_node('output_node'), 'out_res', tensors_renamer, 'in_file')
tensors_renamer.inputs.subject_id = subject_ids
maps_renamer = pe.MapNode(interface=niu.Rename(format_string='%(subject_id)s_%(biomarker)s', keep_ext=True),
name='maps_renamer', iterfield=['in_file', 'subject_id'])
workflow.connect(tvtool, 'out_file', maps_renamer, 'in_file')
workflow.connect(iterator, 'biomarker', maps_renamer, 'biomarker')
maps_renamer.inputs.subject_id = subject_ids
stats_renamer = pe.MapNode(interface=niu.Rename(format_string='%(subject_id)s_%(biomarker)s.csv'),
name='stats_renamer', iterfield=['in_file', 'subject_id'])
workflow.connect(stats_extractor, 'out_file', stats_renamer, 'in_file')
workflow.connect(iterator, 'biomarker', stats_renamer, 'biomarker')
stats_renamer.inputs.subject_id = subject_ids
groupwise_outputs = ['fa', 'labels', 'tensors']
gw_outputs_merger = pe.Node(interface=niu.Merge(numinputs=len(groupwise_outputs)), name='gw_outputs_merger')
workflow.connect(groupwise_fa, 'out_file', gw_outputs_merger, 'in1')
workflow.connect(resample_labels, 'out_file', gw_outputs_merger, 'in2')
workflow.connect(workflow.get_node('output_node'), 'out_template', gw_outputs_merger, 'in3')
groupwise_renamer = pe.MapNode(interface=niu.Rename(format_string='groupwise_%(type)s', keep_ext=True),
name='groupwise_renamer', iterfield=['in_file', 'type'])
workflow.connect(gw_outputs_merger, 'out', groupwise_renamer, 'in_file')
groupwise_renamer.inputs.type = groupwise_outputs
# Create a data sink
ds = pe.Node(nio.DataSink(parameterization=False),
name='data_sink')
ds.inputs.base_directory = os.path.abspath(output_dir)
workflow.connect(maps_renamer, 'out_file', ds, 'biomarkers.@maps')
workflow.connect(stats_renamer, 'out_file', ds, 'biomarkers.@stats')
workflow.connect(tensors_renamer, 'out_file', ds, 'tensors')
workflow.connect(groupwise_renamer, 'out_file', ds, '@outputs')
return workflow
def create_gif_propagation_workflow(in_file,
in_db_file,
output_dir,
in_mask_file=None,
name='gif_propagation',
use_lncc=False):
"""create_niftyseg_gif_propagation_pipeline.
@param in_file input target file
@param in_db_file input database xml file for the GIF algorithm
@param output_dir output directory
@param in_mask_file optional input mask for the target T1 file
@param name optional name of the pipeline
"""
# Extract the basename of the input file
subject_id = split_filename(os.path.basename(in_file))[1]
workflow = pe.Workflow(name=name)
workflow.base_output_dir = name
input_node = pe.Node(interface=niu.IdentityInterface(
fields=['input_file', 'mask_file', 'database_file']),
name='input_node')
input_node.inputs.input_file = in_file
input_node.inputs.database_file = in_db_file
input_node.inputs.mask_file = in_mask_file
# Extract the database information
extract_db_info = pe.Node(interface=niu.Function(
input_names=['in_db_file'],
output_names=['out_templates', 'group_mask'],
function=extract_db_info_function),
name='extract_db_info')
workflow.connect(input_node, 'database_file', extract_db_info,
'in_db_file')
# Affine registration - All images in the database are registered to the input image
affine_registration = pe.MapNode(interface=niftyreg.RegAladin(),
iterfield='flo_file',
name='affine_registration')
workflow.connect(input_node, 'input_file', affine_registration, 'ref_file')
workflow.connect(extract_db_info, 'out_templates', affine_registration,
'flo_file')
# Extract a robust affine registration if applicable
robust_affine = pe.Node(interface=niftyreg.RegAverage(),
name='robust_affine')
workflow.connect(affine_registration, 'aff_file', robust_affine,
'avg_lts_files')
# A mask is created
propagate_mask = None
if in_mask_file is None:
propagate_mask = pe.Node(interface=niftyreg.RegResample(inter_val='NN',
pad_val=0),
name='propagate_mask')
workflow.connect(input_node, 'input_file', propagate_mask, 'ref_file')
workflow.connect(extract_db_info, 'group_mask', propagate_mask,
'flo_file')
workflow.connect(robust_affine, 'out_file', propagate_mask,
'trans_file')
# Initial Bias correction of the input image
bias_correction = pe.Node(interface=N4BiasCorrection(in_downsampling=2),
name='bias_correction')
workflow.connect(input_node, 'input_file', bias_correction, 'in_file')
if in_mask_file is None:
workflow.connect(propagate_mask, 'out_file', bias_correction,
'mask_file')
else:
workflow.connect(input_node, 'mask_file', bias_correction, 'mask_file')
# Non linear registration
non_linear_registration = pe.MapNode(interface=niftyreg.RegF3D(ln_val=4),
iterfield='flo_file',
name='non_linear_registration')
workflow.connect(bias_correction, 'out_file', non_linear_registration,
'ref_file')
workflow.connect(extract_db_info, 'out_templates', non_linear_registration,
'flo_file')
workflow.connect(robust_affine, 'out_file', non_linear_registration,
'aff_file')
if in_mask_file is None:
workflow.connect(propagate_mask, 'out_file', non_linear_registration,
'rmask_file')
else:
workflow.connect(input_node, 'mask_file', non_linear_registration,
'rmask_file')
if use_lncc:
non_linear_registration.inputs.lncc_val = -5
# Save all the images where required
registration_sink = pe.Node(interface=niu.Function(
input_names=['templates', 'aff_files', 'cpp_files', 'in_dir'],
output_names=['out_dir'],
function=registration_sink_function),
name='registration_sink')
registration_sink.inputs.in_dir = output_dir
workflow.connect(extract_db_info, 'out_templates', registration_sink,
'templates')
workflow.connect(affine_registration, 'aff_file', registration_sink,
'aff_files')
workflow.connect(non_linear_registration, 'cpp_file', registration_sink,
'cpp_files')
# Run GIF
gif = pe.Node(interface=Gif(database_file=in_db_file), name='gif')
gif.inputs.omp_core_val = 8
workflow.connect(registration_sink, 'out_dir', gif, 'cpp_dir')
workflow.connect(bias_correction, 'out_file', gif, 'in_file')
if in_mask_file is None:
workflow.connect(propagate_mask, 'out_file', gif, 'mask_file')
else:
workflow.connect(input_node, 'mask_file', gif, 'mask_file')
# Rename and redirect the output
output_merger = pe.Node(interface=niu.Merge(numinputs=7),
name='output_merger')
workflow.connect(gif, 'parc_file', output_merger, 'in1')
workflow.connect(gif, 'prior_file', output_merger, 'in2')
workflow.connect(gif, 'tiv_file', output_merger, 'in3')
workflow.connect(gif, 'seg_file', output_merger, 'in4')
workflow.connect(gif, 'brain_file', output_merger, 'in5')
workflow.connect(gif, 'bias_file', output_merger, 'in6')
workflow.connect(gif, 'volume_file', output_merger, 'in7')
renamer = pe.MapNode(interface=niu.Rename(format_string=subject_id +
"_%(type)s",
keep_ext=True),
iterfield=['in_file', 'type'],
name='renamer')
renamer.inputs.type = [
'labels', 'prior', 'tiv', 'seg', 'brain', 'bias_corrected', 'volumes'
]
workflow.connect(output_merger, 'out', renamer, 'in_file')
return workflow
def create_gif_pseudoct_workflow(in_ute_echo2_file,
in_ute_umap_dir,
in_db_file,
cpp_dir,
in_t1_file=None,
in_t2_file=None,
in_mask_file=None,
in_nac_pet_dir=None,
name='gif_pseudoct'):
"""create_niftyseg_gif_propagation_pipeline.
@param in_ute_echo2_file input UTE echo file
@param in_ute_umap_dir input UTE umap file
@param in_db_file input database xml file for the GIF algorithm
@param cpp_dir cpp directory
@param in_t1_file input T1 target file
@param in_t2_file input T2 target file
@param in_mask_file optional input mask for the target T1 file
@param name optional name of the pipeline
"""
in_file = in_t1_file if in_t1_file else in_t2_file
subject_id = split_filename(os.path.basename(in_file))[1]
workflow = pe.Workflow(name=name)
workflow.base_output_dir = name
gif = pe.Node(interface=Gif(database_file=in_db_file,
cpp_dir=cpp_dir,
lncc_ker=3,
regNMI=True,
regBE=0.01),
name='gif')
if in_mask_file:
gif.inputs.mask_file = in_mask_file
# Create empty masks for the bias correction to cover the full image
t1_full_mask = pe.Node(interface=niu.Function(input_names=['in_file'],
output_names=['out_file'],
function=create_full_mask),
name='t1_full_mask')
t1_full_mask.inputs.in_file = in_t1_file
t2_full_mask = pe.Node(interface=niu.Function(input_names=['in_file'],
output_names=['out_file'],
function=create_full_mask),
name='t2_full_mask')
t2_full_mask.inputs.in_file = in_t2_file
# Create bias correction nodes that are adapted to our needs. i.e. Boost the T2 bias correction
bias_correction_t1 = pe.Node(interface=N4BiasCorrection(),
name='bias_correction_t1')
if in_t1_file:
bias_correction_t1.inputs.in_file = in_t1_file
# Create bias correction nodes that are adapted to our needs. i.e. Boost the T2 bias correction
bias_correction_t2 = pe.Node(interface=N4BiasCorrection(
in_maxiter=300, in_convergence=0.0001),
name='bias_correction_t2')
if in_t2_file:
bias_correction_t2.inputs.in_file = in_t2_file
# Only connect the nodes if the input image exist respectively
if in_t1_file:
workflow.connect(t1_full_mask, 'out_file', bias_correction_t1,
'mask_file')
if in_t2_file:
workflow.connect(t2_full_mask, 'out_file', bias_correction_t2,
'mask_file')
if in_t1_file and in_t2_file:
affine_mr_target = pe.Node(interface=niftyreg.RegAladin(maxit_val=10),
name='affine_mr_target')
workflow.connect(bias_correction_t1, 'out_file', affine_mr_target,
'ref_file')
workflow.connect(bias_correction_t2, 'out_file', affine_mr_target,
'flo_file')
resample_mr_target = pe.Node(
interface=niftyreg.RegResample(pad_val=float('nan')),
name='resample_MR_target')
workflow.connect(bias_correction_t1, 'out_file', resample_mr_target,
'ref_file')
workflow.connect(bias_correction_t2, 'out_file', resample_mr_target,
'flo_file')
lister = pe.Node(interface=niu.Merge(2), name='lister')
merger = pe.Node(interface=fsl.Merge(dimension='t',
output_type='NIFTI_GZ'),
name='fsl_merge')
workflow.connect(affine_mr_target, 'aff_file', resample_mr_target,
'trans_file')
workflow.connect(bias_correction_t1, 'out_file', lister, 'in1')
workflow.connect(resample_mr_target, 'out_file', lister, 'in2')
workflow.connect(lister, 'out', merger, 'in_files')
workflow.connect(merger, 'merged_file', gif, 'in_file')
else:
if in_t1_file:
workflow.connect(bias_correction_t1, 'out_file', gif, 'in_file')
if in_t2_file:
workflow.connect(bias_correction_t2, 'out_file', gif, 'in_file')
pct_hu_to_umap = pe.Node(interface=niu.Function(
input_names=['pCT_file', 'structural_mri_file', 'ute_echo2_file'],
output_names=['pct_umap_file'],
function=convert_pct_hu_to_umap),
name='pCT_HU_to_umap')
pct_hu_to_umap.inputs.structural_mri_file = in_file
pct_hu_to_umap.inputs.ute_echo2_file = in_ute_echo2_file
workflow.connect(gif, 'synth_file', pct_hu_to_umap, 'pCT_file')
pct2dcm_pct_umap = pe.Node(interface=Pct2Dcm(in_umap_name='pCT_umap'),
name='pct2dcm_pct_umap')
workflow.connect(pct_hu_to_umap, 'pct_umap_file', pct2dcm_pct_umap,
'in_umap_file')
pct2dcm_pct_umap.inputs.in_ute_umap_dir = os.path.abspath(in_ute_umap_dir)
merger_output_number = 2
pct2dcm_ute_umap_end = None
pct2dcm_pct_umap_end = None
if in_nac_pet_dir:
ute_umap_dcm2nii = pe.Node(
interface=Dcm2nii(source_dir=in_ute_umap_dir),
name='ute_umap_dcm2nii')
first_item_selector = pe.Node(interface=niu.Select(index=0),
name='first_item_selector')
workflow.connect(ute_umap_dcm2nii, 'converted_files',
first_item_selector, 'inlist')
nac_extractor = pe.Node(interface=niu.Function(
input_names=['dicom_folder'],
output_names=['nifti_file'],
function=extract_nac_pet),
name='nac_extractor')
nac_extractor.inputs.dicom_folder = in_nac_pet_dir
ute_to_nac_registration = pe.Node(
interface=niftyreg.RegAladin(rig_only_flag=True),
name='ute_to_nac_registration')
workflow.connect(nac_extractor, 'nifti_file', ute_to_nac_registration,
'ref_file')
ute_to_nac_registration.inputs.flo_file = in_ute_echo2_file
ute_resample = pe.Node(interface=niftyreg.RegResample(),
name='ute_resample')
workflow.connect(first_item_selector, 'out', ute_resample, 'ref_file')
workflow.connect(first_item_selector, 'out', ute_resample, 'flo_file')
workflow.connect(ute_to_nac_registration, 'aff_file', ute_resample,
'aff_file')
pct2dcm_ute_umap_end = pe.Node(
interface=Pct2Dcm(in_umap_name='UTE_umap_end'),
name='pct2dcm_ute_umap_end')
workflow.connect(ute_resample, 'res_file', pct2dcm_ute_umap_end,
'in_umap_file')
pct2dcm_ute_umap_end.inputs.in_ute_umap_dir = os.path.abspath(
in_ute_umap_dir)
pct_resample = pe.Node(interface=niftyreg.RegResample(),
name='pct_resample')
workflow.connect(pct_hu_to_umap, 'pct_umap_file', pct_resample,
'ref_file')
workflow.connect(pct_hu_to_umap, 'pct_umap_file', pct_resample,
'flo_file')
workflow.connect(ute_to_nac_registration, 'aff_file', pct_resample,
'aff_file')
pct2dcm_pct_umap_end = pe.Node(
interface=Pct2Dcm(in_umap_name='pCT_umap_end'),
name='pct2dcm_pct_umap_end')
workflow.connect(pct_resample, 'res_file', pct2dcm_pct_umap_end,
'in_umap_file')
pct2dcm_pct_umap_end.inputs.in_ute_umap_dir = os.path.abspath(
in_ute_umap_dir)
merger_output_number = 4
# merge output
output_merger = pe.Node(
interface=niu.Merge(numinputs=merger_output_number),
name='output_merger')
workflow.connect(gif, 'synth_file', output_merger, 'in1')
workflow.connect(pct2dcm_pct_umap, 'output_file', output_merger, 'in2')
renamer = pe.Node(interface=niu.Rename(format_string=subject_id +
"_%(type)s",
keep_ext=True),
name='renamer')
if in_nac_pet_dir:
workflow.connect(pct2dcm_ute_umap_end, 'output_file', output_merger,
'in3')
workflow.connect(pct2dcm_pct_umap_end, 'output_file', output_merger,
'in4')
renamer.inputs.type = ['synth', 'pct', 'ute_end', 'pct_end']
else:
renamer.inputs.type = ['synth', 'pct']
workflow.connect(output_merger, 'out', renamer, 'in_file')
return workflow
def create_n4_bias_correction_workflow(input_images,
output_dir,
input_masks=None,
name='n4_bias_correction'):
subject_ids = [
split_filename(os.path.basename(f))[1] for f in input_images
]
# Create a workflow to process the images
workflow = pe.Workflow(name=name)
workflow.base_dir = output_dir
workflow.base_output_dir = name
# Define the input and output node
input_node = pe.Node(interface=niu.IdentityInterface(
fields=['in_files', 'mask_files'], mandatory_inputs=False),
name='input_node')
output_node = pe.Node(interface=niu.IdentityInterface(
fields=['out_img_files', 'out_bias_files', 'out_mask_files']),
name='output_node')
input_node.inputs.in_files = input_images
if input_masks is not None:
input_node.inputs.mask_files = input_masks
thresholder = pe.MapNode(interface=fsl.Threshold(),
name='thresholder',
iterfield=['in_file'])
thresholder.inputs.thresh = 0
# Finding masks to use for bias correction:
bias_correction = pe.MapNode(interface=N4BiasCorrection(),
name='bias_correction',
iterfield=['in_file', 'mask_file'])
bias_correction.inputs.in_downsampling = 2
bias_correction.inputs.in_maxiter = 200
bias_correction.inputs.in_convergence = 0.0002
bias_correction.inputs.in_fwhm = 0.05
renamer = pe.MapNode(
interface=niu.Rename(format_string="%(subject_id)s_corrected.nii.gz"),
name='renamer',
iterfield=['in_file', 'subject_id'])
renamer.inputs.subject_id = subject_ids
mask_renamer = pe.MapNode(interface=niu.Rename(
format_string="%(subject_id)s_corrected_mask.nii.gz"),
name='mask_renamer',
iterfield=['in_file', 'subject_id'])
mask_renamer.inputs.subject_id = subject_ids
if input_masks is None:
mni_to_input = pe.MapNode(interface=niftyreg.RegAladin(),
name='mni_to_input',
iterfield=['ref_file'])
mni_to_input.inputs.flo_file = mni_template
mask_resample = pe.MapNode(interface=niftyreg.RegResample(),
name='mask_resample',
iterfield=['ref_file', 'aff_file'])
mask_resample.inputs.inter_val = 'NN'
mask_resample.inputs.flo_file = mni_template_mask
mask_eroder = pe.MapNode(interface=niftyseg.BinaryMathsInteger(),
name='mask_eroder',
iterfield=['in_file'])
mask_eroder.inputs.operation = 'ero'
mask_eroder.inputs.operand_value = 3
workflow.connect(input_node, 'in_files', mni_to_input, 'ref_file')
workflow.connect(input_node, 'in_files', mask_resample, 'ref_file')
workflow.connect(mni_to_input, 'aff_file', mask_resample, 'aff_file')
workflow.connect(mask_resample, 'out_file', mask_eroder, 'in_file')
workflow.connect(mask_eroder, 'out_file', bias_correction, 'mask_file')
workflow.connect(mask_eroder, 'out_file', mask_renamer, 'in_file')
else:
workflow.connect(input_node, 'mask_files', bias_correction,
'mask_file')
workflow.connect(input_node, 'mask_files', mask_renamer, 'in_file')
workflow.connect(input_node, 'in_files', thresholder, 'in_file')
workflow.connect(thresholder, 'out_file', bias_correction, 'in_file')
# Gather the processed images
workflow.connect(bias_correction, 'out_file', renamer, 'in_file')
workflow.connect(renamer, 'out_file', output_node, 'out_img_files')
workflow.connect(bias_correction, 'out_biasfield_file', output_node,
'out_bias_files')
workflow.connect(mask_renamer, 'out_file', output_node, 'out_mask_files')
# Create a data sink
ds = pe.Node(nio.DataSink(parameterization=False), name='data_sink')
ds.inputs.base_directory = output_dir
workflow.connect(output_node, 'out_img_files', ds, '@img')
workflow.connect(output_node, 'out_mask_files', ds, '@mask')
return workflow
dest='ref',
metavar='ref',
help='Reference Image',
required=True)
parser.add_argument('-f',
'--floating',
dest='flo',
metavar='flo',
help='Floating Image',
required=True)
args = parser.parse_args()
workflow = pe.Workflow(name=name)
workflow.base_output_dir = name
workflow.base_dir = name
directory = os.getcwd()
node = pe.Node(interface=niftyreg.RegResample(), name='resample')
output_node = pe.Node(
interface=niu.IdentityInterface(fields=['res_file', 'blank_file']),
name='output_node')
workflow.connect(node, 'res_file', output_node, 'res_file')
workflow.connect(node, 'blank_file', output_node, 'res_file')
node.inputs.ref_file = os.path.absbath(args.ref)
node.inputs.flo_file = os.path.absbath(args.flo)
workflow.run()
def create_multiple_resample_and_combine_mask(name='resample_and_combine',
out_base_dir=os.getcwd(),
inter_val='LIN',
psf_flag=True):
# Inputs::
#
# ::param inter_val: niftyreg resampling parameter to use
# input_node.input_mask: Mask to resample
# input_node.input_transforms: Input transforms for reg_resample
# input_node.target_image: Resampling ref image
#
# Outputs::
#
# output_node.out_file: Output combined resampled masks
# Create the workflow
workflow = pe.Workflow(name=name)
workflow.base_dir = out_base_dir
workflow.base_output_dir = name
# Create the input node interface
input_node = pe.Node(interface=niu.IdentityInterface(
fields=['input_mask', 'input_transforms', 'target_image']),
name='input_node')
# Resample to multiple outputs
resample_node = pe.MapNode(interface=niftyreg.RegResample(),
name="resample",
iterfield=['trans_file'])
resample_node.inputs.inter_val = inter_val
resample_node.inputs.psf_flag = psf_flag
workflow.connect([(input_node,
resample_node, [('input_transforms', 'trans_file'),
('input_mask', 'flo_file'),
('target_image', 'ref_file')])])
# Merge at this stage for easier processing of the resampled masks, then
# do a reduce (max) after binarising.
merge_node = pe.Node(interface=fsl.utils.Merge(dimension="t"),
name="merge")
workflow.connect(resample_node, 'out_file', merge_node, 'in_files')
# N.B. if adding thresholding to this pipeline, only seg_maths seems safe
# with floating point values
# Using abs with no threshold is quite generous, but this is the aim of
# this masking approach. Ideally should consider PSF too, but needs added
# to the niftyreg interface
abs_node = pe.Node(interface=fsl.maths.UnaryMaths(), name="abs")
abs_node.inputs.nan2zeros = True
abs_node.inputs.operation = 'abs'
workflow.connect(merge_node, 'merged_file', abs_node, 'in_file')
bin_node = pe.Node(interface=fsl.maths.UnaryMaths(), name="bin")
bin_node.inputs.nan2zeros = True
bin_node.inputs.operation = 'bin'
workflow.connect(abs_node, 'out_file', bin_node, 'in_file')
max_node = pe.Node(interface=fsl.maths.MaxImage(dimension="T"), name="max")
workflow.connect(bin_node, 'out_file', max_node, 'in_file')
# Output node interface
output_node = pe.Node(interface=niu.IdentityInterface(fields=['out_file']),
name="output_node")
workflow.connect(max_node, 'out_file', output_node, 'out_file')
return workflow
def create_steps_propagation_pipeline(name='steps_propagation',
aligned_templates=False):
workflow = pe.Workflow(name=name)
# Create an input node
input_node = pe.Node(
interface=niu.IdentityInterface(
fields=['in_file',
'database_file']),
name='input_node')
extract_db_info = pe.Node(interface=niu.Function(input_names=['in_db_file'], output_names=['input_template_images',
'input_template_labels'],
function=extract_db_info_function),
name='extract_db_info')
workflow.connect(input_node, 'database_file', extract_db_info, 'in_db_file')
# All the template images are affinely registered to the target image
current_aladin = pe.MapNode(interface=niftyreg.RegAladin(verbosity_off_flag=True),
name='aladin',
iterfield=['flo_file'])
workflow.connect(input_node, 'in_file', current_aladin, 'ref_file')
workflow.connect(extract_db_info, 'input_template_images', current_aladin, 'flo_file')
# Compute the affine TLS if required
current_robust_affine = None
if aligned_templates is True:
current_robust_affine = pe.Node(interface=niftyreg.RegAverage(), name='robust_affine')
workflow.connect(current_aladin, 'aff_file', current_robust_affine, 'avg_lts_files')
current_aff_prop = pe.MapNode(interface=niftyreg.RegResample(verbosity_off_flag=True, inter_val='NN'),
name='resample_aff',
iterfield=['flo_file'])
workflow.connect(current_robust_affine, 'out_file', current_aff_prop, 'trans_file')
else:
current_aff_prop = pe.MapNode(interface=niftyreg.RegResample(verbosity_off_flag=True, inter_val='NN'),
name='resample_aff',
iterfield=['flo_file',
'trans_file'])
workflow.connect(current_aladin, 'aff_file', current_aff_prop, 'trans_file')
workflow.connect(input_node, 'in_file', current_aff_prop, 'ref_file')
workflow.connect(extract_db_info, 'input_template_labels', current_aff_prop, 'flo_file')
# Merge all the affine parcellation into one 4D
current_aff_prop_merge = pe.Node(interface=fsl.Merge(dimension='t'), name='merge_aff_prop')
workflow.connect(current_aff_prop, 'out_file', current_aff_prop_merge, 'in_files')
# Combine all the propagated parcellation into a single image
current_aff_prop_max = pe.Node(interface=MaxImage(dimension='T'), name='max_aff')
workflow.connect(current_aff_prop_merge, 'merged_file', current_aff_prop_max, 'in_file')
# Binarise the obtained mask
current_aff_prop_bin = pe.Node(interface=niftyseg.UnaryMaths(operation='bin'), name='bin_aff')
workflow.connect(current_aff_prop_max, 'out_file', current_aff_prop_bin, 'in_file')
# Dilate the obtained mask
current_aff_prop_dil = pe.Node(interface=niftyseg.BinaryMathsInteger(operation='dil', operand_value=10),
name='dil_aff')
workflow.connect(current_aff_prop_bin, 'out_file', current_aff_prop_dil, 'in_file')
# Fill the obtained mask
current_aff_prop_fill = pe.Node(interface=niftyseg.UnaryMaths(operation='fill'), name='fill_aff')
workflow.connect(current_aff_prop_dil, 'out_file', current_aff_prop_fill, 'in_file')
# Crop the target image to speed up the process
current_crop_target = pe.Node(interface=CropImage(), name='crop_target')
workflow.connect(input_node, 'in_file', current_crop_target, 'in_file')
workflow.connect(current_aff_prop_fill, 'out_file', current_crop_target, 'mask_file')
# Crop the mask image to speed up the process
current_crop_mask = pe.Node(interface=CropImage(), name='crop_mask')
workflow.connect(current_aff_prop_fill, 'out_file', current_crop_mask, 'in_file')
workflow.connect(current_aff_prop_fill, 'out_file', current_crop_mask, 'mask_file')
# Perform all the non-linear registration
if aligned_templates is True:
current_f3d = pe.MapNode(interface=niftyreg.RegF3D(sx_val=-2.5, be_val=0.01, verbosity_off_flag=True),
name='f3d',
iterfield=['flo_file'])
workflow.connect(current_robust_affine, 'out_file', current_f3d, 'aff_file')
else:
current_f3d = pe.MapNode(interface=niftyreg.RegF3D(),
name='f3d',
iterfield=['flo_file',
'aff_file'])
workflow.connect(current_aladin, 'aff_file', current_f3d, 'aff_file')
workflow.connect(current_crop_target, 'out_file', current_f3d, 'ref_file')
workflow.connect(current_crop_mask, 'out_file', current_f3d, 'rmask_file')
workflow.connect(extract_db_info, 'input_template_images', current_f3d, 'flo_file')
# Merge all the non-linear warped images into one 4D
current_f3d_temp_merge = pe.Node(interface=fsl.Merge(dimension='t'), name='merge_f3d_temp')
workflow.connect(current_f3d, 'res_file', current_f3d_temp_merge, 'in_files')
# Propagate the obtained mask
current_f3d_prop = pe.MapNode(interface=niftyreg.RegResample(inter_val='NN', verbosity_off_flag=True),
name='f3d_prop',
iterfield=['flo_file',
'trans_file'])
workflow.connect(current_crop_target, 'out_file', current_f3d_prop, 'ref_file')
workflow.connect(extract_db_info, 'input_template_labels', current_f3d_prop, 'flo_file')
workflow.connect(current_f3d, 'cpp_file', current_f3d_prop, 'trans_file')
# Merge all the non-linear warped labels into one 4D
current_f3d_prop_merge = pe.Node(interface=fsl.Merge(dimension='t'), name='merge_f3d_prop')
workflow.connect(current_f3d_prop, 'out_file', current_f3d_prop_merge, 'in_files')
# Extract the consensus parcellation using steps
current_fusion = pe.Node(interface=niftyseg.STEPS(template_num=15, kernel_size=1.5, mrf_value=0.15),
name='fusion')
workflow.connect(current_crop_target, 'out_file', current_fusion, 'in_file')
workflow.connect(current_f3d_temp_merge, 'merged_file', current_fusion, 'warped_img_file')
workflow.connect(current_f3d_prop_merge, 'merged_file', current_fusion, 'warped_seg_file')
workflow.connect(current_aff_prop_fill, 'out_file', current_fusion, 'mask_file')
# Resample the obtained consensus label into the original image space
current_prop_orig_res = pe.MapNode(interface=niftyreg.RegResample(inter_val='NN', verbosity_off_flag=True),
name='prop_orig_res',
iterfield=['flo_file'])
workflow.connect(input_node, 'in_file', current_prop_orig_res, 'ref_file')
workflow.connect(current_fusion, 'out_file', current_prop_orig_res, 'flo_file')
# Connect the output to the output node
output_node = pe.Node(
interface=niu.IdentityInterface(
fields=['parcellated_file']),
name='output_node')
workflow.connect(current_prop_orig_res, 'out_file', output_node, 'parcellated_file')
return workflow
def create_cross_sectional_tbss_pipeline(in_files,
output_dir,
name='cross_sectional_tbss',
skeleton_threshold=0.2,
design_mat=None,
design_con=None):
workflow = pe.Workflow(name=name)
workflow.base_dir = output_dir
workflow.base_output_dir = name
# Create the dtitk groupwise registration workflow
groupwise_dtitk = create_dtitk_groupwise_workflow(in_files=in_files,
name="dtitk_groupwise",
rig_iteration=3,
aff_iteration=3,
nrr_iteration=6)
# Create the average FA map
mean_fa = pe.Node(interface=dtitk.TVtool(), name="mean_fa")
workflow.connect(groupwise_dtitk, 'output_node.out_template', mean_fa,
'in_file')
mean_fa.inputs.operation = 'fa'
# Register the FMRIB58_FA_1mm.nii.gz atlas to the mean FA map
reg_atlas = pe.Node(interface=niftyreg.RegAladin(), name='reg_atlas')
workflow.connect(mean_fa, 'out_file', reg_atlas, 'ref_file')
reg_atlas.inputs.flo_file = os.path.join(os.environ['FSLDIR'], 'data',
'standard',
'FMRIB58_FA_1mm.nii.gz')
# Apply the transformation to the lower cingulum image
war_atlas = pe.Node(interface=niftyreg.RegResample(), name='war_atlas')
workflow.connect(mean_fa, 'out_file', war_atlas, 'ref_file')
war_atlas.inputs.flo_file = os.path.join(os.environ['FSLDIR'], 'data',
'standard',
'LowerCingulum_1mm.nii.gz')
workflow.connect(reg_atlas, 'aff_file', war_atlas, 'trans_file')
war_atlas.inputs.inter_val = 'LIN'
# Threshold the propagated lower cingulum
thr_atlas = pe.Node(interface=niftyseg.BinaryMaths(), name='thr_atlas')
workflow.connect(war_atlas, 'out_file', thr_atlas, 'in_file')
thr_atlas.inputs.operation = 'thr'
thr_atlas.inputs.operand_value = 0.5
# Binarise the propagated lower cingulum
bin_atlas = pe.Node(interface=niftyseg.UnaryMaths(), name='bin_atlas')
workflow.connect(thr_atlas, 'out_file', bin_atlas, 'in_file')
bin_atlas.inputs.operation = 'bin'
# Create all the individual FA maps
individual_fa = pe.MapNode(interface=dtitk.TVtool(),
name="individual_fa",
iterfield=['in_file'])
workflow.connect(groupwise_dtitk, 'output_node.out_res', individual_fa,
'in_file')
individual_fa.inputs.operation = 'fa'
# Create all the individual MD maps
individual_md = pe.MapNode(interface=dtitk.TVtool(),
name="individual_md",
iterfield=['in_file'])
workflow.connect(groupwise_dtitk, 'output_node.out_res', individual_md,
'in_file')
individual_md.inputs.operation = 'tr'
# Create all the individual RD maps
individual_rd = pe.MapNode(interface=dtitk.TVtool(),
name="individual_rd",
iterfield=['in_file'])
workflow.connect(groupwise_dtitk, 'output_node.out_res', individual_rd,
'in_file')
individual_rd.inputs.operation = 'rd'
# Create all the individual RD maps
individual_ad = pe.MapNode(interface=dtitk.TVtool(),
name="individual_ad",
iterfield=['in_file'])
workflow.connect(groupwise_dtitk, 'output_node.out_res', individual_ad,
'in_file')
individual_ad.inputs.operation = 'ad'
# Combine all the warped FA images into a 4D image
merged_4d_fa = pe.Node(interface=fsl.Merge(), name='merged_4d_fa')
merged_4d_fa.inputs.dimension = 't'
workflow.connect(individual_fa, 'out_file', merged_4d_fa, 'in_files')
# Combine all the warped MD images into a 4D image
merged_4d_md = pe.Node(interface=fsl.Merge(), name='merged_4d_md')
merged_4d_md.inputs.dimension = 't'
workflow.connect(individual_md, 'out_file', merged_4d_md, 'in_files')
# Combine all the warped RD images into a 4D image
merged_4d_rd = pe.Node(interface=fsl.Merge(), name='merged_4d_rd')
merged_4d_rd.inputs.dimension = 't'
workflow.connect(individual_rd, 'out_file', merged_4d_rd, 'in_files')
# Combine all the warped AD images into a 4D image
merged_4d_ad = pe.Node(interface=fsl.Merge(), name='merged_4d_ad')
merged_4d_ad.inputs.dimension = 't'
workflow.connect(individual_ad, 'out_file', merged_4d_ad, 'in_files')
# Threshold the 4D FA image to 0
merged_4d_fa_thresholded = pe.Node(interface=niftyseg.BinaryMaths(),
name='merged_4d_fa_thresholded')
merged_4d_fa_thresholded.inputs.operation = 'thr'
merged_4d_fa_thresholded.inputs.operand_value = 0
workflow.connect(merged_4d_fa, 'merged_file', merged_4d_fa_thresholded,
'in_file')
# Extract the min value from the 4D FA image
minimal_value_across_all_fa = pe.Node(interface=niftyseg.UnaryMaths(),
name='minimal_value_across_all_fa')
minimal_value_across_all_fa.inputs.operation = 'tmin'
workflow.connect(merged_4d_fa_thresholded, 'out_file',
minimal_value_across_all_fa, 'in_file')
# Create the mask image
fa_mask = pe.Node(interface=niftyseg.UnaryMaths(), name='fa_mask')
fa_mask.inputs.operation = 'bin'
fa_mask.inputs.output_datatype = 'char'
workflow.connect(minimal_value_across_all_fa, 'out_file', fa_mask,
'in_file')
# Mask the mean FA image
masked_mean_fa = pe.Node(interface=fsl.ApplyMask(), name='masked_mean_fa')
workflow.connect(mean_fa, 'out_file', masked_mean_fa, 'in_file')
workflow.connect(fa_mask, 'out_file', masked_mean_fa, 'mask_file')
# Create the skeleton image
skeleton = pe.Node(interface=fsl.TractSkeleton(), name='skeleton')
skeleton.inputs.skeleton_file = True
workflow.connect(masked_mean_fa, 'out_file', skeleton, 'in_file')
# Threshold the skeleton image
thresholded_skeleton = pe.Node(interface=niftyseg.BinaryMaths(),
name='thresholded_skeleton')
thresholded_skeleton.inputs.operation = 'thr'
thresholded_skeleton.inputs.operand_value = skeleton_threshold
workflow.connect(skeleton, 'skeleton_file', thresholded_skeleton,
'in_file')
# Binarise the skeleton image
binarised_skeleton = pe.Node(interface=niftyseg.UnaryMaths(),
name='binarised_skeleton')
binarised_skeleton.inputs.operation = 'bin'
workflow.connect(thresholded_skeleton, 'out_file', binarised_skeleton,
'in_file')
# Create skeleton distance map
invert_mask1 = pe.Node(interface=niftyseg.BinaryMaths(),
name='invert_mask1')
invert_mask1.inputs.operation = 'mul'
invert_mask1.inputs.operand_value = -1
workflow.connect(fa_mask, 'out_file', invert_mask1, 'in_file')
invert_mask2 = pe.Node(interface=niftyseg.BinaryMaths(),
name='invert_mask2')
invert_mask2.inputs.operation = 'add'
invert_mask2.inputs.operand_value = 1
workflow.connect(invert_mask1, 'out_file', invert_mask2, 'in_file')
invert_mask3 = pe.Node(interface=niftyseg.BinaryMaths(),
name='invert_mask3')
invert_mask3.inputs.operation = 'add'
workflow.connect(invert_mask2, 'out_file', invert_mask3, 'in_file')
workflow.connect(binarised_skeleton, 'out_file', invert_mask3,
'operand_file')
distance_map = pe.Node(interface=fsl.DistanceMap(), name='distance_map')
workflow.connect(invert_mask3, 'out_file', distance_map, 'in_file')
# Project the FA values onto the skeleton
all_fa_projected = pe.Node(interface=fsl.TractSkeleton(),
name='all_fa_projected')
all_fa_projected.inputs.threshold = skeleton_threshold
all_fa_projected.inputs.project_data = True
workflow.connect(masked_mean_fa, 'out_file', all_fa_projected, 'in_file')
workflow.connect(distance_map, 'distance_map', all_fa_projected,
'distance_map')
workflow.connect(merged_4d_fa, 'merged_file', all_fa_projected,
'data_file')
workflow.connect(bin_atlas, 'out_file', all_fa_projected,
'search_mask_file')
# Project the MD values onto the skeleton
all_md_projected = pe.Node(interface=fsl.TractSkeleton(),
name='all_md_projected')
all_md_projected.inputs.threshold = skeleton_threshold
all_md_projected.inputs.project_data = True
workflow.connect(masked_mean_fa, 'out_file', all_md_projected, 'in_file')
workflow.connect(distance_map, 'distance_map', all_md_projected,
'distance_map')
workflow.connect(merged_4d_fa, 'merged_file', all_md_projected,
'data_file')
workflow.connect(merged_4d_md, 'merged_file', all_md_projected,
'alt_data_file')
workflow.connect(bin_atlas, 'out_file', all_md_projected,
'search_mask_file')
# Project the RD values onto the skeleton
all_rd_projected = pe.Node(interface=fsl.TractSkeleton(),
name='all_rd_projected')
all_rd_projected.inputs.threshold = skeleton_threshold
all_rd_projected.inputs.project_data = True
workflow.connect(masked_mean_fa, 'out_file', all_rd_projected, 'in_file')
workflow.connect(distance_map, 'distance_map', all_rd_projected,
'distance_map')
workflow.connect(merged_4d_fa, 'merged_file', all_rd_projected,
'data_file')
workflow.connect(merged_4d_rd, 'merged_file', all_rd_projected,
'alt_data_file')
workflow.connect(bin_atlas, 'out_file', all_rd_projected,
'search_mask_file')
# Project the RD values onto the skeleton
all_ad_projected = pe.Node(interface=fsl.TractSkeleton(),
name='all_ad_projected')
all_ad_projected.inputs.threshold = skeleton_threshold
all_ad_projected.inputs.project_data = True
workflow.connect(masked_mean_fa, 'out_file', all_ad_projected, 'in_file')
workflow.connect(distance_map, 'distance_map', all_ad_projected,
'distance_map')
workflow.connect(merged_4d_fa, 'merged_file', all_ad_projected,
'data_file')
workflow.connect(merged_4d_ad, 'merged_file', all_ad_projected,
'alt_data_file')
workflow.connect(bin_atlas, 'out_file', all_ad_projected,
'search_mask_file')
# Create an output node
output_node = pe.Node(interface=niu.IdentityInterface(fields=[
'mean_fa', 'all_fa_skeletonised', 'all_md_skeletonised',
'all_rd_skeletonised', 'all_ad_skeletonised', 'skeleton',
'skeleton_bin', 't_contrast_raw_stat', 't_contrast_uncorrected_pvalue',
't_contrast_corrected_pvalue'
]),
name='output_node')
# Connect the workflow to the output node
workflow.connect(masked_mean_fa, 'out_file', output_node, 'mean_fa')
workflow.connect(all_fa_projected, 'projected_data', output_node,
'all_fa_skeletonised')
workflow.connect(all_md_projected, 'projected_data', output_node,
'all_md_skeletonised')
workflow.connect(all_rd_projected, 'projected_data', output_node,
'all_rd_skeletonised')
workflow.connect(all_ad_projected, 'projected_data', output_node,
'all_ad_skeletonised')
workflow.connect(skeleton, 'skeleton_file', output_node, 'skeleton')
workflow.connect(binarised_skeleton, 'out_file', output_node,
'skeleton_bin')
# Run randomise if required and connect its output to the output node
if design_mat is not None and design_con is not None:
randomise = pe.Node(interface=fsl.Randomise(), name='randomise')
randomise.inputs.base_name = 'stats_tbss'
randomise.inputs.tfce2D = True
randomise.inputs.num_perm = 5000
workflow.connect(all_fa_projected, 'projected_data', randomise,
'in_file')
randomise.inputs.design_mat = design_mat
randomise.inputs.design_con = design_con
workflow.connect(binarised_skeleton, 'out_file', randomise, 'mask')
workflow.connect(randomise, 'tstat_files', output_node,
't_contrast_raw_stat')
workflow.connect(randomise, 't_p_files', output_node,
't_contrast_uncorrected_pvalue')
workflow.connect(randomise, 't_corrected_p_files', output_node,
't_contrast_corrected_pvalue')
# Create nodes to rename the outputs
mean_fa_renamer = pe.Node(interface=niu.Rename(
format_string='tbss_mean_fa', keep_ext=True),
name='mean_fa_renamer')
workflow.connect(output_node, 'mean_fa', mean_fa_renamer, 'in_file')
mean_sk_renamer = pe.Node(interface=niu.Rename(
format_string='tbss_mean_fa_skeleton', keep_ext=True),
name='mean_sk_renamer')
workflow.connect(output_node, 'skeleton', mean_sk_renamer, 'in_file')
bin_ske_renamer = pe.Node(interface=niu.Rename(
format_string='tbss_mean_fa_skeleton_mask', keep_ext=True),
name='bin_ske_renamer')
workflow.connect(output_node, 'skeleton_bin', bin_ske_renamer, 'in_file')
fa_skel_renamer = pe.Node(interface=niu.Rename(
format_string='tbss_all_fa_skeletonised', keep_ext=True),
name='fa_skel_renamer')
workflow.connect(output_node, 'all_fa_skeletonised', fa_skel_renamer,
'in_file')
md_skel_renamer = pe.Node(interface=niu.Rename(
format_string='tbss_all_md_skeletonised', keep_ext=True),
name='md_skel_renamer')
workflow.connect(output_node, 'all_md_skeletonised', md_skel_renamer,
'in_file')
rd_skel_renamer = pe.Node(interface=niu.Rename(
format_string='tbss_all_rd_skeletonised', keep_ext=True),
name='rd_skel_renamer')
workflow.connect(output_node, 'all_rd_skeletonised', rd_skel_renamer,
'in_file')
ad_skel_renamer = pe.Node(interface=niu.Rename(
format_string='tbss_all_ad_skeletonised', keep_ext=True),
name='ad_skel_renamer')
workflow.connect(output_node, 'all_ad_skeletonised', ad_skel_renamer,
'in_file')
# Create a data sink
ds = pe.Node(nio.DataSink(parameterization=False), name='data_sink')
ds.inputs.base_directory = os.path.abspath(output_dir)
# Connect the data sink
workflow.connect(mean_fa_renamer, 'out_file', ds, '@mean_fa')
workflow.connect(mean_sk_renamer, 'out_file', ds, '@skel_fa')
workflow.connect(bin_ske_renamer, 'out_file', ds, '@bkel_fa')
workflow.connect(fa_skel_renamer, 'out_file', ds, '@all_fa')
workflow.connect(md_skel_renamer, 'out_file', ds, '@all_md')
workflow.connect(rd_skel_renamer, 'out_file', ds, '@all_rd')
workflow.connect(ad_skel_renamer, 'out_file', ds, '@all_ad')
if design_mat is not None and design_con is not None:
workflow.connect(output_node, 't_contrast_raw_stat', ds,
'@t_contrast_raw_stat')
workflow.connect(output_node, 't_contrast_uncorrected_pvalue', ds,
'@t_contrast_uncorrected_pvalue')
workflow.connect(output_node, 't_contrast_corrected_pvalue', ds,
'@t_contrast_corrected_pvalue')
return workflow
def preprocessing_input_pipeline(name='preprocessing_inputs_pipeline',
number_of_affine_iterations=7,
ref_file=mni_template,
ref_mask=mni_template_mask):
workflow = pe.Workflow(name=name)
workflow.base_output_dir = name
input_node = pe.Node(interface=niu.IdentityInterface(
fields=['in_file', 'in_images', 'in_affines']),
name='input_node')
'''
*****************************************************************************
First step: Cropping inputs according to 10 voxels surrounding the skull
*****************************************************************************
'''
register_mni_to_image = pe.Node(interface=niftyreg.RegAladin(),
name='register_mni_to_image')
register_mni_to_image.inputs.flo_file = mni_template
resample_mni_mask_to_image = pe.Node(interface=niftyreg.RegResample(),
name='resample_mni_mask_to_image')
resample_mni_mask_to_image.inputs.inter_val = 'NN'
resample_mni_mask_to_image.inputs.flo_file = mni_template_mask
dilate_image_mask = pe.Node(interface=niftyseg.BinaryMaths(),
name='dilate_image_mask')
dilate_image_mask.inputs.operation = 'dil'
dilate_image_mask.inputs.operand_value = 10
crop_image_with_mask = pe.Node(interface=niftk.CropImage(),
name='crop_image_with_mask')
resample_image_mask_to_cropped_image = pe.Node(
interface=niftyreg.RegResample(),
name='resample_image_mask_to_cropped_image')
resample_image_mask_to_cropped_image.inputs.inter_val = 'NN'
resample_image_mask_to_cropped_image.inputs.flo_file = mni_template_mask
bias_correction = pe.Node(interface=niftk.N4BiasCorrection(),
name='bias_correction')
bias_correction.inputs.in_downsampling = 2
'''
*****************************************************************************
Second step: Calculate the cumulated input affine transformations
*****************************************************************************
'''
register_mni_to_cropped_image = pe.Node(
interface=niftyreg.RegAladin(), name='register_mni_to_cropped_image')
register_mni_to_cropped_image.inputs.ref_file = mni_template
invert_affine_transformations = pe.Node(
niftyreg.RegTransform(),
name='invert_affine_transformations',
iterfield=['inv_aff_input'])
compose_affine_transformations = pe.MapNode(
niftyreg.RegTransform(),
name='compose_affine_transformations',
iterfield=['comp_input2'])
'''
*****************************************************************************
Third step: Non linear registration of all pairs
*****************************************************************************
'''
nonlinear_registration = pe.MapNode(interface=niftyreg.RegF3D(),
name='nonlinear_registration',
iterfield=['flo_file', 'aff_file'])
nonlinear_registration.inputs.vel_flag = True
nonlinear_registration.inputs.lncc_val = -5
nonlinear_registration.inputs.maxit_val = 150
nonlinear_registration.inputs.be_val = 0.025
'''
*****************************************************************************
First step: Cropping inputs according to 10 voxels surrounding the skull
*****************************************************************************
'''
workflow.connect(input_node, 'in_file', register_mni_to_image, 'ref_file')
workflow.connect(input_node, 'in_file', resample_mni_mask_to_image,
'ref_file')
workflow.connect(register_mni_to_image, 'aff_file',
resample_mni_mask_to_image, 'aff_file')
workflow.connect(resample_mni_mask_to_image, 'res_file', dilate_image_mask,
'in_file')
workflow.connect(input_node, 'in_file', crop_image_with_mask, 'in_file')
workflow.connect(dilate_image_mask, 'out_file', crop_image_with_mask,
'mask_file')
workflow.connect(crop_image_with_mask, 'out_file',
resample_image_mask_to_cropped_image, 'ref_file')
workflow.connect(register_mni_to_image, 'aff_file',
resample_image_mask_to_cropped_image, 'aff_file')
workflow.connect(crop_image_with_mask, 'out_file', bias_correction,
'in_file')
workflow.connect(resample_image_mask_to_cropped_image, 'res_file',
bias_correction, 'mask_file')
'''
*****************************************************************************
Fourth step: Calculate the cumulated input affine transformations
*****************************************************************************
'''
workflow.connect(bias_correction, 'out_file',
register_mni_to_cropped_image, 'flo_file')
workflow.connect(register_mni_to_cropped_image, 'aff_file',
invert_affine_transformations, 'inv_aff_input')
workflow.connect(invert_affine_transformations, 'out_file',
compose_affine_transformations, 'comp_input')
workflow.connect(input_node, 'in_affines', compose_affine_transformations,
'comp_input2')
'''
*****************************************************************************
Fith step: Non linear registration of all pairs
*****************************************************************************
'''
workflow.connect(bias_correction, 'out_file', nonlinear_registration,
'ref_file')
workflow.connect(input_node, 'in_images', nonlinear_registration,
'flo_file')
workflow.connect(compose_affine_transformations, 'out_file',
nonlinear_registration, 'aff_file')
'''
*****************************************************************************
Connect the outputs
*****************************************************************************
'''
output_node = pe.Node(interface=niu.IdentityInterface(
fields=['out_file', 'out_mask', 'out_aff', 'out_cpps', 'out_invcpps']),
name='output_node')
workflow.connect(bias_correction, 'out_file', output_node, 'out_file')
workflow.connect(resample_image_mask_to_cropped_image, 'res_file',
output_node, 'out_mask')
workflow.connect(register_mni_to_cropped_image, 'aff_file', output_node,
'out_aff')
workflow.connect(nonlinear_registration, 'cpp_file', output_node,
'out_cpps')
workflow.connect(nonlinear_registration, 'invcpp_file', output_node,
'out_invcpps')
return workflow
dg.inputs.server = args.server
dg.inputs.project = args.project
dg.inputs.subject = subject
dcm2nii = pe.Node(interface=mricron.Dcm2nii(), name='dcm2nii')
dcm2nii.inputs.args = '-d n'
dcm2nii.inputs.gzip_output = True
dcm2nii.inputs.anonymize = False
dcm2nii.inputs.reorient = True
dcm2nii.inputs.reorient_and_crop = False
#'/project/ADNI/subjects/0002/experiments/*/assessors/BET_MASK/resources/NIFTI
mni_to_input = pe.Node(interface=niftyreg.RegAladin(), name='mni_to_input')
mni_to_input.inputs.flo_file = mni_template
mask_resample = pe.Node(interface=niftyreg.RegResample(),
name='mask_resample')
mask_resample.inputs.inter_val = 'NN'
mask_resample.inputs.flo_file = mni_template_mask
dsx = pe.Node(interface=nio.XNATSink(), name='dsx')
dsx.inputs.user = args.username
dsx.inputs.pwd = args.password
dsx.inputs.server = args.server
dsx.inputs.project_id = args.project
dsx.inputs.subject_id = subject
dsx.inputs.experiment_id = first_mr_experiment.label()
dsx.inputs.assessor_id = 'BRAIN_MASK'
assessor = first_mr_experiment.assessor('BRAIN_MASK')
if not assessor.exists():
def create_image_to_mesh_workflow(input_images,
input_parcellations,
input_label_id,
result_dir,
rigid_iteration=3,
affine_iteration=3,
reduction_rate=0.1,
name='registrations_init'):
# Create the workflow
workflow = pe.Workflow(name=name)
workflow.base_dir = result_dir
workflow.base_output_dir = name
# Create a sub-workflow for groupwise registration
groupwise = create_atlas(itr_rigid=rigid_iteration,
itr_affine=affine_iteration,
itr_non_lin=0,
name='groupwise')
groupwise.inputs.input_node.in_files = input_images
groupwise.inputs.input_node.ref_file = input_images[0]
# Extract the relevant label from the GIF parcellation
extract_label = pe.MapNode(interface=MergeLabels(),
iterfield=['in_file'],
name='extract_label')
extract_label.iterables = ("roi_list", [[l] for l in input_label_id])
extract_label.inputs.in_file = input_parcellations
# Removing parasite segmentation: Erosion.
erode_binaries = pe.MapNode(interface=niftyseg.BinaryMathsInteger(
operation='ero', operand_value=1),
iterfield=['in_file'],
name='erode_binaries')
workflow.connect(extract_label, 'out_file', erode_binaries, 'in_file')
# Removing parasite segmentation: Dilatation.
dilate_binaries = pe.MapNode(interface=niftyseg.BinaryMathsInteger(
operation='dil', operand_value=1),
iterfield=['in_file'],
name='dilate_binaries')
workflow.connect(erode_binaries, 'out_file', dilate_binaries, 'in_file')
# Apply the relevant transformations to the roi
apply_affine = pe.MapNode(interface=niftyreg.RegResample(inter_val='NN'),
iterfield=['flo_file', 'trans_file'],
name='apply_affine')
workflow.connect(groupwise, 'output_node.trans_files', apply_affine,
'trans_file')
workflow.connect(groupwise, 'output_node.average_image', apply_affine,
'ref_file')
workflow.connect(dilate_binaries, 'out_file', apply_affine, 'flo_file')
# compute the large ROI that correspond to the union of all warped label
extract_union_roi = pe.Node(interface=niftyreg.RegAverage(),
name='extract_union_roi')
workflow.connect(apply_affine, 'res_file', extract_union_roi, 'in_files')
# Binarise the average ROI
binarise_roi = pe.Node(interface=niftyseg.UnaryMaths(operation='bin'),
name='binarise_roi')
workflow.connect(extract_union_roi, 'out_file', binarise_roi, 'in_file')
# Dilation of the binarise union ROI
dilate_roi = pe.Node(interface=niftyseg.BinaryMathsInteger(
operation='dil', operand_value=5),
name='dilate_roi')
workflow.connect(binarise_roi, 'out_file', dilate_roi, 'in_file')
# Apply the transformations
apply_rigid_refinement = pe.MapNode(interface=niftyreg.RegAladin(
rig_only_flag=True, ln_val=1),
iterfield=['flo_file', 'in_aff_file'],
name='apply_rigid_refinement')
apply_rigid_refinement.inputs.flo_file = input_images
workflow.connect(groupwise, 'output_node.average_image',
apply_rigid_refinement, 'ref_file')
workflow.connect(groupwise, 'output_node.trans_files',
apply_rigid_refinement, 'in_aff_file')
workflow.connect(dilate_roi, 'out_file', apply_rigid_refinement,
'rmask_file')
# Extract the mesh corresponding to the label
final_resampling = pe.MapNode(
interface=niftyreg.RegResample(inter_val='NN'),
iterfield=['flo_file', 'trans_file'],
name='final_resampling')
workflow.connect(apply_rigid_refinement, 'aff_file', final_resampling,
'trans_file')
workflow.connect(groupwise, 'output_node.average_image', final_resampling,
'ref_file')
workflow.connect(dilate_binaries, 'out_file', final_resampling, 'flo_file')
# Extract the mesh corresponding to the label
extract_mesh = pe.MapNode(
interface=Image2VtkMesh(in_reductionRate=reduction_rate),
iterfield=['in_file'],
name='extract_mesh')
workflow.connect(final_resampling, 'res_file', extract_mesh, 'in_file')
# workflow.connect(apply_rigid_refinement, 'aff_file', extract_mesh, 'matrix_file')
# Create a rename for the average image
groupwise_renamer = pe.Node(interface=niu.Rename(format_string='atlas',
keep_ext=True),
name='groupwise_renamer')
workflow.connect(groupwise, 'output_node.average_image', groupwise_renamer,
'in_file')
# Create a datasink
ds = pe.Node(nio.DataSink(parameterization=False), name='ds')
ds.inputs.base_directory = result_dir
workflow.connect(groupwise_renamer, 'out_file', ds, '@avg')
workflow.connect(apply_rigid_refinement, 'res_file', ds, '@raf_mask')
workflow.connect(extract_union_roi, 'out_file', ds, '@union_mask')
workflow.connect(dilate_roi, 'out_file', ds, '@dilate_mask')
workflow.connect(extract_mesh, 'out_file', ds, 'mesh_vtk')
return workflow
def create_asl_processing_workflow(in_inversion_recovery_file,
in_asl_file,
output_dir,
in_t1_file=None,
name='asl_processing_workflow'):
workflow = pe.Workflow(name=name)
workflow.base_output_dir = name
subject_id = split_filename(os.path.basename(in_asl_file))[1]
ir_splitter = pe.Node(interface=fsl.Split(
dimension='t',
out_base_name='out_',
in_file=in_inversion_recovery_file),
name='ir_splitter')
ir_selector = pe.Node(interface=niu.Select(index=[0, 2, 4]),
name='ir_selector')
workflow.connect(ir_splitter, 'out_files', ir_selector, 'inlist')
ir_merger = pe.Node(interface=fsl.Merge(dimension='t'), name='ir_merger')
workflow.connect(ir_selector, 'out', ir_merger, 'in_files')
fitqt1 = pe.Node(interface=niftyfit.FitQt1(TIs=[4, 2, 1], SR=True),
name='fitqt1')
workflow.connect(ir_merger, 'merged_file', fitqt1, 'source_file')
extract_ir_0 = pe.Node(interface=niftyseg.BinaryMathsInteger(
operation='tp', operand_value=0, in_file=in_inversion_recovery_file),
name='extract_ir_0')
ir_thresolder = pe.Node(interface=fsl.Threshold(thresh=250),
name='ir_thresolder')
workflow.connect(extract_ir_0, 'out_file', ir_thresolder, 'in_file')
create_mask = pe.Node(interface=fsl.UnaryMaths(operation='bin'),
name='create_mask')
workflow.connect(ir_thresolder, 'out_file', create_mask, 'in_file')
model_fitting = pe.Node(niftyfit.FitAsl(source_file=in_asl_file,
pcasl=True,
PLD=1800,
LDD=1800,
eff=0.614,
mul=0.1),
name='model_fitting')
workflow.connect(fitqt1, 'm0map', model_fitting, 'm0map')
workflow.connect(create_mask, 'out_file', model_fitting, 'mask')
t1_to_asl_registration = pe.Node(niftyreg.RegAladin(rig_only_flag=True),
name='t1_to_asl_registration')
m0_resampling = pe.Node(niftyreg.RegResample(inter_val='LIN'),
name='m0_resampling')
mc_resampling = pe.Node(niftyreg.RegResample(inter_val='LIN'),
name='mc_resampling')
t1_resampling = pe.Node(niftyreg.RegResample(inter_val='LIN'),
name='t1_resampling')
cbf_resampling = pe.Node(niftyreg.RegResample(inter_val='LIN'),
name='cbf_resampling')
if in_t1_file:
t1_to_asl_registration.inputs.flo_file = in_asl_file
t1_to_asl_registration.inputs.ref_file = in_t1_file
m0_resampling.inputs.ref_file = in_t1_file
mc_resampling.inputs.ref_file = in_t1_file
t1_resampling.inputs.ref_file = in_t1_file
cbf_resampling.inputs.ref_file = in_t1_file
workflow.connect(fitqt1, 'm0map', m0_resampling, 'flo_file')
workflow.connect(fitqt1, 'mcmap', mc_resampling, 'flo_file')
workflow.connect(fitqt1, 't1map', t1_resampling, 'flo_file')
workflow.connect(model_fitting, 'cbf_file', cbf_resampling, 'flo_file')
workflow.connect(t1_to_asl_registration, 'aff_file', m0_resampling,
'trans_file')
workflow.connect(t1_to_asl_registration, 'aff_file', mc_resampling,
'trans_file')
workflow.connect(t1_to_asl_registration, 'aff_file', t1_resampling,
'trans_file')
workflow.connect(t1_to_asl_registration, 'aff_file', cbf_resampling,
'trans_file')
maskrenamer = pe.Node(interface=niu.Rename(format_string=subject_id +
'_mask',
keep_ext=True),
name='maskrenamer')
m0renamer = pe.Node(interface=niu.Rename(format_string=subject_id +
'_m0map',
keep_ext=True),
name='m0renamer')
mcrenamer = pe.Node(interface=niu.Rename(format_string=subject_id +
'_mcmap',
keep_ext=True),
name='mcrenamer')
t1renamer = pe.Node(interface=niu.Rename(format_string=subject_id +
'_t1map',
keep_ext=True),
name='t1renamer')
workflow.connect(create_mask, 'out_file', maskrenamer, 'in_file')
if in_t1_file:
workflow.connect(m0_resampling, 'out_file', m0renamer, 'in_file')
workflow.connect(mc_resampling, 'out_file', mcrenamer, 'in_file')
workflow.connect(t1_resampling, 'out_file', t1renamer, 'in_file')
else:
workflow.connect(fitqt1, 'm0map', m0renamer, 'in_file')
workflow.connect(fitqt1, 'mcmap', mcrenamer, 'in_file')
workflow.connect(fitqt1, 't1map', t1renamer, 'in_file')
ds = pe.Node(nio.DataSink(parameterization=False,
base_directory=output_dir),
name='ds')
workflow.connect(maskrenamer, 'out_file', ds, '@mask_file')
workflow.connect(m0renamer, 'out_file', ds, '@m0_file')
workflow.connect(mcrenamer, 'out_file', ds, '@mc_file')
workflow.connect(t1renamer, 'out_file', ds, '@t1_file')
if in_t1_file:
workflow.connect(cbf_resampling, 'out_file', ds, '@cbf_file')
else:
workflow.connect(model_fitting, 'cbf_file', ds, '@cbf_file')
workflow.connect(model_fitting, 'error_file', ds, '@err_file')
return workflow
def create_regional_average_pipeline(output_dir,
name='regional_average',
in_trans=None,
in_weights=None,
in_label=None,
in_threshold=None,
freesurfer=False,
neuromorphometrics=False):
# Create the workflow
workflow = pe.Workflow(name=name)
workflow.base_dir = output_dir
workflow.base_output_dir = name
# Create the input node interface
input_node = pe.Node(interface=niu.IdentityInterface(
fields=['in_files', 'in_rois', 'in_trans', 'in_weights'],
mandatory_inputs=False),
name='input_node')
input_node.inputs.in_trans = in_trans
input_node.inputs.in_weights = in_weights
# Warp the parcelation in the input image space
if in_trans is not None:
resample = pe.MapNode(interface=niftyreg.RegResample(),
name='resampling',
iterfield=['ref_file', 'flo_file', 'trans_file'])
workflow.connect(input_node, 'in_files', resample, 'ref_file')
workflow.connect(input_node, 'in_rois', resample, 'flo_file')
workflow.connect(input_node, 'in_trans', resample, 'trans_file')
resample.inputs.inter_val = 'NN'
resample.inputs.verbosity_off_flag = True
# Compute the regional statistic
average_iterfield = ['in_file', 'roi_file']
if in_weights is not None:
average_iterfield = ['in_file', 'roi_file', 'weight_file']
compute_average = pe.MapNode(interface=ExtractRoiStatistics(),
name='compute_average',
iterfield=average_iterfield)
workflow.connect(input_node, 'in_files', compute_average, 'in_file')
if in_threshold is not None:
compute_average.inputs.in_threshold = in_threshold
if in_label is not None:
compute_average.inputs.in_label = in_label
if in_trans is not None:
workflow.connect(resample, 'out_file', compute_average, 'roi_file')
else:
workflow.connect(input_node, 'in_rois', compute_average, 'roi_file')
if in_weights is not None:
workflow.connect(input_node, 'in_weights', compute_average,
'weight_file')
# Save the result in a csv file
generate_csv = pe.MapNode(interface=WriteArrayToCsv(),
name='generate_csv',
iterfield=['in_array', 'in_name'])
workflow.connect(compute_average, 'out_array', generate_csv, 'in_array')
workflow.connect(input_node, 'in_files', generate_csv, 'in_name')
# The Freesurfer labels are added
if freesurfer is True:
add_fs_labels = pe.MapNode(
interface=FreesurferUpdateCsvFileWithLabels(),
name='add_fs_labels',
iterfield=['in_file'])
workflow.connect(generate_csv, 'out_file', add_fs_labels, 'in_file')
elif neuromorphometrics is True:
add_neuromorphometrics_labels = pe.MapNode(
interface=NeuromorphometricsUpdateCsvFileWithLabels(),
name='add_neuromorphometrics_labels',
iterfield=['in_file'])
workflow.connect(generate_csv, 'out_file',
add_neuromorphometrics_labels, 'in_file')
# Create the output node interface
output_node = pe.Node(
interface=niu.IdentityInterface(fields=['out_files', 'out_par_files']),
name='output_node')
if freesurfer is True:
workflow.connect(add_fs_labels, 'out_file', output_node, 'out_files')
elif neuromorphometrics is True:
workflow.connect(add_neuromorphometrics_labels, 'out_file',
output_node, 'out_files')
else:
workflow.connect(generate_csv, 'out_file', output_node, 'out_files')
if in_trans is not None:
workflow.connect(resample, 'out_file', output_node, 'out_par_files')
else:
workflow.connect(input_node, 'in_rois', output_node, 'out_par_files')
# Create a data sink
ds = pe.Node(nio.DataSink(parameterization=False), name='data_sink')
ds.inputs.base_directory = output_dir
workflow.connect(output_node, 'out_files', ds, '@out_files')
workflow.connect(output_node, 'out_par_files', ds, '@out_par_files')
# Return the created workflow
return workflow
def create_binary_to_meshes(label,
name='gw_binary_to_meshes',
reduction_rate=0.3,
operand_value=1):
# Create the workflow
workflow = pe.Workflow(name=name)
workflow.base_output_dir = name
# Create the input node
input_node = pe.Node(niu.IdentityInterface(fields=[
'input_images', 'input_parcellations', 'input_reference',
'trans_files', 'ref_file'
]),
name='input_node')
# Create the output node
output_node = pe.Node(niu.IdentityInterface(fields=['output_meshes']),
name='output_node')
# Extract the relevant label from the GIF parcellation
extract_label = pe.MapNode(interface=MergeLabels(),
iterfield=['in_file'],
name='extract_label')
extract_label.inputs.roi_list = label
workflow.connect(input_node, 'input_parcellations', extract_label,
'in_file')
# Removing parasite segmentation: Erosion.
erode_binaries = pe.MapNode(interface=niftyseg.BinaryMathsInteger(
operation='ero', operand_value=operand_value),
iterfield=['in_file'],
name='erode_binaries')
workflow.connect(extract_label, 'out_file', erode_binaries, 'in_file')
# Removing parasite segmentation: Dilatation.
dilate_binaries = pe.MapNode(interface=niftyseg.BinaryMathsInteger(
operation='dil', operand_value=operand_value),
iterfield=['in_file'],
name='dilate_binaries')
workflow.connect(erode_binaries, 'out_file', dilate_binaries, 'in_file')
# Apply the relevant transformations to the roi
apply_affine = pe.MapNode(interface=niftyreg.RegResample(inter_val='NN'),
iterfield=['flo_file', 'trans_file'],
name='apply_affine')
workflow.connect(input_node, 'trans_files', apply_affine, 'trans_file')
workflow.connect(input_node, 'ref_file', apply_affine, 'ref_file')
workflow.connect(dilate_binaries, 'out_file', apply_affine, 'flo_file')
# compute the large ROI that correspond to the union of all warped label
extract_union_roi = pe.Node(interface=niftyreg.RegAverage(),
name='extract_union_roi')
workflow.connect(apply_affine, 'out_file', extract_union_roi, 'avg_files')
# Binarise the average ROI
binarise_roi = pe.Node(interface=niftyseg.UnaryMaths(operation='bin'),
name='binarise_roi')
workflow.connect(extract_union_roi, 'out_file', binarise_roi, 'in_file')
# Dilation of the binarise union ROI
dilate_roi = pe.Node(interface=niftyseg.BinaryMathsInteger(
operation='dil', operand_value=4),
name='dilate_roi')
workflow.connect(binarise_roi, 'out_file', dilate_roi, 'in_file')
# Apply the transformations
apply_rigid_refinement = pe.MapNode(interface=niftyreg.RegAladin(
rig_only_flag=True, ln_val=1),
iterfield=['flo_file', 'in_aff_file'],
name='apply_rigid_refinement')
workflow.connect(input_node, 'input_images', apply_rigid_refinement,
'flo_file')
workflow.connect(input_node, 'ref_file', apply_rigid_refinement,
'ref_file')
workflow.connect(input_node, 'trans_files', apply_rigid_refinement,
'in_aff_file')
workflow.connect(dilate_roi, 'out_file', apply_rigid_refinement,
'rmask_file')
# Extract the mesh corresponding to the label
final_resampling = pe.MapNode(
interface=niftyreg.RegResample(inter_val='NN'),
iterfield=['flo_file', 'trans_file'],
name='final_resampling')
workflow.connect(apply_rigid_refinement, 'aff_file', final_resampling,
'trans_file')
workflow.connect(input_node, 'ref_file', final_resampling, 'ref_file')
workflow.connect(dilate_binaries, 'out_file', final_resampling, 'flo_file')
# Extract the mesh corresponding to the label
extract_mesh = pe.MapNode(
interface=Image2VtkMesh(in_reductionRate=reduction_rate),
iterfield=['in_file'],
name='extract_mesh')
workflow.connect(final_resampling, 'out_file', extract_mesh, 'in_file')
# workflow.connect(apply_rigid_refinement, 'aff_file', extract_mesh, 'matrix_file')
# Create a rename for the average image
groupwise_renamer = pe.Node(interface=niu.Rename(format_string='atlas',
keep_ext=True),
name='groupwise_renamer')
workflow.connect(input_node, 'ref_file', groupwise_renamer, 'in_file')
workflow.connect(extract_mesh, 'out_file', output_node, 'output_meshes')
return workflow
def create_compute_suvr_pipeline(input_pet,
input_mri,
input_par,
erode_ref,
output_dir,
name='compute_suvr',
norm_region='cereb'):
# Create the workflow
workflow = pe.Workflow(name=name)
workflow.base_dir = output_dir
workflow.base_output_dir = name
# Merge all the parcelation into a binary image
merge_roi = pe.MapNode(interface=niftyseg.UnaryMaths(),
name='merge_roi',
iterfield=['in_file'])
merge_roi.inputs.in_file = input_par
merge_roi.inputs.operation = 'bin'
dilation = pe.MapNode(interface=niftyseg.BinaryMathsInteger(),
name='dilation',
iterfield=['in_file'])
workflow.connect(merge_roi, 'out_file', dilation, 'in_file')
dilation.inputs.operation = 'dil'
dilation.inputs.operand_value = 5
# generate a mask for the pet image
mask_pet = create_mask_from_functional()
mask_pet.inputs.input_node.in_files = input_pet
# The structural image is first register to the pet image
rigid_reg = pe.MapNode(interface=niftyreg.RegAladin(),
name='rigid_reg',
iterfield=['ref_file',
'flo_file',
'rmask_file',
'fmask_file'])
rigid_reg.inputs.rig_only_flag = True
rigid_reg.inputs.verbosity_off_flag = True
rigid_reg.inputs.v_val = 80
rigid_reg.inputs.nosym_flag = False
rigid_reg.inputs.ref_file = input_pet
rigid_reg.inputs.flo_file = input_mri
workflow.connect(mask_pet, 'output_node.mask_files', rigid_reg, 'rmask_file')
workflow.connect(dilation, 'out_file', rigid_reg, 'fmask_file')
# Propagate the ROIs into the pet space
resampling = pe.MapNode(interface=niftyreg.RegResample(),
name='resampling',
iterfield=['ref_file', 'flo_file', 'trans_file'])
resampling.inputs.inter_val = 'NN'
resampling.inputs.verbosity_off_flag = True
resampling.inputs.ref_file = input_pet
resampling.inputs.flo_file = input_par
workflow.connect(rigid_reg, 'aff_file', resampling, 'trans_file')
# The PET image is normalised
normalisation_workflow = create_regional_normalisation_pipeline(erode_ref=erode_ref)
normalisation_workflow.inputs.input_node.input_files = input_pet
workflow.connect(resampling, 'out_file', normalisation_workflow, 'input_node.input_rois')
if norm_region == 'pons':
roi_indices = [35]
elif norm_region == 'gm_cereb':
roi_indices = [39, 40,72,73,74]
elif norm_region == 'wm_subcort':
roi_indices = [45, 46]
else: # full cerebellum
roi_indices = [39, 40, 41, 42, 72, 73, 74]
normalisation_workflow.inputs.input_node.label_indices = roi_indices
# The regional uptake are computed
regional_average_workflow = create_regional_average_pipeline(output_dir=output_dir, neuromorphometrics=True)
workflow.connect(normalisation_workflow, 'output_node.out_files',
regional_average_workflow, 'input_node.in_files')
workflow.connect(resampling, 'out_file',
regional_average_workflow, 'input_node.in_rois')
# Create an output node
output_node = pe.Node(
interface=niu.IdentityInterface(
fields=['norm_files',
'suvr_files',
'tran_files',
'out_par_files']),
name='output_node')
workflow.connect(normalisation_workflow, 'output_node.out_files',
output_node, 'norm_files')
workflow.connect(regional_average_workflow, 'output_node.out_files', output_node, 'suvr_files')
workflow.connect(rigid_reg, 'aff_file', output_node, 'tran_files')
workflow.connect(resampling, 'out_file', output_node, 'out_par_files')
# Create a data sink
ds = pe.Node(nio.DataSink(parameterization=False), name='data_sink')
ds.inputs.base_directory = output_dir
workflow.connect(output_node, 'norm_files', ds, '@norm_files')
workflow.connect(output_node, 'tran_files', ds, '@tran_files')
# Return the created workflow
return workflow
def create_restingstatefmri_preprocessing_pipeline(in_fmri,
in_t1,
in_segmentation,
in_parcellation,
output_dir,
in_mag=None,
in_phase=None,
in_susceptibility_parameters=None,
name='restingstatefmri'):
"""Perform pre-processing steps for the resting state fMRI using AFNI
Parameters
----------
::
name : name of workflow (default: restingstatefmri)
Inputs::
in_fmri : functional runs into a single 4D image in NIFTI format
in_t1 : The structural T1 image
in_segmentation : The segmentation image containing 6 volumes (background, CSF, GM, WM, deep GM, brainstem),
in the space of the fMRI image
in_parcellation : The parcellation image coming out of the GIF parcellation algorithm
output_dir : The output directory for the workflow
in_mag : *OPT*, magnitude image to use for susceptibility correction (default: None)
in_phase : *OPT*, phase image to use for susceptibility correction (default: None)
in_susceptibility_parameters : *OPT*, susceptibility parameters
(in a vector: read-out-time, echo time difference, phase encoding direction], default : None)
name : *OPT*, name of the workflow (default : restingstatefmri)
Outputs::
Example
-------
>>> preproc = create_restingstatefmri_preprocessing_pipeline(in_fmri, in_t1, in_segmentation, in_parcellation, output_dir) # doctest: +SKIP
>>> preproc.base_dir = '/tmp' # doctest: +SKIP
>>> preproc.run() # doctest: +SKIP
"""
workflow = pe.Workflow(name=name)
workflow.base_output_dir = name
# We need to create an input node for the workflow
input_node = pe.Node(
niu.IdentityInterface(
fields=['in_fmri',
'in_t1',
'in_segmentation',
'in_parcellation']),
name='input_node')
input_node.inputs.in_fmri = in_fmri
input_node.inputs.in_t1 = in_t1
input_node.inputs.in_segmentation = in_segmentation
input_node.inputs.in_parcellation = in_parcellation
resting_state_preproc = pe.Node(interface=RestingStatefMRIPreprocess(),
name='resting_state_preproc')
workflow.connect(input_node, 'in_fmri', resting_state_preproc, 'in_fmri')
workflow.connect(input_node, 'in_t1', resting_state_preproc, 'in_t1')
workflow.connect(input_node, 'in_segmentation', resting_state_preproc, 'in_tissue_segmentation')
workflow.connect(input_node, 'in_parcellation', resting_state_preproc, 'in_parcellation')
# fMRI QC plot
plotter = pe.Node(interface=FmriQcPlot(),
name='plotter')
workflow.connect(input_node, 'in_fmri', plotter, 'in_raw_fmri')
workflow.connect(resting_state_preproc, 'out_raw_fmri_gm', plotter, 'in_raw_fmri_gm')
workflow.connect(resting_state_preproc, 'out_raw_fmri_wm', plotter, 'in_raw_fmri_wm')
workflow.connect(resting_state_preproc, 'out_raw_fmri_csf', plotter, 'in_raw_fmri_csf')
workflow.connect(resting_state_preproc, 'out_mrp_file', plotter, 'in_mrp_file')
workflow.connect(resting_state_preproc, 'out_spike_file', plotter, 'in_spike_file')
workflow.connect(resting_state_preproc, 'out_rms_file', plotter, 'in_rms_file')
# Output node
output_node = pe.Node(interface=niu.IdentityInterface(fields=['out_corrected_fmri',
'out_atlas_fmri',
'out_fmri_to_t1_transformation',
'out_raw_fmri_gm',
'out_raw_fmri_wm',
'out_raw_fmri_csf',
'out_fmri_qc',
'out_motioncorrected_file']),
name="output_node")
workflow.connect(resting_state_preproc, 'out_corrected_fmri', output_node, 'out_corrected_fmri')
workflow.connect(resting_state_preproc, 'out_atlas_fmri', output_node, 'out_atlas_fmri')
workflow.connect(resting_state_preproc, 'out_fmri_to_t1_transformation', output_node,
'out_fmri_to_t1_transformation')
workflow.connect(resting_state_preproc, 'out_raw_fmri_gm', output_node, 'out_raw_fmri_gm')
workflow.connect(resting_state_preproc, 'out_raw_fmri_wm', output_node, 'out_raw_fmri_wm')
workflow.connect(resting_state_preproc, 'out_raw_fmri_csf', output_node, 'out_raw_fmri_csf')
workflow.connect(resting_state_preproc, 'out_motioncorrected_file', output_node, 'out_motioncorrected_file')
workflow.connect(plotter, 'out_file', output_node, 'out_fmri_qc')
ds = pe.Node(nio.DataSink(), name='ds')
ds.inputs.base_directory = os.path.abspath(output_dir)
ds.inputs.parameterization = False
workflow.connect(output_node, 'out_fmri_to_t1_transformation', ds, '@fmri_to_t1_transformation')
workflow.connect(output_node, 'out_atlas_fmri', ds, '@atlas_in_fmri')
workflow.connect(output_node, 'out_raw_fmri_gm', ds, '@gm_in_fmri')
workflow.connect(output_node, 'out_raw_fmri_wm', ds, '@wm_in_fmri')
workflow.connect(output_node, 'out_raw_fmri_csf', ds, '@csf_in_fmri')
workflow.connect(output_node, 'out_fmri_qc', ds, '@fmri_qc')
if in_mag is None or in_phase is None or in_susceptibility_parameters is None:
workflow.connect(output_node, 'out_motioncorrected_file', ds, '@motioncorrected_file')
workflow.connect(output_node, 'out_corrected_fmri', ds, '@corrected_fmri')
else:
split_fmri = pe.Node(interface=fsl.Split(dimension='t'),
name='split_fmri')
workflow.connect(output_node, 'out_motioncorrected_file', split_fmri, 'in_file')
select_1st_fmri = pe.Node(interface=niu.Select(index=0),
name='select_1st_fmri')
workflow.connect(split_fmri, 'out_files', select_1st_fmri, 'inlist')
binarise_parcellation = pe.Node(interface=fsl.UnaryMaths(operation='bin'),
name='binarise_parcellation')
workflow.connect(input_node, 'in_parcellation', binarise_parcellation, 'in_file')
# Perform susceptibility correction, where we already have a mask in the b0 space
susceptibility_correction = create_fieldmap_susceptibility_workflow('susceptibility_correction',
reg_to_t1=True)
susceptibility_correction.inputs.input_node.mag_image = os.path.abspath(in_mag)
susceptibility_correction.inputs.input_node.phase_image = os.path.abspath(in_phase)
susceptibility_correction.inputs.input_node.t1 = os.path.abspath(in_t1)
susceptibility_correction.inputs.input_node.rot = in_susceptibility_parameters[0]
susceptibility_correction.inputs.input_node.etd = in_susceptibility_parameters[1]
susceptibility_correction.inputs.input_node.ped = in_susceptibility_parameters[2]
workflow.connect(select_1st_fmri, 'out', susceptibility_correction, 'input_node.epi_image')
workflow.connect(binarise_parcellation, 'out_file', susceptibility_correction, 'input_node.t1_mask')
fmri_corrected_resample = pe.Node(interface=niftyreg.RegResample(inter_val='LIN'),
name='fmri_corrected_resample')
workflow.connect(output_node, 'out_corrected_fmri', fmri_corrected_resample, 'ref_file')
workflow.connect(output_node, 'out_corrected_fmri', fmri_corrected_resample, 'flo_file')
workflow.connect(susceptibility_correction.get_node('output_node'), 'out_field',
fmri_corrected_resample, 'trans_file')
workflow.connect(fmri_corrected_resample, 'out_file', ds, '@corrected_fmri')
fmri_motion_corrected_resample = pe.Node(interface=niftyreg.RegResample(inter_val='LIN'),
name='fmri_motion_corrected_resample')
workflow.connect(output_node, 'out_motioncorrected_file', fmri_motion_corrected_resample, 'ref_file')
workflow.connect(output_node, 'out_motioncorrected_file', fmri_motion_corrected_resample, 'flo_file')
workflow.connect(susceptibility_correction.get_node('output_node'), 'out_field',
fmri_motion_corrected_resample, 'trans_file')
workflow.connect(fmri_motion_corrected_resample, 'out_file', ds, '@motioncorrected_file')
return workflow
