def measure_overlap(static_center, moving_center, show=True, vol_size=(256, 256, 256)): static_center = [downsample(s, 100) for s in static_center] moving_center = [downsample(s, 100) for s in moving_center] vol = np.zeros(vol_size) ci, cj, ck = vol_size[0] / 2, vol_size[1] / 2, vol_size[2] / 2 spts = np.concatenate(static_center, axis=0) spts = np.round(spts).astype(np.int) + np.array([ci, cj, ck]) mpts = np.concatenate(moving_center, axis=0) mpts = np.round(mpts).astype(np.int) + np.array([ci, cj, ck]) for index in spts: i, j, k = index vol[i, j, k] = 1 vol2 = np.zeros(vol_size) for index in mpts: i, j, k = index vol2[i, j, k] = 1 vol_and = np.logical_and(vol, vol2) overlap = np.sum(vol_and) / float(np.sum(vol2)) if show: viz_vol(vol_and) return 100 * overlap
def skeletonize(fdpy,flsc,points=3): dpr=Dpy(fdpy,'r') T=dpr.read_tracks() dpr.close() print len(T) Td=[downsample(t,points) for t in T] C=local_skeleton_clustering(Td,d_thr=10.,points=points) #Tobject=np.array(T,dtype=np.object) #''' #r=fvtk.ren() skeleton=[] for c in C: #color=np.random.rand(3) if C[c]['N']>0: Ttmp=[] for i in C[c]['indices']: Ttmp.append(T[i]) si,s=most_similar_track_mam(Ttmp,'avg') print si,C[c]['N'] C[c]['most']=Ttmp[si] #fvtk.add(r,fvtk.line(Ttmp[si],color)) print len(skeleton) #r=fos.ren() #fos.add(r,fos.line(skeleton,color)) #fos.add(r,fos.line(T,fos.red)) #fvtk.show(r) #''' save_pickle(flsc,C)
def aggregate(self, track_dataset): """ An example implementation of the k-means algorithm implemented in DSI Studio. This function is automatically applied to all TrackDatasets returned from a query. Parameters: ----------- track_dataset:dsi2.streamlines.track_dataset.TrackDataset """ # extract the streamline data tracks = track_dataset.tracks # Make a matrix of downsampled streamlines points = np.array([ downsample(trk, 3).flatten() \ for trk in tracks]) # Calculate the length of each streamline lengths = np.array([len(trk) for trk in tracks]).reshape(-1, 1) # Concatenate the points and the track lengths features = np.hstack((points, lengths)) # Initialize the k-means algorithm kmeans = MiniBatchKMeans(n_clusters=self.k, compute_labels=True) kmeans.fit(features) # Return the labels return kmeans.labels_
def __init__(self,tracks,dist_thr=4.,pts=12): """ Highly efficient trajectory clustering Parameters ----------- tracks : sequence of (N,3) ... (M,3) arrays, trajectories (or tractography or streamlines) dist_thr : float, distance threshold in the space of the tracks pts : int, number of points for simplifying the tracks Methods -------- clustering() returns a dict holding with the clustering result virtuals() gives the virtuals (track centroids) of the clusters exemplars() gives the exemplars (track medoids) of the clusters Citation --------- E.Garyfallidis, "Towards an accurate brain tractography", PhD thesis, 2011 """ if pts!=None: self.tracksd=[downsample(track,pts) for track in tracks] else: self.tracksd=tracks self.clustering=local_skeleton_clustering(self.tracksd,dist_thr) self.virts=None self.exemps=None
def aggregate(self, track_dataset): """ An example implementation of the k-means algorithm implemented in DSI Studio. This function is automatically applied to all TrackDatasets returned from a query. Parameters: ----------- track_dataset:dsi2.streamlines.track_dataset.TrackDataset """ # extract the streamline data tracks = track_dataset.tracks # Make a matrix of downsampled streamlines points = np.array([ downsample(trk, 3).flatten() \ for trk in tracks]) # Calculate the length of each streamline lengths = np.array([len(trk) for trk in tracks]).reshape(-1,1) # Concatenate the points and the track lengths features = np.hstack((points, lengths)) # Initialize the k-means algorithm kmeans = MiniBatchKMeans(n_clusters=self.k, compute_labels=True) kmeans.fit(features) # Return the labels return kmeans.labels_
def __init__(self, tracks, dist_thr=4., pts=12): """ Highly efficient trajectory clustering Parameters ----------- tracks : sequence of (N,3) ... (M,3) arrays, trajectories (or tractography or streamlines) dist_thr : float, distance threshold in the space of the tracks pts : int, number of points for simplifying the tracks Methods -------- clustering() returns a dict holding with the clustering result virtuals() gives the virtuals (track centroids) of the clusters exemplars() gives the exemplars (track medoids) of the clusters Citation --------- E.Garyfallidis, "Towards an accurate brain tractography", PhD thesis, 2011 """ self.dist_thr = dist_thr self.pts = pts if pts != None: self.tracksd = [downsample(track, self.pts) for track in tracks] else: self.tracksd = tracks self.clustering = local_skeleton_clustering(self.tracksd, self.dist_thr) self.virts = None self.exemps = None
def __init__(self,tracks,num_clusters=10,pts = 12): """ Highly efficient trajectory clustering Parameters ----------- tracks : sequence of (N,3) ... (M,3) arrays, trajectories (or tractography or streamlines) num_clusters : int, number of clusters of the tracks Methods -------- clustering() returns a dict holding with the clustering result virtuals() gives the virtuals (track centroids) of the clusters exemplars() gives the exemplars (track medoids) of the clusters Citation --------- E.Garyfallidis, "Towards an accurate brain tractography", PhD thesis, 2012 """ self.num_clusters = num_clusters self.pts = pts if pts!=None: self.tracksd=[downsample(track,self.pts) for track in tracks] else: self.tracksd=tracks self.clustering=kmeans(self.tracksd, self.num_clusters) self.virts=None self.exemps=None
def resample_streamlines(streamlines, num_points=0, arc_length=False): """ Resample streamlines using number of points per streamline Parameters ---------- streamlines: list List of list of 3D points. num_points: int Number of points per streamline in the output. arc_length: bool Whether to downsample using arc length parametrization. Return ------ resampled_streamlines: list List of resampled streamlines. """ resampled_streamlines = [] for streamline in streamlines: if arc_length: line = set_number_of_points(streamline, num_points) else: line = downsample(streamline, num_points) resampled_streamlines.append(line) return resampled_streamlines
def freeze(self): print( "Freezing current expanded real tracks, then doing QB on them, then restarting." ) print("Selected virtuals: %s" % self.selected) tracks_frozen = [] tracks_frozen_ids = [] for tid in self.selected: print tid part_tracks = self.qb.label2tracks(self.tracks, tid) part_tracks_ids = self.qb.label2tracksids(tid) print("virtual %s represents %s tracks." % (tid, len(part_tracks))) tracks_frozen += part_tracks tracks_frozen_ids += part_tracks_ids print "frozen tracks size:", len(tracks_frozen) print "Computing quick bundles...", self.unselect_track('all') self.tracks = tracks_frozen self.tracks_ids = self.tracks_ids[ tracks_frozen_ids] # range(len(self.tracks)) root = Tkinter.Tk() root.wm_title('QuickBundles threshold') ts = ThresholdSelector(root, default_value=self.qb.dist_thr / 2.0) root.wait_window() #print "Threshold value ",ts.value #self.qb = QuickBundles(self.tracks, dist_thr=qb.dist_thr/2., pts=self.qb.pts) self.qb = QuickBundles(self.tracks, dist_thr=ts.value, pts=self.qb.pts) #self.qb.dist_thr = qb.dist_thr/2. self.qb.dist_thr = ts.value if self.reps == 'virtuals': self.virtuals = qb.virtuals() if self.reps == 'exemplars': self.virtuals, self.ex_ids = self.qb.exemplars() print len(self.virtuals), 'virtuals' self.virtuals_buffer, self.virtuals_colors, self.virtuals_first, self.virtuals_count = self.compute_buffers( self.virtuals, self.virtuals_alpha) #compute buffers self.tracks_buffer, self.tracks_colors, self.tracks_first, self.tracks_count = self.compute_buffers( self.tracks, self.tracks_alpha) # self.unselect_track('all') self.selected = [] self.old_color = {} self.expand = False self.history.append([ self.qb, self.tracks, self.tracks_ids, self.virtuals_buffer, self.virtuals_colors, self.virtuals_first, self.virtuals_count, self.tracks_buffer, self.tracks_colors, self.tracks_first, self.tracks_count ]) if self.vol_shape is not None: print("Shifting!") self.virtuals_shifted = [ downsample(t + np.array(self.vol_shape) / 2., 30) for t in self.virtuals ] else: self.virtuals_shifted = None
def test_downsample_deprecated(): with warnings.catch_warnings(record=True) as cw: warnings.simplefilter("always", DeprecationWarning) streamline = [np.array([[0, 0, 0], [1, 1, 1]])] streamline_12 = tm.downsample(streamline, 12) npt.assert_equal(len(streamline_12[0]), 12) npt.assert_(issubclass(cw[0].category, DeprecationWarning))
def __init__(self, name,qb, tracks, reps='exemplars',colors=None, vol_shape=None, virtuals_line_width=5.0, tracks_line_width=2.0, virtuals_alpha=1.0, tracks_alpha=0.6, affine=None, verbose=False): """TrackLabeler is meant to explore and select subsets of the tracks. The exploration occurs through QuickBundles (qb) in order to simplify the scene. """ super(StreamlineLabeler, self).__init__(name) if affine is None: self.affine = np.eye(4, dtype = np.float32) else: self.affine = affine self.mouse_x=None self.mouse_y=None self.cache = {} self.qb = qb self.reps = reps #virtual tracks if self.reps=='virtuals': self.virtuals=qb.virtuals() if self.reps=='exemplars': self.virtuals,self.ex_ids = qb.exemplars() self.virtuals_alpha = virtuals_alpha self.virtuals_buffer, self.virtuals_colors, self.virtuals_first, self.virtuals_count = self.compute_buffers(self.virtuals, self.virtuals_alpha) #full tractography (downsampled at 12 pts per track) self.tracks = tracks self.tracks_alpha = tracks_alpha self.tracks_ids = np.arange(len(self.tracks), dtype=np.int) self.tracks_buffer, self.tracks_colors, self.tracks_first, self.tracks_count = self.compute_buffers(self.tracks, self.tracks_alpha) #calculate boundary box for entire tractography self.min = np.min(self.tracks_buffer,axis=0) self.max = np.max(self.tracks_buffer,axis=0) self.vertices=self.tracks_buffer #coord1 = np.array([self.tracks_buffer[:,0].min(),self.tracks_buffer[:,1].min(),self.tracks_buffer[:,2].min()], dtype = 'f4') #coord2 = np.array([self.tracks_buffer[:,0].max(),self.tracks_buffer[:,1].max(),self.tracks_buffer[:,2].max()], dtype = 'f4') #self.make_aabb((coord1,coord2),0) #show size of tractography buffer print('MBytes %f' % (self.tracks_buffer.nbytes/2.**20,)) self.position = (0,0,0) #buffer for selected virtual tracks self.selected = [] self.virtuals_line_width = virtuals_line_width self.tracks_line_width = tracks_line_width self.old_color = {} self.hide_virtuals = False self.expand = False self.verbose = verbose self.tracks_visualized_first = np.array([], dtype='i4') self.tracks_visualized_count = np.array([], dtype='i4') self.history = [[self.qb, self.tracks, self.tracks_ids, self.virtuals_buffer, self.virtuals_colors, self.virtuals_first, self.virtuals_count, self.tracks_buffer, self.tracks_colors, self.tracks_first, self.tracks_count]] #shifting of track is necessary for dipy.tracking.vox2track.track_counts #we also upsample using 30 points in order to increase the accuracy of track counts self.vol_shape = vol_shape if self.vol_shape !=None: #self.tracks_shifted =[t+np.array(vol_shape)/2. for t in self.tracks] self.virtuals_shifted =[downsample(t+np.array(self.vol_shape)/2.,30) for t in self.virtuals] else: #self.tracks_shifted=None self.virtuals_shifted=None
def freeze(self): print("Freezing current expanded real tracks, then doing QB on them, then restarting.") print("Selected virtuals: %s" % self.selected) tracks_frozen = [] tracks_frozen_ids = [] for tid in self.selected: print tid part_tracks = self.qb.label2tracks(self.tracks, tid) part_tracks_ids = self.qb.label2tracksids(tid) print("virtual %s represents %s tracks." % (tid, len(part_tracks))) tracks_frozen += part_tracks tracks_frozen_ids += part_tracks_ids print "frozen tracks size:", len(tracks_frozen) print "Computing quick bundles...", self.unselect_track('all') self.tracks = tracks_frozen self.tracks_ids = self.tracks_ids[tracks_frozen_ids] # range(len(self.tracks)) root = Tkinter.Tk() root.wm_title('QuickBundles threshold') ts = ThresholdSelector(root, default_value=self.qb.dist_thr/2.0) root.wait_window() #print "Threshold value ",ts.value #self.qb = QuickBundles(self.tracks, dist_thr=qb.dist_thr/2., pts=self.qb.pts) self.qb = QuickBundles(self.tracks, dist_thr=ts.value, pts=self.qb.pts) #self.qb.dist_thr = qb.dist_thr/2. self.qb.dist_thr = ts.value if self.reps=='virtuals': self.virtuals=qb.virtuals() if self.reps=='exemplars': self.virtuals,self.ex_ids = self.qb.exemplars() print len(self.virtuals), 'virtuals' self.virtuals_buffer, self.virtuals_colors, self.virtuals_first, self.virtuals_count = self.compute_buffers(self.virtuals, self.virtuals_alpha) #compute buffers self.tracks_buffer, self.tracks_colors, self.tracks_first, self.tracks_count = self.compute_buffers(self.tracks, self.tracks_alpha) # self.unselect_track('all') self.selected = [] self.old_color = {} self.expand = False self.history.append([self.qb, self.tracks, self.tracks_ids, self.virtuals_buffer, self.virtuals_colors, self.virtuals_first, self.virtuals_count, self.tracks_buffer, self.tracks_colors, self.tracks_first, self.tracks_count]) if self.vol_shape is not None: print("Shifting!") self.virtuals_shifted = [downsample(t + np.array(self.vol_shape) / 2., 30) for t in self.virtuals] else: self.virtuals_shifted = None
def streamline_based_registration(source_tractography_streamlines, target_tractography_streamlines, subject_pair): intersection_voxel_list = [] target_voxel_list = [] n_points = 20 srr = StreamlineLinearRegistration() SAr = [downsample(i, n_points) for i in source_tractography] SBr = [downsample(i, n_points) for i in target_tractography] srm = srr.optimize(static=SBr, moving=SAr) transformed_tractography = srm.transform(source_tractography) print len(transformed_tractography) temp_index = 0 for i in range(len(source_tractography_streamlines)): voxel_and, voxel_target = voxel_measure( transformed_tractography[ temp_index:temp_index + source_tractography_streamlines[ source + '_' + subject_tracts[str(subject_pair)][i]][1]], target_tractography_streamlines[ target + '_' + subject_tracts[str(subject_pair)][i]][0]) temp_index = temp_index + source_tractography_streamlines[ source + '_' + subject_tracts[str(subject_pair)][i]][1] intersection_voxel_list.append(voxel_and) target_voxel_list.append(voxel_target) total_intersection_voxel_list = np.sum(np.array(intersection_voxel_list)) total_target_voxel_list = np.sum(np.array(target_voxel_list)) print "Number of voxel per tract" print intersection_voxel_list, target_voxel_list print "Number of voxel" print total_intersection_voxel_list, total_target_voxel_list TDA_all_voxel_registration = np.divide(total_intersection_voxel_list, total_target_voxel_list) print "Modified-TDR-for-all" print TDA_all_voxel_registration
def show_zero_level(r,bundle,dist): T=[downsample(b,12) for b in bundle] C=local_skeleton_clustering(T,dist) vs=[] colors=np.zeros((len(T),3)) for c in C: vs.append(C[c]['hidden']/C[c]['N']) color=np.random.rand(3,) #fvtk.add(r,fvtk.line(vs,color,linewidth=4.5)) for i in C[c]['indices']: colors[i]=color fvtk.label(r,text=str(i),pos=(bundle[i][-1]),scale=(.5,.5,.5),color=(color[0],color[1],color[2])) fvtk.add(r,fvtk.line(T,colors,linewidth=2.))
def half_split_comparisons(): res = {} for id in range(len(tractography_sizes)): res[id] = {} first, second = split_halves(id) res[id]["lengths"] = [len(first), len(second)] print len(first), len(second) first_qb = QuickBundles(first, qb_threshold, downsampling) n_clus = first_qb.total_clusters res[id]["nclusters"] = n_clus print "QB for first half has", n_clus, "clusters" second_down = [downsample(s, downsampling) for s in second] matched_random = get_random_streamlines(first_qb.downsampled_tracks(), n_clus) neighbours_first = count_close_tracks(first_qb.virtuals(), first_qb.downsampled_tracks(), adjacency_threshold) neighbours_second = count_close_tracks(first_qb.virtuals(), second_down, adjacency_threshold) neighbours_random = count_close_tracks(matched_random, second_down, adjacency_threshold) maxclose = np.int(np.max(np.hstack((neighbours_first, neighbours_second, neighbours_random)))) # The numbers of tracks 0, 1, 2, ... 'close' subset tracks counts = np.array( [ ( np.int(n), len(find(neighbours_first == n)), len(find(neighbours_second == n)), len(find(neighbours_random == n)), ) for n in range(maxclose + 1) ], dtype="f", ) totals = np.sum(counts[:, 1:], axis=0) res[id]["totals"] = totals res[id]["counts"] = counts # print totals # print counts missed_fractions = counts[0, 1:] / totals res[id]["missed_fractions"] = missed_fractions means = np.sum(counts[:, 1:] * counts[:, [0, 0, 0]], axis=0) / totals # print means res[id]["means"] = means # print res return res
def plot_timings(): #dir='/home/eg309/Data/LSC_limits/full_1M' dir='/tmp/full_1M' fs=['.npy','_2.npy','_3.npy','_4.npy','_5.npy']#,'_6.npy','_7.npy','_8.npy','_9.npy','_10.npy'] T=[] for f in fs: fs1=dir+f T+=change_dtype(list(np.load(fs1))) #return T T=T[:100000] print len(T) #dists=[4.,6.,8.,10.] dists=[8.] #pts=[3,6,12,18] pts=[12] #sub=10**5 sub=10**3 res={} for p in pts: print p res[p]={} for d in dists: print d res[p][d]={} res[p][d]['time']=[] res[p][d]['len']=[] step=0 while step <= len(T): print step Td=[downsample(t,p) for t in T[0:step+sub]] t1=time() C=local_skeleton_clustering(Td,d) t2=time() res[p][d]['time'].append(t2-t1) res[p][d]['len'].append(len(C)) step=step+sub save_pickle('/tmp/res.pkl',res) print('Result saved in /tmp/res.pkl') #return res save_pickle('/tmp/res.pkl',res)
def see_tracks(fdpy,N=2000): dpr=Dpy(fdpy,'r') #T=dpr.read_tracksi(range(N)) T=dpr.read_tracks() dpr.close() T=[downsample(t,5) for t in T] r=fvtk.ren() colors=np.ones((len(T),3)).astype('f4') for (i,c) in enumerate(T): orient=c[0]-c[-1] orient=np.abs(orient/np.linalg.norm(orient)) colors[i,:3]=orient fvtk.add(r,fvtk.line(T,colors,opacity=0.5)) #fos.add(r,fos.sphere((0,0,0),10)) fvtk.show(r)
def generate_random_tracks(rand_no): img=nib.load(fbet) data=img.get_data() affine=img.get_affine() bvals=np.loadtxt(fbvals) bvecs=np.loadtxt(fbvecs).T t=time() gqs=GeneralizedQSampling(data,bvals,bvecs) print 'gqs time',time()-t,'s' for (i,sds) in enumerate(seeds): print i,sds t=time() eu=EuDX(gqs.qa(),gqs.ind(),seeds=sds,a_low=0.0239) T=[downsample(e,12) for e in eu] np.save('/tmp/random_T.npy',np.array(T,dtype=np.object)) ################### print time()-t del T print outs
def generate_skeletons(): img=nib.load(fbet) data=img.get_data() affine=img.get_affine() bvals=np.loadtxt(fbvals) bvecs=np.loadtxt(fbvecs).T t=time() gqs=GeneralizedQSampling(data,bvals,bvecs) print 'gqs time',time()-t,'s' for (i,sds) in enumerate(seeds): print i,sds t=time() eu=EuDX(gqs.qa(),gqs.ind(),seeds=sds,a_low=0.0239) T=[downsample(e,12) for e in eu] #np.save(dout+outs[i]+'.npy',np.array(T,dtype=np.object)) C=local_skeleton_clustering(T,4.) save_pickle(dout+outs[i]+'.skl',C) print time()-t del T print outs
def __init__(self,tracks,dist_thr=4.,pts=12): """ Highly efficient trajectory clustering Parameters ----------- tracks : sequence of (N,3) ... (M,3) arrays, trajectories (or tractography or streamlines) dist_thr : float, distance threshold in the space of the tracks pts : int, number of points for simplifying the tracks Methods -------- clustering() returns a dict holding with the clustering result virtuals() gives the virtuals (track centroids) of the clusters exemplars() gives the exemplars (track medoids) of the clusters Citation --------- E.Garyfallidis, "Towards an accurate brain tractography", PhD thesis, 2012 """ warn(DeprecationWarning("Class 'dipy.segment.quickbundles.QuickBundles'" " is deprecated, use module " "'dipy.segment.clustering.QuickBundles'" " instead")) self.dist_thr = dist_thr self.pts = pts if pts!=None: self.tracksd=[downsample(track,self.pts) for track in tracks] else: self.tracksd=tracks self.clustering=local_skeleton_clustering(self.tracksd, self.dist_thr) self.virts=None self.exemps=None
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 __init__(self, tracks, dist_thr=4., pts=12): """ Highly efficient trajectory clustering [Garyfallidis12]_. Parameters ---------- tracks : sequence of (N,3) ... (M,3) arrays trajectories (or tractography or streamlines) dist_thr : float distance threshold in the space of the tracks pts : int number of points for simplifying the tracks Methods ------- clustering() returns a dict holding with the clustering result virtuals() gives the virtuals (track centroids) of the clusters exemplars() gives the exemplars (track medoids) of the clusters References ---------- .. [Garyfallidis12] Garyfallidis E. et al., QuickBundles a method for tractography simplification, Frontiers in Neuroscience, vol 6, no 175, 2012. """ warn(DeprecationWarning(deprecation_msg)) self.dist_thr = dist_thr self.pts = pts if pts is not None: self.tracksd = [downsample(track, self.pts) for track in tracks] else: self.tracksd = tracks self.clustering = local_skeleton_clustering(self.tracksd, self.dist_thr) self.virts = None self.exemps = None
S = np.dot(Rot, S.T).T + np.array([1, 0, 0]) print "Dummy translated" print invariant_angles(S) from dipy.viz import fvtk r = fvtk.ren() fvtk.add(r, fvtk.line(Sinit, fvtk.red)) fvtk.add(r, fvtk.line(S, fvtk.green)) fvtk.add(r, fvtk.axes()) fvtk.show(r) # helix theta = 2 * np.pi * np.linspace(0, 2, 100) x = np.cos(theta) y = np.sin(theta) z = theta / (2 * np.pi) Shel = np.vstack((x, y, z)).T from dipy.tracking.metrics import downsample Shel = downsample(Shel, 12) print "Helix standard" print invariant_angles(Shel) Shel2 = np.dot(Rot, Shel.T).T print "Helix translated" print invariant_angles(Shel2)
def subsample_streamlines(streamlines, min_length=0., max_length=0., max_streamlines=0, num_points=0, arc_length=False, rng=None): """ Parameters ---------- streamlines: list List of list of 3D points. min_length: float Minimum length of streamlines. max_length: float Maximum length of streamlines. max_streamlines: int Maximum number of streamlines to output. num_points: int Number of points per streamline in the output. arc_length: bool Whether to downsample using arc length parametrization. rng: RandomState object Random number generator to use for shuffling the data. By default, a constant seed is used. Return ------ average: list List of subsampled streamlines. """ if rng is None: rng = np.random.RandomState(1234) num_streamlines = len(streamlines) if max_streamlines <= 0: max_streamlines = num_streamlines lengths = np.zeros(num_streamlines) for i in np.arange(num_streamlines): lengths[i] = dipy.tracking.metrics.length(streamlines[i]) ind = range(0, num_streamlines) rng.shuffle(ind) results = [] while len(ind) > 0 and len(results) < max_streamlines: i = ind.pop() if (lengths[i] >= min_length and (max_length <= 0. or lengths[i] <= max_length)): if num_points: if arc_length: line = set_number_of_points(streamlines[i], num_points) else: line = downsample(streamlines[i], num_points) results.append(line) else: results.append(streamlines[i]) return results
print len(bun3) """ r=fvtk.ren() r.SetBackground(1,1,1.) fvtk.add(r,fvtk.line(bundle,fvtk.red,linewidth=3)) fvtk.add(r,fvtk.line(bundle3,fvtk.green,linewidth=3)) fvtk.add(r,fvtk.line(bundle4,fvtk.blue,linewidth=3)) fvtk.show(r,size=(800,800)) from LSC_limits import bring_virtuals Td=[downsample(t,80) for t in bun3] C8=local_skeleton_clustering(Td,8) vs,ls,tot=bring_virtuals(C8) vs2=shift(vs,np.array([0,0,0],'f4')) """ wi2=Window(bgcolor=(1.,1.,1.,1.),width=1000,height=1000) wi3=Window(bgcolor=(1.,1.,1.,1.),width=1000,height=1000) w2=World() w3=World() wi2.attach(w2) wi3.attach(w3) w2.add(line(vs2,np.array([[1,0,1,1],[0,1,0,1]],'f4'))) """
Next, let's find the number of points that each streamline has. """ n_pts = [len(streamline) for streamline in bundle] """ Often, streamlines are represented with more points than what is actually necessary for specific applications. Also, sometimes every streamline has different number of points which could be of a trouble for some algorithms . The function ``downsample`` can be used to set the number of points of a streamline at a specific number and at the same time enforce that all the segments of the streamline will have equal length. """ bundle_downsampled = [downsample(s, 12) for s in bundle] n_pts_ds = [len(s) for s in bundle_downsampled] """ Alternatively, the function ``approx_polygon_track`` allows to reduce the number of points so that they are more points in curvy regions and less points in less curvy regions. In contrast with ``downsample`` it does not enforce that segments should be of equal size. """ bundle_downsampled2 = [approx_polygon_track(s, 0.25) for s in bundle] n_pts_ds2 = [len(streamline) for streamline in bundle_downsampled2] """ Both, ``downsample`` and ``approx_polygon_track`` can be thought as methods for lossy compression of streamlines.
Load Trackvis file for *Fornix*: """ streams, hdr = tv.read(fname) """ Copy tracks: """ T = [i[0] for i in streams] #T=T[:1000] """ Downsample tracks to just 3 points: """ tracks = [tm.downsample(t, 3) for t in T] """ Delete unnecessary data: """ del streams, hdr """ Perform Local Skeleton Clustering (LSC) with a 5mm threshold: """ now = time.clock() C = td.local_skeleton_clustering(tracks, d_thr=5) print('Done in %.2f s' % (time.clock() - now, )) """ Reduce the number of points for faster visualization using the ``approx_polygon_track`` algorithm which retains points depending on how much they are need to define the shape of the track: """
def vectorize_streamlines(streamlines, no_pts): """ Resample all streamlines to the same number of points """ return [downsample(s, no_pts) for s in streamlines]
def main(): parser = buildArgsParser() args = parser.parse_args() if not os.path.isfile(args.tracts): parser.error("Tracts file: {0} does not exist.".format(args.tracts)) if not os.path.isfile(args.aparc): parser.error("Label file: {0} does not exist.".format(args.aparc)) if not os.path.isfile(args.labels): parser.error("Requested region file: {0} does not exist.".format( args.labels)) if not os.path.isfile(args.lut): parser.error("Freesurfer LUT file: {0} does not exist.".format( args.lut)) if not os.path.isfile(args.faimage): parser.error("FA Image file: {0} does not exist.".format(args.faimage)) if not os.path.isfile(args.mdimage): parser.error("MD Image file: {0} does not exist.".format(args.mdimage)) # Validate that tracts can be processed if not validate_coordinates(args.aparc, args.tracts, nifti_compliant=True): parser.error("The tracts file contains points that are invalid.\n" + "Use the remove_invalid_coordinates.py script to clean.") # Load label image labels_img = nib.load(args.aparc) full_labels = labels_img.get_data().astype('int') # Load fibers tract_format = tc.detect_format(args.tracts) tract = tract_format(args.tracts, args.aparc) affine = compute_affine_for_dipy_functions(args.aparc, args.tracts) #load FA and MD image fa_img = nib.load(args.faimage) fa_data = fa_img.get_data() md_img = nib.load(args.mdimage) md_data = md_img.get_data() # ========= processing streamlines ================= fiberlen_range = np.asarray([args.minlen, args.maxlen]) streamlines = [t for t in tract] print "Subject " + args.sub_id + " has " + str( len(streamlines)) + " raw streamlines." f_streamlines = [] #filtered streamlines lenrecord = [] idx = 0 for sl in streamlines: # Avoid streamlines having only one point, as they crash the # Dipy connectivity matrix function. if sl.shape[0] > 1: flen = length(sl) # get fibers having length between 20mm and 200mm if (flen > fiberlen_range[0]) & (flen < fiberlen_range[1]): f_streamlines.append(sl) lenrecord.append(flen) idx = idx + 1 print "Subject " + args.sub_id + " has " + str( idx) + " streamlines with lengths between " + str( args.minlen) + " and " + str(args.maxlen) + "." # ============= process the parcellation ===================== dilation_para = np.array([args.dilation_dist, args.dilation_windsize]) # Compute the mapping from label name to label id label_id_mapping = compute_labels_map(args.lut) # Find which labels were requested by the user. requested_labels_mapping = compute_requested_labels( args.labels, label_id_mapping) # Filter to keep only needed ones filtered_labels = np.zeros(full_labels.shape, dtype='int') for label_val in requested_labels_mapping: if sum(sum(sum(full_labels == label_val))) == 0: print label_val print requested_labels_mapping[label_val] filtered_labels[full_labels == label_val] = label_val #cortex band dilation dilated_labels = cortexband_dilation_wm(filtered_labels, full_labels, dilation_para) # Reduce the range of labels to avoid a sparse matrix, # because the ids of labels can range from 0 to the 12000's. reduced_labels, labels_lut = dpu.reduce_labels(filtered_labels) reduced_dilated_labels, labels_lut = dpu.reduce_labels(dilated_labels) # Compute connectivity matrix and extract the fibers M, grouping = nconnectivity_matrix(f_streamlines, reduced_dilated_labels, fiberlen_range, args.cnpoint, affine=affine, symmetric=True, return_mapping=True, mapping_as_streamlines=True) Msize = len(M) CM_before_outlierremove = M[1:, 1:] nstream_bf = np.sum(CM_before_outlierremove) print args.sub_id + ' ' + str( nstream_bf ) + ' streamlines in the connectivity matrix before outlier removal.' #===================== process the streamlines ============= print 'Processing streamlines to remove outliers ..............' outlier_para = 3 average_thrd = 8 M_after_ourlierremove = np.zeros((Msize, Msize)) #downsample streamlines cell_streamlines = [] cell_id = [] for i in range(1, Msize): for j in range(i + 1, Msize): tmp_streamlines = grouping[i, j] tmp_streamlines = list(tmp_streamlines) #downsample tmp_streamlines_downsampled = [ downsample(s, 100) for s in tmp_streamlines ] #remove outliers, we need to rewrite the QuickBundle method to speed up this process qb = QuickBundles(threshold=average_thrd) clusters = qb.cluster(tmp_streamlines_downsampled) outlier_clusters = clusters < outlier_para #small clusters nonoutlier_clusters = clusters[np.logical_not(outlier_clusters)] tmp_nonoutlier_index = [] for tmp_cluster in nonoutlier_clusters: tmp_nonoutlier_index = tmp_nonoutlier_index + tmp_cluster.indices clean_streamline_downsampled = [ tmp_streamlines_downsampled[ind] for ind in tmp_nonoutlier_index ] cell_streamlines.append(clean_streamline_downsampled) cell_id.append([i, j]) M_after_ourlierremove[i, j] = len(clean_streamline_downsampled) CM_after_ourlierremove = M_after_ourlierremove[1:, 1:] nstream_bf = np.sum(CM_after_ourlierremove) print args.sub_id + ' ' + str( nstream_bf ) + ' streamlines in the connectivity matrix after outlier removal.' #save streamlines and count matrix cmCountMatrix_fname = args.sub_id + "_" + args.pre + "_cm_count_raw.mat" cmCountMatrix_processed_fname = args.sub_id + "_" + args.pre + "_cm_count_processed.mat" cmStreamlineMatrix_fname = args.sub_id + "_" + args.pre + "_cm_streamlines.mat" reduced_labels_fname = args.sub_id + "_" + args.pre + "_reduced_labels.nii.gz" dilated_labels_fname = args.sub_id + "_" + args.pre + "_dilated_labels.nii.gz" RoiInfo_fname = args.sub_id + "_" + args.pre + "_RoiInfo.mat" # save the raw count matrix CM = M[1:, 1:] sio.savemat(cmCountMatrix_fname, {'cm': CM}) sio.savemat(cmCountMatrix_processed_fname, {'cm': CM_after_ourlierremove}) # save the streamline matrix sio.savemat(cmStreamlineMatrix_fname, {'slines': cell_streamlines}) sio.savemat(RoiInfo_fname, {'ROIinfo': cell_id}) print args.sub_id + 'cell_streamlines.mat, ROIinfo.mat has been saved' filtered_labels_img = nib.Nifti1Image(filtered_labels, labels_img.get_affine(), labels_img.get_header()) nib.save(filtered_labels_img, reduced_labels_fname) print args.sub_id + 'filtered labels have saved' dilated_labels_img = nib.Nifti1Image(dilated_labels, labels_img.get_affine(), labels_img.get_header()) nib.save(dilated_labels_img, dilated_labels_fname) print args.sub_id + 'dilated labels have saved' # ===================== process the streamlines and extract features ============= cm_fa_curve = fa_extraction_use_cellinput(cell_streamlines, cell_id, fa_data, Msize, affine=affine) (tmp_cm_fa_mean, tmp_cm_fa_max, cm_count) = fa_mean_extraction(cm_fa_curve, Msize) # extract MD values along the streamlines cm_md_curve = fa_extraction_use_cellinput(cell_streamlines, cell_id, md_data, Msize, affine=affine) (tmp_cm_md_mean, tmp_cm_md_max, testcm) = fa_mean_extraction(cm_md_curve, Msize) #connected surface area # extract the connective volume ratio (tmp_cm_volumn, tmp_cm_volumn_ratio) = rois_connectedvol_cellinput(reduced_labels, Msize, cell_streamlines, cell_id, affine=affine) #fiber length tmp_connectcm_len = rois_fiberlen_cellinput(Msize, cell_streamlines) #save cm features cm_md_mean = tmp_cm_md_mean[1:, 1:] cm_md_max = tmp_cm_md_max[1:, 1:] cm_fa_mean = tmp_cm_fa_mean[1:, 1:] cm_fa_max = tmp_cm_fa_max[1:, 1:] cm_volumn = tmp_cm_volumn[1:, 1:] cm_volumn_ratio = tmp_cm_volumn_ratio[1:, 1:] connectcm_len = tmp_connectcm_len[1:, 1:] sio.savemat(args.pre + "_cm_processed_mdmean_100.mat", {'cm_mdmean': cm_md_mean}) sio.savemat(args.pre + "_cm_processed_mdmax_100.mat", {'cm_mdmax': cm_md_max}) sio.savemat(args.pre + "_cm_processed_famean_100.mat", {'cm_famean': cm_fa_mean}) sio.savemat(args.pre + "_cm_processed_famax_100.mat", {'cm_famax': cm_fa_max}) sio.savemat(args.pre + "_cm_processed_volumn_100.mat", {'cm_volumn': cm_volumn}) sio.savemat(args.pre + "_cm_processed_volumn_ratio_100.mat", {'cm_volumn_ratio': cm_volumn_ratio}) sio.savemat(args.pre + "_cm_processed_volumn_ratio_100.mat", {'cm_len': connectcm_len}) # save the diffusion functions matrix cell_fa = [] for i in range(1, Msize): for j in range(i + 1, Msize): tmp_fa = cm_fa_curve[i, j] tmp_fa = list(tmp_fa) cell_fa.append(tmp_fa) sio.savemat(args.pre + "_cm_processed_sfa_100.mat", {'sfa': cell_fa}) print 'cell_fa.mat, fa_roiinfo.mat have been saved' cell_md = [] for i in range(1, Msize): for j in range(i + 1, Msize): tmp_md = cm_md_curve[i, j] tmp_md = list(tmp_md) cell_md.append(tmp_md) sio.savemat(args.pre + "_cm_processed_smd_100.mat", {'smd': cell_md})
def main(): parser = buildArgsParser() args = parser.parse_args() if not os.path.isfile(args.tracts): parser.error("Tracts file: {0} does not exist.".format(args.tracts)) if not os.path.isfile(args.org_aparc): parser.error("Original label file: {0} does not exist.".format( args.org_aparc)) if not os.path.isfile(args.dilated_aparc): parser.error("Dilated label file: {0} does not exist.".format( args.dilated_aparc)) if not os.path.isfile(args.subcortical_labels): parser.error("Requested region file: {0} does not exist.".format( args.subcortical_labels)) if not os.path.isfile(args.lut): parser.error("Freesurfer LUT file: {0} does not exist.".format( args.lut)) if not os.path.isfile(args.faimage): parser.error("FA Image file: {0} does not exist.".format(args.faimage)) if not os.path.isfile(args.mdimage): parser.error("MD Image file: {0} does not exist.".format(args.mdimage)) # Validate that tracts can be processed if not validate_coordinates( args.org_aparc, args.tracts, nifti_compliant=True): parser.error("The tracts file contains points that are invalid.\n" + "Use the remove_invalid_coordinates.py script to clean.") # Load label images org_labels_img = nib.load(args.org_aparc) org_labels_data = org_labels_img.get_data().astype('int') dilated_labels_img = nib.load(args.dilated_aparc) dilated_labels_data = dilated_labels_img.get_data().astype('int') # Load fibers tract_format = tc.detect_format(args.tracts) tract = tract_format(args.tracts, args.org_aparc) affine = compute_affine_for_dipy_functions(args.org_aparc, args.tracts) #load FA and MD image fa_img = nib.load(args.faimage) fa_data = fa_img.get_data() md_img = nib.load(args.mdimage) md_data = md_img.get_data() # ========= processing streamlines ================= fiberlen_range = np.asarray([args.minlen, args.maxlen]) streamlines = [t for t in tract] print "Subjeect " + args.sub_id + " has " + str( len(streamlines)) + " streamlines." f_streamlines = [] #filtered streamlines lenrecord = [] idx = 0 for sl in streamlines: # Avoid streamlines having only one point, as they crash the # Dipy connectivity matrix function. if sl.shape[0] > 1: flen = length(sl) # get fibers having length between 20mm and 200mm if (flen > fiberlen_range[0]) & (flen < fiberlen_range[1]): f_streamlines.append(sl) lenrecord.append(flen) idx = idx + 1 print "Subject " + args.sub_id + " has " + str( idx - 1) + " streamlines after filtering." # ============= process the parcellation ===================== # Compute the mapping from label name to label id label_id_mapping = compute_labels_map(args.lut) # Find which labels were requested by the user. requested_labels_mapping = compute_requested_labels( args.subcortical_labels, label_id_mapping) # Increase aparc_filtered_labels with subcortical regions # 17 LH_Hippocampus # 53 RH_Hippocampus # 11 LH_Caudate # 50 RH_Caudate # 12 LH_Putamen # 51 RH_Putamen # 13 LH_Pallidum # 52 RH_Pallidum # 18 LH_Amygdala # 54 RH_Amygdala # 26 LH_Accumbens # 58 RH_Accumbens # 10 LH_Thalamus-Proper # 49 RH_Thalamus-Proper # 4 LH_Lateral-Ventricle # 43 RH_Lateral-Ventricle # 8 LH_Cerebellum-Cortex # 47 RH_Cerebellum-Cortex # # 16 _Brain-Stem (# 7,8 LH_Cerebellum) (# 41 RH_Cerebellum) sub_cortical_labels = [ 17, 53, 11, 50, 12, 51, 13, 52, 18, 54, 26, 58, 10, 49, 4, 43, 8, 47 ] # 16 Brain_Stem_cerebellum = [16] #1 aparc_filtered_labels = dilated_labels_data for label_val in requested_labels_mapping: if sum(sum(sum(org_labels_data == label_val))) == 0: print label_val print requested_labels_mapping[label_val] aparc_filtered_labels[org_labels_data == label_val] = label_val for brain_stem_id in Brain_Stem_cerebellum: if sum(sum(sum(org_labels_data == brain_stem_id))) == 0: print 'no labels of ' print brain_stem_id aparc_filtered_labels[ org_labels_data == brain_stem_id] = 99 # let the brain stem's label be 30 # Reduce the range of labels to avoid a sparse matrix, # because the ids of labels can range from 0 to the 12000's. reduced_dilated_labels, labels_lut = dpu.reduce_labels( aparc_filtered_labels) #dilated_labels_fname = args.sub_id + "_" + args.pre + "_dilated_allbrain_labels.nii.gz" #dilated_labels_img = nib.Nifti1Image(aparc_filtered_labels, org_labels_img.get_affine(),org_labels_img.get_header()) #nib.save(dilated_labels_img,dilated_labels_fname) #print args.sub_id + 'dilated labels have saved' #pdb.set_trace() # Compute connectivity matrix and extract the fibers M, grouping = nconnectivity_matrix(f_streamlines, reduced_dilated_labels, fiberlen_range, args.cnpoint, affine=affine, symmetric=True, return_mapping=True, mapping_as_streamlines=True, keepfiberinroi=True) Msize = len(M) CM_before_outlierremove = M[1:, 1:] nstream_bf = np.sum(CM_before_outlierremove) print args.sub_id + ' ' + str( nstream_bf ) + ' streamlines in the connectivity matrix before outlier removal.' # ===================== process the streamlines ============= print 'Processing streamlines to remove outliers ..............' outlier_para = 3 average_thrd = 8 M_after_ourlierremove = np.zeros((Msize, Msize)) # downsample streamlines cell_streamlines = [] cell_id = [] for i in range(1, Msize): for j in range(i + 1, Msize): tmp_streamlines = grouping[i, j] tmp_streamlines = list(tmp_streamlines) # downsample tmp_streamlines_downsampled = [ downsample(s, 100) for s in tmp_streamlines ] # remove outliers, we need to rewrite the QuickBundle method to speed up this process qb = QuickBundles(threshold=average_thrd) clusters = qb.cluster(tmp_streamlines_downsampled) outlier_clusters = clusters < outlier_para # small clusters nonoutlier_clusters = clusters[np.logical_not(outlier_clusters)] tmp_nonoutlier_index = [] for tmp_cluster in nonoutlier_clusters: tmp_nonoutlier_index = tmp_nonoutlier_index + tmp_cluster.indices clean_streamline_downsampled = [ tmp_streamlines_downsampled[ind] for ind in tmp_nonoutlier_index ] cell_streamlines.append(clean_streamline_downsampled) cell_id.append([i, j]) M_after_ourlierremove[i, j] = len(clean_streamline_downsampled) CM_after_ourlierremove = M_after_ourlierremove[1:, 1:] nstream_bf = np.sum(CM_after_ourlierremove) print args.sub_id + ' ' + str( nstream_bf ) + ' streamlines in the connectivity matrix after outlier removal.' #===================== save the data ======================= if (args.saving_indicator == 1): # save the whole brain connectivity cmCountMatrix_fname = args.sub_id + "_" + args.pre + "_allbrain" + "_cm_count_raw.mat" cmCountMatrix_processed_fname = args.sub_id + "_" + args.pre + "_allbrain" + "_cm_count_processed.mat" cmStreamlineMatrix_fname = args.sub_id + "_" + args.pre + "_allbrain" + "_cm_streamlines.mat" reduced_dilated_labels_fname = args.sub_id + "_" + args.pre + "_allbrain" + "_reduced_dilated_labels.nii.gz" RoiInfo_fname = args.sub_id + "_" + args.pre + "_allbrain_RoiInfo.mat" # save the raw count matrix CM = M[1:, 1:] sio.savemat(cmCountMatrix_fname, {'cm': CM}) sio.savemat(cmCountMatrix_processed_fname, {'cm': CM_after_ourlierremove}) # save the streamline matrix sio.savemat(cmStreamlineMatrix_fname, {'slines': cell_streamlines}) sio.savemat(RoiInfo_fname, {'ROIinfo': cell_id}) print args.sub_id + 'cell_streamlines.mat, ROIinfo.mat has been saved' filtered_labels_img = nib.Nifti1Image(aparc_filtered_labels, org_labels_img.get_affine(), org_labels_img.get_header()) nib.save(filtered_labels_img, reduced_dilated_labels_fname) print args.sub_id + 'all brain dilated labels have saved' # ===================== process the streamlines and extract features ============= cm_fa_curve = fa_extraction_use_cellinput(cell_streamlines, cell_id, fa_data, Msize, affine=affine) (tmp_cm_fa_mean, tmp_cm_fa_max, cm_count) = fa_mean_extraction(cm_fa_curve, Msize) # extract MD values along the streamlines cm_md_curve = fa_extraction_use_cellinput(cell_streamlines, cell_id, md_data, Msize, affine=affine) (tmp_cm_md_mean, tmp_cm_md_max, testcm) = fa_mean_extraction(cm_md_curve, Msize) # connected surface area # extract the connective volume ratio (tmp_cm_volumn, tmp_cm_volumn_ratio) = rois_connectedvol_cellinput( reduced_dilated_labels, Msize, cell_streamlines, cell_id, affine=affine) # fiber length tmp_connectcm_len = rois_fiberlen_cellinput(Msize, cell_streamlines) # save cm features cm_md_mean = tmp_cm_md_mean[1:, 1:] cm_md_max = tmp_cm_md_max[1:, 1:] cm_fa_mean = tmp_cm_fa_mean[1:, 1:] cm_fa_max = tmp_cm_fa_max[1:, 1:] cm_volumn = tmp_cm_volumn[1:, 1:] cm_volumn_ratio = tmp_cm_volumn_ratio[1:, 1:] connectcm_len = tmp_connectcm_len[1:, 1:] sio.savemat(args.pre + "_allbrain" + "_cm_processed_mdmean_100.mat", {'cm_mdmean': cm_md_mean}) sio.savemat(args.pre + "_allbrain" + "_cm_processed_mdmax_100.mat", {'cm_mdmax': cm_md_max}) sio.savemat(args.pre + "_allbrain" + "_cm_processed_famean_100.mat", {'cm_famean': cm_fa_mean}) sio.savemat(args.pre + "_allbrain" + "_cm_processed_famax_100.mat", {'cm_famax': cm_fa_max}) sio.savemat(args.pre + "_allbrain" + "_cm_processed_volumn_100.mat", {'cm_volumn': cm_volumn}) sio.savemat( args.pre + "_allbrain" + "_cm_processed_volumn_ratio_100.mat", {'cm_volumn_ratio': cm_volumn_ratio}) sio.savemat(args.pre + "_allbrain" + "_cm_processed_fiberlen_100.mat", {'cm_len': connectcm_len}) # save the streamline matrix cell_fa = [] for i in range(1, Msize): for j in range(i + 1, Msize): tmp_fa = cm_fa_curve[i, j] tmp_fa = list(tmp_fa) cell_fa.append(tmp_fa) sio.savemat(args.pre + "_allbrain" + "_cm_processed_sfa_100.mat", {'sfa': cell_fa}) print args.pre + '_allbrain" + "_cm_processed_sfa_100.mat' + ' has been saved' cell_md = [] for i in range(1, Msize): for j in range(i + 1, Msize): tmp_md = cm_md_curve[i, j] tmp_md = list(tmp_md) cell_md.append(tmp_md) sio.savemat(args.pre + "_allbrain" + "_cm_processed_smd_100.mat", {'smd': cell_md}) print args.pre + '_allbrain" + "_cm_processed_smd_100.mat' + ' has been saved' if ( args.saving_indicator == 0 ): # save the part of the connection: connection between subcortical region Nsubcortical_reg = len(sub_cortical_labels) + 1 # should be 19 cmCountMatrix_fname = args.sub_id + "_" + args.pre + "_partbrain_subcort" + "_cm_count_raw.mat" cmCountMatrix_processed_fname = args.sub_id + "_" + args.pre + "_partbrain_subcort" + "_cm_count_processed.mat" cmStreamlineMatrix_fname = args.sub_id + "_" + args.pre + "_partbrain_subcort" + "_cm_streamlines.mat" reduced_dilated_labels_fname = args.sub_id + "_" + args.pre + "_partbrain_subcort" + "_reduced_dilated_labels.nii.gz" subcortical_RoiInfo_fname = args.sub_id + "_" + args.pre + "_partbrain_subcort_RoiInfo.mat" # save the raw count matrix CM = M[1:, 1:] sio.savemat(cmCountMatrix_fname, {'cm': CM}) sio.savemat(cmCountMatrix_processed_fname, {'cm': CM_after_ourlierremove}) filtered_labels_img = nib.Nifti1Image(aparc_filtered_labels, org_labels_img.get_affine(), org_labels_img.get_header()) nib.save(filtered_labels_img, reduced_dilated_labels_fname) print args.sub_id + ' all brain dilated labels have saved' # ===================== process the streamlines and extract features ============= cm_fa_curve = fa_extraction_use_cellinput(cell_streamlines, cell_id, fa_data, Msize, affine=affine) (tmp_cm_fa_mean, tmp_cm_fa_max, cm_count) = fa_mean_extraction(cm_fa_curve, Msize) # extract MD values along the streamlines cm_md_curve = fa_extraction_use_cellinput(cell_streamlines, cell_id, md_data, Msize, affine=affine) (tmp_cm_md_mean, tmp_cm_md_max, testcm) = fa_mean_extraction(cm_md_curve, Msize) # connected surface area # extract the connective volume ratio (tmp_cm_volumn, tmp_cm_volumn_ratio) = rois_connectedvol_cellinput( reduced_dilated_labels, Msize, cell_streamlines, cell_id, affine=affine) # fiber length tmp_connectcm_len = rois_fiberlen_cellinput(Msize, cell_streamlines) # save cm features cm_md_mean = tmp_cm_md_mean[1:, 1:] cm_md_max = tmp_cm_md_max[1:, 1:] cm_fa_mean = tmp_cm_fa_mean[1:, 1:] cm_fa_max = tmp_cm_fa_max[1:, 1:] cm_volumn = tmp_cm_volumn[1:, 1:] cm_volumn_ratio = tmp_cm_volumn_ratio[1:, 1:] connectcm_len = tmp_connectcm_len[1:, 1:] sio.savemat( args.pre + "_partbrain_subcort" + "_cm_processed_mdmean_100.mat", {'cm_mdmean': cm_md_mean}) sio.savemat( args.pre + "_partbrain_subcort" + "_cm_processed_mdmax_100.mat", {'cm_mdmax': cm_md_max}) sio.savemat( args.pre + "_partbrain_subcort" + "_cm_processed_famean_100.mat", {'cm_famean': cm_fa_mean}) sio.savemat( args.pre + "_partbrain_subcort" + "_cm_processed_famax_100.mat", {'cm_famax': cm_fa_max}) sio.savemat( args.pre + "_partbrain_subcort" + "_cm_processed_volumn_100.mat", {'cm_volumn': cm_volumn}) sio.savemat( args.pre + "_partbrain_subcort" + "_cm_processed_volumn_ratio_100.mat", {'cm_volumn_ratio': cm_volumn_ratio}) sio.savemat( args.pre + "_partbrain_subcort" + "_cm_processed_fiberlen_100.mat", {'cm_len': connectcm_len}) # save the streamline matrix cell_fa = [] cell_id = [] for i in range(1, Nsubcortical_reg): for j in range(i + 1, Msize): tmp_fa = cm_fa_curve[i, j] tmp_fa = list(tmp_fa) cell_fa.append(tmp_fa) cell_id.append([i, j]) sio.savemat( args.pre + "_partbrain_subcort" + "_cm_processed_sfa_100.mat", {'sfa': cell_fa}) print args.pre + '_partbrain_subcort' + '_cm_processed_sfa_100.mat' + 'has been saved.' cell_md = [] for i in range(1, Nsubcortical_reg): for j in range(i + 1, Msize): tmp_md = cm_md_curve[i, j] tmp_md = list(tmp_md) cell_md.append(tmp_md) sio.savemat(args.pre + "_partbrain" + "_cm_processed_smd_100.mat", {'smd': cell_md}) print args.pre + '_partbrain' + '_cm_processed_smd_100.mat' + 'has been saved.' # save the streamline matrix subcortical_cell_streamlines = [] cell_id = [] idx = 0 for i in range(1, Nsubcortical_reg): for j in range(i + 1, Msize): tmp_sls = cell_streamlines[idx] idx = idx + 1 subcortical_cell_streamlines.append(tmp_sls) cell_id.append([i, j]) sio.savemat(cmStreamlineMatrix_fname, {'slines': subcortical_cell_streamlines}) sio.savemat(subcortical_RoiInfo_fname, {'ROIinfo': cell_id}) print cmStreamlineMatrix_fname + ' has been saved'
print "Loading", buffers_filename buffers = np.load(buffers_filename) except IOError: print "Buffers not found, recomputing." fdpyw = tracks_basenane+'.dpy' dpr = Dpy(fdpyw, 'r') print "Loading", fdpyw T = dpr.read_tracks() dpr.close() # T = T[:5000] # T = np.array(T, dtype=np.object) if downsampling: print "Dowsampling." T = downsample(t, qb_n_points) # print "Centering." # T = [t - np.array(data.shape[:3]) / 2.0 for t in T] # # print "Rotating." # axis = np.array([1, 0, 0]) # theta = - 90. # if downsampling: # T = np.dot(T,rotation_matrix(axis, theta)) # else: # T = [np.dot(t,rotation_matrix(axis, theta)) for t in T] # # axis = np.array([0, 1, 0]) # theta = 180. # if downsampling:
def doit(basedir, rootname, trkloc, lenthr, subsampN=12, save_snapshot=False, debug=False): savename = '%s/%s_mtrx.txt' % (basedir, rootname) savetrk = '%s/%s.trk' % (basedir, rootname) savetrkss = '%s/%s_SS.trk' % (basedir, rootname) savetrkpic = savetrk.replace('.trk', '.png') savetrkpicss = savetrk.replace('.trk', 'SS.png') savehist = '%s/%s_hist.png' % (basedir, rootname) showhist = False showsls_var = False lenthr = 50 pow = 1 if debug: subsampN = 3 subset = 800 trk, hdr = nib.trackvis.read(trkloc) sls = [item[0] for item in trk] lengths = list(length(sls)) #print lengths '''print("cheerio") print(len(lengths)) print(len(sls)) print "two" print lengths[0]''' sls_long = [] for n, j in enumerate(sls): if len(j) > 5: if lengths[n] > lenthr: print(lengths[n]) sls_long.append(j) else: print("BAD") print(lengths[n]) print("CHECKME") print(len(sls)) print(len(sls_long)) subsamp = [downsample(sl, subsampN) for sl in sls_long] if debug: subsamp = subsamp[0:subset] sls_long = sls_long[0:subset] score_mtrx = np.zeros([len(subsamp)]) print("what") print(len(subsamp)) print(len(sls)) for i, sl in enumerate(subsamp): print(str(i) + '/' + str(len(subsamp))) mtrx2 = bundles_distances_mdf([sls_long[i]], sls_long) #mtrx2_oi = np.all([(mtrx2>0) & (mtrx2<5) & (not np.isnan(mtrx2))],axis=0) mtrx2_oi = (mtrx2 > 0) & (mtrx2 < 5) & ~np.isnan(mtrx2) zoom = mtrx2[mtrx2_oi] score = np.sum(np.divide(1, np.power(zoom, pow))) #makehist(zoom.T,score) score_mtrx[i] = score #print score #print score_mtrx '''print savename print basedir print rootname''' np.savetxt(savename, score_mtrx) #makehist(score_mtrx,name=rootname,saveloc=savehist,show=showhist) newhdr = hdr.copy() newhdr['n_properties'] = 1 proplist = newhdr['property_name'] proplist[0] = 'Cluster Confidence' newhdr['property_name'] = proplist #newtrkss = ((sl,None,score_mtrx[i]) for i,sl in enumerate(subsamp)) newtrk = ((sl, None, score_mtrx[i]) for i, sl in enumerate(sls_long)) #nib.trackvis.write(savetrkss, newtrkss, newhdr) nib.trackvis.write(savetrk, newtrk, newhdr) #showsls(subsamp,score_mtrx,savetrkpicss,show=showsls_var) if save_snapshot: showsls(sls_long, score_mtrx, savetrkpic, show=showsls_var)
t1=time() C5=pf.local_skeleton_clustering(T2,.5) t2=time() print t2-t1 print len(C5) from dipy.data import get_data from nibabel import trackvis as tv try: from dipy.viz import fvtk except ImportError, e: raise nose.plugins.skip.SkipTest( 'Fails to import dipy.viz due to %s' % str(e)) streams,hdr=tv.read(get_data('fornix')) T3=[tm.downsample(s[0],6) for s in streams] print 'lenT3',len(T3) C=pf.local_skeleton_clustering(T3,10.) print 'lenC',len(C) """ r=fvtk.ren() colors=np.zeros((len(C),3)) for c in C: color=np.random.rand(3) for i in C[c]['indices']:
def __init__(self, name, qb, tracks, reps='exemplars', colors=None, vol_shape=None, virtuals_line_width=5.0, tracks_line_width=2.0, virtuals_alpha=1.0, tracks_alpha=0.6, affine=None, verbose=False): """TrackLabeler is meant to explore and select subsets of the tracks. The exploration occurs through QuickBundles (qb) in order to simplify the scene. """ super(TrackLabeler, self).__init__(name) if affine is None: self.affine = np.eye(4, dtype=np.float32) else: self.affine = affine self.mouse_x = None self.mouse_y = None self.cache = {} self.qb = qb self.reps = reps #virtual tracks if self.reps == 'virtuals': self.virtuals = qb.virtuals() if self.reps == 'exemplars': self.virtuals, self.ex_ids = qb.exemplars() self.virtuals_alpha = virtuals_alpha self.virtuals_buffer, self.virtuals_colors, self.virtuals_first, self.virtuals_count = self.compute_buffers( self.virtuals, self.virtuals_alpha) #full tractography (downsampled at 12 pts per track) self.tracks = tracks self.tracks_alpha = tracks_alpha self.tracks_ids = np.arange(len(self.tracks), dtype=np.int) self.tracks_buffer, self.tracks_colors, self.tracks_first, self.tracks_count = self.compute_buffers( self.tracks, self.tracks_alpha) #calculate boundary box for entire tractography self.min = np.min(self.tracks_buffer, axis=0) self.max = np.max(self.tracks_buffer, axis=0) self.vertices = self.tracks_buffer #coord1 = np.array([self.tracks_buffer[:,0].min(),self.tracks_buffer[:,1].min(),self.tracks_buffer[:,2].min()], dtype = 'f4') #coord2 = np.array([self.tracks_buffer[:,0].max(),self.tracks_buffer[:,1].max(),self.tracks_buffer[:,2].max()], dtype = 'f4') #self.make_aabb((coord1,coord2),0) #show size of tractography buffer print('MBytes %f' % (self.tracks_buffer.nbytes / 2.**20, )) self.position = (0, 0, 0) #buffer for selected virtual tracks self.selected = [] self.virtuals_line_width = virtuals_line_width self.tracks_line_width = tracks_line_width self.old_color = {} self.hide_virtuals = False self.expand = False self.verbose = verbose self.tracks_visualized_first = np.array([], dtype='i4') self.tracks_visualized_count = np.array([], dtype='i4') self.history = [[ self.qb, self.tracks, self.tracks_ids, self.virtuals_buffer, self.virtuals_colors, self.virtuals_first, self.virtuals_count, self.tracks_buffer, self.tracks_colors, self.tracks_first, self.tracks_count ]] #shifting of track is necessary for dipy.tracking.vox2track.track_counts #we also upsample using 30 points in order to increase the accuracy of track counts self.vol_shape = vol_shape if self.vol_shape != None: #self.tracks_shifted =[t+np.array(vol_shape)/2. for t in self.tracks] self.virtuals_shifted = [ downsample(t + np.array(self.vol_shape) / 2., 30) for t in self.virtuals ] else: #self.tracks_shifted=None self.virtuals_shifted = None
def test_LSCv2(): xyz1=np.array([[1,0,0],[2,0,0],[3,0,0]],dtype='float32') xyz2=np.array([[1,0,0],[1,2,0],[1,3,0]],dtype='float32') xyz3=np.array([[1.1,0,0],[1,2,0],[1,3,0]],dtype='float32') xyz4=np.array([[1,0,0],[2.1,0,0],[3,0,0]],dtype='float32') xyz5=np.array([[100,0,0],[200,0,0],[300,0,0]],dtype='float32') xyz6=np.array([[0,20,0],[0,40,0],[300,50,0]],dtype='float32') T=[xyz1,xyz2,xyz3,xyz4,xyz5,xyz6] C=pf.local_skeleton_clustering(T,0.2) #print C #print len(C) C2=pf.local_skeleton_clustering_3pts(T,0.2) #print C2 #print len(C2) #""" for i in range(40): xyz=np.random.rand(3,3).astype('f4') T.append(xyz) from time import time t1=time() C3=pf.local_skeleton_clustering(T,.5) t2=time() print(t2-t1) print(len(C3)) t1=time() C4=pf.local_skeleton_clustering_3pts(T,.5) t2=time() print(t2-t1) print(len(C4)) for c in C3: assert_equal(np.sum(C3[c]['hidden']-C4[c]['hidden']),0) T2=[] for i in range(10**4): xyz=np.random.rand(10,3).astype('f4') T2.append(xyz) t1=time() C5=pf.local_skeleton_clustering(T2,.5) t2=time() print(t2-t1) print(len(C5)) from dipy.data import get_data from nibabel import trackvis as tv try: from dipy.viz import fvtk except ImportError as e: raise nose.plugins.skip.SkipTest( 'Fails to import dipy.viz due to %s' % str(e)) streams,hdr=tv.read(get_data('fornix')) T3=[tm.downsample(s[0],6) for s in streams] print('lenT3',len(T3)) C=pf.local_skeleton_clustering(T3,10.) print('lenC',len(C)) """
#same as T=[] for s in streams: 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
# if root.endswith('DIFF2DEPI_EKJ_64dirs_14'): # base_dir = root+'/' # filename = 'raw' # base_dir2 = base_dir+ 'DTI/' print base_dir + "../MPRAGE_1/T1_flirt_out.nii.gz" img = nib.load(base_dir + "../MPRAGE_1/T1_flirt_out.nii.gz") data = img.get_data() for i in range(len(tracks_filename_arr)): print ">>>>" print base_dir2 + tracks_filename_arr[i] tracks = load_tracks(base_dir2 + tracks_filename_arr[i]) print len(tracks) # tracks = [downsample(t, 12) - np.array(data.shape[:3])/2. for t in tracks] tracks = [downsample(t, 12) - np.array(data.shape) / 2.0 for t in tracks] # shift in the center of the volume # tracks=[t-np.array(data.shape)/2. for t in tracks] # 1/0 print base_dir2 + qb_filename_15[i] qb = QuickBundles(tracks, 15.0, 12) save_pickle(base_dir2 + qb_filename_15[i], qb) print base_dir2 + qb_filename_20[i] qb = QuickBundles(tracks, 20.0, 12) save_pickle(base_dir2 + qb_filename_20[i], qb) print base_dir2 + qb_filename_30[i] qb = QuickBundles(tracks, 30.0, 12) save_pickle(base_dir2 + qb_filename_30[i], qb) # ================ quick bundles ==============================================
in mind when you calculate lengths with real data. Next, let's find the number of points that each streamline has. """ n_pts = [len(streamline) for streamline in bundle] """ Often, streamlines are represented with more points than what is actually necessary for specific applications. Also, sometimes every streamline has different number of points which could be of a trouble for some algorithms . The function ``downsample`` can be used to set the number of points of a streamline at a specific number and at the same time enforce that all the segments of the streamline will have equal length. """ bundle_downsampled = [downsample(s, 12) for s in bundle] n_pts_ds = [len(s) for s in bundle_downsampled] """ Alternatively, the function ``approx_polygon_track`` allows to reduce the number of points so that they are more points in curvy regions and less points in less curvy regions. In contrast with ``downsample`` it does not enforce that segments should be of equal size. """ bundle_downsampled2 = [approx_polygon_track(s, 0.25) for s in bundle] n_pts_ds2 = [len(streamline) for streamline in bundle_downsampled2] """ Both, ``downsample`` and ``approx_polygon_track`` can be thought as methods for lossy compression of streamlines. """
# base_dir2 = base_dir+ 'DTI/' # print base_dir+'../ANATOMY/T1_flirt_out.nii.gz' # img = nib.load(base_dir+'../ANATOMY/T1_flirt_out.nii.gz') # data = img.get_data() for i in range(len(tracks_filename_arr)): print ">>>>" print base_dir2 + tracks_filename_arr[i] tracks = load_tracks(base_dir2 + tracks_filename_arr[i]) print len(tracks) # shift in the center of the volume # tracks=[t-np.array(data.shape)/2. for t in tracks] tracks = [downsample(t, 12) for t in tracks] print base_dir2 + qb_filename_15[i] qb = QuickBundles(tracks, 15.0, 12) save_pickle(base_dir2 + qb_filename_15[i], qb) print base_dir2 + qb_filename_20[i] qb = QuickBundles(tracks, 20.0, 12) save_pickle(base_dir2 + qb_filename_20[i], qb) print base_dir2 + qb_filename_30[i] qb = QuickBundles(tracks, 30.0, 12) save_pickle(base_dir2 + qb_filename_30[i], qb) # ================ quick bundles ============================================== print ("Done") print (linear_filename)
def test_LSCv2(): xyz1 = np.array([[1, 0, 0], [2, 0, 0], [3, 0, 0]], dtype='float32') xyz2 = np.array([[1, 0, 0], [1, 2, 0], [1, 3, 0]], dtype='float32') xyz3 = np.array([[1.1, 0, 0], [1, 2, 0], [1, 3, 0]], dtype='float32') xyz4 = np.array([[1, 0, 0], [2.1, 0, 0], [3, 0, 0]], dtype='float32') xyz5 = np.array([[100, 0, 0], [200, 0, 0], [300, 0, 0]], dtype='float32') xyz6 = np.array([[0, 20, 0], [0, 40, 0], [300, 50, 0]], dtype='float32') T = [xyz1, xyz2, xyz3, xyz4, xyz5, xyz6] C = pf.local_skeleton_clustering(T, 0.2) # print C # print len(C) C2 = pf.local_skeleton_clustering_3pts(T, 0.2) # print C2 # print len(C2) # """ for i in range(40): xyz = np.random.rand(3, 3).astype('f4') T.append(xyz) from time import time t1 = time() C3 = pf.local_skeleton_clustering(T, .5) t2 = time() print(t2 - t1) print(len(C3)) t1 = time() C4 = pf.local_skeleton_clustering_3pts(T, .5) t2 = time() print(t2 - t1) print(len(C4)) for c in C3: assert_equal(np.sum(C3[c]['hidden'] - C4[c]['hidden']), 0) T2 = [] for i in range(10**4): xyz = np.random.rand(10, 3).astype('f4') T2.append(xyz) t1 = time() C5 = pf.local_skeleton_clustering(T2, .5) t2 = time() print(t2 - t1) print(len(C5)) from dipy.data import get_data from nibabel import trackvis as tv try: from dipy.viz import fvtk except ImportError as e: raise nose.plugins.skip.SkipTest('Fails to import dipy.viz due to %s' % str(e)) streams, hdr = tv.read(get_data('fornix')) T3 = [tm.downsample(s[0], 6) for s in streams] print('lenT3', len(T3)) C = pf.local_skeleton_clustering(T3, 10.) print('lenC', len(C)) """
streams,hdr=tv.read(fname) """ Copy tracks: """ T=[i[0] for i in streams] #T=T[:1000] """ Downsample tracks to just 3 points: """ tracks=[tm.downsample(t,3) for t in T] """ Delete unnecessary data: """ del streams,hdr """ Perform Local Skeleton Clustering (LSC) with a 5mm threshold: """ now=time.clock() C=td.local_skeleton_clustering(tracks,d_thr=5) print('Done in %.2f s' % (time.clock()-now,))
def test_downsample(): t = np.array([[ 82.20181274, 91.3650589 , 43.15737152], [ 82.3844223 , 91.79336548, 43.87036514], [ 82.48710632, 92.27861023, 44.56298065], [ 82.53310394, 92.7854538 , 45.24635315], [ 82.53793335, 93.26902008, 45.94785309], [ 82.48797607, 93.75003815, 46.6493988 ], [ 82.35533142, 94.2518158 , 47.32533264], [ 82.15484619, 94.76634216, 47.97451019], [ 81.90982819, 95.28792572, 48.6024437 ], [ 81.63336945, 95.78153229, 49.23971176], [ 81.35479736, 96.24868011, 49.89558792], [ 81.08713531, 96.69807434, 50.56812668], [ 80.81504822, 97.14285278, 51.24193192], [ 80.52591705, 97.56719971, 51.92168427], [ 80.26599884, 97.98269653, 52.61848068], [ 80.0463562 , 98.38131714, 53.3385582 ], [ 79.8469162 , 98.77052307, 54.06955338], [ 79.57667542, 99.13599396, 54.78985596], [ 79.23351288, 99.4320755 , 55.51065063], [ 78.84815979, 99.64141846, 56.24016571], [ 78.47383881, 99.77347565, 56.9929924 ], [ 78.12837219, 99.81330872, 57.76969528], [ 77.80438995, 99.85082245, 58.55574799], [ 77.4943924 , 99.88065338, 59.34777069], [ 77.21414185, 99.85343933, 60.15090561], [ 76.96416473, 99.82772827, 60.96406937], [ 76.74712372, 99.80519104, 61.78676605], [ 76.52263641, 99.79122162, 62.60765076], [ 76.03757477, 100.08692169, 63.24152374], [ 75.44867706, 100.3526535 , 63.79513168], [ 74.78033447, 100.57255554, 64.272789 ], [ 74.11605835, 100.7733078 , 64.76428986], [ 73.51222992, 100.98779297, 65.32373047], [ 72.97387695, 101.23387146, 65.93502045], [ 72.47355652, 101.49151611, 66.57343292], [ 71.99834442, 101.72480774, 67.2397995 ], [ 71.5690918 , 101.98665619, 67.92664337], [ 71.18083191, 102.29483795, 68.61888123], [ 70.81879425, 102.63343048, 69.31127167], [ 70.47422791, 102.98672485, 70.00532532], [ 70.10092926, 103.28502655, 70.70999908], [ 69.69512177, 103.51667023, 71.42147064], [ 69.27423096, 103.71351624, 72.13452911], [ 68.91260529, 103.81676483, 72.89796448], [ 68.60788727, 103.81982422, 73.69258118], [ 68.34162903, 103.7661972 , 74.49915314], [ 68.08542633, 103.70635223, 75.30856323], [ 67.83590698, 103.60187531, 76.11553955], [ 67.56822968, 103.4482193 , 76.90870667], [ 67.28399658, 103.25878906, 77.68825531], [ 67.00117493, 103.03740692, 78.45989227], [ 66.72718048, 102.80329895, 79.23099518], [ 66.4619751 , 102.54130554, 79.99622345], [ 66.20803833, 102.22305298, 80.7438736 ], [ 65.96872711, 101.88980865, 81.48987579], [ 65.72864532, 101.59316254, 82.25085449], [ 65.47808075, 101.33383942, 83.02194214], [ 65.21841431, 101.11295319, 83.80186462], [ 64.95678711, 100.94080353, 84.59326935], [ 64.71759033, 100.82022095, 85.40114594], [ 64.48053741, 100.73490143, 86.21411896], [ 64.24304199, 100.65074158, 87.02709198], [ 64.01773834, 100.55318451, 87.84204865], [ 63.83801651, 100.41996765, 88.66333008], [ 63.70982361, 100.25119019, 89.48779297], [ 63.60707855, 100.06730652, 90.31262207], [ 63.46164322, 99.91001892, 91.13648224], [ 63.26287842, 99.78648376, 91.95485687], [ 63.03713226, 99.68377686, 92.76905823], [ 62.81192398, 99.56619263, 93.58140564], [ 62.57145309, 99.42708588, 94.38592529], [ 62.32259369, 99.25592804, 95.18167114], [ 62.07497787, 99.05770111, 95.97154236], [ 61.82253647, 98.83877563, 96.7543869 ], [ 61.59536743, 98.59293365, 97.5370636 ], [ 61.46530151, 98.30503845, 98.32772827], [ 61.39904785, 97.97928619, 99.11172485], [ 61.33279419, 97.65353394, 99.89572906], [ 61.26067352, 97.30914307, 100.67123413], [ 61.19459534, 96.96743011, 101.44847107], [ 61.1958046 , 96.63417053, 102.23215485], [ 61.26572037, 96.2988739 , 103.01185608], [ 61.39840698, 95.96297455, 103.78307343], [ 61.5720787 , 95.6426239 , 104.55268097], [ 61.78163528, 95.35540771, 105.32629395], [ 62.06700134, 95.09746552, 106.08564758], [ 62.39427185, 94.8572464 , 106.83369446], [ 62.74076462, 94.62278748, 107.57482147], [ 63.11461639, 94.40107727, 108.30641937], [ 63.53397751, 94.20418549, 109.02002716], [ 64.00019836, 94.03809357, 109.71183777], [ 64.43580627, 93.87523651, 110.42416382], [ 64.84857941, 93.69993591, 111.14715576], [ 65.26740265, 93.51858521, 111.86515808], [ 65.69511414, 93.3671875 , 112.58474731], [ 66.10470581, 93.22719574, 113.31711578], [ 66.45891571, 93.06028748, 114.07256317], [ 66.78582001, 92.90560913, 114.84281921], [ 67.11138916, 92.79004669, 115.6204071 ], [ 67.44729614, 92.75711823, 116.40135193], [ 67.75688171, 92.98265076, 117.16111755], [ 68.02041626, 93.28012848, 117.91371155], [ 68.25725555, 93.53466797, 118.69052124], [ 68.46047974, 93.63263702, 119.51107788], [ 68.62039948, 93.62007141, 120.34690094], [ 68.76782227, 93.56475067, 121.18331909], [ 68.90222168, 93.46326447, 122.01765442], [ 68.99872589, 93.30039978, 122.84759521], [ 69.04119873, 93.05428314, 123.66156769], [ 69.05086517, 92.74394989, 124.45450592], [ 69.02742004, 92.40427399, 125.23509979], [ 68.95466614, 92.09059143, 126.02339935], [ 68.84975433, 91.7967453 , 126.81564331], [ 68.72673798, 91.53726196, 127.61715698], [ 68.6068573 , 91.3030014 , 128.42681885], [ 68.50636292, 91.12481689, 129.25317383], [ 68.39311218, 91.01572418, 130.08976746], [ 68.25946808, 90.94654083, 130.92756653]], dtype=np.float32) pts = 12 td = tm.downsample(t, pts) # print td assert_equal(len(td), pts) res = [] t = np.array([[0, 0, 0], [1, 1, 1], [2, 2, 2]], 'f4') for pts in range(3, 200): td = tm.downsample(t, pts) res.append(pts-len(td)) assert_equal(np.sum(res), 0) """
def test_downsample(): t = np.array([[82.20181274, 91.3650589, 43.15737152], [82.3844223, 91.79336548, 43.87036514], [82.48710632, 92.27861023, 44.56298065], [82.53310394, 92.7854538, 45.24635315], [82.53793335, 93.26902008, 45.94785309], [82.48797607, 93.75003815, 46.6493988], [82.35533142, 94.2518158, 47.32533264], [82.15484619, 94.76634216, 47.97451019], [81.90982819, 95.28792572, 48.6024437], [81.63336945, 95.78153229, 49.23971176], [81.35479736, 96.24868011, 49.89558792], [81.08713531, 96.69807434, 50.56812668], [80.81504822, 97.14285278, 51.24193192], [80.52591705, 97.56719971, 51.92168427], [80.26599884, 97.98269653, 52.61848068], [80.0463562, 98.38131714, 53.3385582], [79.8469162, 98.77052307, 54.06955338], [79.57667542, 99.13599396, 54.78985596], [79.23351288, 99.4320755, 55.51065063], [78.84815979, 99.64141846, 56.24016571], [78.47383881, 99.77347565, 56.9929924], [78.12837219, 99.81330872, 57.76969528], [77.80438995, 99.85082245, 58.55574799], [77.4943924, 99.88065338, 59.34777069], [77.21414185, 99.85343933, 60.15090561], [76.96416473, 99.82772827, 60.96406937], [76.74712372, 99.80519104, 61.78676605], [76.52263641, 99.79122162, 62.60765076], [76.03757477, 100.08692169, 63.24152374], [75.44867706, 100.3526535, 63.79513168], [74.78033447, 100.57255554, 64.272789], [74.11605835, 100.7733078, 64.76428986], [73.51222992, 100.98779297, 65.32373047], [72.97387695, 101.23387146, 65.93502045], [72.47355652, 101.49151611, 66.57343292], [71.99834442, 101.72480774, 67.2397995], [71.5690918, 101.98665619, 67.92664337], [71.18083191, 102.29483795, 68.61888123], [70.81879425, 102.63343048, 69.31127167], [70.47422791, 102.98672485, 70.00532532], [70.10092926, 103.28502655, 70.70999908], [69.69512177, 103.51667023, 71.42147064], [69.27423096, 103.71351624, 72.13452911], [68.91260529, 103.81676483, 72.89796448], [68.60788727, 103.81982422, 73.69258118], [68.34162903, 103.7661972, 74.49915314], [68.08542633, 103.70635223, 75.30856323], [67.83590698, 103.60187531, 76.11553955], [67.56822968, 103.4482193, 76.90870667], [67.28399658, 103.25878906, 77.68825531], [67.00117493, 103.03740692, 78.45989227], [66.72718048, 102.80329895, 79.23099518], [66.4619751, 102.54130554, 79.99622345], [66.20803833, 102.22305298, 80.7438736], [65.96872711, 101.88980865, 81.48987579], [65.72864532, 101.59316254, 82.25085449], [65.47808075, 101.33383942, 83.02194214], [65.21841431, 101.11295319, 83.80186462], [64.95678711, 100.94080353, 84.59326935], [64.71759033, 100.82022095, 85.40114594], [64.48053741, 100.73490143, 86.21411896], [64.24304199, 100.65074158, 87.02709198], [64.01773834, 100.55318451, 87.84204865], [63.83801651, 100.41996765, 88.66333008], [63.70982361, 100.25119019, 89.48779297], [63.60707855, 100.06730652, 90.31262207], [63.46164322, 99.91001892, 91.13648224], [63.26287842, 99.78648376, 91.95485687], [63.03713226, 99.68377686, 92.76905823], [62.81192398, 99.56619263, 93.58140564], [62.57145309, 99.42708588, 94.38592529], [62.32259369, 99.25592804, 95.18167114], [62.07497787, 99.05770111, 95.97154236], [61.82253647, 98.83877563, 96.7543869], [61.59536743, 98.59293365, 97.5370636], [61.46530151, 98.30503845, 98.32772827], [61.39904785, 97.97928619, 99.11172485], [61.33279419, 97.65353394, 99.89572906], [61.26067352, 97.30914307, 100.67123413], [61.19459534, 96.96743011, 101.44847107], [61.1958046, 96.63417053, 102.23215485], [61.26572037, 96.2988739, 103.01185608], [61.39840698, 95.96297455, 103.78307343], [61.5720787, 95.6426239, 104.55268097], [61.78163528, 95.35540771, 105.32629395], [62.06700134, 95.09746552, 106.08564758], [62.39427185, 94.8572464, 106.83369446], [62.74076462, 94.62278748, 107.57482147], [63.11461639, 94.40107727, 108.30641937], [63.53397751, 94.20418549, 109.02002716], [64.00019836, 94.03809357, 109.71183777], [64.43580627, 93.87523651, 110.42416382], [64.84857941, 93.69993591, 111.14715576], [65.26740265, 93.51858521, 111.86515808], [65.69511414, 93.3671875, 112.58474731], [66.10470581, 93.22719574, 113.31711578], [66.45891571, 93.06028748, 114.07256317], [66.78582001, 92.90560913, 114.84281921], [67.11138916, 92.79004669, 115.6204071], [67.44729614, 92.75711823, 116.40135193], [67.75688171, 92.98265076, 117.16111755], [68.02041626, 93.28012848, 117.91371155], [68.25725555, 93.53466797, 118.69052124], [68.46047974, 93.63263702, 119.51107788], [68.62039948, 93.62007141, 120.34690094], [68.76782227, 93.56475067, 121.18331909], [68.90222168, 93.46326447, 122.01765442], [68.99872589, 93.30039978, 122.84759521], [69.04119873, 93.05428314, 123.66156769], [69.05086517, 92.74394989, 124.45450592], [69.02742004, 92.40427399, 125.23509979], [68.95466614, 92.09059143, 126.02339935], [68.84975433, 91.7967453, 126.81564331], [68.72673798, 91.53726196, 127.61715698], [68.6068573, 91.3030014, 128.42681885], [68.50636292, 91.12481689, 129.25317383], [68.39311218, 91.01572418, 130.08976746], [68.25946808, 90.94654083, 130.92756653]], dtype=np.float32) pts = 12 td = tm.downsample(t, pts) # print td assert_equal(len(td), pts) res = [] t = np.array([[0, 0, 0], [1, 1, 1], [2, 2, 2]], 'f4') for pts in range(3, 200): td = tm.downsample(t, pts) res.append(pts - len(td)) assert_equal(np.sum(res), 0) """
t1 = time() C5 = pf.local_skeleton_clustering(T2, .5) t2 = time() print t2 - t1 print len(C5) from dipy.data import get_data from nibabel import trackvis as tv try: from dipy.viz import fvtk except ImportError, e: raise nose.plugins.skip.SkipTest('Fails to import dipy.viz due to %s' % str(e)) streams, hdr = tv.read(get_data('fornix')) T3 = [tm.downsample(s[0], 6) for s in streams] print 'lenT3', len(T3) C = pf.local_skeleton_clustering(T3, 10.) print 'lenC', len(C) """ r=fvtk.ren() colors=np.zeros((len(C),3)) for c in C: color=np.random.rand(3) for i in C[c]['indices']: fvtk.add(r,fvtk.line(T3[i],color)) colors[c]=color