From a7f0473c5c31ae884faa664f97c97a3f9f6c1616 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mael=20Rouxel-Labb=C3=A9?= Date: Fri, 13 Mar 2020 13:24:03 +0100 Subject: [PATCH] Fix most of the tests (at least the compilation...) --- .../Optimal_bounding_box/bench_obb.cpp | 1 + .../Optimal_bounding_box/test_OBB_traits.cpp | 224 ++++++++------- .../Optimal_bounding_box/test_nelder_mead.cpp | 232 +++++++-------- .../test_optimization_algorithms.cpp | 267 ++++++------------ 4 files changed, 329 insertions(+), 395 deletions(-) diff --git a/Optimal_bounding_box/benchmarks/Optimal_bounding_box/bench_obb.cpp b/Optimal_bounding_box/benchmarks/Optimal_bounding_box/bench_obb.cpp index 5d843594140..b6d1e3a5d6a 100644 --- a/Optimal_bounding_box/benchmarks/Optimal_bounding_box/bench_obb.cpp +++ b/Optimal_bounding_box/benchmarks/Optimal_bounding_box/bench_obb.cpp @@ -48,6 +48,7 @@ void bench_finding_obb(const std::string fname) convex_hull_3(mesh, poly); timer.stop(); std::cout << "takes : " << timer.time() << " seconds to find the convex hull\n"; + std::cout << num_vertices(poly) << " vertices on the convex hull" << std::endl; // 2) using convex hull timer.reset(); diff --git a/Optimal_bounding_box/test/Optimal_bounding_box/test_OBB_traits.cpp b/Optimal_bounding_box/test/Optimal_bounding_box/test_OBB_traits.cpp index 41b0474ba07..c5362beb3cd 100644 --- a/Optimal_bounding_box/test/Optimal_bounding_box/test_OBB_traits.cpp +++ b/Optimal_bounding_box/test/Optimal_bounding_box/test_OBB_traits.cpp @@ -1,135 +1,141 @@ -#include -#include -#include +#include + +#include #include -bool assert_doubles(double d1, double d2, double epsilon) +#include +#include + +typedef CGAL::Exact_predicates_inexact_constructions_kernel K; +typedef K::FT FT; +typedef K::Point_3 Point_3; + +typedef CGAL::Oriented_bounding_box_traits_3 Traits; +typedef Traits::Matrix Matrix; + +void check_equality(const FT d1, const FT d2) { - return (d1 < d2 + epsilon && d1 > d2 - epsilon) ? true : false; + const FT epsilon = 1e-3; + + bool ok; + if(std::is_floating_point::value) + ok = CGAL::abs(d1 - d2) < epsilon * CGAL::abs(d2); + else + ok = (d1 == d2); + + if(!ok) + { + std::cout << "Error: got " << d1 << " but expected: " << d2 << std::endl; + assert(false); + } } void test_fitness_function() { - typedef typename CGAL::Eigen_linear_algebra_traits::MatrixXd MatrixXd; - MatrixXd data_points(4, 3); + std::array points; + points[0] = Point_3(0.866802, 0.740808, 0.895304); + points[1] = Point_3(0.912651, 0.761565, 0.160330); + points[2] = Point_3(0.093661, 0.892578, 0.737412); + points[3] = Point_3(0.166461, 0.149912, 0.364944); - data_points.set_coef(0, 0, 0.866802); - data_points.set_coef(0, 1, 0.740808); - data_points.set_coef(0, 2, 0.895304); + Matrix rotation; + rotation.set(0, 0, -0.809204); + rotation.set(0, 1, 0.124296); + rotation.set(0, 2, 0.574230); + rotation.set(1, 0, -0.574694); + rotation.set(1, 1, 0.035719); + rotation.set(1, 2, -0.817589); + rotation.set(2, 0, -0.122134); + rotation.set(2, 1, -0.991602); + rotation.set(2, 2, 0.042528); - data_points.set_coef(1, 0, 0.912651); - data_points.set_coef(1, 1, 0.761565); - data_points.set_coef(1, 2, 0.160330); - - data_points.set_coef(2, 0, 0.093661); - data_points.set_coef(2, 1, 0.892578); - data_points.set_coef(2, 2, 0.737412); - - data_points.set_coef(3, 0, 0.166461); - data_points.set_coef(3, 1, 0.149912); - data_points.set_coef(3, 2, 0.364944); - - typedef typename CGAL::Eigen_linear_algebra_traits::Matrix3d Matrix3d; - Matrix3d rotation; - rotation.set_coef(0, 0, -0.809204); - rotation.set_coef(0, 1, 0.124296); - rotation.set_coef(0, 2, 0.574230); - rotation.set_coef(1, 0, -0.574694); - rotation.set_coef(1, 1, 0.035719); - rotation.set_coef(1, 2, -0.817589); - rotation.set_coef(2, 0, -0.122134); - rotation.set_coef(2, 1, -0.991602); - rotation.set_coef(2, 2, 0.042528); - - CGAL_assertion_code(typedef CGAL::Eigen_linear_algebra_traits Linear_algebra_traits); - CGAL_assertion_code(double fitness = CGAL::Optimal_bounding_box:: - compute_fitness (rotation, data_points)); - CGAL_assertion(assert_doubles(fitness, 0.58606, 1e-5)); + const double fitness = CGAL::Optimal_bounding_box::internal::compute_fitness(rotation, points); + check_equality(fitness, 0.58606); } - - void test_eigen_matrix_interface() { - CGAL_assertion_code(typedef CGAL::Eigen_linear_algebra_traits Linear_algebra_traits); - typedef CGAL::Eigen_dense_matrix Matrix; + Matrix A; + A.set(0, 0, 0.1); + A.set(0, 1, 0.2); + A.set(0, 2, 0.3); + A.set(1, 0, 0.4); + A.set(1, 1, 0.5); + A.set(1, 2, 0.6); + A.set(2, 0, 0.7); + A.set(2, 1, 0.8); + A.set(2, 2, 0.9); - Matrix A(3, 3); - A.set_coef(0, 0, 0.1); - A.set_coef(0, 1, 0.2); - A.set_coef(0, 2, 0.3); - A.set_coef(1, 0, 0.4); - A.set_coef(1, 1, 0.5); - A.set_coef(1, 2, 0.6); - A.set_coef(2, 0, 0.7); - A.set_coef(2, 1, 0.8); - A.set_coef(2, 2, 0.9); - CGAL_assertion_code(Matrix B); - CGAL_assertion_code(B = CGAL::Eigen_linear_algebra_traits::transpose(A)); - CGAL_assertion_code(Matrix S); - CGAL_assertion_code(S = 0.5 * A); - Matrix C(3,3); - C.set_coef(0, 0, 0.3011944); - C.set_coef(0, 1, 0.9932761); - C.set_coef(0, 2, 0.5483701); - C.set_coef(1, 0, 0.5149142); - C.set_coef(1, 1, 0.5973263); - C.set_coef(1, 2, 0.5162336); - C.set_coef(2, 0, 0.0039213); - C.set_coef(2, 1, 0.0202949); - C.set_coef(2, 2, 0.9240308); + Matrix B; + B = CGAL::Optimal_bounding_box::internal::transpose(A); - CGAL_assertion_code(Matrix Q = CGAL::Eigen_linear_algebra_traits::get_Q(C)); - CGAL_assertion_code(double epsilon = 1e-5); - CGAL_assertion(assert_doubles(Q(0,0), -0.504895, epsilon)); - CGAL_assertion(assert_doubles(Q(0,1), 0.862834, epsilon)); - CGAL_assertion(assert_doubles(Q(0,2), -0.024447, epsilon)); - CGAL_assertion(assert_doubles(Q(1,0), -0.863156, epsilon)); - CGAL_assertion(assert_doubles(Q(1,1), -0.504894, epsilon)); - CGAL_assertion(assert_doubles(Q(1,2), 0.006687, epsilon)); - CGAL_assertion(assert_doubles(Q(2,0), -0.006573, epsilon)); - CGAL_assertion(assert_doubles(Q(2,1), 0.024478, epsilon)); - CGAL_assertion(assert_doubles(Q(2,2), 0.999679, epsilon)); + Matrix S; + S = 0.5 * A; - Matrix D(3,3); - D.set_coef(0, 0, -0.809204); - D.set_coef(0, 1, 0.124296); - D.set_coef(0, 2, 0.574230); - D.set_coef(1, 0, -0.574694); - D.set_coef(1, 1, 0.035719); - D.set_coef(1, 2, -0.817589); - D.set_coef(2, 0, -0.122134); - D.set_coef(2, 1, -0.991602); - D.set_coef(2, 2, 0.042528); + Matrix C; + C.set(0, 0, 0.3011944); + C.set(0, 1, 0.9932761); + C.set(0, 2, 0.5483701); + C.set(1, 0, 0.5149142); + C.set(1, 1, 0.5973263); + C.set(1, 2, 0.5162336); + C.set(2, 0, 0.0039213); + C.set(2, 1, 0.0202949); + C.set(2, 2, 0.9240308); - Matrix E(3,3); - E.set_coef(0, 0, -0.45070); - E.set_coef(0, 1, -0.32769); - E.set_coef(0, 2, -0.83035); - E.set_coef(1, 0, -0.13619); - E.set_coef(1, 1, -0.89406); - E.set_coef(1, 2, 0.42675); - E.set_coef(2, 0, -0.88222); - E.set_coef(2, 1, 0.30543); - E.set_coef(2, 2, 0.35833); + Matrix Q = Traits::get_Q(C); - CGAL_assertion_code(Matrix Sr = CGAL::Optimal_bounding_box::reflection(D, E)); - CGAL_assertion(assert_doubles(Sr(0,0), -0.13359, epsilon)); - CGAL_assertion(assert_doubles(Sr(0,1), -0.95986, epsilon)); - CGAL_assertion(assert_doubles(Sr(0,2), -0.24664, epsilon)); - CGAL_assertion(assert_doubles(Sr(1,0), -0.60307, epsilon)); - CGAL_assertion(assert_doubles(Sr(1,1), -0.11875, epsilon)); - CGAL_assertion(assert_doubles(Sr(1,2), 0.78880, epsilon)); - CGAL_assertion(assert_doubles(Sr(2,0), -0.78642, epsilon)); - CGAL_assertion(assert_doubles(Sr(2,1), 0.25411, epsilon)); - CGAL_assertion(assert_doubles(Sr(2,2), -0.56300, epsilon)); + check_equality(Q(0,0), -0.504895); + check_equality(Q(0,1), 0.862834); + check_equality(Q(0,2), -0.024447); + check_equality(Q(1,0), -0.863156); + check_equality(Q(1,1), -0.504894); + check_equality(Q(1,2), 0.006687); + check_equality(Q(2,0), -0.006573); + check_equality(Q(2,1), 0.024478); + check_equality(Q(2,2), 0.999679); + + Matrix D; + D.set(0, 0, -0.809204); + D.set(0, 1, 0.124296); + D.set(0, 2, 0.574230); + D.set(1, 0, -0.574694); + D.set(1, 1, 0.035719); + D.set(1, 2, -0.817589); + D.set(2, 0, -0.122134); + D.set(2, 1, -0.991602); + D.set(2, 2, 0.042528); + + Matrix E; + E.set(0, 0, -0.45070); + E.set(0, 1, -0.32769); + E.set(0, 2, -0.83035); + E.set(1, 0, -0.13619); + E.set(1, 1, -0.89406); + E.set(1, 2, 0.42675); + E.set(2, 0, -0.88222); + E.set(2, 1, 0.30543); + E.set(2, 2, 0.35833); + + Matrix Sr = CGAL::Optimal_bounding_box::internal::reflection(D, E); + check_equality(Sr(0,0), -0.13359); + check_equality(Sr(0,1), -0.95986); + check_equality(Sr(0,2), -0.24664); + check_equality(Sr(1,0), -0.60307); + check_equality(Sr(1,1), -0.11875); + check_equality(Sr(1,2), 0.78880); + check_equality(Sr(2,0), -0.78642); + check_equality(Sr(2,1), 0.25411); + check_equality(Sr(2,2), -0.56300); } -int main() +int main(int, char**) { test_fitness_function(); test_eigen_matrix_interface(); - return 0; + std::cout << "Done!" << std::endl; + + return EXIT_SUCCESS; } diff --git a/Optimal_bounding_box/test/Optimal_bounding_box/test_nelder_mead.cpp b/Optimal_bounding_box/test/Optimal_bounding_box/test_nelder_mead.cpp index a84cb83b5ea..b1a4587f3be 100644 --- a/Optimal_bounding_box/test/Optimal_bounding_box/test_nelder_mead.cpp +++ b/Optimal_bounding_box/test/Optimal_bounding_box/test_nelder_mead.cpp @@ -5,106 +5,115 @@ #include typedef CGAL::Exact_predicates_inexact_constructions_kernel K; +typedef K::FT FT; typedef K::Point_3 Point_3; typedef CGAL::Oriented_bounding_box_traits_3 Traits; typedef Traits::Matrix Matrix; -bool are_equal(double d1, double d2, double epsilon) +void check_equality(const FT d1, const FT d2) { - return (d1 < d2 + epsilon && d1 > d2 - epsilon) ? true : false; + const FT epsilon = 1e-3; + + bool ok; + if(std::is_floating_point::value) + ok = CGAL::abs(d1 - d2) < epsilon * CGAL::abs(d2); + else + ok = (d1 == d2); + + if(!ok) + { + std::cout << "Error: got " << d1 << " but expected: " << d2 << std::endl; + assert(false); + } } -void test_simplex_operations() +void test_simplex_operations(const Traits& traits) { - const double epsilon = 1e-5; - - Matrix Sc(3, 3); + Matrix Sc; Sc.set(0, 0, -0.809204); Sc.set(0, 1, 0.124296); Sc.set(0, 2, 0.574230); Sc.set(1, 0, -0.574694); Sc.set(1, 1, 0.035719); Sc.set(1, 2, -0.817589); Sc.set(2, 0, -0.122134); Sc.set(2, 1, -0.991602); Sc.set(2, 2, 0.042528); - Matrix S_worst(3, 3); + Matrix S_worst; S_worst.set(0, 0, -0.45070); S_worst.set(0, 1, -0.32769); S_worst.set(0, 2, -0.83035); S_worst.set(1, 0, -0.13619); S_worst.set(1, 1, -0.89406); S_worst.set(1, 2, 0.42675); S_worst.set(2, 0, -0.88222); S_worst.set(2, 1, 0.30543); S_worst.set(2, 2, 0.35833); - Matrix Sr = CGAL::Optimal_bounding_box::reflection(Sc, S_worst); - assert(are_equal(Sr(0,0), -0.13359, epsilon)); - assert(are_equal(Sr(0,1), -0.95986, epsilon)); - assert(are_equal(Sr(0,2), -0.24664, epsilon)); - assert(are_equal(Sr(1,0), -0.60307, epsilon)); - assert(are_equal(Sr(1,1), -0.11875, epsilon)); - assert(are_equal(Sr(1,2), 0.78880, epsilon)); - assert(are_equal(Sr(2,0), -0.78642, epsilon)); - assert(are_equal(Sr(2,1), 0.25411, epsilon)); - assert(are_equal(Sr(2,2), -0.56300, epsilon)); + Matrix Sr = CGAL::Optimal_bounding_box::internal::reflection(Sc, S_worst); + check_equality(Sr(0,0), -0.13359); + check_equality(Sr(0,1), -0.95986); + check_equality(Sr(0,2), -0.24664); + check_equality(Sr(1,0), -0.60307); + check_equality(Sr(1,1), -0.11875); + check_equality(Sr(1,2), 0.78880); + check_equality(Sr(2,0), -0.78642); + check_equality(Sr(2,1), 0.25411); + check_equality(Sr(2,2), -0.56300); - Matrix Se = CGAL::Optimal_bounding_box::expansion(Sc, S_worst, Sr); - assert(are_equal(Se(0,0), -0.87991, epsilon)); - assert(are_equal(Se(0,1), 0.36105, epsilon)); - assert(are_equal(Se(0,2), -0.30888, epsilon)); - assert(are_equal(Se(1,0), -0.11816, epsilon)); - assert(are_equal(Se(1,1), -0.79593, epsilon)); - assert(are_equal(Se(1,2), -0.59375, epsilon)); - assert(are_equal(Se(2,0), -0.460215, epsilon)); - assert(are_equal(Se(2,1), -0.48595, epsilon)); - assert(are_equal(Se(2,2), 0.74300, epsilon)); + Matrix Se = CGAL::Optimal_bounding_box::internal::expansion(Sc, S_worst, Sr); + check_equality(Se(0,0), -0.87991); + check_equality(Se(0,1), 0.36105); + check_equality(Se(0,2), -0.30888); + check_equality(Se(1,0), -0.11816); + check_equality(Se(1,1), -0.79593); + check_equality(Se(1,2), -0.59375); + check_equality(Se(2,0), -0.460215); + check_equality(Se(2,1), -0.48595); + check_equality(Se(2,2), 0.74300); - Matrix S_a(3, 3); + Matrix S_a; S_a.set(0, 0, -0.277970); S_a.set(0, 1, 0.953559); S_a.set(0, 2, 0.116010); S_a.set(1, 0, -0.567497); S_a.set(1, 1, -0.065576); S_a.set(1, 2, -0.820760); S_a.set(2, 0, -0.775035); S_a.set(2, 1, -0.293982); S_a.set(2, 2, 0.559370); - Matrix S_b(3, 3); + Matrix S_b; S_b.set(0, 0, -0.419979); S_b.set(0, 1, 0.301765); S_b.set(0, 2, -0.8558940); S_b.set(1, 0, -0.653011); S_b.set(1, 1, -0.755415); S_b.set(1, 2, 0.054087); S_b.set(2, 0, -0.630234); S_b.set(2, 1, 0.581624); S_b.set(2, 2, 0.514314); - Matrix S_c = CGAL::Optimal_bounding_box::mean(S_a, S_b); - assert(are_equal(S_c(0,0), -0.35111, epsilon)); - assert(are_equal(S_c(0,1), 0.79308, epsilon)); - assert(are_equal(S_c(0,2), -0.49774, epsilon)); - assert(are_equal(S_c(1,0), -0.61398, epsilon)); - assert(are_equal(S_c(1,1), -0.59635, epsilon)); - assert(are_equal(S_c(1,2), -0.51710, epsilon)); - assert(are_equal(S_c(2,0), -0.70693, epsilon)); - assert(are_equal(S_c(2,1), 0.12405, epsilon)); - assert(are_equal(S_c(2,2), 0.69632, epsilon)); + Matrix S_c = CGAL::Optimal_bounding_box::internal::mean(S_a, S_b, traits); + check_equality(S_c(0,0), -0.35111); + check_equality(S_c(0,1), 0.79308); + check_equality(S_c(0,2), -0.49774); + check_equality(S_c(1,0), -0.61398); + check_equality(S_c(1,1), -0.59635); + check_equality(S_c(1,2), -0.51710); + check_equality(S_c(2,0), -0.70693); + check_equality(S_c(2,1), 0.12405); + check_equality(S_c(2,2), 0.69632); } -void test_centroid() +void test_centroid(const Traits& traits) { - const double epsilon = 1e-5; - Matrix S_a; S_a.set(0, 0, -0.588443); S_a.set(0, 1, 0.807140); S_a.set(0, 2, -0.047542); S_a.set(1, 0, -0.786228); S_a.set(1, 1, -0.584933); S_a.set(1, 2, -0.199246); S_a.set(2, 0, -0.188629); S_a.set(2, 1, -0.079867); S_a.set(2, 2, 0.978795); - Matrix S_b(3, 3); + Matrix S_b; S_b.set(0, 0, -0.2192721); S_b.set(0, 1, 0.2792986); S_b.set(0, 2, -0.9348326); S_b.set(1, 0, -0.7772152); S_b.set(1, 1, -0.6292092); S_b.set(1, 2, -0.005686); S_b.set(2, 0, -0.5897934); S_b.set(2, 1, 0.7253193); S_b.set(2, 2, 0.3550431); - Matrix S_c(3, 3); + Matrix S_c; S_c.set(0, 0, -0.32657); S_c.set(0, 1, -0.60013); S_c.set(0, 2, -0.730206); S_c.set(1, 0, -0.20022); S_c.set(1, 1, -0.71110); S_c.set(1, 2, 0.67398); S_c.set(2, 0, -0.92372); S_c.set(2, 1, 0.36630); S_c.set(2, 2, 0.11207); - Matrix S_centroid = CGAL::Optimal_bounding_box::nm_centroid(S_a, S_b, S_c); - assert(are_equal(S_centroid(0,0), -0.419979, epsilon)); - assert(are_equal(S_centroid(0,1), 0.301765, epsilon)); - assert(are_equal(S_centroid(0,2), -0.855894, epsilon)); - assert(are_equal(S_centroid(1,0), -0.653011, epsilon)); - assert(are_equal(S_centroid(1,1), -0.755415, epsilon)); - assert(are_equal(S_centroid(1,2), 0.054087, epsilon)); - assert(are_equal(S_centroid(2,0), -0.630234, epsilon)); - assert(are_equal(S_centroid(2,1), 0.581624, epsilon)); - assert(are_equal(S_centroid(2,2), 0.514314, epsilon)); + Matrix S_centroid = CGAL::Optimal_bounding_box::internal::nm_centroid(S_a, S_b, S_c, traits); + check_equality(S_centroid(0,0), -0.419979); + check_equality(S_centroid(0,1), 0.301765); + check_equality(S_centroid(0,2), -0.855894); + check_equality(S_centroid(1,0), -0.653011); + check_equality(S_centroid(1,1), -0.755415); + check_equality(S_centroid(1,2), 0.054087); + check_equality(S_centroid(2,0), -0.630234); + check_equality(S_centroid(2,1), 0.581624); + check_equality(S_centroid(2,2), 0.514314); } -void test_nelder_mead() +void test_nelder_mead(const Traits& traits) { std::array points; points[0] = Point_3(0.866802, 0.740808, 0.895304); @@ -116,21 +125,21 @@ void test_nelder_mead() std::array simplex; Matrix v0, v1, v2, v3; - v0(0,0) = -0.2192721; v0(0,1) = 0.2792986; v0(0,2) = -0.9348326; - v0(1,0) = -0.7772152; v0(1,1) = -0.6292092; v0(1,2) = -0.0056861; - v0(2,0) = -0.5897934; v0(2,1) = 0.7253193; v0(2,2) = 0.3550431; + v0.set(0, 0, -0.2192721); v0.set(0, 1, 0.2792986); v0.set(0, 2, -0.9348326); + v0.set(1, 0, -0.7772152); v0.set(1, 1, -0.6292092); v0.set(1, 2, -0.0056861); + v0.set(2, 0, -0.5897934); v0.set(2, 1, 0.7253193); v0.set(2, 2, 0.3550431); - v1(0,0) = -0.588443; v1(0,1) = 0.807140; v1(0,2) = -0.047542; - v1(1,0) = -0.786228; v1(1,1) = -0.584933; v1(1,2) = -0.199246; - v1(2,0) = -0.188629; v1(2,1) = -0.079867; v1(2,2) = 0.978795; + v1.set(0, 0, -0.588443); v1.set(0, 1, 0.807140); v1.set(0, 2, -0.047542); + v1.set(1, 0, -0.786228); v1.set(1, 1, -0.584933); v1.set(1, 2, -0.199246); + v1.set(2, 0, -0.188629); v1.set(2, 1, -0.079867); v1.set(2, 2, 0.978795); - v2(0,0) = -0.277970; v2(0,1) = 0.953559; v2(0,2) = 0.116010; - v2(1,0) = -0.567497; v2(1,1) = -0.065576; v2(1,2) = -0.820760; - v2(2,0) = -0.775035; v2(2,1) = -0.293982; v2(2,2) = 0.559370; + v2.set(0, 0, -0.277970); v2.set(0, 1, 0.953559); v2.set(0, 2, 0.116010); + v2.set(1, 0, -0.567497); v2.set(1, 1, -0.065576); v2.set(1, 2, -0.820760); + v2.set(2, 0, -0.775035); v2.set(2, 1, -0.293982); v2.set(2, 2, 0.559370); - v3(0,0) = -0.32657; v3(0,1) = -0.60013; v3(0,2) = -0.73020; - v3(1,0) = -0.20022; v3(1,1) = -0.71110; v3(1,2) = 0.67398; - v3(2,0) = -0.92372; v3(2,1) = 0.36630; v3(2,2) = 0.11207; + v3.set(0, 0, -0.32657); v3.set(0, 1, -0.60013); v3.set(0, 2, -0.73020); + v3.set(1, 0, -0.20022); v3.set(1, 1, -0.71110); v3.set(1, 2, 0.67398); + v3.set(2, 0, -0.92372); v3.set(2, 1, 0.36630); v3.set(2, 2, 0.11207); simplex[0] = v0; simplex[1] = v1; @@ -138,59 +147,62 @@ void test_nelder_mead() simplex[3] = v3; std::size_t nm_iterations = 19; - CGAL::Optimal_bounding_box::internal::nelder_mead(simplex, data_points, nm_iterations); + CGAL::Optimal_bounding_box::internal::nelder_mead(points, nm_iterations, traits, simplex); - double epsilon = 1e-5; const Matrix& v0_new = simplex[0]; - assert(assert_doubles(v0_new(0,0), -0.288975, epsilon)); - assert(assert_doubles(v0_new(0,1), 0.7897657, epsilon)); - assert(assert_doubles(v0_new(0,2), -0.541076, epsilon)); - assert(assert_doubles(v0_new(1,0), -0.9407046, epsilon)); - assert(assert_doubles(v0_new(1,1), -0.3391466, epsilon)); - assert(assert_doubles(v0_new(1,2), 0.0073817, epsilon)); - assert(assert_doubles(v0_new(2,0), -0.1776743, epsilon)); - assert(assert_doubles(v0_new(2,1), 0.5111260, epsilon)); - assert(assert_doubles(v0_new(2,2), 0.84094, epsilon)); + check_equality(v0_new(0,0), -0.288975); + check_equality(v0_new(0,1), 0.7897657); + check_equality(v0_new(0,2), -0.541076); + check_equality(v0_new(1,0), -0.9407046); + check_equality(v0_new(1,1), -0.3391466); + check_equality(v0_new(1,2), 0.0073817); + check_equality(v0_new(2,0), -0.1776743); + check_equality(v0_new(2,1), 0.5111260); + check_equality(v0_new(2,2), 0.84094); const Matrix& v1_new = simplex[1]; - assert(assert_doubles(v1_new(0,0), -0.458749, epsilon)); - assert(assert_doubles(v1_new(0,1), 0.823283, epsilon)); - assert(assert_doubles(v1_new(0,2), -0.334296, epsilon)); - assert(assert_doubles(v1_new(1,0), -0.885235, epsilon)); - assert(assert_doubles(v1_new(1,1), -0.455997, epsilon)); - assert(assert_doubles(v1_new(1,2), 0.091794, epsilon)); - assert(assert_doubles(v1_new(2,0), -0.076866, epsilon)); - assert(assert_doubles(v1_new(2,1), 0.338040, epsilon)); - assert(assert_doubles(v1_new(2,2), 0.937987, epsilon)); + check_equality(v1_new(0,0), -0.458749); + check_equality(v1_new(0,1), 0.823283); + check_equality(v1_new(0,2), -0.334296); + check_equality(v1_new(1,0), -0.885235); + check_equality(v1_new(1,1), -0.455997); + check_equality(v1_new(1,2), 0.091794); + check_equality(v1_new(2,0), -0.076866); + check_equality(v1_new(2,1), 0.338040); + check_equality(v1_new(2,2), 0.937987); const Matrix& v2_new = simplex[2]; - assert(assert_doubles(v2_new(0,0), -0.346582, epsilon)); - assert(assert_doubles(v2_new(0,1), 0.878534, epsilon)); - assert(assert_doubles(v2_new(0,2), -0.328724, epsilon)); - assert(assert_doubles(v2_new(1,0), -0.936885, epsilon)); - assert(assert_doubles(v2_new(1,1), -0.341445, epsilon)); - assert(assert_doubles(v2_new(1,2), 0.075251, epsilon)); - assert(assert_doubles(v2_new(2,0), -0.046131, epsilon)); - assert(assert_doubles(v2_new(2,1), 0.334057, epsilon)); - assert(assert_doubles(v2_new(2,2), 0.941423, epsilon)); + check_equality(v2_new(0,0), -0.346582); + check_equality(v2_new(0,1), 0.878534); + check_equality(v2_new(0,2), -0.328724); + check_equality(v2_new(1,0), -0.936885); + check_equality(v2_new(1,1), -0.341445); + check_equality(v2_new(1,2), 0.075251); + check_equality(v2_new(2,0), -0.046131); + check_equality(v2_new(2,1), 0.334057); + check_equality(v2_new(2,2), 0.941423); const Matrix& v3_new = simplex[3]; - assert(assert_doubles(v3_new(0,0), -0.394713, epsilon)); - assert(assert_doubles(v3_new(0,1), 0.791782, epsilon)); - assert(assert_doubles(v3_new(0,2), -0.466136, epsilon)); - assert(assert_doubles(v3_new(1,0), -0.912112, epsilon)); - assert(assert_doubles(v3_new(1,1), -0.398788, epsilon)); - assert(assert_doubles(v3_new(1,2), 0.094972, epsilon)); - assert(assert_doubles(v3_new(2,0), -0.110692, epsilon)); - assert(assert_doubles(v3_new(2,1), 0.462655, epsilon)); - assert(assert_doubles(v3_new(2,2), 0.879601, epsilon)); + check_equality(v3_new(0,0), -0.394713); + check_equality(v3_new(0,1), 0.791782); + check_equality(v3_new(0,2), -0.466136); + check_equality(v3_new(1,0), -0.912112); + check_equality(v3_new(1,1), -0.398788); + check_equality(v3_new(1,2), 0.094972); + check_equality(v3_new(2,0), -0.110692); + check_equality(v3_new(2,1), 0.462655); + check_equality(v3_new(2,2), 0.879601); } -int main() +int main(int, char**) { - test_simplex_operations(); - test_centroid(); - test_nelder_mead(); + Traits traits; - return 0; + test_simplex_operations(traits); + test_centroid(traits); + test_nelder_mead(traits); + + std::cout << "Done!" << std::endl; + + return EXIT_SUCCESS; } diff --git a/Optimal_bounding_box/test/Optimal_bounding_box/test_optimization_algorithms.cpp b/Optimal_bounding_box/test/Optimal_bounding_box/test_optimization_algorithms.cpp index 6dbbec359b0..1dbdc081967 100644 --- a/Optimal_bounding_box/test/Optimal_bounding_box/test_optimization_algorithms.cpp +++ b/Optimal_bounding_box/test/Optimal_bounding_box/test_optimization_algorithms.cpp @@ -2,75 +2,62 @@ #include -#include -#include -#include -#include -#include +#include +#include #include #include -typedef CGAL::Exact_predicates_inexact_constructions_kernel K; +typedef CGAL::Exact_predicates_inexact_constructions_kernel K; +typedef K::FT FT; +typedef K::Point_3 Point_3; -bool assert_doubles(double d1, double d2, double epsilon) +typedef CGAL::Surface_mesh Mesh; + +typedef CGAL::Oriented_bounding_box_traits_3 Traits; +typedef Traits::Matrix Matrix; + +void check_equality(const FT d1, const FT d2) { - return (d1 < d2 + epsilon && d1 > d2 - epsilon) ? true : false; + const FT epsilon = 1e-3; + + bool ok; + if(std::is_floating_point::value) + ok = CGAL::abs(d1 - d2) < epsilon * CGAL::abs(d2); + else + ok = (d1 == d2); + + if(!ok) + { + std::cout << "Error: got " << d1 << " but expected: " << d2 << std::endl; + assert(false); + } } void test_genetic_algorithm() { - CGAL::Eigen_dense_matrix data_points(4, 3); // -1 = dynamic size at run time - data_points(0,0) = 0.866802; - data_points(0,1) = 0.740808; - data_points(0,2) = 0.895304; - data_points(1,0) = 0.912651; - data_points(1,1) = 0.761565; - data_points(1,2) = 0.160330; - data_points(2,0) = 0.093661; - data_points(2,1) = 0.892578; - data_points(2,2) = 0.737412; - data_points(3,0) = 0.166461; - data_points(3,1) = 0.149912; - data_points(3,2) = 0.364944; + std::array points; + points[0] = Point_3(0.866802, 0.740808, 0.895304); + points[1] = Point_3(0.912651, 0.761565, 0.160330); + points[2] = Point_3(0.093661, 0.892578, 0.737412); + points[3] = Point_3(0.166461, 0.149912, 0.364944); - typedef CGAL::Eigen_linear_algebra_traits Linear_algebra_traits; - CGAL::Optimal_bounding_box::Population pop(5); - CGAL::Optimal_bounding_box::Evolution evolution(pop, data_points); + CGAL::Optimal_bounding_box::internal::Population pop(5); + CGAL::Optimal_bounding_box::internal::Evolution evolution(pop, data_points); evolution.genetic_algorithm(); assert(pop.size() == 5); } void test_random_unit_tetra() { - // this is dynamic at run times - CGAL::Eigen_dense_matrix data_points(4, 3); + std::array points; + points[0] = Point_3(0.866802, 0.740808, 0.895304); + points[1] = Point_3(0.912651, 0.761565, 0.160330); + points[2] = Point_3(0.093661, 0.892578, 0.737412); + points[3] = Point_3(0.166461, 0.149912, 0.364944); - // points are on their convex hull - data_points(0,0) = 0.866802; - data_points(0,1) = 0.740808; - data_points(0,2) = 0.895304; - data_points(1,0) = 0.912651; - data_points(1,1) = 0.761565; - data_points(1,2) = 0.160330; - data_points(2,0) = 0.093661; - data_points(2,1) = 0.892578; - data_points(2,2) = 0.737412; - data_points(3,0) = 0.166461; - data_points(3,1) = 0.149912; - data_points(3,2) = 0.364944; - - typedef CGAL::Simple_cartesian K; - typedef K::Point_3 Point; - typedef CGAL::Surface_mesh Mesh; - - // make a mesh and export it Mesh mesh; - Point p1(0.866802, 0.740808, 0.895304); - Point p2(0.912651, 0.761565, 0.160330); - Point p3(0.093661, 0.892578, 0.737412); - Point p4(0.166461, 0.149912, 0.364944); - CGAL::make_tetrahedron(p1, p2, p3, p4, mesh); + CGAL::make_tetrahedron(points[0], points[1], points[2], points[3], mesh); #ifdef CGAL_OPTIMAL_BOUNDING_BOX_DEBUG_TEST std::ofstream out("data/random_unit_tetra.off"); @@ -78,148 +65,102 @@ void test_random_unit_tetra() out.close(); #endif - typedef CGAL::Eigen_linear_algebra_traits Linear_algebra_traits; - typedef Linear_algebra_traits::Matrix Matrix; - std::size_t generations = 10; - CGAL::Optimal_bounding_box::Population pop(50); - CGAL::Optimal_bounding_box::Evolution evolution(pop, data_points); + CGAL::Optimal_bounding_box::internal::Population pop(50); + CGAL::Optimal_bounding_box::internal::Evolution evolution(pop, data_points); evolution.evolve(generations); Matrix R = evolution.get_best(); - const double epsilon = 1e-3; - assert(assert_doubles(Linear_algebra_traits::compute_determinant(R), 1, epsilon)); - assert(assert_doubles(R(0,0), -0.25791, epsilon)); - assert(assert_doubles(R(0,1), 0.796512, epsilon)); - assert(assert_doubles(R(0,2), -0.546855, epsilon)); - assert(assert_doubles(R(1,0), -0.947128, epsilon)); - assert(assert_doubles(R(1,1), -0.320242, epsilon)); - assert(assert_doubles(R(1,2), -0.0197553, epsilon)); - assert(assert_doubles(R(2,0), -0.190861, epsilon)); - assert(assert_doubles(R(2,1), 0.512847, epsilon)); - assert(assert_doubles(R(2,2), 0.836992, epsilon)); - -#ifdef CGAL_OPTIMAL_BOUNDING_BOX_DEBUG_TEST - // postprocessing - CGAL::Eigen_dense_matrix obb(8, 3); - CGAL::Optimal_bounding_box::post_processing(data_points, R, obb); -#endif + check_equality(Traits::compute_determinant(R), 1); + check_equality(R(0,0), -0.25791); + check_equality(R(0,1), 0.796512); + check_equality(R(0,2), -0.546855); + check_equality(R(1,0), -0.947128); + check_equality(R(1,1), -0.320242); + check_equality(R(1,2), -0.0197553); + check_equality(R(2,0), -0.190861); + check_equality(R(2,1), 0.512847); + check_equality(R(2,2), 0.836992); } void test_reference_tetrahedron(const char* fname) { std::ifstream input(fname); - CGAL::Surface_mesh mesh; - if (!input || !(input >> mesh) || mesh.is_empty()) { + CGAL::Surface_mesh mesh; + if(!input || !(input >> mesh) || mesh.is_empty()) + { std::cerr << fname << " is not a valid off file.\n"; std::exit(1); } - typedef CGAL::Eigen_linear_algebra_traits Linear_algebra_traits; - typedef Linear_algebra_traits::Matrix Matrix; - // points in a matrix Matrix points; CGAL::Optimal_bounding_box::sm_to_matrix(mesh, points); std::size_t generations = 10; - CGAL::Optimal_bounding_box::Population pop(50); - CGAL::Optimal_bounding_box::Evolution experiment(pop, points); + CGAL::Optimal_bounding_box::internal::Population pop(50); + CGAL::Optimal_bounding_box::internal::Evolution experiment(pop, points); experiment.evolve(generations); Matrix R = experiment.get_best(); - double epsilon = 1e-5; - assert(assert_doubles(Linear_algebra_traits::compute_determinant(R), 1, epsilon)); - -#ifdef CGAL_OPTIMAL_BOUNDING_BOX_DEBUG_TEST - // postprocessing - Matrix obb(8, 3); - CGAL::Optimal_bounding_box::post_processing(points, R, obb); -#endif + check_equality(Traits::compute_determinant(R), 1); } void test_long_tetrahedron(const std::string fname) { std::ifstream input(fname); - CGAL::Surface_mesh mesh; - if (!input || !(input >> mesh) || mesh.is_empty()) + CGAL::Surface_mesh mesh; + if(!input || !(input >> mesh) || mesh.is_empty()) { std::cerr << fname << " is not a valid off file.\n"; std::exit(1); } - typedef CGAL::Eigen_linear_algebra_traits Linear_algebra_traits; - typedef Linear_algebra_traits::Matrix Matrix; - // points in a matrix Matrix points; CGAL::Optimal_bounding_box::sm_to_matrix(mesh, points); std::size_t max_generations = 10; - CGAL::Optimal_bounding_box::Population pop(50); - CGAL::Optimal_bounding_box::Evolution experiment(pop, points); + CGAL::Optimal_bounding_box::internal::Population pop(50); + CGAL::Optimal_bounding_box::internal::Evolution experiment(pop, points); experiment.evolve(max_generations); Matrix R = experiment.get_best(); - double epsilon = 1e-3; - assert(assert_doubles(Linear_algebra_traits::compute_determinant(R), 1, epsilon)); - assert(assert_doubles(R(0,0), -1, epsilon)); - assert(assert_doubles(R(0,1), 0, epsilon)); - assert(assert_doubles(R(0,2), 0, epsilon)); - assert(assert_doubles(R(1,0), 0, epsilon)); - assert(assert_doubles(R(1,1), -0.707107, epsilon)); - assert(assert_doubles(R(1,2), 0.707106, epsilon) || - assert_doubles(R(1,2), -0.707106, epsilon)); - assert(assert_doubles(R(2,0), 0, epsilon)); - assert(assert_doubles(R(2,1), 0.707106, epsilon) || - assert_doubles(R(1,2), -0.707106, epsilon)); - assert(assert_doubles(R(2,2), 0.707107, epsilon)); - -#ifdef CGAL_OPTIMAL_BOUNDING_BOX_DEBUG_TEST - // postprocessing - Matrix obb(8, 3); - CGAL::Optimal_bounding_box::post_processing(points, R, obb); -#endif + check_equality(Traits::compute_determinant(R), 1); + check_equality(R(0,0), -1); + check_equality(R(0,1), 0); + check_equality(R(0,2), 0); + check_equality(R(1,0), 0); + check_equality(R(1,1), -0.707107); + check_equality(R(1,2), 0.707106) || assert_doubles(R(1,2), -0.707106); + check_equality(R(2,0), 0); + check_equality(R(2,1), 0.707106) || assert_doubles(R(1,2), -0.707106); + check_equality(R(2,2), 0.707107); } void test_compute_obb_evolution(const std::string fname) { std::ifstream input(fname); - typedef CGAL::Surface_mesh SMesh; + typedef CGAL::Surface_mesh SMesh; SMesh mesh; - if (!input || !(input >> mesh) || mesh.is_empty()) + if(!input || !(input >> mesh) || mesh.is_empty()) { std::cerr << fname << " is not a valid off file.\n"; std::exit(1); } - // get mesh points - std::vector sm_points; + Traits traits; + std::array obb_points; + CGAL::oriented_bounding_box(sm, obb_points, CGAL::parameters::use_convex_hull(true) + .geom_traits(traits)); - typedef typename boost::graph_traits::vertex_descriptor vertex_descriptor; - typedef typename boost::property_map::const_type PointPMap; - - PointPMap pmap = get(boost::vertex_point, mesh); - for(vertex_descriptor v : vertices(mesh)) - sm_points.push_back(get(pmap, v)); - - - CGAL::Eigen_linear_algebra_traits la_traits; - std::vector obb_points; - CGAL::Optimal_bounding_box::compute_optimal_bounding_box(sm_points, obb_points, la_traits, true); - - double epsilon = 1e-3; - double vol = CGAL::Optimal_bounding_box::calculate_volume(obb_points); - assert(assert_doubles(vol, 0.883371, epsilon)); + FT vol = CGAL::Optimal_bounding_box::calculate_volume(obb_points); + check_equality(vol, 0.883371); #ifdef CGAL_OPTIMAL_BOUNDING_BOX_DEBUG_TEST - /* - for(int i = 0; i < 8; ++i) - std::cout << obb_points[i].x() << " " << obb_points[i].y() << " " << obb_points[i].z() << "\n" ; - */ - CGAL::Surface_mesh result_mesh; + CGAL::Surface_mesh result_mesh; CGAL::make_hexahedron(obb_points[0], obb_points[1], obb_points[2], obb_points[3], - obb_points[4], obb_points[5], obb_points[6], obb_points[7], result_mesh); + obb_points[4], obb_points[5], obb_points[6], obb_points[7], result_mesh); std::ofstream out("data/obb_result.off"); out << result_mesh; @@ -230,16 +171,15 @@ void test_compute_obb_evolution(const std::string fname) void test_compute_obb_mesh(const std::string fname) { std::ifstream input(fname); - CGAL::Surface_mesh mesh; - if (!input || !(input >> mesh) || mesh.is_empty()) + CGAL::Surface_mesh mesh; + if(!input || !(input >> mesh) || mesh.is_empty()) { std::cerr << fname << " is not a valid off file.\n"; std::exit(1); } - CGAL::Eigen_linear_algebra_traits la_traits; - CGAL::Surface_mesh< K::Point_3> obbmesh; - CGAL::Optimal_bounding_box::compute_optimal_bounding_box(mesh, obbmesh, la_traits, true); + CGAL::Surface_mesh obbmesh; + CGAL::oriented_bounding_box(mesh, obbmesh); #ifdef CGAL_OPTIMAL_BOUNDING_BOX_DEBUG_TEST std::ofstream out("/tmp/result_elephant.off"); @@ -248,46 +188,21 @@ void test_compute_obb_mesh(const std::string fname) #endif } -void test_function_defaults_traits(const std::string fname1, - const std::string fname2) +void test_function_defaults_traits(const std::string fname1) { std::ifstream input1(fname1); - CGAL::Surface_mesh mesh1; - if (!input1 || !(input1 >> mesh1) || mesh1.is_empty()) + CGAL::Surface_mesh mesh1; + if(!input1 || !(input1 >> mesh1) || mesh1.is_empty()) { std::cerr << fname1 << " is not a valid off file.\n"; std::exit(1); } - std::ifstream input2(fname2); - CGAL::Surface_mesh mesh2; - if (!input2 || !(input2 >> mesh2) || mesh2.is_empty()) - { - std::cerr << fname2 << " is not a valid off file.\n"; - std::exit(1); - } + std::array obb_points; + CGAL::oriented_bounding_box(sm_points, obb_points, CGAL::parameters::use_convex_hull(true)); - // test one - std::vector sm_points; - typedef CGAL::Surface_mesh SMesh; - - typedef typename boost::graph_traits::vertex_descriptor vertex_descriptor; - typedef typename boost::property_map::const_type PointPMap; - PointPMap pmap = get(boost::vertex_point, mesh1); - - for(vertex_descriptor v : vertices(mesh1)) - sm_points.push_back(get(pmap, v)); - - std::vector obb_points; - CGAL::Optimal_bounding_box::compute_optimal_bounding_box(sm_points, obb_points, true); - - const double epsilon = 1e-3; - const double vol = CGAL::Optimal_bounding_box::calculate_volume(obb_points); - assert(assert_doubles(vol, 0.883371, epsilon)); - - // test two - CGAL::Surface_mesh obbmesh; - CGAL::Optimal_bounding_box::compute_optimal_bounding_box(mesh2, obbmesh, true); + const FT vol = CGAL::Optimal_bounding_box::calculate_volume(obb_points); + check_equality(vol, 0.883371); } int main() @@ -299,7 +214,7 @@ int main() test_long_tetrahedron("data/long_tetrahedron.off"); test_compute_obb_evolution("data/random_unit_tetra.off"); test_compute_obb_mesh("data/elephant.off"); - test_function_defaults_traits("data/random_unit_tetra.off", "data/elephant.off"); + test_function_defaults_traits("data/random_unit_tetra.off"); return 0; }