diff --git a/Convex_hull_3/test/Convex_hull_3/ch3_dual_test_collinear_3.cpp b/Convex_hull_3/test/Convex_hull_3/ch3_dual_test_collinear_3.cpp new file mode 100644 index 00000000000..e008686ad86 --- /dev/null +++ b/Convex_hull_3/test/Convex_hull_3/ch3_dual_test_collinear_3.cpp @@ -0,0 +1,58 @@ +#include + +#include + +#include +#include + +#include "include/to_dual.h" + +typedef CGAL::Exact_predicates_inexact_constructions_kernel K; +typedef K::Plane_3 Plane; + +typedef CGAL::Convex_hull_3::Convex_hull_traits_dual_3 Hull_traits_dual; +typedef Hull_traits_dual::Collinear_3 Collinear_3_dual; + +typedef CGAL::Convex_hull_traits_3 Hull_traits; +typedef Hull_traits::Collinear_3 Collinear_3; + +int main () { + Hull_traits_dual traits_dual; + Hull_traits traits; + + Collinear_3_dual collinear_dual = traits_dual.collinear_3_object(); + Collinear_3 collinear = traits.collinear_3_object(); + + // Simple true test with equal planes + Plane p(1, 1, 1, 1), q(1, 1, 1, 1), r(1, 1, 1, 1); + /* std::cout << collinear_dual(p, q, r) << std::endl; */ + /* std::cout << collinear(to_dual(p), to_dual(q), to_dual(r)) << std::endl; */ + assert(collinear_dual(p, q, r) == true); + assert(collinear_dual(p, q, r) == collinear(to_dual(p), to_dual(q), to_dual(r))); + + // Simple true test with non equal planes + Plane p2(1, 1, 1, -1), q2(2, 2, 2, -1), r2(3, 3, 3, -1); + /* std::cout << collinear_dual(p2, q2, r2) << std::endl; */ + /* std::cout << collinear(to_dual(p2), to_dual(q2), to_dual(r2)) << std::endl; */ + assert(collinear_dual(p2, q2, r2) == true); + assert(collinear_dual(p2, q2, r2) == collinear(to_dual(p2), to_dual(q2), to_dual(r2))); + + // Simple false test + Plane p3(1, 1, 1, -1), q3(2, 2, 2, -1), r3(3, 3, 2, -1); + /* std::cout << collinear_dual(p3, q3, r3) << std::endl; */ + /* std::cout << collinear(to_dual(p3), to_dual(q3), to_dual(r3)) << std::endl; */ + assert(collinear_dual(p3, q3, r3) == false); + assert(collinear_dual(p3, q3, r3) == collinear(to_dual(p3), to_dual(q3), to_dual(r3))); + + // Almost but not collinear + double almost1 = 0.9999999999; + Plane p4(0, 0, 0, -1), q4(1, 1, 1, -1); + Plane r4(almost1, almost1, almost1+1e-15, -1); + /* std::cout << collinear_dual(p4, q4, r4) << std::endl; */ + /* std::cout << collinear(to_dual(p4), to_dual(q4), to_dual(r4)) << std::endl; */ + assert(collinear_dual(p4, q4, r4) == false); + assert(collinear_dual(p4, q4, r4) == collinear(to_dual(p4), to_dual(q4), to_dual(r4))); + + return 0; +} + diff --git a/Convex_hull_3/test/Convex_hull_3/ch3_dual_test_coplanar_3.cpp b/Convex_hull_3/test/Convex_hull_3/ch3_dual_test_coplanar_3.cpp new file mode 100644 index 00000000000..f1a505b0376 --- /dev/null +++ b/Convex_hull_3/test/Convex_hull_3/ch3_dual_test_coplanar_3.cpp @@ -0,0 +1,49 @@ +#include + +#include + +#include +#include + +#include "include/to_dual.h" + +typedef CGAL::Exact_predicates_inexact_constructions_kernel K; +typedef K::Plane_3 Plane; + +typedef CGAL::Convex_hull_3::Convex_hull_traits_dual_3 Hull_traits_dual; +typedef Hull_traits_dual::Coplanar_3 Coplanar_3_dual; + +typedef CGAL::Convex_hull_traits_3 Hull_traits; +typedef Hull_traits::Coplanar_3 Coplanar_3; + +int main () { + Hull_traits_dual traits_dual; + Hull_traits traits; + + Coplanar_3_dual coplanar_dual = traits_dual.coplanar_3_object(); + Coplanar_3 coplanar = traits.coplanar_3_object(); + + // Simple true test with equal planes + K::Plane_3 p(1, 1, 1, 1), q(1, 1, 1, 1), r(1, 1, 1, 1), s(1, 1, 1, 1); + /* std::cout << coplanar_dual(p, q, r, s) << std::endl; */ + /* std::cout << coplanar(to_dual(p), to_dual(q), to_dual(r), to_dual(s)) << std::endl; */ + assert(coplanar_dual(p, q, r, s) == true); + assert(coplanar_dual(p, q, r, s) == coplanar(to_dual(p), to_dual(q), to_dual(r), to_dual(s))); + + // Simple true test + K::Plane_3 p2(1, 1, 1, -1), q2(2, 1, 1, -1), r2(2, 2, 1, -1), s2(1, 2, 1, -1); + /* std::cout << coplanar_dual(p2, q2, r2, s2) << std::endl; */ + /* std::cout << coplanar(to_dual(p2), to_dual(q2), to_dual(r2), to_dual(s2)) << std::endl; */ + assert(coplanar_dual(p2, q2, r2, s2) == true); + assert(coplanar_dual(p2, q2, r2, s2) == coplanar(to_dual(p2), to_dual(q2), to_dual(r2), to_dual(s2))); + + // Simple false test + K::Plane_3 p3(1, 1, 1, -1), q3(2, 1, 1, -1), r3(2, 2, 1, -1), s3(1, 1, 2, -1); + /* std::cout << coplanar_dual(p3, q3, r3, s3) << std::endl; */ + /* std::cout << coplanar(to_dual(p3), to_dual(q3), to_dual(r3), to_dual(s3)) << std::endl; */ + assert(coplanar_dual(p3, q3, r3, s3) == false); + assert(coplanar_dual(p3, q3, r3, s3) == coplanar(to_dual(p3), to_dual(q3), to_dual(r3), to_dual(s3))); + + return 0; +} + diff --git a/Convex_hull_3/test/Convex_hull_3/ch3_dual_test_equal_3.cpp b/Convex_hull_3/test/Convex_hull_3/ch3_dual_test_equal_3.cpp new file mode 100644 index 00000000000..0edbb3f472b --- /dev/null +++ b/Convex_hull_3/test/Convex_hull_3/ch3_dual_test_equal_3.cpp @@ -0,0 +1,60 @@ +#include + +#include + +#include +#include + +#include "include/to_dual.h" + +typedef CGAL::Exact_predicates_inexact_constructions_kernel K; +typedef K::Plane_3 Plane; +typedef K::Point_3 Point; + +typedef CGAL::Convex_hull_3::Convex_hull_traits_dual_3 Hull_traits_dual; +typedef Hull_traits_dual::Equal_3 Equal_3_dual; + +typedef CGAL::Convex_hull_traits_3 Hull_traits; +typedef Hull_traits::Equal_3 Equal_3; + +int main (void) { + Point origin(0, 0, 0); + + Hull_traits_dual traits_dual(origin); + Hull_traits traits; + + Equal_3_dual equal_dual = traits_dual.equal_3_object(); + Equal_3 equal = traits.equal_3_object(); + + // True test with equal planes + Plane p(1, 1, 1, 1), q(1, 1, 1, 1); + /* std::cout << equal_dual(p, q) << std::endl; */ + /* std::cout << equal(to_dual(p), to_dual(q)) << std::endl; */ + assert(equal_dual(p, q) == true); + assert(equal_dual(p, q) == equal(to_dual(p), to_dual(q))); + + // True test with planes whose coefficients are multiple of the other + Plane pp(1, 1, 1, 1), qq(2, 2, 2, 2); + /* std::cout << equal_dual(pp, qq) << std::endl; */ + /* std::cout << equal(to_dual(pp), to_dual(qq)) << std::endl; */ + assert(equal_dual(pp, qq) == true); + assert(equal_dual(pp, qq) == equal(to_dual(pp), to_dual(qq))); + + // False test with non equal planes + Plane p2(1, 2, 1, 1), q2(2, 2, 2, 2); + /* std::cout << equal_dual(p2, q2) << std::endl; */ + /* std::cout << equal(to_dual(p2), to_dual(q2)) << std::endl; */ + assert(equal_dual(p2, q2) == false); + assert(equal_dual(p2, q2) == equal(to_dual(p2), to_dual(q2))); + + // True test using exact computation + double x = 1.123456789, y = 1.987654321, e=1e-15; + Plane ppp(x, x, x, x), qqq(y+e, y+e, y+e, y+e); + /* std::cout << equal_dual(ppp, qqq) << std::endl; */ + /* std::cout << equal(to_dual(ppp), to_dual(qqq)) << std::endl; */ + assert(equal_dual(ppp, qqq) == true); + assert(equal_dual(ppp, qqq) == equal(to_dual(ppp), to_dual(qqq))); + + return 0; +} + diff --git a/Convex_hull_3/test/Convex_hull_3/ch3_dual_test_has_on_positive_side_3.cpp b/Convex_hull_3/test/Convex_hull_3/ch3_dual_test_has_on_positive_side_3.cpp new file mode 100644 index 00000000000..8a7f577bbbc --- /dev/null +++ b/Convex_hull_3/test/Convex_hull_3/ch3_dual_test_has_on_positive_side_3.cpp @@ -0,0 +1,51 @@ +#include + +#include + +#include +#include + +#include "include/to_dual.h" + +typedef CGAL::Exact_predicates_inexact_constructions_kernel K; +typedef K::Plane_3 Plane; +typedef CGAL::Convex_hull_3::Plane_dual Plane_dual; + +typedef CGAL::Convex_hull_3::Convex_hull_traits_dual_3 Hull_traits_dual; +typedef Hull_traits_dual::Has_on_positive_side_3 Has_on_positive_side_3_dual; + +typedef CGAL::Convex_hull_traits_3 Hull_traits; +typedef Hull_traits::Has_on_positive_side_3 Has_on_positive_side_3; + +int main () { + Hull_traits_dual traits_dual; + Hull_traits traits; + + Has_on_positive_side_3 has_on = traits.has_on_positive_side_3_object(); + Has_on_positive_side_3_dual has_on_dual = traits_dual.has_on_positive_side_3_object(); + + Plane a(1, 1, 0, -1), b(1, 2, 1, -1), c(1, 3, 0, -1); // dual plane : x = 1 + Plane_dual p(a,b,c); + Plane q(0, 0, 0, -1), qq(2, 0, 0, -1), qqq(1, 1, 0, -1); + + // True + /* std::cout << has_on_dual(p, q) << std::endl; */ + /* std::cout << has_on(to_dual_plane(p), to_dual(q)) << std::endl; */ + assert(has_on_dual(p, q) == true); + assert(has_on_dual(p, q) == has_on(to_dual_plane(p), to_dual(q))); + + // False + /* std::cout << has_on_dual(p, qq) << std::endl; */ + /* std::cout << has_on(to_dual_plane(p), to_dual(qq)) << std::endl; */ + assert(has_on_dual(p, q) == false); + assert(has_on_dual(p, q) == has_on(to_dual_plane(p), to_dual(qq))); + + // False : on the plane + /* std::cout << has_on_dual(p, qqq) << std::endl; */ + /* std::cout << has_on(to_dual_plane(p), to_dual(qqq)) << std::endl; */ + assert(has_on_dual(p, q) == false); + assert(has_on_dual(p, q) == has_on(to_dual_plane(p), to_dual(qqq))); + + return 0; +} + diff --git a/Convex_hull_3/test/Convex_hull_3/ch3_dual_test_less_distance_to_point_3.cpp b/Convex_hull_3/test/Convex_hull_3/ch3_dual_test_less_distance_to_point_3.cpp new file mode 100644 index 00000000000..b9322f3837c --- /dev/null +++ b/Convex_hull_3/test/Convex_hull_3/ch3_dual_test_less_distance_to_point_3.cpp @@ -0,0 +1,55 @@ +#include + +#include + +#include +#include + +#include "include/to_dual.h" + +typedef CGAL::Exact_predicates_inexact_constructions_kernel K; +typedef K::Plane_3 Plane; + +typedef CGAL::Convex_hull_3::Convex_hull_traits_dual_3 Hull_traits_dual; +typedef Hull_traits_dual::Less_distance_to_point_3 Less_distance_to_point_3_dual; + +typedef CGAL::Convex_hull_traits_3 Hull_traits; +typedef Hull_traits::Less_distance_to_point_3 Less_distance_to_point_3; + +int main () { + Hull_traits_dual traits_dual; + Hull_traits traits; + + Less_distance_to_point_3_dual less_distance_to_point_dual = traits_dual.less_distance_to_point_3_object(); + Less_distance_to_point_3 less_distance_to_point = traits.less_distance_to_point_3_object(); + + Plane p(1, 0, 0, -1), q(3, 0, 0, -1); + Plane r(2, 0, 0, -1), rr(4, 0, 0, -1); + + // True + /* std::cout << less_distance_to_point_dual(p, q, rr) << std::endl; */ + /* std::cout << less_distance_to_point(to_dual(p), to_dual(q), to_dual(rr)) << std::endl; */ + assert(less_distance_to_point_dual(p, q, rr) == true); + assert(less_distance_to_point_dual(p, q, rr) == less_distance_to_point(to_dual(p), to_dual(q), to_dual(rr))); + + // False + /* std::cout << less_distance_to_point_dual(p, q, r) << std::endl; */ + /* std::cout << less_distance_to_point(to_dual(p), to_dual(q), to_dual(r)) << std::endl; */ + assert(less_distance_to_point_dual(p, q, r) == false); + assert(less_distance_to_point_dual(p, q, r) == less_distance_to_point(to_dual(p), to_dual(q), to_dual(r))); + + // Tests if r is one of the two first points + // False + /* std::cout << less_distance_to_point_dual(p, q, p) << std::endl; */ + /* std::cout << less_distance_to_point(to_dual(p), to_dual(q), to_dual(p)) << std::endl; */ + assert(less_distance_to_point_dual(p, q, p) == false); + assert(less_distance_to_point_dual(p, q, p) == less_distance_to_point(to_dual(p), to_dual(q), to_dual(p))); + + /* std::cout << less_distance_to_point_dual(p, q, q) << std::endl; */ + /* std::cout << less_distance_to_point(to_dual(p), to_dual(q), to_dual(q)) << std::endl; */ + assert(less_distance_to_point_dual(p, q, q) == false); + assert(less_distance_to_point_dual(p, q, q) == less_distance_to_point(to_dual(p), to_dual(q), to_dual(q))); + + return 0; +} + diff --git a/Convex_hull_3/test/Convex_hull_3/ch3_dual_test_less_signed_distance_to_plane_3.cpp b/Convex_hull_3/test/Convex_hull_3/ch3_dual_test_less_signed_distance_to_plane_3.cpp new file mode 100644 index 00000000000..1740cd4e74d --- /dev/null +++ b/Convex_hull_3/test/Convex_hull_3/ch3_dual_test_less_signed_distance_to_plane_3.cpp @@ -0,0 +1,45 @@ +#include + +#include + +#include +#include + +#include "include/to_dual.h" + +typedef CGAL::Exact_predicates_inexact_constructions_kernel K; +typedef K::Plane_3 Plane; +typedef CGAL::Convex_hull_3::Plane_dual Plane_dual; + +typedef CGAL::Convex_hull_3::Convex_hull_traits_dual_3 Hull_traits_dual; +typedef Hull_traits_dual::Less_signed_distance_to_plane_3 Less_signed_distance_to_plane_3_dual; + +typedef CGAL::Convex_hull_traits_3 Hull_traits; +typedef Hull_traits::Less_signed_distance_to_plane_3 Less_signed_distance_to_plane_3; + +int main () { + Hull_traits_dual traits_dual; + Hull_traits traits; + + Less_signed_distance_to_plane_3 less_signed_distance = traits.less_signed_distance_to_plane_3_object(); + Less_signed_distance_to_plane_3_dual less_signed_distance_dual = traits_dual.less_signed_distance_to_plane_3_object(); + + // dual plane : x = 1 + Plane a(1, 1, 0, -1), b(1, 2, 1, -1), c(1, 3, 0, -1); + Plane_dual p(a,b,c); + + Plane q(2, 0, 0, -1), r(3, 0, 0, -1), rr(0.5, 0, 0, -1); + + // False + /* std::cout << less_signed_distance_dual(p, q, r) << std::endl; */ + /* std::cout << less_signed_distance(to_dual_plane(p), to_dual(q), to_dual(r)) << std::endl; */ + assert(less_signed_distance_dual(p, q, r) == false); + + // True + /* std::cout << less_signed_distance_dual(p, q, rr) << std::endl; */ + /* std::cout << less_signed_distance(to_dual_plane(p), to_dual(q), to_dual(rr)) << std::endl; */ + assert(less_signed_distance_dual(p, q, r) == true); + + return 0; +} + diff --git a/Convex_hull_3/test/Convex_hull_3/include/to_dual.h b/Convex_hull_3/test/Convex_hull_3/include/to_dual.h new file mode 100644 index 00000000000..1067f024c7e --- /dev/null +++ b/Convex_hull_3/test/Convex_hull_3/include/to_dual.h @@ -0,0 +1,27 @@ +#ifndef TO_DUAL_H +#define TO_DUAL_H + +// Convert a dual point to a point +template +typename R::Point_3 to_dual (typename R::Plane_3 const& p) { + typename R::Point_3 pp(-p.a() / p.d(), -p.b() / p.d(), -p.c() / p.d()); + + return pp; +} + +// Convert a dual plane to a plane +template +CGAL::Point_triple to_dual_plane (CGAL::Convex_hull_3::Plane_dual const& p) { + typename R::Plane_3 p1 = p.p1; + typename R::Plane_3 p2 = p.p2; + typename R::Plane_3 p3 = p.p3; + + CGAL::Point_triple pp(to_dual(p1), + to_dual(p2), + to_dual(p3)); + + return pp; +} + +#endif +