def test_eudx_bad_seed():
"""Test passing a bad seed to eudx"""
fimg, fbvals, fbvecs = get_data('small_101D')
img = ni.load(fimg)
affine = img.get_affine()
data = img.get_data()
gtab = gradient_table(fbvals, fbvecs)
tensor_model = TensorModel(gtab)
ten = tensor_model.fit(data)
ind = quantize_evecs(ten.evecs)
sphere = get_sphere('symmetric724')
seed = [1000000., 1000000., 1000000.]
eu = EuDX(a=ten.fa, ind=ind, seeds=[seed],
odf_vertices=sphere.vertices, a_low=.2)
assert_raises(ValueError, list, eu)
print(data.shape)
seed = [1., 5., 8.]
eu = EuDX(a=ten.fa, ind=ind, seeds=[seed],
odf_vertices=sphere.vertices, a_low=.2)
track = list(eu)
seed = [-1., 1000000., 1000000.]
eu = EuDX(a=ten.fa, ind=ind, seeds=[seed],
odf_vertices=sphere.vertices, a_low=.2)
assert_raises(ValueError, list, eu)
def test_eudx_further():
""" Cause we love testin.. ;-)
"""
fimg,fbvals,fbvecs=get_data('small_101D')
img=ni.load(fimg)
affine=img.get_affine()
data=img.get_data()
gtab = gradient_table(fbvals, fbvecs)
tensor_model = TensorModel(gtab)
ten = tensor_model.fit(data)
x,y,z=data.shape[:3]
seeds=np.zeros((10**4,3))
for i in range(10**4):
rx=(x-1)*np.random.rand()
ry=(y-1)*np.random.rand()
rz=(z-1)*np.random.rand()
seeds[i]=np.ascontiguousarray(np.array([rx,ry,rz]),dtype=np.float64)
sphere = get_sphere('symmetric724')
ind = quantize_evecs(ten.evecs)
eu=EuDX(a=ten.fa, ind=ind, seeds=seeds,
odf_vertices=sphere.vertices, a_low=.2)
T=[e for e in eu]
#check that there are no negative elements
for t in T:
assert_equal(np.sum(t.ravel()<0),0)
# Test eudx with affine
def random_affine(seeds):
affine = np.eye(4)
affine[:3, :] = np.random.random((3, 4))
seeds = np.dot(seeds, affine[:3, :3].T)
seeds += affine[:3, 3]
return affine, seeds
# Make two random affines and move seeds
affine1, seeds1 = random_affine(seeds)
affine2, seeds2 = random_affine(seeds)
# Make tracks using different affines
eu1 = EuDX(a=ten.fa, ind=ind, odf_vertices=sphere.vertices,
seeds=seeds1, a_low=.2, affine=affine1)
eu2 = EuDX(a=ten.fa, ind=ind, odf_vertices=sphere.vertices,
seeds=seeds2, a_low=.2, affine=affine2)
# Move from eu2 affine2 to affine1
eu2_to_eu1 = utils.move_streamlines(eu2, output_space=affine1,
input_space=affine2)
# Check that the tracks are the same
for sl1, sl2 in zip(eu1, eu2_to_eu1):
assert_array_almost_equal(sl1, sl2)
def test_eudx_further():
""" Cause we love testin.. ;-)
"""
fimg,fbvals,fbvecs=get_data('small_101D')
img=ni.load(fimg)
affine=img.get_affine()
data=img.get_data()
gtab = gradient_table(fbvals, fbvecs)
tensor_model = TensorModel(gtab)
ten = tensor_model.fit(data)
x,y,z=data.shape[:3]
seeds=np.zeros((10**4,3))
for i in range(10**4):
rx=(x-1)*np.random.rand()
ry=(y-1)*np.random.rand()
rz=(z-1)*np.random.rand()
seeds[i]=np.ascontiguousarray(np.array([rx,ry,rz]),dtype=np.float64)
#print seeds
#"""
ind = quantize_evecs(ten.evecs)
eu=EuDX(a=ten.fa, ind=ind, seeds=seeds, a_low=.2)
T=[e for e in eu]
#check that there are no negative elements
for t in T:
assert_equal(np.sum(t.ravel()<0),0)
def fibers_eudx(self, stopping_values, peak_indices, seeds, odf_vertices,
cutoff):
# WGR:TODO figure out how to organize tensor options and formats
# WGR:TODO figure out how to deal with files on disk vs. in workspace
"""
Tensors are used to construct fibers
**Positional Arguments:**
dti_vol:
- Registered DTI volume, from workspace.
atlas_file:
- File containing an atlas (or brain mask).
gtab:
- Structure containing dipy formatted bval/bvec information
"""
streamline_generator = EuDX(stopping_values,
csd_peaks.peak_indices,
seeds=10**6,
odf_vertices=sphere.vertices,
a_low=0.1)
streamlines = [streamline for streamline in streamline_generator]
return streamlines
def tensorTractography(tenfit, img, falow=0.3):
fa = tenfit.fa
fa[np.isnan(fa)] = 0
evecs = tenfit.evecs
hdr = nib.trackvis.empty_header()
hdr['voxel_size'] = img.get_header().get_zooms()[:3]
hdr['voxel_order'] = 'LAS'
hdr['dim'] = fa.shape
from dipy.data import get_sphere #EuDX needs to map voxel dirs on a sphere
sphere = get_sphere('symmetric724')
from dipy.reconst.dti import quantize_evecs
peak_indices = quantize_evecs(evecs, sphere.vertices)
from dipy.tracking.eudx import EuDX
eu = EuDX(fa,
peak_indices,
odf_vertices=sphere.vertices,
a_low=falow,
ang_thr=30.0)
tensor_streamlines = [streamline for streamline in eu]
tensor_streamlines_trk = ((sl, None, None) for sl in tensor_streamlines)
ten_sl_fname = 'tensor_streamlines_tests.trk'
nib.trackvis.write(ten_sl_fname,
tensor_streamlines_trk,
hdr,
points_space='voxel')
def test_eudx_boundaries():
"""
This test checks that the tracking will exclude seeds in both directions.
Here we create a volume of shape (50, 60, 40) and we will add 2 seeds
exactly at the volume's boundaries (49, 0, 0) and (0, 0, 0). Those should
not generate any streamlines as EuDX does not interpolate on the boundary
voxels. We also add 3 seeds not in the boundaries which should generate
streamlines without a problem.
"""
fa = np.ones((50, 60, 40))
ind = np.zeros(fa.shape)
sphere = get_sphere('repulsion724')
seed = [49., 0, 0]
seed2 = [0., 0, 0]
seed3 = [48., 0, 0]
seed4 = [1., 0, 0]
seed5 = [5., 5, 5]
eu = EuDX(a=fa,
ind=ind,
seeds=[seed, seed2, seed3, seed4, seed5],
odf_vertices=sphere.vertices,
a_low=.2,
total_weight=0.)
track = list(eu)
assert_equal(len(track), 3)
def tracking_eudx(dir_src, dir_out, verbose=False):
# Loading FA and evecs data
fa_name = 'data_' + par_b_tag + '_' + par_dim_tag + '_FA.nii.gz'
FA, affine = load_nifti(pjoin(dir_src, fa_name), verbose)
evecs_name = 'data_' + par_b_tag + '_' + par_dim_tag + '_EV.nii.gz'
evecs, _ = load_nifti(pjoin(dir_src, evecs_name), verbose)
# Computation of streamlines
sphere = get_sphere('symmetric724')
peak_indices = quantize_evecs(evecs, sphere.vertices)
streamlines = EuDX(FA.astype('f8'),
ind=peak_indices,
seeds=par_eudx_seeds,
odf_vertices=sphere.vertices,
a_low=par_eudx_threshold)
# Saving tractography
voxel_size = (par_dim_vox, ) * 3
dims = FA.shape[:3]
hdr = nib.trackvis.empty_header()
hdr['voxel_size'] = voxel_size
hdr['voxel_order'] = 'LAS'
hdr['dim'] = dims
hdr['vox_to_ras'] = affine
strm = ((sl, None, None) for sl in streamlines)
trk_name = 'tractogram_' + par_b_tag + '_' + par_dim_tag + '_' + par_rec_tag + '_' + par_eudx_tag + '.trk'
trk_out = os.path.join(dir_out, trk_name)
nib.trackvis.write(trk_out, strm, hdr, points_space='voxel')
def uniform_seed_grid():
#read bvals,gradients and data
fimg,fbvals, fbvecs = get_data('small_64D')
bvals=np.load(fbvals)
gradients=np.load(fbvecs)
img =ni.load(fimg)
data=img.get_data()
x,y,z,g=data.shape
M=np.mgrid[.5:x-.5:np.complex(0,x),.5:y-.5:np.complex(0,y),.5:z-.5:np.complex(0,z)]
M=M.reshape(3,x*y*z).T
print(M.shape)
print(M.dtype)
for m in M:
print(m)
gqs = GeneralizedQSampling(data,bvals,gradients)
iT=iter(EuDX(gqs.QA,gqs.IN,seeds=M))
T=[]
for t in iT:
T.append(i)
print('lenT',len(T))
assert_equal(len(T), 1221)
def track_eudx_work(trackmodel):
ten = trackmodel.ten
ind = trackmodel.ind
sphere = trackmodel.sphere
eu = EuDX(a=ten.fa,
ind=ind,
seeds=10**5 * 5,
odf_vertices=sphere.vertices,
a_low=0.2)
tracks = [e for e in eu]
return tracks
def fiber_tracking(peaks, mask):
print "Start Fibertracking"
seeds = utils.seeds_from_mask(mask, density=[2, 2, 2])
streamline_generator = EuDX(peaks.peak_values,
peaks.peak_indices,
odf_vertices=peaks.sphere.vertices,
a_low=.05,
step_sz=.5,
seeds=seeds)
streamlines = list(streamline_generator)
return streamlines
def tractography(img, gtab, mask, dwi_dir, do_viz=True):
data = img.get_data()
# dirty imputation
data[np.isnan(data)] = 0
# Diffusion model
csd_model = ConstrainedSphericalDeconvModel(gtab, response=None)
sphere = get_sphere('symmetric724')
csd_peaks = peaks_from_model(model=csd_model,
data=data,
sphere=sphere,
mask=mask,
relative_peak_threshold=.5,
min_separation_angle=25,
parallel=False)
# FA values to stop the tractography
tensor_model = TensorModel(gtab, fit_method='WLS')
tensor_fit = tensor_model.fit(data, mask)
fa = fractional_anisotropy(tensor_fit.evals)
stopping_values = np.zeros(csd_peaks.peak_values.shape)
stopping_values[:] = fa[..., None]
# tractography
streamline_generator = EuDX(stopping_values,
csd_peaks.peak_indices,
seeds=10**6,
odf_vertices=sphere.vertices,
a_low=0.1)
streamlines = [streamline for streamline in streamline_generator]
streamlines = filter_according_to_length(streamlines)
np.savez(os.path.join(dwi_dir, 'streamlines.npz'), streamlines)
# write the result as images
hdr = nib.trackvis.empty_header()
hdr['voxel_size'] = img.header.get_zooms()[:3]
hdr['voxel_order'] = 'LAS'
hdr['dim'] = fa.shape[:3]
csd_streamlines_trk = ((sl, None, None) for sl in streamlines)
csd_sl_fname = os.path.join(dwi_dir, 'csd_streamline.trk')
nib.trackvis.write(csd_sl_fname,
csd_streamlines_trk,
hdr,
points_space='voxel')
fa_image = os.path.join(dwi_dir, 'fa_map.nii.gz')
nib.save(nib.Nifti1Image(fa, img.affine), fa_image)
if 1:
visualization(os.path.join(dwi_dir, 'streamlines.npz'))
return streamlines
def tracking_eudx4csd(dir_src, dir_out, verbose=False):
# Load data
fbval = pjoin(dir_src, 'bvals_' + par_b_tag)
fbvec = pjoin(dir_src, 'bvecs_' + par_b_tag)
fdwi = pjoin(dir_src, 'data_' + par_b_tag + '_' + par_dim_tag + '.nii.gz')
#fmask = pjoin(dir_src, 'nodif_brain_mask_' + par_dim_tag + '.nii.gz')
fmask = pjoin(dir_src,
'wm_mask_' + par_b_tag + '_' + par_dim_tag + '.nii.gz')
bvals, bvecs = read_bvals_bvecs(fbval, fbvec)
gtab = gradient_table(bvals, bvecs, b0_threshold=par_b0_threshold)
data, affine = load_nifti(fdwi, verbose)
mask, _ = load_nifti(fmask, verbose)
sphere = get_sphere('symmetric724')
response, ratio = auto_response(gtab,
data,
roi_radius=par_ar_radius,
fa_thr=par_ar_fa_th)
# print('Response function', response)
# Model fitting
csd_model = ConstrainedSphericalDeconvModel(gtab, response)
csd_peaks = peaks_from_model(csd_model,
data,
sphere,
relative_peak_threshold=.5,
min_separation_angle=25,
parallel=False)
# Computation of streamlines
streamlines = EuDX(csd_peaks.peak_values,
csd_peaks.peak_indices,
seeds=par_eudx_seeds,
odf_vertices=sphere.vertices,
a_low=par_eudx_threshold)
# Saving tractography
voxel_size = (par_dim_vox, ) * 3
dims = mask.shape[:3]
hdr = nib.trackvis.empty_header()
hdr['voxel_size'] = voxel_size
hdr['voxel_order'] = 'LAS'
hdr['dim'] = dims
hdr['vox_to_ras'] = affine
strm = ((sl, None, None) for sl in streamlines)
trk_name = 'tractogram_' + par_b_tag + '_' + par_dim_tag + '_' + par_csd_tag + '_' + par_eudx_tag + '.trk'
trk_out = os.path.join(dir_out, trk_name)
nib.trackvis.write(trk_out, strm, hdr, points_space='voxel')
def DTImaps(ImgPath, Bvalpath, Bvecpath, tracto=True):
data, affine = resli(ImgPath)
data = Nonlocal(data, affine)
b0_mask, mask = otsu(data, affine) #maask binary
evals, evecs = DTImodel(b0_mask, affine, mask, gtab(Bvalpath, Bvecpath))
print('--> Calculando el mapa de anisotropia fraccional')
FA = fractional_anisotropy(evals)
FA[np.isnan(FA)] = 0
nib.save(nib.Nifti1Image(FA.astype(np.float32), affine),
"Mapa_anisotropia_fraccional")
print('--> Calculando el mapa de anisotropia fraccional RGB')
FA2 = np.clip(FA, 0, 1)
RGB = color_fa(FA2, evecs)
nib.save(nib.Nifti1Image(np.array(255 * RGB, 'uint8'), affine),
"Mapa_anisotropia_fraccional RGB")
print('--> Calculando el mapa de difusividad media')
MD1 = dti.mean_diffusivity(evals)
nib.save(nib.Nifti1Image(MD1.astype(np.float32), affine),
"Mapa_difusividad_media")
if tracto:
sphere = get_sphere('symmetric724')
peak_indices = quantize_evecs(evecs, sphere.vertices)
eu = EuDX(FA.astype('f8'),
peak_indices,
seeds=500000,
odf_vertices=sphere.vertices,
a_low=0.15)
tensor_streamlines = [streamline for streamline in eu]
new_vox_sz = (2., 2., 2.)
hdr = nib.trackvis.empty_header()
hdr['voxel_size'] = new_vox_sz
hdr['voxel_order'] = 'LAS'
hdr['dim'] = FA.shape
tensor_streamlines_trk = ((sl, None, None)
for sl in tensor_streamlines)
ten_sl_fname = "Tracto.trk"
nib.trackvis.write(ten_sl_fname,
tensor_streamlines_trk,
hdr,
points_space='voxel')
return FA
def compute_tracking(src_dti_dir, out_trk_dir, subj_name):
# Loading FA and evecs data
src_fa_file = os.path.join(src_dti_dir, subj_name + par_fa_suffix)
fa_img = nib.load(src_fa_file)
FA = fa_img.get_data()
src_evecs_file = os.path.join(src_dti_dir, subj_name + par_evecs_suffix)
evecs_img = nib.load(src_evecs_file)
evecs = evecs_img.get_data()
# Computation of streamlines
sphere = get_sphere('symmetric724')
peak_indices = dti.quantize_evecs(evecs, sphere.vertices)
streamlines = EuDX(FA.astype('f8'),
ind=peak_indices,
seeds=par_eudx_seeds,
odf_vertices=sphere.vertices,
a_low=par_eudx_threshold)
# Saving tractography
voxel_size = fa_img.get_header().get_zooms()[:3]
dims = FA.shape[:3]
seed = par_eudx_seeds
seed = "_%d%s" % (seed / 10**6 if seed > 10**5 else seed / 10**3,
'K' if seed < 1000000 else 'M')
hdr = nib.trackvis.empty_header()
hdr['voxel_size'] = voxel_size
hdr['voxel_order'] = 'LAS'
hdr['dim'] = dims
strm = ((sl, None, None) for sl in streamlines
if length(sl) > par_trk_min and length(sl) < par_trk_max)
out_trk_file = os.path.join(out_trk_dir, subj_name + seed + par_trk_suffix)
nib.trackvis.write(out_trk_file, strm, hdr, points_space='voxel')
tracks = [track for track in streamlines]
out_dipy_file = os.path.join(out_trk_dir,
subj_name + seed + par_dipy_suffix)
dpw = Dpy(out_dipy_file, 'w')
dpw.write_tracks(tracks)
dpw.close()
def eudx_basic(self, dti_file, mask_file, gtab, stop_val=0.1):
"""
Tracking with basic tensors and basic eudx - experimental
We now force seeding at every voxel in the provided mask for
simplicity. Future functionality will extend these options.
**Positional Arguments:**
dti_file:
- File (registered) to use for tensor/fiber tracking
mask_file:
- Brain mask to keep tensors inside the brain
gtab:
- dipy formatted bval/bvec Structure
**Optional Arguments:**
stop_val:
- Value to cutoff fiber track
"""
img = nb.load(dti_file)
data = img.get_data()
img = nb.load(mask_file)
mask = img.get_data()
# use all points in mask
seedIdx = np.where(mask > 0) # seed everywhere not equal to zero
seedIdx = np.transpose(seedIdx)
model = TensorModel(gtab)
ten = model.fit(data, mask)
sphere = get_sphere('symmetric724')
ind = quantize_evecs(ten.evecs, sphere.vertices)
eu = EuDX(a=ten.fa,
ind=ind,
seeds=seedIdx,
odf_vertices=sphere.vertices,
a_low=stop_val)
tracks = [e for e in eu]
return (ten, tracks)
model that is a child of OdfModel.
"""
from reconst_csa import csapeaks, sphere
"""
This time we will not use FA as input to EuDX but we will use GFA (generalized FA),
which is more suited for ODF functions. Tracking will stop when GFA is less
than 0.2.
"""
from dipy.tracking.eudx import EuDX
eu = EuDX(csapeaks.gfa,
csapeaks.peak_indices[..., 0],
seeds=10000,
odf_vertices=sphere.vertices,
a_low=0.2)
csa_streamlines = [streamline for streamline in eu]
"""
Now that we have our streamlines in memory we can save the results on the disk.
For this purpose we can use the TrackVis format (``*.trk``). First, we need to
create a header.
"""
import nibabel as nib
hdr = nib.trackvis.empty_header()
hdr['voxel_size'] = (2., 2., 2.)
hdr['voxel_order'] = 'LAS'
def run_to_estimate_dti_maps(path_input,
path_output,
file_tensor_fitevals="",
file_tensor_fitevecs="",
fbval="",
fbvec=""):
folder = os.path.dirname(path_input)
if fbval == "" or fbvec == "":
folder_sujeto = path_output
for l in os.listdir(folder_sujeto):
if "TENSOR" in l and "bval" in l:
fbval = os.path.join(folder_sujeto, l)
if "TENSOR" in l and "bvec" in l:
fbvec = os.path.join(folder_sujeto, l)
if file_tensor_fitevals == "" or file_tensor_fitevecs == "":
for i in os.listdir(folder):
if "DTIEvals" in i:
file_tensor_fitevals = os.path.join(folder, i)
for i in os.listdir(folder):
if "DTIEvecs" in i:
file_tensor_fitevecs = os.path.join(folder, i)
if not os.path.exists(os.path.join(folder, "list_maps.txt")):
# def to_estimate_dti_maps(path_dwi_input, path_output, file_tensor_fitevecs, file_tensor_fitevals):
ref_name_only = utils.to_extract_filename(file_tensor_fitevecs)
ref_name_only = ref_name_only[:-9]
list_maps = []
img_tensorFitevecs = nib.load(file_tensor_fitevecs)
img_tensorFitevals = nib.load(file_tensor_fitevals)
evecs = img_tensorFitevecs.get_data()
evals = img_tensorFitevals.get_data()
affine = img_tensorFitevecs.affine
print(d.separador + d.separador + 'computing of FA map')
FA = fractional_anisotropy(evals)
FA[np.isnan(FA)] = 0
nib.save(
nib.Nifti1Image(FA.astype(np.float32), affine),
os.path.join(path_output, ref_name_only + '_FA' + d.extension))
list_maps.append(
os.path.join(path_output, ref_name_only + '_FA' + d.extension))
print(d.separador + d.separador + 'computing of Color FA map')
FA2 = np.clip(FA, 0, 1)
RGB = color_fa(FA2, evecs)
nib.save(
nib.Nifti1Image(np.array(255 * RGB, 'uint8'), affine),
os.path.join(path_output, ref_name_only + '_FA_RGB' + d.extension))
print(d.separador + d.separador + 'computing of MD map')
MD = dti.mean_diffusivity(evals)
nib.save(
nib.Nifti1Image(MD.astype(np.float32), affine),
os.path.join(path_output, ref_name_only + '_MD' + d.extension))
list_maps.append(
os.path.join(path_output, ref_name_only + '_MD' + d.extension))
print(d.separador + d.separador + 'computing of AD map')
AD = dti.axial_diffusivity(evals)
nib.save(
nib.Nifti1Image(AD.astype(np.float32), affine),
os.path.join(path_output, ref_name_only + '_AD' + d.extension))
list_maps.append(
os.path.join(path_output, ref_name_only + '_AD' + d.extension))
print(d.separador + d.separador + 'computing of RD map')
RD = dti.radial_diffusivity(evals)
nib.save(
nib.Nifti1Image(RD.astype(np.float32), affine),
os.path.join(path_output, ref_name_only + '_RD' + d.extension))
list_maps.append(
os.path.join(path_output, ref_name_only + '_RD' + d.extension))
sphere = get_sphere('symmetric724')
peak_indices = quantize_evecs(evecs, sphere.vertices)
eu = EuDX(FA.astype('f8'),
peak_indices,
seeds=300000,
odf_vertices=sphere.vertices,
a_low=0.15)
tensor_streamlines = [streamline for streamline in eu]
hdr = nib.trackvis.empty_header()
hdr['voxel_size'] = nib.load(path_input).header.get_zooms()[:3]
hdr['voxel_order'] = 'LAS'
hdr['dim'] = FA.shape
tensor_streamlines_trk = ((sl, None, None)
for sl in tensor_streamlines)
nib.trackvis.write(os.path.join(
path_output, ref_name_only + '_tractography_EuDx.trk'),
tensor_streamlines_trk,
hdr,
points_space='voxel')
print(list_maps)
with open(os.path.join(path_output, "list_maps.txt"), "w") as f:
for s in list_maps:
f.write(str(s) + "\n")
return path_input
def experiment1(f_name, data_path):
"OUTPUT"
f = open(f_name + '_out.txt', 'w')
"""""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """"""
"""Read Data"""
dipy_home = pjoin(os.path.expanduser('~'), '.dipy')
folder = pjoin(dipy_home, data_path)
fraw = pjoin(folder, f_name + '.nii.gz')
fbval = pjoin(folder, f_name + '.bval')
fbvec = pjoin(folder, f_name + '.bvec')
flabels = pjoin(folder, f_name + '.nii-label.nii.gz')
bvals, bvecs = read_bvals_bvecs(fbval, fbvec)
gtab = gradient_table(bvals, bvecs)
img = nib.load(fraw)
data = img.get_data()
print('data.shape (%d, %d, %d, %d)' % data.shape)
print('Building DTI Model Data......')
"""Load label"""
label_img = nib.load(flabels)
labels = label_img.get_data()
labelpo1 = label_position(labels, 1)
print labelpo1
"""""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """"""
maskdata, mask = median_otsu(data,
3,
1,
False,
vol_idx=range(10, 50),
dilate=2)
from dipy.reconst.dti import TensorModel
tenmodel = TensorModel(gtab)
tenfit = tenmodel.fit(data, mask)
FA = fractional_anisotropy(tenfit.evals)
FA[np.isnan(FA)] = 0
np.save(f_name + '_FA', FA)
fa_img = nib.Nifti1Image(FA.astype(np.float32), img.get_affine())
#nib.save(fa_img,f_name+'_DTI_tensor_fa.nii.gz')
#print('Saving "DTI_tensor_fa.nii.gz" sucessful.')
evecs_img = nib.Nifti1Image(tenfit.evecs.astype(np.float32),
img.get_affine())
#nib.save(evecs_img, f_name+'_DTI_tensor_evecs.nii.gz')
#print('Saving "DTI_tensor_evecs.nii.gz" sucessful.')
"""""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""" """""
""Fiber Tracking"""
print('Fiber Tracking......')
from dipy.tracking.eudx import EuDX
from dipy.data import get_sphere
from dipy.tracking import utils
seeds = utils.seeds_from_mask(labels, density=3)
print('The number of seeds is %d.' % len(seeds))
print >> f, ('The number of seeds is %d.' % len(seeds))
sphere = get_sphere('symmetric724')
from dipy.reconst.dti import quantize_evecs
evecs = evecs_img.get_data()
peak_indices = quantize_evecs(evecs, sphere.vertices)
"""""" """""" """""" """""" """""" """""" """""" """""" """""" """"""
streamline_generator = EuDX(FA.astype('f8'),
peak_indices,
seeds=10**5,
odf_vertices=sphere.vertices,
a_low=0.2,
step_sz=0.5,
ang_thr=60.0,
total_weight=.5,
max_points=10**5)
streamlines_all = [
streamlines_all for streamlines_all in streamline_generator
]
"""""" """""" """""" """""" """"""
"""Select length bigger than 10"""
from dipy.tracking.utils import length
lengths = list(length(streamlines_all))
select_length = 0
length = len(streamlines_all)
j = 0
for i in range(length):
if ((lengths[i]) > select_length):
streamlines_all[j] = streamlines_all[i]
j = j + 1
j = j - 1
streamlines = streamlines_all[0:j]
hdr = nib.trackvis.empty_header()
hdr['voxel_size'] = img.get_header().get_zooms()[:3]
hdr['voxel_order'] = 'LAS'
hdr['dim'] = FA.shape[:3]
"""划出roi streamlines"""
affine = streamline_generator.affine
cc_streamlines = label_streamlines(streamlines, labels, 1, affine, hdr,
f_name, data_path)
#M,grouping = connective_label(cc_streamlines, labels, affine, hdr, f_name, data_path)
label_streamlines_density(cc_streamlines, labels, affine, f_name, img,
label_img)
"""两个label的问题"""
flabels2 = pjoin(folder, f_name + '22.nii-label.nii.gz')
label_img2 = nib.load(flabels2)
labels2 = label_img2.get_data()
cc22_streamlines = label_streamlines(streamlines, labels2, 3, affine, hdr,
f_name, data_path)
labels3 = labels[:]
for i in range(len(labels)):
for j in range(len(labels[i])):
for k in range(len(labels[i][j])):
if (labels[i][j][k] == 0 and labels2[i][j][k] != 0):
labels3[i][j][k] = labels2[i][j][k]
M, grouping = connective_label(streamlines, labels3, affine, hdr, f_name,
data_path)
print M
print grouping[0, 3]
#experiment1('zhu long ping','patient_data')
csa_peaks = peaks_from_model(model=csa_model,
data=data,
sphere=default_sphere,
relative_peak_threshold=relative_peak_threshold,
min_separation_angle=min_separation_angle,
mask=mask)
#csd_peaks = peaks_from_model(model=csd_model,
# data=data,
# sphere=default_sphere,
# relative_peak_threshold=relative_peak_threshold,
# min_separation_angle=min_separation_angle,
# mask=mask)
streamline_eudx = EuDX(csa_peaks.peak_values, csa_peaks.peak_indices,
odf_vertices=default_sphere.vertices,
a_low=threshold_tissue_classifier, step_sz=step_size, seeds=seeds)
save(streamline_eudx, streamline_eudx.affine, mask.shape, '1.trk', lenght_threshold)
detmax_dg = DeterministicMaximumDirectionGetter.from_shcoeff(csa_peaks.shm_coeff, max_angle=max_angle, sphere=default_sphere)
tensor_model = dti.TensorModel(gtab)
dti_fit = tensor_model.fit(data, mask=mask)
FA = fractional_anisotropy(dti_fit.evals)
classifier = ThresholdTissueClassifier(FA, threshold_tissue_classifier)
streamlines_dmdg = LocalTracking(detmax_dg, classifier, seeds, affine, step_size=step_size)
save(streamlines_dmdg, streamline_eudx.affine, mask.shape, '1.trk', lenght_threshold)
classifier = ThresholdTissueClassifier(csa_peaks.gfa, threshold_tissue_classifier)
prob_dg = ProbabilisticDirectionGetter.from_shcoeff(csa_peaks.shm_coeff, max_angle=max_angle, sphere=default_sphere)
# Fit the data using created tensor model
tenfit = tenmodel.fit(data)
# Compute FA
fa = fractional_anisotropy(tenfit.evals)
# Compute spherical coordinates
sphere = get_sphere('symmetric724') # Symmetric Sphere with 724 vertices
# Get quantize vectors
ind = quantize_evecs(tenfit.evecs, sphere.vertices)
print('ind.shape (%d, %d, %d)' % ind.shape)
# Compute Eular Delta Crossing with FA
eu = EuDX(a=fa, ind=ind, seeds=100000, odf_vertices=sphere.vertices,
a_low=0.2) # FA uses a_low = 0.2
streamlines = [line for line in eu]
print('Number of streamlines %i' % len(streamlines))
'''
for line in streamlines:
print(line.shape)
'''
# Do steamline clustering using QuickBundles (QB) using Eular's Method
# dist_thr (distance threshold) which affects number of clusters and their size
# pts (number of points in each streamline) which will be used for downsampling before clustering
# Default values : dist_thr = 4 & pts = 12
qb = QuickBundles(streamlines, dist_thr=20, pts=20)
clusters = qb.clusters()
print('Number of clusters %i' % qb.total_clusters)
print('Cluster size', qb.clusters_sizes())
**Direction Field (peaks)**
``EuDX`` [Garyfallidis12]_ is a fast algorithm that we use here to generate
streamlines. If the parameter ``seeds`` is a positive integer it will generate
that number of randomly placed seeds everywhere in the volume. Alternatively,
you can specify the exact seed points using an array (N, 3) where N is the
number of seed points. For simplicity, here we will use the first option
(random seeds). ``a_low`` is the threshold of the fist parameter
(``stopping_values``) which means that there will that tracking will stop in
regions with FA < 0.1.
"""
streamline_generator = EuDX(stopping_values,
csd_peaks.peak_indices,
seeds=10**4,
odf_vertices=sphere.vertices,
a_low=0.1)
streamlines = [streamline for streamline in streamline_generator]
"""
We can visualize the streamlines using ``fvtk.line`` or ``fvtk.streamtube``.
"""
fvtk.clear(ren)
fvtk.add(ren, fvtk.line(streamlines, line_colors(streamlines)))
print('Saving illustration as csd_streamlines_eudx.png')
fvtk.record(ren, out_path='csd_streamlines_eudx.png', size=(900, 900))
def eudx_advanced(self,
dti_file,
mask_file,
gtab,
seed_num=100000,
stop_val=0.1):
"""
Tracking with more complex tensors - experimental
Initializes the graph with nodes corresponding to the number of ROIs
**Positional Arguments:**
dti_file:
- File (registered) to use for tensor/fiber tracking
mask_file:
- Brain mask to keep tensors inside the brain
gtab:
- dipy formatted bval/bvec Structure
**Optional Arguments:**
seed_num:
- Number of seeds to use for fiber tracking
stop_val:
- Value to cutoff fiber track
"""
img = nb.load(dti_file)
data = img.get_data()
img = nb.load(mask_file)
mask = img.get_data()
mask = mask > 0 # to ensure binary mask
"""
For the constrained spherical deconvolution we need to estimate the
response function (see :ref:`example_reconst_csd`) and create a model.
"""
response, ratio = auto_response(gtab, data, roi_radius=10, fa_thr=0.7)
csd_model = ConstrainedSphericalDeconvModel(gtab, response)
"""
Next, we use ``peaks_from_model`` to fit the data and calculated
the fiber directions in all voxels.
"""
sphere = get_sphere('symmetric724')
csd_peaks = peaks_from_model(model=csd_model,
data=data,
sphere=sphere,
mask=mask,
relative_peak_threshold=.5,
min_separation_angle=25,
parallel=True)
"""
For the tracking part, we will use ``csd_model`` fiber directions
but stop tracking where fractional anisotropy (FA) is low (< 0.1).
To derive the FA, used as a stopping criterion, we need to fit a
tensor model first. Here, we use weighted least squares (WLS).
"""
print 'tensors...'
tensor_model = TensorModel(gtab, fit_method='WLS')
tensor_fit = tensor_model.fit(data, mask)
FA = fractional_anisotropy(tensor_fit.evals)
"""
In order for the stopping values to be used with our tracking
algorithm we need to have the same dimensions as the
``csd_peaks.peak_values``. For this reason, we can assign the
same FA value to every peak direction in the same voxel in
the following way.
"""
stopping_values = np.zeros(csd_peaks.peak_values.shape)
stopping_values[:] = FA[..., None]
streamline_generator = EuDX(stopping_values,
csd_peaks.peak_indices,
seeds=seed_num,
odf_vertices=sphere.vertices,
a_low=stop_val)
streamlines = [streamline for streamline in streamline_generator]
return streamlines
def deterministic(diffusion_file,
bvecs_file,
bvals_file,
trackfile,
mask_file=None,
order=4,
nb_seeds_per_voxel=1,
step=0.5):
""" Compute a deterministic tractography using an ODF model.
Parameters
----------
diffusion_file: str (mandatory)
a file containing the preprocessed diffusion data.
bvecs_file: str (mandatory)
a file containing the diffusion gradient directions.
bvals_file: str (mandatory)
a file containing the diffusion b-values.
trackfile: str (mandatory)
a file path where the fibers will be saved in trackvis format.
mask_file: str (optional, default None)
an image used to mask the diffusion data during the tractography. If
not set, all the image voxels are considered.
order: int (optional, default 4)
the order of the ODF model.
nb_seeds_per_voxel: int (optional, default 1)
the number of seeds per voxel used during the propagation.
step: float (optional, default 0.5)
the integration step in voxel fraction used during the propagation.
Returns
-------
streamlines: tuple of 3-uplet
the computed fiber tracks in trackvis format (points: ndarray shape
(N,3) where N is the number of points, scalars: None or ndarray shape
(N, M) where M is the number of scalars per point, properties: None or
ndarray shape (P,) where P is the number of properties).
hdr: structured array
structured array with trackvis header fields (voxel size, voxel order,
dim).
"""
# Read diffusion sequence
bvals, bvecs = read_bvals_bvecs(bvals_file, bvecs_file)
gtab = gradient_table(bvals, bvecs)
diffusion_image = nibabel.load(diffusion_file)
diffusion_array = diffusion_image.get_data()
if mask_file is not None:
mask_array = nibabel.load(mask_file).get_data()
else:
mask_array = numpy.ones(diffusion_array.shape[:3], dtype=numpy.uint8)
# Estimate ODF model
csamodel = shm.CsaOdfModel(gtab, order)
csapeaks = peaks.peaks_from_model(model=csamodel,
data=diffusion_array,
sphere=peaks.default_sphere,
relative_peak_threshold=.8,
min_separation_angle=45,
mask=mask_array)
# Compute deterministic tractography in voxel space so affine is equal
# to identity
seeds = utils.seeds_from_mask(mask_array, density=nb_seeds_per_voxel)
streamline_generator = EuDX(csapeaks.peak_values,
csapeaks.peak_indices,
odf_vertices=peaks.default_sphere.vertices,
a_low=.05,
step_sz=step,
seeds=seeds)
# affine = streamline_generator.affine
# Save the tracks in trackvis format
hdr = nibabel.trackvis.empty_header()
hdr["voxel_size"] = diffusion_image.get_header().get_zooms()[:3]
hdr["voxel_order"] = "LAS"
hdr["dim"] = diffusion_array.shape[:3]
streamlines = [track for track in streamline_generator]
random.shuffle(streamlines)
streamlines = ((track, None, None) for track in streamlines)
nibabel.trackvis.write(trackfile, streamlines, hdr, points_space="voxel")
return streamlines, hdr
def dmri_recon(sid,
data_dir,
out_dir,
resolution,
recon='csd',
dirs='',
num_threads=2):
import tempfile
#tempfile.tempdir = '/om/scratch/Fri/ksitek/'
import os
oldval = None
if 'MKL_NUM_THREADS' in os.environ:
oldval = os.environ['MKL_NUM_THREADS']
os.environ['MKL_NUM_THREADS'] = '%d' % num_threads
ompoldval = None
if 'OMP_NUM_THREADS' in os.environ:
ompoldval = os.environ['OMP_NUM_THREADS']
os.environ['OMP_NUM_THREADS'] = '%d' % num_threads
import nibabel as nib
import numpy as np
from glob import glob
if resolution == '0.2mm':
filename = 'Reg_S64550_nii4d.nii'
#filename = 'angular_resample/dwi_%s.nii.gz'%dirs
fimg = os.path.abspath(glob(os.path.join(data_dir, filename))[0])
else:
filename = 'Reg_S64550_nii4d_resamp-%s.nii.gz' % (resolution)
fimg = os.path.abspath(
glob(os.path.join(data_dir, 'resample', filename))[0])
print("dwi file = %s" % fimg)
fbval = os.path.abspath(
glob(os.path.join(data_dir, 'bvecs', 'camino_120_RAS.bvals'))[0])
print("bval file = %s" % fbval)
fbvec = os.path.abspath(
glob(os.path.join(data_dir, 'bvecs',
'camino_120_RAS_flipped-xy.bvecs'))[0])
# 'angular_resample',
# 'dwi_%s.bvecs'%dirs))[0])
print("bvec file = %s" % fbvec)
img = nib.load(fimg)
data = img.get_fdata()
affine = img.get_affine()
prefix = sid
from dipy.io import read_bvals_bvecs
bvals, bvecs = read_bvals_bvecs(fbval, fbvec)
'''
from dipy.core.gradients import vector_norm
b0idx = []
for idx, val in enumerate(bvals):
if val < 1:
pass
#bvecs[idx] = [1, 0, 0]
else:
b0idx.append(idx)
#print "b0idx=%d"%idx
#print "input bvecs:"
#print bvecs
bvecs[b0idx, :] = bvecs[b0idx, :]/vector_norm(bvecs[b0idx])[:, None]
#print "bvecs after normalization:"
#print bvecs
'''
from dipy.core.gradients import gradient_table
gtab = gradient_table(bvals, bvecs)
gtab.bvecs.shape == bvecs.shape
gtab.bvecs
gtab.bvals.shape == bvals.shape
gtab.bvals
#from dipy.segment.mask import median_otsu
#b0_mask, mask = median_otsu(data[:, :, :, b0idx].mean(axis=3).squeeze(), 4, 4)
if resolution == '0.2mm':
mask_name = 'Reg_S64550_nii_b0-slice_mask.nii.gz'
fmask1 = os.path.join(data_dir, mask_name)
else:
mask_name = 'Reg_S64550_nii_b0-slice_mask_resamp-%s.nii.gz' % (
resolution)
fmask1 = os.path.join(data_dir, 'resample', mask_name)
print("fmask file = %s" % fmask1)
mask = nib.load(fmask1).get_fdata()
''' DTI model & save metrics '''
from dipy.reconst.dti import TensorModel
print("running tensor model")
tenmodel = TensorModel(gtab)
tenfit = tenmodel.fit(data, mask)
from dipy.reconst.dti import fractional_anisotropy
print("running FA")
FA = fractional_anisotropy(tenfit.evals)
FA[np.isnan(FA)] = 0
fa_img = nib.Nifti1Image(FA, img.get_affine())
tensor_fa_file = os.path.abspath('%s_tensor_fa.nii.gz' % (prefix))
nib.save(fa_img, tensor_fa_file)
from dipy.reconst.dti import axial_diffusivity
print("running AD")
AD = axial_diffusivity(tenfit.evals)
AD[np.isnan(AD)] = 0
ad_img = nib.Nifti1Image(AD, img.get_affine())
tensor_ad_file = os.path.abspath('%s_tensor_ad.nii.gz' % (prefix))
nib.save(ad_img, tensor_ad_file)
from dipy.reconst.dti import radial_diffusivity
print("running RD")
RD = radial_diffusivity(tenfit.evals)
RD[np.isnan(RD)] = 0
rd_img = nib.Nifti1Image(RD, img.get_affine())
tensor_rd_file = os.path.abspath('%s_tensor_rd.nii.gz' % (prefix))
nib.save(rd_img, tensor_rd_file)
from dipy.reconst.dti import mean_diffusivity
print("running MD")
MD = mean_diffusivity(tenfit.evals)
MD[np.isnan(MD)] = 0
md_img = nib.Nifti1Image(MD, img.get_affine())
tensor_md_file = os.path.abspath('%s_tensor_md.nii.gz' % (prefix))
nib.save(md_img, tensor_md_file)
evecs = tenfit.evecs
evec_img = nib.Nifti1Image(evecs, img.get_affine())
tensor_evec_file = os.path.abspath('%s_tensor_evec.nii.gz' % (prefix))
nib.save(evec_img, tensor_evec_file)
''' ODF model '''
useFA = True
print("creating %s model" % recon)
if recon == 'csd':
from dipy.reconst.csdeconv import ConstrainedSphericalDeconvModel
from dipy.reconst.csdeconv import auto_response
response, ratio = auto_response(gtab, data, roi_radius=10,
fa_thr=0.5) # 0.7
model = ConstrainedSphericalDeconvModel(gtab, response)
useFA = True
return_sh = True
elif recon == 'csa':
from dipy.reconst.shm import CsaOdfModel, normalize_data
model = CsaOdfModel(gtab, sh_order=8)
useFA = True
return_sh = True
elif recon == 'gqi':
from dipy.reconst.gqi import GeneralizedQSamplingModel
model = GeneralizedQSamplingModel(gtab)
return_sh = False
else:
raise ValueError('only csd, csa supported currently')
from dipy.reconst.dsi import (DiffusionSpectrumDeconvModel,
DiffusionSpectrumModel)
model = DiffusionSpectrumDeconvModel(gtab)
'''reconstruct ODFs'''
from dipy.data import get_sphere
sphere = get_sphere('symmetric724')
#odfs = fit.odf(sphere)
# with CSD/GQI, uses > 50GB per core; don't get greedy with cores!
from dipy.reconst.peaks import peaks_from_model
print("running peaks_from_model")
peaks = peaks_from_model(
model=model,
data=data,
sphere=sphere,
mask=mask,
return_sh=return_sh,
return_odf=False,
normalize_peaks=True,
npeaks=5,
relative_peak_threshold=.5,
min_separation_angle=10, #25,
parallel=num_threads > 1,
nbr_processes=num_threads)
# save the peaks
from dipy.io.peaks import save_peaks
peaks_file = os.path.abspath('%s_peaks.pam5' % (prefix))
save_peaks(peaks_file, peaks)
# save the spherical harmonics
shm_coeff_file = os.path.abspath('%s_shm_coeff.nii.gz' % (prefix))
if return_sh:
shm_coeff = peaks.shm_coeff
nib.save(nib.Nifti1Image(shm_coeff, img.get_affine()), shm_coeff_file)
else:
# if it's not a spherical model, output it as an essentially null file
np.savetxt(shm_coeff_file, [0])
# save the generalized fractional anisotropy image
gfa_img = nib.Nifti1Image(peaks.gfa, img.get_affine())
model_gfa_file = os.path.abspath('%s_%s_gfa.nii.gz' % (prefix, recon))
nib.save(gfa_img, model_gfa_file)
#from dipy.reconst.dti import quantize_evecs
#peak_indices = quantize_evecs(tenfit.evecs, sphere.vertices)
#eu = EuDX(FA, peak_indices, odf_vertices = sphere.vertices,
#a_low=0.2, seeds=10**6, ang_thr=35)
''' probabilistic tracking '''
'''
from dipy.direction import ProbabilisticDirectionGetter
from dipy.tracking.local import LocalTracking
from dipy.tracking.streamline import Streamlines
from dipy.io.streamline import save_trk
prob_dg = ProbabilisticDirectionGetter.from_shcoeff(shm_coeff,
max_angle=45.,
sphere=sphere)
streamlines_generator = LocalTracking(prob_dg,
affine,
step_size=.5,
max_cross=1)
# Generate streamlines object
streamlines = Streamlines(streamlines_generator)
affine = img.get_affine()
vox_size=fa_img.get_header().get_zooms()[:3]
fname = os.path.abspath('%s_%s_prob_streamline.trk' % (prefix, recon))
save_trk(fname, streamlines, affine, vox_size=vox_size)
'''
''' deterministic tracking with EuDX method'''
from dipy.tracking.eudx import EuDX
print("reconstructing with EuDX")
if useFA:
eu = EuDX(
FA,
peaks.peak_indices[..., 0],
odf_vertices=sphere.vertices,
a_low=0.001, # default is 0.0239
seeds=10**6,
ang_thr=75)
else:
eu = EuDX(
peaks.gfa,
peaks.peak_indices[..., 0],
odf_vertices=sphere.vertices,
#a_low=0.1,
seeds=10**6,
ang_thr=45)
sl_fname = os.path.abspath('%s_%s_det_streamline.trk' % (prefix, recon))
# trying new dipy.io.streamline module, per email to neuroimaging list
# 2018.04.05
from nibabel.streamlines import Field
from nibabel.orientations import aff2axcodes
affine = img.get_affine()
vox_size = fa_img.get_header().get_zooms()[:3]
fov_shape = FA.shape[:3]
if vox_size is not None and fov_shape is not None:
hdr = {}
hdr[Field.VOXEL_TO_RASMM] = affine.copy()
hdr[Field.VOXEL_SIZES] = vox_size
hdr[Field.DIMENSIONS] = fov_shape
hdr[Field.VOXEL_ORDER] = "".join(aff2axcodes(affine))
tractogram = nib.streamlines.Tractogram(eu)
tractogram.affine_to_rasmm = affine
trk_file = nib.streamlines.TrkFile(tractogram, header=hdr)
nib.streamlines.save(trk_file, sl_fname)
if oldval:
os.environ['MKL_NUM_THREADS'] = oldval
else:
del os.environ['MKL_NUM_THREADS']
if ompoldval:
os.environ['OMP_NUM_THREADS'] = ompoldval
else:
del os.environ['OMP_NUM_THREADS']
print('all output files created')
return (tensor_fa_file, tensor_evec_file, model_gfa_file, sl_fname, affine,
tensor_ad_file, tensor_rd_file, tensor_md_file, shm_coeff_file,
peaks_file)
sphere=peaks.default_sphere,
relative_peak_threshold=.8,
min_separation_angle=45,
mask=white_matter)
"""
Now we can use EuDX to track all of the white matter. To keep things reasonably
fast we use ``density=2`` which will result in 8 seeds per voxel. We'll set
``a_low`` (the parameter which determines the threshold of FA/QA under which
tracking stops) to be very low because we've already applied a white matter
mask.
"""
seeds = utils.seeds_from_mask(white_matter, density=2)
streamline_generator = EuDX(csapeaks.peak_values,
csapeaks.peak_indices,
odf_vertices=peaks.default_sphere.vertices,
a_low=.05,
step_sz=.5,
seeds=seeds)
affine = streamline_generator.affine
streamlines = list(streamline_generator)
"""
The first of the tracking utilities we'll cover here is ``target``. This
function takes a set of streamlines and a region of interest (ROI) and returns
only those streamlines that pass though the ROI. The ROI should be an array
such that the voxels that belong to the ROI are ``True`` and all other voxels
are ``False`` (this type of binary array is sometimes called a mask). This
function can also exclude all the streamlines that pass though an ROI by
setting the ``include`` flag to ``False``. In this example we'll target the
streamlines of the corpus callosum. Our ``labels`` array has a sagittal slice
of the corpus callosum identified by the label value 2. We'll create an ROI
mask from that label and create two sets of streamlines, those that intersect
def deterministic(diffusion_file,
bvecs_file,
bvals_file,
outdir,
mask_file=None,
order=4,
nb_seeds_per_voxel=1,
step=0.5,
fmt="%.4f"):
""" Compute a deterministic tractography using an ODF model.
Parameters
----------
diffusion_file: str (mandatory)
a file containing the preprocessed diffusion data.
bvecs_file: str (mandatory)
a file containing the diffusion gradient directions.
bvals_file: str (mandatory)
a file containing the diffusion b-values.
outdir: str (mandatory)
the output directory.
mask_file: str (optional, default None)
an image used to mask the diffusion data during the tractography. If
not set, all the image voxels are considered.
order: int (optional, default 4)
the order of the ODF model.
nb_seeds_per_voxel: int (optional, default 1)
the number of seeds per voxel used during the propagation.
step: float (optional, default 0.5)
the integration step in voxel fraction used during the propagation.
fmt: str (optional, default '%.4f')
the saved track elements format.
Returns
-------
track_file: str
a determinist model of the white matter organization.
"""
# Read diffusion sequence
bvals, bvecs = read_bvals_bvecs(bvals_file, bvecs_file)
gtab = gradient_table(bvals, bvecs)
diffusion_array = nibabel.load(diffusion_file).get_data()
if mask_file is not None:
mask_array = nibabel.load(mask_file).get_data()
else:
mask_array = numpy.ones(diffusion_array.shape[:3], dtype=numpy.uint8)
# Estimate ODF model
csamodel = shm.CsaOdfModel(gtab, order)
csapeaks = peaks.peaks_from_model(model=csamodel,
data=diffusion_array,
sphere=peaks.default_sphere,
relative_peak_threshold=.8,
min_separation_angle=45,
mask=mask_array)
# Compute deterministic tractography in voxel space so affine is equal
# to identity
seeds = utils.seeds_from_mask(mask_array, density=nb_seeds_per_voxel)
streamline_generator = EuDX(csapeaks.peak_values,
csapeaks.peak_indices,
odf_vertices=peaks.default_sphere.vertices,
a_low=.05,
step_sz=step,
seeds=seeds)
affine = streamline_generator.affine
streamlines = list(streamline_generator)
# Save the tracks
track_file = os.path.join(outdir, "fibers.txt")
savetxt(track_file, streamlines, fmt=fmt)
return track_file
def _run_interface(self, runtime):
from dipy.reconst.peaks import peaks_from_model
from dipy.tracking.eudx import EuDX
from dipy.data import get_sphere
# import marshal as pickle
import pickle as pickle
import gzip
if (not (isdefined(self.inputs.in_model)
or isdefined(self.inputs.in_peaks))):
raise RuntimeError(('At least one of in_model or in_peaks should '
'be supplied'))
img = nb.load(self.inputs.in_file)
imref = nb.four_to_three(img)[0]
affine = img.affine
data = img.get_data().astype(np.float32)
hdr = imref.header.copy()
hdr.set_data_dtype(np.float32)
hdr['data_type'] = 16
sphere = get_sphere('symmetric724')
self._save_peaks = False
if isdefined(self.inputs.in_peaks):
IFLOGGER.info('Peaks file found, skipping ODF peaks search...')
f = gzip.open(self.inputs.in_peaks, 'rb')
peaks = pickle.load(f)
f.close()
else:
self._save_peaks = True
IFLOGGER.info('Loading model and computing ODF peaks')
f = gzip.open(self.inputs.in_model, 'rb')
odf_model = pickle.load(f)
f.close()
peaks = peaks_from_model(
model=odf_model,
data=data,
sphere=sphere,
relative_peak_threshold=self.inputs.peak_threshold,
min_separation_angle=self.inputs.min_angle,
parallel=self.inputs.multiprocess)
f = gzip.open(self._gen_filename('peaks', ext='.pklz'), 'wb')
pickle.dump(peaks, f, -1)
f.close()
hdr.set_data_shape(peaks.gfa.shape)
nb.Nifti1Image(peaks.gfa.astype(np.float32), affine,
hdr).to_filename(self._gen_filename('gfa'))
IFLOGGER.info('Performing tractography')
if isdefined(self.inputs.tracking_mask):
msk = nb.load(self.inputs.tracking_mask).get_data()
msk[msk > 0] = 1
msk[msk < 0] = 0
else:
msk = np.ones(imref.shape)
gfa = peaks.gfa * msk
seeds = self.inputs.num_seeds
if isdefined(self.inputs.seed_coord):
seeds = np.loadtxt(self.inputs.seed_coord)
elif isdefined(self.inputs.seed_mask):
seedmsk = nb.load(self.inputs.seed_mask).get_data()
assert (seedmsk.shape == data.shape[:3])
seedmsk[seedmsk > 0] = 1
seedmsk[seedmsk < 1] = 0
seedps = np.array(np.where(seedmsk == 1), dtype=np.float32).T
vseeds = seedps.shape[0]
nsperv = (seeds // vseeds) + 1
IFLOGGER.info(
'Seed mask is provided (%d voxels inside '
'mask), computing seeds (%d seeds/voxel).', vseeds, nsperv)
if nsperv > 1:
IFLOGGER.info('Needed %d seeds per selected voxel (total %d).',
nsperv, vseeds)
seedps = np.vstack(np.array([seedps] * nsperv))
voxcoord = seedps + np.random.uniform(-1, 1, size=seedps.shape)
nseeds = voxcoord.shape[0]
seeds = affine.dot(
np.vstack((voxcoord.T, np.ones((1, nseeds)))))[:3, :].T
if self.inputs.save_seeds:
np.savetxt(self._gen_filename('seeds', ext='.txt'), seeds)
if isdefined(self.inputs.tracking_mask):
tmask = msk
a_low = 0.1
else:
tmask = gfa
a_low = self.inputs.gfa_thresh
eu = EuDX(tmask,
peaks.peak_indices[..., 0],
seeds=seeds,
affine=affine,
odf_vertices=sphere.vertices,
a_low=a_low)
ss_mm = [np.array(s) for s in eu]
trkfilev = nb.trackvis.TrackvisFile([(s, None, None) for s in ss_mm],
points_space='rasmm',
affine=np.eye(4))
trkfilev.to_file(self._gen_filename('tracked', ext='.trk'))
return runtime
fa = fractional_anisotropy(ten_fit.evals)
cfa = color_fa(fa, ten_fit.evecs)
csamodel = CsaOdfModel(gtab, 6)
sphere = get_sphere('symmetric724')
pmd = peaks_from_model(model=csamodel,
data=data,
sphere=sphere,
relative_peak_threshold=.5,
min_separation_angle=25,
mask=mask,
return_odf=False)
#Deterministic tractography
eu = EuDX(a=fa,
ind=pmd.peak_indices[..., 0],
seeds=2000000,
odf_vertices=sphere.vertices,
a_low=0.2)
affine = eu.affine
csd_streamlines = list(eu)
#Remove tracts shorter than 30mm
#print np.shape(csd_streamlines)
from dipy.tracking.utils import length
csd_streamlines = [t for t in csd_streamlines if length(t) > 30]
#Trackvis
hdr = nib.trackvis.empty_header()
hdr['voxel_size'] = img.get_header().get_zooms()[:3]
hdr['voxel_order'] = 'LAS'
hdr['dim'] = fa.shape
from dipy.reconst.dti import quantize_evecs
peak_indices = quantize_evecs(evecs, sphere.vertices)
"""
EuDX is the fiber tracking algorithm that we use in this example.
The most important parameters are the first one which represents the
magnitude of the peak of a scalar anisotropic function, the
second which represents the indices of the discretized directions of
the peaks and odf_vertices are the vertices of the input sphere.
"""
from dipy.tracking.eudx import EuDX
eu = EuDX(FA.astype('f8'),
peak_indices,
seeds=50000,
odf_vertices=sphere.vertices,
a_low=0.2)
tensor_streamlines = [streamline for streamline in eu]
"""
We can now save the results in the disk. For this purpose we can use the
TrackVis format (``*.trk``). First, we need to create a header.
"""
hdr = nib.trackvis.empty_header()
hdr['voxel_size'] = fa_img.header.get_zooms()[:3]
hdr['voxel_order'] = 'LAS'
hdr['dim'] = FA.shape
"""
Then we need to input the streamlines in the way that Trackvis format expects them.
et3 = time.time() - st3
print 'seeding transformation finished, the total seeds are {}, running time is {}'.format(
seeds.shape[0], et3)
print 'generating streamlines begins'
st4 = time.time()
del data, img, labels, labels_img
gc.collect()
print 'data, img, labels, labels_img elete to save memory'
streamline_generator = EuDX(csapeaks1.peak_values,
csapeaks1.peak_indices,
odf_vertices=peaks.default_sphere.vertices,
a_low=.05,
step_sz=.5,
seeds=seeds,
ang_thr=70.0,
length_thr=0.0,
total_weight=0.5,
max_points=1000,
affine=None)
affine = streamline_generator.affine
streamlines = Streamlines(streamline_generator)
et4 = time.time() - st4
lengths = [length(sl).astype(np.int) for sl in streamlines]
print 'generating streamlines finished, the length is {}~{}, running time is {}'.format(
np.min(lengths), np.max(lengths), et4)
del bm, mask, lengths
gc.collect()