def test_eudx():
# 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()
print(data.shape)
gqs = GeneralizedQSampling(data, bvals, gradients)
ten = Tensor(data, bvals, gradients, thresh=50)
seed_list = np.dot(np.diag(np.arange(10)), np.ones((10, 3)))
iT = iter(EuDX(gqs.qa(), gqs.ind(), seeds=seed_list))
T = []
for t in iT:
T.append(t)
iT2 = iter(EuDX(ten.fa(), ten.ind(), seeds=seed_list))
T2 = []
for t in iT2:
T2.append(t)
print("length T ", sum([length(t) for t in T]))
print("length T2", sum([length(t) for t in T2]))
print(gqs.QA[1, 4, 8, 0])
print(gqs.QA.ravel()[ndarray_offset(np.array([1, 4, 8, 0]), np.array(gqs.QA.strides), 4, 8)])
assert_almost_equal(
gqs.QA[1, 4, 8, 0], gqs.QA.ravel()[ndarray_offset(np.array([1, 4, 8, 0]), np.array(gqs.QA.strides), 4, 8)]
)
assert_almost_equal(sum([length(t) for t in T]), 70.999996185302734, places=3)
assert_almost_equal(sum([length(t) for t in T2]), 56.999997615814209, places=3)
def test_eudx():
#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()
print(data.shape)
gqs = GeneralizedQSampling(data,bvals,gradients)
ten = Tensor(data,bvals,gradients,thresh=50)
seed_list=np.dot(np.diag(np.arange(10)),np.ones((10,3)))
iT=iter(EuDX(gqs.qa(),gqs.ind(),seed_list=seed_list))
T=[]
for t in iT:
T.append(t)
iT2=iter(EuDX(ten.fa(),ten.ind(),seed_list=seed_list))
T2=[]
for t in iT2:
T2.append(t)
print('length T ',sum([length(t) for t in T]))
print('length T2',sum([length(t) for t in T2]))
print(gqs.QA[1,4,8,0])
print(gqs.QA.ravel()[ndarray_offset(np.array([1,4,8,0]),np.array(gqs.QA.strides),4,8)])
assert_equal(gqs.QA[1,4,8,0], gqs.QA.ravel()[ndarray_offset(np.array([1,4,8,0]),np.array(gqs.QA.strides),4,8)])
#assert_equal, sum([length(t) for t in T ]) , 77.999996662139893
#assert_equal, sum([length(t) for t in T2]) , 63.499998092651367
assert_equal(sum([length(t) for t in T ]) , 75.214988201856613)
assert_equal(sum([length(t) for t in T2]) , 60.202986091375351)
def load_data(id, limits=[0, np.Inf]):
ids = ["02", "03", "04", "05", "06", "08", "09", "10", "11", "12"]
filename = "data/subj_" + ids[id] + "_lsc_QA_ref.dpy"
dp = Dpy(filename, "r")
print "Loading", filename
tracks = dp.read_tracks()
dp.close()
tracks = [t for t in tracks if length(t) >= limits[0] and length(t) <= limits[1]]
return tracks
def filtered_streamlines_by_length(self,
minimum=Config.get_config()
.getfloat("tracking", "minimumStreamlineLength",
fallback="20"),
maximum=Config.get_config()
.getfloat("tracking", "maximumStreamlineLength",
fallback="200")):
"""
removes streamlines that are shorter than minimumLength (in mm)
"""
return [x for x in self.streamlines if metrics.length(x) > minimum
and metrics.length(x) < maximum]
def load_cst(tracks_filename, cst_index_file, ext):
from dipy.io.dpy import Dpy
from dipy.io.pickles import load_pickle
dpr_tracks = Dpy(tracks_filename, 'r')
all_tracks=dpr_tracks.read_tracks()
dpr_tracks.close()
tracks_id = load_pickle(cst_index_file)
cst = [all_tracks[i] for i in tracks_id]
cst_ext = [all_tracks[i] for i in tracks_id]
medoid_cst = []
#len_dis = 250
if ext:
k = np.round(len(cst)*1.2)
not_cst_fil = []
min_len = min(len(i) for i in cst)
#print 'min_len of cst', min_len
min_len = min_len*2.2/3#2./3.2# - 20
for i in np.arange(len(all_tracks)):
if (i not in tracks_id) and (length(all_tracks[i]) > min_len):
not_cst_fil.append(all_tracks[i])
#for st in all_tracks:
# if (length(st)>=min_len) and (st not in cst):
# not_cst_fil.append(st)
from dipy.segment.quickbundles import QuickBundles
qb = QuickBundles(cst,200,18)
medoid_cst = qb.centroids[0]
med_notcst_dm = bundles_distances_mam([medoid_cst], not_cst_fil)
med_cst_dm = bundles_distances_mam([medoid_cst], cst)
cst_rad = med_cst_dm[0][np.argmax(med_cst_dm[0])]
len_dis = cst_rad * 2.8/2.
#print med_cst_dm
#print cst_rad
#print len_dis
#k_indices which close to the medoid
sort = np.argsort(med_notcst_dm,axis = 1)[0]
#print sort[:k+1]
while (k>0 and med_notcst_dm[0][sort[k]]>=len_dis):
k = k - 1
#print med_notcst_dm[0][sort[0:k]]
#print k
#close_indices = np.argsort(cst_dm,axis = 1)[:,0:k][0]
close_indices = sort[0:k]
for idx in close_indices:
cst_ext.append(not_cst_fil[idx])
return cst, cst_ext, medoid_cst
return cst
def DIPY_nii2streamlines(imgfile, maskfile, bvals, bvecs, output_prefix):
import numpy as np
import nibabel as nib
import os
from dipy.reconst.dti import TensorModel
print "nii2streamlines"
img = nib.load(imgfile)
bvals = np.genfromtxt(bvals)
bvecs = np.genfromtxt(bvecs)
if bvecs.shape[1] != 3:
bvecs = bvecs.T
print bvecs.shape
from nipype.utils.filemanip import split_filename
_, prefix, _ = split_filename(imgfile)
from dipy.data import gradient_table
gtab = gradient_table(bvals, bvecs)
data = img.get_data()
affine = img.get_affine()
zooms = img.get_header().get_zooms()[:3]
new_zooms = (2., 2., 2.)
data2, affine2 = data, affine
mask = nib.load(maskfile).get_data().astype(np.bool)
tenmodel = TensorModel(gtab)
tenfit = tenmodel.fit(data2, mask)
from dipy.reconst.dti import fractional_anisotropy
FA = fractional_anisotropy(tenfit.evals)
FA[np.isnan(FA)] = 0
fa_img = nib.Nifti1Image(FA, img.get_affine())
nib.save(fa_img, experiment_dir + '/' + ('%s_tensor_fa.nii.gz' % prefix))
evecs = tenfit.evecs
evec_img = nib.Nifti1Image(evecs, img.get_affine())
nib.save(evec_img, experiment_dir + '/' + ('%s_tensor_evec.nii.gz' % prefix))
from dipy.data import get_sphere
sphere = get_sphere('symmetric724')
from dipy.reconst.dti import quantize_evecs
peak_indices = quantize_evecs(tenfit.evecs, sphere.vertices)
from dipy.tracking.eudx import EuDX
eu = EuDX(FA, peak_indices, odf_vertices = sphere.vertices, a_low=0.2, seeds=10**6, ang_thr=35)
tensor_streamlines = [streamline for streamline in eu]
hdr = nib.trackvis.empty_header()
hdr['voxel_size'] = new_zooms
hdr['voxel_order'] = 'LPS'
hdr['dim'] = data2.shape[:3]
import dipy.tracking.metrics as dmetrics
tensor_streamlines = ((sl, None, None) for sl in tensor_streamlines if dmetrics.length(sl) > 15)
ten_sl_fname = experiment_dir + '/' + ('%s_streamline.trk' % prefix)
nib.trackvis.write(ten_sl_fname, tensor_streamlines, hdr, points_space='voxel')
return ten_sl_fname
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()
affine = fa_img.get_affine()
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
hdr['vox_to_ras'] = affine
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 loading_full_tractograpy(self, tracpath=None):
"""
Loading full tractography and creates StreamlineLabeler to
show it all.
"""
# load the tracks registered in MNI space
self.tracpath=tracpath
basename = os.path.basename(self.tracpath)
tracks_basename, tracks_format = os.path.splitext(basename)
if tracks_format == '.dpy':
dpr = Dpy(self.tracpath, 'r')
print "Loading", self.tracpath
self.T = dpr.read_tracks()
dpr.close()
self.T = np.array(self.T, dtype=np.object)
elif tracks_format == '.trk':
streams, self.hdr = nib.trackvis.read(self.tracpath, points_space='voxel')
print "Loading", self.tracpath
self.T = np.array([s[0] for s in streams], dtype=np.object)
print "Removing short streamlines"
self.T = np.array([t for t in self.T if length(t)>= 15], dtype=np.object)
tracks_directoryname = os.path.dirname(self.tracpath) + '/.temp/'
general_info_filename = tracks_directoryname + tracks_basename + '.spa'
# Check if there is the .spa file that contains all the
# computed information from the tractography anyway and try to
# load it
try:
print "Looking for general information file"
self.load_info(general_info_filename)
except (IOError, KeyError):
print "General information not found, recomputing buffers"
self.update_info(general_info_filename)
# create the interaction system for tracks,
self.streamlab = StreamlineLabeler('Bundle Picker',
self.buffers, self.clusters,
vol_shape=self.dims,
affine=np.copy(self.affine),
clustering_parameter=len(self.clusters),
clustering_parameter_max=len(self.clusters),
full_dissimilarity_matrix=self.full_dissimilarity_matrix)
self.scene.add_actor(self.streamlab)
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 loading_full_tractograpy(self, tracpath=None):
"""
Loading full tractography and creates StreamlineLabeler to
show it all.
"""
# load the tracks registered in MNI space
self.tracpath = tracpath
basename = os.path.basename(self.tracpath)
tracks_basename, tracks_format = os.path.splitext(basename)
if tracks_format == '.dpy':
dpr = Dpy(self.tracpath, 'r')
print "Loading", self.tracpath
self.T = dpr.read_tracks()
dpr.close()
self.T = np.array(self.T, dtype=np.object)
elif tracks_format == '.trk':
streams, self.hdr = nib.trackvis.read(self.tracpath,
points_space='voxel')
print "Loading", self.tracpath
self.T = np.array([s[0] for s in streams], dtype=np.object)
print "Removing short streamlines"
self.T = np.array([t for t in self.T if length(t) >= 15],
dtype=np.object)
tracks_directoryname = os.path.dirname(self.tracpath) + '/.temp/'
general_info_filename = tracks_directoryname + tracks_basename + '.spa'
# Check if there is the .spa file that contains all the
# computed information from the tractography anyway and try to
# load it
try:
print "Looking for general information file"
self.load_info(general_info_filename)
except (IOError, KeyError):
print "General information not found, recomputing buffers"
self.update_info(general_info_filename)
# create the interaction system for tracks,
self.streamlab = StreamlineLabeler(
'Bundle Picker',
self.buffers,
self.clusters,
vol_shape=self.dims,
affine=np.copy(self.affine),
clustering_parameter=len(self.clusters),
clustering_parameter_max=len(self.clusters),
full_dissimilarity_matrix=self.full_dissimilarity_matrix)
self.scene.add_actor(self.streamlab)
def test_eudx():
#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()
print(data.shape)
gqs = GeneralizedQSampling(data, bvals, gradients)
ten = Tensor(data, bvals, gradients, thresh=50)
seed_list = np.dot(np.diag(np.arange(10)), np.ones((10, 3)))
iT = iter(EuDX(gqs.qa(), gqs.ind(), seeds=seed_list))
T = []
for t in iT:
T.append(t)
iT2 = iter(EuDX(ten.fa(), ten.ind(), seeds=seed_list))
T2 = []
for t in iT2:
T2.append(t)
print('length T ', sum([length(t) for t in T]))
print('length T2', sum([length(t) for t in T2]))
print(gqs.QA[1, 4, 8, 0])
print(gqs.QA.ravel()[ndarray_offset(np.array([1, 4, 8, 0]),
np.array(gqs.QA.strides), 4, 8)])
assert_almost_equal(
gqs.QA[1, 4, 8, 0],
gqs.QA.ravel()[ndarray_offset(np.array([1, 4, 8, 0]),
np.array(gqs.QA.strides), 4, 8)])
assert_almost_equal(sum([length(t) for t in T]),
70.999996185302734,
places=3)
assert_almost_equal(sum([length(t) for t in T2]),
56.999997615814209,
places=3)
def filter_streamlines_by_length(streamlines,
data_per_point,
data_per_streamline,
min_length=0.,
max_length=np.inf):
"""
Filter streamlines using minimum and max length
Parameters
----------
streamlines: list
List of list of 3D points.
data_per_point: dict
dict of data with one value per point per streamline
data_per_streamline: dict
dict of data with one value per streamline
min_length: float
Minimum length of streamlines.
max_length: float
Maximum length of streamlines.
Return
------
filtered_streamlines: list
List of filtered streamlines by length.
filtered_data_per_point: dict
dict of data per point for filtered streamlines
filtered_data_per_streamline: dict
dict of data per streamline for filtered streamlines
"""
lengths = []
for streamline in streamlines:
lengths.append(length(streamline))
lengths = np.asarray(lengths)
filter_stream = np.logical_and(lengths >= min_length,
lengths <= max_length)
filtered_streamlines = list(np.asarray(streamlines)[filter_stream])
filtered_data_per_point = data_per_point[filter_stream]
filtered_data_per_streamline = data_per_streamline[filter_stream]
return filtered_streamlines, filtered_data_per_point, filtered_data_per_streamline
def iterate_on_sampler_and_verify(batch_sampler, batch_size, batch_size_units):
# Default variables
nb_subjs = len(TEST_EXPECTED_SUBJ_NAMES)
logging.debug(' Iterating on the batch sampler directly, without '
'actually loading the batch.')
batch_generator = batch_sampler.__iter__()
# Init to avoid "batch referenced before assignment" in case generator
# fails
# Loop on batches
for batch_idx in batch_generator:
subj0 = batch_idx[0]
(subj0_id, subj0_streamlines_idx) = subj0
nb_streamlines_sampled = len(subj0_streamlines_idx)
if batch_size_units == 'nb_streamlines':
logging.debug(
' Based on first subject, nb sampled streamlines per subj '
'was {} \n'
' (Batch size should be {} streamlines, result should be '
'batch_size / nb_subjs ({}) = {})\n'.format(
nb_streamlines_sampled, batch_size, nb_subjs,
batch_size / nb_subjs))
assert nb_streamlines_sampled == batch_size / nb_subjs
else:
subj0 = batch_sampler.dataset.subjs_data_list[0]
sub0_sft = subj0.sft_data_list[0].as_sft(subj0_streamlines_idx)
sub0_sft.to_rasmm()
lengths = [length(s) for s in sub0_sft.streamlines]
computed_size = sum(lengths)
logging.debug(
' Based on first subject, nb sampled streamlines per subj '
'was {} for a total size of {}\n'
' (Batch size should be {} in terms of length in mm, '
'result should be batch_size / nb_subjs ({}) = {})\n'.format(
nb_streamlines_sampled, computed_size, batch_size,
nb_subjs, batch_size / nb_subjs))
allowed_error = 200 # Usually, biggest streamline length is 200mm
assert batch_size - computed_size < allowed_error
break
def filtered_streamlines_by_length(streamlines: List,
minimum=20,
maximum=200) -> List:
"""
Returns filtered streamlines that are longer than minimum (in mm) and shorter than maximum (in mm)
Parameters
----------
streamlines
The streamlines we would like to filter
minimum
The minimum length in mm
maximum
The maximum length in mm
Returns
-------
List
The filtered streamlines
"""
return [x for x in streamlines if minimum <= metrics.length(x) <= maximum]
def test_length():
# Generate a simulated bundle of fibers:
n_streamlines = 50
n_pts = 100
t = np.linspace(-10, 10, n_pts)
bundle = []
for i in np.linspace(3, 5, n_streamlines):
pts = np.vstack((np.cos(2 * t/np.pi), np.zeros(t.shape) + i, t)).T
bundle.append(pts)
start = np.random.randint(10, 30, n_streamlines)
end = np.random.randint(60, 100, n_streamlines)
bundle = [10 * streamline[start[i]:end[i]] for (i, streamline) in
enumerate(bundle)]
bundle_lengths = length(bundle)
for idx, this_length in enumerate(bundle_lengths):
assert_equal(this_length, metrix.length(bundle[idx]))
def test_length():
# Generate a simulated bundle of fibers:
n_streamlines = 50
n_pts = 100
t = np.linspace(-10, 10, n_pts)
bundle = []
for i in np.linspace(3, 5, n_streamlines):
pts = np.vstack((np.cos(2 * t / np.pi), np.zeros(t.shape) + i, t)).T
bundle.append(pts)
start = np.random.randint(10, 30, n_streamlines)
end = np.random.randint(60, 100, n_streamlines)
bundle = [10 * streamline[start[i]:end[i]] for (i, streamline) in
enumerate(bundle)]
bundle_lengths = length(bundle)
for idx, this_length in enumerate(bundle_lengths):
npt.assert_equal(this_length, metrics.length(bundle[idx]))
def __iter__(self):
""" This is were all the fun starts """
x, y, z, g = self.a.shape
# for all seeds
for i in range(self.seed_no):
if self.seed_list == None:
rx = (x - 1) * np.random.rand()
ry = (y - 1) * np.random.rand()
rz = (z - 1) * np.random.rand()
seed = np.ascontiguousarray(np.array([rx, ry, rz]), dtype=np.float64)
else:
seed = np.ascontiguousarray(self.seed_list[i], dtype=np.float64)
# for all peaks
for ref in range(g):
# propagate up and down
# print g,self.a.shape
# """
# print i,seed
track = eudx_both_directions(
seed.copy(),
ref,
self.a,
self.ind,
self.odf_vertices,
self.a_low,
self.ang_thr,
self.step_sz,
self.total_weight,
)
# """
# track =None
if track == None:
# print 'None'
pass
else:
# return a track from that seed
if length(track) > self.length_thr:
# print 'track'
yield track
def smooth_line_gaussian(streamline, sigma):
if sigma < 0.00001:
ValueError('Cant have a 0 sigma with gaussian.')
nb_points = int(length(streamline))
if nb_points < 2:
logging.debug('Streamline shorter than 1mm, corner cases possible.')
nb_points = 2
sampled_streamline = set_number_of_points(streamline, nb_points)
x, y, z = sampled_streamline.T
x3 = gaussian_filter1d(x, sigma)
y3 = gaussian_filter1d(y, sigma)
z3 = gaussian_filter1d(z, sigma)
smoothed_streamline = np.asarray([x3, y3, z3]).T
# Ensure first and last point remain the same
smoothed_streamline[0] = streamline[0]
smoothed_streamline[-1] = streamline[-1]
return smoothed_streamline
def smooth_line_spline(streamline, sigma, nb_ctrl_points):
if sigma < 0.00001:
ValueError('Cant have a 0 sigma with spline.')
nb_points = int(length(streamline))
if nb_points < 2:
logging.debug('Streamline shorter than 1mm, corner cases possible.')
if nb_ctrl_points < 3:
nb_ctrl_points = 3
sampled_streamline = set_number_of_points(streamline, nb_ctrl_points)
tck, u = splprep(sampled_streamline.T, s=sigma)
smoothed_streamline = splev(np.linspace(0, 1, 99), tck)
smoothed_streamline = np.squeeze(np.asarray([smoothed_streamline]).T)
# Ensure first and last point remain the same
smoothed_streamline[0] = streamline[0]
smoothed_streamline[-1] = streamline[-1]
return smoothed_streamline
def show(T,A,IND,VERTS,scale):
r=fvtk.ren()
fvtk.clear(r)
fvtk.add(r,fvtk.line(T,fvtk.red))
fvtk.show(r)
Td=[downsample(t,20) for t in T]
C=local_skeleton_clustering(Td,3)
fvtk.clear(r)
lent=float(len(T))
for c in C:
color=np.random.rand(3)
virtual=C[c]['hidden']/float(C[c]['N'])
if length(virtual)> virtual_thr:
linewidth=100*len(C[c]['indices'])/lent
if linewidth<1.:
linewidth=1
#fvtk.add(r,fvtk.line(virtual,color,linewidth=linewidth))
#fvtk.add(r,fvtk.label(r,str(len(C[c]['indices'])),pos=virtual[0],scale=3,color=color ))
#print C[c]['hidden'].shape
print A.shape
print IND.shape
print VERTS.shape
all,allo=fvtk.crossing(A,IND,VERTS,scale,True)
colors=np.zeros((len(all),3))
for (i,a) in enumerate(all):
if allo[i][0]==0 and allo[i][1]==0 and allo[i][2]==1:
pass
else:
colors[i]=cm.boys2rgb(allo[i])
fvtk.add(r,fvtk.line(all,colors))
fvtk.show(r)
def save_id_tract_plus_sff(tracks_filename, id_file, num_proto, distance, out_fname):
if (tracks_filename[-3:]=='dpy'):
dpr_tracks = Dpy(tracks_filename, 'r')
all_tracks=dpr_tracks.read_tracks()
dpr_tracks.close()
else:
all_tracks = load_whole_tract_trk(tracks_filename)
tracks_id = load_pickle(id_file)
tract = [all_tracks[i] for i in tracks_id]
not_tract_fil = []
id_not_tract_fil = []
min_len = min(len(i) for i in tract)
#print 'min_len of cst', min_len
min_len = min_len*2.2/3#2./3.2# - 20
for i in np.arange(len(all_tracks)):
if (i not in tracks_id) and (length(all_tracks[i]) > min_len):
not_tract_fil.append(all_tracks[i])
id_not_tract_fil.append(i)
not_tract_fil = np.array(not_tract_fil,dtype=np.object)
sff_pro_id = sff(not_tract_fil, num_proto, distance)
tract_sff_id = []
for i in tracks_id:
tract_sff_id.append(i)
for idx in sff_pro_id:
tract_sff_id.append(id_not_tract_fil[idx])
#tract_sff_id.append(id_not_tract_fil[i] for i in sff_pro_id)
print len(tract), len(tract_sff_id)
save_pickle(out_fname, tract_sff_id)
return tract_sff_id
def __iter__(self):
''' This is were all the fun starts '''
x,y,z,g=self.a.shape
#for all seeds
for i in range(self.seed_no):
if self.seed_list==None:
rx=(x-1)*np.random.rand()
ry=(y-1)*np.random.rand()
rz=(z-1)*np.random.rand()
seed=np.ascontiguousarray(np.array([rx,ry,rz]),dtype=np.float64)
else:
seed=np.ascontiguousarray(self.seed_list[i],dtype=np.float64)
#for all peaks
for ref in range(self.a.shape[-1]):
#propagate up and down
track =eudx_propagation(seed.copy(),ref,self.a,self.ind,self.odf_vertices,self.a_low,self.ang_thr,self.step_sz)
if track == None:
pass
else:
#tlist.append(track.astype(np.float32))
if length(track)>self.length_thr:
yield track
def __iter__(self):
''' This is were all the fun starts '''
x, y, z, g = self.a.shape
#for all seeds
for i in range(self.seed_no):
if self.seed_list == None:
rx = (x - 1) * np.random.rand()
ry = (y - 1) * np.random.rand()
rz = (z - 1) * np.random.rand()
seed = np.ascontiguousarray(np.array([rx, ry, rz]),
dtype=np.float64)
else:
seed = np.ascontiguousarray(self.seed_list[i],
dtype=np.float64)
#for all peaks
for ref in range(g):
#propagate up and down
#print g,self.a.shape
#"""
#print i,seed
track = eudx_both_directions(seed.copy(), ref, self.a,
self.ind, self.odf_vertices,
self.a_low, self.ang_thr,
self.step_sz, self.total_weight)
#"""
#track =None
if track == None:
#print 'None'
pass
else:
#return a track from that seed
if length(track) > self.length_thr:
#print 'track'
yield track
def load_tractography(subject_id, subject_pair):
tract_streamline = {}
Total_streamline = 0
for tract in subject_tracts[str(subject_pair)]:
filename_tractography = '/home/nusrat//targetDirectory/MICCAI2015_DTI_EUDX/' + str(
subject_id) + '_1M_wmql/wmql_' + str(tract) + '.trk'
tractography, header = trackvis.read(filename_tractography,
points_space='voxel')
tractography = [streamline[0] for streamline in tractography]
tractography = [
streamline for streamline in tractography
if length(streamline) >= 15
]
dict_element = (tractography, len(tractography))
tract_streamline[str(subject_id) + '_' + str(tract)] = dict_element
Total_streamline = len(tractography) + Total_streamline
return tract_streamline, Total_streamline
odf_vertices=peaks.default_sphere.vertices,
a_low=.05,
step_sz=.5,
seeds=seeds)
affine = streamline_generator.affine
streamlines = list(streamline_generator)
# to include only longer streamlines, so we visualize lesser amount of tract, for hardware reasons
# part for changing including streamlines only longer than particular length, here 50
from dipy.tracking.metrics import length
longer_streamlines = []
for tract in streamlines:
if length(tract) > 50.0:
longer_streamlines.append(tract)
# Streamlines visualization
from dipy.viz import fvtk
from dipy.viz.colormap import line_colors
# Make display objects
streamlines_actor = fvtk.line(longer_streamlines,
line_colors(longer_streamlines))
# Add display objects to canvas
r = fvtk.ren()
fvtk.add(r, streamlines_actor)
T.append(s[0])
r=fvtk.ren()
linea=fvtk.line(T,fvtk.red)
fvtk.add(r,linea)
fvtk.show(r)
#for more complicated visualizations use mayavi
#or the new fos when released
dT=[tm.downsample(t,10) for t in T]
C=td.local_skeleton_clustering(dT,d_thr=5)
ldT=[tm.length(t) for t in dT]
#average length
avg_ldT=sum(ldT)/len(dT)
print(avg_ldT)
"""
r=fvtk.ren()
#fvtk.clear(r)
colors=np.zeros((len(T),3))
for c in C:
color=np.random.rand(1,3)
for i in C[c]['indices']:
colors[i]=color
fvtk.add(r,fvtk.line(T,colors,opacity=1))
fvtk.show(r)
"""
filename_1 = 'data/101_tracks_dti_10K.dpy'
filename_2 = 'data/104_tracks_dti_10K.dpy'
prototype_policies = ['random', 'fft', 'sff']
num_prototypes = 10
size1 = num_prototypes
size2 = size1 + 20
print "Loading tracks."
dpr_1 = Dpy(filename_1, 'r')
tracks_1_all = dpr_1.read_tracks()
dpr_1.close()
tracks_1 = []
for st in tracks_1_all:
if (length(st)>50):
tracks_1.append(st)
tracks_1 = np.array(tracks_1, dtype=np.object)
dpr_2 = Dpy(filename_2, 'r')
tracks_2_all = dpr_2.read_tracks()
dpr_2.close()
tracks_2 = []
for st in tracks_2_all:
if (length(st)>50):
tracks_2.append(st)
tracks_2 = np.array(tracks_2, dtype=np.object)
def truth_length_min(tracks):
lmin = length(tracks[0], False)
for k in range(len(tracks)):
if lmin>length(tracks[k]):
lmin = length(tracks[k])
return lmin
def filter_ellipsoid(sft, ellipsoid_radius, ellipsoid_center,
filter_type, is_exclude, is_in_vox=False):
"""
Parameters
----------
sft : StatefulTractogram
StatefulTractogram containing the streamlines to segment.
ellipsoid_radius : numpy.ndarray (3)
Size in mm, x/y/z of the ellipsoid.
ellipsoid_center: numpy.ndarray (3)
Center x/y/z of the ellipsoid.
filter_type: str
One of the 3 following choices, 'any', 'either_end', 'both_ends'.
is_exclude: bool
Value to indicate if the ROI is an AND (false) or a NOT (true).
is_in_vox: bool
Value to indicate if the ROI is in voxel space.
Returns
-------
ids : tuple
Filtered sft.
Ids of the streamlines passing through the mask.
"""
pre_filtered_sft, pre_filtered_indices = \
pre_filtering_for_geometrical_shape(sft, ellipsoid_radius,
ellipsoid_center, filter_type,
is_in_vox)
pre_filtered_sft.to_rasmm()
pre_filtered_sft.to_center()
pre_filtered_streamlines = pre_filtered_sft.streamlines
transfo, _, res, _ = sft.space_attributes
if is_in_vox:
ellipsoid_center = np.asarray(apply_affine(transfo,
ellipsoid_center))
selected_by_ellipsoid = []
line_based_indices_1 = []
line_based_indices_2 = []
# This is still point based (but resampled), I had a ton of problems trying
# to use something with intersection, but even if I could do it :
# The result won't be identical to MI-Brain since I am not using the
# vtkPolydata. Also it won't be identical to TrackVis either,
# because TrackVis is point-based for Spherical ROI...
ellipsoid_radius = np.asarray(ellipsoid_radius)
ellipsoid_center = np.asarray(ellipsoid_center)
for i, line in enumerate(pre_filtered_streamlines):
if filter_type == 'any':
# Resample to 1/10 of the voxel size
nb_points = max(int(length(line) / np.average(res) * 10), 2)
line = set_number_of_points(line, nb_points)
points_in_ellipsoid = np.sum(
((line - ellipsoid_center) / ellipsoid_radius) ** 2,
axis=1)
if np.argwhere(points_in_ellipsoid <= 1).any():
# If at least one point was in the ellipsoid, we selected
# the streamline
selected_by_ellipsoid.append(pre_filtered_indices[i])
else:
points_in_ellipsoid = np.sum(
((line[0] - ellipsoid_center) / ellipsoid_radius) ** 2)
if points_in_ellipsoid <= 1.0:
line_based_indices_1.append(pre_filtered_indices[i])
points_in_ellipsoid = np.sum(
((line[-1] - ellipsoid_center) / ellipsoid_radius) ** 2)
if points_in_ellipsoid <= 1.0:
line_based_indices_2.append(pre_filtered_indices[i])
# Both endpoints need to be in the mask (AND)
if filter_type == 'both_ends':
selected_by_ellipsoid = np.intersect1d(line_based_indices_1,
line_based_indices_2)
# Only one endpoint needs to be in the mask (OR)
elif filter_type == 'either_end':
selected_by_ellipsoid = np.union1d(line_based_indices_1,
line_based_indices_2)
# If the 'exclude' option is used, the selection is inverted
if is_exclude:
selected_by_ellipsoid = np.setdiff1d(range(len(sft)),
np.unique(selected_by_ellipsoid))
line_based_indices = np.asarray(selected_by_ellipsoid).astype(np.int32)
# From indices to sft
streamlines = sft.streamlines[line_based_indices]
data_per_streamline = sft.data_per_streamline[line_based_indices]
data_per_point = sft.data_per_point[line_based_indices]
new_sft = StatefulTractogram.from_sft(streamlines, sft,
data_per_streamline=data_per_streamline,
data_per_point=data_per_point)
return new_sft, line_based_indices
def track_range(a,b):
lt=length(t)
if lt>a and lt<b:
return True
return False
def truth_length_max(tracks):
lmax = length(tracks[0], False)
for k in range(len(tracks)):
if lmax<length(tracks[k],False):
lmax = length(tracks[k])
return lmax
def truth_length_avg(tracks):
s = 0
for k in range(len(tracks)):
s = s + length(tracks[k])
return s/len(tracks)
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)
# to include only longer streamlines, so we visualize lesser amount of tract, for hardware reasons
# part for changing including streamlines only longer than particular length, here 50
from dipy.tracking.metrics import length
longer_streamlines = []
for tract in streamlines:
if length(tract)>50.0:
longer_streamlines.append(tract)
# Streamlines visualization
from dipy.viz import fvtk
from dipy.viz.colormap import line_colors
# Make display objects
streamlines_actor = fvtk.line(longer_streamlines, line_colors(longer_streamlines))
# Add display objects to canvas
r = fvtk.ren()
fvtk.add(r, streamlines_actor)
def filter_ellipsoid(sft, ellipsoid_radius, ellipsoid_center,
filter_type, is_not, is_in_vox=False):
pre_filtered_streamlines, pre_filtered_indices = \
pre_filtering_for_geometrical_shape(sft, ellipsoid_radius,
ellipsoid_center, filter_type,
is_in_vox)
transfo, _, res, _ = sft.space_attribute
if is_in_vox:
ellipsoid_center = np.asarray(apply_affine(transfo,
ellipsoid_center))
selected_by_ellipsoid = []
line_based_indices_1 = []
line_based_indices_2 = []
# This is still point based (but resampled), I had a ton of problems trying
# to use something with intersection, but even if I could do it :
# The result won't be identical to MI-Brain since I am not using the
# vtkPolydata. Also it won't be identical to TrackVis either,
# because TrackVis is point-based for Spherical ROI...
ellipsoid_radius = np.asarray(ellipsoid_radius)
ellipsoid_center = np.asarray(ellipsoid_center)
for i, line in enumerate(pre_filtered_streamlines):
if filter_type == 'any':
# Resample to 1/10 of the voxel size
nb_points = max(int(length(line) / np.average(res) * 10), 2)
line = set_number_of_points(line, nb_points)
points_in_ellipsoid = np.sum(
((line - ellipsoid_center) / ellipsoid_radius) ** 2,
axis=1)
if np.argwhere(points_in_ellipsoid <= 1).any():
# If at least one point was in the ellipsoid, we selected
# the streamline
selected_by_ellipsoid.append(pre_filtered_indices[i])
else:
points_in_ellipsoid = np.sum(
((line[0] - ellipsoid_center) / ellipsoid_radius) ** 2)
if points_in_ellipsoid <= 1.0:
line_based_indices_1.append(pre_filtered_indices[i])
points_in_ellipsoid = np.sum(
((line[-1] - ellipsoid_center) / ellipsoid_radius) ** 2)
if points_in_ellipsoid <= 1.0:
line_based_indices_2.append(pre_filtered_indices[i])
# Both endpoints need to be in the mask (AND)
if filter_type == 'both_ends':
selected_by_ellipsoid = np.intersect1d(line_based_indices_1,
line_based_indices_2)
# Only one endpoint needs to be in the mask (OR)
elif filter_type == 'either_end':
selected_by_ellipsoid = np.union1d(line_based_indices_1,
line_based_indices_2)
# If the --not option is used, the selection is inverted
all_indices = range(len(sft))
if is_not:
selected_by_ellipsoid = np.setdiff1d(all_indices,
np.unique(selected_by_ellipsoid))
# From indices to streamlines
final_streamlines = list(sft.streamlines[
np.asarray(selected_by_ellipsoid).astype(np.int32)])
return final_streamlines, selected_by_ellipsoid
def filter_cuboid(sft, cuboid_radius, cuboid_center,
filter_type, is_not):
pre_filtered_streamlines, pre_filtered_indices = \
pre_filtering_for_geometrical_shape(sft, cuboid_radius,
cuboid_center, filter_type,
False)
_, _, res, _ = sft.space_attribute
selected_by_cuboid = []
line_based_indices_1 = []
line_based_indices_2 = []
# Also here I am not using a mathematical intersection and
# I am not using vtkPolyData like in MI-Brain, so not exactly the same
cuboid_radius = np.asarray(cuboid_radius)
cuboid_center = np.asarray(cuboid_center)
for i, line in enumerate(pre_filtered_streamlines):
if filter_type == 'any':
# Resample to 1/10 of the voxel size
nb_points = max(int(length(line)/np.average(res) * 10), 2)
line = set_number_of_points(line, nb_points)
points_in_cuboid = np.abs(line - cuboid_center) / cuboid_radius
points_in_cuboid[points_in_cuboid <= 1] = 1
points_in_cuboid[points_in_cuboid > 1] = 0
points_in_cuboid = np.sum(points_in_cuboid, axis=1)
if np.argwhere(points_in_cuboid == 3).any():
# If at least one point was in the cuboid, we selected
# the streamlines
selected_by_cuboid.append(pre_filtered_indices[i])
else:
# Faster to do it twice than trying to do in using an array of 2
points_in_cuboid = np.abs(line[0] - cuboid_center) / cuboid_radius
points_in_cuboid[points_in_cuboid <= 1] = 1
points_in_cuboid[points_in_cuboid > 1] = 0
points_in_cuboid = np.sum(points_in_cuboid)
if points_in_cuboid == 3:
line_based_indices_1.append(pre_filtered_indices[i])
points_in_cuboid = np.abs(line[-1] - cuboid_center) / cuboid_radius
points_in_cuboid[points_in_cuboid <= 1] = 1
points_in_cuboid[points_in_cuboid > 1] = 0
points_in_cuboid = np.sum(points_in_cuboid)
if points_in_cuboid == 3:
line_based_indices_2.append(pre_filtered_indices[i])
# Both endpoints need to be in the mask (AND)
if filter_type == 'both_ends':
selected_by_cuboid = np.intersect1d(line_based_indices_1,
line_based_indices_2)
# Only one endpoint need to be in the mask (OR)
elif filter_type == 'either_end':
selected_by_cuboid = np.union1d(line_based_indices_1,
line_based_indices_2)
# If the --not option is used, the selection is inverted
all_indices = range(len(sft))
if is_not:
selected_by_cuboid = np.setdiff1d(all_indices,
np.unique(selected_by_cuboid))
# From indices to streamlines
# From indices to streamlines
final_streamlines = list(sft.streamlines[
np.asarray(selected_by_cuboid).astype(np.int32)])
return final_streamlines, selected_by_cuboid
def nii2streamlines(imgfile, maskfile, bvals, bvecs):
import numpy as np
import nibabel as nib
import os
from dipy.reconst.dti import TensorModel
img = nib.load(imgfile)
bvals = np.genfromtxt(bvals)
bvecs = np.genfromtxt(bvecs)
if bvecs.shape[1] != 3:
bvecs = bvecs.T
from nipype.utils.filemanip import split_filename
_, prefix, _ = split_filename(imgfile)
from dipy.data import gradient_table
gtab = gradient_table(bvals, bvecs)
data = img.get_data()
affine = img.get_affine()
zooms = img.get_header().get_zooms()[:3]
new_zooms = (2., 2., 2.)
data2, affine2 = data, affine
mask = nib.load(maskfile).get_data().astype(np.bool)
tenmodel = TensorModel(gtab)
tenfit = tenmodel.fit(data2, mask)
from dipy.reconst.dti import fractional_anisotropy
FA = fractional_anisotropy(tenfit.evals)
FA[np.isnan(FA)] = 0
fa_img = nib.Nifti1Image(FA, img.get_affine())
nib.save(fa_img, '%s_tensor_fa.nii.gz' % prefix)
evecs = tenfit.evecs
evec_img = nib.Nifti1Image(evecs, img.get_affine())
nib.save(evec_img, '%s_tensor_evec.nii.gz' % prefix)
from dipy.data import get_sphere
sphere = get_sphere('symmetric724')
from dipy.reconst.dti import quantize_evecs
peak_indices = quantize_evecs(tenfit.evecs, sphere.vertices)
from dipy.tracking.eudx import EuDX
eu = EuDX(FA,
peak_indices,
odf_vertices=sphere.vertices,
a_low=0.2,
seeds=10**6,
ang_thr=35)
tensor_streamlines = [streamline for streamline in eu]
hdr = nib.trackvis.empty_header()
hdr['voxel_size'] = new_zooms
hdr['voxel_order'] = 'LPS'
hdr['dim'] = data2.shape[:3]
import dipy.tracking.metrics as dmetrics
tensor_streamlines = ((sl, None, None) for sl in tensor_streamlines
if dmetrics.length(sl) > 15)
ten_sl_fname = '%s_streamline.trk' % prefix
nib.trackvis.write(ten_sl_fname,
tensor_streamlines,
hdr,
points_space='voxel')
return ten_sl_fname
filename_1 = 'data/101_tracks_dti_10K_linear.dpy'
filename_2 = 'data/104_tracks_dti_10K_linear.dpy'
prototype_policies = ['random', 'fft', 'sff']
num_prototypes = 40
print "Loading tracks."
dpr_1 = Dpy(filename_1, 'r')
tracks_1_all = dpr_1.read_tracks()
dpr_1.close()
tracks_1 = []
for st in tracks_1_all:
if (length(st)>45):
tracks_1.append(st)
tracks_1 = np.array(tracks_1, dtype=np.object)
dpr_2 = Dpy(filename_2, 'r')
tracks_2_all = dpr_2.read_tracks()
dpr_2.close()
tracks_2 = []
for st in tracks_2_all:
if (length(st)>45):
tracks_2.append(st)
tracks_2 = np.array(tracks_2, dtype=np.object)
def loading_full_tractograpy(self, tracpath=None):
"""
Loading full tractography and creates StreamlineLabeler to
show it all.
"""
# load the tracks registered in MNI space
self.tracpath=tracpath
basename = os.path.basename(self.tracpath)
tracks_basename, tracks_format = os.path.splitext(basename)
if tracks_format == '.dpy':
dpr = Dpy(self.tracpath, 'r')
print "Loading", self.tracpath
self.T = dpr.read_tracks()
dpr.close()
self.T = np.array(self.T, dtype=np.object)
elif tracks_format == '.trk':
streams, self.hdr = nib.trackvis.read(self.tracpath, points_space='voxel')
print "Loading", self.tracpath
self.T = np.array([s[0] for s in streams], dtype=np.object)
print "Removing short streamlines"
self.T = np.array([t for t in self.T if length(t)>= 15], dtype=np.object)
tracks_directoryname = os.path.dirname(self.tracpath) + '/.temp/'
general_info_filename = tracks_directoryname + tracks_basename + '.spa'
# Check if there is the .spa file that contains all the
# computed information from the tractography anyway and try to
# load it
try:
print "Looking for general information file"
self.load_info(general_info_filename)
except IOError:
print "General information not found, recomputing buffers"
print "Computing buffers."
self.buffers = compute_buffers(self.T, alpha=1.0, save=False)
print "Computing dissimilarity matrix"
self.num_prototypes = 40
self.full_dissimilarity_matrix = compute_dissimilarity(self.T, distance=bundles_distances_mam, prototype_policy='sff', num_prototypes=self.num_prototypes)
# compute initial MBKM with given n_clusters
print "Computing MBKM"
size_T = len(self.T)
if size_T > 150:
n_clusters = 150
else:
n_clusters = size_T
streamlines_ids = np.arange(size_T, dtype=np.int)
self.clusters = mbkm_wrapper(self.full_dissimilarity_matrix, n_clusters, streamlines_ids)
print "Saving computed information from tractography"
if not os.path.exists(tracks_directoryname):
os.makedirs(tracks_directoryname)
self.save_info(general_info_filename)
# create the interaction system for tracks,
self.streamlab = StreamlineLabeler('Bundle Picker',
self.buffers, self.clusters,
vol_shape=self.dims,
affine=np.copy(self.affine),
clustering_parameter=len(self.clusters),
clustering_parameter_max=len(self.clusters),
full_dissimilarity_matrix=self.full_dissimilarity_matrix)
self.scene.add_actor(self.streamlab)
print 'after',bvals2.shape,bvecs2.shape
#always check the threshold but 50 should be okay
ten=Tensor(data2,bvals2,bvecs2,thresh=50)
#ten.ind is indices of the eigen directions projected on a sphere
#stopping criteria is FA of .2
eu=EuDX(a=ten.fa(),ind=ten.ind(),seeds=5000,a_low=0.2)
#generate tracks
ten_tracks=[track for track in eu]
print 'No tracks ',len(ten_tracks)
#remove short tracks smaller than 40mm i.e. 20 in native units
ten_tracks=[t for t in ten_tracks if length(t)>20]
print 'No reduced tracks ',len(ten_tracks)
raw_input('Press enter...')
#load the rois
imsk1=nib.load(dname+'/'+froi1)
roi1=imsk1.get_data()
imsk2=nib.load(dname+'/'+froi2)
roi2=imsk2.get_data()
print 'roi dimensions', roi1.shape,roi2.shape
print 'roi voxels', np.sum(roi1==255),np.sum(roi2==255)
#tcs track counts volume
#tes dictionary of tracks passing from voxels
def save_id_tract_ext1(tracks_filename, id_file, distance, out_fname, thres_len= 2.2/3., thres_vol = 1.2 , thres_dis = 2.8/2.):
print thres_len, thres_vol, thres_dis
if (tracks_filename[-3:]=='dpy'):
dpr_tracks = Dpy(tracks_filename, 'r')
all_tracks=dpr_tracks.read_tracks()
dpr_tracks.close()
else:
all_tracks = load_whole_tract_trk(tracks_filename)
tracks_id = load_pickle(id_file)
tract = [all_tracks[i] for i in tracks_id]
not_tract_fil = []
id_not_tract_fil = []
min_len = min(len(i) for i in tract)
#print 'min_len of cst', min_len
min_len = min_len*thres_len
for i in np.arange(len(all_tracks)):
if (i not in tracks_id) and (length(all_tracks[i]) > min_len):
not_tract_fil.append(all_tracks[i])
id_not_tract_fil.append(i)
k = np.round(len(tract) * thres_vol )
from dipy.segment.quickbundles import QuickBundles
qb = QuickBundles(tract,200,18)
medoid_tract = qb.centroids[0]
med_nottract_dm = distance([medoid_tract], not_tract_fil)
med_tract_dm = distance([medoid_tract], tract)
tract_rad = med_tract_dm[0][np.argmax(med_tract_dm[0])]
len_dis = tract_rad * thres_dis# 2.8/2.
#k_indices which close to the medoid
sort = np.argsort(med_nottract_dm,axis = 1)[0]
#print sort[:k+1]
while (k>0 and med_nottract_dm[0][sort[k]]>=len_dis):
k = k - 1
#print k
close_indices = sort[0:k]
#for idx in close_indices:
# tract_ext.append(not_tract_fil[idx])
#print 'close indices', len(close_indices)
tract_ext_id = []
for i in tracks_id:
tract_ext_id.append(i)
#print 'Before', len(tract_ext_id)
for idx in close_indices:
tract_ext_id.append(id_not_tract_fil[idx])
# print idx, id_not_tract_fil[idx]
#print 'After', len(tract_ext_id)
#tract_ext_id = [i for i in tracks_id]
#tract_ext_id.append(id_not_tract_fil[i] for i in close_indices)
save_pickle(out_fname, tract_ext_id)
return tract_ext_id
def lengths(tracks):
return [length(t) for t in tracks]
def generate_lengths(fdpy,fnpy):
dpr=Dpy(fdpy,'r')
T=dpr.read_tracks()
dpr.close()
lenT=[length(t) for t in T]
np.save(fnpy,np.array(lenT))
def filter_cuboid(sft, cuboid_radius, cuboid_center,
filter_type, is_exclude):
"""
Parameters
----------
sft : StatefulTractogram
StatefulTractogram containing the streamlines to segment.
cuboid_radius : numpy.ndarray (3)
Size in mm, x/y/z of the cuboid.
cuboid_center: numpy.ndarray (3)
Center x/y/z of the cuboid.
filter_type: str
One of the 3 following choices, 'any', 'either_end', 'both_ends'.
is_exclude: bool
Value to indicate if the ROI is an AND (false) or a NOT (true).
is_in_vox: bool
Value to indicate if the ROI is in voxel space.
Returns
-------
ids : tuple
Filtered sft.
Ids of the streamlines passing through the mask.
"""
pre_filtered_sft, pre_filtered_indices = \
pre_filtering_for_geometrical_shape(sft, cuboid_radius,
cuboid_center, filter_type,
False)
pre_filtered_sft.to_rasmm()
pre_filtered_sft.to_center()
pre_filtered_streamlines = pre_filtered_sft.streamlines
_, _, res, _ = sft.space_attributes
selected_by_cuboid = []
line_based_indices_1 = []
line_based_indices_2 = []
# Also here I am not using a mathematical intersection and
# I am not using vtkPolyData like in MI-Brain, so not exactly the same
cuboid_radius = np.asarray(cuboid_radius)
cuboid_center = np.asarray(cuboid_center)
for i, line in enumerate(pre_filtered_streamlines):
if filter_type == 'any':
# Resample to 1/10 of the voxel size
nb_points = max(int(length(line) / np.average(res) * 10), 2)
line = set_number_of_points(line, nb_points)
points_in_cuboid = np.abs(line - cuboid_center) / cuboid_radius
points_in_cuboid = np.sum(np.where(points_in_cuboid <= 1, 1, 0),
axis=1)
if np.argwhere(points_in_cuboid == 3).any():
# If at least one point was in the cuboid in x/y/z,
# we selected that streamline
selected_by_cuboid.append(pre_filtered_indices[i])
else:
# Faster to do it twice than trying to do in using an array of 2
points_in_cuboid = np.abs(line[0] - cuboid_center) / cuboid_radius
points_in_cuboid = np.sum(np.where(points_in_cuboid <= 1, 1, 0))
if points_in_cuboid == 3:
line_based_indices_1.append(pre_filtered_indices[i])
points_in_cuboid = np.abs(line[-1] - cuboid_center) / cuboid_radius
points_in_cuboid = np.sum(np.where(points_in_cuboid <= 1, 1, 0))
if points_in_cuboid == 3:
line_based_indices_2.append(pre_filtered_indices[i])
# Both endpoints need to be in the mask (AND)
if filter_type == 'both_ends':
selected_by_cuboid = np.intersect1d(line_based_indices_1,
line_based_indices_2)
# Only one endpoint need to be in the mask (OR)
elif filter_type == 'either_end':
selected_by_cuboid = np.union1d(line_based_indices_1,
line_based_indices_2)
# If the 'exclude' option is used, the selection is inverted
if is_exclude:
selected_by_cuboid = np.setdiff1d(range(len(sft)),
np.unique(selected_by_cuboid))
line_based_indices = np.asarray(selected_by_cuboid).astype(np.int32)
# From indices to sft
streamlines = sft.streamlines[line_based_indices]
data_per_streamline = sft.data_per_streamline[line_based_indices]
data_per_point = sft.data_per_point[line_based_indices]
new_sft = StatefulTractogram.from_sft(streamlines, sft,
data_per_streamline=data_per_streamline,
data_per_point=data_per_point)
return new_sft, line_based_indices
def metrics_compute(self, streamlines):
"""
script to extract metrics
and save to a tabular file
spline for spline interpolation
centre_of_mass
mean_curvature,
mean_orientation
the frenet_serret framework for curvature
torsion calculations along a streamline.
https://dipy.org/documentation/1.4.1./reference/dipy.tracking/
https://dipy.org/documentation/1.1.1./reference/dipy.tracking/
# from dipy.segment.metric import AveragePointwiseEuclideanMetric
# from dipy.segment.clustering import QuickBundles
# # Create the instance of `AveragePointwiseEuclideanMetric` to use.
# metric = AveragePointwiseEuclideanMetric()
# qb = QuickBundles(threshold=10., metric=metric)
# clusters = qb.cluster(streamlines)
chk:
https://nipype.readthedocs.io/en/latest/users/examples/dmri_connectivity_advanced.html
"""
print("extracting metrics")
metrics_dic = {
"lengths": list(),
"average_length": list(),
"std": list(),
"mean_curvature": list(),
"mean_orientation": list(),
"spline": list(),
"curvature_scalar": list(),
"torsion": list()
}
# lengths of streamlines
lengths = [length(s) for s in streamlines]
lengths = np.array(lengths)
metrics_dic["lengths"] = lengths.tolist()
metrics_dic["average_length"] = [
lengths.mean(),
]
metrics_dic["std"] = [
lengths.std(),
]
# mean curvature, mean orientation and spline for spline interpolation
for streamline in streamlines:
mc = metrics_dic.mean_curvature(streamline)
metrics_dic["mean_curvature"].append(mc)
mo = metrics_dic.mean_orientation(streamline)
metrics_dic["mean_orientation"].append(mo)
spl = metrics_dic.spline(streamline)
metrics_dic["spline"].append(spl)
k = metrics_dic.frenet_serret(streamline)[3]
metrics_dic["curvature_scalar"].append(k)
t = metrics_dic.frenet_serret(streamline)[4]
metrics_dic["torsion"].append(t)
return metrics_dic
data = img.get_data()
affine = img.get_affine()
print len(data)
#load the tracks
tracks_filename = 'ALS_Data/'+str(subj)+'/DIFF2DEPI_EKJ_64dirs_14/DTI/tracks_dti_'+str(num_seeds)+'M_linear.dpy'
dpr_tracks = Dpy(tracks_filename, 'r')
T = dpr_tracks.read_tracks();
dpr_tracks.close()
#print len(T)
print len(T)
T = T[:200]
T = [t for t in T if length(t)>= 15]
# T = [downsample(t, 18) - np.array(data.shape[:3]) / 2. for t in T]
# axis = np.array([1, 0, 0])
# theta = - 90.
# T = np.dot(T,rotation_matrix(axis, theta))
# axis = np.array([0, 1, 0])
# theta = 180.
# T = np.dot(T, rotation_matrix(axis, theta))
#
#load initial QuickBundles with threshold 30mm
#fpkl = dname+'data/subj_05/101_32/DTI/qb_gqi_1M_linear_30.pkl'
#qb=QuickBundles(T, 10., 18)
#save_pickle(fpkl,qb)
#qb=load_pickle(fpkl)
filename_1 = 'data/101_tracks_dti_10K_linear.dpy'
filename_2 = 'data/104_tracks_dti_10K_linear.dpy'
prototype_policies = ['random', 'fft', 'sff']
num_prototypes = 10
print "Loading tracks."
dpr_1 = Dpy(filename_1, 'r')
tracks_1_all = dpr_1.read_tracks()
dpr_1.close()
tracks_1 = []
for st in tracks_1_all:
if (length(st)>20):
tracks_1.append(st)
tracks_1 = np.array(tracks_1, dtype=np.object)
dpr_2 = Dpy(filename_2, 'r')
tracks_2_all = dpr_2.read_tracks()
dpr_2.close()
tracks_2 = []
for st in tracks_2_all:
if (length(st)>20):
tracks_2.append(st)
tracks_2 = np.array(tracks_2, dtype=np.object)
