def test_ab(self):
x, y, r, nt = 10, 20, 0, 9999
a0, b0, a1, b1 = 10, 5, 8, 15
data0 = ret.make_ellipse_data_points(x, y, a0, b0, r, nt=nt, use_focus=False)
assert np.allclose(data0.min(axis=0), (x - a0, y - b0), atol=10e-5)
data1 = ret.make_ellipse_data_points(x, y, a1, b1, r, nt=nt, use_focus=False)
assert np.allclose(data1.min(axis=0), (x - a1, y - b1), atol=10e-5)
def test_r(self):
x, y, a, b, nt = 10, 20, 15, 5, 9999
r0, r1 = 0, math.pi / 2
data0 = ret.make_ellipse_data_points(x, y, a, b, r0, nt=nt, use_focus=False)
assert np.allclose(data0.min(axis=0), (x - a, y - b), atol=10e-5)
data1 = ret.make_ellipse_data_points(x, y, a, b, r1, nt=nt, use_focus=False)
assert np.allclose(data1.min(axis=0), (x - b, y - a), atol=10e-5)
def test_xy_use_focus_false(self):
x0, y0, x1, y1 = 10, -5, -20, 30
a, b, r = 10, 8, 0
data0 = ret.make_ellipse_data_points(x0, y0, a, b, r, nt=99, use_focus=False)
assert np.allclose(data0.mean(axis=0), (x0, y0))
data1 = ret.make_ellipse_data_points(x1, y1, a, b, r, nt=99, use_focus=False)
assert np.allclose(data1.mean(axis=0), (x1, y1))
def test_xy_use_focus_true(self):
x0, y0, x1, y1 = 10, -5, -20, 30
a, b, r = 10, 8, 0
data0 = ret.make_ellipse_data_points(x0, y0, a, b, r, nt=99, use_focus=True)
xc0, yc0 = data0.mean(axis=0)
f0 = ret._get_closest_focus(x0, y0, xc0, yc0, a, b, r)
assert approx(f0) == (x0, y0)
data1 = ret.make_ellipse_data_points(x1, y1, a, b, r, nt=99, use_focus=True)
xc1, yc1 = data1.mean(axis=0)
f1 = ret._get_closest_focus(x1, y1, xc1, yc1, a, b, r)
assert approx(f1) == (x1, y1)
def test_semi_len_max(self):
xf, yf, a, b, r = 50, 55, 21, 20, 2
data = ret.make_ellipse_data_points(xf, yf, a, b, r, nt=25)
model_ransac0, inliers0 = ret.get_ellipse_model_ransac_single_frame(
data,
xf=50,
yf=55,
rf_lim=2,
semi_len_min=None,
semi_len_max=25,
semi_len_ratio_lim=2,
min_samples=6,
residual_threshold=10,
max_trails=100,
)
params0f = (xf, yf, a, b, r)
params1f = ret._ellipse_model_centre_to_focus(*model_ransac0.params, xf, yf)
assert inliers0.all()
compare_model_params(params0f, params1f, abs=0.1)
model_ransac1, inliers1 = ret.get_ellipse_model_ransac_single_frame(
data,
xf=50,
yf=55,
rf_lim=2,
semi_len_min=None,
semi_len_max=15,
semi_len_ratio_lim=2,
min_samples=6,
residual_threshold=10,
max_trails=100,
)
assert model_ransac1 is None
def test_min_samples(self):
xf, yf, a, b, r = 50, 55, 21, 20, 0
data = ret.make_ellipse_data_points(xf, yf, a, b, r, nt=20)
data = np.vstack((data, [70, 55]))
model_ransac0, inliers0 = ret.get_ellipse_model_ransac_single_frame(
data,
xf=50,
yf=55,
rf_lim=5,
semi_len_min=15,
semi_len_max=None,
semi_len_ratio_lim=None,
min_samples=20,
residual_threshold=3,
max_trails=100,
)
assert inliers0[:-1].all()
assert not inliers0[-1]
model_ransac1, inliers1 = ret.get_ellipse_model_ransac_single_frame(
data,
xf=50,
yf=55,
rf_lim=5,
semi_len_min=15,
semi_len_max=None,
semi_len_ratio_lim=None,
min_samples=20,
residual_threshold=6,
max_trails=100,
)
assert inliers1.all()
def test_full_ellipse_ransac_processing():
xf, yf, a, b, r, nt = 100, 115, 45, 35, 0, 15
data_points = ret.make_ellipse_data_points(xf, yf, a, b, r, nt)
image = np.zeros(shape=(200, 210), dtype=np.float32)
for x, y in data_points:
image[int(round(x)), int(round(y))] = 100
disk = morphology.disk(5, np.uint16)
image = convolve2d(image, disk, mode="same")
data = np.zeros((2, 3, 210, 200), dtype=np.float32)
data[:, :] = image.T
s = Diffraction2D(data)
s_t = s.template_match_disk(disk_r=5)
peak_array = s_t.find_peaks_lazy(lazy_result=False)
c = math.sqrt(math.pow(a, 2) - math.pow(b, 2))
xc, yc = xf - c * math.cos(r), yf - c * math.sin(r)
for iy, ix in np.ndindex(peak_array.shape):
peaks = peak_array[iy, ix]
assert len(peaks) == 15
assert approx(peaks[:, 1].mean(), abs=2) == xc
assert approx(peaks[:, 0].mean(), abs=2) == yc
assert approx(peaks[:, 1].max(), abs=2) == xc + a
assert approx(peaks[:, 0].max(), abs=2) == yc + b
assert approx(peaks[:, 1].min(), abs=2) == xc - a
assert approx(peaks[:, 0].min(), abs=2) == yc - b
ellipse_array, inlier_array = ret.get_ellipse_model_ransac(
peak_array,
yf=yf,
xf=xf,
rf_lim=15,
semi_len_min=min(a, b) - 5,
semi_len_max=max(a, b) + 5,
semi_len_ratio_lim=5,
max_trails=50,
min_samples=10,
)
s.add_ellipse_array_as_markers(ellipse_array)
for iy, ix in np.ndindex(ellipse_array.shape):
ycf, xcf, bf, af, rf = ellipse_array[iy, ix]
if af < bf:
rf += math.pi / 2
af, bf = bf, af
assert approx((xcf, ycf, af, bf, rf), abs=0.1) == [xc, yc, a, b, r]
assert inlier_array[iy, ix].all()
s.add_ellipse_array_as_markers(ellipse_array)
x_list, y_list = [], []
for _, marker in list(s.metadata.Markers):
x_list.append(marker.data["x1"][()][0][0])
y_list.append(marker.data["y1"][()][0][0])
assert approx(np.mean(x_list), abs=1) == xc
assert approx(np.mean(y_list), abs=1) == yc
assert approx(np.max(x_list), abs=1) == xc + a
assert approx(np.max(y_list), abs=1) == yc + b
assert approx(np.min(x_list), abs=1) == xc - a
assert approx(np.min(y_list), abs=1) == yc - b
def test_use_focus(self):
x, y, a, b, r = 5, 9, 10, 8, 0
data0 = ret.make_ellipse_data_points(x,
y,
a,
b,
r,
nt=99,
use_focus=False)
assert np.allclose(data0.mean(axis=0), (x, y))
data1 = ret.make_ellipse_data_points(x,
y,
a,
b,
r,
nt=99,
use_focus=True)
assert not np.allclose(data1.mean(axis=0), (x, y))
def test_yf(self):
xf, yf0, yf1, a, b, r = 50, 55, 140, 21, 20, 2
data0 = ret.make_ellipse_data_points(xf, yf0, a, b, r, nt=25)
data1 = ret.make_ellipse_data_points(xf, yf1, a, b, r, nt=25)
data = np.vstack((data0, data1))
model_ransac0, inliers0 = ret.get_ellipse_model_ransac_single_frame(
data,
xf=50,
yf=yf0,
rf_lim=2,
semi_len_min=19,
semi_len_max=None,
semi_len_ratio_lim=2,
min_samples=5,
residual_threshold=10,
max_trails=300,
)
params00f = (xf, yf0, a, b, r)
params01f = ret._ellipse_model_centre_to_focus(*model_ransac0.params,
xf, yf0)
compare_model_params(params00f, params01f, abs=0.1)
model_ransac1, inliers1 = ret.get_ellipse_model_ransac_single_frame(
data,
xf=50,
yf=yf1,
rf_lim=2,
semi_len_min=19,
semi_len_max=None,
semi_len_ratio_lim=2,
min_samples=5,
residual_threshold=10,
max_trails=300,
)
params10f = (xf, yf1, a, b, r)
params11f = ret._ellipse_model_centre_to_focus(*model_ransac1.params,
xf, yf1)
compare_model_params(params10f, params11f, abs=0.1)
def _make_4d_peak_array_test_data(xf, yf, semi0, semi1, rot, nt=20):
"""Get a 4D NumPy array with peak_array test data.
Parameters
----------
xf, yf : scalar, 2D NumPy array
Centre position of the ellipse. The size of the xf array gives the
size of the peak_array.
semi0, semi1 : scalar, 2D NumPy array
Semi length of the ellipse, of rot is 0 semi0 is the x-direction
semi length, and semi1 the y-direction.
rot : scalar, 2D NumPy array
Rotation in radians.
nt : scalar
Number of points in the ellipse.
Returns
-------
peak_array : NumPy 4D array
Examples
--------
>>> import pyxem as pxm
>>> from pyxem.dummy_data import make_diffraction_test_data as mdtd
>>> xf = np.random.randint(65, 70, size=(4, 5))
>>> yf = np.random.randint(115, 120, size=(4, 5))
>>> semi0 = np.random.randint(35, 40, size=(4, 5))
>>> semi1 = np.random.randint(45, 50, size=(4, 5))
>>> rot = np.random.random(size=(4, 5)) * 0.2
>>> peak_array = mdtd._make_4d_peak_array_test_data(
... xf, yf, semi0, semi1, rot)
>>> s = pxm.signals.Diffraction2D(np.zeros(shape=(4, 5, 200, 210)))
>>> import pyxem.utils.marker_tools as mt
>>> mt.add_peak_array_to_signal_as_markers(s, peak_array)
"""
peak_array = np.empty_like(xf, dtype=np.object)
for iy, ix in np.ndindex(peak_array.shape):
params = (xf[iy, ix], yf[iy, ix], semi0[iy,
ix], semi1[iy,
ix], rot[iy,
ix], nt)
ellipse_points = ret.make_ellipse_data_points(*params)
peak_array[iy, ix] = np.fliplr(ellipse_points)
return peak_array
def test_simple(self):
data = ret.make_ellipse_data_points(50, 55, 20, 16, 2, nt=15)
ret.get_ellipse_model_ransac_single_frame(data)
def test_nt(self):
data0 = ret.make_ellipse_data_points(5, 2, 9, 5, 0, nt=10)
assert data0.shape == (10, 2)
data1 = ret.make_ellipse_data_points(5, 2, 9, 5, 0, nt=29)
assert data1.shape == (29, 2)
def test_simple(self):
data = ret.make_ellipse_data_points(5, 2, 9, 5, 0)
assert data.size > 0
def test_min_samples_smaller_than_data(self):
data = ret.make_ellipse_data_points(50, 55, 20, 16, 2, nt=15)
ret.get_ellipse_model_ransac_single_frame(data, min_samples=25)
