mirror of https://github.com/CGAL/cgal
move test files from gsoc2014-VCM_3-jmeyron@276e4bb8
This commit is contained in:
Sébastien Loriot
parent
e8f43d0a76
commit
3dbc4880c6
|
|
@ -0,0 +1,58 @@
|
|||
#include <cassert>
|
||||
|
||||
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
|
||||
|
||||
#include <CGAL/Convex_hull_3/dual/Convex_hull_traits_dual_3.h>
|
||||
#include <CGAL/Convex_hull_traits_3.h>
|
||||
|
||||
#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<K> Hull_traits_dual;
|
||||
typedef Hull_traits_dual::Collinear_3 Collinear_3_dual;
|
||||
|
||||
typedef CGAL::Convex_hull_traits_3<K> 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<K>(p), to_dual<K>(q), to_dual<K>(r)) << std::endl; */
|
||||
assert(collinear_dual(p, q, r) == true);
|
||||
assert(collinear_dual(p, q, r) == collinear(to_dual<K>(p), to_dual<K>(q), to_dual<K>(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<K>(p2), to_dual<K>(q2), to_dual<K>(r2)) << std::endl; */
|
||||
assert(collinear_dual(p2, q2, r2) == true);
|
||||
assert(collinear_dual(p2, q2, r2) == collinear(to_dual<K>(p2), to_dual<K>(q2), to_dual<K>(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<K>(p3), to_dual<K>(q3), to_dual<K>(r3)) << std::endl; */
|
||||
assert(collinear_dual(p3, q3, r3) == false);
|
||||
assert(collinear_dual(p3, q3, r3) == collinear(to_dual<K>(p3), to_dual<K>(q3), to_dual<K>(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<K>(p4), to_dual<K>(q4), to_dual<K>(r4)) << std::endl; */
|
||||
assert(collinear_dual(p4, q4, r4) == false);
|
||||
assert(collinear_dual(p4, q4, r4) == collinear(to_dual<K>(p4), to_dual<K>(q4), to_dual<K>(r4)));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
#include <cassert>
|
||||
|
||||
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
|
||||
|
||||
#include <CGAL/Convex_hull_3/dual/Convex_hull_traits_dual_3.h>
|
||||
#include <CGAL/Convex_hull_traits_3.h>
|
||||
|
||||
#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<K> Hull_traits_dual;
|
||||
typedef Hull_traits_dual::Coplanar_3 Coplanar_3_dual;
|
||||
|
||||
typedef CGAL::Convex_hull_traits_3<K> 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<K>(p), to_dual<K>(q), to_dual<K>(r), to_dual<K>(s)) << std::endl; */
|
||||
assert(coplanar_dual(p, q, r, s) == true);
|
||||
assert(coplanar_dual(p, q, r, s) == coplanar(to_dual<K>(p), to_dual<K>(q), to_dual<K>(r), to_dual<K>(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<K>(p2), to_dual<K>(q2), to_dual<K>(r2), to_dual<K>(s2)) << std::endl; */
|
||||
assert(coplanar_dual(p2, q2, r2, s2) == true);
|
||||
assert(coplanar_dual(p2, q2, r2, s2) == coplanar(to_dual<K>(p2), to_dual<K>(q2), to_dual<K>(r2), to_dual<K>(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<K>(p3), to_dual<K>(q3), to_dual<K>(r3), to_dual<K>(s3)) << std::endl; */
|
||||
assert(coplanar_dual(p3, q3, r3, s3) == false);
|
||||
assert(coplanar_dual(p3, q3, r3, s3) == coplanar(to_dual<K>(p3), to_dual<K>(q3), to_dual<K>(r3), to_dual<K>(s3)));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,60 @@
|
|||
#include <cassert>
|
||||
|
||||
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
|
||||
|
||||
#include <CGAL/Convex_hull_3/dual/Convex_hull_traits_dual_3.h>
|
||||
#include <CGAL/Convex_hull_traits_3.h>
|
||||
|
||||
#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<K> Hull_traits_dual;
|
||||
typedef Hull_traits_dual::Equal_3 Equal_3_dual;
|
||||
|
||||
typedef CGAL::Convex_hull_traits_3<K> 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<K>(p), to_dual<K>(q)) << std::endl; */
|
||||
assert(equal_dual(p, q) == true);
|
||||
assert(equal_dual(p, q) == equal(to_dual<K>(p), to_dual<K>(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<K>(pp), to_dual<K>(qq)) << std::endl; */
|
||||
assert(equal_dual(pp, qq) == true);
|
||||
assert(equal_dual(pp, qq) == equal(to_dual<K>(pp), to_dual<K>(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<K>(p2), to_dual<K>(q2)) << std::endl; */
|
||||
assert(equal_dual(p2, q2) == false);
|
||||
assert(equal_dual(p2, q2) == equal(to_dual<K>(p2), to_dual<K>(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<K>(ppp), to_dual<K>(qqq)) << std::endl; */
|
||||
assert(equal_dual(ppp, qqq) == true);
|
||||
assert(equal_dual(ppp, qqq) == equal(to_dual<K>(ppp), to_dual<K>(qqq)));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
#include <cassert>
|
||||
|
||||
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
|
||||
|
||||
#include <CGAL/Convex_hull_3/dual/Convex_hull_traits_dual_3.h>
|
||||
#include <CGAL/Convex_hull_traits_3.h>
|
||||
|
||||
#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<K> Plane_dual;
|
||||
|
||||
typedef CGAL::Convex_hull_3::Convex_hull_traits_dual_3<K> Hull_traits_dual;
|
||||
typedef Hull_traits_dual::Has_on_positive_side_3 Has_on_positive_side_3_dual;
|
||||
|
||||
typedef CGAL::Convex_hull_traits_3<K> 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<K>(p), to_dual<K>(q)) << std::endl; */
|
||||
assert(has_on_dual(p, q) == true);
|
||||
assert(has_on_dual(p, q) == has_on(to_dual_plane<K>(p), to_dual<K>(q)));
|
||||
|
||||
// False
|
||||
/* std::cout << has_on_dual(p, qq) << std::endl; */
|
||||
/* std::cout << has_on(to_dual_plane<K>(p), to_dual<K>(qq)) << std::endl; */
|
||||
assert(has_on_dual(p, q) == false);
|
||||
assert(has_on_dual(p, q) == has_on(to_dual_plane<K>(p), to_dual<K>(qq)));
|
||||
|
||||
// False : on the plane
|
||||
/* std::cout << has_on_dual(p, qqq) << std::endl; */
|
||||
/* std::cout << has_on(to_dual_plane<K>(p), to_dual<K>(qqq)) << std::endl; */
|
||||
assert(has_on_dual(p, q) == false);
|
||||
assert(has_on_dual(p, q) == has_on(to_dual_plane<K>(p), to_dual<K>(qqq)));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
#include <cassert>
|
||||
|
||||
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
|
||||
|
||||
#include <CGAL/Convex_hull_3/dual/Convex_hull_traits_dual_3.h>
|
||||
#include <CGAL/Convex_hull_traits_3.h>
|
||||
|
||||
#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<K> Hull_traits_dual;
|
||||
typedef Hull_traits_dual::Less_distance_to_point_3 Less_distance_to_point_3_dual;
|
||||
|
||||
typedef CGAL::Convex_hull_traits_3<K> 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<K>(p), to_dual<K>(q), to_dual<K>(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<K>(p), to_dual<K>(q), to_dual<K>(rr)));
|
||||
|
||||
// False
|
||||
/* std::cout << less_distance_to_point_dual(p, q, r) << std::endl; */
|
||||
/* std::cout << less_distance_to_point(to_dual<K>(p), to_dual<K>(q), to_dual<K>(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<K>(p), to_dual<K>(q), to_dual<K>(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<K>(p), to_dual<K>(q), to_dual<K>(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<K>(p), to_dual<K>(q), to_dual<K>(p)));
|
||||
|
||||
/* std::cout << less_distance_to_point_dual(p, q, q) << std::endl; */
|
||||
/* std::cout << less_distance_to_point(to_dual<K>(p), to_dual<K>(q), to_dual<K>(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<K>(p), to_dual<K>(q), to_dual<K>(q)));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,45 @@
|
|||
#include <cassert>
|
||||
|
||||
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
|
||||
|
||||
#include <CGAL/Convex_hull_3/dual/Convex_hull_traits_dual_3.h>
|
||||
#include <CGAL/Convex_hull_traits_3.h>
|
||||
|
||||
#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<K> Plane_dual;
|
||||
|
||||
typedef CGAL::Convex_hull_3::Convex_hull_traits_dual_3<K> 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<K> 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<K>(p), to_dual<K>(q), to_dual<K>(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<K>(p), to_dual<K>(q), to_dual<K>(rr)) << std::endl; */
|
||||
assert(less_signed_distance_dual(p, q, r) == true);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
#ifndef TO_DUAL_H
|
||||
#define TO_DUAL_H
|
||||
|
||||
// Convert a dual point to a point
|
||||
template <typename R>
|
||||
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 <typename R>
|
||||
CGAL::Point_triple<R> to_dual_plane (CGAL::Convex_hull_3::Plane_dual<R> 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<R> pp(to_dual<R>(p1),
|
||||
to_dual<R>(p2),
|
||||
to_dual<R>(p3));
|
||||
|
||||
return pp;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
Loading…
Reference in New Issue