def test_create_eddy_correct_pipeline():
fsl_course_dir = os.path.abspath('fsl_course_data')
dwi_file = os.path.join(fsl_course_dir, "fdt/subj1/data.nii.gz")
nipype_eddycorrect = create_eddy_correct_pipeline("nipype_eddycorrect")
nipype_eddycorrect.inputs.inputnode.in_file = dwi_file
nipype_eddycorrect.inputs.inputnode.ref_num = 0
with warnings.catch_warnings():
warnings.simplefilter("ignore")
original_eddycorrect = pe.Node(interface=fsl.EddyCorrect(), name="original_eddycorrect")
original_eddycorrect.inputs.in_file = dwi_file
original_eddycorrect.inputs.ref_num = 0
test = pe.Node(util.AssertEqual(), name="eddy_corrected_dwi_test")
pipeline = pe.Workflow(name="test_eddycorrect")
pipeline.base_dir = tempfile.mkdtemp(prefix="nipype_test_eddycorrect_")
pipeline.connect([(nipype_eddycorrect, test, [("outputnode.eddy_corrected", "volume1")]),
(original_eddycorrect, test, [("eddy_corrected", "volume2")]),
])
pipeline.run(plugin='Linear')
shutil.rmtree(pipeline.base_dir)
def create_prep(subj):
inputspec = pe.Node(interface=util.IdentityInterface(fields=['dwi','bvec','bval']),
name='inputspec')
gen_fa = pe.Workflow(name="gen_fa")
gen_fa.base_dir = os.path.join(os.path.abspath(workingdir), 'l1')
eddy_correct = create_eddy_correct_pipeline()
eddy_correct.inputs.inputnode.ref_num = 0
gen_fa.connect(inputspec, 'dwi', eddy_correct, 'inputnode.in_file')
bet = pe.Node(interface=fsl.BET(), name='bet')
bet.inputs.mask = True
bet.inputs.frac = frac
gen_fa.connect(eddy_correct, 'pick_ref.out', bet, 'in_file')
dtifit = pe.Node(interface=fsl.DTIFit(), name='dtifit')
gen_fa.connect(eddy_correct, 'outputnode.eddy_corrected', dtifit, 'dwi')
dtifit.inputs.base_name = subj
gen_fa.connect(bet, 'mask_file', dtifit, 'mask')
gen_fa.connect(inputspec, 'bvec', dtifit, 'bvecs')
gen_fa.connect(inputspec, 'bval', dtifit, 'bvals')
outputnode = pe.Node(interface=util.IdentityInterface(fields=['FA','MD']), name='outputspec')
gen_fa.connect(dtifit, 'FA', outputnode, 'FA')
gen_fa.connect(dtifit, 'MD', outputnode, 'MD')
return gen_fa
def create_dwi_preprocess_pipeline(name="preprocess"):
inputnode = pe.Node(interface=util.IdentityInterface(fields=['dwi']), name="inputnode")
preprocess = pe.Workflow(name=name)
"""
extract the volume with b=0 (nodif_brain)
"""
fslroi = pe.Node(interface=fsl.ExtractROI(),name='fslroi')
fslroi.inputs.t_min=0
fslroi.inputs.t_size=1
"""
create a brain mask from the nodif_brain
"""
bet = pe.Node(interface=fsl.BET(),name='bet')
bet.inputs.mask=True
bet.inputs.frac=0.34
"""
correct the diffusion weighted images for eddy_currents
"""
eddycorrect = create_eddy_correct_pipeline("eddycorrect")
eddycorrect.inputs.inputnode.ref_num=0
preprocess.connect([(inputnode, fslroi,[('dwi','in_file')]),
(inputnode, eddycorrect, [('dwi','inputnode.in_file')]),
(fslroi,bet,[('roi_file','in_file')]),
])
return preprocess
def create_dti_workflow(name="dti_workflow"):
inputnode = pe.Node(interface=util.IdentityInterface(fields=['dwi', 'bvals',
'bvecs']), name="inputnode")
eddie_correct = create_eddy_correct_pipeline(name="eddie_correct")
eddie_correct.inputs.inputnode.ref_num = 0
mrtrix = create_mrtrix_dti_pipeline('mrtrix', tractography_type='deterministic')
gen_WM_mask = mrtrix.get_node("gen_WM_mask")
csdeconv = mrtrix.get_node("csdeconv")
mrtrix.disconnect([(gen_WM_mask, csdeconv,[("WMprobabilitymap","mask_image")])])
bet = mrtrix.get_node("bet")
mrtrix.connect([(bet, csdeconv,[("mask_file","mask_image")])])
mrtrix.inputs.CSDstreamtrack.desired_number_of_tracks = 20000
#mrtrix.inputs.CSDstreamtrack.minimum_radius_of_curvature = 2
mrtrix.inputs.CSDstreamtrack.minimum_tract_length = 40
mrtrix.inputs.CSDstreamtrack.cutoff_value = 0.2
mrtrix.inputs.fsl2mrtrix.invert_z = True
mrtrix.inputs.bet.frac = 0.7
mrtrix.inputs.estimateresponse.maximum_harmonic_order = 10
mrtrix.inputs.csdeconv.maximum_harmonic_order = 10
spline_clean = pe.Node(interface=dt.SplineFilter(step_length=0.5), name="spline_clean")
dwiproc = pe.Workflow(name=name)
dwiproc.connect([
(inputnode, eddie_correct,[('dwi','inputnode.in_file'),
]),
(inputnode, mrtrix, [('bvals','inputnode.bvals'),
('bvecs','inputnode.bvecs')]),
(eddie_correct, mrtrix, [('outputnode.eddy_corrected', 'inputnode.dwi')]),
# (mrtrix, spline_clean, [('outputnode.tracts_trk', 'track_file')])
])
return dwiproc
def test_create_eddy_correct_pipeline():
fsl_course_dir = os.path.abspath('fsl_course_data')
dwi_file = os.path.join(fsl_course_dir, "fdt/subj1/data.nii.gz")
nipype_eddycorrect = create_eddy_correct_pipeline("nipype_eddycorrect")
nipype_eddycorrect.inputs.inputnode.in_file = dwi_file
nipype_eddycorrect.inputs.inputnode.ref_num = 0
with warnings.catch_warnings():
warnings.simplefilter("ignore")
original_eddycorrect = pe.Node(interface=fsl.EddyCorrect(),
name="original_eddycorrect")
original_eddycorrect.inputs.in_file = dwi_file
original_eddycorrect.inputs.ref_num = 0
test = pe.Node(util.AssertEqual(), name="eddy_corrected_dwi_test")
pipeline = pe.Workflow(name="test_eddycorrect")
pipeline.base_dir = tempfile.mkdtemp(prefix="nipype_test_eddycorrect_")
pipeline.connect([
(nipype_eddycorrect, test, [("outputnode.eddy_corrected", "volume1")]),
(original_eddycorrect, test, [("eddy_corrected", "volume2")]),
])
pipeline.run(plugin='Linear')
shutil.rmtree(pipeline.base_dir)
fslroi.inputs.t_min = 0
fslroi.inputs.t_size = 1
"""
create a brain mask from the nodif_brain
"""
bet = pe.Node(interface=fsl.BET(), name='bet')
bet.inputs.mask = True
bet.inputs.frac = 0.34
"""
correct the diffusion weighted images for eddy_currents
"""
eddycorrect = create_eddy_correct_pipeline('eddycorrect')
eddycorrect.inputs.inputnode.ref_num = 0
"""
compute the diffusion tensor in each voxel
"""
dtifit = pe.Node(interface=dtk.DTIRecon(), name='dtifit')
"""
connect all the nodes for this workflow
"""
computeTensor.connect([
(fslroi, bet, [('roi_file', 'in_file')]),
(eddycorrect, dtifit, [('outputnode.eddy_corrected', 'DWI')])
from nipype.workflows.dmri.fsl.dti import create_eddy_correct_pipeline
from classInterfaces import BrainExtraction, EddyCorrection, ResampleVoxelSize, TensorModel, Tracking
path ='/home/bao/tiensy/Nipype_tutorial/data/dmri/temp6/'
data = path+ 'raw.nii.gz'
###### WORKFLOW DEFINITION #######
wf=pe.Workflow(name="reconstructing_tractography")
wf.base_dir= path + 'results'
wf.config['execution'] = {'remove_unnecessary_outputs': 'False'}
###### NODE DEFINITION #######
brain_extraction_node = pe.Node(fsl.BET(), name="brain_extraction_node")
eddy_current_correction_node = create_eddy_correct_pipeline("nipype_eddycorrect_wkf")
resample_voxel_size_node = pe.Node(ResampleVoxelSize(), name='resample_voxel_size_node')
tensor_model_node = pe.Node(TensorModel(), name='tensor_model_node')
tracking_node = pe.Node(Tracking(), name='tracking_node')
###### INPUT NODE DEFINITION #######
#inputs: brain_extraction_node
brain_extraction_node.inputs.in_file=data
brain_extraction_node.inputs.frac = 0.2
brain_extraction_node.inputs.functional = True
#brain_extraction_node.inputs.robust = True
brain_extraction_node.inputs.vertical_gradient = 0
brain_extraction_node.inputs.out_file = path + 'raw_bet.nii.gz'
fslroi = pe.Node(interface=fsl.ExtractROI(), name='fslroi')
fslroi.inputs.t_min = 0
fslroi.inputs.t_size = 1
"""
create a brain mask from the nodif_brain
"""
bet = pe.Node(interface=fsl.BET(), name='bet')
bet.inputs.mask = True
bet.inputs.frac = 0.34
"""
correct the diffusion weighted images for eddy_currents
"""
eddycorrect = create_eddy_correct_pipeline('eddycorrect')
eddycorrect.inputs.inputnode.ref_num = 0
hardi_mat = pe.Node(interface=dtk.HARDIMat(), name='hardi_mat')
odf_recon = pe.Node(interface=dtk.ODFRecon(), name='odf_recon')
"""
connect all the nodes for this workflow
"""
compute_ODF.connect([(fslroi, bet, [('roi_file', 'in_file')]),
(eddycorrect, odf_recon, [('outputnode.eddy_corrected',
'DWI')]),
(eddycorrect, hardi_mat, [('outputnode.eddy_corrected',
'reference_file')]),
(hardi_mat, odf_recon, [('out_file', 'matrix')])])
http://www.brain.org.au/software/mrtrix/index.html
MRtrix's online documentation
b-values and b-vectors stored in FSL's format are converted into a single encoding file for MRTrix.
"""
fsl2mrtrix = pe.Node(interface=mrtrix.FSL2MRTrix(),name='fsl2mrtrix')
"""
Distortions induced by eddy currents are corrected prior to fitting the tensors.
The first image is used as a reference for which to warp the others.
"""
eddycorrect = create_eddy_correct_pipeline(name='eddycorrect')
eddycorrect.inputs.inputnode.ref_num = 1
"""
Tensors are fitted to each voxel in the diffusion-weighted image and from these three maps are created:
* Major eigenvector in each voxel
* Apparent diffusion coefficient
* Fractional anisotropy
"""
dwi2tensor = pe.Node(interface=mrtrix.DWI2Tensor(),name='dwi2tensor')
tensor2vector = pe.Node(interface=mrtrix.Tensor2Vector(),name='tensor2vector')
tensor2adc = pe.Node(interface=mrtrix.Tensor2ApparentDiffusion(),name='tensor2adc')
tensor2fa = pe.Node(interface=mrtrix.Tensor2FractionalAnisotropy(),name='tensor2fa')
MRconvert_fa = pe.Node(interface=mrtrix.MRConvert(),name='MRconvert_fa')
subject_id_infosource = pe.Node(util.IdentityInterface(fields=['subject_id']),
name='subject_id_infosource')
subject_id_infosource.iterables = ('subject_id', subjects_list)
datasource = pe.Node(interface=nio.DataGrabber(
infields=['subject_id'], outfields=['dwi', 'bvec', 'bval']),
name='datasource')
datasource.inputs.base_directory = os.path.abspath(dataDir)
datasource.inputs.template = '%s/session2/DTI_mx_137/dti.%s'
datasource.inputs.template_args = dict(dwi=[['subject_id', 'nii.gz']],
bvec=[['subject_id', 'bvec']],
bval=[['subject_id', 'bval']])
datasource.inputs.sort_filelist = True
gen_fa.connect(subject_id_infosource, 'subject_id', datasource, 'subject_id')
eddy_correct = create_eddy_correct_pipeline()
eddy_correct.inputs.inputnode.ref_num = 0
gen_fa.connect(datasource, 'dwi', eddy_correct, 'inputnode.in_file')
bet = pe.Node(interface=fsl.BET(), name='bet')
bet.inputs.mask = True
bet.inputs.frac = 0.34
gen_fa.connect(eddy_correct, 'pick_ref.out', bet, 'in_file')
dtifit = pe.Node(interface=fsl.DTIFit(), name='dtifit')
gen_fa.connect(eddy_correct, 'outputnode.eddy_corrected', dtifit, 'dwi')
gen_fa.connect(subject_id_infosource, 'subject_id', dtifit, 'base_name')
gen_fa.connect(bet, 'mask_file', dtifit, 'mask')
gen_fa.connect(datasource, 'bvec', dtifit, 'bvecs')
gen_fa.connect(datasource, 'bval', dtifit, 'bvals')
http://www.brain.org.au/software/mrtrix/index.html
MRtrix's online documentation
b-values and b-vectors stored in FSL's format are converted into a single encoding file for MRTrix.
"""
fsl2mrtrix = pe.Node(interface=mrtrix.FSL2MRTrix(), name="fsl2mrtrix")
"""
Distortions induced by eddy currents are corrected prior to fitting the tensors.
The first image is used as a reference for which to warp the others.
"""
eddycorrect = create_eddy_correct_pipeline(name="eddycorrect")
eddycorrect.inputs.inputnode.ref_num = 1
"""
Tensors are fitted to each voxel in the diffusion-weighted image and from these three maps are created:
* Major eigenvector in each voxel
* Apparent diffusion coefficient
* Fractional anisotropy
"""
dwi2tensor = pe.Node(interface=mrtrix.DWI2Tensor(), name="dwi2tensor")
tensor2vector = pe.Node(interface=mrtrix.Tensor2Vector(), name="tensor2vector")
tensor2adc = pe.Node(interface=mrtrix.Tensor2ApparentDiffusion(), name="tensor2adc")
tensor2fa = pe.Node(interface=mrtrix.Tensor2FractionalAnisotropy(), name="tensor2fa")
MRconvert_fa = pe.Node(interface=mrtrix.MRConvert(), name="MRconvert_fa")
subject_id_infosource.iterables = ('subject_id', subjects_list)
datasource = pe.Node(
interface=nio.DataGrabber(
infields=['subject_id'], outfields=['dwi', 'bvec', 'bval']),
name='datasource')
datasource.inputs.base_directory = os.path.abspath(dataDir)
datasource.inputs.template = '%s/session2/DTI_mx_137/dti.%s'
datasource.inputs.template_args = dict(
dwi=[['subject_id', 'nii.gz']],
bvec=[['subject_id', 'bvec']],
bval=[['subject_id', 'bval']])
datasource.inputs.sort_filelist = True
gen_fa.connect(subject_id_infosource, 'subject_id', datasource, 'subject_id')
eddy_correct = create_eddy_correct_pipeline()
eddy_correct.inputs.inputnode.ref_num = 0
gen_fa.connect(datasource, 'dwi', eddy_correct, 'inputnode.in_file')
bet = pe.Node(interface=fsl.BET(), name='bet')
bet.inputs.mask = True
bet.inputs.frac = 0.34
gen_fa.connect(eddy_correct, 'pick_ref.out', bet, 'in_file')
dtifit = pe.Node(interface=fsl.DTIFit(), name='dtifit')
gen_fa.connect(eddy_correct, 'outputnode.eddy_corrected', dtifit, 'dwi')
gen_fa.connect(subject_id_infosource, 'subject_id', dtifit, 'base_name')
gen_fa.connect(bet, 'mask_file', dtifit, 'mask')
gen_fa.connect(datasource, 'bvec', dtifit, 'bvecs')
gen_fa.connect(datasource, 'bval', dtifit, 'bvals')
http://www.brain.org.au/software/mrtrix/index.html
MRtrix's online documentation
b-values and b-vectors stored in FSL's format are converted into a single encoding file for MRTrix.
"""
fsl2mrtrix = pe.Node(interface=mrtrix.FSL2MRTrix(), name='fsl2mrtrix')
"""
Distortions induced by eddy currents are corrected prior to fitting the tensors.
The first image is used as a reference for which to warp the others.
"""
eddycorrect = create_eddy_correct_pipeline(name='eddycorrect')
eddycorrect.inputs.inputnode.ref_num = 1
"""
Tensors are fitted to each voxel in the diffusion-weighted image and from these three maps are created:
* Major eigenvector in each voxel
* Apparent diffusion coefficient
* Fractional anisotropy
"""
dwi2tensor = pe.Node(interface=mrtrix.DWI2Tensor(), name='dwi2tensor')
tensor2vector = pe.Node(interface=mrtrix.Tensor2Vector(), name='tensor2vector')
tensor2adc = pe.Node(interface=mrtrix.Tensor2ApparentDiffusion(),
name='tensor2adc')
tensor2fa = pe.Node(interface=mrtrix.Tensor2FractionalAnisotropy(),
name='tensor2fa')
MRconvert_fa = pe.Node(interface=mrtrix.MRConvert(), name='MRconvert_fa')
