class TestDiscreteCurves(geomstats.tests.TestCase): def setup_method(self): s2 = Hypersphere(dim=2) r2 = Euclidean(dim=2) r3 = s2.embedding_space initial_point = [0.0, 0.0, 1.0] initial_tangent_vec_a = [1.0, 0.0, 0.0] initial_tangent_vec_b = [0.0, 1.0, 0.0] initial_tangent_vec_c = [-1.0, 0.0, 0.0] curve_fun_a = s2.metric.geodesic( initial_point=initial_point, initial_tangent_vec=initial_tangent_vec_a ) curve_fun_b = s2.metric.geodesic( initial_point=initial_point, initial_tangent_vec=initial_tangent_vec_b ) curve_fun_c = s2.metric.geodesic( initial_point=initial_point, initial_tangent_vec=initial_tangent_vec_c ) self.curve_fun_a = curve_fun_a self.n_sampling_points = 10 self.sampling_times = gs.linspace(0.0, 1.0, self.n_sampling_points) self.curve_a = curve_fun_a(self.sampling_times) self.curve_b = curve_fun_b(self.sampling_times) self.curve_c = curve_fun_c(self.sampling_times) self.space_curves_in_euclidean_3d = DiscreteCurves(ambient_manifold=r3) self.space_curves_in_sphere_2d = DiscreteCurves(ambient_manifold=s2) self.space_closed_curves_in_euclidean_2d = ClosedDiscreteCurves( ambient_manifold=r2 ) self.l2_metric_s2 = L2CurvesMetric(ambient_manifold=s2) self.l2_metric_r3 = L2CurvesMetric(ambient_manifold=r3) self.srv_metric_r3 = ( self.space_curves_in_euclidean_3d.square_root_velocity_metric ) self.quotient_srv_metric_r3 = ( self.space_curves_in_euclidean_3d.quotient_square_root_velocity_metric ) self.a = 1 self.b = 1 self.elastic_metric = ElasticMetric(self.a, self.b) self.n_discretized_curves = 5 self.times = gs.linspace(0.0, 1.0, self.n_discretized_curves) gs.random.seed(1234) def test_belongs(self): result = self.space_curves_in_sphere_2d.belongs(self.curve_a) self.assertTrue(result) curve_ab = [self.curve_a[:-1], self.curve_b] result = self.space_curves_in_sphere_2d.belongs(curve_ab) self.assertTrue(gs.all(result)) curve_ab = gs.array([self.curve_a, self.curve_b]) result = self.space_curves_in_sphere_2d.belongs(curve_ab) self.assertTrue(gs.all(result)) @geomstats.tests.np_autograd_and_torch_only def test_l2_metric_log_and_squared_norm_and_dist(self): """Test that squared norm of logarithm is squared dist.""" tangent_vec = self.l2_metric_s2.log(point=self.curve_b, base_point=self.curve_a) log_ab = tangent_vec result = self.l2_metric_s2.squared_norm(vector=log_ab, base_point=self.curve_a) expected = self.l2_metric_s2.dist(self.curve_a, self.curve_b) ** 2 self.assertAllClose(result, expected) def test_l2_metric_log_and_exp(self): """Test that exp and log are inverse maps.""" tangent_vec = self.l2_metric_s2.log(point=self.curve_b, base_point=self.curve_a) result = self.l2_metric_s2.exp(tangent_vec=tangent_vec, base_point=self.curve_a) expected = self.curve_b self.assertAllClose(result, expected) def test_l2_metric_inner_product_vectorization(self): """Test the vectorization inner_product.""" n_samples = self.n_discretized_curves curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b) curves_bc = self.l2_metric_s2.geodesic(self.curve_b, self.curve_c) curves_ab = curves_ab(self.times) curves_bc = curves_bc(self.times) tangent_vecs = self.l2_metric_s2.log(point=curves_bc, base_point=curves_ab) result = self.l2_metric_s2.inner_product(tangent_vecs, tangent_vecs, curves_ab) self.assertAllClose(gs.shape(result), (n_samples,)) def test_l2_metric_dist_vectorization(self): """Test the vectorization of dist.""" n_samples = self.n_discretized_curves curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b) curves_bc = self.l2_metric_s2.geodesic(self.curve_b, self.curve_c) curves_ab = curves_ab(self.times) curves_bc = curves_bc(self.times) result = self.l2_metric_s2.dist(curves_ab, curves_bc) self.assertAllClose(gs.shape(result), (n_samples,)) def test_l2_metric_exp_vectorization(self): """Test the vectorization of exp.""" curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b) curves_bc = self.l2_metric_s2.geodesic(self.curve_b, self.curve_c) curves_ab = curves_ab(self.times) curves_bc = curves_bc(self.times) tangent_vecs = self.l2_metric_s2.log(point=curves_bc, base_point=curves_ab) result = self.l2_metric_s2.exp(tangent_vec=tangent_vecs, base_point=curves_ab) self.assertAllClose(gs.shape(result), gs.shape(curves_ab)) def test_l2_metric_log_vectorization(self): """Test the vectorization of log.""" curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b) curves_bc = self.l2_metric_s2.geodesic(self.curve_b, self.curve_c) curves_ab = curves_ab(self.times) curves_bc = curves_bc(self.times) tangent_vecs = self.l2_metric_s2.log(point=curves_bc, base_point=curves_ab) result = tangent_vecs self.assertAllClose(gs.shape(result), gs.shape(curves_ab)) def test_l2_metric_geodesic(self): """Test the geodesic method of L2Metric.""" curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b) curves_ab = curves_ab(self.times) result = curves_ab expected = [] for k in range(self.n_sampling_points): geod = self.l2_metric_s2.ambient_metric.geodesic( initial_point=self.curve_a[k, :], end_point=self.curve_b[k, :] ) expected.append(geod(self.times)) expected = gs.stack(expected, axis=1) self.assertAllClose(result, expected) def test_srv_metric_pointwise_inner_products(self): curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b) curves_bc = self.l2_metric_s2.geodesic(self.curve_b, self.curve_c) curves_ab = curves_ab(self.times) curves_bc = curves_bc(self.times) tangent_vecs = self.l2_metric_s2.log(point=curves_bc, base_point=curves_ab) result = self.srv_metric_r3.l2_metric.pointwise_inner_products( tangent_vec_a=tangent_vecs, tangent_vec_b=tangent_vecs, base_curve=curves_ab ) expected_shape = (self.n_discretized_curves, self.n_sampling_points) self.assertAllClose(gs.shape(result), expected_shape) result = self.srv_metric_r3.l2_metric.pointwise_inner_products( tangent_vec_a=tangent_vecs[0], tangent_vec_b=tangent_vecs[0], base_curve=curves_ab[0], ) expected_shape = (self.n_sampling_points,) self.assertAllClose(gs.shape(result), expected_shape) def test_srv_transform_and_inverse(self): """Test of SRVT and its inverse. N.B: Here curves_ab are seen as curves in R3 and not S2. """ curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b) curves_ab = curves_ab(self.times) curves = curves_ab srv_curves = self.srv_metric_r3.srv_transform(curves) starting_points = curves[:, 0, :] result = self.srv_metric_r3.srv_transform_inverse(srv_curves, starting_points) expected = curves self.assertAllClose(result, expected) def test_srv_metric_exp_and_log(self): """Test that exp and log are inverse maps and vectorized. N.B: Here curves_ab and curves_bc are seen as curves in R3 and not S2. """ curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b) curves_bc = self.l2_metric_s2.geodesic(self.curve_b, self.curve_c) curves_ab = curves_ab(self.times) curves_bc = curves_bc(self.times) log = self.srv_metric_r3.log(point=curves_bc, base_point=curves_ab) result = self.srv_metric_r3.exp(tangent_vec=log, base_point=curves_ab) expected = curves_bc self.assertAllClose(gs.squeeze(result), expected) def test_srv_metric_geodesic(self): """Test that the geodesic between two curves in a Euclidean space. for the srv metric is the L2 geodesic betweeen the curves srvs. N.B: Here curve_a and curve_b are seen as curves in R3 and not S2. """ geod = self.srv_metric_r3.geodesic( initial_curve=self.curve_a, end_curve=self.curve_b ) result = geod(self.times) srv_a = self.srv_metric_r3.srv_transform(self.curve_a) srv_b = self.srv_metric_r3.srv_transform(self.curve_b) geod_srv = self.l2_metric_r3.geodesic(initial_point=srv_a, end_point=srv_b) geod_srv = geod_srv(self.times) starting_points = self.srv_metric_r3.ambient_metric.geodesic( initial_point=self.curve_a[0, :], end_point=self.curve_b[0, :] ) starting_points = starting_points(self.times) expected = self.srv_metric_r3.srv_transform_inverse(geod_srv, starting_points) self.assertAllClose(result, expected) def test_srv_metric_dist_and_geod(self): """Test that the length of the geodesic gives the distance. N.B: Here curve_a and curve_b are seen as curves in R3 and not S2. """ geod = self.srv_metric_r3.geodesic( initial_curve=self.curve_a, end_curve=self.curve_b ) geod = geod(self.times) srv = self.srv_metric_r3.srv_transform(geod) srv_derivative = self.n_discretized_curves * (srv[1:, :] - srv[:-1, :]) norms = self.srv_metric_r3.l2_metric.norm(srv_derivative) result = gs.sum(norms, 0) / self.n_discretized_curves expected = self.srv_metric_r3.dist(self.curve_a, self.curve_b) self.assertAllClose(result, expected) def test_random_and_belongs(self): random = self.space_curves_in_sphere_2d.random_point() result = self.space_curves_in_sphere_2d.belongs(random) self.assertTrue(result) self.assertAllClose(random.shape, (10, 3)) random = self.space_curves_in_sphere_2d.random_point(2) result = self.space_curves_in_sphere_2d.belongs(random) self.assertTrue(gs.all(result)) def test_is_tangent_to_tangent(self): point = self.space_curves_in_sphere_2d.random_point() vector = self.space_curves_in_sphere_2d.random_point() tangent_vec = self.space_curves_in_sphere_2d.to_tangent(vector, point) result = self.space_curves_in_sphere_2d.is_tangent(tangent_vec, point) self.assertTrue(result) point = self.space_curves_in_sphere_2d.random_point(2) vector = self.space_curves_in_sphere_2d.random_point(2) tangent_vec = self.space_curves_in_sphere_2d.to_tangent(vector, point) result = self.space_curves_in_sphere_2d.is_tangent(tangent_vec, point) self.assertTrue(gs.all(result)) @geomstats.tests.np_and_autograd_only def test_projection_closed_curves(self): """Test that projecting the projection returns projection. Also test that the projection is a closed curve. """ planar_closed_curves = self.space_closed_curves_in_euclidean_2d cells, _, _ = data_utils.load_cells() curves = [cell[:-10] for cell in cells[:5]] for curve in curves: proj = planar_closed_curves.project(curve) expected = proj result = planar_closed_curves.project(proj) self.assertAllClose(result, expected) result = proj[-1, :] expected = proj[0, :] self.assertAllClose(result, expected, rtol=10 * gs.rtol) def test_srv_inner_product(self): """Test that srv_inner_product works as expected. Also test that the resulting shape is right. """ curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b) curves_bc = self.l2_metric_s2.geodesic(self.curve_b, self.curve_c) curves_ab = curves_ab(self.times) curves_bc = curves_bc(self.times) srvs_ab = self.srv_metric_r3.srv_transform(curves_ab) srvs_bc = self.srv_metric_r3.srv_transform(curves_bc) result = self.srv_metric_r3.l2_metric.inner_product(srvs_ab, srvs_bc) products = srvs_ab * srvs_bc expected = [gs.sum(product) for product in products] expected = gs.array(expected) / (srvs_ab.shape[-2] + 1) self.assertAllClose(result, expected) result = result.shape expected = [srvs_ab.shape[0]] self.assertAllClose(result, expected) def test_srv_norm(self): """Test that srv_norm works as expected. Also test that the resulting shape is right. """ curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b) curves_ab = curves_ab(self.times) srvs_ab = self.srv_metric_r3.srv_transform(curves_ab) result = self.srv_metric_r3.l2_metric.norm(srvs_ab) products = srvs_ab * srvs_ab sums = [gs.sum(product) for product in products] squared_norm = gs.array(sums) / (srvs_ab.shape[-2] + 1) expected = gs.sqrt(squared_norm) self.assertAllClose(result, expected) result = result.shape expected = [srvs_ab.shape[0]] self.assertAllClose(result, expected) def test_f_transform(self): """Test that the f transform coincides with the SRVF. With the parameters: a=1, b=1/2. """ r2 = Euclidean(dim=2) elastic_metric = ElasticMetric(a=1.0, b=0.5) curves_r2 = DiscreteCurves(ambient_manifold=r2) curve_a_projected = gs.stack((self.curve_a[:, 0], self.curve_a[:, 2]), axis=-1) result = elastic_metric.f_transform(curve_a_projected) expected = gs.squeeze( curves_r2.square_root_velocity_metric.srv_transform(curve_a_projected) ) self.assertAllClose(result, expected) @geomstats.tests.np_autograd_and_tf_only def test_f_transform_and_inverse(self): """Test that the inverse is right.""" cells, _, _ = data_utils.load_cells() curve = cells[0] metric = self.elastic_metric f = metric.f_transform(curve) f_inverse = metric.f_transform_inverse(f, curve[0]) result = f.shape expected = (curve.shape[0] - 1, 2) self.assertAllClose(result, expected) result = f_inverse expected = curve self.assertAllClose(result, expected) @geomstats.tests.np_autograd_and_torch_only def test_elastic_dist(self): """Test shape and positivity.""" cells, _, _ = data_utils.load_cells() curve_1, curve_2 = cells[0][:10], cells[1][:10] metric = self.elastic_metric dist = metric.dist(curve_1, curve_2) result = dist.shape expected = () self.assertAllClose(result, expected) result = dist > 0 self.assertTrue(result) @geomstats.tests.np_autograd_and_torch_only def test_elastic_and_srv_dist(self): """Test that SRV dist and elastic dist coincide. For a=1 and b=1/2. """ r2 = Euclidean(dim=2) elastic_metric = ElasticMetric(a=1.0, b=0.5) curves_r2 = DiscreteCurves(ambient_manifold=r2) curve_a_projected = gs.stack((self.curve_a[:, 0], self.curve_a[:, 2]), axis=-1) curve_b_projected = gs.stack((self.curve_b[:, 0], self.curve_b[:, 2]), axis=-1) result = elastic_metric.dist(curve_a_projected, curve_b_projected) expected = curves_r2.square_root_velocity_metric.dist( curve_a_projected, curve_b_projected ) print(result / expected) self.assertAllClose(result, expected) def test_cartesian_to_polar_and_inverse(self): """Test that going back to cartesian works.""" cells, _, _ = data_utils.load_cells() curve = cells[0] metric = self.elastic_metric norms, args = metric.cartesian_to_polar(curve) result = metric.polar_to_cartesian(norms, args) expected = curve self.assertAllClose(result, expected, rtol=10000 * gs.rtol) @geomstats.tests.np_and_autograd_only def test_aux_differential_srv_transform(self): """Test differential of square root velocity transform. Check that its value at (curve, tangent_vec) coincides with the derivative at zero of the square root velocity transform of a path of curves starting at curve with initial derivative tangent_vec. """ dim = 3 n_sampling_points = 2000 sampling_times = gs.linspace(0.0, 1.0, n_sampling_points) curve_a = self.curve_fun_a(sampling_times) tangent_vec = gs.transpose( gs.tile(gs.linspace(1.0, 2.0, n_sampling_points), (dim, 1)) ) result = self.srv_metric_r3.aux_differential_srv_transform(tangent_vec, curve_a) n_curves = 2000 times = gs.linspace(0.0, 1.0, n_curves) path_of_curves = curve_a + gs.einsum("i,jk->ijk", times, tangent_vec) srv_path = self.srv_metric_r3.srv_transform(path_of_curves) expected = n_curves * (srv_path[1] - srv_path[0]) self.assertAllClose(result, expected, atol=1e-3, rtol=1e-3) @geomstats.tests.np_and_autograd_only def test_aux_differential_srv_transform_inverse(self): """Test inverse of differential of square root velocity transform. Check that it is the inverse of aux_differential_srv_transform. """ dim = 3 tangent_vec = gs.transpose( gs.tile(gs.linspace(0.0, 1.0, self.n_sampling_points), (dim, 1)) ) d_srv = self.srv_metric_r3.aux_differential_srv_transform( tangent_vec, self.curve_a ) result = self.srv_metric_r3.aux_differential_srv_transform_inverse( d_srv, self.curve_a ) expected = tangent_vec self.assertAllClose(result, expected, atol=1e-3, rtol=1e-3) def test_aux_differential_srv_transform_vectorization(self): """Test differential of square root velocity transform. Check vectorization. """ dim = 3 curves = gs.stack((self.curve_a, self.curve_b)) tangent_vecs = gs.random.rand(2, self.n_sampling_points, dim) result = self.srv_metric_r3.aux_differential_srv_transform(tangent_vecs, curves) res_a = self.srv_metric_r3.aux_differential_srv_transform( tangent_vecs[0], self.curve_a ) res_b = self.srv_metric_r3.aux_differential_srv_transform( tangent_vecs[1], self.curve_b ) expected = gs.stack([res_a, res_b]) self.assertAllClose(result, expected) def test_srv_inner_product_elastic(self): """Test inner product of SRVMetric. Check that the pullback metric gives an elastic metric with parameters a=1, b=1/2. """ tangent_vec_a = gs.random.rand(self.n_sampling_points, 3) tangent_vec_b = gs.random.rand(self.n_sampling_points, 3) result = self.srv_metric_r3.inner_product( tangent_vec_a, tangent_vec_b, self.curve_a ) r3 = Euclidean(3) d_vec_a = (self.n_sampling_points - 1) * ( tangent_vec_a[1:, :] - tangent_vec_a[:-1, :] ) d_vec_b = (self.n_sampling_points - 1) * ( tangent_vec_b[1:, :] - tangent_vec_b[:-1, :] ) velocity_vec = (self.n_sampling_points - 1) * ( self.curve_a[1:, :] - self.curve_a[:-1, :] ) velocity_norm = r3.metric.norm(velocity_vec) unit_velocity_vec = gs.einsum("ij,i->ij", velocity_vec, 1 / velocity_norm) a_param = 1 b_param = 1 / 2 integrand = ( a_param**2 * gs.sum(d_vec_a * d_vec_b, axis=1) - (a_param**2 - b_param**2) * gs.sum(d_vec_a * unit_velocity_vec, axis=1) * gs.sum(d_vec_b * unit_velocity_vec, axis=1) ) / velocity_norm expected = gs.sum(integrand) / self.n_sampling_points self.assertAllClose(result, expected) def test_srv_inner_product_and_dist(self): """Test that norm of log and dist coincide for curves with same / different starting points, and for the translation invariant / non invariant SRV metric. """ r3 = Euclidean(dim=3) curve_b_transl = self.curve_b + gs.array([1.0, 0.0, 0.0]) curve_b = [self.curve_b, curve_b_transl] translation_invariant = [True, False] for curve in curve_b: for param in translation_invariant: srv_metric = SRVMetric(ambient_manifold=r3, translation_invariant=param) log = srv_metric.log(point=curve, base_point=self.curve_a) result = srv_metric.norm(vector=log, base_point=self.curve_a) expected = srv_metric.dist(self.curve_a, curve) self.assertAllClose(result, expected) def test_srv_inner_product_vectorization(self): """Test inner product of SRVMetric. Check vectorization. """ dim = 3 curves = gs.stack((self.curve_a, self.curve_b)) tangent_vecs_1 = gs.random.rand(2, self.n_sampling_points, dim) tangent_vecs_2 = gs.random.rand(2, self.n_sampling_points, dim) result = self.srv_metric_r3.inner_product( tangent_vecs_1, tangent_vecs_2, curves ) res_a = self.srv_metric_r3.inner_product( tangent_vecs_1[0], tangent_vecs_2[0], self.curve_a ) res_b = self.srv_metric_r3.inner_product( tangent_vecs_1[1], tangent_vecs_2[1], self.curve_b ) expected = gs.stack((res_a, res_b)) self.assertAllClose(result, expected) @geomstats.tests.np_autograd_and_torch_only def test_split_horizontal_vertical(self): """Test split horizontal vertical. Check that horizontal and vertical parts of any tangent vector are othogonal with respect to the SRVMetric inner product, and check vectorization. """ geod = self.srv_metric_r3.geodesic( initial_curve=self.curve_a, end_curve=self.curve_b ) geod = geod(self.times) tangent_vec = self.n_discretized_curves * (geod[1, :, :] - geod[0, :, :]) ( tangent_vec_hor, tangent_vec_ver, _, ) = self.quotient_srv_metric_r3.split_horizontal_vertical( tangent_vec, self.curve_a ) result = self.srv_metric_r3.inner_product( tangent_vec_hor, tangent_vec_ver, self.curve_a ) expected = 0.0 self.assertAllClose(result, expected, atol=1e-4) tangent_vecs = self.n_discretized_curves * (geod[1:] - geod[:-1]) _, _, result = self.quotient_srv_metric_r3.split_horizontal_vertical( tangent_vecs, geod[:-1] ) expected = [] for i in range(self.n_discretized_curves - 1): _, _, res = self.quotient_srv_metric_r3.split_horizontal_vertical( tangent_vecs[i], geod[i] ) expected.append(res) expected = gs.stack(expected) self.assertAllClose(result, expected) def test_space_derivative(self): """Test space derivative. Check result on an example and vectorization. """ n_points = 3 dim = 3 curve = gs.random.rand(n_points, dim) result = self.srv_metric_r3.space_derivative(curve) delta = 1 / n_points d_curve_1 = (curve[1] - curve[0]) / delta d_curve_2 = (curve[2] - curve[0]) / (2 * delta) d_curve_3 = (curve[2] - curve[1]) / delta expected = gs.squeeze( gs.vstack( ( gs.to_ndarray(d_curve_1, 2), gs.to_ndarray(d_curve_2, 2), gs.to_ndarray(d_curve_3, 2), ) ) ) self.assertAllClose(result, expected) path_of_curves = gs.random.rand( self.n_discretized_curves, self.n_sampling_points, dim ) result = self.srv_metric_r3.space_derivative(path_of_curves) expected = [] for i in range(self.n_discretized_curves): expected.append(self.srv_metric_r3.space_derivative(path_of_curves[i])) expected = gs.stack(expected) self.assertAllClose(result, expected) @geomstats.tests.np_autograd_and_torch_only def test_horizontal_geodesic(self): """Test horizontal geodesic. Check that the time derivative of the geodesic is horizontal at all time. """ curve_b = gs.transpose( gs.stack( ( gs.zeros(self.n_sampling_points), gs.zeros(self.n_sampling_points), gs.linspace(1.0, 0.5, self.n_sampling_points), ) ) ) horizontal_geod_fun = self.quotient_srv_metric_r3.horizontal_geodesic( self.curve_a, curve_b ) n_times = 20 times = gs.linspace(0.0, 1.0, n_times) horizontal_geod = horizontal_geod_fun(times) velocity_vec = n_times * (horizontal_geod[1:] - horizontal_geod[:-1]) _, _, vertical_norms = self.quotient_srv_metric_r3.split_horizontal_vertical( velocity_vec, horizontal_geod[:-1] ) result = gs.sum(vertical_norms**2, axis=1) ** (1 / 2) expected = gs.zeros(n_times - 1) self.assertAllClose(result, expected, atol=1e-3) @geomstats.tests.np_autograd_and_torch_only def test_quotient_dist(self): """Test quotient distance. Check that the quotient distance is the same as the distance between the end points of the horizontal geodesic. """ curve_a_resampled = self.curve_fun_a(self.sampling_times**2) curve_b = gs.transpose( gs.stack( ( gs.zeros(self.n_sampling_points), gs.zeros(self.n_sampling_points), gs.linspace(1.0, 0.5, self.n_sampling_points), ) ) ) result = self.quotient_srv_metric_r3.dist(curve_a_resampled, curve_b) expected = self.quotient_srv_metric_r3.dist(self.curve_a, curve_b) self.assertAllClose(result, expected, atol=1e-3, rtol=1e-3)
class TestDiscreteCurves(geomstats.tests.TestCase): def setUp(self): s2 = Hypersphere(dim=2) r3 = s2.embedding_space initial_point = [0., 0., 1.] initial_tangent_vec_a = [1., 0., 0.] initial_tangent_vec_b = [0., 1., 0.] initial_tangent_vec_c = [-1., 0., 0.] curve_a = s2.metric.geodesic(initial_point=initial_point, initial_tangent_vec=initial_tangent_vec_a) curve_b = s2.metric.geodesic(initial_point=initial_point, initial_tangent_vec=initial_tangent_vec_b) curve_c = s2.metric.geodesic(initial_point=initial_point, initial_tangent_vec=initial_tangent_vec_c) self.n_sampling_points = 10 sampling_times = gs.linspace(0., 1., self.n_sampling_points) discretized_curve_a = curve_a(sampling_times) discretized_curve_b = curve_b(sampling_times) discretized_curve_c = curve_c(sampling_times) self.n_discretized_curves = 5 self.times = gs.linspace(0., 1., self.n_discretized_curves) gs.random.seed(1234) self.space_curves_in_euclidean_3d = DiscreteCurves(ambient_manifold=r3) self.space_curves_in_sphere_2d = DiscreteCurves(ambient_manifold=s2) self.l2_metric_s2 = self.space_curves_in_sphere_2d.l2_metric( self.n_sampling_points) self.l2_metric_r3 = self.space_curves_in_euclidean_3d.l2_metric( self.n_sampling_points) self.srv_metric_r3 = self.space_curves_in_euclidean_3d.\ square_root_velocity_metric self.curve_a = discretized_curve_a self.curve_b = discretized_curve_b self.curve_c = discretized_curve_c def test_belongs(self): result = self.space_curves_in_sphere_2d.belongs(self.curve_a) self.assertTrue(result) curve_ab = [self.curve_a[:-1], self.curve_b] result = self.space_curves_in_sphere_2d.belongs(curve_ab) self.assertTrue(gs.all(result)) curve_ab = gs.array([self.curve_a, self.curve_b]) result = self.space_curves_in_sphere_2d.belongs(curve_ab) self.assertTrue(gs.all(result)) def test_l2_metric_log_and_squared_norm_and_dist(self): """Test that squared norm of logarithm is squared dist.""" tangent_vec = self.l2_metric_s2.log(point=self.curve_b, base_point=self.curve_a) log_ab = tangent_vec result = self.l2_metric_s2.squared_norm(vector=log_ab, base_point=self.curve_a) expected = self.l2_metric_s2.dist(self.curve_a, self.curve_b)**2 self.assertAllClose(result, expected) def test_l2_metric_log_and_exp(self): """Test that exp and log are inverse maps.""" tangent_vec = self.l2_metric_s2.log(point=self.curve_b, base_point=self.curve_a) result = self.l2_metric_s2.exp(tangent_vec=tangent_vec, base_point=self.curve_a) expected = self.curve_b self.assertAllClose(result, expected) def test_l2_metric_inner_product_vectorization(self): """Test the vectorization inner_product.""" n_samples = self.n_discretized_curves curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b) curves_bc = self.l2_metric_s2.geodesic(self.curve_b, self.curve_c) curves_ab = curves_ab(self.times) curves_bc = curves_bc(self.times) tangent_vecs = self.l2_metric_s2.log(point=curves_bc, base_point=curves_ab) result = self.l2_metric_s2.inner_product(tangent_vecs, tangent_vecs, curves_ab) self.assertAllClose(gs.shape(result), (n_samples, )) def test_l2_metric_dist_vectorization(self): """Test the vectorization of dist.""" n_samples = self.n_discretized_curves curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b) curves_bc = self.l2_metric_s2.geodesic(self.curve_b, self.curve_c) curves_ab = curves_ab(self.times) curves_bc = curves_bc(self.times) result = self.l2_metric_s2.dist(curves_ab, curves_bc) self.assertAllClose(gs.shape(result), (n_samples, )) def test_l2_metric_exp_vectorization(self): """Test the vectorization of exp.""" curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b) curves_bc = self.l2_metric_s2.geodesic(self.curve_b, self.curve_c) curves_ab = curves_ab(self.times) curves_bc = curves_bc(self.times) tangent_vecs = self.l2_metric_s2.log(point=curves_bc, base_point=curves_ab) result = self.l2_metric_s2.exp(tangent_vec=tangent_vecs, base_point=curves_ab) self.assertAllClose(gs.shape(result), gs.shape(curves_ab)) def test_l2_metric_log_vectorization(self): """Test the vectorization of log.""" curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b) curves_bc = self.l2_metric_s2.geodesic(self.curve_b, self.curve_c) curves_ab = curves_ab(self.times) curves_bc = curves_bc(self.times) tangent_vecs = self.l2_metric_s2.log(point=curves_bc, base_point=curves_ab) result = tangent_vecs self.assertAllClose(gs.shape(result), gs.shape(curves_ab)) def test_l2_metric_geodesic(self): """Test the geodesic method of L2Metric.""" curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b) curves_ab = curves_ab(self.times) result = curves_ab expected = [] for k in range(self.n_sampling_points): geod = self.l2_metric_s2.ambient_metric.geodesic( initial_point=self.curve_a[k, :], end_point=self.curve_b[k, :]) expected.append(geod(self.times)) expected = gs.stack(expected, axis=1) self.assertAllClose(result, expected) def test_srv_metric_pointwise_inner_product(self): curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b) curves_bc = self.l2_metric_s2.geodesic(self.curve_b, self.curve_c) curves_ab = curves_ab(self.times) curves_bc = curves_bc(self.times) tangent_vecs = self.l2_metric_s2.log(point=curves_bc, base_point=curves_ab) result = self.srv_metric_r3.pointwise_inner_product( tangent_vec_a=tangent_vecs, tangent_vec_b=tangent_vecs, base_curve=curves_ab) expected_shape = (self.n_discretized_curves, self.n_sampling_points) self.assertAllClose(gs.shape(result), expected_shape) result = self.srv_metric_r3.pointwise_inner_product( tangent_vec_a=tangent_vecs[0], tangent_vec_b=tangent_vecs[0], base_curve=curves_ab[0]) expected_shape = (self.n_sampling_points, ) self.assertAllClose(gs.shape(result), expected_shape) def test_square_root_velocity_and_inverse(self): """Test of square_root_velocity and its inverse. N.B: Here curves_ab are seen as curves in R3 and not S2. """ curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b) curves_ab = curves_ab(self.times) curves = curves_ab srv_curves = self.srv_metric_r3.square_root_velocity(curves) starting_points = curves[:, 0, :] result = self.srv_metric_r3.square_root_velocity_inverse( srv_curves, starting_points) expected = curves self.assertAllClose(result, expected) def test_srv_metric_exp_and_log(self): """Test that exp and log are inverse maps and vectorized. N.B: Here curves_ab and curves_bc are seen as curves in R3 and not S2. """ curves_ab = self.l2_metric_s2.geodesic(self.curve_a, self.curve_b) curves_bc = self.l2_metric_s2.geodesic(self.curve_b, self.curve_c) curves_ab = curves_ab(self.times) curves_bc = curves_bc(self.times) log = self.srv_metric_r3.log(point=curves_bc, base_point=curves_ab) result = self.srv_metric_r3.exp(tangent_vec=log, base_point=curves_ab) expected = curves_bc self.assertAllClose(gs.squeeze(result), expected) def test_srv_metric_geodesic(self): """Test that the geodesic between two curves in a Euclidean space. for the srv metric is the L2 geodesic betweeen the curves srvs. N.B: Here curve_a and curve_b are seen as curves in R3 and not S2. """ geod = self.srv_metric_r3.geodesic(initial_curve=self.curve_a, end_curve=self.curve_b) result = geod(self.times) srv_a = self.srv_metric_r3.square_root_velocity(self.curve_a) srv_b = self.srv_metric_r3.square_root_velocity(self.curve_b) l2_metric = self.space_curves_in_euclidean_3d.l2_metric( self.n_sampling_points - 1) geod_srv = l2_metric.geodesic(initial_point=srv_a, end_point=srv_b) geod_srv = geod_srv(self.times) starting_points = self.srv_metric_r3.ambient_metric.geodesic( initial_point=self.curve_a[0, :], end_point=self.curve_b[0, :]) starting_points = starting_points(self.times) expected = self.srv_metric_r3.square_root_velocity_inverse( geod_srv, starting_points) self.assertAllClose(result, expected) def test_srv_metric_dist_and_geod(self): """Test that the length of the geodesic gives the distance. N.B: Here curve_a and curve_b are seen as curves in R3 and not S2. """ geod = self.srv_metric_r3.geodesic(initial_curve=self.curve_a, end_curve=self.curve_b) geod = geod(self.times) srv = self.srv_metric_r3.square_root_velocity(geod) srv_derivative = self.n_discretized_curves * (srv[1:, :] - srv[:-1, :]) l2_metric = self.space_curves_in_euclidean_3d.l2_metric( self.n_sampling_points - 1) norms = l2_metric.norm(srv_derivative, geod[:-1, :-1, :]) result = gs.sum(norms, 0) / self.n_discretized_curves expected = self.srv_metric_r3.dist(self.curve_a, self.curve_b)[0] self.assertAllClose(result, expected) def test_random_and_belongs(self): random = self.space_curves_in_sphere_2d.random_point() result = self.space_curves_in_sphere_2d.belongs(random) self.assertTrue(result) self.assertAllClose(random.shape, (10, 3)) random = self.space_curves_in_sphere_2d.random_point(2) result = self.space_curves_in_sphere_2d.belongs(random) self.assertTrue(gs.all(result)) def test_is_tangent_to_tangent(self): point = self.space_curves_in_sphere_2d.random_point() vector = self.space_curves_in_sphere_2d.random_point() tangent_vec = self.space_curves_in_sphere_2d.to_tangent(vector, point) result = self.space_curves_in_sphere_2d.is_tangent(tangent_vec, point) self.assertTrue(result) point = self.space_curves_in_sphere_2d.random_point(2) vector = self.space_curves_in_sphere_2d.random_point(2) tangent_vec = self.space_curves_in_sphere_2d.to_tangent(vector, point) result = self.space_curves_in_sphere_2d.is_tangent(tangent_vec, point) self.assertTrue(gs.all(result))