def rk4(self, input_vf, input_num_steps=None, input_pix_dims=None):
""" Runge Kutta 4 """
# (0)
self.initialise_input(input_vf)
self.initialise_number_of_steps(input_num_steps=input_num_steps,
input_pix_dims=input_pix_dims)
if self.num_steps == 0:
h = 1.0
else:
h = 1.0 / self.num_steps
for _ in range(self.num_steps):
r_1 = h * cp.lagrangian_dot_lagrangian(
self.vf, self.phi, s_i_o=self.s_i_o, add_right=False)
psi_1 = self.phi + .5 * r_1
r_2 = h * cp.lagrangian_dot_lagrangian(
self.vf, psi_1, s_i_o=self.s_i_o, add_right=False)
psi_2 = self.phi + .5 * r_2
r_3 = h * cp.lagrangian_dot_lagrangian(
self.vf, psi_2, s_i_o=self.s_i_o, add_right=False)
psi_3 = self.phi + r_3
r_4 = h * cp.lagrangian_dot_lagrangian(
self.vf, psi_3, s_i_o=self.s_i_o, add_right=False)
self.phi += (1. / 6) * (r_1 + 2 * r_2 + 2 * r_3 + r_4)
return self.phi
def heun_mod(self, input_vf, input_num_steps=None, input_pix_dims=None):
""" Heun modified method """
# (0)
self.initialise_input(input_vf)
self.initialise_number_of_steps(input_num_steps=input_num_steps,
input_pix_dims=input_pix_dims)
if self.num_steps == 0:
h = 1.0
else:
h = 1.0 / self.num_steps
for i in range(self.num_steps):
psi_1 = self.phi + (h / 3) * cp.lagrangian_dot_lagrangian(
self.vf, self.phi, s_i_o=self.s_i_o, add_right=False)
psi_2 = self.phi + h * (2. / 3) * cp.lagrangian_dot_lagrangian(
self.vf, psi_1, s_i_o=self.s_i_o, add_right=False)
psi_3 = cp.lagrangian_dot_lagrangian(self.vf, self.phi, s_i_o=self.s_i_o, add_right=False) + \
3 * cp.lagrangian_dot_lagrangian(self.vf, psi_2, s_i_o=self.s_i_o, add_right=False)
self.phi += (h / 4) * psi_3
return self.phi
def trapezoid_midpoint(self,
input_vf,
input_num_steps=None,
input_pix_dims=None):
""" """
# (0)
self.initialise_input(input_vf)
self.initialise_number_of_steps(input_num_steps=input_num_steps,
input_pix_dims=input_pix_dims)
if self.num_steps == 0:
h = 1.0
else:
h = 1.0 / self.num_steps
for _ in range(0, self.num_steps):
# midpoint
phi_tilda_tilda = self.phi + (
h / 2) * cp.lagrangian_dot_lagrangian(
self.vf, self.phi, s_i_o=self.s_i_o, add_right=False)
phi_tilda = self.phi + h * cp.lagrangian_dot_lagrangian(
self.vf, phi_tilda_tilda, s_i_o=self.s_i_o, add_right=False)
self.phi += .5 * h * (cp.lagrangian_dot_lagrangian(
self.vf, self.phi, s_i_o=self.s_i_o,
add_right=False) + cp.lagrangian_dot_lagrangian(
self.vf, phi_tilda, s_i_o=self.s_i_o, add_right=False))
return self.phi
def test_2_random_vector_fields_svf(get_figures=False):
"""
The composition is not the identity since we are working in the tangent space.
"""
dec = 3
passe_partout = 5
omega = (10, 10)
svf_f = gen_id.id_lagrangian(omega=omega)
svf_f_inv = np.copy(-1 * svf_f)
f_o_f_inv = cp.lagrangian_dot_lagrangian(svf_f, svf_f_inv, add_right=True)
f_inv_o_f = cp.lagrangian_dot_lagrangian(svf_f_inv, svf_f, add_right=True)
svf_id = gen_id.id_lagrangian(omega=omega)
# # results of a composition of 2 lagrangian must be a lagrangian zero field
assert_array_almost_equal(f_o_f_inv[passe_partout:-passe_partout,
passe_partout:-passe_partout, 0, 0, :],
svf_id[passe_partout:-passe_partout,
passe_partout:-passe_partout, 0, 0, :],
decimal=dec)
assert_array_almost_equal(f_inv_o_f[passe_partout:-passe_partout,
passe_partout:-passe_partout, 0, 0, :],
svf_id[passe_partout:-passe_partout,
passe_partout:-passe_partout, 0, 0, :],
decimal=dec)
if get_figures:
fields_at_the_window.see_field(svf_f, fig_tag=51)
fields_at_the_window.see_field(
svf_f_inv,
fig_tag=51,
input_color='r',
title_input='2 vector fields: f blue, g red')
fields_at_the_window.see_field(svf_f, fig_tag=52)
fields_at_the_window.see_field(svf_f_inv, fig_tag=52, input_color='r')
fields_at_the_window.see_field(
f_o_f_inv,
fig_tag=52,
input_color='g',
title_input='composition (f o f^(-1)) in green')
fields_at_the_window.see_field(svf_f, fig_tag=53)
fields_at_the_window.see_field(svf_f_inv, fig_tag=53, input_color='r')
fields_at_the_window.see_field(
f_inv_o_f,
fig_tag=53,
input_color='g',
title_input='composition (f^(-1) o f) in green')
plt.show()
def gss_rk4(self, input_vf, input_num_steps=None, input_pix_dims=None):
""" Generalised scaling and squaring runge kutta method """
# (0)
self.initialise_input(input_vf)
self.initialise_number_of_steps(input_num_steps=input_num_steps,
input_pix_dims=input_pix_dims)
norm = np.linalg.norm(self.vf, axis=self.vf.ndim - 1)
max_norm = np.max(norm[:])
if max_norm == 0:
return self.phi
if self.num_steps == 0:
h = 1.0
else:
h = 1.0 / self.num_steps
# (1)
init = 1 << self.num_steps
self.vf = self.vf / init
# (1.5)
for _ in range(self.num_steps):
r_1 = h * cp.lagrangian_dot_lagrangian(
self.vf, self.phi, s_i_o=self.s_i_o, add_right=False)
psi_1 = self.phi + .5 * r_1
r_2 = h * cp.lagrangian_dot_lagrangian(
self.vf, psi_1, s_i_o=self.s_i_o, add_right=False)
psi_2 = self.phi + .5 * r_2
r_3 = h * cp.lagrangian_dot_lagrangian(
self.vf, psi_2, s_i_o=self.s_i_o, add_right=False)
psi_3 = self.phi + r_3
r_4 = h * cp.lagrangian_dot_lagrangian(
self.vf, psi_3, s_i_o=self.s_i_o, add_right=False)
self.phi += (1. / 6) * (r_1 + 2 * r_2 + 2 * r_3 + r_4)
# (2)
for _ in range(self.num_steps):
self.phi = cp.lagrangian_dot_lagrangian(self.phi,
self.phi,
s_i_o=self.s_i_o,
add_right=True)
return self.phi
def gss_aei(self, input_vf, input_num_steps=None, input_pix_dims=None):
""" generalised scaling and squaring approximated exponential integrators """
# (0)
self.initialise_input(input_vf)
self.initialise_number_of_steps(input_num_steps=input_num_steps,
input_pix_dims=input_pix_dims)
# (1)
if self.num_steps == 0:
self.phi = self.vf
else:
init = 1 << self.num_steps
self.phi = self.vf / init
# (1.5) phi = 1 + v + 0.5jac*v
jv = np.squeeze(jac.compute_jacobian(self.phi))
v_sq = np.squeeze(self.phi)
new_shape = list(
self.omega) + [1] * (4 - self.dimension) + [self.dimension]
jv_prod_v = matrices.matrix_vector_field_product(
jv, v_sq).reshape(new_shape)
self.phi += 0.5 * jv_prod_v
# (2)
for _ in range(0, self.num_steps):
self.phi = cp.lagrangian_dot_lagrangian(self.phi,
self.phi,
s_i_o=self.s_i_o)
return self.phi
def gss_ei(self, input_vf, input_num_steps=None, input_pix_dims=None):
""" generalised scaling and squaring exponetial integrator """
# (0)
self.initialise_input(input_vf)
self.initialise_number_of_steps(input_num_steps=input_num_steps,
input_pix_dims=input_pix_dims)
# (1)
init = 1 << self.num_steps
self.phi = self.vf / init
# (1.5)
jv = jac.compute_jacobian(self.phi)
if self.dimension == 2:
v_matrix = np.array([0.0] * 3 * 3).reshape([3, 3])
for x in range(self.phi.shape[0]):
for y in range(self.phi.shape[1]):
# skew symmetric part
v_matrix[0:2, 0:2] = jv[x, y, 0, 0, :].reshape([2, 2])
# translational part
v_matrix[0, 2], v_matrix[1, 2] = self.phi[x, y, 0, 0,
0:2] # + \
# jv[x, y, 0, 0, :].reshape([2, 2]).dot([x, y])
# translational part of the exp is the answer:
self.phi[x, y, 0, 0, :] = expm(v_matrix)[0:2, 2]
elif self.dimension == 3:
v_matrix = np.array([0.0] * 4 * 4).reshape([4, 4])
for x in range(self.phi.shape[0]):
for y in range(self.phi.shape[1]):
for z in range(self.phi.shape[2]):
# skew symmetric part
v_matrix[0:3, 0:3] = jv[x, y, z, 0, :].reshape([3, 3])
# translation part
v_matrix[0,
3], v_matrix[1,
3], v_matrix[2,
3] = self.phi[x, y,
z, 0,
0:3]
self.phi[x, y, z, 0, :] = expm(v_matrix)[0:3, 3]
# (2)
for _ in range(0, self.num_steps):
self.phi = cp.lagrangian_dot_lagrangian(self.phi,
self.phi,
s_i_o=self.s_i_o)
return self.phi
def midpoint(self, input_vf, input_num_steps=None, input_pix_dims=None):
""" midpoint method """
# (0)
self.initialise_input(input_vf)
self.initialise_number_of_steps(input_num_steps=input_num_steps,
input_pix_dims=input_pix_dims)
# (1, 2)
if self.num_steps == 0:
h = 1.0
else:
h = 1.0 / self.num_steps
for _ in range(self.num_steps):
phi_tilda = self.phi + (h / 2) * cp.lagrangian_dot_lagrangian(
self.vf, self.phi, s_i_o=self.s_i_o, add_right=False)
self.phi += h * cp.lagrangian_dot_lagrangian(
self.vf, phi_tilda, s_i_o=self.s_i_o, add_right=False)
return self.phi
def gss_trapezoid_midpoint(self,
input_vf,
input_num_steps=None,
input_pix_dims=None):
""" """
# (0)
self.initialise_input(input_vf)
self.initialise_number_of_steps(input_num_steps=input_num_steps,
input_pix_dims=input_pix_dims)
if self.num_steps == 0:
h = 1.0
else:
h = 1.0 / self.num_steps
# TODO correct h for init value.
# (1)
init = 1 << self.num_steps
self.vf = self.vf / init
# (1.5)
for _ in range(0, self.num_steps):
phi_tilda_tilda = self.phi + (
h / 2) * cp.lagrangian_dot_lagrangian(
self.vf, self.phi, s_i_o=self.s_i_o, add_right=False)
phi_tilda = self.phi + h * cp.lagrangian_dot_lagrangian(
self.vf, phi_tilda_tilda, s_i_o=self.s_i_o, add_right=False)
self.phi += .5 * h * (cp.lagrangian_dot_lagrangian(
self.vf, self.phi, s_i_o=self.s_i_o,
add_right=False) + cp.lagrangian_dot_lagrangian(
self.vf, phi_tilda, s_i_o=self.s_i_o, add_right=False))
# (2)
for _ in range(0, self.num_steps):
self.phi = cp.lagrangian_dot_lagrangian(self.phi,
self.phi,
s_i_o=self.s_i_o,
add_right=True)
return self.phi
def euler_mod(self, input_vf, input_num_steps=None, input_pix_dims=None):
""" Euler modified method """
# (0)
self.initialise_input(input_vf)
self.initialise_number_of_steps(input_num_steps=input_num_steps,
input_pix_dims=input_pix_dims)
if self.num_steps == 0:
h = 1.0
else:
h = 1.0 / self.num_steps
for _ in range(self.num_steps):
phi_tilda = self.phi + h * cp.lagrangian_dot_lagrangian(
self.vf, self.phi, s_i_o=self.s_i_o, add_right=False)
self.phi += (h / 2) * (cp.lagrangian_dot_lagrangian(
self.vf, self.phi, s_i_o=self.s_i_o,
add_right=False) + cp.lagrangian_dot_lagrangian(
self.vf, phi_tilda, s_i_o=self.s_i_o, add_right=False))
return self.phi
def gss_trapezoid_euler(self,
input_vf,
input_num_steps=None,
input_pix_dims=None):
""" """
# (0)
self.initialise_input(input_vf)
self.initialise_number_of_steps(input_num_steps=input_num_steps,
input_pix_dims=input_pix_dims)
if self.num_steps == 0:
h = 1.0
else:
h = 1.0 / self.num_steps
# (1)
init = 1 << self.num_steps
self.vf = self.vf / init
# (1.5)
for _ in range(0, self.num_steps):
tilda_phi = self.phi + h * cp.lagrangian_dot_lagrangian(
self.vf, self.phi, s_i_o=self.s_i_o, add_right=False)
self.phi += .5 * h * (cp.lagrangian_dot_lagrangian(
self.vf, self.phi, s_i_o=self.s_i_o,
add_right=False) + cp.lagrangian_dot_lagrangian(
self.vf, tilda_phi, s_i_o=self.s_i_o, add_right=False))
# (2)
for _ in range(0, self.num_steps):
self.phi = cp.lagrangian_dot_lagrangian(self.phi,
self.phi,
s_i_o=self.s_i_o,
add_right=True)
return self.phi
def euler(self, input_vf, input_num_steps=None, input_pix_dims=None):
""" """
# (0)
self.initialise_input(input_vf)
self.initialise_number_of_steps(input_num_steps=input_num_steps,
input_pix_dims=input_pix_dims)
if self.num_steps == 0:
h = 1.0
else:
h = 1.0 / self.num_steps
for _ in range(self.num_steps):
self.phi += h * cp.lagrangian_dot_lagrangian(
self.vf, self.phi, s_i_o=self.s_i_o, add_right=False)
return self.phi
def gss_ei_mod(self, input_vf, input_num_steps=None, input_pix_dims=None):
""" generalised scaling and squaring exponential integrators modified """
# (0)
self.initialise_input(input_vf)
self.initialise_number_of_steps(input_num_steps=input_num_steps,
input_pix_dims=input_pix_dims)
# (1) copy the reduced v in phi, future solution of the ODE.
init = 1 << self.num_steps
self.phi = self.vf / init
# (1.5)
jv = jac.compute_jacobian(self.phi)
if self.dimension == 2:
for x in range(self.phi.shape[0]):
for y in range(self.phi.shape[1]):
j = jv[x, y, 0, 0, :].reshape([2, 2])
tr = self.phi[x, y, 0, 0, 0:2]
j_tr = j.dot(tr)
self.phi[x, y, 0,
0, :] = tr + 0.5 * j_tr # + 1/6. * J.dot(J_tr)
elif self.dimension == 3:
for x in range(self.phi.shape[0]):
for y in range(self.phi.shape[1]):
for z in range(self.phi.shape[2]):
j = jv[x, y, z, 0, :].reshape([3, 3])
tr = self.phi[x, y, z, 0, 0:3]
j_tr = j.dot(tr)
self.phi[
x, y, z,
0, :] = tr + 0.5 * j_tr # + 1/6. * j.dot(j_tr)
# (2)
for _ in range(0, self.num_steps):
self.phi = cp.lagrangian_dot_lagrangian(self.phi,
self.phi,
s_i_o=self.s_i_o)
return self.phi
def scaling_and_squaring(self,
input_vf,
input_num_steps=None,
input_pix_dims=None):
""" classical scaling and squaring """
# (0)
self.initialise_input(input_vf)
self.initialise_number_of_steps(input_num_steps=input_num_steps,
input_pix_dims=input_pix_dims)
# (1)
init = 1 << self.num_steps
self.phi = self.vf / float(init)
# (2)
for _ in range(0, self.num_steps):
self.phi = cp.lagrangian_dot_lagrangian(self.phi,
self.phi,
s_i_o=self.s_i_o)
return self.phi
def euler_aei(self, input_vf, input_num_steps=None, input_pix_dims=None):
""" euler with approximated exponential integrators """
# (0)
self.initialise_input(input_vf)
self.initialise_number_of_steps(input_num_steps=input_num_steps,
input_pix_dims=input_pix_dims)
self.vf = self.vf / self.num_steps
jv = np.squeeze(jac.compute_jacobian(self.vf))
v_sq = np.squeeze(self.vf)
new_shape = list(
self.omega) + [1] * (4 - self.dimension) + [self.dimension]
jv_prod_v = matrices.matrix_vector_field_product(
jv, v_sq).reshape(new_shape)
self.vf += 0.5 * jv_prod_v
for _ in range(self.num_steps):
self.phi = cp.lagrangian_dot_lagrangian(self.vf,
self.phi,
s_i_o=self.s_i_o)
return self.phi
def test_2_random_vector_fields_as_deformations(get_figures=False):
dec = 1
passe_partout = 3
omega = (15, 15)
sigma_init = 4
sigma_gaussian_filter = 2
svf_zeros = gen_id.id_lagrangian(omega)
svf_0 = gen.generate_random(omega,
parameters=(sigma_init, sigma_gaussian_filter))
l_exp = lie_exp.LieExp()
sdisp_0 = l_exp.scaling_and_squaring(svf_0)
sdisp_0_inv = l_exp.scaling_and_squaring(-1 * svf_0)
f_o_f_inv = cp.lagrangian_dot_lagrangian(sdisp_0,
sdisp_0_inv,
add_right=True)
f_inv_o_f = cp.lagrangian_dot_lagrangian(sdisp_0_inv,
sdisp_0,
add_right=True)
# results of a composition of 2 lagrangian must be a lagrangian zero field
assert_array_almost_equal(f_o_f_inv[passe_partout:-passe_partout,
passe_partout:-passe_partout, 0, 0, :],
svf_zeros[passe_partout:-passe_partout,
passe_partout:-passe_partout, 0, 0, :],
decimal=dec)
assert_array_almost_equal(f_inv_o_f[passe_partout:-passe_partout,
passe_partout:-passe_partout, 0, 0, :],
svf_zeros[passe_partout:-passe_partout,
passe_partout:-passe_partout, 0, 0, :],
decimal=dec)
if get_figures:
fields_at_the_window.see_field(sdisp_0, fig_tag=61)
fields_at_the_window.see_field(
sdisp_0_inv,
fig_tag=61,
input_color='r',
title_input='2 displacement fields: f blue, g red')
fields_at_the_window.see_field(sdisp_0, fig_tag=62)
fields_at_the_window.see_field(sdisp_0_inv,
fig_tag=62,
input_color='r')
fields_at_the_window.see_field(
f_o_f_inv,
fig_tag=62,
input_color='g',
title_input='composition (f o f^(-1)) in green')
fields_at_the_window.see_field(sdisp_0, fig_tag=63)
fields_at_the_window.see_field(sdisp_0_inv,
fig_tag=63,
input_color='r')
fields_at_the_window.see_field(
f_inv_o_f,
fig_tag=63,
input_color='g',
title_input='composition (f^(-1) o f) in green')
plt.show()
def test_less_easy_composition_with_identity(get_figures=False):
dec = 0 # decimal for the error
passe_partout = 4
omega = (20, 25)
svf_zeros = gen_id.id_lagrangian(omega=omega)
svf_f = gen_id.id_lagrangian(omega=omega)
svf_id = gen_id.id_lagrangian(omega=omega)
def function_f(t, x):
t = float(t)
x = [float(y) for y in x]
return np.array([np.sin(0.01 * x[1]), (3 * np.cos(x[0])) / (x[0] + 2)])
for x in range(20):
for y in range(20):
svf_f[x, y, 0, 0, :] = function_f(1, [x, y])
f_o_id = cp.lagrangian_dot_lagrangian(svf_f, svf_id, add_right=True)
id_o_f = cp.lagrangian_dot_lagrangian(svf_id, svf_f, add_right=True)
# test if the compositions are still in lagrangian coordinates, as attributes and as shape
assert_array_almost_equal(f_o_id[5, 5, 0, 0, :],
function_f(1, [5, 5]),
decimal=dec)
assert_array_almost_equal(id_o_f[5, 5, 0, 0, :],
function_f(1, [5, 5]),
decimal=dec)
# results of a composition of 2 lagrangian must be a lagrangian zero field
assert_array_almost_equal(f_o_id[passe_partout:-passe_partout,
passe_partout:-passe_partout, 0, 0, :],
svf_zeros[passe_partout:-passe_partout,
passe_partout:-passe_partout, 0, 0, :],
decimal=dec)
assert_array_almost_equal(id_o_f[passe_partout:-passe_partout,
passe_partout:-passe_partout, 0, 0, :],
svf_zeros[passe_partout:-passe_partout,
passe_partout:-passe_partout, 0, 0, :],
decimal=dec)
if get_figures:
fields_at_the_window.see_field(svf_f, fig_tag=41)
fields_at_the_window.see_field(
svf_id,
fig_tag=41,
input_color='r',
title_input='2 vector fields: f blue, g red')
fields_at_the_window.see_field(svf_f, fig_tag=42)
fields_at_the_window.see_field(svf_id, fig_tag=42, input_color='r')
fields_at_the_window.see_field(
f_o_id,
fig_tag=42,
input_color='g',
title_input='composition (f o id) in green')
fields_at_the_window.see_field(svf_f, fig_tag=43)
fields_at_the_window.see_field(svf_id, fig_tag=43, input_color='r')
fields_at_the_window.see_field(
id_o_f,
fig_tag=43,
input_color='g',
title_input='composition (id o f) in green')
plt.show()
def test_easy_composition_with_identity(get_figures=False):
dec = 6
passe_partout = 0
omega = (10, 10)
svf_zeros = gen_id.id_lagrangian(omega)
svf_f = gen_id.id_lagrangian(omega)
svf_id = gen_id.id_lagrangian(
omega) # id in lagrangian coordinates is the zero field
def function_f(t, x):
t = float(t)
x = [float(y) for y in x]
return np.array([0, 0.3])
for x in range(10):
for y in range(10):
svf_f[x, y, 0, 0, :] = function_f(1, [x, y])
f_o_id = cp.lagrangian_dot_lagrangian(svf_f, svf_id, add_right=True)
id_o_f = cp.lagrangian_dot_lagrangian(svf_id, svf_f, add_right=True)
# sfv_0 is provided in Lagrangian coordinates!
if get_figures:
fields_at_the_window.see_field(svf_f, fig_tag=21)
fields_at_the_window.see_field(
svf_id,
fig_tag=21,
input_color='r',
title_input='2 vector fields: f blue, g red')
fields_at_the_window.see_field(svf_f, fig_tag=22)
fields_at_the_window.see_field(svf_id, fig_tag=22, input_color='r')
fields_at_the_window.see_field(
f_o_id,
fig_tag=22,
input_color='g',
title_input='composition (f o id) in green')
fields_at_the_window.see_field(svf_f, fig_tag=23)
fields_at_the_window.see_field(svf_id, fig_tag=23, input_color='r')
fields_at_the_window.see_field(
id_o_f,
fig_tag=23,
input_color='g',
title_input='composition (id o f) in green')
plt.show()
# test if the compositions are still in lagrangian coordinates, as attributes and as shape
assert_array_almost_equal(f_o_id[5, 5, 0, 0, :],
function_f(1, [5, 5]),
decimal=dec)
assert_array_almost_equal(id_o_f[5, 5, 0, 0, :],
function_f(1, [5, 5]),
decimal=dec)
# results of a composition of 2 lagrangian must be a lagrangian zero field
assert_array_almost_equal(f_o_id[passe_partout:-passe_partout,
passe_partout:-passe_partout, 0, 0, :],
svf_zeros[passe_partout:-passe_partout,
passe_partout:-passe_partout, 0, 0, :],
decimal=dec)
assert_array_almost_equal(id_o_f[passe_partout:-passe_partout,
passe_partout:-passe_partout, 0, 0, :],
svf_zeros[passe_partout:-passe_partout,
passe_partout:-passe_partout, 0, 0, :],
decimal=dec)
def function_f(t, x):
t = float(t)
x = [float(y) for y in x]
return np.array([0, 0.3])
def function_g(t, x):
t = float(t)
x = [float(y) for y in x]
return np.array([0, -0.3])
for x in range(0, 6):
for y in range(0, 6):
svf_f[x, y, 0, 0, :] = function_f(1, [x, y])
svf_g[x, y, 0, 0, :] = function_g(1, [x, y])
f_o_g = cp.lagrangian_dot_lagrangian(svf_f, svf_g)
g_o_f = cp.lagrangian_dot_lagrangian(svf_g, svf_f)
fields_at_the_window.see_field(svf_f, fig_tag=2, input_color='b')
fields_at_the_window.see_field(svf_g, fig_tag=2, input_color='r')
fields_at_the_window.see_field(f_o_g, fig_tag=2, input_color='g', title_input='composition (f o g) in green')
fields_at_the_window.see_field(svf_f, fig_tag=3, input_color='b')
fields_at_the_window.see_field(svf_g, fig_tag=3, input_color='r')
fields_at_the_window.see_field(g_o_f, fig_tag=3, input_color='g', title_input='composition (g o f) in green')
plt.show()
from calie.operations import lie_exp
from calie.visualisations.fields import fields_at_the_window
from calie.fields import generate as gen
from calie.fields import compose as cp
if __name__ == '__main__':
# generate two vector fields
omega = (20, 20)
svf_v = gen.generate_random(omega, parameters=(2, 2))
svf_v_inv = np.copy(-1 * svf_v)
# we wrongly perform the composition of stationary velocity fields. The outcome is not the identity.
v_o_v_inv_alg = cp.lagrangian_dot_lagrangian(svf_v, svf_v_inv)
v_inv_o_v_alg = cp.lagrangian_dot_lagrangian(svf_v_inv, svf_v)
# we correctly perform the composition after exponentiating the SVF in the Lie group.
# The outcome is the identity, as expected.
l_exp = lie_exp.LieExp()
disp_v = l_exp.scaling_and_squaring(svf_v)
disp_v_inv = l_exp.scaling_and_squaring(svf_v_inv)
v_o_v_inv_grp = cp.lagrangian_dot_lagrangian(disp_v, disp_v_inv)
f_inv_o_f_grp = cp.lagrangian_dot_lagrangian(disp_v_inv, disp_v)
# see svf map the svfs
fields_at_the_window.see_field(svf_v, fig_tag=77)
def test_controlled_composition_of_two_closed_form_vector_fields_2d_1(
get_figures=False):
omega = (30, 30)
dec = 1
passe_partout = 10
def u(x, y):
return 0, 0
def v(x, y):
return 1, 1
def u_dot_v(x, y):
return 0, 0
def v_dot_u(x, y):
return 1, 1
svf_u = gen_id.id_lagrangian(omega=omega)
svf_v = gen_id.id_lagrangian(omega=omega)
svf_u_dot_v = gen_id.id_lagrangian(omega=omega)
svf_v_dot_u = gen_id.id_lagrangian(omega=omega)
for x in range(omega[0]):
for y in range(omega[1]):
svf_u[x, y, 0, 0, :] = u(x, y)
svf_v[x, y, 0, 0, :] = v(x, y)
svf_u_dot_v[x, y, 0, 0, :] = u_dot_v(x, y)
svf_v_dot_u[x, y, 0, 0, :] = v_dot_u(x, y)
svf_u_dot_v_numerical = cp.lagrangian_dot_lagrangian(svf_u,
svf_v,
add_right=False)
svf_v_dot_u_numerical = cp.lagrangian_dot_lagrangian(svf_v,
svf_u,
add_right=False)
if get_figures:
fields_at_the_window.see_field(svf_u, fig_tag=62)
fields_at_the_window.see_field(svf_v, fig_tag=62, input_color='r')
fields_at_the_window.see_field(svf_u_dot_v,
fig_tag=62,
input_color='g',
title_input='(u o v) closed form')
fields_at_the_window.see_field(svf_u, fig_tag=63)
fields_at_the_window.see_field(svf_v, fig_tag=63, input_color='r')
fields_at_the_window.see_field(svf_u_dot_v_numerical,
fig_tag=63,
input_color='g',
title_input='(u o v) numerical')
fields_at_the_window.see_field(svf_u, fig_tag=64)
fields_at_the_window.see_field(svf_v, fig_tag=64, input_color='r')
fields_at_the_window.see_field(
svf_v_dot_u,
fig_tag=64,
input_color='g',
title_input='composition v o u closed form')
fields_at_the_window.see_field(svf_u, fig_tag=65)
fields_at_the_window.see_field(svf_v, fig_tag=65, input_color='r')
fields_at_the_window.see_field(
svf_v_dot_u_numerical,
fig_tag=65,
input_color='g',
title_input='composition v o u numerical')
plt.show()
assert_array_almost_equal(
svf_u_dot_v[passe_partout:-passe_partout, passe_partout:-passe_partout,
0, 0, :],
svf_u_dot_v_numerical[passe_partout:-passe_partout,
passe_partout:-passe_partout, 0, 0, :],
decimal=dec)
assert_array_almost_equal(
svf_v_dot_u[passe_partout:-passe_partout, passe_partout:-passe_partout,
0, 0, :],
svf_v_dot_u_numerical[passe_partout:-passe_partout,
passe_partout:-passe_partout, 0, 0, :],
decimal=dec)
def test_2_less_easy_vector_fields(get_figures=False):
dec = 1 # decimal for the error
passe_partout = 3
omega = (20, 20)
svf_zeros = gen_id.id_lagrangian(omega)
svf_f = gen_id.id_lagrangian(omega)
svf_f_inv = gen_id.id_lagrangian(omega)
def function_f(t, x):
t = float(t)
x = [float(y) for y in x]
return np.array([np.sin(0.01 * x[1]), (3 * np.cos(x[0])) / (x[0] + 2)])
for x in range(20):
for y in range(20):
svf_f[x, y, 0, 0, :] = function_f(1, [x, y])
svf_f_inv[x, y, 0, 0, :] = -1 * function_f(1, [x, y])
f_o_f_inv = cp.lagrangian_dot_lagrangian(svf_f, svf_f_inv, add_right=True)
f_inv_o_f = cp.lagrangian_dot_lagrangian(svf_f_inv, svf_f, add_right=True)
assert_array_almost_equal(f_o_f_inv[10, 10, 0, 0, :], [.0, .0],
decimal=dec)
assert_array_almost_equal(f_inv_o_f[10, 10, 0, 0, :], [.0, .0],
decimal=dec)
# results of a composition
assert_array_almost_equal(f_o_f_inv[passe_partout:-passe_partout,
passe_partout:-passe_partout, 0, 0, :],
svf_zeros[passe_partout:-passe_partout,
passe_partout:-passe_partout, 0, 0, :],
decimal=dec)
assert_array_almost_equal(f_inv_o_f[passe_partout:-passe_partout,
passe_partout:-passe_partout, 0, 0, :],
svf_zeros[passe_partout:-passe_partout,
passe_partout:-passe_partout, 0, 0, :],
decimal=dec)
if get_figures:
fields_at_the_window.see_field(svf_f)
fields_at_the_window.see_field(
svf_f_inv,
input_color='r',
title_input='2 vector fields: f blue, g red')
fields_at_the_window.see_field(svf_f, fig_tag=2)
fields_at_the_window.see_field(svf_f_inv, fig_tag=2)
fields_at_the_window.see_field(
f_o_f_inv,
fig_tag=2,
input_color='g',
title_input='composition (f o f^(-1)) in green')
fields_at_the_window.see_field(svf_f, fig_tag=3)
fields_at_the_window.see_field(svf_f_inv, fig_tag=3, input_color='r')
fields_at_the_window.see_field(
f_inv_o_f,
fig_tag=3,
input_color='g',
title_input='composition (f^(-1) o f) in green')
plt.show()
def three_assessments_collector(control):
# ----------------------- #
# Retrieve data set paths
# ----------------------- #
if control['svf_dataset'].lower() in {'rotation', 'rotations'}:
pfi_svf_list = [
jph(pfo_output_A4_SE2, 'se2-{}-algebra.npy'.format(s + 1))
for s in range(num_samples)
]
elif control['svf_dataset'].lower() in {'linear'}:
pfi_svf_list = [
jph(pfo_output_A4_GL2, 'gl2-{}-algebra.npy'.format(s + 1))
for s in range(num_samples)
]
elif control['svf_dataset'].lower() in {'homography', 'homographies'}:
pfi_svf_list = [
jph(pfo_output_A4_HOM, 'hom-{}-algebra.npy'.format(s + 1))
for s in range(12)
] # TODO
elif control['svf_dataset'].lower() in {'gauss'}:
pfi_svf_list = [
jph(pfo_output_A4_GAU, 'gau-{}-algebra.npy'.format(s + 1))
for s in range(num_samples)
]
elif control['svf_dataset'].lower() in {'brainweb'}:
pfi_svf_list = [
jph(pfo_output_A4_BW, 'bw-{}-algebra.npy'.format(sj))
for sj in bw_subjects[1:]
]
elif control['svf_dataset'].lower() in {'adni'}:
pfi_svf_list = [
jph(pfo_output_A4_AD, 'ad-{}-algebra.npy'.format(sj))
for sj in ad_subjects
]
else:
raise IOError('Svf data set not given'.format(control['svf_dataset']))
for pfi in pfi_svf_list:
assert os.path.exists(pfi), pfi
# --------------------------------------- #
# Select number of steps for each method
# --------------------------------------- #
if control['computation'] == 'IC':
steps = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20, 30]
elif control['computation'] == 'SA':
steps = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20, 30]
elif control['computation'] == 'SE':
steps = range(1, 30)
else:
raise IOError('Input control computation {} not defined.'.format(
control['computation']))
if control['collect']:
print(
'---------------------------------------------------------------------------'
)
print('Test {} for dataset {} '.format(control['computation'],
control['svf_dataset']))
print(
'---------------------------------------------------------------------------'
)
for pfi_svf in pfi_svf_list:
sj_id = os.path.basename(pfi_svf).split('-')[:2]
sj_id = sj_id[0] + '-' + sj_id[1]
print('Computation for subject {}.'.format(sj_id))
method_names = [k for k in methods.keys() if methods[k][1]]
df_steps_measures = pd.DataFrame(columns=method_names, index=steps)
svf1 = np.load(pfi_svf)
for met in method_names:
print(' --> Computing method {}.'.format(met))
exp_method = methods[met][0]
for st in steps:
print(' ---> step {}'.format(st))
if control['computation'] == 'IC':
exp_st_svf1 = exp_method(svf1, input_num_steps=st)
exp_st_neg_svf1 = exp_method(-1 * svf1,
input_num_steps=st)
error = 0.5 * (qr.norm(cp.lagrangian_dot_lagrangian(
exp_st_svf1, exp_st_neg_svf1),
normalized=True) +
qr.norm(cp.lagrangian_dot_lagrangian(
exp_st_neg_svf1, exp_st_svf1),
normalized=True))
elif control['computation'] == 'SA':
a, b, c = 0.3, 0.3, 0.4
exp_st_a_svf1 = exp_method(a * svf1,
input_num_steps=st)
exp_st_b_svf1 = exp_method(b * svf1,
input_num_steps=st)
exp_st_c_svf1 = exp_method(c * svf1,
input_num_steps=st)
error = qr.norm(cp.lagrangian_dot_lagrangian(
cp.lagrangian_dot_lagrangian(
exp_st_a_svf1, exp_st_b_svf1), exp_st_c_svf1),
normalized=True)
elif control['computation'] == 'SE':
exp_st_svf1 = exp_method(svf1, input_num_steps=st)
exp_st_plus_one_svf1 = exp_method(svf1,
input_num_steps=st +
1)
error = qr.norm(exp_st_svf1 - exp_st_plus_one_svf1,
normalized=True)
else:
raise IOError(
'Input control computation {} not defined.'.format(
control['computation']))
df_steps_measures[met][st] = error
print(df_steps_measures)
fin_output = 'test_{}_{}.csv'.format(control['computation'], sj_id)
df_steps_measures.to_csv(jph(pfo_output_A5_3T, fin_output))
print('Test result saved in:')
print(fin_output)
print('\n')
else:
# assert pandas data-frame exists.
for pfi_svf in pfi_svf_list:
sj_id = os.path.basename(pfi_svf).split('-')[:2]
sj_id = sj_id[0] + '-' + sj_id[1]
fin_output = 'test_{}_{}.csv'.format(control['computation'], sj_id)
assert os.path.exists(jph(pfo_output_A5_3T, fin_output)), jph(
pfo_output_A5_3T, fin_output)
##################
# get statistics #
##################
if control['get_statistics']:
print(
'---------------------------------------------------------------------------'
)
print('Get statistics for {}, dataset {}. '.format(
control['computation'], control['svf_dataset']))
print(
'---------------------------------------------------------------------------'
)
# for each method get mean and std indexed by num-steps.
# | steps | mu_error | sigma_error | mu_time | sigma_error |
# in a file called stats-<computation>-<method>.csv
for method_name in [k for k in methods.keys() if methods[k][1]]:
print('\n Statistics for method {} \n'.format(method_name))
# for each method stack all the measurements in a single matrix STEPS x SVFs
steps_times_subjects = np.nan * np.ones(
[len(steps), len(pfi_svf_list)])
for pfi_svf_index, pfi_svf in enumerate(pfi_svf_list):
sj_id = os.path.basename(pfi_svf).split('-')[:2]
sj_id = sj_id[0] + '-' + sj_id[1]
fin_test = 'test_{}_{}.csv'.format(control['computation'],
sj_id)
df_steps_measures = pd.read_csv(jph(pfo_output_A5_3T,
fin_test))
steps_times_subjects[:, pfi_svf_index] = df_steps_measures[
method_name].as_matrix()
df_mean_std = pd.DataFrame(
columns=['steps', 'mu_error', 'std_error'],
index=range(len(steps)))
df_mean_std['steps'] = steps
df_mean_std['mu_error'] = np.mean(steps_times_subjects, axis=1)
df_mean_std['std_error'] = np.std(steps_times_subjects, axis=1)
print(df_mean_std)
pfi_df_mean_std = jph(
pfo_output_A5_3T,
'stats-3T-{}-{}-{}.csv'.format(control['svf_dataset'],
control['computation'],
method_name))
df_mean_std.to_csv(jph(pfi_df_mean_std))
else:
for method_name in [k for k in methods.keys() if methods[k][1]][:1]:
pfi_df_mean_std = jph(
pfo_output_A5_3T,
'stats-3T-{}-{}-{}.csv'.format(control['svf_dataset'],
control['computation'],
method_name))
assert os.path.exists(pfi_df_mean_std), pfi_df_mean_std
###############
# show graphs #
###############
if control['show_graphs']:
print(
'---------------------------------------------------------------------------'
)
print('Showing graphs for {}, dataset {}. '.format(
control['computation'], control['svf_dataset']))
print(
'---------------------------------------------------------------------------'
)
font_top = {
'family': 'serif',
'color': 'darkblue',
'weight': 'normal',
'size': 14
}
font_bl = {
'family': 'serif',
'color': 'black',
'weight': 'normal',
'size': 12
}
legend_prop = {'size': 11}
sns.set_style()
fig, ax = plt.subplots(figsize=(11, 6))
fig.canvas.set_window_title('{}_{}.pdf'.format(control['svf_dataset'],
control['computation']))
for method_name in [k for k in methods.keys() if methods[k][1]]:
pfi_df_mean_std = jph(
pfo_output_A5_3T,
'stats-3T-{}-{}-{}.csv'.format(control['svf_dataset'],
control['computation'],
method_name))
df_mean_std = pd.read_csv(pfi_df_mean_std)
if method_name in [
'gss_ei', 'gss_ei_mod', 'gss_aei', 'gss_rk4', 'euler_aei'
]:
method_name_bypass = method_name + ' *'
elif method_name in ['scaling_and_squaring']:
method_name_bypass = '******'
else:
method_name_bypass = method_name
ax.plot(df_mean_std['steps'].values,
df_mean_std['mu_error'].values,
label=method_name_bypass,
color=methods[method_name][3],
linestyle=methods[method_name][4],
marker=methods[method_name][5])
plt.errorbar(df_mean_std['steps'].values,
df_mean_std['mu_error'].values,
df_mean_std['std_error'].values,
linestyle='None',
marker='None',
color=methods[method_name][3],
alpha=0.5,
elinewidth=0.8)
ax.set_title('Experiment {} for {}'.format(control['computation'],
control['svf_dataset']),
fontdict=font_top)
ax.legend(loc='upper right', shadow=True, prop=legend_prop)
ax.xaxis.grid(True,
linestyle='-',
which='major',
color='lightgrey',
alpha=0.5)
ax.yaxis.grid(True,
linestyle='-',
which='major',
color='lightgrey',
alpha=0.5)
ax.set_axisbelow(True)
ax.set_xlabel('Steps', fontdict=font_bl, labelpad=5)
ax.set_ylabel('Error (mm)', fontdict=font_bl, labelpad=5)
# ax.set_xscale('log', nonposx="mask")
# ax.set_yscale('log', nonposy="mask")
pfi_figure_time_vs_error = jph(
pfo_output_A5_3T,
'three_experiments_{}_{}.pdf'.format(control['computation'],
control['svf_dataset']))
plt.savefig(pfi_figure_time_vs_error, dpi=150)
plt.show(block=True)