def test_ascm_accuracy():
test_ascm_data_ref = nib.load(dpd.get_data("ascm_test")).get_data()
test_data = nib.load(dpd.get_data("aniso_vox")).get_data()
# the test data was constructed in this manner
mask = test_data > 50
sigma = estimate_sigma(test_data, N=4)
den_small = non_local_means(
test_data,
sigma=sigma,
mask=mask,
patch_radius=1,
block_radius=1,
rician=True)
den_large = non_local_means(
test_data,
sigma=sigma,
mask=mask,
patch_radius=2,
block_radius=1,
rician=True)
S0n = np.array(adaptive_soft_matching(test_data,
den_small, den_large, sigma[0]))
assert_array_almost_equal(S0n, test_ascm_data_ref)
def test_dipy_fit_tensor():
with InTemporaryDirectory() as tmp:
dwi, bval, bvec = get_data("small_25")
# Copy data to tmp directory
shutil.copyfile(dwi, "small_25.nii.gz")
shutil.copyfile(bval, "small_25.bval")
shutil.copyfile(bvec, "small_25.bvec")
# Call script
cmd = ["dipy_fit_tensor", "--mask=none", "small_25.nii.gz"]
out = run_command(" ".join(cmd))
assert_equal(out[0], 0)
# Get expected values
img = nib.load("small_25.nii.gz")
affine = img.get_affine()
shape = img.shape[:-1]
# Check expected outputs
assert_image_shape_affine("small_25_fa.nii.gz", shape, affine)
assert_image_shape_affine("small_25_t2di.nii.gz", shape, affine)
assert_image_shape_affine("small_25_dirFA.nii.gz", shape, affine)
assert_image_shape_affine("small_25_ad.nii.gz", shape, affine)
assert_image_shape_affine("small_25_md.nii.gz", shape, affine)
assert_image_shape_affine("small_25_rd.nii.gz", shape, affine)
with InTemporaryDirectory() as tmp:
dwi, bval, bvec = get_data("small_25")
# Copy data to tmp directory
shutil.copyfile(dwi, "small_25.nii.gz")
shutil.copyfile(bval, "small_25.bval")
shutil.copyfile(bvec, "small_25.bvec")
# Call script
cmd = ["dipy_fit_tensor", "--save-tensor", "--mask=none", "small_25.nii.gz"]
out = run_command(" ".join(cmd))
assert_equal(out[0], 0)
# Get expected values
img = nib.load("small_25.nii.gz")
affine = img.get_affine()
shape = img.shape[:-1]
# Check expected outputs
assert_image_shape_affine("small_25_fa.nii.gz", shape, affine)
assert_image_shape_affine("small_25_t2di.nii.gz", shape, affine)
assert_image_shape_affine("small_25_dirFA.nii.gz", shape, affine)
assert_image_shape_affine("small_25_ad.nii.gz", shape, affine)
assert_image_shape_affine("small_25_md.nii.gz", shape, affine)
assert_image_shape_affine("small_25_rd.nii.gz", shape, affine)
# small_25_tensor saves the tensor as a symmetric matrix following
# the nifti standard.
ten_shape = shape + (1, 6)
assert_image_shape_affine("small_25_tensor.nii.gz", ten_shape,
affine)
def test_fit_dti():
# Let's see whether we can pass a list of files for each one:
fdata1, fbval1, fbvec1 = dpd.get_data('small_101D')
fdata2, fbval2, fbvec2 = dpd.get_data('small_101D')
with nbtmp.InTemporaryDirectory() as tmpdir:
file_dict = dti.fit_dti([fdata1, fdata2],
[fbval1, fbval2],
[fbvec1, fbvec2],
out_dir=tmpdir)
for f in file_dict.values():
npt.assert_(op.exists(f))
def test_nlls_fit_tensor():
"""
Test the implementation of NLLS and RESTORE
"""
b0 = 1000.
bvecs, bval = read_bvec_file(get_data('55dir_grad.bvec'))
gtab = grad.gradient_table(bval, bvecs)
B = bval[1]
#Scale the eigenvalues and tensor by the B value so the units match
D = np.array([1., 1., 1., 0., 0., 1., -np.log(b0) * B]) / B
evals = np.array([2., 1., 0.]) / B
md = evals.mean()
tensor = from_lower_triangular(D)
#Design Matrix
X = dti.design_matrix(bvecs, bval)
#Signals
Y = np.exp(np.dot(X,D))
Y.shape = (-1,) + Y.shape
#Estimate tensor from test signals and compare against expected result
#using non-linear least squares:
tensor_model = dti.TensorModel(gtab, fit_method='NLLS')
tensor_est = tensor_model.fit(Y)
assert_equal(tensor_est.shape, Y.shape[:-1])
assert_array_almost_equal(tensor_est.evals[0], evals)
assert_array_almost_equal(tensor_est.quadratic_form[0], tensor)
assert_almost_equal(tensor_est.md[0], md)
# Using the gmm weighting scheme:
tensor_model = dti.TensorModel(gtab, fit_method='NLLS', weighting='gmm')
assert_equal(tensor_est.shape, Y.shape[:-1])
assert_array_almost_equal(tensor_est.evals[0], evals)
assert_array_almost_equal(tensor_est.quadratic_form[0], tensor)
assert_almost_equal(tensor_est.md[0], md)
# Use NLLS with some actual 4D data:
data, bvals, bvecs = get_data('small_25')
gtab = grad.gradient_table(bvals, bvecs)
tm1 = dti.TensorModel(gtab, fit_method='NLLS')
dd = nib.load(data).get_data()
tf1 = tm1.fit(dd)
tm2 = dti.TensorModel(gtab)
tf2 = tm2.fit(dd)
assert_array_almost_equal(tf1.fa, tf2.fa, decimal=1)
def test_btable_prepare():
sq2 = np.sqrt(2) / 2.
bvals = 1500 * np.ones(7)
bvals[0] = 0
bvecs = np.array([[0, 0, 0],
[1, 0, 0],
[0, 1, 0],
[0, 0, 1],
[sq2, sq2, 0],
[sq2, 0, sq2],
[0, sq2, sq2]])
bt = gradient_table(bvals, bvecs)
npt.assert_array_equal(bt.bvecs, bvecs)
bt.info
fimg, fbvals, fbvecs = get_data('small_64D')
bvals = np.load(fbvals)
bvecs = np.load(fbvecs)
bvecs = np.where(np.isnan(bvecs), 0, bvecs)
bt = gradient_table(bvals, bvecs)
npt.assert_array_equal(bt.bvecs, bvecs)
bt2 = gradient_table(bvals, bvecs.T)
npt.assert_array_equal(bt2.bvecs, bvecs)
btab = np.concatenate((bvals[:, None], bvecs), axis=1)
bt3 = gradient_table(btab)
npt.assert_array_equal(bt3.bvecs, bvecs)
npt.assert_array_equal(bt3.bvals, bvals)
bt4 = gradient_table(btab.T)
npt.assert_array_equal(bt4.bvecs, bvecs)
npt.assert_array_equal(bt4.bvals, bvals)
# Test for proper inputs (expects either bvals/bvecs or 4 by n):
assert_raises(ValueError, gradient_table, bvecs)
def test_eudx_bad_seed():
"""Test passing a bad seed to eudx"""
fimg, fbvals, fbvecs = get_data('small_101D')
img = ni.load(fimg)
affine = img.affine
data = img.get_data()
gtab = gradient_table(fbvals, fbvecs)
tensor_model = TensorModel(gtab)
ten = tensor_model.fit(data)
ind = quantize_evecs(ten.evecs)
sphere = get_sphere('symmetric724')
seed = [1000000., 1000000., 1000000.]
eu = EuDX(a=ten.fa, ind=ind, seeds=[seed],
odf_vertices=sphere.vertices, a_low=.2)
assert_raises(ValueError, list, eu)
print(data.shape)
seed = [1., 5., 8.]
eu = EuDX(a=ten.fa, ind=ind, seeds=[seed],
odf_vertices=sphere.vertices, a_low=.2)
track = list(eu)
seed = [-1., 1000000., 1000000.]
eu = EuDX(a=ten.fa, ind=ind, seeds=[seed],
odf_vertices=sphere.vertices, a_low=.2)
assert_raises(ValueError, list, eu)
def test_all_zeros():
bvecs, bvals = read_bvec_file(get_data('55dir_grad.bvec'))
gtab = grad.gradient_table_from_bvals_bvecs(bvals, bvecs.T)
fit_methods = ['LS', 'OLS', 'NNLS', 'RESTORE']
for _ in fit_methods:
dm = dti.TensorModel(gtab)
assert_array_almost_equal(dm.fit(np.zeros(bvals.shape[0])).evals, 0)
def test_nnls_jacobian_fucn():
b0 = 1000.
bvecs, bval = read_bvec_file(get_data('55dir_grad.bvec'))
gtab = grad.gradient_table(bval, bvecs)
B = bval[1]
# Scale the eigenvalues and tensor by the B value so the units match
D = np.array([1., 1., 1., 0., 0., 1., -np.log(b0) * B]) / B
# Design Matrix
X = dti.design_matrix(gtab)
# Signals
Y = np.exp(np.dot(X, D))
# Test Jacobian at D
args = [X, Y]
analytical = dti._nlls_jacobian_func(D, *args)
for i in range(len(X)):
args = [X[i], Y[i]]
approx = opt.approx_fprime(D, dti._nlls_err_func, 1e-8, *args)
assert_true(np.allclose(approx, analytical[i]))
# Test Jacobian at zero
D = np.zeros_like(D)
args = [X, Y]
analytical = dti._nlls_jacobian_func(D, *args)
for i in range(len(X)):
args = [X[i], Y[i]]
approx = opt.approx_fprime(D, dti._nlls_err_func, 1e-8, *args)
assert_true(np.allclose(approx, analytical[i]))
def test_qb_commandline():
with InTemporaryDirectory():
tracks_file = get_data('fornix')
cmd = ["dipy_quickbundles", tracks_file, '--pkl_file', 'mypickle.pkl',
'--out_file', 'tracks300.trk']
out = run_command(cmd)
assert_equal(out[0], 0)
def test_masked_array_with_tensor():
data = np.ones((2, 4, 56))
mask = np.array([[True, False, False, True],
[True, False, True, False]])
bvec, bval = read_bvec_file(get_data('55dir_grad.bvec'))
gtab = grad.gradient_table_from_bvals_bvecs(bval, bvec.T)
tensor_model = TensorModel(gtab)
tensor = tensor_model.fit(data, mask=mask)
assert_equal(tensor.shape, (2, 4))
assert_equal(tensor.fa.shape, (2, 4))
assert_equal(tensor.evals.shape, (2, 4, 3))
assert_equal(tensor.evecs.shape, (2, 4, 3, 3))
tensor = tensor[0]
assert_equal(tensor.shape, (4,))
assert_equal(tensor.fa.shape, (4,))
assert_equal(tensor.evals.shape, (4, 3))
assert_equal(tensor.evecs.shape, (4, 3, 3))
tensor = tensor[0]
assert_equal(tensor.shape, tuple())
assert_equal(tensor.fa.shape, tuple())
assert_equal(tensor.evals.shape, (3,))
assert_equal(tensor.evecs.shape, (3, 3))
assert_equal(type(tensor.model_params), np.ndarray)
def test_force_overwrite():
with TemporaryDirectory() as out_dir:
data_path, _, _ = get_data('small_25')
mo_flow = MedianOtsuFlow(output_strategy='absolute')
# Generate the first results
mo_flow.run(data_path, out_dir=out_dir)
mask_file = mo_flow.last_generated_outputs['out_mask']
first_time = os.path.getmtime(mask_file)
# re-run with no force overwrite, modified time should not change
mo_flow.run(data_path, out_dir=out_dir)
mask_file = mo_flow.last_generated_outputs['out_mask']
second_time = os.path.getmtime(mask_file)
assert first_time == second_time
# re-run with force overwrite, modified time should change
mo_flow = MedianOtsuFlow(output_strategy='absolute', force=True)
# Make sure that at least one second elapsed, so that time-stamp is
# different (sometimes measured in whole seconds)
time.sleep(1)
mo_flow.run(data_path, out_dir=out_dir)
mask_file = mo_flow.last_generated_outputs['out_mask']
third_time = os.path.getmtime(mask_file)
assert third_time != second_time
def test_median_otsu_flow():
with TemporaryDirectory() as out_dir:
data_path, _, _ = get_data('small_25')
volume = nib.load(data_path).get_data()
save_masked = True
median_radius = 3
numpass = 3
autocrop = False
vol_idx = [0]
dilate = 0
mo_flow = MedianOtsuFlow()
mo_flow.run(data_path, out_dir=out_dir, save_masked=save_masked,
median_radius=median_radius, numpass=numpass,
autocrop=autocrop, vol_idx=vol_idx, dilate=dilate)
mask_name = mo_flow.last_generated_outputs['out_mask']
masked_name = mo_flow.last_generated_outputs['out_masked']
masked, mask = median_otsu(volume, median_radius,
numpass, autocrop,
vol_idx, dilate)
result_mask_data = nib.load(join(out_dir, mask_name)).get_data()
npt.assert_array_equal(result_mask_data, mask)
result_masked_data = nib.load(join(out_dir, masked_name)).get_data()
npt.assert_array_equal(result_masked_data, masked)
def test_csd_superres():
""" Check the quality of csdfit with high SH order. """
_, fbvals, fbvecs = get_data('small_64D')
bvals = np.load(fbvals)
bvecs = np.load(fbvecs)
gtab = gradient_table(bvals, bvecs)
# img, gtab = read_stanford_hardi()
evals = np.array([[1.5, .3, .3]]) * [[1.], [1.]] / 1000.
S, sticks = multi_tensor(gtab, evals, snr=None, fractions=[55., 45.])
model16 = ConstrainedSphericalDeconvModel(gtab, (evals[0], 3.),
sh_order=16)
fit16 = model16.fit(S)
# print local_maxima(fit16.odf(default_sphere), default_sphere.edges)
d, v, ind = peak_directions(fit16.odf(default_sphere), default_sphere,
relative_peak_threshold=.2,
min_separation_angle=0)
# Check that there are two peaks
assert_equal(len(d), 2)
# Check that peaks line up with sticks
cos_sim = abs((d * sticks).sum(1)) ** .5
assert_(all(cos_sim > .99))
def get_synthetic_warped_circle(nslices):
#get a subsampled circle
fname_cicle = get_data('reg_o')
circle = np.load(fname_cicle)[::4,::4].astype(floating)
#create a synthetic invertible map and warp the circle
d, dinv = vfu.create_harmonic_fields_2d(64, 64, 0.1, 4)
d = np.asarray(d, dtype=floating)
dinv = np.asarray(dinv, dtype=floating)
mapping = DiffeomorphicMap(2, (64, 64))
mapping.forward, mapping.backward = d, dinv
wcircle = mapping.transform(circle)
if(nslices == 1):
return circle, wcircle
#normalize and form the 3d by piling slices
circle = (circle-circle.min())/(circle.max() - circle.min())
circle_3d = np.ndarray(circle.shape + (nslices,), dtype=floating)
circle_3d[...] = circle[...,None]
circle_3d[...,0] = 0
circle_3d[...,-1] = 0
#do the same with the warped circle
wcircle = (wcircle-wcircle.min())/(wcircle.max() - wcircle.min())
wcircle_3d = np.ndarray(wcircle.shape + (nslices,), dtype=floating)
wcircle_3d[...] = wcircle[...,None]
wcircle_3d[...,0] = 0
wcircle_3d[...,-1] = 0
return circle_3d, wcircle_3d
def test_response_from_mask():
fdata, fbvals, fbvecs = get_data('small_64D')
bvals = np.load(fbvals)
bvecs = np.load(fbvecs)
data = nib.load(fdata).get_data()
gtab = gradient_table(bvals, bvecs)
ten = TensorModel(gtab)
tenfit = ten.fit(data)
FA = fractional_anisotropy(tenfit.evals)
FA[np.isnan(FA)] = 0
radius = 3
for fa_thr in np.arange(0, 1, 0.1):
response_auto, ratio_auto, nvoxels = auto_response(gtab,
data,
roi_center=None,
roi_radius=radius,
fa_thr=fa_thr,
return_number_of_voxels=True)
ci, cj, ck = np.array(data.shape[:3]) / 2
mask = np.zeros(data.shape[:3])
mask[ci - radius: ci + radius,
cj - radius: cj + radius,
ck - radius: ck + radius] = 1
mask[FA <= fa_thr] = 0
response_mask, ratio_mask = response_from_mask(gtab, data, mask)
assert_equal(int(np.sum(mask)), nvoxels)
assert_array_almost_equal(response_mask[0], response_auto[0])
assert_almost_equal(response_mask[1], response_auto[1])
assert_almost_equal(ratio_mask, ratio_auto)
def test_eudx():
# read bvals,gradients and data
fimg, fbvals, fbvecs = get_data("small_64D")
bvals = np.load(fbvals)
gradients = np.load(fbvecs)
img = ni.load(fimg)
data = img.get_data()
print(data.shape)
gqs = GeneralizedQSampling(data, bvals, gradients)
ten = Tensor(data, bvals, gradients, thresh=50)
seed_list = np.dot(np.diag(np.arange(10)), np.ones((10, 3)))
iT = iter(EuDX(gqs.qa(), gqs.ind(), seeds=seed_list))
T = []
for t in iT:
T.append(t)
iT2 = iter(EuDX(ten.fa(), ten.ind(), seeds=seed_list))
T2 = []
for t in iT2:
T2.append(t)
print("length T ", sum([length(t) for t in T]))
print("length T2", sum([length(t) for t in T2]))
print(gqs.QA[1, 4, 8, 0])
print(gqs.QA.ravel()[ndarray_offset(np.array([1, 4, 8, 0]), np.array(gqs.QA.strides), 4, 8)])
assert_almost_equal(
gqs.QA[1, 4, 8, 0], gqs.QA.ravel()[ndarray_offset(np.array([1, 4, 8, 0]), np.array(gqs.QA.strides), 4, 8)]
)
assert_almost_equal(sum([length(t) for t in T]), 70.999996185302734, places=3)
assert_almost_equal(sum([length(t) for t in T2]), 56.999997615814209, places=3)
def test_r2_term_odf_sharp():
SNR = None
S0 = 1
angle = 75
_, 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]))
S, sticks = multi_tensor(gtab, mevals, S0, angles=[(0, 0), (angle, 0)],
fractions=[50, 50], snr=SNR)
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)
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)
def test_csd_predict():
"""
"""
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), (60, 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])
response = (np.array([0.0015, 0.0003, 0.0003]), S0)
csd = ConstrainedSphericalDeconvModel(gtab, response)
csd_fit = csd.fit(S)
prediction = csd_predict(csd_fit.shm_coeff, gtab, response=response, S0=S0)
npt.assert_equal(prediction.shape[0], S.shape[0])
model_prediction = csd.predict(csd_fit.shm_coeff)
assert_array_almost_equal(prediction, model_prediction)
# Roundtrip tests (quite inaccurate, because of regularization):
assert_array_almost_equal(csd_fit.predict(gtab, S0=S0),S,decimal=1)
assert_array_almost_equal(csd.predict(csd_fit.shm_coeff, S0=S0),S,decimal=1)
def test_exponential_iso():
fdata, fbvals, fbvecs = dpd.get_data()
data_dti = nib.load(fdata).get_data()
gtab_dti = grad.gradient_table(fbvals, fbvecs)
data_multi, gtab_multi = dpd.dsi_deconv_voxels()
for data, gtab in zip([data_dti, data_multi], [gtab_dti, gtab_multi]):
sfmodel = sfm.SparseFascicleModel(
gtab, isotropic=sfm.ExponentialIsotropicModel)
sffit1 = sfmodel.fit(data[0, 0, 0])
sphere = dpd.get_sphere()
odf1 = sffit1.odf(sphere)
pred1 = sffit1.predict(gtab)
SNR = 1000
S0 = 100
mevals = np.array(([0.0015, 0.0005, 0.0005],
[0.0015, 0.0005, 0.0005]))
angles = [(0, 0), (60, 0)]
S, sticks = sims.multi_tensor(gtab, mevals, S0, angles=angles,
fractions=[50, 50], snr=SNR)
sffit = sfmodel.fit(S)
pred = sffit.predict()
npt.assert_(xval.coeff_of_determination(pred, S) > 96)
def test_eudx_further():
""" Cause we love testin.. ;-)
"""
fimg, fbvals, fbvecs = get_data("small_101D")
img = ni.load(fimg)
affine = img.get_affine()
bvals = np.loadtxt(fbvals)
gradients = np.loadtxt(fbvecs).T
data = img.get_data()
ten = Tensor(data, bvals, gradients, thresh=50)
x, y, z = data.shape[:3]
seeds = np.zeros((10 ** 4, 3))
for i in range(10 ** 4):
rx = (x - 1) * np.random.rand()
ry = (y - 1) * np.random.rand()
rz = (z - 1) * np.random.rand()
seeds[i] = np.ascontiguousarray(np.array([rx, ry, rz]), dtype=np.float64)
# print seeds
# """
eu = EuDX(a=ten.fa(), ind=ten.ind(), seeds=seeds, a_low=0.2)
T = [e for e in eu]
# check that there are no negative elements
for t in T:
assert_equal(np.sum(t.ravel() < 0), 0)
"""
def test_sphere_scaling_csdmodel():
"""Check that mirroring regularization sphere does not change the result of
the model"""
_, 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), (60, 0)]
S, sticks = multi_tensor(gtab, mevals, 100., angles=angles,
fractions=[50, 50], snr=None)
hemi = small_sphere
sphere = hemi.mirror()
response = (np.array([0.0015, 0.0003, 0.0003]), 100)
model_full = ConstrainedSphericalDeconvModel(gtab, response,
reg_sphere=sphere)
model_hemi = ConstrainedSphericalDeconvModel(gtab, response,
reg_sphere=hemi)
csd_fit_full = model_full.fit(S)
csd_fit_hemi = model_hemi.fit(S)
assert_array_almost_equal(csd_fit_full.shm_coeff, csd_fit_hemi.shm_coeff)
def test_passing_maskedview():
data = np.ones((2,4,56))
mask = np.array([[True, False, False, True],
[True, False, True, False]])
gtab, bval = read_bvec_file(get_data('55dir_grad.bvec'))
data = data[mask]
mv = MaskedView(mask, data)
tensor = dti.Tensor(mv, bval, gtab.T, min_signal=1e-9)
assert_equal(tensor.shape, (2,4))
assert_equal(tensor.fa().shape, (2,4))
assert_equal(tensor.evals.shape, (2,4,3))
assert_equal(tensor.evecs.shape, (2,4,3,3))
assert_equal(type(tensor.model_params), MaskedView)
assert_array_equal(tensor.mask, mask)
tensor = tensor[0]
assert_equal(tensor.shape, (4,))
assert_equal(tensor.fa().shape, (4,))
assert_equal(tensor.evals.shape, (4,3))
assert_equal(tensor.evecs.shape, (4,3,3))
assert_equal(type(tensor.model_params), MaskedView)
assert_array_equal(tensor.mask, mask[0])
tensor = tensor[0]
assert_equal(tensor.shape, tuple())
assert_equal(tensor.fa().shape, tuple())
assert_equal(tensor.evals.shape, (3,))
assert_equal(tensor.evecs.shape, (3,3))
assert_equal(type(tensor.model_params), np.ndarray)
def test_sfm():
fdata, fbvals, fbvecs = dpd.get_data()
data = nib.load(fdata).get_data()
gtab = grad.gradient_table(fbvals, fbvecs)
sfmodel = sfm.SparseFascicleModel(gtab)
sffit1 = sfmodel.fit(data[0, 0, 0])
sphere = dpd.get_sphere("symmetric642")
odf1 = sffit1.odf(sphere)
pred1 = sffit1.predict(gtab)
mask = np.ones(data.shape[:-1])
sffit2 = sfmodel.fit(data, mask)
pred2 = sffit2.predict(gtab)
odf2 = sffit2.odf(sphere)
sffit3 = sfmodel.fit(data)
pred3 = sffit3.predict(gtab)
odf3 = sffit3.odf(sphere)
npt.assert_almost_equal(pred3, pred2, decimal=2)
npt.assert_almost_equal(pred3[0, 0, 0], pred1, decimal=2)
npt.assert_almost_equal(odf3[0, 0, 0], odf1, decimal=2)
npt.assert_almost_equal(odf3[0, 0, 0], odf2[0, 0, 0], decimal=2)
# Fit zeros and you will get back zeros
npt.assert_almost_equal(
sfmodel.fit(np.zeros(data[0, 0, 0].shape)).beta, np.zeros(sfmodel.design_matrix[0].shape[-1])
)
def test_eudx_bad_seed():
"""Test passing a bad seed to eudx"""
fimg, fbvals, fbvecs = get_data('small_101D')
img = ni.load(fimg)
affine = img.get_affine()
data = img.get_data()
gtab = gradient_table(fbvals, fbvecs)
tensor_model = TensorModel(gtab)
ten = tensor_model.fit(data)
ind = quantize_evecs(ten.evecs)
seed = [1000000., 1000000., 1000000.]
eu = EuDX(a=ten.fa, ind=ind, seeds=[seed], a_low=.2)
try:
track = list(eu)
except ValueError as ve:
if ve.args[0] == 'Seed outside boundaries':
print(ve)
print(data.shape)
seed = [1., 5., 8.]
eu = EuDX(a=ten.fa, ind=ind, seeds=[seed], a_low=.2)
track = list(eu)
seed = [-1., 1000000., 1000000.]
eu = EuDX(a=ten.fa, ind=ind, seeds=[seed], a_low=.2)
try:
track = list(eu)
except ValueError as ve:
if ve.args[0] == 'Seed outside boundaries':
print(ve)
def uniform_seed_grid():
#read bvals,gradients and data
fimg,fbvals, fbvecs = get_data('small_64D')
bvals=np.load(fbvals)
gradients=np.load(fbvecs)
img =ni.load(fimg)
data=img.get_data()
x,y,z,g=data.shape
M=np.mgrid[.5:x-.5:np.complex(0,x),.5:y-.5:np.complex(0,y),.5:z-.5:np.complex(0,z)]
M=M.reshape(3,x*y*z).T
print(M.shape)
print(M.dtype)
for m in M:
print(m)
gqs = GeneralizedQSampling(data,bvals,gradients)
iT=iter(EuDX(gqs.QA,gqs.IN,seeds=M))
T=[]
for t in iT:
T.append(i)
print('lenT',len(T))
assert_equal(len(T), 1221)
def reconst_flow_core(flow, extra_args=[]):
with TemporaryDirectory() as out_dir:
data_path, bval_path, bvec_path = get_data('small_25')
vol_img = nib.load(data_path)
volume = vol_img.get_data()
mask = np.ones_like(volume[:, :, :, 0])
mask_img = nib.Nifti1Image(mask.astype(np.uint8), vol_img.affine)
mask_path = join(out_dir, 'tmp_mask.nii.gz')
nib.save(mask_img, mask_path)
dti_flow = flow()
args = [data_path, bval_path, bvec_path, mask_path]
args.extend(extra_args)
dti_flow.run(*args, out_dir=out_dir)
fa_path = dti_flow.last_generated_outputs['out_fa']
fa_data = nib.load(fa_path).get_data()
assert_equal(fa_data.shape, volume.shape[:-1])
tensor_path = dti_flow.last_generated_outputs['out_tensor']
tensor_data = nib.load(tensor_path)
assert_equal(tensor_data.shape[-1], 6)
assert_equal(tensor_data.shape[:-1], volume.shape[:-1])
ga_path = dti_flow.last_generated_outputs['out_ga']
ga_data = nib.load(ga_path).get_data()
assert_equal(ga_data.shape, volume.shape[:-1])
rgb_path = dti_flow.last_generated_outputs['out_rgb']
rgb_data = nib.load(rgb_path)
assert_equal(rgb_data.shape[-1], 3)
assert_equal(rgb_data.shape[:-1], volume.shape[:-1])
md_path = dti_flow.last_generated_outputs['out_md']
md_data = nib.load(md_path).get_data()
assert_equal(md_data.shape, volume.shape[:-1])
ad_path = dti_flow.last_generated_outputs['out_ad']
ad_data = nib.load(ad_path).get_data()
assert_equal(ad_data.shape, volume.shape[:-1])
rd_path = dti_flow.last_generated_outputs['out_rd']
rd_data = nib.load(rd_path).get_data()
assert_equal(rd_data.shape, volume.shape[:-1])
mode_path = dti_flow.last_generated_outputs['out_mode']
mode_data = nib.load(mode_path).get_data()
assert_equal(mode_data.shape, volume.shape[:-1])
evecs_path = dti_flow.last_generated_outputs['out_evec']
evecs_data = nib.load(evecs_path).get_data()
assert_equal(evecs_data.shape[-2:], tuple((3, 3)))
assert_equal(evecs_data.shape[:-2], volume.shape[:-1])
evals_path = dti_flow.last_generated_outputs['out_eval']
evals_data = nib.load(evals_path).get_data()
assert_equal(evals_data.shape[-1], 3)
assert_equal(evals_data.shape[:-1], volume.shape[:-1])
def test_restore():
"""
Test the implementation of the RESTORE algorithm
"""
b0 = 1000.
bvecs, bval = read_bvec_file(get_data('55dir_grad.bvec'))
gtab = grad.gradient_table(bval, bvecs)
B = bval[1]
#Scale the eigenvalues and tensor by the B value so the units match
D = np.array([1., 1., 1., 0., 0., 1., -np.log(b0) * B]) / B
evals = np.array([2., 1., 0.]) / B
md = evals.mean()
tensor = from_lower_triangular(D)
#Design Matrix
X = dti.design_matrix(gtab)
#Signals
Y = np.exp(np.dot(X,D))
Y.shape = (-1,) + Y.shape
for drop_this in range(1, Y.shape[-1]):
# RESTORE estimates should be robust to dropping
this_y = Y.copy()
this_y[:, drop_this] = 1.0
tensor_model = dti.TensorModel(gtab, fit_method='restore',
sigma=67.0)
tensor_est = tensor_model.fit(this_y)
assert_array_almost_equal(tensor_est.evals[0], evals, decimal=3)
assert_array_almost_equal(tensor_est.quadratic_form[0], tensor,
decimal=3)
def test_median_otsu():
fname = get_data('S0_10')
img = nib.load(fname)
data = img.get_data()
data = np.squeeze(data)
dummy_mask = data > data.mean()
data_masked, mask = median_otsu(data, median_radius=3, numpass=2,
autocrop=False, vol_idx=None,
dilate=None)
assert_equal(mask.sum() < dummy_mask.sum(), True)
data2 = np.zeros(data.shape + (2,))
data2[..., 0] = data
data2[..., 1] = data
data2_masked, mask2 = median_otsu(data2, median_radius=3, numpass=2,
autocrop=False, vol_idx=[0, 1],
dilate=None)
assert_equal(mask.sum() == mask2.sum(), True)
_, mask3 = median_otsu(data2, median_radius=3, numpass=2,
autocrop=False, vol_idx=[0, 1],
dilate=1)
assert_equal(mask2.sum() < mask3.sum(), True)
_, mask4 = median_otsu(data2, median_radius=3, numpass=2,
autocrop=False, vol_idx=[0, 1],
dilate=2)
assert_equal(mask3.sum() < mask4.sum(), True)
def test_eudx_further():
""" Cause we love testin.. ;-)
"""
fimg,fbvals,fbvecs=get_data('small_101D')
img=ni.load(fimg)
affine=img.get_affine()
data=img.get_data()
gtab = gradient_table(fbvals, fbvecs)
tensor_model = TensorModel(gtab)
ten = tensor_model.fit(data)
x,y,z=data.shape[:3]
seeds=np.zeros((10**4,3))
for i in range(10**4):
rx=(x-1)*np.random.rand()
ry=(y-1)*np.random.rand()
rz=(z-1)*np.random.rand()
seeds[i]=np.ascontiguousarray(np.array([rx,ry,rz]),dtype=np.float64)
ind = quantize_evecs(ten.evecs)
eu=EuDX(a=ten.fa, ind=ind, seeds=seeds, a_low=.2)
T=[e for e in eu]
#check that there are no negative elements
for t in T:
assert_equal(np.sum(t.ravel()<0),0)
def test_dandelion():
fimg,fbvals,fbvecs=get_data('small_101D')
bvals=np.loadtxt(fbvals)
gradients=np.loadtxt(fbvecs).T
data=nib.load(fimg).get_data()
print(bvals.shape, gradients.shape, data.shape)
sd=SphericalDandelion(data,bvals,gradients)
sdf=sd.spherical_diffusivity(data[5,5,5])
XA=sd.xa()
np.set_printoptions(2)
print XA.min(),XA.max(),XA.mean()
print sdf*10**4
"""
print(sdf.shape)
gq=GeneralizedQSampling(data,bvals,gradients)
sodf=gq.odf(data[5,5,5])
vertices, faces = get_sphere('symmetric362')
print(faces.shape)
peaks,inds=peak_finding(np.squeeze(sdf),faces)
print(peaks, inds)
peaks2,inds2=peak_finding(np.squeeze(sodf),faces)
print(peaks2, inds2)
"""
'''
import dipy.reconst.fwdti as fwdti
from dipy.reconst.fwdti import fwdti_prediction
from numpy.testing import (assert_array_almost_equal, assert_almost_equal)
from nose.tools import assert_raises
from dipy.reconst.dti import (from_lower_triangular, decompose_tensor,
fractional_anisotropy)
from dipy.reconst.fwdti import (lower_triangular_to_cholesky,
cholesky_to_lower_triangular, nls_fit_tensor,
wls_fit_tensor)
from dipy.sims.voxel import (multi_tensor, single_tensor, all_tensor_evecs,
multi_tensor_dki)
from dipy.io.gradients import read_bvals_bvecs
from dipy.core.gradients import gradient_table
from dipy.data import get_data
fimg, fbvals, fbvecs = get_data('small_64D')
bvals, bvecs = read_bvals_bvecs(fbvals, fbvecs)
gtab = gradient_table(bvals, bvecs)
# FW model requires multishell data
bvals_2s = np.concatenate((bvals, bvals * 1.5), axis=0)
bvecs_2s = np.concatenate((bvecs, bvecs), axis=0)
gtab_2s = gradient_table(bvals_2s, bvecs_2s)
# Simulation a typical DT and DW signal for no water contamination
S0 = np.array(100)
dt = np.array([0.0017, 0, 0.0003, 0, 0, 0.0003])
evals, evecs = decompose_tensor(from_lower_triangular(dt))
S_tissue = single_tensor(gtab_2s, S0=100, evals=evals, evecs=evecs, snr=None)
dm = dti.TensorModel(gtab_2s, 'WLS')
dtifit = dm.fit(S_tissue)
``get_data`` provides data for a small region of interest from a real diffusion
weighted MR dataset acquired with 102 gradients (including one for b=0).
In order to make this work with your data you should comment out the line below
and add the paths for your nifti file (``*.nii`` or ``*.nii.gz``) and your
``*.bvec`` and ``*.bval files``.
If you are not using nifti files or you don't know how to create the ``*.bvec``
and ``*.bval`` files from your raw dicom (``*.dcm``) data then you can either
try the example called ``dcm_2_tracks.py`` or use mricron_ to convert the dicom
files to nii, bvec and bval files using ``dcm2nii``.
.. _mricron: http://www.cabiatl.com/mricro/mricron
"""
fimg, fbvals, fbvecs = get_data('small_101D')
"""
**Load the nifti file found at path fimg as an Nifti1Image.**
"""
img = nib.load(fimg)
"""
**Read the datasets from the Nifti1Image.**
"""
data = img.get_data()
print('data.shape (%d,%d,%d,%d)' % data.shape)
"""
This produces the output::
data.shape (6,10,10,102)
First import the necessary modules.
"""
import numpy as np
from nibabel import trackvis as tv
from dipy.tracking.streamline import Streamlines
from dipy.segment.clustering import QuickBundles
from dipy.io.pickles import save_pickle
from dipy.data import get_data
from dipy.viz import window, actor
"""
For educational purposes we will try to cluster a small streamline bundle known
from neuroanatomy as the fornix.
"""
fname = get_data('fornix')
"""
Load fornix streamlines.
"""
streams, hdr = tv.read(fname)
streamlines = [i[0] for i in streams]
"""
Perform QuickBundles clustering using the MDF metric and a 10mm distance
threshold. Keep in mind that since the MDF metric requires streamlines to have
the same number of points, the clustering algorithm will internally use a
representation of streamlines that have been automatically downsampled/upsampled
so they have only 12 points (To set manually the number of points,
see :ref:`clustering-examples-ResampleFeature`).
"""
def test_read_bvals_bvecs():
fimg, fbvals, fbvecs = get_data('small_101D')
bvals, bvecs = read_bvals_bvecs(fbvals, fbvecs)
gt = gradient_table(bvals, bvecs)
npt.assert_array_equal(bvals, gt.bvals)
npt.assert_array_equal(bvecs, gt.bvecs)
# None should also work as an input:
bvals_none, bvecs_none = read_bvals_bvecs(None, fbvecs)
npt.assert_array_equal(bvecs_none, gt.bvecs)
bvals_none, bvecs_none = read_bvals_bvecs(fbvals, None)
npt.assert_array_equal(bvals_none, gt.bvals)
# Test for error raising with unknown file formats:
nan_fbvecs = osp.splitext(fbvecs)[0] + '.nan' # Nonsense extension
npt.assert_raises(ValueError, read_bvals_bvecs, fbvals, nan_fbvecs)
# Test for error raising with incorrect file-contents:
with InTemporaryDirectory():
# These bvecs only have two rows/columns:
new_bvecs1 = bvecs[:, :2]
# Make a temporary file
with open('test_bv_file1.txt', 'wt') as bv_file1:
# And fill it with these 2-columned bvecs:
for x in range(new_bvecs1.shape[0]):
bv_file1.write('%s %s\n' % (new_bvecs1[x][0],
new_bvecs1[x][1]))
npt.assert_raises(IOError, read_bvals_bvecs, fbvals, 'test_bv_file1.txt')
# These bvecs are saved as one long array:
new_bvecs2 = np.ravel(bvecs)
with open('test_bv_file2.npy', 'w') as bv_file2:
print('FILENAME:', bv_file2.name)
np.save(bv_file2.name, new_bvecs2)
npt.assert_raises(IOError, read_bvals_bvecs, fbvals, 'test_bv_file2.npy')
# There are less bvecs than bvals:
new_bvecs3 = bvecs[:-1, :]
with open('test_bv_file3.txt', 'w') as bv_file3:
np.savetxt(bv_file3.name, new_bvecs3)
npt.assert_raises(IOError, read_bvals_bvecs, fbvals, 'test_bv_file3.txt')
# You entered the bvecs on both sides:
npt.assert_raises(IOError, read_bvals_bvecs, fbvecs, fbvecs)
# All possible delimiters should work
bv_file4 = 'test_space.txt'
with open(bv_file4, 'w') as f:
f.write("66 55 33")
bvals_1, _ = read_bvals_bvecs(bv_file4, '')
bv_file5 = 'test_coma.txt'
with open(bv_file5, 'w') as f:
f.write("66, 55, 33")
bvals_2, _ = read_bvals_bvecs(bv_file5, '')
bv_file6 = 'test_tabs.txt'
with open(bv_file6, 'w') as f:
f.write("66 \t 55 \t 33")
bvals_3, _ = read_bvals_bvecs(bv_file6, '')
ans = np.array([66., 55., 33.])
npt.assert_array_equal(ans, bvals_1)
npt.assert_array_equal(ans, bvals_2)
npt.assert_array_equal(ans, bvals_3)
bv_file7 = 'test_space_2.txt'
with open(bv_file7, 'w') as f:
f.write("66 55 33\n45 34 21\n55 32 65\n")
_, bvecs_1 = read_bvals_bvecs('', bv_file7)
bv_file8 = 'test_coma_2.txt'
with open(bv_file8, 'w') as f:
f.write("66, 55, 33\n45, 34, 21 \n 55, 32, 65\n")
_, bvecs_2 = read_bvals_bvecs('', bv_file8)
bv_file9 = 'test_tabs_2.txt'
with open(bv_file9, 'w') as f:
f.write("66 \t 55 \t 33\n45 \t 34 \t 21\n55 \t 32 \t 65\n")
_, bvecs_3 = read_bvals_bvecs('', bv_file9)
bv_file10 = 'test_multiple_space.txt'
with open(bv_file10, 'w') as f:
f.write("66 55 33\n45, 34, 21 \n 55, 32, 65\n")
_, bvecs_4 = read_bvals_bvecs('', bv_file10)
ans = np.array([[66., 55., 33.], [45., 34., 21.], [55., 32., 65.]])
npt.assert_array_equal(ans, bvecs_1)
npt.assert_array_equal(ans, bvecs_2)
npt.assert_array_equal(ans, bvecs_3)
npt.assert_array_equal(ans, bvecs_4)
def test_csdeconv():
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), (60, 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])
response = (np.array([0.0015, 0.0003, 0.0003]), S0)
csd = ConstrainedSphericalDeconvModel(gtab, response)
csd_fit = csd.fit(S)
assert_equal(csd_fit.shm_coeff[0] > 0, True)
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:
ConstrainedSphericalDeconvModel(gtab, response, sh_order=10)
assert_equal(len(w) > 0, True)
with warnings.catch_warnings(record=True) as w:
ConstrainedSphericalDeconvModel(gtab, response, sh_order=8)
assert_equal(len(w) > 0, False)
mevecs = []
for s in sticks:
mevecs += [all_tensor_evecs(s).T]
S2 = single_tensor(gtab, 100, mevals[0], mevecs[0], snr=None)
big_S = np.zeros((10, 10, 10, len(S2)))
big_S[:] = S2
aresponse, aratio = auto_response(gtab, big_S, roi_center=(5, 5, 4), roi_radius=3, fa_thr=0.5)
assert_array_almost_equal(aresponse[0], response[0])
assert_almost_equal(aresponse[1], 100)
assert_almost_equal(aratio, response[0][1]/response[0][0])
aresponse2, aratio2 = auto_response(gtab, big_S, roi_radius=3, fa_thr=0.5)
assert_array_almost_equal(aresponse[0], response[0])
def test_tensor_model():
fdata, fbval, fbvec = get_data('small_25')
data1 = nib.load(fdata).get_data()
gtab1 = grad.gradient_table(fbval, fbvec)
data2, gtab2 = dsi_voxels()
for data, gtab in zip([data1, data2], [gtab1, gtab2]):
dm = dti.TensorModel(gtab, 'LS')
dtifit = dm.fit(data[0, 0, 0])
assert_equal(dtifit.fa < 0.9, True)
dm = dti.TensorModel(gtab, 'WLS')
dtifit = dm.fit(data[0, 0, 0])
assert_equal(dtifit.fa < 0.9, True)
assert_equal(dtifit.fa > 0, True)
sphere = create_unit_sphere(4)
assert_equal(len(dtifit.odf(sphere)), len(sphere.vertices))
# Check that the multivoxel case works:
dtifit = dm.fit(data)
# Check that it works on signal that has already been normalized to S0:
dm_to_relative = dti.TensorModel(gtab)
if np.any(gtab.b0s_mask):
relative_data = (data[0, 0, 0] /
np.mean(data[0, 0, 0, gtab.b0s_mask]))
dtifit_to_relative = dm_to_relative.fit(relative_data)
npt.assert_almost_equal(dtifit.fa[0, 0, 0],
dtifit_to_relative.fa,
decimal=3)
# And smoke-test that all these operations return sensibly-shaped arrays:
assert_equal(dtifit.fa.shape, data.shape[:3])
assert_equal(dtifit.ad.shape, data.shape[:3])
assert_equal(dtifit.md.shape, data.shape[:3])
assert_equal(dtifit.rd.shape, data.shape[:3])
assert_equal(dtifit.trace.shape, data.shape[:3])
assert_equal(dtifit.mode.shape, data.shape[:3])
assert_equal(dtifit.linearity.shape, data.shape[:3])
assert_equal(dtifit.planarity.shape, data.shape[:3])
assert_equal(dtifit.sphericity.shape, data.shape[:3])
# Test for the shape of the mask
assert_raises(ValueError, dm.fit, np.ones((10, 10, 3)), np.ones((3, 3)))
# Make some synthetic data
b0 = 1000.
bvecs, bvals = read_bvec_file(get_data('55dir_grad.bvec'))
gtab = grad.gradient_table_from_bvals_bvecs(bvals, bvecs.T)
# The first b value is 0., so we take the second one:
B = bvals[1]
# Scale the eigenvalues and tensor by the B value so the units match
D = np.array([1., 1., 1., 0., 0., 1., -np.log(b0) * B]) / B
evals = np.array([2., 1., 0.]) / B
md = evals.mean()
tensor = from_lower_triangular(D)
A_squiggle = tensor - (1 / 3.0) * np.trace(tensor) * np.eye(3)
mode = (3 * np.sqrt(6) *
np.linalg.det(A_squiggle / np.linalg.norm(A_squiggle)))
evals_eigh, evecs_eigh = np.linalg.eigh(tensor)
# Sort according to eigen-value from large to small:
evecs = evecs_eigh[:, np.argsort(evals_eigh)[::-1]]
# Check that eigenvalues and eigenvectors are properly sorted through
# that previous operation:
for i in range(3):
assert_array_almost_equal(np.dot(tensor, evecs[:, i]),
evals[i] * evecs[:, i])
# Design Matrix
X = dti.design_matrix(gtab)
# Signals
Y = np.exp(np.dot(X, D))
assert_almost_equal(Y[0], b0)
Y.shape = (-1, ) + Y.shape
# Test fitting with different methods:
for fit_method in ['OLS', 'WLS', 'NLLS']:
tensor_model = dti.TensorModel(gtab,
fit_method=fit_method,
return_S0_hat=True)
tensor_fit = tensor_model.fit(Y)
assert_true(tensor_fit.model is tensor_model)
assert_equal(tensor_fit.shape, Y.shape[:-1])
assert_array_almost_equal(tensor_fit.evals[0], evals)
assert_array_almost_equal(tensor_fit.S0_hat, b0, decimal=3)
# Test that the eigenvectors are correct, one-by-one:
for i in range(3):
# Eigenvectors have intrinsic sign ambiguity
# (see
# http://prod.sandia.gov/techlib/access-control.cgi/2007/076422.pdf)
# so we need to allow for sign flips. One of the following should
# always be true:
assert_(
np.all(
np.abs(tensor_fit.evecs[0][:, i] - evecs[:, i]) < 10e-6)
or np.all(
np.abs(-tensor_fit.evecs[0][:, i] - evecs[:, i]) < 10e-6))
# We set a fixed tolerance of 10e-6, similar to array_almost_equal
err_msg = "Calculation of tensor from Y does not compare to "
err_msg += "analytical solution"
assert_array_almost_equal(tensor_fit.quadratic_form[0],
tensor,
err_msg=err_msg)
assert_almost_equal(tensor_fit.md[0], md)
assert_array_almost_equal(tensor_fit.mode, mode, decimal=5)
assert_equal(tensor_fit.directions.shape[-2], 1)
assert_equal(tensor_fit.directions.shape[-1], 3)
# Test error-handling:
assert_raises(ValueError, dti.TensorModel, gtab, fit_method='crazy_method')
# Test custom fit tensor method
try:
model = dti.TensorModel(gtab, fit_method=lambda *args, **kwargs: 42)
fit = model.fit_method()
except Exception as exc:
assert False, "TensorModel should accept custom fit methods: %s" % exc
assert fit == 42, "Custom fit method for TensorModel returned %s." % fit
# Test multi-voxel data
data = np.zeros((3, Y.shape[1]))
# Normal voxel
data[0] = Y
# High diffusion voxel, all diffusing weighted signal equal to zero
data[1, gtab.b0s_mask] = b0
data[1, ~gtab.b0s_mask] = 0
# Masked voxel, all data set to zero
data[2] = 0.
tensor_model = dti.TensorModel(gtab)
fit = tensor_model.fit(data)
assert_array_almost_equal(fit[0].evals, evals)
# Return S0_test
tensor_model = dti.TensorModel(gtab, return_S0_hat=True)
fit = tensor_model.fit(data)
assert_array_almost_equal(fit[0].evals, evals)
assert_array_almost_equal(fit[0].S0_hat, b0)
# Evals should be high for high diffusion voxel
assert_(all(fit[1].evals > evals[0] * .9))
# Evals should be zero where data is masked
assert_array_almost_equal(fit[2].evals, 0.)
def test_ssd_2d_gauss_newton():
r'''
Classical Circle-To-C experiment for 2D Monomodal registration. This test
is intended to detect regressions only: we saved the energy profile (the
sequence of energy values at each iteration) of a working version of SSD in
2D using the Gauss Newton step, and this test checks that the current energy
profile matches the saved one.
'''
fname_moving = get_data('reg_o')
fname_static = get_data('reg_c')
moving = np.load(fname_moving)
static = np.load(fname_static)
moving = np.array(moving, dtype=floating)
static = np.array(static, dtype=floating)
moving = (moving-moving.min())/(moving.max() - moving.min())
static = (static-static.min())/(static.max() - static.min())
#Create the SSD metric
smooth = 4
inner_iter = 5
step_type = 'gauss_newton'
similarity_metric = metrics.SSDMetric(2, smooth, inner_iter, step_type)
#Configure and run the Optimizer
level_iters = [200, 100, 50, 25]
step_length = 0.5
opt_tol = 1e-4
inv_iter = 40
inv_tol = 1e-3
ss_sigma_factor = 0.2
optimizer = imwarp.SymmetricDiffeomorphicRegistration(similarity_metric,
level_iters, step_length, ss_sigma_factor, opt_tol, inv_iter, inv_tol)
#test callback not being called
optimizer.INIT_START_CALLED = 0
optimizer.INIT_END_CALLED = 0
optimizer.OPT_START_CALLED = 0
optimizer.OPT_END_CALLED = 0
optimizer.SCALE_START_CALLED = 0
optimizer.SCALE_END_CALLED = 0
optimizer.ITER_START_CALLED = 0
optimizer.ITER_END_CALLED = 0
optimizer.verbosity = VerbosityLevels.DEBUG
mapping = optimizer.optimize(static, moving, np.eye(3), np.eye(3), np.eye(3))
m = optimizer.get_map()
assert_equal(mapping, m)
subsampled_energy_profile = np.array(optimizer.full_energy_profile[::10])
if floating is np.float32:
expected_profile = \
np.array([312.68133316, 79.40404517, 23.3715698, 125.02700267,
59.79982213, 34.64971733, 23.37131446, 171.28250576,
62.22266377, 125.24392168])
else:
expected_profile = \
np.array([312.68133361, 79.40404354, 23.34588446, 124.3247997,
61.69601973, 38.15047181, 23.53315113, 80.0791295,
57.21700113, 143.73270476])
assert_array_almost_equal(subsampled_energy_profile, expected_profile)
assert_equal(optimizer.OPT_START_CALLED, 0)
assert_equal(optimizer.OPT_END_CALLED, 0)
assert_equal(optimizer.SCALE_START_CALLED, 0)
assert_equal(optimizer.SCALE_END_CALLED, 0)
assert_equal(optimizer.ITER_START_CALLED, 0)
assert_equal(optimizer.ITER_END_CALLED, 0)
def test_piesno():
# Values taken from hispeed.OptimalPIESNO with the test data
# in the package computed in matlab
test_piesno_data = nib.load(dpd.get_data("test_piesno")).get_data()
sigma = piesno(test_piesno_data,
N=8,
alpha=0.01,
l=1,
eps=1e-10,
return_mask=False)
assert_almost_equal(sigma, 0.010749458025559)
noise1 = (np.random.randn(100, 100, 100) * 50) + 10
noise2 = (np.random.randn(100, 100, 100) * 50) + 10
rician_noise = np.sqrt(noise1**2 + noise2**2)
sigma, mask = piesno(rician_noise,
N=1,
alpha=0.01,
l=1,
eps=1e-10,
return_mask=True)
# less than 3% of error?
assert_(np.abs(sigma - 50) / sigma < 0.03)
# Test using the median as the initial estimation
initial_estimation = (np.median(sigma) /
np.sqrt(2 * _inv_nchi_cdf(1, 1, 0.5)))
sigma, mask = _piesno_3D(rician_noise,
N=1,
alpha=0.01,
l=1,
eps=1e-10,
return_mask=True,
initial_estimation=initial_estimation)
assert_(np.abs(sigma - 50) / sigma < 0.03)
sigma = _piesno_3D(rician_noise,
N=1,
alpha=0.01,
l=1,
eps=1e-10,
return_mask=False,
initial_estimation=initial_estimation)
assert_(np.abs(sigma - 50) / sigma < 0.03)
sigma = _piesno_3D(np.zeros_like(rician_noise),
N=1,
alpha=0.01,
l=1,
eps=1e-10,
return_mask=False,
initial_estimation=initial_estimation)
assert_(np.all(sigma == 0))
sigma, mask = _piesno_3D(np.zeros_like(rician_noise),
N=1,
alpha=0.01,
l=1,
eps=1e-10,
return_mask=True,
initial_estimation=initial_estimation)
assert_(np.all(sigma == 0))
assert_(np.all(mask == 0))
# Check if no noise points found in array it exits
sigma = _piesno_3D(1000 * np.ones_like(rician_noise),
N=1,
alpha=0.01,
l=1,
eps=1e-10,
return_mask=False,
initial_estimation=10)
assert_(np.all(sigma == 10))
import numpy as np
import nibabel as nib
from dipy.core.gradients import gradient_table
from dipy.data import get_data
# import dipy.reconst.activeax as activeax
import dipy.reconst.NODDIx as NODDIx
# from dipy.segment.mask import median_otsu
from scipy.linalg import get_blas_funcs
gemm = get_blas_funcs("gemm")
# t1 = time()
# fname = get_data('mask_CC')
# img = nib.load(fname)
# mask = img.get_data()
fname, fscanner = get_data('NODDIx_example')
params = np.loadtxt(fscanner)
img = nib.load(fname)
data = img.get_data()
affine = img.affine
bvecs = params[:, 0:3]
G = params[:, 3] / 10**6 # gradient strength
big_delta = params[:, 4]
small_delta = params[:, 5]
gamma = 2.675987 * 10**8
bvals = gamma**2 * G**2 * small_delta**2 * (big_delta - small_delta / 3.)
gtab = gradient_table(bvals,
bvecs,
big_delta=big_delta,
small_delta=small_delta,
def test_recursive_response_calibration():
"""
Test the recursive response calibration method.
"""
SNR = 100
S0 = 1
sh_order = 8
_, fbvals, fbvecs = get_data('small_64D')
bvals = np.load(fbvals)
bvecs = np.load(fbvecs)
sphere = get_sphere('symmetric724')
gtab = gradient_table(bvals, bvecs)
evals = np.array([0.0015, 0.0003, 0.0003])
evecs = np.array([[0, 1, 0], [0, 0, 1], [1, 0, 0]]).T
mevals = np.array(([0.0015, 0.0003, 0.0003], [0.0015, 0.0003, 0.0003]))
angles = [(0, 0), (90, 0)]
where_dwi = lazy_index(~gtab.b0s_mask)
S_cross, sticks_cross = multi_tensor(gtab,
mevals,
S0,
angles=angles,
fractions=[50, 50],
snr=SNR)
S_single = single_tensor(gtab, S0, evals, evecs, snr=SNR)
data = np.concatenate((np.tile(S_cross, (8, 1)), np.tile(S_single,
(2, 1))),
axis=0)
odf_gt_cross = multi_tensor_odf(sphere.vertices, mevals, angles, [50, 50])
odf_gt_single = single_tensor_odf(sphere.vertices, evals, evecs)
response = recursive_response(gtab,
data,
mask=None,
sh_order=8,
peak_thr=0.01,
init_fa=0.05,
init_trace=0.0021,
iter=8,
convergence=0.001,
parallel=False)
csd = ConstrainedSphericalDeconvModel(gtab, response)
csd_fit = csd.fit(data)
assert_equal(np.all(csd_fit.shm_coeff[:, 0] >= 0), True)
fodf = csd_fit.odf(sphere)
directions_gt_single, _, _ = peak_directions(odf_gt_single, sphere)
directions_gt_cross, _, _ = peak_directions(odf_gt_cross, sphere)
directions_single, _, _ = peak_directions(fodf[8, :], sphere)
directions_cross, _, _ = peak_directions(fodf[0, :], sphere)
ang_sim = angular_similarity(directions_cross, directions_gt_cross)
assert_equal(ang_sim > 1.9, True)
assert_equal(directions_cross.shape[0], 2)
assert_equal(directions_gt_cross.shape[0], 2)
ang_sim = angular_similarity(directions_single, directions_gt_single)
assert_equal(ang_sim > 0.9, True)
assert_equal(directions_single.shape[0], 1)
assert_equal(directions_gt_single.shape[0], 1)
sphere = Sphere(xyz=gtab.gradients[where_dwi])
sf = response.on_sphere(sphere)
S = np.concatenate(([response.S0], sf))
tenmodel = dti.TensorModel(gtab, min_signal=0.001)
tenfit = tenmodel.fit(S)
FA = fractional_anisotropy(tenfit.evals)
FA_gt = fractional_anisotropy(evals)
assert_almost_equal(FA, FA_gt, 1)
def test_predict():
"""
Test model prediction API
"""
psphere = get_sphere('symmetric362')
bvecs = np.concatenate(([[1, 0, 0]], psphere.vertices))
bvals = np.zeros(len(bvecs)) + 1000
bvals[0] = 0
gtab = grad.gradient_table(bvals, bvecs)
mevals = np.array(([0.0015, 0.0003, 0.0001], [0.0015, 0.0003, 0.0003]))
mevecs = [
np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]]),
np.array([[0, 0, 1], [0, 1, 0], [1, 0, 0]])
]
S = single_tensor(gtab, 100, mevals[0], mevecs[0], snr=None)
dm = dti.TensorModel(gtab, 'LS', return_S0_hat=True)
dmfit = dm.fit(S)
assert_array_almost_equal(dmfit.predict(gtab, S0=100), S)
assert_array_almost_equal(dmfit.predict(gtab), S)
assert_array_almost_equal(dm.predict(dmfit.model_params, S0=100), S)
fdata, fbvals, fbvecs = get_data()
data = nib.load(fdata).get_data()
# Make the data cube a bit larger:
data = np.tile(data.T, 2).T
gtab = grad.gradient_table(fbvals, fbvecs)
dtim = dti.TensorModel(gtab)
dtif = dtim.fit(data)
S0 = np.mean(data[..., gtab.b0s_mask], -1)
p = dtif.predict(gtab, S0)
assert_equal(p.shape, data.shape)
# Predict using S0_hat:
dtim = dti.TensorModel(gtab, return_S0_hat=True)
dtif = dtim.fit(data)
p = dtif.predict(gtab)
assert_equal(p.shape, data.shape)
p = dtif.predict(gtab, S0)
assert_equal(p.shape, data.shape)
# Test iter_fit_tensor with S0_hat
dtim = dti.TensorModel(gtab, step=2, return_S0_hat=True)
dtif = dtim.fit(data)
S0 = np.mean(data[..., gtab.b0s_mask], -1)
p = dtif.predict(gtab, S0)
assert_equal(p.shape, data.shape)
# Use a smaller step in predicting:
dtim = dti.TensorModel(gtab, step=2)
dtif = dtim.fit(data)
S0 = np.mean(data[..., gtab.b0s_mask], -1)
p = dtif.predict(gtab, S0)
assert_equal(p.shape, data.shape)
# And with a scalar S0:
S0 = 1
p = dtif.predict(gtab, S0)
assert_equal(p.shape, data.shape)
# Assign the step through kwarg:
p = dtif.predict(gtab, S0, step=1)
assert_equal(p.shape, data.shape)
# And without S0:
p = dtif.predict(gtab, step=1)
assert_equal(p.shape, data.shape)
def test_wls_and_ls_fit():
"""
Tests the WLS and LS fitting functions to see if they returns the correct
eigenvalues and eigenvectors.
Uses data/55dir_grad.bvec as the gradient table and 3by3by56.nii
as the data.
"""
# Defining Test Voxel (avoid nibabel dependency) ###
# Recall: D = [Dxx,Dyy,Dzz,Dxy,Dxz,Dyz,log(S_0)] and D ~ 10^-4 mm^2 /s
b0 = 1000.
bvec, bval = read_bvec_file(get_data('55dir_grad.bvec'))
B = bval[1]
# Scale the eigenvalues and tensor by the B value so the units match
D = np.array([1., 1., 1., 0., 0., 1., -np.log(b0) * B]) / B
evals = np.array([2., 1., 0.]) / B
md = evals.mean()
tensor = from_lower_triangular(D)
# Design Matrix
gtab = grad.gradient_table(bval, bvec)
X = dti.design_matrix(gtab)
# Signals
Y = np.exp(np.dot(X, D))
assert_almost_equal(Y[0], b0)
Y.shape = (-1, ) + Y.shape
# Testing WLS Fit on Single Voxel
# If you do something wonky (passing min_signal<0), you should get an
# error:
npt.assert_raises(ValueError,
TensorModel,
gtab,
fit_method='WLS',
min_signal=-1)
# Estimate tensor from test signals
model = TensorModel(gtab, fit_method='WLS', return_S0_hat=True)
tensor_est = model.fit(Y)
assert_equal(tensor_est.shape, Y.shape[:-1])
assert_array_almost_equal(tensor_est.evals[0], evals)
assert_array_almost_equal(tensor_est.quadratic_form[0],
tensor,
err_msg="Calculation of tensor from Y does not "
"compare to analytical solution")
assert_almost_equal(tensor_est.md[0], md)
assert_array_almost_equal(tensor_est.S0_hat[0], b0, decimal=3)
# Test that we can fit a single voxel's worth of data (a 1d array)
y = Y[0]
tensor_est = model.fit(y)
assert_equal(tensor_est.shape, tuple())
assert_array_almost_equal(tensor_est.evals, evals)
assert_array_almost_equal(tensor_est.quadratic_form, tensor)
assert_almost_equal(tensor_est.md, md)
assert_array_almost_equal(tensor_est.lower_triangular(b0), D)
# Test using fit_method='LS'
model = TensorModel(gtab, fit_method='LS')
tensor_est = model.fit(y)
assert_equal(tensor_est.shape, tuple())
assert_array_almost_equal(tensor_est.evals, evals)
assert_array_almost_equal(tensor_est.quadratic_form, tensor)
assert_almost_equal(tensor_est.md, md)
assert_array_almost_equal(tensor_est.lower_triangular(b0), D)
assert_array_almost_equal(tensor_est.linearity, linearity(evals))
assert_array_almost_equal(tensor_est.planarity, planarity(evals))
assert_array_almost_equal(tensor_est.sphericity, sphericity(evals))
def test_reconst_dki():
with TemporaryDirectory() as out_dir:
data_path, bval_path, bvec_path = get_data('small_101D')
vol_img = nib.load(data_path)
volume = vol_img.get_data()
mask = np.ones_like(volume[:, :, :, 0])
mask_img = nib.Nifti1Image(mask.astype(np.uint8), vol_img.affine)
mask_path = join(out_dir, 'tmp_mask.nii.gz')
nib.save(mask_img, mask_path)
dki_flow = ReconstDkiFlow()
args = [data_path, bval_path, bvec_path, mask_path]
dki_flow.run(*args, out_dir=out_dir)
fa_path = dki_flow.last_generated_outputs['out_fa']
fa_data = nib.load(fa_path).get_data()
assert_equal(fa_data.shape, volume.shape[:-1])
tensor_path = dki_flow.last_generated_outputs['out_dt_tensor']
tensor_data = nib.load(tensor_path)
assert_equal(tensor_data.shape[-1], 6)
assert_equal(tensor_data.shape[:-1], volume.shape[:-1])
ga_path = dki_flow.last_generated_outputs['out_ga']
ga_data = nib.load(ga_path).get_data()
assert_equal(ga_data.shape, volume.shape[:-1])
rgb_path = dki_flow.last_generated_outputs['out_rgb']
rgb_data = nib.load(rgb_path)
assert_equal(rgb_data.shape[-1], 3)
assert_equal(rgb_data.shape[:-1], volume.shape[:-1])
md_path = dki_flow.last_generated_outputs['out_md']
md_data = nib.load(md_path).get_data()
assert_equal(md_data.shape, volume.shape[:-1])
ad_path = dki_flow.last_generated_outputs['out_ad']
ad_data = nib.load(ad_path).get_data()
assert_equal(ad_data.shape, volume.shape[:-1])
rd_path = dki_flow.last_generated_outputs['out_rd']
rd_data = nib.load(rd_path).get_data()
assert_equal(rd_data.shape, volume.shape[:-1])
mk_path = dki_flow.last_generated_outputs['out_mk']
mk_data = nib.load(mk_path).get_data()
assert_equal(mk_data.shape, volume.shape[:-1])
ak_path = dki_flow.last_generated_outputs['out_ak']
ak_data = nib.load(ak_path).get_data()
assert_equal(ak_data.shape, volume.shape[:-1])
rk_path = dki_flow.last_generated_outputs['out_rk']
rk_data = nib.load(rk_path).get_data()
assert_equal(rk_data.shape, volume.shape[:-1])
kt_path = dki_flow.last_generated_outputs['out_dk_tensor']
kt_data = nib.load(kt_path)
assert_equal(kt_data.shape[-1], 15)
assert_equal(kt_data.shape[:-1], volume.shape[:-1])
mode_path = dki_flow.last_generated_outputs['out_mode']
mode_data = nib.load(mode_path).get_data()
assert_equal(mode_data.shape, volume.shape[:-1])
evecs_path = dki_flow.last_generated_outputs['out_evec']
evecs_data = nib.load(evecs_path).get_data()
assert_equal(evecs_data.shape[-2:], tuple((3, 3)))
assert_equal(evecs_data.shape[:-2], volume.shape[:-1])
evals_path = dki_flow.last_generated_outputs['out_eval']
evals_data = nib.load(evals_path).get_data()
assert_equal(evals_data.shape[-1], 3)
assert_equal(evals_data.shape[:-1], volume.shape[:-1])
def test_nlls_fit_tensor():
"""
Test the implementation of NLLS and RESTORE
"""
b0 = 1000.
bvecs, bval = read_bvec_file(get_data('55dir_grad.bvec'))
gtab = grad.gradient_table(bval, bvecs)
B = bval[1]
# Scale the eigenvalues and tensor by the B value so the units match
D = np.array([1., 1., 1., 0., 0., 1., -np.log(b0) * B]) / B
evals = np.array([2., 1., 0.]) / B
md = evals.mean()
tensor = from_lower_triangular(D)
# Design Matrix
X = dti.design_matrix(gtab)
# Signals
Y = np.exp(np.dot(X, D))
Y.shape = (-1, ) + Y.shape
# Estimate tensor from test signals and compare against expected result
# using non-linear least squares:
tensor_model = dti.TensorModel(gtab, fit_method='NLLS')
tensor_est = tensor_model.fit(Y)
assert_equal(tensor_est.shape, Y.shape[:-1])
assert_array_almost_equal(tensor_est.evals[0], evals)
assert_array_almost_equal(tensor_est.quadratic_form[0], tensor)
assert_almost_equal(tensor_est.md[0], md)
# You can also do this without the Jacobian (though it's slower):
tensor_model = dti.TensorModel(gtab, fit_method='NLLS', jac=False)
tensor_est = tensor_model.fit(Y)
assert_equal(tensor_est.shape, Y.shape[:-1])
assert_array_almost_equal(tensor_est.evals[0], evals)
assert_array_almost_equal(tensor_est.quadratic_form[0], tensor)
assert_almost_equal(tensor_est.md[0], md)
# Using the gmm weighting scheme:
tensor_model = dti.TensorModel(gtab, fit_method='NLLS', weighting='gmm')
tensor_est = tensor_model.fit(Y)
assert_equal(tensor_est.shape, Y.shape[:-1])
assert_array_almost_equal(tensor_est.evals[0], evals)
assert_array_almost_equal(tensor_est.quadratic_form[0], tensor)
assert_almost_equal(tensor_est.md[0], md)
# If you use sigma weighting, you'd better provide a sigma:
tensor_model = dti.TensorModel(gtab, fit_method='NLLS', weighting='sigma')
npt.assert_raises(ValueError, tensor_model.fit, Y)
# Use NLLS with some actual 4D data:
data, bvals, bvecs = get_data('small_25')
gtab = grad.gradient_table(bvals, bvecs)
tm1 = dti.TensorModel(gtab, fit_method='NLLS')
dd = nib.load(data).get_data()
tf1 = tm1.fit(dd)
tm2 = dti.TensorModel(gtab)
tf2 = tm2.fit(dd)
assert_array_almost_equal(tf1.fa, tf2.fa, decimal=1)
def test_eudx_further():
""" Cause we love testin.. ;-)
"""
fimg, fbvals, fbvecs = get_data('small_101D')
img = ni.load(fimg)
affine = img.get_affine()
data = img.get_data()
gtab = gradient_table(fbvals, fbvecs)
tensor_model = TensorModel(gtab)
ten = tensor_model.fit(data)
x, y, z = data.shape[:3]
seeds = np.zeros((10**4, 3))
for i in range(10**4):
rx = (x - 1) * np.random.rand()
ry = (y - 1) * np.random.rand()
rz = (z - 1) * np.random.rand()
seeds[i] = np.ascontiguousarray(np.array([rx, ry, rz]),
dtype=np.float64)
sphere = get_sphere('symmetric724')
ind = quantize_evecs(ten.evecs)
eu = EuDX(a=ten.fa,
ind=ind,
seeds=seeds,
odf_vertices=sphere.vertices,
a_low=.2)
T = [e for e in eu]
#check that there are no negative elements
for t in T:
assert_equal(np.sum(t.ravel() < 0), 0)
# Test eudx with affine
def random_affine(seeds):
affine = np.eye(4)
affine[:3, :] = np.random.random((3, 4))
seeds = np.dot(seeds, affine[:3, :3].T)
seeds += affine[:3, 3]
return affine, seeds
# Make two random affines and move seeds
affine1, seeds1 = random_affine(seeds)
affine2, seeds2 = random_affine(seeds)
# Make tracks using different affines
eu1 = EuDX(a=ten.fa,
ind=ind,
odf_vertices=sphere.vertices,
seeds=seeds1,
a_low=.2,
affine=affine1)
eu2 = EuDX(a=ten.fa,
ind=ind,
odf_vertices=sphere.vertices,
seeds=seeds2,
a_low=.2,
affine=affine2)
# Move from eu2 affine2 to affine1
eu2_to_eu1 = utils.move_streamlines(eu2,
output_space=affine1,
input_space=affine2)
# Check that the tracks are the same
for sl1, sl2 in zip(eu1, eu2_to_eu1):
assert_array_almost_equal(sl1, sl2)
import numpy as np
import numpy.testing as npt
from dipy.data import get_data
from dipy.sims.voxel import add_noise
from dipy.segment.mrf import (ConstantObservationModel,
IteratedConditionalModes)
from dipy.segment.tissue import (TissueClassifierHMRF)
# Load a coronal slice from a T1-weighted MRI
fname = get_data('t1_coronal_slice')
single_slice = np.load(fname)
# Stack a few copies to form a 3D volume
nslices = 5
image = np.zeros(shape=single_slice.shape + (nslices,))
image[..., :nslices] = single_slice[..., None]
# Set up parameters
nclasses = 4
beta = np.float64(0.0)
max_iter = 10
background_noise = True
# Making squares
square = np.zeros((256, 256, 3), dtype=np.int16)
square[42:213, 42:213, :] = 1
square[71:185, 71:185, :] = 2
square[99:157, 99:157, :] = 3
square_gauss = np.zeros((256, 256, 3)) + 0.001
def test_fit_dki():
fdata, fbval, fbvec = dpd.get_data('small_101D')
with nbtmp.InTemporaryDirectory() as tmpdir:
file_dict = dki.fit_dki(fdata, fbval, fbvec, out_dir=tmpdir)
for f in file_dict.values():
op.exists(f)
import numpy as np
import nibabel as nib
import dipy.reconst.dti as dti
import dipy.data as dpd
import dipy.core.gradients as grad
b0 = 1000.
bvecs, bval = dpd.read_bvec_file(dpd.get_data('55dir_grad.bvec'))
gtab = grad.gradient_table(bval, bvecs)
B = bval[1]
D = np.array([1., 1., 1., 0., 0., 1., -np.log(b0) * B]) / B
evals = np.array([2., 1., 0.]) / B
md = evals.mean()
tensor = dti.from_lower_triangular(D)
X = dti.design_matrix(bvecs, bval)
data = np.exp(np.dot(X,D))
data.shape = (-1,) + data.shape
dti_wls = dti.TensorModel(gtab)
fit_wls = dti_wls.fit(data)
fa1 = fit_wls.fa
noisy_data = np.copy(data)
noisy_data[..., -1] = 1.0
fit_wls_noisy = dti_wls.fit(noisy_data)
fa2 = fit_wls_noisy.fa
def fornix_streamlines(no_pts=12):
fname = get_data('fornix')
streams, hdr = tv.read(fname)
streamlines = [set_number_of_points(i[0], no_pts) for i in streams]
return streamlines
In this example we will show with simulated data how this method's ODF performs
against standard DSI ODF and a ground truth multi tensor ODF.
"""
import numpy as np
from dipy.sims.voxel import multi_tensor, multi_tensor_odf
from dipy.data import get_data, get_sphere
from dipy.core.gradients import gradient_table
from dipy.reconst.dsi import (DiffusionSpectrumDeconvModel,
DiffusionSpectrumModel)
"""
For the simulation we will use a standard DSI acqusition scheme with 514
gradient directions and 1 S0.
"""
btable = np.loadtxt(get_data('dsi515btable'))
gtab = gradient_table(btable[:, 0], btable[:, 1:])
"""
Let's create a multi tensor with 2 fiber directions at 60 degrees.
"""
evals = np.array([[0.0015, 0.0003, 0.0003], [0.0015, 0.0003, 0.0003]])
directions = [(-30, 0), (30, 0)]
fractions = [50, 50]
signal, _ = multi_tensor(gtab,
evals,
100,
def test_dsi():
btable = np.loadtxt(get_data('dsi515btable'))
bvals = btable[:, 0]
bvecs = btable[:, 1:]
S, stics = SticksAndBall(bvals,
bvecs,
d=0.0015,
S0=100,
angles=[(0, 0), (90, 0), (90, 90)],
fractions=[50, 50, 0],
snr=None)
pdf0, odf0, peaks0 = standard_dsi_algorithm(S, bvals, bvecs)
S2 = S.copy()
S2 = S2.reshape(1, len(S))
ds = DiffusionSpectrum(S2, bvals, bvecs)
assert_almost_equal(np.sum(ds.pdf(S) - pdf0), 0)
assert_almost_equal(np.sum(ds.odf(ds.pdf(S)) - odf0), 0)
#compare gfa
psi = odf0 / odf0.max()
numer = len(psi) * np.sum((psi - np.mean(psi))**2)
denom = (len(psi) - 1) * np.sum(psi**2)
GFA = np.sqrt(numer / denom)
assert_almost_equal(ds.gfa()[0], GFA)
#compare indices
#print ds.ind()
#print peak_finding(odf0,odf_faces)
#print peaks0
data = np.zeros((3, 3, 3, 515))
data[:, :, :] = S
ds = DiffusionSpectrum(data, bvals, bvecs)
ds2 = DiffusionSpectrum(data, bvals, bvecs, auto=False)
r = np.sqrt(ds2.qtable[:, 0]**2 + ds2.qtable[:, 1]**2 +
ds2.qtable[:, 2]**2)
ds2.filter = .5 * np.cos(2 * np.pi * r / 32)
ds2.fit()
assert_almost_equal(np.sum(ds2.qa() - ds.qa()), 0)
#1 fiber
S, stics = SticksAndBall(bvals,
bvecs,
d=0.0015,
S0=100,
angles=[(0, 0), (90, 0), (90, 90)],
fractions=[100, 0, 0],
snr=None)
ds = DiffusionSpectrum(S.reshape(1, len(S)), bvals, bvecs)
QA = ds.qa()
assert_equal(np.sum(QA > 0), 1)
#2 fibers
S, stics = SticksAndBall(bvals,
bvecs,
d=0.0015,
S0=100,
angles=[(0, 0), (90, 0), (90, 90)],
fractions=[50, 50, 0],
snr=None)
ds = DiffusionSpectrum(S.reshape(1, len(S)), bvals, bvecs)
QA = ds.qa()
assert_equal(np.sum(QA > 0), 2)
#3 fibers
S, stics = SticksAndBall(bvals,
bvecs,
d=0.0015,
S0=100,
angles=[(0, 0), (90, 0), (90, 90)],
fractions=[33, 33, 33],
snr=None)
ds = DiffusionSpectrum(S.reshape(1, len(S)), bvals, bvecs)
QA = ds.qa()
assert_equal(np.sum(QA > 0), 3)
#isotropic
S, stics = SticksAndBall(bvals,
bvecs,
d=0.0015,
S0=100,
angles=[(0, 0), (90, 0), (90, 90)],
fractions=[0, 0, 0],
snr=None)
ds = DiffusionSpectrum(S.reshape(1, len(S)), bvals, bvecs)
QA = ds.qa()
assert_equal(np.sum(QA > 0), 0)
def test_peaksFromModelParallel():
SNR = 100
S0 = 100
_, 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]))
data, _ = multi_tensor(gtab,
mevals,
S0,
angles=[(0, 0), (60, 0)],
fractions=[50, 50],
snr=SNR)
# test equality with/without multiprocessing
model = SimpleOdfModel(gtab)
pam_multi = peaks_from_model(model,
data,
_sphere,
.5,
45,
normalize_peaks=True,
return_odf=True,
return_sh=True,
parallel=True)
pam_single = peaks_from_model(model,
data,
_sphere,
.5,
45,
normalize_peaks=True,
return_odf=True,
return_sh=True,
parallel=False)
assert_equal(pam_multi.gfa.dtype, pam_single.gfa.dtype)
assert_equal(pam_multi.gfa.shape, pam_single.gfa.shape)
assert_array_almost_equal(pam_multi.gfa, pam_single.gfa)
assert_equal(pam_multi.qa.dtype, pam_single.qa.dtype)
assert_equal(pam_multi.qa.shape, pam_single.qa.shape)
assert_array_almost_equal(pam_multi.qa, pam_single.qa)
assert_equal(pam_multi.peak_values.dtype, pam_single.peak_values.dtype)
assert_equal(pam_multi.peak_values.shape, pam_single.peak_values.shape)
assert_array_almost_equal(pam_multi.peak_values, pam_single.peak_values)
assert_equal(pam_multi.peak_indices.dtype, pam_single.peak_indices.dtype)
assert_equal(pam_multi.peak_indices.shape, pam_single.peak_indices.shape)
assert_array_equal(pam_multi.peak_indices, pam_single.peak_indices)
assert_equal(pam_multi.peak_dirs.dtype, pam_single.peak_dirs.dtype)
assert_equal(pam_multi.peak_dirs.shape, pam_single.peak_dirs.shape)
assert_array_almost_equal(pam_multi.peak_dirs, pam_single.peak_dirs)
assert_equal(pam_multi.shm_coeff.dtype, pam_single.shm_coeff.dtype)
assert_equal(pam_multi.shm_coeff.shape, pam_single.shm_coeff.shape)
assert_array_almost_equal(pam_multi.shm_coeff, pam_single.shm_coeff)
assert_equal(pam_multi.odf.dtype, pam_single.odf.dtype)
assert_equal(pam_multi.odf.shape, pam_single.odf.shape)
assert_array_almost_equal(pam_multi.odf, pam_single.odf)
def test_affine_transformations():
"""This tests that the input affine is properly handled by
LocalTracking and produces reasonable streamlines in a simple example.
"""
sphere = HemiSphere.from_sphere(unit_octahedron)
# A simple image with three possible configurations, a vertical tract,
# a horizontal tract and a crossing
pmf_lookup = np.array([[0., 0., 1.], [1., 0., 0.], [0., 1., 0.],
[.4, .6, 0.]])
simple_image = np.array([
[0, 0, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
[0, 3, 2, 2, 2, 0],
[0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0],
])
simple_image = simple_image[..., None]
pmf = pmf_lookup[simple_image]
seeds = [np.array([1., 1., 0.]), np.array([2., 4., 0.])]
expected = [
np.array([[0., 1., 0.], [1., 1., 0.], [2., 1., 0.], [3., 1., 0.],
[4., 1., 0.]]),
np.array([[2., 0., 0.], [2., 1., 0.], [2., 2., 0.], [2., 3., 0.],
[2., 4., 0.], [2., 5., 0.]])
]
mask = (simple_image > 0).astype(float)
tc = BinaryTissueClassifier(mask)
dg = DeterministicMaximumDirectionGetter.from_pmf(pmf,
60,
sphere,
pmf_threshold=0.1)
# TST- bad affine wrong shape
bad_affine = np.eye(3)
npt.assert_raises(ValueError, LocalTracking, dg, tc, seeds, bad_affine, 1.)
# TST - bad affine with shearing
bad_affine = np.eye(4)
bad_affine[0, 1] = 1.
npt.assert_raises(ValueError, LocalTracking, dg, tc, seeds, bad_affine, 1.)
# TST - identity
a0 = np.eye(4)
# TST - affines with positive/negative offsets
a1 = np.eye(4)
a1[:3, 3] = [1, 2, 3]
a2 = np.eye(4)
a2[:3, 3] = [-2, 0, -1]
# TST - affine with scaling
a3 = np.eye(4)
a3[0, 0] = a3[1, 1] = a3[2, 2] = 8
# TST - affine with axes inverting (negative value)
a4 = np.eye(4)
a4[1, 1] = a4[2, 2] = -1
# TST - combined affines
a5 = a1 + a2 + a3
a5[3, 3] = 1
# TST - in vivo affine exemple
# Sometimes data have affines with tiny shear components.
# For example, the small_101D data-set has some of that:
fdata, _, _ = get_data('small_101D')
a6 = nib.load(fdata).affine
for affine in [a0, a1, a2, a3, a4, a5, a6]:
lin = affine[:3, :3]
offset = affine[:3, 3]
seeds_trans = [np.dot(lin, s) + offset for s in seeds]
# We compute the voxel size to ajust the step size to one voxel
voxel_size = np.mean(np.sqrt(np.dot(lin, lin).diagonal()))
streamlines = LocalTracking(direction_getter=dg,
tissue_classifier=tc,
seeds=seeds_trans,
affine=affine,
step_size=voxel_size,
return_all=True)
# We apply the inverse affine transformation to the generated
# streamlines. It should be equals to the expected streamlines
# (generated with the identity affine matrix).
affine_inv = np.linalg.inv(affine)
lin = affine_inv[:3, :3]
offset = affine_inv[:3, 3]
streamlines_inv = []
for line in streamlines:
streamlines_inv.append([np.dot(pts, lin) + offset for pts in line])
npt.assert_equal(len(streamlines_inv[0]), len(expected[0]))
npt.assert_(np.allclose(streamlines_inv[0], expected[0], atol=0.3))
npt.assert_equal(len(streamlines_inv[1]), len(expected[1]))
npt.assert_(np.allclose(streamlines_inv[1], expected[1], atol=0.3))
def test_TensorModel():
data, gtab = dsi_voxels()
dm = dti.TensorModel(gtab, 'LS')
dtifit = dm.fit(data[0, 0, 0])
assert_equal(dtifit.fa < 0.5, True)
dm = dti.TensorModel(gtab, 'WLS')
dtifit = dm.fit(data[0, 0, 0])
assert_equal(dtifit.fa < 0.5, True)
sphere = create_unit_sphere(4)
assert_equal(len(dtifit.odf(sphere)), len(sphere.vertices))
assert_almost_equal(dtifit.fa, gfa(dtifit.odf(sphere)), 1)
# Check that the multivoxel case works:
dtifit = dm.fit(data)
# And smoke-test that all these operations return sensibly-shaped arrays:
assert_equal(dtifit.fa.shape, data.shape[:3])
assert_equal(dtifit.ad.shape, data.shape[:3])
assert_equal(dtifit.md.shape, data.shape[:3])
assert_equal(dtifit.rd.shape, data.shape[:3])
assert_equal(dtifit.trace.shape, data.shape[:3])
assert_equal(dtifit.mode.shape, data.shape[:3])
assert_equal(dtifit.linearity.shape, data.shape[:3])
assert_equal(dtifit.planarity.shape, data.shape[:3])
assert_equal(dtifit.sphericity.shape, data.shape[:3])
# Test for the shape of the mask
assert_raises(ValueError, dm.fit, np.ones((10, 10, 3)), np.ones((3, 3)))
# Make some synthetic data
b0 = 1000.
bvecs, bvals = read_bvec_file(get_data('55dir_grad.bvec'))
gtab = grad.gradient_table_from_bvals_bvecs(bvals, bvecs.T)
# The first b value is 0., so we take the second one:
B = bvals[1]
# Scale the eigenvalues and tensor by the B value so the units match
D = np.array([1., 1., 1., 0., 0., 1., -np.log(b0) * B]) / B
evals = np.array([2., 1., 0.]) / B
md = evals.mean()
tensor = from_lower_triangular(D)
A_squiggle = tensor - (1 / 3.0) * np.trace(tensor) * np.eye(3)
mode = 3 * np.sqrt(6) * np.linalg.det(
A_squiggle / np.linalg.norm(A_squiggle))
evecs = np.linalg.eigh(tensor)[1]
# Design Matrix
X = dti.design_matrix(gtab)
# Signals
Y = np.exp(np.dot(X, D))
assert_almost_equal(Y[0], b0)
Y.shape = (-1, ) + Y.shape
# Test fitting with different methods:
for fit_method in ['OLS', 'WLS', 'NLLS']:
tensor_model = dti.TensorModel(gtab, fit_method=fit_method)
tensor_fit = tensor_model.fit(Y)
assert_true(tensor_fit.model is tensor_model)
assert_equal(tensor_fit.shape, Y.shape[:-1])
assert_array_almost_equal(tensor_fit.evals[0], evals)
assert_array_almost_equal(tensor_fit.quadratic_form[0], tensor,
err_msg=\
"Calculation of tensor from Y does not compare to analytical solution")
assert_almost_equal(tensor_fit.md[0], md)
assert_array_almost_equal(tensor_fit.mode, mode, decimal=5)
assert_equal(tensor_fit.directions.shape[-2], 1)
assert_equal(tensor_fit.directions.shape[-1], 3)
# Test error-handling:
assert_raises(ValueError, dti.TensorModel, gtab, fit_method='crazy_method')
"""
from __future__ import division, print_function, absolute_import
import numpy as np
import numpy.testing as npt
import nibabel as nib
import dipy.reconst.cross_validation as xval
import dipy.data as dpd
import dipy.reconst.dti as dti
import dipy.core.gradients as gt
import dipy.sims.voxel as sims
import dipy.reconst.csdeconv as csd
import dipy.reconst.base as base
import dipy.reconst.shm as shm
# We'll set these globally:
fdata, fbval, fbvec = dpd.get_data('small_64D')
def test_coeff_of_determination():
"""
Test the calculation of the coefficient of determination
"""
model = np.random.randn(10, 10, 10, 150)
data = np.copy(model)
# If the model predicts the data perfectly, the COD is all 100s:
cod = xval.coeff_of_determination(data, model)
npt.assert_array_equal(100, cod)
def test_dti_xval():
can reslice a dMRI dataset to have isotropic voxel size.
"""
import nibabel as nib
"""
The function we need to use is called resample.
"""
from dipy.align.reslice import reslice
from dipy.data import get_data
"""
We use here a very small dataset to show the basic principles but you can
replace the following line with the path of your image.
"""
fimg = get_data('aniso_vox')
"""
We load the image and print the shape of the volume
"""
img = nib.load(fimg)
data = img.get_data()
data.shape
"""
``(58, 58, 24)``
Load the affine of the image. The affine is the transformation matrix
which maps image coordinates to world (mm) coordinates.
"""
affine = img.affine
def test_ssd_2d_demons():
r'''
Classical Circle-To-C experiment for 2D Monomodal registration. This test
is intended to detect regressions only: we saved the energy profile (the
sequence of energy values at each iteration) of a working version of SSD in
2D using the Demons step, and this test checks that the current energy
profile matches the saved one.
'''
fname_moving = get_data('reg_o')
fname_static = get_data('reg_c')
moving = np.load(fname_moving)
static = np.load(fname_static)
moving = np.array(moving, dtype=floating)
static = np.array(static, dtype=floating)
moving = (moving-moving.min())/(moving.max() - moving.min())
static = (static-static.min())/(static.max() - static.min())
#Create the SSD metric
smooth = 4
step_type = 'demons'
similarity_metric = metrics.SSDMetric(2, smooth=smooth, step_type=step_type)
#Configure and run the Optimizer
level_iters = [200, 100, 50, 25]
step_length = 0.25
opt_tol = 1e-4
inv_iter = 40
inv_tol = 1e-3
ss_sigma_factor = 0.2
optimizer = imwarp.SymmetricDiffeomorphicRegistration(similarity_metric,
level_iters, step_length, ss_sigma_factor, opt_tol, inv_iter, inv_tol)
#test callback being called
optimizer.INIT_START_CALLED = 0
optimizer.INIT_END_CALLED = 0
optimizer.OPT_START_CALLED = 0
optimizer.OPT_END_CALLED = 0
optimizer.SCALE_START_CALLED = 0
optimizer.SCALE_END_CALLED = 0
optimizer.ITER_START_CALLED = 0
optimizer.ITER_END_CALLED = 0
optimizer.callback_counter_test = 0
optimizer.callback = simple_callback
optimizer.verbosity = VerbosityLevels.DEBUG
mapping = optimizer.optimize(static, moving, None)
m = optimizer.get_map()
assert_equal(mapping, m)
subsampled_energy_profile = np.array(optimizer.full_energy_profile[::10])
if floating is np.float32:
expected_profile = \
np.array([312.6813333, 162.57756447, 99.2766679, 77.38698935,
61.75415204, 55.37420428, 46.36872571, 41.81811505,
36.38683617, 33.03952963, 30.91409901, 54.41447237,
23.40232241, 12.75092466, 10.19231733, 9.21058037,
57.4636143, 38.94004856, 36.26093212, 108.0136453,
81.35521049, 74.61956833])
else:
expected_profile = \
np.array([312.68133361, 162.57744066, 99.27669798, 77.38683186,
61.75391429, 55.3740711, 46.36870776, 41.81809239,
36.3898153, 32.78365961, 30.69843811, 53.67073767,
21.74630524, 11.98102583, 11.51086685, 55.30707781,
39.88467545, 34.29444978, 33.10822964, 122.64743831,
84.18144073, 75.60088687])
assert_array_almost_equal(subsampled_energy_profile, expected_profile)
assert_equal(optimizer.OPT_START_CALLED, 1)
assert_equal(optimizer.OPT_END_CALLED, 1)
assert_equal(optimizer.SCALE_START_CALLED, 1)
assert_equal(optimizer.SCALE_END_CALLED, 1)
assert_equal(optimizer.ITER_START_CALLED, 1)
assert_equal(optimizer.ITER_END_CALLED, 1)
def orbital_phantom(gtab=None,
evals=diffusion_evals,
func=None,
t=np.linspace(0, 2 * np.pi, 1000),
datashape=(64, 64, 64, 65),
origin=(32, 32, 32),
scale=(25, 25, 25),
angles=np.linspace(0, 2 * np.pi, 32),
radii=np.linspace(0.2, 2, 6),
S0=100.,
snr=None):
"""Create a phantom based on a 3-D orbit ``f(t) -> (x,y,z)``.
Parameters
-----------
gtab : GradientTable
Gradient table of measurement directions.
evals : array, shape (3,)
Tensor eigenvalues.
func : user defined function f(t)->(x,y,z)
It could be desirable for ``-1=<x,y,z <=1``.
If None creates a circular orbit.
t : array, shape (K,)
Represents time for the orbit. Default is
``np.linspace(0, 2 * np.pi, 1000)``.
datashape : array, shape (X,Y,Z,W)
Size of the output simulated data
origin : tuple, shape (3,)
Define the center for the volume
scale : tuple, shape (3,)
Scale the function before applying to the grid
angles : array, shape (L,)
Density angle points, always perpendicular to the first eigen vector
Default np.linspace(0, 2 * np.pi, 32).
radii : array, shape (M,)
Thickness radii. Default ``np.linspace(0.2, 2, 6)``.
angles and radii define the total thickness options
S0 : double, optional
Maximum simulated signal. Default 100.
snr : float, optional
The signal to noise ratio set to apply Rician noise to the data.
Default is to not add noise at all.
Returns
-------
data : array, shape (datashape)
See Also
--------
add_noise
Examples
---------
>>> def f(t):
... x = np.sin(t)
... y = np.cos(t)
... z = np.linspace(-1, 1, len(x))
... return x, y, z
>>> data = orbital_phantom(func=f)
"""
if gtab is None:
fimg, fbvals, fbvecs = get_data('small_64D')
gtab = gradient_table(fbvals, fbvecs)
if func is None:
x = np.sin(t)
y = np.cos(t)
z = np.zeros(t.shape)
else:
x, y, z = func(t)
dx = np.diff(x)
dy = np.diff(y)
dz = np.diff(z)
x = scale[0] * x + origin[0]
y = scale[1] * y + origin[1]
z = scale[2] * z + origin[2]
bx = np.zeros(len(angles))
by = np.sin(angles)
bz = np.cos(angles)
# The entire volume is considered to be inside the brain.
# Voxels without a fiber crossing through them are taken
# to be isotropic with signal = S0.
vol = np.zeros(datashape) + S0
for i in range(len(dx)):
evecs, R = diff2eigenvectors(dx[i], dy[i], dz[i])
S = SingleTensor(gtab, S0, evals, evecs, snr=None)
vol[int(x[i]), int(y[i]), int(z[i]), :] += S
for r in radii:
for j in range(len(angles)):
rb = np.dot(R, np.array([bx[j], by[j], bz[j]]))
ix = int(x[i] + r * rb[0])
iy = int(y[i] + r * rb[1])
iz = int(z[i] + r * rb[2])
vol[ix, iy, iz] = vol[ix, iy, iz] + S
vol = vol / np.max(vol, axis=-1)[..., np.newaxis]
vol *= S0
if snr is not None:
vol = add_noise(vol, snr, S0=S0, noise_type='rician')
return vol
def test_gtable_from_files():
fimg, fbvals, fbvecs = get_data('small_101D')
gt = gradient_table(fbvals, fbvecs)
bvals, bvecs = read_bvals_bvecs(fbvals, fbvecs)
npt.assert_array_equal(gt.bvals, bvals)
npt.assert_array_equal(gt.bvecs, bvecs)
def test_tensor_model():
fdata, fbval, fbvec = get_data('small_25')
data1 = nib.load(fdata).get_data()
gtab1 = grad.gradient_table(fbval, fbvec)
data2, gtab2 = dsi_voxels()
for data, gtab in zip([data1, data2], [gtab1, gtab2]):
dm = dti.TensorModel(gtab, 'LS')
dtifit = dm.fit(data[0, 0, 0])
assert_equal(dtifit.fa < 0.9, True)
dm = dti.TensorModel(gtab, 'WLS')
dtifit = dm.fit(data[0, 0, 0])
assert_equal(dtifit.fa < 0.9, True)
assert_equal(dtifit.fa > 0, True)
sphere = create_unit_sphere(4)
assert_equal(len(dtifit.odf(sphere)), len(sphere.vertices))
# Check that the multivoxel case works:
dtifit = dm.fit(data)
# Check that it works on signal that has already been normalized to S0:
dm_to_relative = dti.TensorModel(gtab)
if np.any(gtab.b0s_mask):
relative_data = (data[0, 0, 0] /
np.mean(data[0, 0, 0, gtab.b0s_mask]))
dtifit_to_relative = dm_to_relative.fit(relative_data)
npt.assert_almost_equal(dtifit.fa[0, 0, 0],
dtifit_to_relative.fa,
decimal=3)
# And smoke-test that all these operations return sensibly-shaped arrays:
assert_equal(dtifit.fa.shape, data.shape[:3])
assert_equal(dtifit.ad.shape, data.shape[:3])
assert_equal(dtifit.md.shape, data.shape[:3])
assert_equal(dtifit.rd.shape, data.shape[:3])
assert_equal(dtifit.trace.shape, data.shape[:3])
assert_equal(dtifit.mode.shape, data.shape[:3])
assert_equal(dtifit.linearity.shape, data.shape[:3])
assert_equal(dtifit.planarity.shape, data.shape[:3])
assert_equal(dtifit.sphericity.shape, data.shape[:3])
# Test for the shape of the mask
assert_raises(ValueError, dm.fit, np.ones((10, 10, 3)), np.ones((3, 3)))
# Make some synthetic data
b0 = 1000.
bvecs, bvals = read_bvec_file(get_data('55dir_grad.bvec'))
gtab = grad.gradient_table_from_bvals_bvecs(bvals, bvecs.T)
# The first b value is 0., so we take the second one:
B = bvals[1]
# Scale the eigenvalues and tensor by the B value so the units match
D = np.array([1., 1., 1., 0., 0., 1., -np.log(b0) * B]) / B
evals = np.array([2., 1., 0.]) / B
md = evals.mean()
tensor = from_lower_triangular(D)
A_squiggle = tensor - (1 / 3.0) * np.trace(tensor) * np.eye(3)
mode = 3 * np.sqrt(6) * np.linalg.det(
A_squiggle / np.linalg.norm(A_squiggle))
evecs = np.linalg.eigh(tensor)[1]
# Design Matrix
X = dti.design_matrix(gtab)
# Signals
Y = np.exp(np.dot(X, D))
assert_almost_equal(Y[0], b0)
Y.shape = (-1, ) + Y.shape
# Test fitting with different methods:
for fit_method in ['OLS', 'WLS', 'NLLS']:
tensor_model = dti.TensorModel(gtab, fit_method=fit_method)
tensor_fit = tensor_model.fit(Y)
assert_true(tensor_fit.model is tensor_model)
assert_equal(tensor_fit.shape, Y.shape[:-1])
assert_array_almost_equal(tensor_fit.evals[0], evals)
assert_array_almost_equal(tensor_fit.quadratic_form[0], tensor,
err_msg=\
"Calculation of tensor from Y does not compare to analytical solution")
assert_almost_equal(tensor_fit.md[0], md)
assert_array_almost_equal(tensor_fit.mode, mode, decimal=5)
assert_equal(tensor_fit.directions.shape[-2], 1)
assert_equal(tensor_fit.directions.shape[-1], 3)
# Test error-handling:
assert_raises(ValueError, dti.TensorModel, gtab, fit_method='crazy_method')
# Test multi-voxel data
data = np.zeros((3, Y.shape[1]))
# Normal voxel
data[0] = Y
# High diffusion voxel, all diffusing weighted signal equal to zero
data[1, gtab.b0s_mask] = b0
data[1, ~gtab.b0s_mask] = 0
# Masked voxel, all data set to zero
data[2] = 0.
tensor_model = dti.TensorModel(gtab)
fit = tensor_model.fit(data)
assert_array_almost_equal(fit[0].evals, evals)
# Evals should be high for high diffusion voxel
assert_(all(fit[1].evals > evals[0] * .9))
# Evals should be zero where data is masked
assert_array_almost_equal(fit[2].evals, 0.)
