def test_se2_g_inv_null_element():
angle = 0
tx = 0
ty = 0
element = se2.Se2G(angle, tx, ty)
inverse_element = element.inv()
expected_inverse_element = se2.Se2G(-angle, -tx, -ty)
assert_array_almost_equal(inverse_element.get,
expected_inverse_element.get)
def test_se2_g_comparing_product_restricted_form_and_matrix_form():
any_angle_1 = uniform(-np.pi + np.abs(np.spacing(-np.pi)), np.pi)
any_tx_1 = uniform(-10, 10)
any_ty_1 = uniform(-10, 10)
any_angle_2 = uniform(-np.pi + np.abs(np.spacing(-np.pi)), np.pi)
any_tx_2 = uniform(-10, 10)
any_ty_2 = uniform(-10, 10)
get_matrix_output = \
(se2.Se2G(any_angle_1, any_tx_1, any_ty_1) * se2.Se2G(any_angle_2, any_tx_2, any_ty_2)).get_matrix
matrix_product_output = \
se2.Se2G(any_angle_1, any_tx_1, any_ty_1).get_matrix.dot(
se2.Se2G(any_angle_2, any_tx_2, any_ty_2).get_matrix)
assert_array_almost_equal(get_matrix_output, matrix_product_output)
def test_se2_g_mul_0_translation():
any_angle_1 = uniform(-np.pi + np.abs(np.spacing(-np.pi)), np.pi)
tx_1 = 0
ty_1 = 0
any_angle_2 = uniform(-np.pi + np.abs(np.spacing(-np.pi)), np.pi)
tx_2 = 0
ty_2 = 0
expected_output_angle = angles.mod_pipi(any_angle_1 + any_angle_2)
expected_output_tx = 0
expected_output_ty = 0
expected_output = [
expected_output_angle, expected_output_tx, expected_output_ty
]
given_output = (se2.Se2G(any_angle_1, tx_1, ty_1) *
se2.Se2G(any_angle_2, tx_2, ty_2)).get
assert_array_equal(given_output, expected_output)
def test_init_se2_g_random_input():
any_angle_in_pi_pi = uniform(-np.pi + np.abs(np.spacing(-np.pi)), np.pi)
any_tx = uniform(-10, 10)
any_ty = uniform(-10, 10)
assert_array_equal(
se2.Se2G(any_angle_in_pi_pi, any_tx, any_ty).get,
[any_angle_in_pi_pi, any_tx, any_ty])
def test_theory_inverse_exp_log():
any_angle_1 = uniform(-np.pi + np.abs(np.spacing(-np.pi)), np.pi)
any_tx_1 = uniform(-10, 10)
any_ty_1 = uniform(-10, 10)
a = se2.Se2G(any_angle_1, any_tx_1, any_ty_1)
ans = se2.se2a_exp(se2.se2g_log(a))
assert_array_almost_equal(a.get, ans.get)
def test_se2_g_mul_0_rotation():
angle_1 = 0
any_tx_1 = uniform(-10, 10)
any_ty_1 = uniform(-10, 10)
angle_2 = 0
any_tx_2 = uniform(-10, 10)
any_ty_2 = uniform(-10, 10)
expected_output_angle = 0
expected_output_tx = any_tx_1 + any_tx_2
expected_output_ty = any_ty_1 + any_ty_2
expected_output = [
expected_output_angle, expected_output_tx, expected_output_ty
]
given_output = (se2.Se2G(angle_1, any_tx_1, any_ty_1) *
se2.Se2G(angle_2, any_tx_2, any_ty_2)).get
assert_array_equal(given_output, expected_output)
def test_se2_g_get_matrix():
any_angle_in_pi_pi = uniform(-np.pi + np.abs(np.spacing(-np.pi)), np.pi)
any_tx = uniform(-10, 10)
any_ty = uniform(-10, 10)
m = se2.Se2G(any_angle_in_pi_pi, any_tx, any_ty).get_matrix
assert m[0, 0] == m[1, 1] == np.cos(any_angle_in_pi_pi) \
and -m[0, 1] == m[1, 0] == np.sin(any_angle_in_pi_pi) \
and m[2, 2] == 1 and m[0, 2] == any_tx and m[1, 2] == any_ty
def test_se2_g_log_pade_approx_comparison():
theta = uniform(-np.pi, np.pi)
tx = uniform(-5, 5)
ty = uniform(-5, 5)
element = se2.Se2G(theta, tx, ty)
ans_log = se2.se2g_log(element).get_matrix
ans_pade = lin.logm(element.get_matrix)
assert_array_almost_equal(ans_log, ans_pade)
def test_se2_g_inv_random_element():
angle = uniform(-np.pi + np.abs(np.spacing(-np.pi)), np.pi)
tx = uniform(-10, 10)
ty = uniform(-10, 10)
element = se2.Se2G(angle, tx, ty)
inverse_element = element.inv().get_matrix
expected = np.linalg.inv(element.get_matrix)
assert_array_almost_equal(inverse_element, expected)
def test_se2_g_inv_in_matrix_product():
angle = uniform(-np.pi + np.abs(np.spacing(-np.pi)), np.pi)
tx = uniform(-10, 10)
ty = uniform(-10, 10)
element = se2.Se2G(angle, tx, ty)
matr = element.get_matrix
matri_inv = element.inv().get_matrix
assert_array_almost_equal(matr.dot(matri_inv), np.identity(3))
def test_se2_g_norm_standard_random_input():
angle = uniform(-np.pi + np.abs(np.spacing(-np.pi)), np.pi)
tx = uniform(-10, 10)
ty = uniform(-10, 10)
lamb = 1.4
element = se2.Se2G(angle, tx, ty)
assert_equal(element.norm('standard', lamb),
np.sqrt(angle**2 + lamb * (tx**2 + ty**2)))
def test_se2_g_matrix2se2_g_sane_input():
theta = uniform(-np.pi, np.pi)
tx = uniform(-5, 5)
ty = uniform(-5, 5)
m = np.array([[np.cos(theta), -np.sin(theta), tx],
[np.sin(theta), np.cos(theta), ty], [0, 0, 1]])
ans = se2.matrix2se2g(m)
exp_ans = se2.Se2G(theta, tx, ty)
assert_array_almost_equal(ans.get, exp_ans.get)
def test_se2_g_mul_random_input():
any_angle_1 = uniform(-np.pi + np.abs(np.spacing(-np.pi)), np.pi)
any_tx_1 = uniform(-10, 10)
any_ty_1 = uniform(-10, 10)
any_angle_2 = uniform(-np.pi + np.abs(np.spacing(-np.pi)), np.pi)
any_tx_2 = uniform(-10, 10)
any_ty_2 = uniform(-10, 10)
expected_output_angle = angles.mod_pipi(any_angle_1 + any_angle_2)
expected_output_tx = any_tx_1 + any_tx_2 * np.cos(
any_angle_1) - any_ty_2 * np.sin(any_angle_1)
expected_output_ty = any_ty_1 + any_tx_2 * np.sin(
any_angle_1) + any_ty_2 * np.cos(any_angle_1)
expected_output = [
expected_output_angle, expected_output_tx, expected_output_ty
]
given_output = (se2.Se2G(any_angle_1, any_tx_1, any_ty_1) *
se2.Se2G(any_angle_2, any_tx_2, any_ty_2)).get
assert_array_equal(given_output, expected_output)
def test_se2_g_norm_fro_random_input_comparing_matrix_numpy_norm():
# comparing frobenius with frobenius norm matrix (random matrix
angle = uniform(-np.pi + np.abs(np.spacing(-np.pi)), np.pi)
tx = uniform(-10, 10)
ty = uniform(-10, 10)
element = se2.Se2G(angle, tx, ty)
output_norm = element.norm('fro')
linalg_norm = np.linalg.norm(element.get_matrix, 'fro')
global meaningful_decimals
assert round(np.abs(output_norm - linalg_norm), meaningful_decimals) == 0.0
def test_se2_g_log_0_angle():
theta = 0
tx = uniform(-5, 5)
ty = uniform(-5, 5)
element = se2.Se2G(theta, tx, ty)
ans_log = se2.se2g_log(element)
if ans_log.rotation_angle == 0 and ans_log.tx == tx and ans_log.ty == ty:
assert True
else:
assert False
def test_se2_g_get_matrix_det():
any_angle_in_pi_pi = uniform(-np.pi + np.abs(np.spacing(-np.pi)), np.pi)
any_tx = uniform(-10, 10)
any_ty = uniform(-10, 10)
m = se2.Se2G(any_angle_in_pi_pi, any_tx, any_ty).get_matrix
given_output = np.linalg.det(m)
expected_output = 1.0
global meaningful_decimals
assert round(np.abs(given_output - expected_output),
meaningful_decimals) == 0.0
def randomgen_linear_by_taste(sigma, taste, center=(0, 0)):
"""
To create a linear (2D) stationary tangent vector field according to the proposed taste
classification:
+ Taste 1 : real eigenvalues with positive signs. UNSTABLE NODE
+ Taste 2 : real eigenvalues with negative signs. STABLE NODE
+ Taste 3 : real eigenvalues with opposite signs. SADDLE
+ Taste 4 : complex conjugate with positive real part. OUTWARD SPIRAL
+ Taste 5 : complex conjugate with negative real part. INWARD SPIRAL
+ Taste 6 : complex conjugate with 0 real parts. CIRCLES, Based on se2.Se2G
:param sigma: how further away going from identity.
:param taste: int between 1 and 6 as in the classification.
:param center: (float, float) center of the transformation.
:return: 3x3 tangent space linear transformation matrix of the shape
| R | t |
| - - - |
| 0 | 0 |
"""
if taste not in range(1, 7):
raise IOError('taste must be an integer number between 1 and 6.')
if taste == 6:
x_c, y_c = center
theta = sigma * np.random.randn() + 2 * sigma
tx = (1 - np.cos(theta)) * x_c + np.sin(theta) * y_c
ty = -np.sin(theta) * x_c + (1 - np.cos(theta)) * y_c
m0 = se2.Se2G(theta, tx, ty)
dm0 = se2.se2g_log(m0)
return dm0.get_matrix
else:
found = False
rot = np.zeros([2, 2])
while not found:
rot = np.random.randn(2, 2)
if get_taste(rot - np.eye(2)) == taste:
found = True
dm = np.zeros([3, 3])
dm[:2, :2] = (1 / sigma) * rot
tx = (1 - dm[0, 0]) * center[0] - dm[0, 1] * center[1]
ty = -dm[1, 0] * center[0] + (1 - dm[1, 1]) * center[1]
dm[:2, 2] = np.array([tx, ty])
dm = dm - np.eye(3)
dm[2, 2] = 0
return dm
def test_se2_g_norm_fro_invariance_for_angle():
angle_1, tx, ty = 4, 5, 6
angle_2 = angle_1 + uniform(-np.pi, np.pi)
element_1 = se2.Se2G(angle_1, tx, ty)
element_2 = se2.Se2G(angle_2, tx, ty)
assert_equal(element_1.norm('fro'), element_2.norm('fro'))
def test_se2_g_norm_spam_input():
angle, tx, ty = 4, 5, 6
element = se2.Se2G(angle, tx, ty)
assert_equal(element.norm('spam'), -1)
def test_se2_g_norm_fro_random_input():
angle = uniform(-np.pi + np.abs(np.spacing(-np.pi)), np.pi)
tx = uniform(-10, 10)
ty = uniform(-10, 10)
element = se2.Se2G(angle, tx, ty)
assert_equal(element.norm('fro'), np.sqrt(3 + tx**2 + ty**2))
def test_se2_g_norm_fro_fixed_input_non0():
angle, tx, ty = 4, 5, 6
element = se2.Se2G(angle, tx, ty)
assert_equal(element.norm('fro'), np.sqrt(3 + 61.0))
def test_se2_g_norm_translation_fixed_input_non0():
angle, tx, ty = 4, 5, 6
element = se2.Se2G(angle, tx, ty)
assert_equal(element.norm('translation'), np.sqrt(61.0))
def test_se2_g_norm_standard_fixed_input_non0():
angle, tx, ty = 4, 5, 6
lamb = 1
element = se2.Se2G(angle, tx, ty)
assert_equal(element.norm('standard', lamb),
np.sqrt(angles.mod_pipi(angle)**2 + lamb * (tx**2 + ty**2)))
def test_se2_g_norm_fro_fixed_input_0():
angle, tx, ty = 0, 0, 0
element = se2.Se2G(angle, tx, ty)
print(element.get)
assert_equal(element.norm('fro'), np.sqrt(3))
def test_se2_g_norm_translation_fixed_input_0():
angle, tx, ty = 0, 0, 0
element = se2.Se2G(angle, tx, ty)
assert_equal(element.norm('translation'), 0)
def test_se2_g_norm_standard_fixed_input_0():
angle, tx, ty = 0, 0, 0
element = se2.Se2G(angle, tx, ty)
assert_equal(element.norm('standard', 1), 0)
# -> transformation model <- #
if params['deformation_model'] == 'translation':
svf_0 = np.zeros(list(omega)[::-1] + [1, 1, 2])
svf_0[..., 0] = 10
svf_0[..., 1] = 20
elif params['deformation_model'] == 'rotation':
x_c, y_c = [c / 2 for c in omega]
theta = np.pi / 8
tx = (1 - np.cos(theta)) * x_c + np.sin(theta) * y_c
ty = -np.sin(theta) * x_c + (1 - np.cos(theta)) * y_c
m_0 = se2.Se2G(theta, tx, ty)
dm_0 = se2.se2g_log(m_0)
print(m_0.get_matrix)
print('')
print(dm_0.get_matrix)
# Generate subsequent vector fields
flow = gen.generate_from_matrix(list(omega)[::-1], m_0.get_matrix, structure='group')
svf_0 = gen.generate_from_matrix(list(omega)[::-1], dm_0.get_matrix, structure='algebra')
elif params['deformation_model'] == 'linear':
taste = 1
beta = 0.5
def test_visual_assessment_method_one_se2(show=False):
"""
:param show: to add the visualisation of a figure.
This test is for visual assessment. Please put show to True.
Aimed to test the prototyping of the computation of the exponential map
with some methods.
(Nothing is saved in external folder.)
"""
##############
# controller #
##############
domain = (20, 20)
x_c = 10
y_c = 10
theta = np.pi / 8
tx = (1 - np.cos(theta)) * x_c + np.sin(theta) * y_c
ty = -np.sin(theta) * x_c + (1 - np.cos(theta)) * y_c
passepartout = 5
spline_interpolation_order = 3
l_exp = lie_exp.LieExp()
l_exp.s_i_o = spline_interpolation_order
methods_list = [
l_exp.scaling_and_squaring, l_exp.gss_ei, l_exp.gss_ei_mod,
l_exp.gss_aei, l_exp.midpoint, l_exp.series, l_exp.euler,
l_exp.euler_aei, l_exp.euler_mod, l_exp.heun, l_exp.heun_mod,
l_exp.rk4, l_exp.gss_rk4, l_exp.trapeziod_euler,
l_exp.trapezoid_midpoint, l_exp.gss_trapezoid_euler,
l_exp.gss_trapezoid_midpoint
]
# -----
# model
# -----
m_0 = se2.Se2G(theta, tx, ty)
dm_0 = se2.se2g_log(m_0)
# -- generate subsequent vector fields
svf_0 = gen.generate_from_matrix(domain,
dm_0.get_matrix,
structure='algebra')
sdisp_0 = gen.generate_from_matrix(domain,
m_0.get_matrix,
structure='group')
# -- compute exponential with different available methods:
sdisp_list = []
res_time = np.zeros(len(methods_list))
for num_met, met in enumerate(methods_list):
start = time.time()
sdisp_list.append(met(svf_0, input_num_steps=10))
res_time[num_met] = (time.time() - start)
# ----
# view
# ----
print('--------------------')
print('Norm of the svf: ')
print(qr.norm(svf_0, passe_partout_size=4))
print('--------------------')
print("Norm of the displacement field:")
print(qr.norm(sdisp_0, passe_partout_size=4))
print('--------------------')
print('Norm of the errors: ')
print('--------------------')
for num_met in range(len(methods_list)):
err = qr.norm(sdisp_list[num_met] - sdisp_0,
passe_partout_size=passepartout)
print('|{0:>22} - disp| = {1}'.format(methods_list[num_met].__name__,
err))
if methods_list[num_met].__name__ == 'euler':
assert err < 3
else:
assert err < 0.5
print('---------------------')
print('Computational Times: ')
print('---------------------')
if show:
title_input_l = ['Sfv Input', 'Ground Output'] + methods_list
fields_list = [svf_0, sdisp_0] + sdisp_list
list_fields_of_field = [[svf_0], [sdisp_0]]
list_colors = ['r', 'b']
for third_field in fields_list[2:]:
list_fields_of_field += [[svf_0, sdisp_0, third_field]]
list_colors += ['r', 'b', 'm']
fields_comparisons.see_n_fields_special(
list_fields_of_field,
fig_tag=50,
row_fig=5,
col_fig=5,
input_figsize=(14, 7),
colors_input=list_colors,
titles_input=title_input_l,
sample=(1, 1),
zoom_input=[0, 20, 0, 20],
window_title_input='matrix generated svf')
plt.show()
