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)
def write_tracks(fdpy,scalar,indices,seed_no=10**6,a_thr=.2,compression=1):
eudx=EuDX(scalar,indices,seed_no=seed_no,a_low=a_thr)
#exi=iter(eudx)
dpw=Dpy(fdpy,'w',compression=1)
#for (i,track) in enumerate(exi):
for track in eudx:
dpw.write_track(track.astype(np.float32))
dpw.close()
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 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'
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])
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
"""
from dipy.io.dpy import Dpy
dpw = Dpy('fornix.dpy', 'w')
"""
Write many streamlines at once.
"""
dpw.write_tracks(streamlines)
"""
Write one track
"""
dpw.write_track(streamlines[0])
"""
or one track each time.
"""
for t in streamlines:
dpw.write_track(t)
dpw.close()
"""
Read streamlines directly from the disk using their indices
.. include:: ../links_names.inc
"""
Here is a simple example.
"""
from dipy.io.dpy import Dpy
dpw = Dpy('fornix.dpy', 'w')
"""
Write many streamlines at once.
"""
dpw.write_tracks(streamlines2)
"""
Write one track
"""
dpw.write_track(streamlines2[0])
"""
or one track each time.
"""
for t in streamlines:
dpw.write_track(t)
dpw.close()
"""
Read streamlines directly from the disk using their indices
.. include:: ../links_names.inc
"""
dpr = Dpy('fornix.dpy', 'r')
* extendable
"""
from dipy.io.dpy import Dpy
dpw = Dpy('fornix.dpy', 'w')
"""
write many tracks at once
"""
dpw.write_tracks(tracks2)
"""
write one track
"""
dpw.write_track(tracks2[0] * 6)
"""
or one track each time
"""
for t in tracks:
dpw.write_track(t * 3)
dpw.close()
"""
read tracks directly from the disk using their indices
"""
dpr = Dpy('fornix.dpy', 'r')
some_tracks = dpr.read_tracksi([0, 10, 20, 30, 100])
dpr.close()
def create_native_tracks(subj,fnames,data_type='qa'):
#initial raw data
fname =dname+fnames[subj]+'.nii.gz'
#bvecs
fbvecs=dname+fnames[subj]+'.bvec'
#bvals
fbvals=dname+fnames[subj]+'.bval'
#beted initial data
fbet =dname+fnames[subj]+'_bet.nii.gz'
#fa
ffa =dname+fnames[subj]+'_bet_FA.nii.gz'
#qa
fqa =dname+fnames[subj]+'_bet_QA.nii.gz'
#normalization factor for qa
fqan =dname+fnames[subj]+'_bet_QA_normalization.txt'
#qa warperd in fmrib58
fqaw =dname+fnames[subj]+'_bet_QA_warp.nii.gz'
#mask after bet was applied
fmask =dname+fnames[subj]+'_bet_mask.nii.gz'
#mean diffusivity
fmd =dname+fnames[subj]+'_bet_MD.nii.gz'
#b0 volume
fs0 =dname+fnames[subj]+'_bet_S0.nii.gz'
#fa registerd in fmri58
ffareg=dname+fnames[subj]+'_bet_FA_reg.nii.gz'
#affine transformation matrix (from flirt before nonlinear registration)
faff =dname+fnames[subj]+'_affine_transf.mat'
#image after transforming(warping) (splines)
fnon =dname+fnames[subj]+'_nonlin_transf.nii.gz'#look at fa_to_fmrib58
#nonlinear displacements
fdis =dname+fnames[subj]+'_nonlin_displacements.nii.gz'#look at fa_to_fmrib58
#warped md
fmdw =dname+fnames[subj]+'_bet_MD_warp.nii.gz'
#warped s0
fs0w =dname+fnames[subj]+'_bet_S0_warp.nii.gz'
#warped fa tracks
ffa_warp_dpy =dname+fnames[subj]+'_FA_warp.dpy'
#warped qa tracks
#fqa_warp_dpy =dname+fnames[subj]+'_QA_warp.dpy'
fqa_warp_dpy =dname+fnames[subj]+'_QA_warp2.dpy'
#native fa tracks
ffa_native_dpy =dname+fnames[subj]+'_FA_native.dpy'
#native qa tracks
fqa_native_dpy =dname+fnames[subj]+'_QA_native.dpy'
#remove scalp
#bet(fname,fbet)
#read skull stripped image and get affine
img=ni.load(fbet)
data=img.get_data()
affine=img.get_affine()
bvals=np.loadtxt(fbvals)
gradients=np.loadtxt(fbvecs).T
#load mask
mask_img=ni.load(fmask)
mask=mask_img.get_data()
mask_affine=mask_img.get_affine()
print 'mask.shape',mask.shape
#calculate Tensor
if data_type=='fa':
ten=dp.Tensor(data,bvals,gradients,thresh=50)
#uncomment if you want to save FA,MD,S0 unwarped/warped
#imgFA=ni.Nifti1Image(ten.fa(),affine)
#imgMD=ni.Nifti1Image(ten.md(),affine)
#imgS0=ni.Nifti1Image(data[:,:,:,0].astype(np.uint16),affine)
#ni.save(imgFA,ffa)
#ni.save(imgMD,fmd)
#ni.save(imgS0,fs0)
#fa_to_fmrib58(ffa,faff,fnon,ffareg)
#apply_warp(fmd,faff,fnon,fmdw)
#apply_warp(fs0,faff,fnon,fs0w)
#calculate GQI
if data_type=='qa':
gqs=dp.GeneralizedQSampling(data,bvals,gradients,mask=mask)
print('save normalization factor')
fobjn=open(fqan,'w')
fobjn.write(str(gqs.glob_norm_param))
fobjn.close()
print('save qa image')
imgQA=ni.Nifti1Image(gqs.QA,affine)
ni.save(imgQA,fqa)
print('warp qa to fmrib58')
apply_warp(fqa,faff,fnon,fqaw)
if data_type=='fa':
#eudx=EuDX(ten.FA,ten.IN,seed_list=img_pts,qa_thr=.2)
eudx=EuDX(ten.FA,ten.IN,seed_no=5*10**6,qa_thr=.2)
fnative_dpy=ffa_native_dpy
fwarp_dpy = ffa_warp_dpy
if data_type=='qa':
#eudx=EuDX(gqs.QA,gqs.IN,seed_list=img_pts,qa_thr=0.0239)
eudx=EuDX(gqs.QA,gqs.IN,seed_no=5*10**6,qa_thr=0.0239)
fnative_dpy=fqa_native_dpy
fwarp_dpy = fqa_warp_dpy
exi=iter(eudx)
print(fnative_dpy)
dpw=Dpy(fnative_dpy,'w')
#print(fwarp_dpy)
#dpww=Dpy(fwarp_dpy,'w')
for (i,track) in enumerate(exi):
dpw.write_track(track.astype(np.float32))
dpw.close()
"""
from dipy.io.dpy import Dpy
dpw=Dpy('fornix.dpy','w')
"""
write many tracks at once
"""
dpw.write_tracks(tracks2)
"""
write one track
"""
dpw.write_track(tracks2[0]*6)
"""
or one track each time
"""
for t in tracks:
dpw.write_track(t*3)
dpw.close()
"""
read tracks directly from the disk using their indices
"""
dpr=Dpy('fornix.dpy','r')
def generate_gqi_tracks_and_warp_in_MNI_space(fname,dname):
fbvals=fname+'.bval'
fbvecs=fname+'.bvec'
fdata=fname+'.nii.gz'
if os.path.isfile(fdata):
pass
else:
fdata=fname+'.nii'
if os.path.isfile(fdata)==False:
print('Data do not exist')
return
dti_dname=os.path.join(dname,'DTI')
if os.path.isdir(dti_dname):
pass
else:
os.mkdir(dti_dname)
print dti_dname
gqi_dname=os.path.join(dname,'GQI')
if os.path.isdir(gqi_dname):
pass
else:
os.mkdir(gqi_dname)
print gqi_dname
fdatabet=fname+'_bet.nii.gz'
if os.path.isfile(fdatabet):
pass
else:
print('fdatabet does not exist')
img=nib.load(fdatabet)
data=img.get_data()
affine=img.get_affine()
bvals=np.loadtxt(fbvals)
bvecs=np.loadtxt(fbvecs).T
gqs=GeneralizedQSampling(data,bvals,bvecs)
eu=EuDX(gqs.qa(),gqs.ind(),seeds=10**6,a_low=0.0239)
fdpy=pjoin(gqi_dname,'lsc_QA.dpy')
dpw=Dpy(fdpy,'w',compression=1)
for track in eu:
dpw.write_track(track.astype(np.float32))
dpw.close()
local=dti_dname
fmat=pjoin(local,'flirt.mat')
fnon=pjoin(local,'fnirt.nii.gz')
finv=pjoin(local,'invw.nii.gz')
fdis=pjoin(local,'dis.nii.gz')
fdisa=pjoin(local,'disa.nii.gz')
ffa=pjoin(local,'FA_bet.nii.gz')
fdpyw=pjoin(gqi_dname,'lsc_QA_ref.dpy')
#print fdatabet
#print fmat
#print fnon
print fdpy
print fdpyw
read_warp_save_tracks(fdpy,ffa,fmat,finv,fdis,fdisa,fref,fdpyw)
