def getLengths(streamlines): from dipy.tracking.utils import length lengths = list(length(streamlines)) nb_stl = len(streamlines) min_len = min(length(streamlines)) max_len = max(length(streamlines)) print('Nb. streamlines:') print(nb_stl) print('Min length:') print(min_len) print('Max length:') print(max_len) return lengths
def filterLength(streamlines, thr_len): from dipy.tracking.utils import length new_streamlines = [ s for s, l in zip(streamlines, getLengths(streamlines)) if l > thr_len ] #3.5 #2.5 #new_streamlines_l = list(new_streamlines) new_lengths = list(length(new_streamlines)) print('Nb. new streamlines:') print(len(new_streamlines)) return new_streamlines
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 filterlength(dname, fdwi, ffa, ftrk, thr_length, show=False): fa_img = nib.load(ffa) fa = fa_img.get_data() affine = fa_img.get_affine() img = nib.load(fdwi) data = img.get_data() from nibabel import trackvis streams, hdr = trackvis.read(ftrk) streamlines = [s[0] for s in streams] # threshold on streamline length from dipy.tracking.utils import length lengths = list(length(streamlines)) new_streamlines = [ s for s, l in zip(streamlines, lengths) if l > thr_length ] #3.5 # info length streamlines print(len(streamlines)) print(len(new_streamlines)) print(max(length(streamlines))) print(min(length(streamlines))) print(max(length(new_streamlines))) print(min(length(new_streamlines))) # show new tracto new_streamlines = list(new_streamlines) new_lengths = list(length(new_streamlines)) fnew_tractogram = dname + 'filteredtractogram.trk' save_trk_old_style(fnew_tractogram, new_streamlines, affine, fa.shape) if show: show_results(data, new_streamlines, fa, affine, opacity=0.6)
# Make a corpus callosum seed mask for tracking seed_mask = labels == 2 seeds = utils.seeds_from_mask(seed_mask, density=[1, 1, 1], affine=affine) # Make a streamline bundle model of the corpus callosum ROI connectivity streamlines = LocalTracking(csa_peaks, classifier, seeds, affine, step_size=2) streamlines = Streamlines(streamlines) """ We do not want our results inflated by short streamlines, so we remove streamlines shorter than 40mm prior to calculating the CCI. """ lengths = list(length(streamlines)) long_streamlines = Streamlines() for i, sl in enumerate(streamlines): if lengths[i] > 40: long_streamlines.append(sl) """ Now we calculate the Cluster Confidence Index using the corpus callosum streamline bundle and visualize them. """ cci = cluster_confidence(long_streamlines) # Visualize the streamlines, colored by cci
return bundle bundle = simulated_bundles() print("This bundle has %d streamlines" % len(bundle)) """ This bundle has 50 streamlines. Using the ``length`` function we can retrieve the lengths of each streamline. Below we show the histogram of the lengths of the streamlines. """ lengths = list(length(bundle)) import matplotlib.pyplot as plt fig_hist, ax = plt.subplots(1) ax.hist(lengths, color="burlywood") ax.set_xlabel("Length") ax.set_ylabel("Count") plt.show() plt.legend() plt.savefig("length_histogram.png") """ .. figure:: length_histogram.png :align: center
def compute_correlation(data, distance, prototype_policies, num_prototypes, iterations, verbose=False, size_limit=1000): global tracks_t,ids_l,data_original,tracks_s,id_t,tracks_n,a_ind, tracks_subsample print "Computing distance matrix and similarity matrix (original space):", data_original = data if data.shape[0] > size_limit: print print "Datset too big: subsampling to %s entries only!" % size_limit data = data[np.random.permutation(data.shape[0])[:size_limit], :] od = distance(data, data) print od.shape original_distances = squareform(od) #original_distances2 = squareform(od) """ my code """ affine=utils.affine_for_trackvis(voxel_size=np.array([2,2,2])) lengths = list(length(data_original)) lengths=np.array(lengths) temp=np.where(lengths>10)[0] l=np.argsort(lengths)[::-1][:len(temp)] data_original_temp=data_original[l] a= streamline_mapping_new_step(data_original_temp, affine=affine) tracks_subsample=data_original_temp[a] print len(tracks_subsample) """ my code """ rho = np.zeros((len(prototype_policies), len(num_prototypes),iterations)) for m, prototype_policy in enumerate(prototype_policies): print prototype_policy for j, num_proto in enumerate(num_prototypes): print "number of prototypes:", num_proto, " - ", for k in range(iterations): print k, stdout.flush() if verbose: print("Generating %s prototypes as" % num_proto), # Note that we use the original dataset here, not the subsampled one! if prototype_policy=='random': if verbose: print("random subset of the initial data.") prototype_idx = np.random.permutation(data_original.shape[0])[:num_proto] prototype = [data_original[i] for i in prototype_idx] elif prototype_policy=='sff': prototype_idx = subset_furthest_first(data_original, num_proto, distance) prototype = [data_original[i] for i in prototype_idx] elif prototype_policy=='fft': prototype_idx = furthest_first_traversal( tracks_subsample, num_proto, distance) prototype = [ tracks_subsample[i] for i in prototype_idx] else: raise Exception if verbose: print("Computing dissimilarity matrix.") data_dissimilarity = distance(data, prototype) if verbose: print("Computing distance matrix (dissimilarity space).") dissimilarity_distances = pdist(data_dissimilarity, metric='euclidean') rho[m,j,k] = correlation(original_distances, dissimilarity_distances)[0] print return rho
""" Reading the track """ streams1,hdr1=nib.trackvis.read('/home/nusrat/dataset_trackvis/101.trk') tracks = np.array([s[0] for s in streams1], dtype=np.object) """ affine for converting the streamline cordinate with the voxel cordinate """ affine=utils.affine_for_trackvis(voxel_size=np.array([2,2,2])) """ length function from the dipy https://github.com/nipy/dipy/blob/master/dipy/tracking/_utils.py """ lengths = list(length(tracks)) """ fiter the whole tractography--like we are not interested the track less than 10. """ lengths=np.array(lengths) l=np.where(lengths>10)[0] """ rearrange the tracktography """ tracks=tracks[l] """ checking is there any crossing bewtween them--calling the function that retrun the id of streamline those are not crossing """
return T, hdr if __name__ == '__main__': T_A_filename = 'F:\Thesis\data\\100307\\100307_af.left.trk' T_A,hdr= loadtrkfile(T_A_filename, threshold_short_streamlines=10.0) T_A.tolist() T_A_filename2 = 'F:\Thesis\data\\124422\\124422_af.left.trk' #T_A_filename2 = 'F:\Thesis\data\\100307\\100307_af.right.trk' T_A2,hdr= loadtrkfile(T_A_filename2, threshold_short_streamlines=10.0) T_A2.tolist() dis=mam_distances(T_A[0], T_A2[0], metric='avg' ) print("Track Distance .. ") lengths = list(length(T_A)) fig_hist, ax = plt.subplots() ax.plot(dis) plt.show() print(dis)
We will use a slice of the anatomically-based corpus callosum ROI as our seed mask to demonstrate the method. """ # Make a corpus callosum seed mask for tracking seed_mask = labels == 2 seeds = utils.seeds_from_mask(seed_mask, density=[1, 1, 1], affine=affine) # Make a streamline bundle model of the corpus callosum ROI connectivity streamlines = LocalTracking(csa_peaks, classifier, seeds, affine, step_size=2) streamlines = Streamlines(streamlines) """ We do not want our results inflated by short streamlines, so we remove streamlines shorter than 40mm prior to calculating the CCI. """ lengths = list(length(streamlines)) long_streamlines = Streamlines() for i, sl in enumerate(streamlines): if lengths[i] > 40: long_streamlines.append(sl) """ Now we calculate the Cluster Confidence Index using the corpus callosum streamline bundle and visualize them. """ cci = cluster_confidence(long_streamlines) # Visualize the streamlines, colored by cci ren = window.Renderer() hue = [0.5, 1]
def compute_measures(args): filename_tuple, no_uniformize = args sft = load_tractogram(filename_tuple[0], filename_tuple[1]) _, dimensions, voxel_size, _ = sft.space_attributes if not no_uniformize: uniformize_bundle_sft(sft) nbr_streamlines = len(sft) if not nbr_streamlines: logging.warning('{} is empty'.format(filename_tuple[0])) return dict(zip(['volume', 'volume_endpoints', 'streamlines_count', 'avg_length', 'std_length', 'min_length', 'max_length', 'span', 'curl', 'diameter', 'elongation', 'surface_area', 'end_surface_area_head', 'end_surface_area_tail', 'radius_head', 'radius_tail', 'irregularity', 'irregularity_of_end_surface_head', 'irregularity_of_end_surface_tail', 'mean_curvature', 'fractal_dimension'], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) streamline_cords = list(sft.streamlines) length_list = list(length(streamline_cords)) length_avg = float(np.average(length_list)) length_std = float(np.std(length_list)) length_min = float(np.min(length_list)) length_max = float(np.max(length_list)) sft.to_vox() sft.to_corner() streamlines = sft.streamlines density = compute_tract_counts_map(streamlines, dimensions) endpoints_density = get_endpoints_density_map(streamlines, dimensions) span_list = list(map(compute_span, streamline_cords)) span = float(np.average(span_list)) curl = length_avg / span volume = np.count_nonzero(density) * np.product(voxel_size) diameter = 2 * np.sqrt(volume / (np.pi * length_avg)) elon = length_avg / diameter roi = np.where(density != 0, 1, density) surf_area = approximate_surface_node(roi) * (voxel_size[0] ** 2) irregularity = surf_area / (np.pi * diameter * length_avg) endpoints_map_head, endpoints_map_tail = \ get_head_tail_density_maps(sft.streamlines, dimensions) endpoints_map_head_roi = \ np.where(endpoints_map_head != 0, 1, endpoints_map_head) endpoints_map_tail_roi = \ np.where(endpoints_map_tail != 0, 1, endpoints_map_tail) end_sur_area_head = \ approximate_surface_node(endpoints_map_head_roi) * (voxel_size[0] ** 2) end_sur_area_tail = \ approximate_surface_node(endpoints_map_tail_roi) * (voxel_size[0] ** 2) endpoints_coords_head = np.array(np.where(endpoints_map_head_roi)).T endpoints_coords_tail = np.array(np.where(endpoints_map_tail_roi)).T radius_head = 1.5 * np.average( np.sqrt(((endpoints_coords_head - np.average( endpoints_coords_head, axis=0)) ** 2).sum(axis=1))) radius_tail = 1.5 * np.average( np.sqrt(((endpoints_coords_tail - np.average( endpoints_coords_tail, axis=0)) ** 2).sum(axis=1))) end_irreg_head = (np.pi * radius_head ** 2) / end_sur_area_head end_irreg_tail = (np.pi * radius_tail ** 2) / end_sur_area_tail fractal_dimension = compute_fractal_dimension(density) curvature_list = np.zeros((nbr_streamlines,)) for i in range(nbr_streamlines): curvature_list[i] = mean_curvature(sft.streamlines[i]) return dict(zip(['volume', 'volume_endpoints', 'streamlines_count', 'avg_length', 'std_length', 'min_length', 'max_length', 'span', 'curl', 'diameter', 'elongation', 'surface_area', 'end_surface_area_head', 'end_surface_area_tail', 'radius_head', 'radius_tail', 'irregularity', 'irregularity_of_end_surface_head', 'irregularity_of_end_surface_tail', 'mean_curvature', 'fractal_dimension'], [volume, np.count_nonzero(endpoints_density) * np.product(voxel_size), nbr_streamlines, length_avg, length_std, length_min, length_max, span, curl, diameter, elon, surf_area, end_sur_area_head, end_sur_area_tail, radius_head, radius_tail, irregularity, end_irreg_head, end_irreg_tail, float(np.mean(curvature_list)), fractal_dimension]))
def fib_lengths_count(stream): lengths = length(stream) return lengths
#ftractogram = dname + 'tractogram.trk' #save .trk #save_trk_old_style(ftractogram, streamlines, affine, fa.shape) #render show_results(streamlines, fa, fa_affine) # In[18]: # threshold on streamline length from dipy.tracking.utils import length lengths = list(length(streamlines)) new_streamlines = [ s for s, l in zip(streamlines, lengths) if l > 2. ] #3.5 # In[19]: # info length streamlines print(len(streamlines)) print(len(new_streamlines)) print(max(length(streamlines))) print(min(length(streamlines))) print(max(length(new_streamlines)))
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')
] return bundle bundle = simulated_bundles() print('This bundle has %d streamlines' % len(bundle)) """ This bundle has 50 streamlines. Using the ``length`` function we can retrieve the lengths of each streamline. Below we show the histogram of the lengths of the streamlines. """ lengths = list(length(bundle)) import matplotlib.pyplot as plt fig_hist, ax = plt.subplots(1) ax.hist(lengths, color='burlywood') ax.set_xlabel('Length') ax.set_ylabel('Count') plt.show() plt.legend() plt.savefig('length_histogram.png') """ .. figure:: length_histogram.png :align: center **Histogram of lengths of the streamlines**