def test_patch2self_random_noise():
S0 = 30 + 2 * np.random.standard_normal((20, 20, 20, 50))
bvals = np.repeat(30, 50)
# shift = True
S0den_shift = p2s.patch2self(S0, bvals, model='ols', shift_intensity=True)
assert_greater_equal(S0den_shift.min(), S0.min())
assert_less_equal(np.round(S0den_shift.mean()), 30)
# clip = True
S0den_clip = p2s.patch2self(S0, bvals, model='ols',
clip_negative_vals=True)
assert_greater(S0den_clip.min(), S0.min())
assert_equal(np.round(S0den_clip.mean()), 30)
# both clip and shift = True, and int patch_radius
S0den_clip = p2s.patch2self(S0, bvals, patch_radius=0, model='ols',
clip_negative_vals=True,
shift_intensity=True)
assert_greater(S0den_clip.min(), S0.min())
assert_equal(np.round(S0den_clip.mean()), 30)
# both clip and shift = False
S0den_clip = p2s.patch2self(S0, bvals, model='ols',
clip_negative_vals=False,
shift_intensity=False)
assert_greater(S0den_clip.min(), S0.min())
assert_equal(np.round(S0den_clip.mean()), 30)
def test_csd_superres():
""" Check the quality of csdfit with high SH order. """
_, fbvals, fbvecs = get_fnames('small_64D')
bvals, bvecs = read_bvals_bvecs(fbvals, 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.])
with warnings.catch_warnings(record=True) as w:
warnings.filterwarnings(action="always",
message="Number of parameters required.*",
category=UserWarning)
model16 = ConstrainedSphericalDeconvModel(gtab, (evals[0], 3.),
sh_order=16)
assert_greater_equal(len(w), 1)
npt.assert_(issubclass(w[-1].category, UserWarning))
fit16 = model16.fit(S)
sphere = HemiSphere.from_sphere(get_sphere('symmetric724'))
# print local_maxima(fit16.odf(default_sphere), default_sphere.edges)
d, v, ind = peak_directions(fit16.odf(sphere), 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 test_leastsq_error():
"""
Test error handling of the `_leastsq` method works when unfeasible x0 is
passed. If an unfeasible x0 value is passed using which leastsq fails, the
x0 value is returned as it is.
"""
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always", category=UserWarning)
fit = ivim_model_LM._leastsq(data_single, [-1, -1, -1, -1])
assert_greater_equal(len(w), 1)
assert_(issubclass(w[-1].category, UserWarning))
assert_("" in str(w[-1].message))
assert_("x0 is unfeasible" in str(w[-1].message))
assert_array_almost_equal(fit, [-1, -1, -1, -1])
def test_leastsq_failing():
"""
Test for cases where leastsq fitting fails and the results from a linear
fit is returned.
"""
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always", category=UserWarning)
fit_single = ivim_model_LM.fit(noisy_single)
assert_greater_equal(len(w), 3)
u_warn = [l_w for l_w in w if issubclass(l_w.category, UserWarning)]
assert_greater_equal(len(u_warn), 3)
message = ["x0 obtained from linear fitting is not feasibile",
"x0 is unfeasible",
"Bounds are violated for leastsq fitting"]
assert_greater_equal(len([lw for lw in u_warn for m in message
if m in str(lw.message)]), 3)
# Test for the S0 and D values
assert_array_almost_equal(fit_single.S0_predicted, 4356.268901117833)
assert_array_almost_equal(fit_single.D, 6.936684e-04)
def test_metric_minimum_average_direct_flip():
feature = dipysfeature.IdentityFeature()
class MinimumAverageDirectFlipMetric(dipysmetric.Metric):
def __init__(self, feature):
super(MinimumAverageDirectFlipMetric,
self).__init__(feature=feature)
@property
def is_order_invariant(self):
return True # Ordering is handled in the distance computation
def are_compatible(self, shape1, shape2):
return shape1[0] == shape2[0]
def dist(self, v1, v2):
def average_euclidean(x, y):
return np.mean(norm(x - y, axis=1))
dist_direct = average_euclidean(v1, v2)
dist_flipped = average_euclidean(v1, v2[::-1])
return min(dist_direct, dist_flipped)
for metric in [
MinimumAverageDirectFlipMetric(feature),
dipysmetric.MinimumAverageDirectFlipMetric(feature)
]:
# Test special cases of the MDF distance.
assert_equal(metric.dist(s, s), 0.)
assert_equal(metric.dist(s, s[::-1]), 0.)
# Translation
offset = np.array([0.8, 1.3, 5], dtype=dtype)
assert_almost_equal(metric.dist(s, s + offset), norm(offset), 5)
# Scaling
M_scaling = np.diag([1.2, 2.8, 3]).astype(dtype)
s_mean = np.mean(s, axis=0)
s_zero_mean = s - s_mean
s_scaled = np.dot(M_scaling, s_zero_mean.T).T + s_mean
d = np.mean(norm((np.diag(M_scaling) - 1) * s_zero_mean, axis=1))
assert_almost_equal(metric.dist(s, s_scaled), d, 5)
# Rotation
from dipy.core.geometry import rodrigues_axis_rotation
rot_axis = np.array([1, 2, 3], dtype=dtype)
M_rotation = rodrigues_axis_rotation(rot_axis, 60.).astype(dtype)
s_mean = np.mean(s, axis=0)
s_zero_mean = s - s_mean
s_rotated = np.dot(M_rotation, s_zero_mean.T).T + s_mean
opposite = norm(np.cross(rot_axis, s_zero_mean),
axis=1) / norm(rot_axis)
distances = np.sqrt(2 * opposite**2 *
(1 - np.cos(60. * np.pi / 180.))).astype(dtype)
d = np.mean(distances)
assert_almost_equal(metric.dist(s, s_rotated), d, 5)
# All possible pairs
for s1, s2 in itertools.product(*[streamlines] * 2):
# Extract features since metric doesn't work
# directly on streamlines
f1 = metric.feature.extract(s1)
f2 = metric.feature.extract(s2)
# Test method are_compatible
same_nb_points = f1.shape[0] == f2.shape[0]
assert_equal(metric.are_compatible(f1.shape, f2.shape),
same_nb_points)
# Test method dist if features are compatible
if metric.are_compatible(f1.shape, f2.shape):
distance = metric.dist(f1, f2)
if np.all(f1 == f2):
assert_equal(distance, 0.)
assert_almost_equal(distance, dipysmetric.dist(metric, s1, s2))
assert_almost_equal(distance, dipymetric.mdf(s1, s2))
assert_greater_equal(distance, 0.)
# This metric type is order invariant
assert_true(metric.is_order_invariant)
# All possible pairs
for s1, s2 in itertools.product(*[streamlines] * 2):
f1 = metric.feature.extract(s1)
f2 = metric.feature.extract(s2)
if not metric.are_compatible(f1.shape, f2.shape):
continue
f1_flip = metric.feature.extract(s1[::-1])
f2_flip = metric.feature.extract(s2[::-1])
distance = metric.dist(f1, f2)
assert_almost_equal(metric.dist(f1_flip, f2_flip), distance)
if not np.all(f1_flip == f2_flip):
assert_true(np.allclose(metric.dist(f1, f2_flip), distance))
assert_true(np.allclose(metric.dist(f1_flip, f2), distance))
def test_metric_cosine():
feature = dipysfeature.VectorOfEndpointsFeature()
class CosineMetric(dipysmetric.Metric):
def __init__(self, feature):
super(CosineMetric, self).__init__(feature=feature)
def are_compatible(self, shape1, shape2):
# Cosine metric works on vectors.
return shape1 == shape2 and shape1[0] == 1
def dist(self, v1, v2):
# Check if we have null vectors
if norm(v1) == 0:
return 0. if norm(v2) == 0 else 1.
v1_normed = v1.astype(np.float64) / norm(v1.astype(np.float64))
v2_normed = v2.astype(np.float64) / norm(v2.astype(np.float64))
cos_theta = np.dot(v1_normed, v2_normed.T)
# Make sure it's in [-1, 1], i.e. within domain of arccosine
cos_theta = np.minimum(cos_theta, 1.)
cos_theta = np.maximum(cos_theta, -1.)
return np.arccos(cos_theta) / np.pi # Normalized cosine distance
for metric in [CosineMetric(feature), dipysmetric.CosineMetric(feature)]:
# Test special cases of the cosine distance.
v0 = np.array([[0, 0, 0]], dtype=np.float32)
v1 = np.array([[1, 2, 3]], dtype=np.float32)
v2 = np.array([[1, -1. / 2, 0]], dtype=np.float32)
v3 = np.array([[-1, -2, -3]], dtype=np.float32)
assert_equal(metric.dist(v0, v0), 0.) # dot-dot
assert_equal(metric.dist(v0, v1), 1.) # dot-line
assert_equal(metric.dist(v1, v1), 0.) # collinear
assert_equal(metric.dist(v1, v2), 0.5) # orthogonal
assert_equal(metric.dist(v1, v3), 1.) # opposite
# All possible pairs
for s1, s2 in itertools.product(*[streamlines] * 2):
# Extract features since metric doesn't
# work directly on streamlines
f1 = metric.feature.extract(s1)
f2 = metric.feature.extract(s2)
# Test method are_compatible
are_vectors = f1.shape[0] == 1 and f2.shape[0] == 1
same_dimension = f1.shape[1] == f2.shape[1]
assert_equal(metric.are_compatible(f1.shape, f2.shape), are_vectors
and same_dimension)
# Test method dist if features are compatible
if metric.are_compatible(f1.shape, f2.shape):
distance = metric.dist(f1, f2)
if np.all(f1 == f2):
assert_almost_equal(distance, 0.)
assert_almost_equal(distance, dipysmetric.dist(metric, s1, s2))
assert_greater_equal(distance, 0.)
assert_less_equal(distance, 1.)
# This metric type is not order invariant
assert_false(metric.is_order_invariant)
# All possible pairs
for s1, s2 in itertools.product(*[streamlines] * 2):
f1 = metric.feature.extract(s1)
f2 = metric.feature.extract(s2)
if not metric.are_compatible(f1.shape, f2.shape):
continue
f1_flip = metric.feature.extract(s1[::-1])
f2_flip = metric.feature.extract(s2[::-1])
distance = metric.dist(f1, f2)
assert_almost_equal(metric.dist(f1_flip, f2_flip), distance)
if not np.all(f1_flip == f2_flip):
assert_false(metric.dist(f1, f2_flip) == distance)
assert_false(metric.dist(f1_flip, f2) == distance)
def test_metric_minimum_average_direct_flip():
feature = dipymetric.IdentityFeature()
class MinimumAverageDirectFlipMetric(dipymetric.Metric):
def __init__(self, feature):
super(MinimumAverageDirectFlipMetric, self).__init__(
feature=feature)
@property
def is_order_invariant(self):
return True # Ordering is handled in the distance computation
def are_compatible(self, shape1, shape2):
return shape1[0] == shape2[0]
def dist(self, v1, v2):
def average_euclidean(x, y):
return np.mean(norm(x-y, axis=1))
dist_direct = average_euclidean(v1, v2)
dist_flipped = average_euclidean(v1, v2[::-1])
return min(dist_direct, dist_flipped)
for metric in [MinimumAverageDirectFlipMetric(feature),
dipymetric.MinimumAverageDirectFlipMetric(feature)]:
# Test special cases of the MDF distance.
assert_equal(metric.dist(s, s), 0.)
assert_equal(metric.dist(s, s[::-1]), 0.)
# Translation
offset = np.array([0.8, 1.3, 5], dtype=dtype)
assert_almost_equal(metric.dist(s, s+offset), norm(offset), 5)
# Scaling
M_scaling = np.diag([1.2, 2.8, 3]).astype(dtype)
s_mean = np.mean(s, axis=0)
s_zero_mean = s - s_mean
s_scaled = np.dot(M_scaling, s_zero_mean.T).T + s_mean
d = np.mean(norm((np.diag(M_scaling)-1)*s_zero_mean, axis=1))
assert_almost_equal(metric.dist(s, s_scaled), d, 5)
# Rotation
from dipy.core.geometry import rodrigues_axis_rotation
rot_axis = np.array([1, 2, 3], dtype=dtype)
M_rotation = rodrigues_axis_rotation(rot_axis, 60.).astype(dtype)
s_mean = np.mean(s, axis=0)
s_zero_mean = s - s_mean
s_rotated = np.dot(M_rotation, s_zero_mean.T).T + s_mean
opposite = norm(np.cross(rot_axis, s_zero_mean),
axis=1) / norm(rot_axis)
distances = np.sqrt(2*opposite**2 *
(1 - np.cos(60.*np.pi/180.))).astype(dtype)
d = np.mean(distances)
assert_almost_equal(metric.dist(s, s_rotated), d, 5)
# All possible pairs
for s1, s2 in itertools.product(*[streamlines]*2):
# Extract features since metric doesn't work
# directly on streamlines
f1 = metric.feature.extract(s1)
f2 = metric.feature.extract(s2)
# Test method are_compatible
same_nb_points = f1.shape[0] == f2.shape[0]
assert_equal(metric.are_compatible(f1.shape, f2.shape),
same_nb_points)
# Test method dist if features are compatible
if metric.are_compatible(f1.shape, f2.shape):
distance = metric.dist(f1, f2)
if np.all(f1 == f2):
assert_equal(distance, 0.)
assert_almost_equal(distance, dipymetric.dist(metric, s1, s2))
assert_almost_equal(distance, dipymetric.mdf(s1, s2))
assert_greater_equal(distance, 0.)
# This metric type is order invariant
assert_true(metric.is_order_invariant)
# All possible pairs
for s1, s2 in itertools.product(*[streamlines]*2):
f1 = metric.feature.extract(s1)
f2 = metric.feature.extract(s2)
if not metric.are_compatible(f1.shape, f2.shape):
continue
f1_flip = metric.feature.extract(s1[::-1])
f2_flip = metric.feature.extract(s2[::-1])
distance = metric.dist(f1, f2)
assert_almost_equal(metric.dist(f1_flip, f2_flip), distance)
if not np.all(f1_flip == f2_flip):
assert_true(np.allclose(metric.dist(f1, f2_flip), distance))
assert_true(np.allclose(metric.dist(f1_flip, f2), distance))
def test_metric_cosine():
feature = dipymetric.VectorOfEndpointsFeature()
class CosineMetric(dipymetric.Metric):
def __init__(self, feature):
super(CosineMetric, self).__init__(feature=feature)
def are_compatible(self, shape1, shape2):
# Cosine metric works on vectors.
return shape1 == shape2 and shape1[0] == 1
def dist(self, v1, v2):
# Check if we have null vectors
if norm(v1) == 0:
return 0. if norm(v2) == 0 else 1.
v1_normed = v1.astype(np.float64) / norm(v1.astype(np.float64))
v2_normed = v2.astype(np.float64) / norm(v2.astype(np.float64))
cos_theta = np.dot(v1_normed, v2_normed.T)
# Make sure it's in [-1, 1], i.e. within domain of arccosine
cos_theta = np.minimum(cos_theta, 1.)
cos_theta = np.maximum(cos_theta, -1.)
return np.arccos(cos_theta) / np.pi # Normalized cosine distance
for metric in [CosineMetric(feature), dipymetric.CosineMetric(feature)]:
# Test special cases of the cosine distance.
v0 = np.array([[0, 0, 0]], dtype=np.float32)
v1 = np.array([[1, 2, 3]], dtype=np.float32)
v2 = np.array([[1, -1./2, 0]], dtype=np.float32)
v3 = np.array([[-1, -2, -3]], dtype=np.float32)
assert_equal(metric.dist(v0, v0), 0.) # dot-dot
assert_equal(metric.dist(v0, v1), 1.) # dot-line
assert_equal(metric.dist(v1, v1), 0.) # collinear
assert_equal(metric.dist(v1, v2), 0.5) # orthogonal
assert_equal(metric.dist(v1, v3), 1.) # opposite
# All possible pairs
for s1, s2 in itertools.product(*[streamlines]*2):
# Extract features since metric doesn't
# work directly on streamlines
f1 = metric.feature.extract(s1)
f2 = metric.feature.extract(s2)
# Test method are_compatible
are_vectors = f1.shape[0] == 1 and f2.shape[0] == 1
same_dimension = f1.shape[1] == f2.shape[1]
assert_equal(metric.are_compatible(f1.shape, f2.shape),
are_vectors and same_dimension)
# Test method dist if features are compatible
if metric.are_compatible(f1.shape, f2.shape):
distance = metric.dist(f1, f2)
if np.all(f1 == f2):
assert_almost_equal(distance, 0.)
assert_almost_equal(distance, dipymetric.dist(metric, s1, s2))
assert_greater_equal(distance, 0.)
assert_less_equal(distance, 1.)
# This metric type is not order invariant
assert_false(metric.is_order_invariant)
# All possible pairs
for s1, s2 in itertools.product(*[streamlines]*2):
f1 = metric.feature.extract(s1)
f2 = metric.feature.extract(s2)
if not metric.are_compatible(f1.shape, f2.shape):
continue
f1_flip = metric.feature.extract(s1[::-1])
f2_flip = metric.feature.extract(s2[::-1])
distance = metric.dist(f1, f2)
assert_almost_equal(metric.dist(f1_flip, f2_flip), distance)
if not np.all(f1_flip == f2_flip):
assert_false(metric.dist(f1, f2_flip) == distance)
assert_false(metric.dist(f1_flip, f2) == distance)
