def test_rf_lim(self):
xf, yf = np.ones((2, 3)) * 200, np.ones((2, 3)) * 210
np.random.seed(7)
semi0 = np.random.randint(90, 110, size=(2, 3))
semi1 = np.random.randint(130, 140, size=(2, 3))
rot = np.zeros((2, 3))
peak_array = mdtd._make_4d_peak_array_test_data(
xf, yf, semi0, semi1, rot, nt=20
)
ellipse_array0, inlier_array0 = ret.get_ellipse_model_ransac(
peak_array,
xf=200,
yf=210,
rf_lim=20,
semi_len_min=80,
semi_len_max=150,
semi_len_ratio_lim=1.7,
min_samples=15,
max_trails=20,
)
ellipse_array1, inlier_array1 = ret.get_ellipse_model_ransac(
peak_array,
xf=200,
yf=210,
rf_lim=20,
semi_len_min=80,
semi_len_max=150,
semi_len_ratio_lim=1.01,
min_samples=15,
max_trails=20,
)
for iy, ix in np.ndindex(xf.shape):
ellipse_params0 = ellipse_array0[iy, ix]
ellipse_params1 = ellipse_array1[iy, ix]
assert ellipse_params0 != ellipse_params1
def test_semi_len_ratio_lim(self):
xf, yf = np.ones((2, 3)) * 200, np.ones((2, 3)) * 210
semi00, semi01 = np.ones((2, 3)) * 100, np.ones((2, 3)) * 100
semi10, semi11 = np.ones((2, 3)) * 100, np.ones((2, 3)) * 190
rot = np.zeros((2, 3))
peak_array = mdtd._make_4d_peak_array_test_data(xf,
yf,
semi00,
semi01,
rot,
nt=20)
peak_array1 = mdtd._make_4d_peak_array_test_data(xf,
yf,
semi10,
semi11,
rot,
nt=20)
for iy, ix in np.ndindex(xf.shape):
peak_array[iy, ix] = np.vstack(
(peak_array[iy, ix], peak_array1[iy, ix]))
ellipse_array0, inlier_array0 = ret.get_ellipse_model_ransac(
peak_array,
xf=200,
yf=210,
rf_lim=20,
semi_len_min=95,
semi_len_max=195,
semi_len_ratio_lim=1.11,
min_samples=15,
max_trails=200,
)
ellipse_array1, inlier_array1 = ret.get_ellipse_model_ransac(
peak_array,
xf=200,
yf=210,
rf_lim=20,
semi_len_min=95,
semi_len_max=195,
semi_len_ratio_lim=2.0,
min_samples=15,
max_trails=200,
)
semi_len_ratio_list = []
for iy, ix in np.ndindex(xf.shape):
if ellipse_array1[iy, ix] is not None:
semi0, semi1 = ellipse_array1[iy, ix][2:4]
semi_len_ratio = max(semi0, semi1) / min(semi0, semi1)
semi_len_ratio_list.append(semi_len_ratio)
semi_len_ratio_list = np.array(semi_len_ratio_list)
assert (semi_len_ratio_list > 1.8).any()
def test_no_values_out_of_bounds(self):
xf, yf, rf_lim = 100, 100, 20
semi_len_min, semi_len_max = 50, 100
semi_len_ratio_lim = 1.15
peak_array = np.random.randint(0, 200, size=(10, 11, 200, 2))
ellipse_array, inlier_array = ret.get_ellipse_model_ransac(
peak_array,
xf=xf,
yf=yf,
rf_lim=rf_lim,
semi_len_min=semi_len_min,
semi_len_max=semi_len_max,
semi_len_ratio_lim=semi_len_ratio_lim,
min_samples=15,
max_trails=5,
)
for iy, ix in np.ndindex(peak_array.shape[:2]):
if ellipse_array[iy, ix] is not None:
xc, yc, semi0, semi1, r = ellipse_array[iy, ix]
x, y = ret._get_closest_focus(xf, yf, xc, yc, semi0, semi1, r)
rf = math.hypot(x - xf, y - yf)
semi_ratio = max(semi0, semi1) / min(semi0, semi1)
assert rf < rf_lim
assert semi_ratio < semi_len_ratio_lim
assert semi0 > semi_len_min
assert semi1 > semi_len_min
assert semi0 < semi_len_max
assert semi1 < semi_len_max
def test_semi_lengths(self):
xf, yf = np.ones((2, 3)) * 200, np.ones((2, 3)) * 210
np.random.seed(7)
semi0 = np.random.randint(90, 110, size=(2, 3))
semi1 = np.random.randint(130, 140, size=(2, 3))
rot = np.zeros((2, 3))
peak_array = mdtd._make_4d_peak_array_test_data(
xf, yf, semi0, semi1, rot, nt=20
)
ellipse_array, inlier_array = ret.get_ellipse_model_ransac(
peak_array,
xf=200,
yf=210,
rf_lim=20,
semi_len_min=80,
semi_len_max=150,
semi_len_ratio_lim=1.7,
min_samples=15,
max_trails=20,
)
for iy, ix in np.ndindex(xf.shape):
semi_min = min(ellipse_array[iy, ix][2], ellipse_array[iy, ix][3])
semi_max = max(ellipse_array[iy, ix][2], ellipse_array[iy, ix][3])
assert approx(semi_min, abs=0.01) == semi0[iy, ix]
assert approx(semi_max, abs=0.01) == semi1[iy, ix]
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_simple(self):
xc, yc = np.ones((2, 3)), np.ones((2, 3))
semi0, semi1 = np.ones((2, 3)), np.ones((2, 3))
rot = np.zeros((2, 3))
peak_array = mdtd._make_4d_peak_array_test_data(xc, yc, semi0, semi1, rot)
ellipse_array, inlier_array = ret.get_ellipse_model_ransac(
peak_array, max_trails=50
)
assert ellipse_array.shape == xc.shape
assert inlier_array.shape == xc.shape
def test_xc_yc(self):
np.random.seed(7)
xf = np.random.randint(90, 100, size=(2, 3))
yf = np.random.randint(110, 120, size=(2, 3))
semi0, semi1 = np.ones((2, 3)) * 60, np.ones((2, 3)) * 60
rot = np.zeros((2, 3))
peak_array = mdtd._make_4d_peak_array_test_data(xf,
yf,
semi0,
semi1,
rot,
nt=20)
ellipse_array0, inlier_array0 = ret.get_ellipse_model_ransac(
peak_array,
xf=95,
yf=115,
rf_lim=20,
semi_len_min=50,
semi_len_max=65,
semi_len_ratio_lim=1.2,
min_samples=15,
max_trails=20,
)
ellipse_array1, inlier_array1 = ret.get_ellipse_model_ransac(
peak_array,
xf=10,
yf=12,
rf_lim=20,
semi_len_min=50,
semi_len_max=65,
semi_len_ratio_lim=1.2,
min_samples=15,
max_trails=20,
)
for iy, ix in np.ndindex(xf.shape):
assert approx(xf[iy, ix], abs=0.0005) == ellipse_array0[iy, ix][1]
assert approx(yf[iy, ix], abs=0.0005) == ellipse_array0[iy, ix][0]
assert inlier_array0[iy, ix].all()
assert ellipse_array1[iy, ix] is None
assert inlier_array1[iy, ix] is None
def test_residual_threshold(self):
xyf, semi = np.ones((2, 3)) * 100, np.ones((2, 3)) * 90
rot = np.zeros((2, 3))
peak_array = mdtd._make_4d_peak_array_test_data(xyf,
xyf,
semi,
semi,
rot,
nt=20)
for iy, ix in np.ndindex(xyf.shape):
peak_array[iy, ix] = np.vstack((peak_array[iy, ix], [100, 5]))
ellipse_array0, inlier_array0 = ret.get_ellipse_model_ransac(
peak_array,
xf=100,
yf=100,
semi_len_min=85,
semi_len_max=95,
semi_len_ratio_lim=1.1,
residual_threshold=1,
max_trails=100,
min_samples=15,
)
ellipse_array1, inlier_array1 = ret.get_ellipse_model_ransac(
peak_array,
xf=100,
yf=100,
semi_len_min=85,
semi_len_max=95,
semi_len_ratio_lim=1.1,
residual_threshold=5,
max_trails=100,
min_samples=15,
)
for iy, ix in np.ndindex(xyf.shape):
inlier0 = inlier_array0[iy, ix]
inlier1 = inlier_array1[iy, ix]
assert inlier0.sum() == 20
assert inlier1.sum() == 21
def test_simple(self):
s, parray = dd.get_simple_ellipse_signal_peak_array()
ellipse_array, inlier_array = ret.get_ellipse_model_ransac(
parray,
xf=95,
yf=95,
rf_lim=20,
semi_len_min=40,
semi_len_max=100,
semi_len_ratio_lim=5,
max_trails=50,
)
s.add_ellipse_array_as_markers(ellipse_array,
inlier_array=inlier_array,
peak_array=parray)
def test_only_ellipse_array(self):
s, parray = dd.get_simple_ellipse_signal_peak_array()
s1 = s.deepcopy()
ellipse_array, inlier_array = ret.get_ellipse_model_ransac(
parray,
xf=95,
yf=95,
rf_lim=20,
semi_len_min=40,
semi_len_max=100,
semi_len_ratio_lim=5,
max_trails=50,
)
s.add_ellipse_array_as_markers(ellipse_array)
s1.add_ellipse_array_as_markers(ellipse_array,
inlier_array=inlier_array,
peak_array=parray)
assert len(list(s.metadata.Markers)) < len(list(s1.metadata.Markers))
