From f7a63d0ec594bb8c63aadef4775b446d20b46ca7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?St=C3=A9phane=20Tayeb?= Date: Tue, 10 Nov 2009 16:58:02 +0000 Subject: [PATCH] revert r52901-52902 (moving predicate from AABB_tree to Intersections_3) --- .gitattributes | 1 + AABB_tree/demo/AABB_tree/Scene.h | 1 + AABB_tree/include/CGAL/AABB_intersections.h | 17 +- .../Bbox_3_bbox_3_do_intersect.h | 39 ++ .../Bbox_3_line_3_do_intersect.h | 149 +++++ .../Bbox_3_plane_3_do_intersect.h | 101 ++++ .../Bbox_3_ray_3_do_intersect.h | 170 ++++++ .../Bbox_3_segment_3_do_intersect.h | 149 +++++ .../Bbox_3_sphere_3_do_intersect.h | 116 ++++ .../Bbox_3_triangle_3_do_intersect.h | 282 +++++++++ .../Triangle_3_line_3_intersection.h | 419 ++++++++++++++ .../Triangle_3_plane_3_intersection.h | 187 ++++++ .../Triangle_3_ray_3_intersection.h | 166 ++++++ .../Triangle_3_segment_3_intersection.h | 542 ++++++++++++++++++ AABB_tree/include/CGAL/AABB_traits.h | 3 +- AABB_tree/test/AABB_tree/CMakeLists.txt | 5 +- .../aabb_correctness_triangle_test.cpp | 1 + .../AABB_tree/aabb_distance_edge_test.cpp | 1 + .../aabb_distance_triangle_hint_test.cpp | 1 + .../AABB_tree/aabb_distance_triangle_test.cpp | 2 + .../test/AABB_tree/aabb_do_intersect_test.cpp | 187 ++++++ .../test/AABB_tree/aabb_intersection_test.cpp | 340 +++++++++++ .../aabb_intersection_triangle_test.cpp | 1 + ...bb_naive_vs_tree_distance_segment_test.cpp | 1 + ...b_naive_vs_tree_distance_triangle_test.cpp | 1 + .../aabb_naive_vs_tree_triangle_test.cpp | 1 + 26 files changed, 2876 insertions(+), 7 deletions(-) create mode 100644 AABB_tree/include/CGAL/AABB_intersections/Bbox_3_bbox_3_do_intersect.h create mode 100644 AABB_tree/include/CGAL/AABB_intersections/Bbox_3_line_3_do_intersect.h create mode 100644 AABB_tree/include/CGAL/AABB_intersections/Bbox_3_plane_3_do_intersect.h create mode 100644 AABB_tree/include/CGAL/AABB_intersections/Bbox_3_ray_3_do_intersect.h create mode 100644 AABB_tree/include/CGAL/AABB_intersections/Bbox_3_segment_3_do_intersect.h create mode 100644 AABB_tree/include/CGAL/AABB_intersections/Bbox_3_sphere_3_do_intersect.h create mode 100644 AABB_tree/include/CGAL/AABB_intersections/Bbox_3_triangle_3_do_intersect.h create mode 100644 AABB_tree/include/CGAL/AABB_intersections/Triangle_3_line_3_intersection.h create mode 100644 AABB_tree/include/CGAL/AABB_intersections/Triangle_3_plane_3_intersection.h create mode 100644 AABB_tree/include/CGAL/AABB_intersections/Triangle_3_ray_3_intersection.h create mode 100644 AABB_tree/include/CGAL/AABB_intersections/Triangle_3_segment_3_intersection.h create mode 100644 AABB_tree/test/AABB_tree/aabb_do_intersect_test.cpp create mode 100644 AABB_tree/test/AABB_tree/aabb_intersection_test.cpp diff --git a/.gitattributes b/.gitattributes index 364af720cd4..b7f368ac391 100644 --- a/.gitattributes +++ b/.gitattributes @@ -54,6 +54,7 @@ AABB_tree/examples/AABB_tree/AABB_triangle_3_example.cpp -text AABB_tree/examples/AABB_tree/CMakeLists.txt -text AABB_tree/examples/AABB_tree/cleanup.bat -text AABB_tree/include/CGAL/AABB_intersections.h -text +AABB_tree/include/CGAL/AABB_intersections/Triangle_3_line_3_intersection.h -text AABB_tree/include/CGAL/AABB_intersections/nearest_point_segment_3.h -text AABB_tree/include/CGAL/AABB_polyhedron_segment_primitive.h -text AABB_tree/include/CGAL/AABB_polyhedron_triangle_primitive.h -text diff --git a/AABB_tree/demo/AABB_tree/Scene.h b/AABB_tree/demo/AABB_tree/Scene.h index fc8a7bb9321..e1d009525f5 100644 --- a/AABB_tree/demo/AABB_tree/Scene.h +++ b/AABB_tree/demo/AABB_tree/Scene.h @@ -5,6 +5,7 @@ #include #include +#include #include "types.h" #include "Color_ramp.h" diff --git a/AABB_tree/include/CGAL/AABB_intersections.h b/AABB_tree/include/CGAL/AABB_intersections.h index 2cbd6a85d7e..28c3ee54b95 100644 --- a/AABB_tree/include/CGAL/AABB_intersections.h +++ b/AABB_tree/include/CGAL/AABB_intersections.h @@ -17,7 +17,20 @@ // // Author(s) : Camille Wormser, Pierre Alliez, Stephane Tayeb -// THIS FILE IS DEPRECATED ... - #include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include diff --git a/AABB_tree/include/CGAL/AABB_intersections/Bbox_3_bbox_3_do_intersect.h b/AABB_tree/include/CGAL/AABB_intersections/Bbox_3_bbox_3_do_intersect.h new file mode 100644 index 00000000000..e0e7ef41e28 --- /dev/null +++ b/AABB_tree/include/CGAL/AABB_intersections/Bbox_3_bbox_3_do_intersect.h @@ -0,0 +1,39 @@ +// Copyright (c) 2008 INRIA Sophia-Antipolis (France), ETH Zurich (Switzerland). +// Copyright (c) 2009 GeometryFactory (France) +// All rights reserved. +// +// This file is part of CGAL (www.cgal.org); you may redistribute it under +// the terms of the Q Public License version 1.0. +// See the file LICENSE.QPL distributed with CGAL. +// +// Licensees holding a valid commercial license may use this file in +// accordance with the commercial license agreement provided with the software. +// +// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +// +// $URL$ +// $Id$ +// +// +// Author(s) : Laurent Rineau, Camille Wormser, Jane Tournois, Pierre Alliez + +#ifndef CGAL_BBOX_3_BBOX_3_DO_INTERSECT_H +#define CGAL_BBOX_3_BBOX_3_DO_INTERSECT_H + +// Turn off Visual C++ warning +#ifdef _MSC_VER +#pragma warning ( disable : 4003 ) +#endif + +CGAL_BEGIN_NAMESPACE + +bool do_intersect(const CGAL::Bbox_3& c, + const CGAL::Bbox_3& bbox) +{ + return CGAL::do_overlap(c, bbox); +} + +CGAL_END_NAMESPACE + +#endif // CGAL_BBOX_3_BBOX_3_DO_INTERSECT_H diff --git a/AABB_tree/include/CGAL/AABB_intersections/Bbox_3_line_3_do_intersect.h b/AABB_tree/include/CGAL/AABB_intersections/Bbox_3_line_3_do_intersect.h new file mode 100644 index 00000000000..926b8da363a --- /dev/null +++ b/AABB_tree/include/CGAL/AABB_intersections/Bbox_3_line_3_do_intersect.h @@ -0,0 +1,149 @@ +// Copyright (c) 2008 INRIA Sophia-Antipolis (France), ETH Zurich (Switzerland). +// All rights reserved. +// +// This file is part of CGAL (www.cgal.org); you may redistribute it under +// the terms of the Q Public License version 1.0. +// See the file LICENSE.QPL distributed with CGAL. +// +// Licensees holding a valid commercial license may use this file in +// accordance with the commercial license agreement provided with the software. +// +// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +// +// $URL$ +// $Id$ +// +// +// Author(s) : Camille Wormser, Jane Tournois, Pierre Alliez + + +#ifndef CGAL_LINE_3_BBOX_3_DO_INTERSECT_H +#define CGAL_LINE_3_BBOX_3_DO_INTERSECT_H + +#include +#include + +// inspired from http://cag.csail.mit.edu/~amy/papers/box-jgt.pdf + +CGAL_BEGIN_NAMESPACE + +namespace internal { + + template + bool do_intersect(const typename K::Line_3& line, + const CGAL::Bbox_3& bbox, + const K&) + { + typedef typename K::FT FT; + typedef typename K::Point_3 Point; + typedef typename K::Vector_3 Vector; + + const Point source = line.point(0); + + Point parameters[2]; + parameters[0] = Point(bbox.xmin(), bbox.ymin(), bbox.zmin()); + parameters[1] = Point(bbox.xmax(), bbox.ymax(), bbox.zmax()); + + const Vector direction = line.to_vector(); + + // We don't care about values + FT tmin(0.0); + FT tmax(0.0); + + bool is_dx_null = false; + bool is_dy_null = false; + + if ( ! CGAL_NTS is_zero(direction.x()) ) + { + FT inv_direction_x = FT(1)/direction.x(); + const int sign_x = inv_direction_x < FT(0); + + tmin = (parameters[sign_x].x() - source.x()) * inv_direction_x; + tmax = (parameters[1-sign_x].x() - source.x()) * inv_direction_x; + } + else + { + // premature exit if x value of line is outside bbox + if ( source.x() < parameters[0].x() || source.x() > parameters[1].x() ) + return false; + + is_dx_null = true; + } + + if ( ! CGAL_NTS is_zero(direction.y()) ) + { + FT inv_direction_y = FT(1)/direction.y(); + const int sign_y = inv_direction_y < FT(0); + + const FT tymin = (parameters[sign_y].y() - source.y()) * inv_direction_y; + const FT tymax = (parameters[1-sign_y].y() - source.y()) * inv_direction_y; + + if ( !is_dx_null ) + { + if(tmin > tymax || tymin > tmax) + return false; + + if(tymin > tmin) + tmin = tymin; + + if(tymax < tmax) + tmax = tymax; + } + else + { + tmin = tymin; + tmax = tymax; + } + } + else + { + // premature exit if y value of line is outside bbox + if ( source.y() < parameters[0].y() || source.y() > parameters[1].y() ) + return false; + + is_dy_null = true; + } + + if ( ! CGAL_NTS is_zero(direction.z()) ) + { + FT inv_direction_z = FT(1)/direction.z(); + const int sign_z = inv_direction_z < FT(0); + + FT tzmin = (parameters[sign_z].z() - source.z()) * inv_direction_z; + FT tzmax = (parameters[1-sign_z].z() - source.z()) * inv_direction_z; + + if( (!is_dx_null || !is_dy_null) && (tmin > tzmax || tzmin > tmax) ) + return false; + } + else + { + // premature exit if z value of line is outside bbox + if ( source.z() < parameters[0].z() || source.z() > parameters[1].z() ) + return false; + } + + return true; + } + +} // namespace internal + +template +bool do_intersect(const CGAL::Line_3& line, + const CGAL::Bbox_3& bbox) +{ + return typename K::Do_intersect_3()(line, bbox); +} + +template +bool do_intersect(const CGAL::Bbox_3& bbox, + const CGAL::Line_3& line) +{ + return typename K::Do_intersect_3()(line, bbox); +} + +CGAL_END_NAMESPACE + +#endif // CGAL_LINE_3_BBOX_3_DO_INTERSECT_H + + diff --git a/AABB_tree/include/CGAL/AABB_intersections/Bbox_3_plane_3_do_intersect.h b/AABB_tree/include/CGAL/AABB_intersections/Bbox_3_plane_3_do_intersect.h new file mode 100644 index 00000000000..c922b6a3943 --- /dev/null +++ b/AABB_tree/include/CGAL/AABB_intersections/Bbox_3_plane_3_do_intersect.h @@ -0,0 +1,101 @@ +// Copyright (c) 2008 INRIA Sophia-Antipolis (France), ETH Zurich (Switzerland). +// All rights reserved. +// +// This file is part of CGAL (www.cgal.org); you may redistribute it under +// the terms of the Q Public License version 1.0. +// See the file LICENSE.QPL distributed with CGAL. +// +// Licensees holding a valid commercial license may use this file in +// accordance with the commercial license agreement provided with the software. +// +// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +// +// $URL$ +// $Id$ +// +// +// Author(s) : Camille Wormser, Jane Tournois, Pierre Alliez + + +#ifndef CGAL_PLANE_3_BBOX_3_DO_INTERSECT_H +#define CGAL_PLANE_3_BBOX_3_DO_INTERSECT_H + +#include +#include + +// Opcode like + +CGAL_BEGIN_NAMESPACE + +namespace internal { + + template + void get_min_max(const typename K::Vector_3& p, + const CGAL::Bbox_3& bbox, + typename K::Point_3& p_min, + typename K::Point_3& p_max) + { + if(p.x() > 0) { + if(p.y() > 0) { + if(p.z() > 0) { p_min = typename K::Point_3(bbox.xmin(), bbox.ymin(),bbox.zmin()); + p_max = typename K::Point_3(bbox.xmax(), bbox.ymax(),bbox.zmax());} + else { p_min = typename K::Point_3(bbox.xmin(), bbox.ymin(),bbox.zmax()); + p_max = typename K::Point_3(bbox.xmax(), bbox.ymax(),bbox.zmin());} + } + else { + if(p.z() > 0) { p_min = typename K::Point_3(bbox.xmin(), bbox.ymax(),bbox.zmin()); + p_max = typename K::Point_3(bbox.xmax(), bbox.ymin(),bbox.zmax());} + else { p_min = typename K::Point_3(bbox.xmin(), bbox.ymax(),bbox.zmax()); + p_max = typename K::Point_3(bbox.xmax(), bbox.ymin(),bbox.zmin());} + } + } + else { + if(p.y() > 0) { + if(p.z() > 0) { p_min = typename K::Point_3(bbox.xmax(), bbox.ymin(),bbox.zmin()); + p_max = typename K::Point_3(bbox.xmin(), bbox.ymax(),bbox.zmax());} + else { p_min = typename K::Point_3(bbox.xmax(), bbox.ymin(),bbox.zmax()); + p_max = typename K::Point_3(bbox.xmin(), bbox.ymax(),bbox.zmin());} + } + else { + if(p.z() > 0) { p_min = typename K::Point_3(bbox.xmax(), bbox.ymax(),bbox.zmin()); + p_max = typename K::Point_3(bbox.xmin(), bbox.ymin(),bbox.zmax());} + else { p_min = typename K::Point_3(bbox.xmax(), bbox.ymax(),bbox.zmax()); + p_max = typename K::Point_3(bbox.xmin(), bbox.ymin(),bbox.zmin());} + } + } + } + + template + bool do_intersect(const typename K::Plane_3& plane, + const CGAL::Bbox_3& bbox, + const K&) + { + typename K::Point_3 p_max, p_min; + get_min_max(plane.orthogonal_vector(), bbox, p_min, p_max); + return ! (plane.oriented_side(p_max) == ON_NEGATIVE_SIDE || + plane.oriented_side(p_min) == ON_POSITIVE_SIDE); + } + +} // namespace internal + +template +bool do_intersect(const CGAL::Plane_3& plane, + const CGAL::Bbox_3& bbox) +{ + return typename K::Do_intersect_3()(plane, bbox); +} + +template +bool do_intersect(const CGAL::Bbox_3& bbox, + const CGAL::Plane_3& plane) +{ + return typename K::Do_intersect_3()(plane, bbox); +} + + +CGAL_END_NAMESPACE + +#endif // CGAL_PLANE_3_BBOX_3_DO_INTERSECT_H + + diff --git a/AABB_tree/include/CGAL/AABB_intersections/Bbox_3_ray_3_do_intersect.h b/AABB_tree/include/CGAL/AABB_intersections/Bbox_3_ray_3_do_intersect.h new file mode 100644 index 00000000000..8934d03663e --- /dev/null +++ b/AABB_tree/include/CGAL/AABB_intersections/Bbox_3_ray_3_do_intersect.h @@ -0,0 +1,170 @@ +// Copyright (c) 2008 INRIA Sophia-Antipolis (France), ETH Zurich (Switzerland). +// All rights reserved. +// +// This file is part of CGAL (www.cgal.org); you may redistribute it under +// the terms of the Q Public License version 1.0. +// See the file LICENSE.QPL distributed with CGAL. +// +// Licensees holding a valid commercial license may use this file in +// accordance with the commercial license agreement provided with the software. +// +// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +// +// $URL$ +// $Id$ +// +// +// Author(s) : Camille Wormser, Jane Tournois, Pierre Alliez + +#ifndef CGAL_RAY_3_BBOX_3_DO_INTERSECT_H +#define CGAL_RAY_3_BBOX_3_DO_INTERSECT_H + +#include + +// inspired from http://cag.csail.mit.edu/~amy/papers/box-jgt.pdf + +CGAL_BEGIN_NAMESPACE + +namespace internal { + + template + bool do_intersect(const typename K::Ray_3& ray, + const CGAL::Bbox_3& bbox, + const K&) + { + typedef typename K::FT FT; + typedef typename K::Point_3 Point; + typedef typename K::Vector_3 Vector; + + Point parameters[2]; + parameters[0] = Point(bbox.xmin(), bbox.ymin(), bbox.zmin()); + parameters[1] = Point(bbox.xmax(), bbox.ymax(), bbox.zmax()); + + const Point source = ray.source(); + if((parameters[0].x() <= source.x()) && (source.x() <= parameters[1].x()) && + (parameters[0].y() <= source.y()) && (source.y() <= parameters[1].y()) && + (parameters[0].z() <= source.z()) && (source.z() <= parameters[1].z())) + return true; + + const Vector direction = ray.to_vector(); + + FT tmin(0.0); + FT tmax(0.0); + + bool is_dx_null = false; + bool is_dy_null = false; + + if ( ! CGAL_NTS is_zero(direction.x()) ) + { + FT inv_direction_x = FT(1)/direction.x(); + const int sign_x = inv_direction_x < FT(0); + + tmin = (parameters[sign_x].x() - source.x()) * inv_direction_x; + tmax = (parameters[1-sign_x].x() - source.x()) * inv_direction_x; + + // premature exit + if(tmax < FT(0)) + return false; + if(tmin < FT(0)) + tmin = FT(0); + } + else + { + // premature exit if x value of ray is outside bbox + if ( source.x() < parameters[0].x() || source.x() > parameters[1].x() ) + return false; + + is_dx_null = true; + } + + if ( ! CGAL_NTS is_zero(direction.y()) ) + { + FT inv_direction_y = FT(1)/direction.y(); + const int sign_y = inv_direction_y < FT(0); + + const FT tymin = (parameters[sign_y].y() - source.y()) * inv_direction_y; + const FT tymax = (parameters[1-sign_y].y() - source.y()) * inv_direction_y; + + if ( !is_dx_null ) + { + if(tmin > tymax || tymin > tmax) + return false; + + if(tymin > tmin) + tmin = tymin; + + if(tymax < tmax) + tmax = tymax; + } + else + { + if(tymax < FT(0)) + return false; + + tmin = tymin; + tmax = tymax; + + if(tmin < FT(0)) + tmin = FT(0); + } + } + else + { + // premature exit if y value of ray is outside bbox + if ( source.y() < parameters[0].y() || source.y() > parameters[1].y() ) + return false; + + is_dy_null = true; + } + + if ( ! CGAL_NTS is_zero(direction.z()) ) + { + FT inv_direction_z = FT(1)/direction.z(); + const int sign_z = inv_direction_z < FT(0); + + FT tzmin = (parameters[sign_z].z() - source.z()) * inv_direction_z; + FT tzmax = (parameters[1-sign_z].z() - source.z()) * inv_direction_z; + + if ( !is_dx_null || !is_dy_null ) + { + if (tmin > tzmax || tzmin > tmax) + return false; + } + else + { + if ( tzmax < FT(0) ) + return false; + } + } + else + { + // premature exit if z value of ray is outside bbox + if ( source.z() < parameters[0].z() || source.z() > parameters[1].z() ) + return false; + } + + return true; + } + +} // namespace internal + +template +bool do_intersect(const CGAL::Ray_3& ray, + const CGAL::Bbox_3& bbox) +{ + return typename K::Do_intersect_3()(ray, bbox); +} + +template +bool do_intersect(const CGAL::Bbox_3& bbox, + const CGAL::Ray_3& ray) +{ + return typename K::Do_intersect_3(ray, bbox); +} + +CGAL_END_NAMESPACE + +#endif // CGAL_RAY_3_BBOX_3_DO_INTERSECT_H + + diff --git a/AABB_tree/include/CGAL/AABB_intersections/Bbox_3_segment_3_do_intersect.h b/AABB_tree/include/CGAL/AABB_intersections/Bbox_3_segment_3_do_intersect.h new file mode 100644 index 00000000000..3f61fa42c70 --- /dev/null +++ b/AABB_tree/include/CGAL/AABB_intersections/Bbox_3_segment_3_do_intersect.h @@ -0,0 +1,149 @@ +// Copyright (c) 2008 INRIA Sophia-Antipolis (France), ETH Zurich (Switzerland). +// All rights reserved. +// +// This file is part of CGAL (www.cgal.org); you may redistribute it under +// the terms of the Q Public License version 1.0. +// See the file LICENSE.QPL distributed with CGAL. +// +// Licensees holding a valid commercial license may use this file in +// accordance with the commercial license agreement provided with the software. +// +// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +// +// $URL$ +// $Id$ +// +// +// Author(s) : Camille Wormser, Jane Tournois, Pierre Alliez + + +#ifndef CGAL_SEGMENT_3_BBOX_3_DO_INTERSECT_H +#define CGAL_SEGMENT_3_BBOX_3_DO_INTERSECT_H + +#include +#include + +// inspired from http://cag.csail.mit.edu/~amy/papers/box-jgt.pdf + +CGAL_BEGIN_NAMESPACE + +namespace internal { + + template + bool do_intersect(const typename K::Segment_3& segment, + const CGAL::Bbox_3& bbox, + const K&) + { + typedef typename K::FT FT; + typedef typename K::Point_3 Point; + typedef typename K::Vector_3 Vector; + typedef typename K::Segment_3 Segment; + + Point parameters[2]; + parameters[0] = Point(bbox.xmin(), bbox.ymin(), bbox.zmin()); + parameters[1] = Point(bbox.xmax(), bbox.ymax(), bbox.zmax()); + + const Point source = segment.source(); + const Point target = segment.target(); + + const Vector direction = target - source; + FT tmin(0.0); + FT tmax(1.0); + + if ( ! CGAL_NTS is_zero(direction.x()) ) + { + FT inv_direction_x = FT(1)/direction.x(); + const int sign_x = inv_direction_x < FT(0); + + tmin = (parameters[sign_x].x() - source.x()) * inv_direction_x; + tmax = (parameters[1-sign_x].x() - source.x()) * inv_direction_x; + + // premature exit + if(tmax < FT(0) || tmin > FT(1)) + return false; + + if(tmin < FT(0)) + tmin = FT(0); + if(tmax > FT(1)) + tmax = FT(1); + } + else + { + // premature exit if x value of segment is outside bbox + if ( source.x() < parameters[0].x() || source.x() > parameters[1].x() ) + return false; + } + + if ( ! CGAL_NTS is_zero(direction.y()) ) + { + FT inv_direction_y = FT(1)/direction.y(); + const int sign_y = inv_direction_y < FT(0); + + const FT tymin = (parameters[sign_y].y() - source.y()) * inv_direction_y; + const FT tymax = (parameters[1-sign_y].y() - source.y()) * inv_direction_y; + + if(tmin > tymax || tymin > tmax) + return false; + + if(tymin > tmin) + tmin = tymin; + + if(tymax < tmax) + tmax = tymax; + } + else + { + // premature exit if y value of segment is outside bbox + if ( source.y() < parameters[0].y() || source.y() > parameters[1].y() ) + return false; + } + + if ( ! CGAL_NTS is_zero(direction.z()) ) + { + FT inv_direction_z = FT(1)/direction.z(); + const int sign_z = inv_direction_z < FT(0); + + FT tzmin = (parameters[sign_z].z() - source.z()) * inv_direction_z; + FT tzmax = (parameters[1-sign_z].z() - source.z()) * inv_direction_z; + + if(tmin > tzmax || tzmin > tmax) + return false; + } + else + { + // premature exit if z value of segment is outside bbox + if ( source.z() < parameters[0].z() || source.z() > parameters[1].z() ) + return false; + } + + return true; + } + + template + bool do_intersect(const CGAL::Bbox_3& bbox, + const typename K::Segment_3& segment, + const K& k) + { + return do_intersect(segment, bbox, k); + } + +} // namespace internal + +template +bool do_intersect(const CGAL::Segment_3& segment, + const CGAL::Bbox_3& bbox) +{ + return typename K::Do_intersect_3()(segment, bbox); +} + +template +bool do_intersect(const CGAL::Bbox_3& bbox, + const CGAL::Segment_3& segment) +{ + return typename K::Do_intersect_3()(segment, bbox); +} + +CGAL_END_NAMESPACE + +#endif // CGAL_SEGMENT_3_BBOX_3_DO_INTERSECT_H diff --git a/AABB_tree/include/CGAL/AABB_intersections/Bbox_3_sphere_3_do_intersect.h b/AABB_tree/include/CGAL/AABB_intersections/Bbox_3_sphere_3_do_intersect.h new file mode 100644 index 00000000000..72f6dd9d964 --- /dev/null +++ b/AABB_tree/include/CGAL/AABB_intersections/Bbox_3_sphere_3_do_intersect.h @@ -0,0 +1,116 @@ +// Copyright (c) 2008 INRIA Sophia-Antipolis (France), ETH Zurich (Switzerland). +// All rights reserved. +// +// This file is part of CGAL (www.cgal.org); you may redistribute it under +// the terms of the Q Public License version 1.0. +// See the file LICENSE.QPL distributed with CGAL. +// +// Licensees holding a valid commercial license may use this file in +// accordance with the commercial license agreement provided with the software. +// +// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +// +// $URL$ +// $Id$ +// +// +// Author(s) : Camille Wormser, Jane Tournois, Pierre Alliez + + +#ifndef CGAL_SPHERE_3_BBOX_DO_INTERSECT_H +#define CGAL_SPHERE_3_BBOX_DO_INTERSECT_H + +#include +#include + +#include + + +CGAL_BEGIN_NAMESPACE + +namespace internal { + + template + bool do_intersect(const typename K::Sphere_3& sphere, + const CGAL::Bbox_3& bbox, + const K&) + { + typedef typename K::FT FT; + typedef typename K::Point_3 Point; + FT d = FT(0); + FT distance = FT(0); + Point center = sphere.center(); + + if(center.x() < (FT)bbox.xmin()) + { + d = (FT)bbox.xmin() - center.x(); + distance += d * d; + } + else if(center.x() > (FT)bbox.xmax()) + { + d = center.x() - (FT)bbox.xmax(); + distance += d * d; + } + + if(center.y() < (FT)bbox.ymin()) + { + d = (FT)bbox.ymin() - center.y(); + distance += d * d; + } + else if(center.y() > (FT)bbox.ymax()) + { + d = center.y() - (FT)bbox.ymax(); + distance += d * d; + } + + if(center.z() < (FT)bbox.zmin()) + { + d = (FT)bbox.zmin() - center.z(); + distance += d * d; + } + else if(center.z() > (FT)bbox.zmax()) + { + d = center.z() - (FT)bbox.zmax(); + distance += d * d; + } + + // For unknown reason this causes a syntax error on VC2005 + // but compiles fine on Linux and MAC + //int i; + //for(i = 0; i < 3; ++i) + //{ + // if(center[i] < (FT)bbox.min(i)) + // { + // d = (FT)bbox.min(i) - center[i]; + // distance += d * d; + // } + // else if(center[i] > (FT)bbox.max(i)) + // { + // d = center[i] - (FT)bbox.max(i); + // distance += d * d; + // } + //} + + return distance <= sphere.squared_radius(); + } + +} // namespace internal + +template +bool do_intersect(const CGAL::Sphere_3& sphere, + const CGAL::Bbox_3& bbox) +{ + return typename K::Do_intersect_3()(sphere, bbox); +} + +template +bool do_intersect(const CGAL::Bbox_3& bbox, + const CGAL::Sphere_3& sphere) +{ + return typename K::Do_intersect_3()(sphere, bbox); +} + +CGAL_END_NAMESPACE + +#endif // CGAL_SPHERE_3_BBOX_DO_INTERSECT_H diff --git a/AABB_tree/include/CGAL/AABB_intersections/Bbox_3_triangle_3_do_intersect.h b/AABB_tree/include/CGAL/AABB_intersections/Bbox_3_triangle_3_do_intersect.h new file mode 100644 index 00000000000..358d60d0ba0 --- /dev/null +++ b/AABB_tree/include/CGAL/AABB_intersections/Bbox_3_triangle_3_do_intersect.h @@ -0,0 +1,282 @@ +// Copyright (c) 2008 INRIA Sophia-Antipolis (France), ETH Zurich (Switzerland). +// All rights reserved. +// +// This file is part of CGAL (www.cgal.org); you may redistribute it under +// the terms of the Q Public License version 1.0. +// See the file LICENSE.QPL distributed with CGAL. +// +// Licensees holding a valid commercial license may use this file in +// accordance with the commercial license agreement provided with the software. +// +// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +// +// $URL$ +// $Id$ +// +// +// Author(s) : Camille Wormser, Jane Tournois, Pierre Alliez + +#ifndef CGAL_TRIANGLE_3_BBOX_3_DO_INTERSECT_H +#define CGAL_TRIANGLE_3_BBOX_3_DO_INTERSECT_H + +#include +#include + +// Fast Triangle-Cuboid intersection test, following Tomas Akenine-Moeller description. +// The code looks slightly different from his code because we avoid the translation at +// a minimal cost (and we use C++ ;). + +#include +#include "Bbox_3_plane_3_do_intersect.h" + +CGAL_BEGIN_NAMESPACE + +namespace internal { + + template + inline + bool do_bbox_intersect(const typename K::Triangle_3& triangle, + const CGAL::Bbox_3& bbox) + { + const typename K::Point_3& p = triangle.vertex(0); + const typename K::Point_3& q = triangle.vertex(1); + const typename K::Point_3& r = triangle.vertex(2); + + for(int i = 0; i < 3; ++i) { + if(p[i] <= q[i]) { + if(q[i] <= r[i]) { // pqr + if(bbox.max(i) < p[i] || bbox.min(i) > r[i]) + return false; + } + else { + if(p[i] <= r[i]) { // prq + if(bbox.max(i) < p[i] || bbox.min(i) > q[i]) + return false; + } + else { // rpq + if(bbox.max(i) < r[i] || bbox.min(i) > q[i]) + return false; + } + } + } + else { + if(p[i] <= r[i]) { // qpr + if(bbox.max(i) < q[i] || bbox.min(i) > r[i]) + return false; + } + else { + if(q[i] <= r[i]) { // qrp + if(bbox.max(i) < q[i] || bbox.min(i) > p[i]) + return false; + } + else { // rqp + if(bbox.max(i) < r[i] || bbox.min(i) > p[i]) + return false; + } + } + } + } + return true; + } + + // AXE is the axe such that p is orthogonal to it. + // if you do not know it, or if it does not exist, + // use get_min_max without the AXE template parameter + // available in _plane_is_cuboid_do_intersect.h + template + inline + void get_min_max(const typename K::FT& px, + const typename K::FT& py, + const typename K::FT& pz, + const CGAL::Bbox_3& c, + typename K::Point_3& p_min, + typename K::Point_3& p_max) + { + if(AXE == 0 || px > 0) { + if(AXE == 1 || py > 0) { + if(AXE == 2 || pz > 0) { + p_min = typename K::Point_3(c.xmin(), c.ymin(),c.zmin()); + p_max = typename K::Point_3(c.xmax(), c.ymax(),c.zmax()); + } + else { + p_min = typename K::Point_3(c.xmin(), c.ymin(),c.zmax()); + p_max = typename K::Point_3(c.xmax(), c.ymax(),c.zmin()); + } + } + else { + if(AXE == 2 || pz > 0) { + p_min = typename K::Point_3(c.xmin(), c.ymax(),c.zmin()); + p_max = typename K::Point_3(c.xmax(), c.ymin(),c.zmax()); + } + else { + p_min = typename K::Point_3(c.xmin(), c.ymax(),c.zmax()); + p_max = typename K::Point_3(c.xmax(), c.ymin(),c.zmin()); + } + } + } + else { + if(AXE == 1 || py > 0) { + if(AXE == 2 || pz > 0) { + p_min = typename K::Point_3(c.xmax(), c.ymin(),c.zmin()); + p_max = typename K::Point_3(c.xmin(), c.ymax(),c.zmax()); + } + else { + p_min = typename K::Point_3(c.xmax(), c.ymin(),c.zmax()); + p_max = typename K::Point_3(c.xmin(), c.ymax(),c.zmin()); + } + } + else { + if(AXE == 2 || pz > 0) { + p_min = typename K::Point_3(c.xmax(), c.ymax(),c.zmin()); + p_max = typename K::Point_3(c.xmin(), c.ymin(),c.zmax()); + } + else { + p_min = typename K::Point_3(c.xmax(), c.ymax(),c.zmax()); + p_max = typename K::Point_3(c.xmin(), c.ymin(),c.zmin()); + } + } + } + } + + + template + inline + typename K::FT + do_axis_intersect_aux(const typename K::FT& alpha, + const typename K::FT& beta, + const typename K::Vector_3* sides) + { + switch ( AXE ) + { + case 0: + return -sides[SIDE].z()*alpha + sides[SIDE].y()*beta; + case 1: + return sides[SIDE].z()*alpha - sides[SIDE].x()*beta; + case 2: + return -sides[SIDE].y()*alpha + sides[SIDE].x()*beta; + default: + CGAL_kernel_assertion(false); + return typename K::FT(0.); + } + } + + + template + inline + bool do_axis_intersect(const typename K::Triangle_3& triangle, + const typename K::Vector_3* sides, + const CGAL::Bbox_3& bbox) + { + const typename K::Point_3& j = triangle.vertex(SIDE); + const typename K::Point_3& k = triangle.vertex((SIDE+2)%3); + + typename K::Point_3 p_min, p_max; + get_min_max(AXE==0? 0: AXE==1? sides[SIDE].z(): -sides[SIDE].y(), + AXE==0? -sides[SIDE].z(): AXE==1? 0: sides[SIDE].x(), + AXE==0? sides[SIDE].y(): AXE==1? -sides[SIDE].x(): 0, + bbox, p_min, p_max); + + switch ( AXE ) + { + case 0: + // t_max >= t_min + if ( do_axis_intersect_aux(k.y()-j.y(), k.z()-j.z(), sides) >= 0 ) + { + return ( do_axis_intersect_aux(p_min.y()-k.y(), p_min.z()-k.z(), sides) <= 0 + || do_axis_intersect_aux(p_max.y()-j.y(), p_max.z()-j.z(), sides) >= 0 ); + } + else + { + return ( do_axis_intersect_aux(p_min.y()-j.y(), p_min.z()-j.z(), sides) <= 0 + || do_axis_intersect_aux(p_max.y()-k.y(), p_max.z()-k.z(), sides) >= 0 ); + } + break; + case 1: + // t_max >= t_min + if ( do_axis_intersect_aux(k.x()-j.x(), k.z()-j.z(), sides) >= 0 ) + { + return ( do_axis_intersect_aux(p_min.x()-k.x(), p_min.z()-k.z(), sides) <= 0 + || do_axis_intersect_aux(p_max.x()-j.x(), p_max.z()-j.z(), sides) >= 0 ); + } + else + { + return ( do_axis_intersect_aux(p_min.x()-j.x(), p_min.z()-j.z(), sides) <= 0 + || do_axis_intersect_aux(p_max.x()-k.x(), p_max.z()-k.z(), sides) >= 0 ); + } + break; + case 2: + // t_max >= t_min + if ( do_axis_intersect_aux(k.x()-j.x(), k.y()-j.y(), sides) >= 0 ) + { + return ( do_axis_intersect_aux(p_min.x()-k.x(), p_min.y()-k.y(), sides) <= 0 + || do_axis_intersect_aux(p_max.x()-j.x(), p_max.y()-j.y(), sides) >= 0 ); + } + else + { + return ( do_axis_intersect_aux(p_min.x()-j.x(), p_min.y()-j.y(), sides) <= 0 + || do_axis_intersect_aux(p_max.x()-k.x(), p_max.y()-k.y(), sides) >= 0 ); + } + break; + default: + // Should not happen + CGAL_kernel_assertion(false); + return false; + } + } + + // assumes that the intersection with the supporting plane has + // already been checked. + template + bool do_intersect(const typename K::Triangle_3& triangle, + const CGAL::Bbox_3& bbox, + const K&) + { + if(! do_bbox_intersect(triangle, bbox)) + return false; + + typename K::Vector_3 sides[3]; + sides[0] = triangle[1] - triangle[0]; + sides[1] = triangle[2] - triangle[1]; + sides[2] = triangle[0] - triangle[2]; + + if(! do_axis_intersect(triangle, sides, bbox)) + return false; + if(! do_axis_intersect(triangle, sides, bbox)) + return false; + if(! do_axis_intersect(triangle, sides, bbox)) + return false; + if(! do_axis_intersect(triangle, sides, bbox)) + return false; + if(! do_axis_intersect(triangle, sides, bbox)) + return false; + if(! do_axis_intersect(triangle, sides, bbox)) + return false; + if(! do_axis_intersect(triangle, sides, bbox)) + return false; + if(! do_axis_intersect(triangle, sides, bbox)) + return false; + if(! do_axis_intersect(triangle, sides, bbox)) + return false; + return true; + } + +} // namespace internal + +template +bool do_intersect(const CGAL::Triangle_3& triangle, + const CGAL::Bbox_3& bbox) +{ + return typename K::Do_intersect_3()(triangle, bbox); +} + +template +bool do_intersect(const CGAL::Bbox_3& bbox, + const CGAL::Triangle_3& triangle) +{ + return typename K::Do_intersect_3()(triangle, bbox); +} + +CGAL_END_NAMESPACE + +#endif // CGAL_TRIANGLE_3_BBOX_3_DO_INTERSECT_H diff --git a/AABB_tree/include/CGAL/AABB_intersections/Triangle_3_line_3_intersection.h b/AABB_tree/include/CGAL/AABB_intersections/Triangle_3_line_3_intersection.h new file mode 100644 index 00000000000..ac56c56cb62 --- /dev/null +++ b/AABB_tree/include/CGAL/AABB_intersections/Triangle_3_line_3_intersection.h @@ -0,0 +1,419 @@ +// Copyright (c) 2009 INRIA Sophia-Antipolis (France). +// All rights reserved. +// +// This file is part of CGAL (www.cgal.org); you may redistribute it under +// the terms of the Q Public License version 1.0. +// See the file LICENSE.QPL distributed with CGAL. +// +// Licensees holding a valid commercial license may use this file in +// accordance with the commercial license agreement provided with the software. +// +// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +// +// $URL$ +// $Id$ +// +// +// Author(s) : Stéphane Tayeb +// +//****************************************************************************** +// File Description : +// +//****************************************************************************** + +#ifndef TRIANGLE_3_LINE_3_INTERSECTION_H_ +#define TRIANGLE_3_LINE_3_INTERSECTION_H_ + +#include +#include + +namespace CGAL { +namespace internal { + + +template +Object +t3l3_intersection_coplanar_aux(const typename K::Point_3& a, + const typename K::Point_3& b, + const typename K::Point_3& c, + const typename K::Line_3& l, + const bool negative_side, + const K& k) +{ + // This function is designed to clip pq into the triangle abc. + // Point configuration should be as follows + // + // +q + // | +a + // | + // +c | +b + // | + // +p + // + // We know that c is isolated on the negative side of pq + + typedef typename K::Point_3 Point_3; + + typename K::Intersect_3 intersection = + k.intersect_3_object(); + + typename K::Construct_line_3 line = + k.construct_line_3_object(); + + typename K::Construct_segment_3 segment = + k.construct_segment_3_object(); + + // Let's get the intersection points + Object l_bc_obj = intersection(l,line(b,c)); + const Point_3* l_bc = object_cast(&l_bc_obj); + if ( NULL == l_bc ) + { + CGAL_kernel_assertion(false); + return Object(); + } + + Object l_ca_obj = intersection(l,line(c,a)); + const Point_3* l_ca = object_cast(&l_ca_obj); + if ( NULL == l_ca ) + { + CGAL_kernel_assertion(false); + return Object(); + } + + if ( negative_side ) + return make_object(segment(*l_bc, *l_ca)); + else + return make_object(segment(*l_ca, *l_bc)); +} + + +template +Object +intersection_coplanar(const typename K::Triangle_3 &t, + const typename K::Line_3 &l, + const K & k ) +{ + + CGAL_kernel_precondition( ! k.is_degenerate_3_object()(t) ) ; + CGAL_kernel_precondition( ! k.is_degenerate_3_object()(l) ) ; + + typedef typename K::Point_3 Point_3; + + + typename K::Construct_point_on_3 point_on = + k.construct_point_on_3_object(); + + typename K::Construct_vertex_3 vertex_on = + k.construct_vertex_3_object(); + + typename K::Coplanar_orientation_3 coplanar_orientation = + k.coplanar_orientation_3_object(); + + typename K::Construct_line_3 line = + k.construct_line_3_object(); + + typename K::Construct_segment_3 segment = + k.construct_segment_3_object(); + + + const Point_3 & p = point_on(l,0); + const Point_3 & q = point_on(l,1); + + const Point_3 & A = vertex_on(t,0); + const Point_3 & B = vertex_on(t,1); + const Point_3 & C = vertex_on(t,2); + + int k0 = 0; + int k1 = 1; + int k2 = 2; + + // Determine the orientation of the triangle in the common plane + if (coplanar_orientation(A,B,C) != POSITIVE) + { + // The triangle is not counterclockwise oriented + // swap two vertices. + std::swap(k1,k2); + } + + const Point_3& a = vertex_on(t,k0); + const Point_3& b = vertex_on(t,k1); + const Point_3& c = vertex_on(t,k2); + + // Test whether the segment's supporting line intersects the + // triangle in the common plane + const Orientation pqa = coplanar_orientation(p,q,a); + const Orientation pqb = coplanar_orientation(p,q,b); + const Orientation pqc = coplanar_orientation(p,q,c); + + + switch ( pqa ) { + // ----------------------------------- + // pqa POSITIVE + // ----------------------------------- + case POSITIVE: + switch ( pqb ) { + case POSITIVE: + switch ( pqc ) { + case POSITIVE: + // the triangle lies in the positive halfspace + // defined by the segment's supporting line. + return Object(); + case NEGATIVE: + // c is isolated on the negative side + return t3l3_intersection_coplanar_aux(a,b,c,l,true,k); + case COLLINEAR: + return make_object(c); + } + + case NEGATIVE: + if ( POSITIVE == pqc ) + // b is isolated on the negative side + return t3l3_intersection_coplanar_aux(c,a,b,l,true,k); + else + // a is isolated on the positive side (here mb c could be use as + // an endpoint instead of computing an intersection is some cases) + return t3l3_intersection_coplanar_aux(b,c,a,l,false,k); + + case COLLINEAR: + switch ( pqc ) { + case POSITIVE: + return make_object(b); + case NEGATIVE: + // a is isolated on the positive side (here mb b could be use as + // an endpoint instead of computing an intersection) + return t3l3_intersection_coplanar_aux(b,c,a,l,false,k); + case COLLINEAR: + // b,c,p,q are aligned, [p,q]&[b,c] have the same direction + return make_object(segment(b,c)); + } + + default: // should not happen. + CGAL_kernel_assertion(false); + return Object(); + } + + // ----------------------------------- + // pqa NEGATIVE + // ----------------------------------- + case NEGATIVE: + switch ( pqb ) { + case POSITIVE: + if ( POSITIVE == pqc ) + // a is isolated on the negative side + return t3l3_intersection_coplanar_aux(b,c,a,l,true,k); + else + // b is isolated on the positive side (here mb c could be use as + // an endpoint instead of computing an intersection, in some cases) + return t3l3_intersection_coplanar_aux(c,a,b,l,false,k); + + case NEGATIVE: + switch ( pqc ) { + case POSITIVE: + // c is isolated on the positive side + return t3l3_intersection_coplanar_aux(a,b,c,l,false,k); + case NEGATIVE: + // the triangle lies in the negative halfspace + // defined by the segment's supporting line. + return Object(); + case COLLINEAR: + return make_object(c); + } + + case COLLINEAR: + switch ( pqc ) { + case POSITIVE: + // a is isolated on the negative side (here mb b could be use as + // an endpoint instead of computing an intersection) + return t3l3_intersection_coplanar_aux(b,c,a,l,true,k); + case NEGATIVE: + return make_object(b); + case COLLINEAR: + // b,c,p,q are aligned, [p,q]&[c,b] have the same direction + return make_object(segment(c,b)); + } + + default: // should not happen. + CGAL_kernel_assertion(false); + return Object(); + } + + // ----------------------------------- + // pqa COLLINEAR + // ----------------------------------- + case COLLINEAR: + switch ( pqb ) { + case POSITIVE: + switch ( pqc ) { + case POSITIVE: + return make_object(a); + case NEGATIVE: + // b is isolated on the positive side (here mb a could be use as + // an endpoint instead of computing an intersection) + return t3l3_intersection_coplanar_aux(c,a,b,l,false,k); + case COLLINEAR: + // a,c,p,q are aligned, [p,q]&[c,a] have the same direction + return make_object(segment(c,a)); + } + + case NEGATIVE: + switch ( pqc ) { + case POSITIVE: + // b is isolated on the negative side (here mb a could be use as + // an endpoint instead of computing an intersection) + return t3l3_intersection_coplanar_aux(c,a,b,l,true,k); + case NEGATIVE: + return make_object(a); + case COLLINEAR: + // a,c,p,q are aligned, [p,q]&[a,c] have the same direction + return make_object(segment(a,c)); + } + + case COLLINEAR: + switch ( pqc ) { + case POSITIVE: + // a,b,p,q are aligned, [p,q]&[a,b] have the same direction + return make_object(segment(a,b)); + case NEGATIVE: + // a,b,p,q are aligned, [p,q]&[b,a] have the same direction + return make_object(segment(b,a)); + case COLLINEAR: + // case pqc == COLLINEAR is impossible since the triangle is + // assumed to be non flat + CGAL_kernel_assertion(false); + return Object(); + } + + default: // should not happen. + CGAL_kernel_assertion(false); + return Object(); + + } + + default:// should not happen. + CGAL_kernel_assertion(false); + return Object(); + + } +} + + + + + + + +template +Object +intersection(const typename K::Triangle_3 &t, + const typename K::Line_3 &l, + const K& k) +{ + CGAL_kernel_precondition( ! k.is_degenerate_3_object()(t) ) ; + CGAL_kernel_precondition( ! k.is_degenerate_3_object()(l) ) ; + + typedef typename K::Point_3 Point_3; + + typename K::Construct_point_on_3 point_on = + k.construct_point_on_3_object(); + + typename K::Construct_vertex_3 vertex_on = + k.construct_vertex_3_object(); + + typename K::Orientation_3 orientation = + k.orientation_3_object(); + + typename K::Coplanar_orientation_3 coplanar_orientation = + k.coplanar_orientation_3_object(); + + typename K::Intersect_3 intersection = + k.intersect_3_object(); + + const Point_3 & a = vertex_on(t,0); + const Point_3 & b = vertex_on(t,1); + const Point_3 & c = vertex_on(t,2); + const Point_3 & p = point_on(l,0); + const Point_3 & q = point_on(l,1); + + if ( ( orientation(a,b,c,p) != COPLANAR ) + || ( orientation(a,b,c,q) != COPLANAR ) ) + { + const Orientation pqab = orientation(p,q,a,b); + const Orientation pqbc = orientation(p,q,b,c); + + switch ( pqab ) { + case POSITIVE: + if ( pqbc != NEGATIVE && orientation(p,q,c,a) != NEGATIVE ) + return intersection(l,t.supporting_plane()); + else + return Object(); + + case NEGATIVE: + if ( pqbc != POSITIVE && orientation(p,q,c,a) != POSITIVE ) + return intersection(l,t.supporting_plane()); + else + return Object(); + + case COPLANAR: + switch ( pqbc ) { + case POSITIVE: + if ( orientation(p,q,c,a) != NEGATIVE ) + return intersection(l,t.supporting_plane()); + else + return Object(); + + case NEGATIVE: + if ( orientation(p,q,c,a) != POSITIVE ) + return intersection(l,t.supporting_plane()); + else + return Object(); + + case COPLANAR: // pqa or pqb or pqc are collinear + return intersection(l,t.supporting_plane()); + + default: // should not happen. + CGAL_kernel_assertion(false); + return Object(); + } + + default: // should not happen. + CGAL_kernel_assertion(false); + return Object(); + } + } + + // Coplanar case + return intersection_coplanar(t,l,k); +} + +template +Object +intersection(const typename K::Line_3 &l, + const typename K::Triangle_3 &t, + const K& k) +{ + return internal::intersection(t,l,k); +} + + +} // end namespace internal + +template +inline +Object +intersection(const Triangle_3 &t, const Line_3 &l) +{ + return typename K::Intersect_3()(t,l); +} + +template +inline +Object +intersection(const Line_3 &l, const Triangle_3 &t) +{ + return typename K::Intersect_3()(t,l); +} + +} // end namespace CGAL + +#endif // TRIANGLE_3_LINE_3_INTERSECTION_H_ diff --git a/AABB_tree/include/CGAL/AABB_intersections/Triangle_3_plane_3_intersection.h b/AABB_tree/include/CGAL/AABB_intersections/Triangle_3_plane_3_intersection.h new file mode 100644 index 00000000000..54810da94f6 --- /dev/null +++ b/AABB_tree/include/CGAL/AABB_intersections/Triangle_3_plane_3_intersection.h @@ -0,0 +1,187 @@ +// Copyright (c) 2003 INRIA Sophia-Antipolis (France). +// Copyright (c) 2009 GeometryFactory (France). +// All rights reserved. +// +// This file is part of CGAL (www.cgal.org); you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation; version 2.1 of the License. +// See the file LICENSE.LGPL distributed with CGAL. +// +// Licensees holding a valid commercial license may use this file in +// accordance with the commercial license agreement provided with the software. +// +// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +// +// $URL$ +// $Id$ +// +// +// Adapted from +// +// Author(s) : Philippe Guigue, Laurent Rineau + +#ifndef CGAL_TRIANGLE_3_PLANE_3_INTERSECTION_H +#define CGAL_TRIANGLE_3_PLANE_3_INTERSECTION_H + +#include +#include + +namespace CGAL { + +namespace internal { + +template +inline +typename K::Point_3 +inter_plane_triangle_3_aux(const typename K::Point_3 &p1, + const typename K::RT & f1, + const typename K::Point_3 &p2, + const typename K::RT & f2) +{ + return typename K::Point_3(f2 * p1.x() - f1 * p2.x(), + f2 * p1.y() - f1 * p2.y(), + f2 * p1.z() - f1 * p2.z(), + f2 - f1); +} + +template +Object +intersection(const typename K::Plane_3 &plane, + const typename K::Triangle_3 &triangle, + const K& k) +{ + CGAL_kernel_precondition( ! k.is_degenerate_3_object()(triangle)) ; + CGAL_kernel_precondition( ! k.is_degenerate_3_object()(plane)) ; + + typedef typename K::Point_3 Point_3; + typedef typename K::Segment_3 Segment_3; + typedef typename K::Object_3 Object_3; + typedef typename K::RT RT; + typedef typename Sgn::result_type SignRT; + + typename K::Construct_vertex_3 vertex_on = + k.construct_vertex_3_object(); + + //typename K::Oriented_side_3 oriented_side = + //k.oriented_side_3_object(); // PA: never used + + typename K::Construct_segment_3 segment = + k.construct_segment_3_object(); + + typename K::Construct_object_3 make_object = + k.construct_object_3_object(); + + const Point_3& t0 = vertex_on(triangle,0); + const Point_3& t1 = vertex_on(triangle,1); + const Point_3& t2 = vertex_on(triangle,2); + + const RT f0 = plane.a()*t0.hx() + plane.b()*t0.hy() + + plane.c()*t0.hz() + wmult_hw((K*)0, plane.d(), t0); + const RT f1 = plane.a()*t1.hx() + plane.b()*t1.hy() + + plane.c()*t1.hz() + wmult_hw((K*)1, plane.d(), t1); + const RT f2 = plane.a()*t2.hx() + plane.b()*t2.hy() + + plane.c()*t2.hz() + wmult_hw((K*)2, plane.d(), t2); + + const SignRT s0 = CGAL_NTS sign(f0); + const SignRT s1 = CGAL_NTS sign(f1); + const SignRT s2 = CGAL_NTS sign(f2); + + if(s0 == ZERO) { + if(s1 == ZERO) { + if(s2 == ZERO) { + // all zero + return make_object(triangle); + } + else { + // s0, s1 zero + return make_object(segment(t0, t1)); + } + } + else if(s2 == ZERO) { + // s0, s2 zero + return make_object(segment(t0, t2)); + } + else { + // s0 zero + return make_object(t0); + } + } + else { + if(s1 == ZERO) { + if(s2 == ZERO) { + // s1, s2 zero + return make_object(segment(t1, t2)); + } + else { + // s1 zero + return make_object(t1); + } + } + else if( s2 == ZERO ) { + // s2 zero + return make_object(t2); + } + else { + // all non-zero + if(s0 == s1) { + if(s0 == s2) { + return Object_3(); + } + else { + // s0 and s1 on same side, s2 different + return make_object(segment(inter_plane_triangle_3_aux(t0, f0, + t2, f2), + inter_plane_triangle_3_aux(t1, f1, + t2, f2))); + } + } + else if(s0 == s2) { + // s0 and s2 on same side, s1 different + return make_object(segment(inter_plane_triangle_3_aux(t1, f1, + t2, f2), + inter_plane_triangle_3_aux(t1, f1, + t0, f0))); + } + else { + // s1 and s2 on same side, s0 different + return make_object(segment(inter_plane_triangle_3_aux(t0, f0, + t2, f2), + inter_plane_triangle_3_aux(t0, f0, + t1, f1))); + } + } + } +} // end function internal::intersection(Plane, Triangle) + +template +inline +Object +intersection(const typename K::Triangle_3 &triangle, + const typename K::Plane_3 &plane, + const K& k) +{ + return intersection(plane, triangle, k); +} + +} // end namespace internal + +template +inline +Object +intersection(const Plane_3 &plane, const Triangle_3 &triangle) +{ + return typename K::Intersect_3()(plane, triangle); +} + +template +inline +Object +intersection(const Triangle_3 &triangle, const Plane_3 &plane) +{ + return typename K::Intersect_3()(plane, triangle); +} + +} // end namespace CGAL + +#endif // CGAL_TRIANGLE_3_PLANE_3_INTERSECTION_H diff --git a/AABB_tree/include/CGAL/AABB_intersections/Triangle_3_ray_3_intersection.h b/AABB_tree/include/CGAL/AABB_intersections/Triangle_3_ray_3_intersection.h new file mode 100644 index 00000000000..f97f60c95a5 --- /dev/null +++ b/AABB_tree/include/CGAL/AABB_intersections/Triangle_3_ray_3_intersection.h @@ -0,0 +1,166 @@ +// Copyright (c) 2009 GeometryFactory (France). +// All rights reserved. +// +// This file is part of CGAL (www.cgal.org); you may redistribute it under +// the terms of the Q Public License version 1.0. +// See the file LICENSE.QPL distributed with CGAL. +// +// Licensees holding a valid commercial license may use this file in +// accordance with the commercial license agreement provided with the software. +// +// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +// +// $URL$ +// $Id$ +// +// +// Author(s) : Laurent Rineau + +#ifndef CGAL_TRIANGLE_3_RAY_3_INTERSECTION_H +#define CGAL_TRIANGLE_3_RAY_3_INTERSECTION_H + +#include +#include + +namespace CGAL { +namespace internal { + + + +template +Object +intersection_triangle_ray_aux(const typename K::Ray_3 &r, + const typename K::Segment_3 &s, + const K& k) +{ + typedef typename K::Point_3 Point_3; + + typename K::Has_on_3 has_on = k.has_on_3_object(); + typename K::Construct_object_3 make_object = k.construct_object_3_object(); + typename K::Construct_direction_3 direction = k.construct_direction_3_object(); + typename K::Construct_segment_3 make_segment = k.construct_segment_3_object(); + // typename K::Compare_xyz_3 compare = k.compare_xyz_3_object(); // PA: never used + typename K::Equal_3 equal = k.equal_3_object(); + + const Point_3& p = r.source(); + const Point_3& q1 = s.source(); + const Point_3& q2 = s.target(); + + if ( ! has_on(s,p) ) + return make_object(s); + + if ( equal(p,q1) || equal(p,q2) ) + return make_object(p); + + if ( direction(r) == direction(s) ) + return make_object(make_segment(p,q2)); + else + return make_object(make_segment(p,q1)); +} + + +template +Object +intersection(const typename K::Triangle_3 &t, + const typename K::Ray_3 &r, + const K& k) +{ + typedef typename K::Point_3 Point_3; + typedef typename K::Segment_3 Segment_3; + typedef typename K::Object_3 Object_3; + typedef typename K::Ray_3 Ray_3; + typedef typename K::Line_3 Line_3; + + + if ( !CGAL::do_intersect(t, r) ) + return Object_3(); + + // TOFIX: here we assume that we have already tested + // do_intersect between the triangle and the ray + const Object intersection = CGAL::intersection(t.supporting_plane(), + r); + + // intersection is either a point, either a ray + // if it is a ray, then we need to clip it to a segment + if ( const Ray_3* ray = object_cast(&intersection)) + { + typename K::Intersect_3 intersect = k.intersect_3_object(); + typename K::Construct_line_3 f_line = k.construct_line_3_object(); + typename K::Construct_vertex_3 vertex_on = k.construct_vertex_3_object(); + typename K::Construct_object_3 make_object = k.construct_object_3_object(); + typename K::Construct_segment_3 f_segment = k.construct_segment_3_object(); + typename K::Has_on_3 has_on = k.has_on_3_object(); + + const Point_3& t0 = vertex_on(t,0); + const Point_3& t1 = vertex_on(t,1); + const Point_3& t2 = vertex_on(t,2); + + const Line_3 l01 = f_line(t0,t1); + const Line_3 l02 = f_line(t0,t2); + const Line_3 l12 = f_line(t1,t2); + + const Segment_3 s01 = f_segment(t0,t1); + const Segment_3 s02 = f_segment(t0,t2); + const Segment_3 s12 = f_segment(t1,t2); + + const Line_3 lr = ray->supporting_line(); + + const Object_3 inter_01 = intersect(l01,lr); + const Object_3 inter_02 = intersect(l02,lr); + const Object_3 inter_12 = intersect(l12,lr); + + const Point_3* p01 = object_cast(&inter_01); + const Point_3* p02 = object_cast(&inter_02); + const Point_3* p12 = object_cast(&inter_12); + + if ( p01 && has_on(s01, *p01) ) + { + if ( p02 && has_on(s02, *p02) ) + return intersection_triangle_ray_aux(*ray, f_segment(*p01,*p02), k); + else if ( p12 && has_on(s12, *p12) ) + return intersection_triangle_ray_aux(*ray, f_segment(*p01,*p12), k); + else + return make_object(*p01); + } + else if ( p02 && has_on(s02, *p02) ) + { + if ( p12 && has_on(s12, *p12) ) + return intersection_triangle_ray_aux(*ray, f_segment(*p02,*p12), k); + else + return make_object(*p02); + } + else if ( p12 && has_on(s12, *p12) ) + { + return make_object(*p12); + } + + // should not happen + CGAL_kernel_assertion(false); + return Object_3(); + } + else + return intersection; +} + +} // end namespace internal + +template +inline +Object +intersection(const Triangle_3 &t, const Ray_3 &r) +{ + return typename K::Intersect_3()(t, r); +} + +template +inline +Object +intersection(const Ray_3 &r, const Triangle_3 &t) +{ + return typename K::Intersect_3()(t, r); +} + +} // end namespace CGAL + +#endif // CGAL_TRIANGLE_3_RAY_3_INTERSECTION_H diff --git a/AABB_tree/include/CGAL/AABB_intersections/Triangle_3_segment_3_intersection.h b/AABB_tree/include/CGAL/AABB_intersections/Triangle_3_segment_3_intersection.h new file mode 100644 index 00000000000..8e35ab9c582 --- /dev/null +++ b/AABB_tree/include/CGAL/AABB_intersections/Triangle_3_segment_3_intersection.h @@ -0,0 +1,542 @@ +// Copyright (c) 2009 GeometryFactory (France), INRIA Sophia-Antipolis (France). +// All rights reserved. +// +// This file is part of CGAL (www.cgal.org); you may redistribute it under +// the terms of the Q Public License version 1.0. +// See the file LICENSE.QPL distributed with CGAL. +// +// Licensees holding a valid commercial license may use this file in +// accordance with the commercial license agreement provided with the software. +// +// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +// +// $URL$ +// $Id$ +// +// +// Author(s) : Laurent Rineau, Stephane Tayeb +// +//****************************************************************************** +// File Description : Implements triangle_3 segment_3 intersection construction. +// +// This implementation is adapted from Triangle_3_Segment_3_do_intersect.h. +//****************************************************************************** + + +#ifndef CGAL_TRIANGLE_3_SEGMENT_3_INTERSECTION_H +#define CGAL_TRIANGLE_3_SEGMENT_3_INTERSECTION_H + +#include +#include + +namespace CGAL { +namespace internal { + + +template +Object +t3s3_intersection_coplanar_aux(const typename K::Point_3& a, + const typename K::Point_3& b, + const typename K::Point_3& c, + const typename K::Point_3& p, + const typename K::Point_3& q, + const bool negative_side, + const K& k) +{ + // This function is designed to clip pq into the triangle abc. + // Point configuration should be as follows + // + // +q + // | +a + // | + // +c | +b + // | + // +p + // + // We know that c is isolated on the negative side of pq, but we don't know + // p position wrt [bc]&[ca] and q position wrt [bc]&[ca] + + typedef typename K::Point_3 Point_3; + + typename K::Coplanar_orientation_3 coplanar_orientation = + k.coplanar_orientation_3_object(); + + typename K::Intersect_3 intersection = + k.intersect_3_object(); + + typename K::Construct_line_3 line = + k.construct_line_3_object(); + + typename K::Construct_segment_3 segment = + k.construct_segment_3_object(); + + const Orientation bcq = coplanar_orientation(b,c,q); + const Orientation cap = coplanar_orientation(c,a,p); + + if ( NEGATIVE == bcq || NEGATIVE == cap ) + return Object(); + else if ( COLLINEAR == bcq ) + // q is inside [c,b], p is outside t (because of pqc) + return make_object(q); + else if ( COLLINEAR == cap ) + // p is inside [c,a], q is outside t (because of pqc) + return make_object(p); + else // bcq == POSITIVE && cap == POSITIVE + { + // Here we know the intersection is not empty + // Let's get the intersection points + Point_3 p_side_end_point(p); + if ( NEGATIVE == coplanar_orientation(b,c,p) ) + { + Object obj = intersection(line(p,q),line(b,c)); + const Point_3* p_temp = object_cast(&obj); + if ( NULL != p_temp ) + p_side_end_point = *p_temp; + } + + Point_3 q_side_end_point(q); + if ( NEGATIVE == coplanar_orientation(c,a,q) ) + { + Object obj = intersection(line(p,q),line(c,a)); + const Point_3* p_temp = object_cast(&obj); + if ( NULL != p_temp ) + q_side_end_point = *p_temp; + } + + if ( negative_side ) + return make_object(segment(p_side_end_point, q_side_end_point)); + else + return make_object(segment(q_side_end_point, p_side_end_point)); + } +} + + +template +Object +t3s3_intersection_coplanar_aux(const typename K::Point_3& a, + const typename K::Point_3& b, + const typename K::Point_3& p, + const typename K::Point_3& q, + const K& k) +{ + // Builds resulting segment of intersection of [a,b] and [p,q] + // Precondition: [a,b] and [p,q] have the same direction + + typename K::Construct_segment_3 segment = + k.construct_segment_3_object(); + + typename K::Collinear_are_ordered_along_line_3 collinear_ordered = + k.collinear_are_ordered_along_line_3_object(); + + // possible orders: [p,a,b,q], [p,a,q,b], [a,p,b,q], [a,p,q,b] + if ( collinear_ordered(p,a,q) ) + { + // p is before a + if ( collinear_ordered(p,b,q) ) + return make_object(segment(a,b)); + else + return make_object(segment(a,q)); + } + else + { + // p is after a + if ( collinear_ordered(p,b,q) ) + return make_object(segment(p,b)); + else + return make_object(segment(p,q)); + } + +} + +template +Object +intersection_coplanar(const typename K::Triangle_3 &t, + const typename K::Segment_3 &s, + const K & k ) +{ + + CGAL_kernel_precondition( ! k.is_degenerate_3_object()(t) ) ; + CGAL_kernel_precondition( ! k.is_degenerate_3_object()(s) ) ; + + typedef typename K::Point_3 Point_3; + + + typename K::Construct_point_on_3 point_on = + k.construct_point_on_3_object(); + + typename K::Construct_vertex_3 vertex_on = + k.construct_vertex_3_object(); + + typename K::Coplanar_orientation_3 coplanar_orientation = + k.coplanar_orientation_3_object(); + + typename K::Collinear_are_ordered_along_line_3 collinear_ordered = + k.collinear_are_ordered_along_line_3_object(); + + typename K::Construct_line_3 line = + k.construct_line_3_object(); + + typename K::Construct_segment_3 segment = + k.construct_segment_3_object(); + + + const Point_3 & p = point_on(s,0); + const Point_3 & q = point_on(s,1); + + const Point_3 & A = vertex_on(t,0); + const Point_3 & B = vertex_on(t,1); + const Point_3 & C = vertex_on(t,2); + + int k0 = 0; + int k1 = 1; + int k2 = 2; + + // Determine the orientation of the triangle in the common plane + if (coplanar_orientation(A,B,C) != POSITIVE) + { + // The triangle is not counterclockwise oriented + // swap two vertices. + std::swap(k1,k2); + } + + const Point_3& a = vertex_on(t,k0); + const Point_3& b = vertex_on(t,k1); + const Point_3& c = vertex_on(t,k2); + + // Test whether the segment's supporting line intersects the + // triangle in the common plane + const Orientation pqa = coplanar_orientation(p,q,a); + const Orientation pqb = coplanar_orientation(p,q,b); + const Orientation pqc = coplanar_orientation(p,q,c); + + + switch ( pqa ) { + // ----------------------------------- + // pqa POSITIVE + // ----------------------------------- + case POSITIVE: + switch ( pqb ) { + case POSITIVE: + switch ( pqc ) { + case POSITIVE: + // the triangle lies in the positive halfspace + // defined by the segment's supporting line. + return Object(); + case NEGATIVE: + // c is isolated on the negative side + return t3s3_intersection_coplanar_aux(a,b,c,p,q,true,k); + case COLLINEAR: + if ( collinear_ordered(p,c,q) ) // c is inside [p,q] + return make_object(c); + else + return Object(); + } + + case NEGATIVE: + if ( POSITIVE == pqc ) + // b is isolated on the negative side + return t3s3_intersection_coplanar_aux(c,a,b,p,q,true,k); + else + // a is isolated on the positive side + return t3s3_intersection_coplanar_aux(b,c,a,q,p,false,k); + + case COLLINEAR: + switch ( pqc ) { + case POSITIVE: + if ( collinear_ordered(p,b,q) ) // b is inside [p,q] + return make_object(b); + else + return Object(); + case NEGATIVE: + // a is isolated on the positive side + return t3s3_intersection_coplanar_aux(b,c,a,q,p,false,k); + case COLLINEAR: + // b,c,p,q are aligned, [p,q]&[b,c] have the same direction + return t3s3_intersection_coplanar_aux(b,c,p,q,k); + } + + default: // should not happen. + CGAL_kernel_assertion(false); + return Object(); + } + + // ----------------------------------- + // pqa NEGATIVE + // ----------------------------------- + case NEGATIVE: + switch ( pqb ) { + case POSITIVE: + if ( POSITIVE == pqc ) + // a is isolated on the negative side + return t3s3_intersection_coplanar_aux(b,c,a,p,q,true,k); + else + // b is isolated on the positive side + return t3s3_intersection_coplanar_aux(c,a,b,q,p,false,k); + + case NEGATIVE: + switch ( pqc ) { + case POSITIVE: + // c is isolated on the positive side + return t3s3_intersection_coplanar_aux(a,b,c,q,p,false,k); + case NEGATIVE: + // the triangle lies in the negative halfspace + // defined by the segment's supporting line. + return Object(); + case COLLINEAR: + if ( collinear_ordered(p,c,q) ) // c is inside [p,q] + return make_object(c); + else + return Object(); + } + + case COLLINEAR: + switch ( pqc ) { + case POSITIVE: + // a is isolated on the negative side + return t3s3_intersection_coplanar_aux(b,c,a,p,q,true,k); + case NEGATIVE: + if ( collinear_ordered(p,b,q) ) // b is inside [p,q] + return make_object(b); + else + return Object(); + case COLLINEAR: + // b,c,p,q are aligned, [p,q]&[c,b] have the same direction + return t3s3_intersection_coplanar_aux(c,b,p,q,k); + } + + default: // should not happen. + CGAL_kernel_assertion(false); + return Object(); + } + + // ----------------------------------- + // pqa COLLINEAR + // ----------------------------------- + case COLLINEAR: + switch ( pqb ) { + case POSITIVE: + switch ( pqc ) { + case POSITIVE: + if ( collinear_ordered(p,a,q) ) // a is inside [p,q] + return make_object(a); + else + return Object(); + case NEGATIVE: + // b is isolated on the positive side + return t3s3_intersection_coplanar_aux(c,a,b,q,p,false,k); + case COLLINEAR: + // a,c,p,q are aligned, [p,q]&[c,a] have the same direction + return t3s3_intersection_coplanar_aux(c,a,p,q,k); + } + + case NEGATIVE: + switch ( pqc ) { + case POSITIVE: + // b is isolated on the negative side + return t3s3_intersection_coplanar_aux(c,a,b,p,q,true,k); + case NEGATIVE: + if ( collinear_ordered(p,a,q) ) // a is inside [p,q] + return make_object(a); + else + return Object(); + case COLLINEAR: + // a,c,p,q are aligned, [p,q]&[a,c] have the same direction + return t3s3_intersection_coplanar_aux(a,c,p,q,k); + } + + case COLLINEAR: + switch ( pqc ) { + case POSITIVE: + // a,b,p,q are aligned, [p,q]&[a,b] have the same direction + return t3s3_intersection_coplanar_aux(a,b,p,q,k); + case NEGATIVE: + // a,b,p,q are aligned, [p,q]&[b,a] have the same direction + return t3s3_intersection_coplanar_aux(b,a,p,q,k); + case COLLINEAR: + // case pqc == COLLINEAR is impossible since the triangle is + // assumed to be non flat + CGAL_kernel_assertion(false); + return Object(); + } + + default: // should not happen. + CGAL_kernel_assertion(false); + return Object(); + + } + + default:// should not happen. + CGAL_kernel_assertion(false); + return Object(); + + } +} + + +template +Object +intersection(const typename K::Triangle_3 &t, + const typename K::Segment_3 &s, + const K & k) +{ + + CGAL_kernel_precondition( ! k.is_degenerate_3_object()(t) ) ; + CGAL_kernel_precondition( ! k.is_degenerate_3_object()(s) ) ; + + typedef typename K::Point_3 Point_3; + + + typename K::Construct_point_on_3 point_on = + k.construct_point_on_3_object(); + + typename K::Construct_vertex_3 vertex_on = + k.construct_vertex_3_object(); + + typename K::Orientation_3 orientation = + k.orientation_3_object(); + + typename K::Intersect_3 intersection = + k.intersect_3_object(); + + const Point_3 & a = vertex_on(t,0); + const Point_3 & b = vertex_on(t,1); + const Point_3 & c = vertex_on(t,2); + const Point_3 & p = point_on(s,0); + const Point_3 & q = point_on(s,1); + + + const Orientation abcp = orientation(a,b,c,p); + const Orientation abcq = orientation(a,b,c,q); + + + switch ( abcp ) { + case POSITIVE: + switch ( abcq ) { + case POSITIVE: + // the segment lies in the positive open halfspaces defined by the + // triangle's supporting plane + return Object(); + + case NEGATIVE: + // p sees the triangle in counterclockwise order + if ( orientation(p,q,a,b) != POSITIVE + && orientation(p,q,b,c) != POSITIVE + && orientation(p,q,c,a) != POSITIVE ) + return intersection(s,t.supporting_plane()); + else + return Object(); + + case COPLANAR: + // q belongs to the triangle's supporting plane + // p sees the triangle in counterclockwise order + if ( orientation(p,q,a,b) != POSITIVE + && orientation(p,q,b,c) != POSITIVE + && orientation(p,q,c,a) != POSITIVE ) + return make_object(q); + else + return Object(); + + default: // should not happen. + CGAL_kernel_assertion(false); + return Object(); + } + case NEGATIVE: + switch ( abcq ) { + case POSITIVE: + // q sees the triangle in counterclockwise order + if ( orientation(q,p,a,b) != POSITIVE + && orientation(q,p,b,c) != POSITIVE + && orientation(q,p,c,a) != POSITIVE ) + return intersection(s,t.supporting_plane()); + else + return Object(); + + case NEGATIVE: + // the segment lies in the negative open halfspaces defined by the + // triangle's supporting plane + return Object(); + + case COPLANAR: + // q belongs to the triangle's supporting plane + // p sees the triangle in clockwise order + if ( orientation(q,p,a,b) != POSITIVE + && orientation(q,p,b,c) != POSITIVE + && orientation(q,p,c,a) != POSITIVE ) + return make_object(q); + else + return Object(); + + default: // should not happen. + CGAL_kernel_assertion(false); + return Object(); + } + case COPLANAR: // p belongs to the triangle's supporting plane + switch ( abcq ) { + case POSITIVE: + // q sees the triangle in counterclockwise order + if ( orientation(q,p,a,b) != POSITIVE + && orientation(q,p,b,c) != POSITIVE + && orientation(q,p,c,a) != POSITIVE ) + return make_object(p); + else + return Object(); + + case NEGATIVE: + // q sees the triangle in clockwise order + if ( orientation(p,q,a,b) != POSITIVE + && orientation(p,q,b,c) != POSITIVE + && orientation(p,q,c,a) != POSITIVE ) + return make_object(p); + else + return Object(); + + case COPLANAR: + // the segment is coplanar with the triangle's supporting plane + // we test whether the segment intersects the triangle in the common + // supporting plane + return intersection_coplanar(t,s,k); + + default: // should not happen. + CGAL_kernel_assertion(false); + return Object(); + } + default: // should not happen. + CGAL_kernel_assertion(false); + return Object(); + } +} + +template +inline +Object +intersection(const typename K::Segment_3 &s, + const typename K::Triangle_3 &t, + const K & k) +{ + return internal::intersection(t,s,k); +} + + +} // end namespace internal + +template +inline +Object +intersection(const Triangle_3 &t, const Segment_3 &s) +{ + return typename K::Intersect_3()(t, s); +} + +template +inline +Object +intersection(const Segment_3 &s, const Triangle_3 &t) +{ + return typename K::Intersect_3()(t, s); +} + +} // end namespace CGAL + +#endif // CGAL_TRIANGLE_3_SEGMENT_3_INTERSECTION_H + diff --git a/AABB_tree/include/CGAL/AABB_traits.h b/AABB_tree/include/CGAL/AABB_traits.h index 43af4002bf0..754e8cc5212 100644 --- a/AABB_tree/include/CGAL/AABB_traits.h +++ b/AABB_tree/include/CGAL/AABB_traits.h @@ -26,8 +26,7 @@ #define CGAL_AABB_TRAITS_H_ #include -#include -#include +#include namespace CGAL { diff --git a/AABB_tree/test/AABB_tree/CMakeLists.txt b/AABB_tree/test/AABB_tree/CMakeLists.txt index cc0b27e77f4..34fc2fa9e38 100644 --- a/AABB_tree/test/AABB_tree/CMakeLists.txt +++ b/AABB_tree/test/AABB_tree/CMakeLists.txt @@ -6,6 +6,8 @@ project(AABB_tests) CMAKE_MINIMUM_REQUIRED(VERSION 2.4.5) +include_directories(../../include) + set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS true) if ( COMMAND cmake_policy ) @@ -21,9 +23,6 @@ if ( CGAL_FOUND ) include( CGAL_CreateSingleSourceCGALProgram ) - include_directories( BEFORE ../../include ) - include_directories( BEFORE ../../../trunk/Intersections_3/include ) - create_single_source_cgal_program("aabb_intersection_triangle_test.cpp") create_single_source_cgal_program("aabb_distance_triangle_test.cpp") create_single_source_cgal_program("aabb_distance_edge_test.cpp") diff --git a/AABB_tree/test/AABB_tree/aabb_correctness_triangle_test.cpp b/AABB_tree/test/AABB_tree/aabb_correctness_triangle_test.cpp index 79aa0d49b3c..b54f1db980b 100644 --- a/AABB_tree/test/AABB_tree/aabb_correctness_triangle_test.cpp +++ b/AABB_tree/test/AABB_tree/aabb_correctness_triangle_test.cpp @@ -27,6 +27,7 @@ #include +#include #include #include #include diff --git a/AABB_tree/test/AABB_tree/aabb_distance_edge_test.cpp b/AABB_tree/test/AABB_tree/aabb_distance_edge_test.cpp index 3356e0ca30f..1aa700aac67 100644 --- a/AABB_tree/test/AABB_tree/aabb_distance_edge_test.cpp +++ b/AABB_tree/test/AABB_tree/aabb_distance_edge_test.cpp @@ -26,6 +26,7 @@ #include #include +#include #include #include #include diff --git a/AABB_tree/test/AABB_tree/aabb_distance_triangle_hint_test.cpp b/AABB_tree/test/AABB_tree/aabb_distance_triangle_hint_test.cpp index 224c4e0a819..07b9e243fdb 100644 --- a/AABB_tree/test/AABB_tree/aabb_distance_triangle_hint_test.cpp +++ b/AABB_tree/test/AABB_tree/aabb_distance_triangle_hint_test.cpp @@ -26,6 +26,7 @@ #include #include +#include #include #include #include diff --git a/AABB_tree/test/AABB_tree/aabb_distance_triangle_test.cpp b/AABB_tree/test/AABB_tree/aabb_distance_triangle_test.cpp index 75fb421de3f..b7c6c860b6e 100644 --- a/AABB_tree/test/AABB_tree/aabb_distance_triangle_test.cpp +++ b/AABB_tree/test/AABB_tree/aabb_distance_triangle_test.cpp @@ -26,6 +26,8 @@ #include #include +#include + #include #include #include diff --git a/AABB_tree/test/AABB_tree/aabb_do_intersect_test.cpp b/AABB_tree/test/AABB_tree/aabb_do_intersect_test.cpp new file mode 100644 index 00000000000..3c4ad48720a --- /dev/null +++ b/AABB_tree/test/AABB_tree/aabb_do_intersect_test.cpp @@ -0,0 +1,187 @@ +// Copyright (c) 2009 INRIA Sophia-Antipolis (France). +// All rights reserved. +// +// This file is part of CGAL (www.cgal.org); you may redistribute it under +// the terms of the Q Public License version 1.0. +// See the file LICENSE.QPL distributed with CGAL. +// +// Licensees holding a valid commercial license may use this file in +// accordance with the commercial license agreement provided with the software. +// +// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +// +// $URL$ +// $Id$ +// +// +// Author(s) : Stephane Tayeb +// +//****************************************************************************** +// File Description : +// +//****************************************************************************** + +#include + +#include +#include +#include +#include +#include + + +template +bool test_aux(const T& t, + const std::string& name, + const CGAL::Bbox_3& bbox, + bool expected) +{ + bool b = CGAL::do_intersect(t,bbox); + + if ( b != expected ) + std::cout << "ERROR: do_intersect(" << name + << ") did not answer the expected result !" << std::endl; + + return (b == expected); +} + +template +bool test() +{ + // types + typedef typename K::FT FT; + typedef typename K::Line_3 Line; + typedef typename K::Point_3 Point; + typedef typename K::Segment_3 Segment; + typedef typename K::Ray_3 Ray; + typedef typename K::Line_3 Line; + + CGAL::Bbox_3 bbox(1.0,1.0,1.0,10.0,50.0,100.0); + + Point p1(FT(0.), FT(0.), FT(0.)); + Point p2(FT(0.), FT(100.), FT(100.)); + Point p3(FT(100.), FT(0.), FT(100.)); + Point p4(FT(100.), FT(100.), FT(0.)); + Point p5(FT(0.), FT(0.), FT(100.)); + Point p6(FT(100.), FT(100.), FT(100.)); + Point p7(FT(-1.), FT(-1.), FT(-1.)); + + Point pA(FT(5.), FT(0.), FT(0.)); + Point pB(FT(5.), FT(10.), FT(100.)); + Point pC(FT(5.), FT(10.), FT(-1.)); + Point pE(FT(5.), FT(10.), FT(0.)); + + Segment s12(p1,p2); + Segment s13(p1,p3); + Segment s14(p1,p4); + Segment s15(p1,p5); + Segment s16(p1,p6); + Segment s17(p1,p7); + Segment s71(p7,p1); + + Segment sAB(pA,pB); + Segment sBA(pB,pA); + Segment sBC(pB,pC); + Segment sCE(pC,pE); + Segment sEC(pE,pC); + + bool b = test_aux(s12,"s12",bbox,false); + b &= test_aux(s13,"s13",bbox,false); + b &= test_aux(s14,"s14",bbox,false); + b &= test_aux(s15,"s15",bbox,false); + b &= test_aux(s16,"s16",bbox,true); + b &= test_aux(s17,"s17",bbox,false); + b &= test_aux(s71,"s71",bbox,false); + + b &= test_aux(sAB,"sAB",bbox,true); + b &= test_aux(sBA,"sBA",bbox,true); + b &= test_aux(sBC,"sBC",bbox,true); + b &= test_aux(sCE,"sCE",bbox,false); + b &= test_aux(sEC,"sEC",bbox,false); + + + Ray r12(p1,p2); + Ray r13(p1,p3); + Ray r14(p1,p4); + Ray r15(p1,p5); + Ray r16(p1,p6); + Ray r17(p1,p7); + Ray r71(p7,p1); + + Ray rAB(pA,pB); + Ray rBA(pB,pA); + Ray rBC(pB,pC); + Ray rCE(pC,pE); + Ray rEC(pE,pC); + + b &= test_aux(r12,"r12",bbox,false); + b &= test_aux(r13,"r13",bbox,false); + b &= test_aux(r14,"r14",bbox,false); + b &= test_aux(r15,"r15",bbox,false); + b &= test_aux(r16,"r16",bbox,true); + b &= test_aux(r17,"r17",bbox,false); + b &= test_aux(r71,"r71",bbox,true); + + b &= test_aux(rAB,"rAB",bbox,true); + b &= test_aux(rBA,"rBA",bbox,true); + b &= test_aux(rBC,"rBC",bbox,true); + b &= test_aux(rCE,"rCE",bbox,true); + b &= test_aux(rEC,"rEC",bbox,false); + + Line l12(p1,p2); + Line l13(p1,p3); + Line l14(p1,p4); + Line l15(p1,p5); + Line l16(p1,p6); + Line l17(p1,p7); + Line l71(p7,p1); + + Line lAB(pA,pB); + Line lBA(pB,pA); + Line lBC(pB,pC); + Line lCE(pC,pE); + Line lEC(pE,pC); + + b &= test_aux(l12,"l12",bbox,false); + b &= test_aux(l13,"l13",bbox,false); + b &= test_aux(l14,"l14",bbox,false); + b &= test_aux(l15,"l15",bbox,false); + b &= test_aux(l16,"l16",bbox,true); + b &= test_aux(l17,"l17",bbox,true); + b &= test_aux(l71,"l71",bbox,true); + + b &= test_aux(lAB,"lAB",bbox,true); + b &= test_aux(lBA,"lBA",bbox,true); + b &= test_aux(lBC,"lBC",bbox,true); + b &= test_aux(lCE,"lCE",bbox,true); + b &= test_aux(lEC,"lEC",bbox,true); + + return b; +} + +int main() +{ + std::cout << "Testing with Simple_cartesian..." << std::endl ; + bool b = test >(); + + std::cout << "Testing with Simple_cartesian..." << std::endl ; + b &= test >(); + + std::cout << "Testing with Cartesian..." << std::endl ; + b &= test >(); + + std::cout << "Testing with Cartesian..." << std::endl ; + b &= test >(); + + std::cout << "Testing with Exact_predicates_inexact_constructions_kernel..." << std::endl ; + b &= test(); + + std::cout << "Testing with Exact_predicates_exact_constructions_kernel..." << std::endl ; + b &= test(); + + if ( b ) + return EXIT_SUCCESS; + else + return EXIT_FAILURE; +} diff --git a/AABB_tree/test/AABB_tree/aabb_intersection_test.cpp b/AABB_tree/test/AABB_tree/aabb_intersection_test.cpp new file mode 100644 index 00000000000..41412041bed --- /dev/null +++ b/AABB_tree/test/AABB_tree/aabb_intersection_test.cpp @@ -0,0 +1,340 @@ +// Copyright (c) 2009 INRIA Sophia-Antipolis (France). +// All rights reserved. +// +// This file is part of CGAL (www.cgal.org); you may redistribute it under +// the terms of the Q Public License version 1.0. +// See the file LICENSE.QPL distributed with CGAL. +// +// Licensees holding a valid commercial license may use this file in +// accordance with the commercial license agreement provided with the software. +// +// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +// +// $URL$ +// $Id$ +// +// +// Author(s) : Stephane Tayeb +// +//****************************************************************************** +// File Description : +// +//****************************************************************************** + +#include + +#include +#include +#include +#include +#include + + +template +bool test_aux(const Triangle t, + const Query& q, + const std::string& name, + const Result& expected) +{ + CGAL::Object object = CGAL::intersection(t,q); + const Result* pr = CGAL::object_cast(&object); + + if ( (NULL != pr) && (expected == *pr) ) + { + return true; + } + else + { + std::cout << "ERROR: intersection(" << name + << ") did not answer the expected result !"; + + if ( NULL != pr ) + std::cout << " (answer: ["<< *pr << "])"; + + std::cout << std::endl; + } + + return false; +} + +template +bool test() +{ + // types + typedef typename K::FT FT; + typedef typename K::Line_3 Line; + typedef typename K::Point_3 Point; + typedef typename K::Segment_3 Segment; + typedef typename K::Ray_3 Ray; + typedef typename K::Line_3 Line; + typedef typename K::Triangle_3 Triangle; + + /* ------------------------------------- + // Test data is something like that (in t supporting plane) + // Triangle is (p1,p2,p3) + // + // +E +1 + // / \ + // +C 6+ +8 +4 +B + // / 9++7 \ + // 3+-------+5--+2 + // + // +F +A + ------------------------------------- */ + + Point p1(FT(1.), FT(0.), FT(0.)); + Point p2(FT(0.), FT(1.), FT(0.)); + Point p3(FT(0.), FT(0.), FT(1.)); + + Triangle t(p1,p2,p3); + + // Edges of t + Segment s12(p1,p2); + Segment s21(p2,p1); + Segment s13(p1,p3); + Segment s23(p2,p3); + Segment s32(p3,p2); + Segment s31(p3,p1); + + bool b = test_aux(t,s12,"t-s12",s12); + b &= test_aux(t,s21,"t-s21",s21); + b &= test_aux(t,s13,"t-s13",s13); + b &= test_aux(t,s23,"t-s23",s23); + + // Inside points + Point p4(FT(0.5), FT(0.5), FT(0.)); + Point p5(FT(0.), FT(0.75), FT(0.25)); + Point p6(FT(0.5), FT(0.), FT(0.5)); + Point p7(FT(0.25), FT(0.625), FT(0.125)); + Point p8(FT(0.5), FT(0.25), FT(0.25)); + + Segment s14(p1,p4); + Segment s41(p4,p1); + Segment s24(p2,p4); + Segment s42(p4,p2); + Segment s15(p1,p5); + Segment s25(p2,p5); + Segment s34(p3,p4); + Segment s35(p3,p5); + Segment s36(p3,p6); + Segment s45(p4,p5); + Segment s16(p1,p6); + Segment s26(p2,p6); + Segment s62(p6,p2); + Segment s46(p4,p6); + Segment s48(p4,p8); + Segment s56(p5,p6); + Segment s65(p6,p5); + Segment s64(p6,p4); + Segment s17(p1,p7); + Segment s67(p6,p7); + Segment s68(p6,p8); + Segment s86(p8,p6); + Segment s78(p7,p8); + Segment s87(p8,p7); + + b &= test_aux(t,s14,"t-s14",s14); + b &= test_aux(t,s41,"t-s41",s41); + b &= test_aux(t,s24,"t-s24",s24); + b &= test_aux(t,s42,"t-s42",s42); + b &= test_aux(t,s15,"t-s15",s15); + b &= test_aux(t,s25,"t-s25",s25); + b &= test_aux(t,s34,"t-s34",s34); + b &= test_aux(t,s35,"t-s35",s35); + b &= test_aux(t,s36,"t-s36",s36); + b &= test_aux(t,s45,"t-s45",s45); + b &= test_aux(t,s16,"t-s16",s16); + b &= test_aux(t,s26,"t-s26",s26); + b &= test_aux(t,s62,"t-s62",s62); + b &= test_aux(t,s46,"t-s46",s46); + b &= test_aux(t,s65,"t-s65",s65); + b &= test_aux(t,s64,"t-s64",s64); + b &= test_aux(t,s48,"t-s48",s48); + b &= test_aux(t,s56,"t-s56",s56); + b &= test_aux(t,s17,"t-t17",s17); + b &= test_aux(t,s67,"t-t67",s67); + b &= test_aux(t,s68,"t-s68",s68); + b &= test_aux(t,s86,"t-s86",s86); + b &= test_aux(t,s78,"t-t78",s78); + b &= test_aux(t,s87,"t-t87",s87); + + // Outside points (in triangle plane) + Point pA(FT(-0.5), FT(1.), FT(0.5)); + Point pB(FT(0.5), FT(1.), FT(-0.5)); + Point pC(FT(0.5), FT(-0.5), FT(1.)); + Point pE(FT(1.), FT(-1.), FT(1.)); + Point pF(FT(-1.), FT(0.), FT(2.)); + + Segment sAB(pA,pB); + Segment sBC(pB,pC); + Segment s2E(p2,pE); + Segment sE2(pE,p2); + Segment s2A(p2,pA); + Segment s6E(p6,pE); + Segment sB8(pB,p8); + Segment sC8(pC,p8); + Segment s8C(p8,pC); + Segment s1F(p1,pF); + Segment sF6(pF,p6); + + b &= test_aux(t,sAB,"t-sAB",p2); + b &= test_aux(t,sBC,"t-sBC",s46); + b &= test_aux(t,s2E,"t-s2E",s26); + b &= test_aux(t,sE2,"t-sE2",s62); + b &= test_aux(t,s2A,"t-s2A",p2); + b &= test_aux(t,s6E,"t-s6E",p6); + b &= test_aux(t,sB8,"t-sB8",s48); + b &= test_aux(t,sC8,"t-sC8",s68); + b &= test_aux(t,s8C,"t-s8C",s86); + b &= test_aux(t,s1F,"t-s1F",s13); + b &= test_aux(t,sF6,"t-sF6",s36); + + // Outside triangle plane + Point pa(FT(0.), FT(0.), FT(0.)); + Point pb(FT(2.), FT(0.), FT(0.)); + Point pc(FT(1.), FT(0.), FT(1.)); + Point pe(FT(1.), FT(0.5), FT(0.5)); + + Segment sab(pa,pb); + Segment sac(pa,pc); + Segment sae(pa,pe); + Segment sa8(pa,p8); + Segment sb2(pb,p2); + + b &= test_aux(t,sab,"t-sab",p1); + b &= test_aux(t,sac,"t-sac",p6); + b &= test_aux(t,sae,"t-sae",p8); + b &= test_aux(t,sa8,"t-sa8",p8); + b &= test_aux(t,sb2,"t-sb2",p2); + + + // ----------------------------------- + // Line queries + // ----------------------------------- + // Edges of t + Line l12(p1,p2); + Line l21(p2,p1); + Line l13(p1,p3); + Line l23(p2,p3); + + b &= test_aux(t,l12,"t-l12",s12); + b &= test_aux(t,l21,"t-l21",s21); + b &= test_aux(t,l13,"t-l13",s13); + b &= test_aux(t,l23,"t-l23",s23); + + // In triangle + Point p9_(FT(0.), FT(0.5), FT(0.5)); + Point p9(FT(0.25), FT(0.375), FT(0.375)); + + Line l14(p1,p4); + Line l41(p4,p1); + Line l24(p2,p4); + Line l42(p4,p2); + Line l15(p1,p5); + Line l25(p2,p5); + Line l34(p3,p4); + Line l35(p3,p5); + Line l36(p3,p6); + Line l45(p4,p5); + Line l16(p1,p6); + Line l26(p2,p6); + Line l62(p6,p2); + Line l46(p4,p6); + Line l48(p4,p8); + Line l56(p5,p6); + Line l47(p4,p7); + Line l89(p8,p9); + Line l86(p8,p6); + Line l68(p6,p8); + Segment s89_res(p1,p9_); + + b &= test_aux(t,l14,"t-l14",s12); + b &= test_aux(t,l41,"t-l41",s21); + b &= test_aux(t,l24,"t-l24",s21); + b &= test_aux(t,l42,"t-l42",s12); + b &= test_aux(t,l15,"t-l15",s15); + b &= test_aux(t,l25,"t-l25",s23); + b &= test_aux(t,l34,"t-l34",s34); + b &= test_aux(t,l35,"t-l35",s32); + b &= test_aux(t,l36,"t-l36",s31); + b &= test_aux(t,l45,"t-l45",s45); + b &= test_aux(t,l16,"t-l16",s13); + b &= test_aux(t,l26,"t-l26",s26); + b &= test_aux(t,l62,"t-l62",s62); + b &= test_aux(t,l46,"t-l46",s46); + b &= test_aux(t,l48,"t-l48",s46); + b &= test_aux(t,l56,"t-l56",s56); + b &= test_aux(t,l47,"t-l47",s45); + b &= test_aux(t,l89,"t-t89",s89_res); + b &= test_aux(t,l68,"t-l68",s64); + b &= test_aux(t,l86,"t-l86",s46); + + + // Outside points (in triangle plane) + Line lAB(pA,pB); + Line lBC(pB,pC); + Line l2E(p2,pE); + Line lE2(pE,p2); + Line l2A(p2,pA); + Line l6E(p6,pE); + Line lB8(pB,p8); + Line lC8(pC,p8); + Line l8C(p8,pC); + Line l1F(p1,pF); + Line lF6(pF,p6); + + b &= test_aux(t,lAB,"t-lAB",p2); + b &= test_aux(t,lBC,"t-lBC",s46); + b &= test_aux(t,l2E,"t-l2E",s26); + b &= test_aux(t,lE2,"t-lE2",s62); + b &= test_aux(t,l2A,"t-l2A",p2); + b &= test_aux(t,l6E,"t-l6E",s26); + b &= test_aux(t,lB8,"t-lB8",s46); + b &= test_aux(t,lC8,"t-lC8",s64); + b &= test_aux(t,l8C,"t-l8C",s46); + b &= test_aux(t,l1F,"t-l1F",s13); + b &= test_aux(t,lF6,"t-lF6",s31); + + // Outside triangle plane + Line lab(pa,pb); + Line lac(pa,pc); + Line lae(pa,pe); + Line la8(pa,p8); + Line lb2(pb,p2); + + b &= test_aux(t,lab,"t-lab",p1); + b &= test_aux(t,lac,"t-lac",p6); + b &= test_aux(t,lae,"t-lae",p8); + b &= test_aux(t,la8,"t-la8",p8); + b &= test_aux(t,lb2,"t-lb2",p2); + + + return b; +} + +int main() +{ + std::cout << "Testing with Simple_cartesian..." << std::endl ; + bool b = test >(); + + std::cout << "Testing with Simple_cartesian..." << std::endl ; + b &= test >(); + + std::cout << "Testing with Cartesian..." << std::endl ; + b &= test >(); + + std::cout << "Testing with Cartesian..." << std::endl ; + b &= test >(); + + std::cout << "Testing with Exact_predicates_inexact_constructions_kernel..." << std::endl ; + b &= test(); + + std::cout << "Testing with Exact_predicates_exact_constructions_kernel..." << std::endl ; + b &= test(); + + if ( b ) + return EXIT_SUCCESS; + else + return EXIT_FAILURE; +} diff --git a/AABB_tree/test/AABB_tree/aabb_intersection_triangle_test.cpp b/AABB_tree/test/AABB_tree/aabb_intersection_triangle_test.cpp index 6fd9ed71d17..931ec3ef4ee 100644 --- a/AABB_tree/test/AABB_tree/aabb_intersection_triangle_test.cpp +++ b/AABB_tree/test/AABB_tree/aabb_intersection_triangle_test.cpp @@ -27,6 +27,7 @@ #include +#include #include #include #include diff --git a/AABB_tree/test/AABB_tree/aabb_naive_vs_tree_distance_segment_test.cpp b/AABB_tree/test/AABB_tree/aabb_naive_vs_tree_distance_segment_test.cpp index 9b70e2f1388..448256973d6 100644 --- a/AABB_tree/test/AABB_tree/aabb_naive_vs_tree_distance_segment_test.cpp +++ b/AABB_tree/test/AABB_tree/aabb_naive_vs_tree_distance_segment_test.cpp @@ -27,6 +27,7 @@ #include +#include #include #include #include diff --git a/AABB_tree/test/AABB_tree/aabb_naive_vs_tree_distance_triangle_test.cpp b/AABB_tree/test/AABB_tree/aabb_naive_vs_tree_distance_triangle_test.cpp index f1a458ebfea..56e70442c4f 100644 --- a/AABB_tree/test/AABB_tree/aabb_naive_vs_tree_distance_triangle_test.cpp +++ b/AABB_tree/test/AABB_tree/aabb_naive_vs_tree_distance_triangle_test.cpp @@ -27,6 +27,7 @@ #include +#include #include #include #include diff --git a/AABB_tree/test/AABB_tree/aabb_naive_vs_tree_triangle_test.cpp b/AABB_tree/test/AABB_tree/aabb_naive_vs_tree_triangle_test.cpp index 86b3af9b76a..e7739d583a8 100644 --- a/AABB_tree/test/AABB_tree/aabb_naive_vs_tree_triangle_test.cpp +++ b/AABB_tree/test/AABB_tree/aabb_naive_vs_tree_triangle_test.cpp @@ -27,6 +27,7 @@ #include +#include #include #include #include