def sdt(training, category, snr, denoised, odeconv, tv, method, weight=0.1):
data, affine, gtab, mask, evals, S0, prefix = prepare(training,
category,
snr,
denoised,
odeconv,
tv,
method)
if category == 'dti':
csdt_model = ConstrainedSDTModel(gtab, ratio = evals[1] / evals[0], sh_order=6)
if category == 'hardi':
csdt_model = ConstrainedSDTModel(gtab, ratio = evals[1] / evals[0], sh_order=8)
csdt_fit = csdt_model.fit(data, mask)
sphere = get_sphere('symmetric724')
odf = csdt_fit.odf(sphere)
if tv == True:
odf = tv_denoise_4d(odf, weight=weight)
save_odfs_peaks(training, odf, affine, sphere, dres, prefix)
def test_odfdeconv():
SNR = 100
S0 = 1
_, fbvals, fbvecs = get_data('small_64D')
bvals = np.load(fbvals)
bvecs = np.load(fbvecs)
gtab = gradient_table(bvals, bvecs)
mevals = np.array(([0.0015, 0.0003, 0.0003],
[0.0015, 0.0003, 0.0003]))
angles = [(0, 0), (90, 0)]
S, sticks = multi_tensor(gtab, mevals, S0, angles=angles,
fractions=[50, 50], snr=SNR)
sphere = get_sphere('symmetric362')
odf_gt = multi_tensor_odf(sphere.vertices, mevals, angles, [50, 50])
e1 = 15.0
e2 = 3.0
ratio = e2 / e1
csd = ConstrainedSDTModel(gtab, ratio, None)
csd_fit = csd.fit(S)
fodf = csd_fit.odf(sphere)
directions, _, _ = peak_directions(odf_gt, sphere)
directions2, _, _ = peak_directions(fodf, sphere)
ang_sim = angular_similarity(directions, directions2)
assert_equal(ang_sim > 1.9, True)
assert_equal(directions.shape[0], 2)
assert_equal(directions2.shape[0], 2)
with warnings.catch_warnings(record=True) as w:
ConstrainedSDTModel(gtab, ratio, sh_order=10)
assert_equal(len(w) > 0, True)
with warnings.catch_warnings(record=True) as w:
ConstrainedSDTModel(gtab, ratio, sh_order=8)
assert_equal(len(w) > 0, False)
csd_fit = csd.fit(np.zeros_like(S))
fodf = csd_fit.odf(sphere)
assert_array_equal(fodf, np.zeros_like(fodf))
odf_sh = np.zeros_like(fodf)
odf_sh[1] = np.nan
fodf, it = odf_deconv(odf_sh, csd.R, csd.B_reg)
assert_array_equal(fodf, np.zeros_like(fodf))
def test_odfdeconv():
SNR = 100
S0 = 1
_, fbvals, fbvecs = get_data('small_64D')
bvals = np.load(fbvals)
bvecs = np.load(fbvecs)
gtab = gradient_table(bvals, bvecs)
mevals = np.array(([0.0015, 0.0003, 0.0003], [0.0015, 0.0003, 0.0003]))
S, sticks = multi_tensor(gtab,
mevals,
S0,
angles=[(0, 0), (90, 0)],
fractions=[50, 50],
snr=SNR)
sphere = get_sphere('symmetric724')
mevecs = [all_tensor_evecs(sticks[0]).T, all_tensor_evecs(sticks[1]).T]
odf_gt = multi_tensor_odf(sphere.vertices, [0.5, 0.5], mevals, mevecs)
e1 = 15.0
e2 = 3.0
ratio = e2 / e1
csd = ConstrainedSDTModel(gtab, ratio, None)
csd_fit = csd.fit(S)
fodf = csd_fit.odf(sphere)
directions, _, _ = peak_directions(odf_gt, sphere)
directions2, _, _ = peak_directions(fodf, sphere)
ang_sim = angular_similarity(directions, directions2)
assert_equal(ang_sim > 1.9, True)
assert_equal(directions.shape[0], 2)
assert_equal(directions2.shape[0], 2)
with warnings.catch_warnings(record=True) as w:
ConstrainedSDTModel(gtab, ratio, sh_order=10)
assert_equal(len(w) > 0, True)
with warnings.catch_warnings(record=True) as w:
ConstrainedSDTModel(gtab, ratio, sh_order=8)
assert_equal(len(w) > 0, False)
def test_r2_term_odf_sharp():
SNR = None
S0 = 1
angle = 45 # 45 degrees is a very tight angle to disentangle
_, fbvals, fbvecs = get_data('small_64D') # get_data('small_64D')
bvals = np.load(fbvals)
bvecs = np.load(fbvecs)
sphere = get_sphere('symmetric724')
gtab = gradient_table(bvals, bvecs)
mevals = np.array(([0.0015, 0.0003, 0.0003], [0.0015, 0.0003, 0.0003]))
angles = [(0, 0), (angle, 0)]
S, sticks = multi_tensor(gtab,
mevals,
S0,
angles=angles,
fractions=[50, 50],
snr=SNR)
odf_gt = multi_tensor_odf(sphere.vertices, mevals, angles, [50, 50])
odfs_sh = sf_to_sh(odf_gt, sphere, sh_order=8, basis_type=None)
fodf_sh = odf_sh_to_sharp(odfs_sh,
sphere,
basis=None,
ratio=3 / 15.,
sh_order=8,
lambda_=1.,
tau=0.1,
r2_term=True)
fodf = sh_to_sf(fodf_sh, sphere, sh_order=8, basis_type=None)
directions_gt, _, _ = peak_directions(odf_gt, sphere)
directions, _, _ = peak_directions(fodf, sphere)
ang_sim = angular_similarity(directions_gt, directions)
assert_equal(ang_sim > 1.9, True)
assert_equal(directions.shape[0], 2)
# This should pass as well
sdt_model = ConstrainedSDTModel(gtab, ratio=3 / 15., sh_order=8)
sdt_fit = sdt_model.fit(S)
fodf = sdt_fit.odf(sphere)
directions_gt, _, _ = peak_directions(odf_gt, sphere)
directions, _, _ = peak_directions(fodf, sphere)
ang_sim = angular_similarity(directions_gt, directions)
assert_equal(ang_sim > 1.9, True)
assert_equal(directions.shape[0], 2)
def test_r2_term_odf_sharp():
SNR = None
S0 = 1
angle = 45 #45 degrees is a very tight angle to disentangle
_, fbvals, fbvecs = get_data('small_64D') #get_data('small_64D')
bvals = np.load(fbvals)
bvecs = np.load(fbvecs)
sphere = get_sphere('symmetric724')
gtab = gradient_table(bvals, bvecs)
mevals = np.array(([0.0015, 0.0003, 0.0003],
[0.0015, 0.0003, 0.0003]))
angles = [(0, 0), (angle, 0)]
S, sticks = multi_tensor(gtab, mevals, S0, angles=angles,
fractions=[50, 50], snr=SNR)
odf_gt = multi_tensor_odf(sphere.vertices, mevals, angles, [50, 50])
odfs_sh = sf_to_sh(odf_gt, sphere, sh_order=8, basis_type=None)
fodf_sh = odf_sh_to_sharp(odfs_sh, sphere, basis=None, ratio=3 / 15.,
sh_order=8, lambda_=1., tau=0.1, r2_term=True)
fodf = sh_to_sf(fodf_sh, sphere, sh_order=8, basis_type=None)
directions_gt, _, _ = peak_directions(odf_gt, sphere)
directions, _, _ = peak_directions(fodf, sphere)
ang_sim = angular_similarity(directions_gt, directions)
assert_equal(ang_sim > 1.9, True)
assert_equal(directions.shape[0], 2)
# This should pass as well
sdt_model = ConstrainedSDTModel(gtab, ratio=3/15., sh_order=8)
sdt_fit = sdt_model.fit(S)
fodf = sdt_fit.odf(sphere)
directions_gt, _, _ = peak_directions(odf_gt, sphere)
directions, _, _ = peak_directions(fodf, sphere)
ang_sim = angular_similarity(directions_gt, directions)
assert_equal(ang_sim > 1.9, True)
assert_equal(directions.shape[0], 2)
def test_odfdeconv():
SNR = 100
S0 = 1
_, fbvals, fbvecs = get_fnames('small_64D')
bvals, bvecs = read_bvals_bvecs(fbvals, fbvecs)
gtab = gradient_table(bvals, bvecs)
mevals = np.array(([0.0015, 0.0003, 0.0003], [0.0015, 0.0003, 0.0003]))
angles = [(0, 0), (90, 0)]
S, _ = multi_tensor(gtab,
mevals,
S0,
angles=angles,
fractions=[50, 50],
snr=SNR)
sphere = get_sphere('symmetric362')
odf_gt = multi_tensor_odf(sphere.vertices, mevals, angles, [50, 50])
e1 = 15.0
e2 = 3.0
ratio = e2 / e1
csd = ConstrainedSDTModel(gtab, ratio, None)
csd_fit = csd.fit(S)
fodf = csd_fit.odf(sphere)
directions, _, _ = peak_directions(odf_gt, sphere)
directions2, _, _ = peak_directions(fodf, sphere)
ang_sim = angular_similarity(directions, directions2)
assert_equal(ang_sim > 1.9, True)
assert_equal(directions.shape[0], 2)
assert_equal(directions2.shape[0], 2)
with warnings.catch_warnings(record=True) as w:
ConstrainedSDTModel(gtab, ratio, sh_order=10)
assert_equal(len(w) > 0, True)
with warnings.catch_warnings(record=True) as w:
ConstrainedSDTModel(gtab, ratio, sh_order=8)
assert_equal(len(w) > 0, False)
csd_fit = csd.fit(np.zeros_like(S))
fodf = csd_fit.odf(sphere)
assert_array_equal(fodf, np.zeros_like(fodf))
odf_sh = np.zeros_like(fodf)
odf_sh[1] = np.nan
fodf, _ = odf_deconv(odf_sh, csd.R, csd.B_reg)
assert_array_equal(fodf, np.zeros_like(fodf))
def test_odfdeconv():
SNR = 100
S0 = 1
_, fbvals, fbvecs = get_fnames('small_64D')
bvals, bvecs = read_bvals_bvecs(fbvals, fbvecs)
gtab = gradient_table(bvals, bvecs)
mevals = np.array(([0.0015, 0.0003, 0.0003], [0.0015, 0.0003, 0.0003]))
angles = [(0, 0), (90, 0)]
S, _ = multi_tensor(gtab,
mevals,
S0,
angles=angles,
fractions=[50, 50],
snr=SNR)
sphere = get_sphere('symmetric362')
odf_gt = multi_tensor_odf(sphere.vertices, mevals, angles, [50, 50])
e1 = 15.0
e2 = 3.0
ratio = e2 / e1
csd = ConstrainedSDTModel(gtab, ratio, None)
csd_fit = csd.fit(S)
fodf = csd_fit.odf(sphere)
directions, _, _ = peak_directions(odf_gt, sphere)
directions2, _, _ = peak_directions(fodf, sphere)
ang_sim = angular_similarity(directions, directions2)
assert_equal(ang_sim > 1.9, True)
assert_equal(directions.shape[0], 2)
assert_equal(directions2.shape[0], 2)
with warnings.catch_warnings(record=True) as w:
ConstrainedSDTModel(gtab, ratio, sh_order=10)
w_count = len(w)
# A warning is expected from the ConstrainedSDTModel constructor
# and additionnal warnings should be raised where legacy SH bases
# are used
assert_equal(w_count > 1, True)
with warnings.catch_warnings(record=True) as w:
ConstrainedSDTModel(gtab, ratio, sh_order=8)
# Test that the warning from ConstrainedSDTModel
# constructor is no more raised
assert_equal(len(w) == w_count - 1, True)
csd_fit = csd.fit(np.zeros_like(S))
fodf = csd_fit.odf(sphere)
assert_array_equal(fodf, np.zeros_like(fodf))
odf_sh = np.zeros_like(fodf)
odf_sh[1] = np.nan
fodf, _ = odf_deconv(odf_sh, csd.R, csd.B_reg)
assert_array_equal(fodf, np.zeros_like(fodf))
def test_r2_term_odf_sharp():
SNR = None
S0 = 1
angle = 45 # 45 degrees is a very tight angle to disentangle
_, fbvals, fbvecs = get_fnames('small_64D') # get_fnames('small_64D')
bvals, bvecs = read_bvals_bvecs(fbvals, fbvecs)
sphere = default_sphere
gtab = gradient_table(bvals, bvecs)
mevals = np.array(([0.0015, 0.0003, 0.0003], [0.0015, 0.0003, 0.0003]))
angles = [(0, 0), (angle, 0)]
S, _ = multi_tensor(gtab,
mevals,
S0,
angles=angles,
fractions=[50, 50],
snr=SNR)
odf_gt = multi_tensor_odf(sphere.vertices, mevals, angles, [50, 50])
with warnings.catch_warnings():
warnings.filterwarnings("ignore",
message=descoteaux07_legacy_msg,
category=PendingDeprecationWarning)
odfs_sh = sf_to_sh(odf_gt, sphere, sh_order=8, basis_type=None)
with warnings.catch_warnings():
warnings.filterwarnings("ignore",
message=descoteaux07_legacy_msg,
category=PendingDeprecationWarning)
fodf_sh = odf_sh_to_sharp(odfs_sh,
sphere,
basis=None,
ratio=3 / 15.,
sh_order=8,
lambda_=1.,
tau=0.1,
r2_term=True)
with warnings.catch_warnings():
warnings.filterwarnings("ignore",
message=descoteaux07_legacy_msg,
category=PendingDeprecationWarning)
fodf = sh_to_sf(fodf_sh, sphere, sh_order=8, basis_type=None)
directions_gt, _, _ = peak_directions(odf_gt, sphere)
directions, _, _ = peak_directions(fodf, sphere)
ang_sim = angular_similarity(directions_gt, directions)
assert_equal(ang_sim > 1.9, True)
assert_equal(directions.shape[0], 2)
# This should pass as well
with warnings.catch_warnings():
warnings.filterwarnings("ignore",
message=descoteaux07_legacy_msg,
category=PendingDeprecationWarning)
sdt_model = ConstrainedSDTModel(gtab, ratio=3 / 15., sh_order=8)
sdt_fit = sdt_model.fit(S)
with warnings.catch_warnings():
warnings.filterwarnings("ignore",
message=descoteaux07_legacy_msg,
category=PendingDeprecationWarning)
fodf = sdt_fit.odf(sphere)
directions_gt, _, _ = peak_directions(odf_gt, sphere)
directions, _, _ = peak_directions(fodf, sphere)
ang_sim = angular_similarity(directions_gt, directions)
assert_equal(ang_sim > 1.9, True)
assert_equal(directions.shape[0], 2)
ratio = l01[1] / l01[0]
#ratio = 0.2
from dipy.data import get_sphere
sphere = get_sphere('symmetric724')
# csd_model = ConstrainedSphericalDeconvModel(gtab, (evals, S0), regul_sphere = sphere)
# csd_fit = csd_model.fit(data[25 - 10:25 + 10, 25 - 10:25 + 10, 25])
# csd_odf = csd_fit.odf(sphere)
# from dipy.viz import fvtk
# r = fvtk.ren()
# fvtk.add(r, fvtk.sphere_funcs(csd_odf, sphere))
# fvtk.show(r)
csdt_model = ConstrainedSDTModel(gtab, ratio, regul_sphere = sphere)
csdt_fit = csdt_model.fit(data[25 - 10:25 + 10, 25 - 10:25 + 10, 25])
csdt_odf = csdt_fit.odf(sphere)
from dipy.viz import fvtk
r = fvtk.ren()
fvtk.clear(r)
fvtk.add(r, fvtk.sphere_funcs(csdt_odf, sphere))
fvtk.show(r)
