Exemple #1
0
def test_dpy():

    fd,fname = mkstemp()    
    dpw = Dpy(fname,'w')    
    A=np.ones((5,3))
    B=2*A.copy()
    C=3*A.copy()        
    dpw.write_track(A)
    dpw.write_track(B)
    dpw.write_track(C)            
    dpw.write_tracks([C,B,A])    
    dpw.close()    
    dpr = Dpy(fname,'r')    
    assert_equal(dpr.version()=='0.0.1',True)    
    T=dpr.read_tracksi([0,1,2,0,0,2])    
    print(T)    
    T2=dpr.read_tracks()    
    assert_equal(len(T2),6)    
    dpr.close()
    assert_array_equal(A,T[0])
    assert_array_equal(C,T[5])
    os.remove(fname)

    
    
    
Exemple #2
0
def spherical_rois(fdpy,fsr,sq_radius=4):    
    
    
    R=atlantic_points()    
    dpr=Dpy(fdpy,'r')
    T=dpr.read_tracks()
    dpr.close()
    
    center=R['BCC']
    
    refimg=nib.load(fref)
    aff=refimg.get_affine()
    
    SR={}
    
    for key in R:
        
        center=R[key]
        #back to world space
        centerw=np.dot(aff,np.array(center+(1,)))[:3]        
        centerw.shape=(1,)+centerw.shape   
        centerw=centerw.astype(np.float32)
    
        res= [track_roi_intersection_check(t,centerw,sq_radius) for t in T]
        res= np.array(res,dtype=np.int)
        ind=np.where(res>0)[0]
        
        SR[key]={}
        SR[key]['center']=center
        SR[key]['centerw']=tuple(np.squeeze(centerw))
        SR[key]['radiusw']=np.sqrt(sq_radius)
        SR[key]['indices']=ind
        
    
    save_pickle(fsr,SR)
Exemple #3
0
def load_tractogram(filename, lazy_load=False):
    """ Loads tractogram files (*.trk or *.tck or *.dpy)

    Parameters
    ----------
    filename : str
        input trk filename
    lazy_load : {False, True}, optional
        If True, load streamlines in a lazy manner i.e. they will not be kept
        in memory and only be loaded when needed.
        Otherwise, load all streamlines in memory.

    Returns
    -------
    streamlines : list of 2D arrays
        Each 2D array represents a sequence of 3D points (points, 3).
    hdr : dict
        header from a trk file
    """
    if 'dpy' in os.path.splitext(filename)[1].lower():
        dpw = Dpy(filename, 'r')
        streamlines = dpw.read_tracks()
        dpw.close()
        return streamlines, {}

    trk_file = nib.streamlines.load(filename, lazy_load)
    return trk_file.streamlines, trk_file.header
Exemple #4
0
    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':
            print "Loading", self.tracpath
            # Old nibabel API:
            # streams, self.hdr = nib.trackvis.read(self.tracpath, points_space='voxel')
            # self.T = np.array([s[0] for s in streams], dtype=np.object)
            # New nibabel API
            tmp = nib.streamlines.load(self.tracpath)
            streams = tmp.tractogram.apply_affine(np.linalg.inv(tmp.affine)).streamlines
            self.header = tmp.header
            self.T = np.array(streams, dtype=np.object)

        # The following code has been commented out to avoid
        # misalignment between original streamlines IDs and final IDs.
        # 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)
Exemple #5
0
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)
Exemple #6
0
def load_tractogram(filename, lazy_load=False):
    """ Loads tractogram files (*.trk or *.tck or *.dpy)

    Parameters
    ----------
    filename : str
        input trk filename
    lazy_load : {False, True}, optional
        If True, load streamlines in a lazy manner i.e. they will not be kept
        in memory and only be loaded when needed.
        Otherwise, load all streamlines in memory.

    Returns
    -------
    streamlines : list of 2D arrays
        Each 2D array represents a sequence of 3D points (points, 3).
    hdr : dict
        header from a trk file
    """
    if 'dpy' in os.path.splitext(filename)[1].lower():
        dpw = Dpy(filename, 'r')
        streamlines = dpw.read_tracks()
        dpw.close()
        return streamlines, {}

    trk_file = nib.streamlines.load(filename, lazy_load)
    return trk_file.streamlines, trk_file.header
Exemple #7
0
def roi_track_counts(fdpy,fref,fatlas,roi_no,dist_transf=True,fres=None):
    
    dpr=Dpy(fdpy,'r')
    T=dpr.read_tracks()
    dpr.close()
    
    img=nib.load(fref)
    affine=img.get_affine()
    zooms = img.get_header().get_zooms()
    iaffine=np.linalg.inv(affine)
    T2=[]
    #go back to volume space
    for t in T:
        T2.append(np.dot(t,iaffine[:3,:3].T)+iaffine[:3,3])
    del T
    
    tcs,tes=track_counts(T2,img.get_shape(),zooms,True)
    
    atlas_img=nib.load(fatlas)
    atlas=atlas_img.get_data()
    roi=atlas.copy()
    roi[atlas!=roi_no]=0
    
    if dist_transf:
        roi2=distance_transform_cdt(roi)
        roi[roi2!=roi2.max()]=0
        I=np.array(np.where(roi==roi_no)).T
    else:
        I=np.array(np.where(roi==roi_no)).T    
    
    """    
    if erosion_level>0:
        roi2=binary_erosion(roi,cross,erosion_level)                 
        I=np.array(np.where(roi2==True)).T
    else:        
        roi2=distance_transform_cdt(roi)        
        I=np.array(np.where(roi==roi_no)).T        
    """
    
    #print I.shape    
    #nib.save(nib.Nifti1Image(roi2,affine),'/tmp/test.nii.gz')
    
    Ttes=[]
    for iroi in I:
        try:
            Ttes.append(tes[tuple(iroi)])
        except KeyError:
            pass
    
    Ttes=list(set(list(chain.from_iterable(Ttes))))    
    T2n=np.array(T2,dtype=np.object)
    res=list(T2n[Ttes])
    
    #back to world space
    res2=[]
    for t in res:
        res2.append(np.dot(t,affine[:3,:3].T)+affine[:3,3])
    np.save(fres,np.array(res2,dtype=np.object))
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
Exemple #9
0
    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)
Exemple #10
0
def get_luigi_SLFI():
    fseg1 = "/home/eg309/Devel/segmented_bundles/luigi_s1_for_eleftherios/S1_SLFI"
    # fseg2='/home/eg309/Devel/segmented_bundles/luigi_s1_for_eleftherios/S1_SLFII'
    subject = "01"
    fdpyw = "data/subj_" + subject + "/101_32/DTI/tracks_gqi_3M_linear.dpy"
    dpr = Dpy(fdpyw, "r")
    T = dpr.read_tracks()
    dpr.close()
    seg_inds = load_pickle(fseg1)
    T1 = [T[i] for i in seg_inds]
    # seg_inds=load_pickle(fseg2)
    # T2=[T[i] for i in seg_inds]
    return T1
def load_data(figure, data_id):   
    
    if figure=='small_dataset':
        filename = 'ALS_Data/'+ str(data_id) + '/DIFF2DEPI_EKJ_64dirs_14/DTI/tracks_dti_10K.dpy'        
    elif figure=='median_dataset':
        filename = 'ALS_Data/' + str(data_id) + '/DIFF2DEPI_EKJ_64dirs_14/DTI/tracks_dti_1M.dpy'    
    elif figure=='big_dataset':
        filename = 'ALS_Data/' + str(data_id) + '/DIFF2DEPI_EKJ_64dirs_14/DTI/tracks_dti_3M.dpy'
    
    print "Loading tracks."
    dpr = Dpy(filename, 'r')
    tracks = dpr.read_tracks()
    dpr.close()
    tracks = np.array(tracks, dtype=np.object)
    return tracks
def load_data(figure, data_id):

    if figure == "small_dataset":
        filename = "ALS_Data/" + str(data_id) + "/DIFF2DEPI_EKJ_64dirs_14/DTI/tracks_dti_10K.dpy"
    elif figure == "median_dataset":
        filename = "ALS_Data/" + str(data_id) + "/DIFF2DEPI_EKJ_64dirs_14/DTI/tracks_dti_1M.dpy"
    elif figure == "big_dataset":
        filename = "ALS_Data/" + str(data_id) + "/DIFF2DEPI_EKJ_64dirs_14/DTI/tracks_dti_3M.dpy"

    print "Loading tracks."
    dpr = Dpy(filename, "r")
    tracks = dpr.read_tracks()
    dpr.close()
    tracks = np.array(tracks, dtype=np.object)
    return tracks
def load_whole_tract(tracks_filename):
    
    from dipy.io.pickles import load_pickle
    if (tracks_filename[-3:]=='dpy'):
        from dipy.io.dpy import Dpy
        dpr_tracks = Dpy(tracks_filename, 'r')
        all_tracks=dpr_tracks.read_tracks()
        dpr_tracks.close()
    else:
        import nibabel as nib
        streams,hdr=nib.trackvis.read(tracks_filename,points_space='voxel')
        all_tracks = np.array([s[0] for s in streams], dtype=np.object)    

    all_tracks = np.array(all_tracks,dtype=np.object)
    return all_tracks
Exemple #14
0
def create_dataset_from_tractography(size1, size2, same=True):
    if same: assert(size2 >= size1)
    filename = 'data/tracks_dti_10K_linear.dpy'
    print "Loading", filename
    dpr = Dpy(filename, 'r')
    tractography = dpr.read_tracks()
    dpr.close()
    print len(tractography), "streamlines"
    print "Removing streamlines that are too short"
    tractography = filter(lambda x: len(x) > 20, tractography) # remove too short streamlines
    print len(tractography), "streamlines"    
    tractography = np.array(tractography, dtype=np.object)

    print "Creating two simulated tractographies of sizes", size1, "and", size2
    if same:
        ids = fft(tractography, k=max([size1, size2]), distance=bundles_distances_mam)
        tractography1 = tractography[ids[:size1]]
    else:
        # ids1 = np.random.permutation(len(tractography))[:size1]
        # ids1 = sff(tractography, k=size1, distance=bundles_distances_mam)
        ids1 = fft(tractography, k=size1, distance=bundles_distances_mam)
        tractography1 = tractography[ids1[:size1]]

    if same:
        tractography2 = tractography[ids[:size2]]
    else:
        # ids2 = np.random.permutation(len(tractography))[:size2]
        # ids2 = sff(tractography, k=size2, distance=bundles_distances_mam)
        ids2 = fft(tractography, k=size2, distance=bundles_distances_mam)
        tractography2 = tractography[ids2]
        
    print "Done."

    print "Computing the distance matrices for each tractography."
    dm1 = bundles_distances_mam(tractography1, tractography1)
    dm2 = bundles_distances_mam(tractography2, tractography2)

    print("Computing similarity matrices.")
    sigma2 = np.mean([np.median(dm1), np.median(dm2)]) ** 2.0
    print("sigma2 = %f" % sigma2)
    A = np.exp(-dm1 * dm1 / sigma2)
    B = np.exp(-dm2 * dm2 / sigma2)

    # Note: the optimization works even using distance instead of similarity:
    # A = dm1
    # B = dm2

    return A, B
Exemple #15
0
def load_tracks(method="pmt"):
    from nibabel import trackvis as tv

    dname = "/home/eg309/Data/orbital_phantoms/dwi_dir/subject1/"

    if method == "pmt":
        fname = "/home/eg309/Data/orbital_phantoms/dwi_dir/workflow/tractography/_subject_id_subject1/cam2trk_pico_twoten/data_fit_pdfs_tracked.trk"
        streams, hdr = tv.read(fname, points_space="voxel")
        tracks = [s[0] for s in streams]
    if method == "dti":
        fname = dname + "dti_tracks.dpy"
    if method == "dsi":
        fname = dname + "dsi_tracks.dpy"
    if method == "gqs":
        fname = dname + "gqi_tracks.dpy"
    if method == "eit":
        fname = dname + "eit_tracks.dpy"
    if method in ["dti", "dsi", "gqs", "eit"]:
        dpr_linear = Dpy(fname, "r")
        tracks = dpr_linear.read_tracks()
        dpr_linear.close()

    if method != "pmt":
        tracks = [t - np.array([96 / 2.0, 96 / 2.0, 55 / 2.0]) for t in tracks if track_range(t, 100 / 2.5, 150 / 2.5)]
    tracks = [t for t in tracks if track_range(t, 100 / 2.5, 150 / 2.5)]

    print "final no of tracks ", len(tracks)
    qb = QuickBundles(tracks, 25.0 / 2.5, 18)
    # from dipy.viz import fvtk
    # r=fvtk.ren()
    # fvtk.add(r,fvtk.line(qb.virtuals(),fvtk.red))
    # fvtk.show(r)
    # show_tracks(tracks)#qb.exemplars()[0])
    # qb.remove_small_clusters(40)
    del tracks
    # load
    tl = TrackLabeler(qb, qb.downsampled_tracks(), vol_shape=None, tracks_line_width=3.0, tracks_alpha=1)

    # return tracks
    w = World()
    w.add(tl)
    # create window
    wi = Window(caption="Fos", bgcolor=(1.0, 1.0, 1.0, 1.0), width=1600, height=900)
    wi.attach(w)
    # create window manager
    wm = WindowManager()
    wm.add(wi)
    wm.run()
Exemple #16
0
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)
Exemple #17
0
def see_spherical_intersections(fdpy,fsr):
    
    dpr=Dpy(fdpy,'r')
    T=dpr.read_tracks()
    dpr.close()
    
    SR=load_pickle(fsr)
    
    r=fvtk.ren()
    
    for key in SR:
        ind=SR[key]['indices']
        intersT=[T[i] for i in ind]
        fvtk.add(r,fvtk.line(intersT,np.random.rand(3)))    
        centerw=SR[key]['centerw']
        radius=SR[key]['radiusw']
        fvtk.add(r,fvtk.sphere(position=centerw,radius=radius))
        
    fvtk.show(r)
Exemple #18
0
def test_dpy():
    fname = 'test.bin'
    with InTemporaryDirectory():
        dpw = Dpy(fname, 'w')
        A = np.ones((5, 3))
        B = 2 * A.copy()
        C = 3 * A.copy()
        dpw.write_track(A)
        dpw.write_track(B)
        dpw.write_track(C)
        dpw.write_tracks([C, B, A])
        dpw.close()
        dpr = Dpy(fname, 'r')
        assert_equal(dpr.version() == '0.0.1', True)
        T = dpr.read_tracksi([0, 1, 2, 0, 0, 2])
        T2 = dpr.read_tracks()
        assert_equal(len(T2), 6)
        dpr.close()
        assert_array_equal(A, T[0])
        assert_array_equal(C, T[5])
def test_dpy():
    fname = 'test.bin'

    dpw = Dpy(fname, 'w')
    A = np.ones((5, 3))
    B = 2 * A.copy()
    C = 3 * A.copy()
    dpw.write_track(A)
    dpw.write_track(B)
    dpw.write_track(C)
    dpw.write_tracks([C, B, A])
    dpw.close()
    dpr = Dpy(fname, 'r')
    assert_equal(dpr.version() == '0.0.1', True)
    T = dpr.read_tracksi([0, 1, 2, 0, 0, 2])
    T2 = dpr.read_tracks()
    assert_equal(len(T2), 6)
    dpr.close()
    assert_array_equal(A, T[0])
    assert_array_equal(C, T[5])
def compute_conmats(dir_res_out):

    # Connectiivty matrices are compute for all tractograms
    # and all .nii.gz parcellation files prefixed with 'parc_'

    dpys = glob.glob(dir_res_out + '/*.dpy')
    parcs = glob.glob(dir_res_out + '/parc_*.nii.gz')

    for parc_file in parcs:

      parc_name = os.path.split(parc_file)[1].replace('.nii.gz', '')
      parc_img = nib.load(parc_file)
      parc_dat = parc_img.get_data().astype('int32')

      affine = np.eye(4)

      for dpy_file in dpys:

        dpy_name = os.path.split(dpy_file)[1].replace('.dpy', '')
        cm_name = 'conmat__' + parc_name.replace('parc__', '') \
                             + dpy_name.replace('tractogram', '')
        mapping_name = cm_name.replace('Conmat', 'conmat_mapping')

        cm_file = dir_res_out + '/' + cm_name + '.h5'

        dpy = Dpy(dpy_file, 'r')
        dpy_streams = dpy.read_tracks()
        dpy.close()

        M,G = connectivity_matrix(dpy_streams,parc_dat,affine=affine,
                                  return_mapping=True,mapping_as_streamlines=False)

        F = h5py.File(cm_file, 'w')
        F.create_dataset('M', data=M)
        g = F.create_group('G')  
        for k,v in G.items(): g[str(k)] = v
        F.close()
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 warp_tracks_linearly(flirt_filename,fa_filename, tracks_filename,linear_filename):
    fsl_ref = '/usr/share/fsl/data/standard/FMRIB58_FA_1mm.nii.gz'
    
    img_fa = nib.load(fa_filename)            

    flirt_affine= np.loadtxt(flirt_filename)    
        
    img_ref =nib.load(fsl_ref)
    
    #create affine matrix from flirt     
    mat=flirt2aff(flirt_affine,img_fa,img_ref)        

     #read tracks    
    dpr = Dpy(tracks_filename, 'r')
    tensor_tracks = dpr.read_tracks()
    dpr.close()
        
    #linear tranform for tractography
    tracks_warped_linear = transform_tracks(tensor_tracks,mat)        

    #save tracks_warped_linear    
    dpr_linear = Dpy(linear_filename, 'w')
    dpr_linear.write_tracks(tracks_warped_linear)
    dpr_linear.close()         
def save_id_tract_plus_sff_in_ext(tracks_filename, id_file, num_proto, distance,  out_fname_ext , out_fname_sff_in_ext, thres_len= 2.2/3., thres_vol = 1.4 , thres_dis = 3./2.):
    
    
    tract_ext_id = save_id_tract_ext1(tracks_filename,id_file, distance, out_fname_ext, 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)
    	
    ext_not_tract_id = []
    ext_not_tract = []
    for idx in tract_ext_id:
        if idx not in tracks_id:
            ext_not_tract.append(all_tracks[idx])
            ext_not_tract_id.append(idx)
        
          
    ext_not_tract = np.array(ext_not_tract,dtype=np.object)        
    sff_pro_id = sff(ext_not_tract, num_proto, distance)        
    
    tract_sff_in_ext_id = []
    for i in tracks_id:
        tract_sff_in_ext_id.append(i)
        
    for k in sff_pro_id:        
        tract_sff_in_ext_id.append(ext_not_tract_id[k])
        
    #tract_sff_id.append(id_not_tract_fil[i] for i in sff_pro_id)
    print len(tracks_id), len(tract_sff_in_ext_id), len(tract_ext_id)
    save_pickle( out_fname_sff_in_ext, tract_sff_in_ext_id)
    return tract_sff_in_ext_id
Exemple #24
0
def test_dpy():
    fname = 'test.bin'
    with InTemporaryDirectory():
        dpw = Dpy(fname, 'w')
        A = np.ones((5, 3))
        B = 2 * A.copy()
        C = 3 * A.copy()
        dpw.write_track(A)
        dpw.write_track(B)
        dpw.write_track(C)
        dpw.write_tracks(Streamlines([C, B, A]))

        all_tracks = np.ascontiguousarray(np.vstack([A, B, C, C, B, A]))
        npt.assert_array_equal(all_tracks, dpw.tracks[:])
        dpw.close()

        dpr = Dpy(fname, 'r')
        npt.assert_equal(dpr.version() == u'0.0.1', True)
        T = dpr.read_tracksi([0, 1, 2, 0, 0, 2])
        T2 = dpr.read_tracks()
        npt.assert_equal(len(T2), 6)
        dpr.close()
        npt.assert_array_equal(A, T[0])
        npt.assert_array_equal(C, T[5])
Exemple #25
0
def warp_displacements_tracks(fdpy, ffa, fmat, finv, fdis, fdisa, fref, fdpyw):
    """ Warp tracks from native space to the FMRIB58/MNI space

    We use here the fsl displacements. Have a look at create_displacements to
    see an example of how to use these displacements.

    Parameters
    ------------
    fdpy : filename of the .dpy file with the tractography
    ffa : filename of nifti to be warped
    fmat : filename of .mat  (flirt)
    fdis :  filename of displacements (fnirtfileutils)
    fdisa :  filename of displacements (fnirtfileutils + affine)
    finv : filename of invwarp displacements (invwarp)
    fref : filename of reference volume e.g. (FMRIB58_FA_1mm.nii.gz)
    fdpyw : filename of the warped tractography


    See also
    -----------
    dipy.external.fsl.create_displacements

    """

    # read the tracks from the image space
    dpr = Dpy(fdpy, 'r')
    T = dpr.read_tracks()
    dpr.close()

    # copy them in a new file
    dpw = Dpy(fdpyw, 'w', compression=1)
    dpw.write_tracks(T)
    dpw.close()

    # from fa index to ref index
    res = flirt2aff_files(fmat, ffa, fref)

    # load the reference img
    imgref = nib.load(fref)
    refaff = imgref.get_affine()

    # load the invwarp displacements
    imginvw = nib.load(finv)
    invwdata = imginvw.get_data()
    invwaff = imginvw.get_affine()

    # load the forward displacements
    imgdis = nib.load(fdis)
    disdata = imgdis.get_data()

    # load the forward displacements + affine
    imgdis2 = nib.load(fdisa)
    disdata2 = imgdis2.get_data()

    # from their difference create the affine
    disaff = disdata2 - disdata

    del disdata
    del disdata2

    shape = nib.load(ffa).get_data().shape

    # transform the displacements affine back to image space
    disaff0 = affine_transform(disaff[..., 0], res[:3, :3], res[:3, 3], shape,
                               order=1)
    disaff1 = affine_transform(disaff[..., 1], res[:3, :3], res[:3, 3], shape,
                               order=1)
    disaff2 = affine_transform(disaff[..., 2], res[:3, :3], res[:3, 3], shape,
                               order=1)

    # remove the transformed affine from the invwarp displacements
    di = invwdata[:, :, :, 0] + disaff0
    dj = invwdata[:, :, :, 1] + disaff1
    dk = invwdata[:, :, :, 2] + disaff2

    dprw = Dpy(fdpyw, 'r+')
    rows = len(dprw.f.root.streamlines.tracks)
    blocks = np.round(np.linspace(0, rows, 10)).astype(int)  # lets work in
    #                                                                   blocks
    # print rows
    for i in range(len(blocks) - 1):
        # print blocks[i],blocks[i+1]
        # copy a lot of tracks together
        caboodle = dprw.f.root.streamlines.tracks[blocks[i]:blocks[i + 1]]
        mci = mc(di, caboodle.T, order=1)  # interpolations for i displacement
        mcj = mc(dj, caboodle.T, order=1)  # interpolations for j displacement
        mck = mc(dk, caboodle.T, order=1)  # interpolations for k displacement
        D = np.vstack((mci, mcj, mck)).T
        # go back to mni image space
        WI2 = np.dot(caboodle, res[:3, :3].T) + res[:3, 3] + D
        # and then to mni world space
        caboodlew = np.dot(WI2, refaff[:3, :3].T) + refaff[:3, 3]
        # write back
        dprw.f.root.streamlines.tracks[blocks[i]:blocks[i + 1]] = (
            caboodlew.astype('f4'))
    dprw.close()
Exemple #26
0
    def dpy(workingdir,
            input,
            compressed=None,
            restored=None,
            tol_error=0.01,
            force=False,
            coords_only=False,
            verbose=False):

        if not input.endswith('tck') and not input.endswith('trk'):
            # we need to convert
            print('Invalid format')
            return None

        if not compressed:
            compressed = input + '_compressed' + str(tol_error) + '.dpy'

        if not restored:
            restored = input + '_restored' + str(tol_error) + '.tck'

        original = os.path.join(workingdir, input)

        #
        # compression
        #
        c_time = -1
        if not os.path.exists(os.path.join(workingdir, compressed)) or force:
            # compress again!
            t0 = time.time()

            loaded_original = nib.streamlines.load(original, lazy_load=False)
            original_streamlines = loaded_original.streamlines

            # parameters from Presseau15 are 0.01 and inf
            c_streamlines = compress_streamlines(original_streamlines,
                                                 tol_error=tol_error,
                                                 max_segment_length=np.inf)

            # write dpy file
            # set compression to highest but it does have any effect
            dpw = Dpy(os.path.join(workingdir, compressed),
                      mode='w',
                      compression=9)
            for c_s in c_streamlines:
                dpw.write_track(c_s)
            dpw.close()

            c_time = time.time() - t0

            if verbose:
                print('compression done.')

        #
        # restoring
        #
        d_time = -1
        if not os.path.exists(os.path.join(workingdir, restored)) or force:
            # restore again!
            t0 = time.time()
            restored_data = Dpy(os.path.join(workingdir, compressed), mode='r')
            restored_streamlines = restored_data.read_tracks()
            restored_data.close()
            d_time = time.time() - t0

            with open(os.path.join(workingdir, restored), 'w') as f:
                f.write('restoredok.')

            if verbose:
                print('restoring done.')

        #
        # calculate errors
        #
        stats = compressed + '_stats' + str(tol_error) + '.p'
        if not os.path.exists(os.path.join(workingdir, stats)) or force:

            statsdata = Runner.error_per_streamlines(original_streamlines,
                                                     restored_streamlines)
            sizestatsdata = Runner.sizestats(
                os.path.join(workingdir, original),
                os.path.join(workingdir, compressed))

            statsdata = [
                c_time, d_time, sizestatsdata, statsdata[0], statsdata[1]
            ]

            with open(os.path.join(workingdir, stats), 'wb') as f:
                pickle.dump(statsdata, f)

        else:
            with open(os.path.join(workingdir, stats), 'rb') as f:
                statsdata = pickle.load(f)


        [c_time, d_time, sizestatsdata, (min_e, max_e, mean_e, std_e), (end_min_e, end_max_e, end_mean_e, end_std_e)] = \
          statsdata

        if verbose:
            print('Times', c_time, d_time)
            print('Size Stats', sizestatsdata)
            print('Error', min_e, max_e, mean_e, std_e)
            print('Endpoint Error', end_min_e, end_max_e, end_mean_e,
                  end_std_e)

        return statsdata
    #tracks_chosen_filename = 'ALS/ALS_Segmentation/s201_corticospinal_left_3M_Nivedita.pkl'
    #subj = 201    

    tracks_id=load_pickle(tracks_chosen_filename)     

    root = Tkinter.Tk()
    root.wm_title('Subject Selection')
    subsel = SubjectSelector(root, default_value=1)
    root.wait_window()
    mapping  = [0,101,201,102,202,103,203,104,204,105,205,106,206,107,207,109,208,110,209,111,210,112,212,113,213]    
    subj = mapping[subsel.value]
     
    #load the tracks
    tracks_filename = 'ALS/ALS_Data/'+str(subj)+'/DIFF2DEPI_EKJ_64dirs_14/DTI/tracks_dti_'+str(num_seeds)+'M_linear.dpy'    
    dpr_tracks = Dpy(tracks_filename, 'r')
    tensor_all_tracks=dpr_tracks.read_tracks();
    dpr_tracks.close()
    T = [tensor_all_tracks[i] for i in tracks_id]
        
    #print len(T)
    print len(tracks_id)
   
   #load the volume
    img = nib.load('ALS/ALS_Data/'+str(subj)+'/MP_Rage_1x1x1_ND_3/T1_flirt_out.nii.gz') 
    data = img.get_data()
    affine = img.get_affine()
    print len(data)    
        
    #T = [t for t in T if length(t)>= 15]

#    T = [downsample(t, 18) - np.array(data.shape[:3]) / 2. for t in T]
dirname = "ALS/ALS_Data/101"
for root, dirs, files in os.walk(dirname):
  if root.endswith('DTI'):
    #if root.endswith('101_32'):
    base_dir = root+'/'       
    basedir_recon = os.getcwd() + '/' + base_dir + '/'               
        
        #loading fa_image
    fa_file = basedir_recon + 'fa_warped.nii.gz'            
    fa_img = nib.load(fa_file)
    fa = fa_img.get_data()
    fa[np.isnan(fa)] = 0
    for i in range(len(tracks_filename_arr)):
        tracks_filename = basedir_recon + tracks_filename_arr[i]
        dpr_tracks = Dpy(tracks_filename, 'r')
        tensor_tracks_1=dpr_tracks.read_tracks();
        dpr_tracks.close()
        
        tensor_tracks = T
                
        #end of moi them vao 20130604
        #----------------------------------------------------------------------------        
    
        
        

        """
        We can now save the results in the disk. For this purpose we can use the
        TrackVis format (*.trk). First, we need to create a header.
        """
    do_simulated_annealing = True    

    iterations_random = 10000
    iterations_anneal = 1000

    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:
Exemple #30
0
    def ok(self):
        self.value = self.s.get()
        self.parent.destroy()


if __name__ == '__main__':

    #load T1 volume registered in MNI space
    #img = nib.load('data/subj_05/MPRAGE_32/T1_flirt_out.nii.gz')
    #data = img.get_data()
    #affine = img.get_affine()
    #load the tracks registered in MNI space
    fdpyw = 'data/subj_05/101_32/DTI/tracks_gqi_1M_linear.dpy'
    dpr = Dpy(fdpyw, 'r')
    T = dpr.read_tracks()
    dpr.close()
    #load initial QuickBundles with threshold 30mm
    fpkl = 'data/subj_05/101_32/DTI/qb_gqi_1M_linear_30.pkl'
    #qb=QuickBundles(T,30.,12)
    #save_pickle(fpkl,qb)
    qb = load_pickle(fpkl)

    #create the interaction system for tracks
    tl = TrackLabeler('Bundle Picker',
                      qb,
                      qb.downsampled_tracks(),
                      vol_shape=(182, 218, 182),
                      tracks_alpha=1)
    #add a interactive slicing/masking tool
    #sl = Slicer(affine,data)
Exemple #31
0
from dipy.io.dpy import Dpy
from dipy.tracking.distances import mam_distances, bundles_distances_mam
from dipy.viz import fvtk

if __name__ == '__main__':

    np.random.seed(0)

    filename = 'data/tracks_dti_10K_linear.dpy'
        
    dpr = Dpy(filename, 'r')
    tracks = dpr.read_tracks()
    dpr.close()
    tracks = np.array(tracks, dtype=np.object)

    size1 = 100
    size2 = 100
    tracks1 = tracks[np.random.permutation(len(tracks))[:size1]]
    tracks2 = tracks[np.random.permutation(len(tracks))[:size2]]
    # solution = np.random.permutation(len(tracks1))
    # tracks2 = tracks1[solution]
    # inverse_solution = np.argsort(solution)

    dm1 = bundles_distances_mam(tracks1, tracks1)
    dm2 = bundles_distances_mam(tracks2, tracks2)

    print "For each s1 and for each s2 we reorder their distances and create a mapping from the first ordered ids to the second ordered ids"
    print "Then we compute the loss of this mapping"
    print "This approach is suboptimal but should provide a very good guess."

    idx2_best = None
if __name__ == '__main__':

    do_random_search = False#True
    do_simulated_annealing = True

    iterations_random = 10000
    iterations_anneal = 1000
    
    two_tractography = True    
    
    if two_tractography == False:
        filename = 'data/tracks_dti_10K_linear.dpy'
        print "Loading", filename
        dpr = Dpy(filename, 'r')
        tractography = dpr.read_tracks()
        dpr.close()
        print len(tractography), "streamlines"
        print "Removing streamlines that are too short"
        tractography = filter(lambda x: len(x) > 20, tractography) # remove too short streamlines
        print len(tractography), "streamlines"    
        tractography = np.array(tractography, dtype=np.object)
    
        size1 = 100#100
        size2 = 100#100
        print "Creating two simulated tractographies of sizes", size1, "and", size2
        np.random.seed(1) # this is the random seed to create tractography1 and tractography2
        ids1 = np.random.permutation(len(tractography))[:size1]
        # ids1 = sff(tractography, k=size1, distance=bundles_distances_mam)
        # ids1 = fft(tractography, k=size1, distance=bundles_distances_mam)
        tractography1 = tractography[ids1]
Exemple #33
0
def warp_displacements_tracks(fdpy, ffa, fmat, finv, fdis, fdisa, fref, fdpyw):
    """ Warp tracks from native space to the FMRIB58/MNI space

    We use here the fsl displacements. Have a look at create_displacements to
    see an example of how to use these displacements.

    Parameters
    ------------
    fdpy : filename of the .dpy file with the tractography
    ffa : filename of nifti to be warped
    fmat : filename of .mat  (flirt)
    fdis :  filename of displacements (fnirtfileutils)
    fdisa :  filename of displacements (fnirtfileutils + affine)
    finv : filename of invwarp displacements (invwarp)
    fref : filename of reference volume e.g. (FMRIB58_FA_1mm.nii.gz)
    fdpyw : filename of the warped tractography


    See also
    -----------
    dipy.external.fsl.create_displacements

    """

    # read the tracks from the image space
    dpr = Dpy(fdpy, 'r')
    T = dpr.read_tracks()
    dpr.close()

    # copy them in a new file
    dpw = Dpy(fdpyw, 'w', compression=1)
    dpw.write_tracks(T)
    dpw.close()

    # from fa index to ref index
    res = flirt2aff_files(fmat, ffa, fref)

    # load the reference img
    imgref = nib.load(fref)
    refaff = imgref.affine

    # load the invwarp displacements
    imginvw = nib.load(finv)
    invwdata = imginvw.get_data()

    # load the forward displacements
    imgdis = nib.load(fdis)
    disdata = imgdis.get_data()

    # load the forward displacements + affine
    imgdis2 = nib.load(fdisa)
    disdata2 = imgdis2.get_data()

    # from their difference create the affine
    disaff = disdata2 - disdata

    del disdata
    del disdata2

    shape = nib.load(ffa).get_data().shape

    # transform the displacements affine back to image space
    disaff0 = affine_transform(disaff[..., 0], res[:3, :3], res[:3, 3], shape,
                               order=1)
    disaff1 = affine_transform(disaff[..., 1], res[:3, :3], res[:3, 3], shape,
                               order=1)
    disaff2 = affine_transform(disaff[..., 2], res[:3, :3], res[:3, 3], shape,
                               order=1)

    # remove the transformed affine from the invwarp displacements
    di = invwdata[:, :, :, 0] + disaff0
    dj = invwdata[:, :, :, 1] + disaff1
    dk = invwdata[:, :, :, 2] + disaff2

    dprw = Dpy(fdpyw, 'r+')
    rows = len(dprw.f.root.streamlines.tracks)
    blocks = np.round(np.linspace(0, rows, 10)).astype(int)  # lets work in
    #                                                                   blocks
    # print rows
    for i in range(len(blocks) - 1):
        # print blocks[i],blocks[i+1]
        # copy a lot of tracks together
        caboodle = dprw.f.root.streamlines.tracks[blocks[i]:blocks[i + 1]]
        mci = mc(di, caboodle.T, order=1)  # interpolations for i displacement
        mcj = mc(dj, caboodle.T, order=1)  # interpolations for j displacement
        mck = mc(dk, caboodle.T, order=1)  # interpolations for k displacement
        D = np.vstack((mci, mcj, mck)).T
        # go back to mni image space
        WI2 = np.dot(caboodle, res[:3, :3].T) + res[:3, 3] + D
        # and then to mni world space
        caboodlew = np.dot(WI2, refaff[:3, :3].T) + refaff[:3, 3]
        # write back
        dprw.f.root.streamlines.tracks[blocks[i]:blocks[i + 1]] = (
            caboodlew.astype('f4'))
    dprw.close()
    subsel = SubjectSelector(root, default_value=1)
    root.wait_window()
    mapping  = [0,101,201,102,202,103,203,104,204,105,205,106,206,107,207,109,208,110,209,111,210,112,212,113,213]    
    subj = mapping[subsel.value]
     
     
    #load the volume
    img = nib.load('ALS_Data/'+str(subj)+'/MP_Rage_1x1x1_ND_3/T1_flirt_out.nii.gz') 
    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. 
def load_tracks(filename):
    dpr = Dpy(filename, "r")
    tracks = dpr.read_tracks()
    dpr.close()
    return tracks
Exemple #36
0
def load_tractogram(filename,
                    reference,
                    to_space=Space.RASMM,
                    shifted_origin=False,
                    bbox_valid_check=True,
                    trk_header_check=True):
    """ Load the stateful tractogram from any format (trk, tck, vtk, fib, dpy)

    Parameters
    ----------
    filename : string
        Filename with valid extension
    reference : Nifti or Trk filename, Nifti1Image or TrkFile, Nifti1Header or
        trk.header (dict), or 'same' if the input is a trk file.
        Reference that provides the spatial attribute.
        Typically a nifti-related object from the native diffusion used for
        streamlines generation
    to_space : Enum (dipy.io.stateful_tractogram.Space)
        Space to which the streamlines will be transformed after loading.
    shifted_origin : bool
        Information on the position of the origin,
        False is Trackvis standard, default (center of the voxel)
        True is NIFTI standard (corner of the voxel)
    bbox_valid_check : bool
        Verification for negative voxel coordinates or values above the
        volume dimensions. Default is True, to enforce valid file.
    trk_header_check : bool
        Verification that the reference has the same header as the spatial
        attributes as the input tractogram when a Trk is loaded

    Returns
    -------
    output : StatefulTractogram
        The tractogram to load (must have been saved properly)
    """
    _, extension = os.path.splitext(filename)
    if extension not in ['.trk', '.tck', '.vtk', '.fib', '.dpy']:
        logging.error('Output filename is not one of the supported format')
        return False

    if to_space not in Space:
        logging.error('Space MUST be one of the 3 choices (Enum)')
        return False

    if reference == 'same':
        if extension == '.trk':
            reference = filename
        else:
            logging.error('Reference must be provided, "same" is only ' +
                          'available for Trk file.')
            return False

    if trk_header_check and extension == '.trk':
        if not is_header_compatible(filename, reference):
            logging.error('Trk file header does not match the provided ' +
                          'reference')
            return False

    timer = time.time()
    data_per_point = None
    data_per_streamline = None
    if extension in ['.trk', '.tck']:
        tractogram_obj = nib.streamlines.load(filename).tractogram
        streamlines = tractogram_obj.streamlines
        if extension == '.trk':
            data_per_point = tractogram_obj.data_per_point
            data_per_streamline = tractogram_obj.data_per_streamline

    elif extension in ['.vtk', '.fib']:
        streamlines = load_vtk_streamlines(filename)
    elif extension in ['.dpy']:
        dpy_obj = Dpy(filename, mode='r')
        streamlines = list(dpy_obj.read_tracks())
        dpy_obj.close()
    logging.debug('Load %s with %s streamlines in %s seconds', filename,
                  len(streamlines), round(time.time() - timer, 3))

    sft = StatefulTractogram(streamlines,
                             reference,
                             Space.RASMM,
                             shifted_origin=shifted_origin,
                             data_per_point=data_per_point,
                             data_per_streamline=data_per_streamline)

    if to_space == Space.VOX:
        sft.to_vox()
    elif to_space == Space.VOXMM:
        sft.to_voxmm()

    if bbox_valid_check and not sft.is_bbox_in_vox_valid():
        raise ValueError('Bounding box is not valid in voxel space, cannot ' +
                         'load a valid file if some coordinates are invalid.' +
                         'Please set bbox_valid_check to False and then use' +
                         'the function remove_invalid_streamlines to discard' +
                         'invalid streamlines.')

    return sft
     filename = 'ALS_Data/101/DIFF2DEPI_EKJ_64dirs_14/DTI/tracks_dti_10K.dpy'
     prototype_policies = ['random', 'fft', 'sff']
     color_policies = ['ko--', 'kx:', 'k^-']
 elif figure=='big_dataset':
     filename = 'ALS_Data/101/DIFF2DEPI_EKJ_64dirs_14/DTI/tracks_dti_3M.dpy'
     prototype_policies = ['random', 'sff']
     color_policies = ['ko--', 'k^-']
 
 num_trks = [500,1000,5000,10000,15000,0]
 num_clusters = [50,150,250]
 num_prototypes = 40
 
 
 print "Loading tracks."
 dpr = Dpy(filename, 'r')
 tracks_all = dpr.read_tracks()
 dpr.close()
 tracks_all = np.array(tracks_all, dtype=np.object)
 t_batch=0
 t_batch_random=0
 print "Num tracks \t num clusters \t btree \t dissimilarity \t minibatch (random) \t medoids"
 for i in range(len(num_trks)):   
   
     ##############################################################################
     # define some parameters
     num_trk = num_trks[i]        
     if num_trk!=0:
         tracks = tracks_all[:num_trk]
     else:
         tracks = tracks_all
     print "tracks:", tracks.size