songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove obsolete config flag CGAL_CFG_MATCHING_BUG_4 and its dependency CGAL_WRAP.

This commit is contained in:
Sylvain Pion 2007-08-08 15:15:20 +00:00
parent 4f24f131d7
commit a90de08bf3
42 changed files with 805 additions and 858 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

114
Distance_2/include/CGAL/squared_distance_2_1.h
View File

@ -45,8 +45,8 @@ namespace CGALi {
template <class K>
inline typename K::FT
squared_distance(const typename CGAL_WRAP(K)::Point_2 & pt1,
const typename CGAL_WRAP(K)::Point_2 & pt2,
squared_distance(const typename K::Point_2 & pt1,
const typename K::Point_2 & pt2,
const K& k)
{
typename K::Vector_2 vec = k.construct_vector_2_object()(pt2, pt1);
@ -55,8 +55,8 @@ namespace CGALi {
template <class K>
typename K::FT
squared_distance(const typename CGAL_WRAP(K)::Point_2 &pt,
const typename CGAL_WRAP(K)::Line_2 &line,
squared_distance(const typename K::Point_2 &pt,
const typename K::Line_2 &line,
const K&,
const Homogeneous_tag&)
{
@ -72,8 +72,8 @@ namespace CGALi {
template <class K>
typename K::FT
squared_distance(const typename CGAL_WRAP(K)::Point_2 &pt,
const typename CGAL_WRAP(K)::Line_2 &line,
squared_distance(const typename K::Point_2 &pt,
const typename K::Line_2 &line,
const K&,
const Cartesian_tag&)
{
@ -88,8 +88,8 @@ namespace CGALi {
template <class K>
typename K::FT
squared_distance(const typename CGAL_WRAP(K)::Point_2 &pt,
const typename CGAL_WRAP(K)::Line_2 &line,
squared_distance(const typename K::Point_2 &pt,
const typename K::Line_2 &line,
const K& k)
{
typedef typename K::Kernel_tag Tag;
@ -99,8 +99,8 @@ namespace CGALi {
template <class K>
inline typename K::FT
squared_distance(const typename CGAL_WRAP(K)::Line_2 &line,
const typename CGAL_WRAP(K)::Point_2 &pt,
squared_distance(const typename K::Line_2 &line,
const typename K::Point_2 &pt,
const K& k)
{
return CGALi::squared_distance(pt, line, k);
@ -108,8 +108,8 @@ namespace CGALi {
template <class K>
typename K::FT
squared_distance(const typename CGAL_WRAP(K)::Point_2 &pt,
const typename CGAL_WRAP(K)::Ray_2 &ray,
squared_distance(const typename K::Point_2 &pt,
const typename K::Ray_2 &ray,
const K& k)
{
typedef typename K::Vector_2 Vector_2;
@ -123,8 +123,8 @@ namespace CGALi {
template <class K>
inline typename K::FT
squared_distance(const typename CGAL_WRAP(K)::Ray_2 &ray,
const typename CGAL_WRAP(K)::Point_2 &pt,
squared_distance(const typename K::Ray_2 &ray,
const typename K::Point_2 &pt,
const K& k)
{
return CGALi::squared_distance(pt, ray, k);
@ -132,8 +132,8 @@ namespace CGALi {
template <class K>
typename K::FT
squared_distance(const typename CGAL_WRAP(K)::Point_2 &pt,
const typename CGAL_WRAP(K)::Segment_2 &seg,
squared_distance(const typename K::Point_2 &pt,
const typename K::Segment_2 &seg,
const K& k)
{
typename K::Construct_vector_2 construct_vector;
@ -153,8 +153,8 @@ namespace CGALi {
template <class K>
inline typename K::FT
squared_distance(const typename CGAL_WRAP(K)::Segment_2 &seg,
const typename CGAL_WRAP(K)::Point_2 &pt,
squared_distance(const typename K::Segment_2 &seg,
const typename K::Point_2 &pt,
const K& k)
{
return CGALi::squared_distance(pt, seg, k);
@ -162,8 +162,8 @@ namespace CGALi {
template <class K>
typename K::FT
squared_distance_parallel(const typename CGAL_WRAP(K)::Segment_2 &seg1,
const typename CGAL_WRAP(K)::Segment_2 &seg2,
squared_distance_parallel(const typename K::Segment_2 &seg1,
const typename K::Segment_2 &seg2,
const K& k)
{
typedef typename K::Vector_2 Vector_2;
@ -187,8 +187,8 @@ namespace CGALi {
inline typename K::RT
_distance_measure_sub(const typename K::RT &startwcross,
const typename K::RT &endwcross,
const typename CGAL_WRAP(K)::Point_2 &start,
const typename CGAL_WRAP(K)::Point_2 &end)
const typename K::Point_2 &start,
const typename K::Point_2 &end)
{
return CGAL_NTS abs(wmult((K*)0, startwcross, end.hw())) -
CGAL_NTS abs(wmult((K*)0, endwcross, start.hw()));
@ -196,8 +196,8 @@ namespace CGALi {
template <class K>
typename K::FT
squared_distance(const typename CGAL_WRAP(K)::Segment_2 &seg1,
const typename CGAL_WRAP(K)::Segment_2 &seg2,
squared_distance(const typename K::Segment_2 &seg1,
const typename K::Segment_2 &seg2,
const K& k)
{
typedef typename K::RT RT;
@ -291,8 +291,8 @@ namespace CGALi {
inline typename K::RT
_distance_measure_sub(const typename K::RT &startwcross,
const typename K::RT &endwcross,
const typename CGAL_WRAP(K)::Vector_2 &start,
const typename CGAL_WRAP(K)::Vector_2 &end)
const typename K::Vector_2 &start,
const typename K::Vector_2 &end)
{
return CGAL_NTS abs(wmult((K*)0, startwcross, end.hw())) -
CGAL_NTS abs(wmult((K*)0, endwcross, start.hw()));
@ -300,8 +300,8 @@ namespace CGALi {
template <class K>
typename K::FT
squared_distance_parallel(const typename CGAL_WRAP(K)::Segment_2 &seg,
const typename CGAL_WRAP(K)::Ray_2 &ray,
squared_distance_parallel(const typename K::Segment_2 &seg,
const typename K::Ray_2 &ray,
const K& k)
{
typedef typename K::Vector_2 Vector_2;
@ -320,8 +320,8 @@ namespace CGALi {
template <class K>
typename K::FT
squared_distance(const typename CGAL_WRAP(K)::Segment_2 &seg,
const typename CGAL_WRAP(K)::Ray_2 &ray,
squared_distance(const typename K::Segment_2 &seg,
const typename K::Ray_2 &ray,
const K& k)
{
typename K::Construct_vector_2 construct_vector;
@ -396,8 +396,8 @@ namespace CGALi {
template <class K>
inline typename K::FT
squared_distance(const typename CGAL_WRAP(K)::Ray_2 &ray,
const typename CGAL_WRAP(K)::Segment_2 &seg,
squared_distance(const typename K::Ray_2 &ray,
const typename K::Segment_2 &seg,
const K& k)
{
return CGALi::squared_distance(seg, ray, k);
@ -405,9 +405,9 @@ namespace CGALi {
template <class K>
typename K::FT
_sqd_to_line(const typename CGAL_WRAP(K)::Vector_2 &diff,
_sqd_to_line(const typename K::Vector_2 &diff,
const typename K::RT & wcross,
const typename CGAL_WRAP(K)::Vector_2 &dir )
const typename K::Vector_2 &dir )
{
typedef typename K::RT RT;
typedef typename K::FT FT;
@ -419,8 +419,8 @@ namespace CGALi {
template <class K>
typename K::FT
squared_distance(const typename CGAL_WRAP(K)::Segment_2 &seg,
const typename CGAL_WRAP(K)::Line_2 &line,
squared_distance(const typename K::Segment_2 &seg,
const typename K::Line_2 &line,
const K& k)
{
typename K::Construct_vector_2 construct_vector;
@ -464,8 +464,8 @@ namespace CGALi {
template <class K>
inline typename K::FT
squared_distance(const typename CGAL_WRAP(K)::Line_2 &line,
const typename CGAL_WRAP(K)::Segment_2 &seg,
squared_distance(const typename K::Line_2 &line,
const typename K::Segment_2 &seg,
const K& k)
{
return CGALi::squared_distance(seg, line, k);
@ -474,9 +474,9 @@ namespace CGALi {
template <class K>
typename K::FT
ray_ray_squared_distance_parallel(
const typename CGAL_WRAP(K)::Vector_2 &ray1dir,
const typename CGAL_WRAP(K)::Vector_2 &ray2dir,
const typename CGAL_WRAP(K)::Vector_2 &from1to2,
const typename K::Vector_2 &ray1dir,
const typename K::Vector_2 &ray2dir,
const typename K::Vector_2 &from1to2,
const K& k)
{
typedef typename K::RT RT;
@ -494,8 +494,8 @@ namespace CGALi {
template <class K>
typename K::FT
squared_distance(const typename CGAL_WRAP(K)::Ray_2 &ray1,
const typename CGAL_WRAP(K)::Ray_2 &ray2,
squared_distance(const typename K::Ray_2 &ray1,
const typename K::Ray_2 &ray2,
const K& k)
{
typename K::Construct_vector_2 construct_vector;
@ -538,8 +538,8 @@ namespace CGALi {
template <class K>
typename K::FT
squared_distance(const typename CGAL_WRAP(K)::Line_2 &line,
const typename CGAL_WRAP(K)::Ray_2 &ray,
squared_distance(const typename K::Line_2 &line,
const typename K::Ray_2 &ray,
const K& k)
{
typename K::Construct_vector_2 construct_vector;
@ -560,8 +560,8 @@ namespace CGALi {
template <class K>
inline typename K::FT
squared_distance(const typename CGAL_WRAP(K)::Ray_2 &ray,
const typename CGAL_WRAP(K)::Line_2 &line,
squared_distance(const typename K::Ray_2 &ray,
const typename K::Line_2 &line,
const K& k)
{
return CGALi::squared_distance(line, ray, k);
@ -569,8 +569,8 @@ namespace CGALi {
template <class K>
inline typename K::FT
squared_distance(const typename CGAL_WRAP(K)::Line_2 &line1,
const typename CGAL_WRAP(K)::Line_2 &line2,
squared_distance(const typename K::Line_2 &line1,
const typename K::Line_2 &line2,
const K& k)
{
typedef typename K::FT FT;
@ -583,8 +583,8 @@ namespace CGALi {
template <class K>
void
distance_index(int &ind,
const typename CGAL_WRAP(K)::Point_2 &pt,
const typename CGAL_WRAP(K)::Ray_2 &ray,
const typename K::Point_2 &pt,
const typename K::Ray_2 &ray,
const K& k)
{
typename K::Construct_vector_2 construct_vector;
@ -598,8 +598,8 @@ namespace CGALi {
template <class K>
void
distance_index(int &ind,
const typename CGAL_WRAP(K)::Point_2 &pt,
const typename CGAL_WRAP(K)::Segment_2 &seg,
const typename K::Point_2 &pt,
const typename K::Segment_2 &seg,
const K& k)
{
if (!is_acute_angle(seg.target(),seg.source(),pt, k)) {
@ -615,8 +615,8 @@ namespace CGALi {
template <class K>
inline typename K::FT
squared_distance_indexed(const typename CGAL_WRAP(K)::Point_2 &pt,
const typename CGAL_WRAP(K)::Ray_2 &ray,
squared_distance_indexed(const typename K::Point_2 &pt,
const typename K::Ray_2 &ray,
int ind,
const K& k)
{
@ -627,8 +627,8 @@ namespace CGALi {
template <class K>
inline typename K::FT
squared_distance_indexed(const typename CGAL_WRAP(K)::Point_2 &pt,
const typename CGAL_WRAP(K)::Segment_2 &seg,
squared_distance_indexed(const typename K::Point_2 &pt,
const typename K::Segment_2 &seg,
int ind,
const K& k)
{

44
Distance_2/include/CGAL/squared_distance_2_2.h
View File

@ -46,8 +46,8 @@ namespace CGALi {
void
distance_index(int &ind1,
int &ind2,
const typename CGAL_WRAP(K)::Point_2 &pt,
const typename CGAL_WRAP(K)::Triangle_2 &triangle,
const typename K::Point_2 &pt,
const typename K::Triangle_2 &triangle,
const K& k )
{
typename K::Left_turn_2 leftturn = k.left_turn_2_object();
@ -219,8 +219,8 @@ namespace CGALi {
template <class K>
typename K::FT
squared_distance_indexed(const typename CGAL_WRAP(K)::Point_2 &pt,
const typename CGAL_WRAP(K)::Triangle_2 &triangle,
squared_distance_indexed(const typename K::Point_2 &pt,
const typename K::Triangle_2 &triangle,
int ind1, int ind2,
const K& k)
{
@ -239,8 +239,8 @@ namespace CGALi {
template <class K>
typename K::FT
squared_distance(const typename CGAL_WRAP(K)::Point_2 &pt,
const typename CGAL_WRAP(K)::Triangle_2 &triangle,
squared_distance(const typename K::Point_2 &pt,
const typename K::Triangle_2 &triangle,
const K& k)
{
int ind1,ind2;
@ -251,8 +251,8 @@ namespace CGALi {
template <class K>
inline typename K::FT
squared_distance(const typename CGAL_WRAP(K)::Triangle_2 & triangle,
const typename CGAL_WRAP(K)::Point_2 & pt,
squared_distance(const typename K::Triangle_2 & triangle,
const typename K::Point_2 & pt,
const K& k)
{
return CGALi::squared_distance(pt, triangle, k);
@ -261,8 +261,8 @@ namespace CGALi {
template <class K>
typename K::FT
squared_distance(const typename CGAL_WRAP(K)::Line_2 &line,
const typename CGAL_WRAP(K)::Triangle_2 &triangle,
squared_distance(const typename K::Line_2 &line,
const typename K::Triangle_2 &triangle,
const K& k)
{
typedef typename K::FT FT;
@ -286,8 +286,8 @@ namespace CGALi {
template <class K>
inline typename K::FT
squared_distance(const typename CGAL_WRAP(K)::Triangle_2 & triangle,
const typename CGAL_WRAP(K)::Line_2 & line,
squared_distance(const typename K::Triangle_2 & triangle,
const typename K::Line_2 & line,
const K& k)
{
return CGALi::squared_distance(line, triangle, k);
@ -296,8 +296,8 @@ namespace CGALi {
template <class K>
typename K::FT
squared_distance(const typename CGAL_WRAP(K)::Ray_2 &ray,
const typename CGAL_WRAP(K)::Triangle_2 &triangle,
squared_distance(const typename K::Ray_2 &ray,
const typename K::Triangle_2 &triangle,
const K& k)
{
typedef typename K::FT FT;
@ -348,8 +348,8 @@ namespace CGALi {
template <class K>
inline typename K::FT
squared_distance(const typename CGAL_WRAP(K)::Triangle_2 & triangle,
const typename CGAL_WRAP(K)::Ray_2 & ray,
squared_distance(const typename K::Triangle_2 & triangle,
const typename K::Ray_2 & ray,
const K& k)
{
return CGALi::squared_distance(ray, triangle, k);
@ -358,8 +358,8 @@ namespace CGALi {
template <class K>
typename K::FT
squared_distance(const typename CGAL_WRAP(K)::Segment_2 &seg,
const typename CGAL_WRAP(K)::Triangle_2 &triangle,
squared_distance(const typename K::Segment_2 &seg,
const typename K::Triangle_2 &triangle,
const K& k)
{
typedef typename K::FT FT;
@ -421,8 +421,8 @@ namespace CGALi {
template <class K>
inline typename K::FT
squared_distance(const typename CGAL_WRAP(K)::Triangle_2 & triangle,
const typename CGAL_WRAP(K)::Segment_2 & seg,
squared_distance(const typename K::Triangle_2 & triangle,
const typename K::Segment_2 & seg,
const K& k)
{
return CGALi::squared_distance(seg, triangle, k);
@ -432,8 +432,8 @@ namespace CGALi {
template <class K>
typename K::FT
squared_distance(const typename CGAL_WRAP(K)::Triangle_2 &triangle1,
const typename CGAL_WRAP(K)::Triangle_2 &triangle2,
squared_distance(const typename K::Triangle_2 &triangle1,
const typename K::Triangle_2 &triangle2,
const K& k)
{
typedef typename K::FT FT;

82
Distance_3/include/CGAL/squared_distance_3_0.h
View File

@ -39,7 +39,7 @@ CGAL_BEGIN_NAMESPACE
namespace CGALi {
template <class K>
bool is_null(const typename CGAL_WRAP(K)::Vector_3 &v, const K&)
bool is_null(const typename K::Vector_3 &v, const K&)
{
typedef typename K::RT RT;
return v.hx()==RT(0) && v.hy()==RT(0) && v.hz()==RT(0);
@ -49,8 +49,8 @@ bool is_null(const typename CGAL_WRAP(K)::Vector_3 &v, const K&)
template <class K>
typename K::RT
wdot(const typename CGAL_WRAP(K)::Vector_3 &u,
const typename CGAL_WRAP(K)::Vector_3 &v,
wdot(const typename K::Vector_3 &u,
const typename K::Vector_3 &v,
const K&)
{
return (u.hx()*v.hx() + u.hy()*v.hy() + u.hz()*v.hz());
@ -58,9 +58,9 @@ wdot(const typename CGAL_WRAP(K)::Vector_3 &u,
template <class K>
typename K::RT
wdot_tag(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r,
wdot_tag(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r,
const K&,
const Cartesian_tag&)
{
@ -71,9 +71,9 @@ wdot_tag(const typename CGAL_WRAP(K)::Point_3 &p,
template <class K>
typename K::RT
wdot_tag(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r,
wdot_tag(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r,
const K&,
const Homogeneous_tag&)
{
@ -88,9 +88,9 @@ wdot_tag(const typename CGAL_WRAP(K)::Point_3 &p,
template <class K>
inline
typename K::RT
wdot(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r,
wdot(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r,
const K& k)
{
typedef typename K::Kernel_tag Tag;
@ -103,8 +103,8 @@ wdot(const typename CGAL_WRAP(K)::Point_3 &p,
template <class K>
typename K::Vector_3
wcross(const typename CGAL_WRAP(K)::Vector_3 &u,
const typename CGAL_WRAP(K)::Vector_3 &v,
wcross(const typename K::Vector_3 &u,
const typename K::Vector_3 &v,
const K&)
{
typedef typename K::Vector_3 Vector_3;
@ -118,8 +118,8 @@ wcross(const typename CGAL_WRAP(K)::Vector_3 &u,
template <class K>
inline
bool
is_acute_angle(const typename CGAL_WRAP(K)::Vector_3 &u,
const typename CGAL_WRAP(K)::Vector_3 &v,
is_acute_angle(const typename K::Vector_3 &u,
const typename K::Vector_3 &v,
const K& k)
{
typedef typename K::RT RT;
@ -129,8 +129,8 @@ is_acute_angle(const typename CGAL_WRAP(K)::Vector_3 &u,
template <class K>
inline
bool
is_straight_angle(const typename CGAL_WRAP(K)::Vector_3 &u,
const typename CGAL_WRAP(K)::Vector_3 &v,
is_straight_angle(const typename K::Vector_3 &u,
const typename K::Vector_3 &v,
const K& k)
{
typedef typename K::RT RT;
@ -140,8 +140,8 @@ is_straight_angle(const typename CGAL_WRAP(K)::Vector_3 &u,
template <class K>
inline
bool
is_obtuse_angle(const typename CGAL_WRAP(K)::Vector_3 &u,
const typename CGAL_WRAP(K)::Vector_3 &v,
is_obtuse_angle(const typename K::Vector_3 &u,
const typename K::Vector_3 &v,
const K& k)
{
typedef typename K::RT RT;
@ -151,9 +151,9 @@ is_obtuse_angle(const typename CGAL_WRAP(K)::Vector_3 &u,
template <class K>
inline
bool
is_acute_angle(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r,
is_acute_angle(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r,
const K& k)
{
typedef typename K::RT RT;
@ -163,9 +163,9 @@ is_acute_angle(const typename CGAL_WRAP(K)::Point_3 &p,
template <class K>
inline
bool
is_straight_angle(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r,
is_straight_angle(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r,
const K& k)
{
typedef typename K::RT RT;
@ -175,9 +175,9 @@ is_straight_angle(const typename CGAL_WRAP(K)::Point_3 &p,
template <class K>
inline
bool
is_obtuse_angle(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r,
is_obtuse_angle(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r,
const K& k)
{
typedef typename K::RT RT;
@ -186,8 +186,8 @@ is_obtuse_angle(const typename CGAL_WRAP(K)::Point_3 &p,
template <class K>
inline
typename K::FT
squared_distance(const typename CGAL_WRAP(K)::Point_3 & pt1,
const typename CGAL_WRAP(K)::Point_3 & pt2,
squared_distance(const typename K::Point_3 & pt1,
const typename K::Point_3 & pt2,
const K& k)
{
return k.compute_squared_distance_3_object()(pt1, pt2);
@ -196,8 +196,8 @@ squared_distance(const typename CGAL_WRAP(K)::Point_3 & pt1,
template <class K>
typename K::FT
squared_distance_to_plane(const typename CGAL_WRAP(K)::Vector_3 & normal,
const typename CGAL_WRAP(K)::Vector_3 & diff,
squared_distance_to_plane(const typename K::Vector_3 & normal,
const typename K::Vector_3 & diff,
const K& k)
{
typedef typename K::RT RT;
@ -212,8 +212,8 @@ squared_distance_to_plane(const typename CGAL_WRAP(K)::Vector_3 & normal,
template <class K>
typename K::FT
squared_distance_to_line(const typename CGAL_WRAP(K)::Vector_3 & dir,
const typename CGAL_WRAP(K)::Vector_3 & diff,
squared_distance_to_line(const typename K::Vector_3 & dir,
const typename K::Vector_3 & diff,
const K& k)
{
typedef typename K::Vector_3 Vector_3;
@ -228,8 +228,8 @@ squared_distance_to_line(const typename CGAL_WRAP(K)::Vector_3 & dir,
template <class K>
inline
bool
same_direction_tag(const typename CGAL_WRAP(K)::Vector_3 &u,
const typename CGAL_WRAP(K)::Vector_3 &v,
same_direction_tag(const typename K::Vector_3 &u,
const typename K::Vector_3 &v,
const K&,
const Cartesian_tag&)
{
@ -256,8 +256,8 @@ same_direction_tag(const typename CGAL_WRAP(K)::Vector_3 &u,
template <class K>
inline
bool
same_direction_tag(const typename CGAL_WRAP(K)::Vector_3 &u,
const typename CGAL_WRAP(K)::Vector_3 &v,
same_direction_tag(const typename K::Vector_3 &u,
const typename K::Vector_3 &v,
const K&,
const Homogeneous_tag&)
{
@ -284,8 +284,8 @@ same_direction_tag(const typename CGAL_WRAP(K)::Vector_3 &u,
template <class K>
inline
bool
same_direction(const typename CGAL_WRAP(K)::Vector_3 &u,
const typename CGAL_WRAP(K)::Vector_3 &v,
same_direction(const typename K::Vector_3 &u,
const typename K::Vector_3 &v,
const K& k)
{
typedef typename K::Kernel_tag Tag;

86
Distance_3/include/CGAL/squared_distance_3_1.h
View File

@ -40,8 +40,8 @@ namespace CGALi {
template <class K>
typename K::FT
squared_distance(
const typename CGAL_WRAP(K)::Point_3 &pt,
const typename CGAL_WRAP(K)::Line_3 &line,
const typename K::Point_3 &pt,
const typename K::Line_3 &line,
const K& k)
{
typedef typename K::Vector_3 Vector_3;
@ -55,8 +55,8 @@ template <class K>
inline
typename K::FT
squared_distance(
const typename CGAL_WRAP(K)::Line_3 & line,
const typename CGAL_WRAP(K)::Point_3 & pt,
const typename K::Line_3 & line,
const typename K::Point_3 & pt,
const K& k)
{
return squared_distance(pt, line, k);
@ -66,8 +66,8 @@ squared_distance(
template <class K>
typename K::FT
squared_distance(
const typename CGAL_WRAP(K)::Point_3 &pt,
const typename CGAL_WRAP(K)::Ray_3 &ray,
const typename K::Point_3 &pt,
const typename K::Ray_3 &ray,
const K& k)
{
typename K::Construct_vector_3 construct_vector;
@ -85,8 +85,8 @@ template <class K>
inline
typename K::FT
squared_distance(
const typename CGAL_WRAP(K)::Ray_3 & ray,
const typename CGAL_WRAP(K)::Point_3 & pt,
const typename K::Ray_3 & ray,
const typename K::Point_3 & pt,
const K& k)
{
return squared_distance(pt, ray, k);
@ -98,8 +98,8 @@ squared_distance(
template <class K>
typename K::FT
squared_distance(
const typename CGAL_WRAP(K)::Point_3 &pt,
const typename CGAL_WRAP(K)::Segment_3 &seg,
const typename K::Point_3 &pt,
const typename K::Segment_3 &seg,
const K& k,
const Homogeneous_tag)
{
@ -124,8 +124,8 @@ squared_distance(
template <class K>
typename K::FT
squared_distance(
const typename CGAL_WRAP(K)::Point_3 &pt,
const typename CGAL_WRAP(K)::Segment_3 &seg,
const typename K::Point_3 &pt,
const typename K::Segment_3 &seg,
const K& k,
const Cartesian_tag&)
{
@ -152,8 +152,8 @@ template <class K>
inline
typename K::FT
squared_distance(
const typename CGAL_WRAP(K)::Point_3 &pt,
const typename CGAL_WRAP(K)::Segment_3 &seg,
const typename K::Point_3 &pt,
const typename K::Segment_3 &seg,
const K& k)
{
typedef typename K::Kernel_tag Tag;
@ -166,8 +166,8 @@ template <class K>
inline
typename K::FT
squared_distance(
const typename CGAL_WRAP(K)::Segment_3 & seg,
const typename CGAL_WRAP(K)::Point_3 & pt,
const typename K::Segment_3 & seg,
const typename K::Point_3 & pt,
const K& k)
{
return squared_distance(pt, seg, k);
@ -179,8 +179,8 @@ squared_distance(
template <class K>
typename K::FT
squared_distance_parallel(
const typename CGAL_WRAP(K)::Segment_3 &seg1,
const typename CGAL_WRAP(K)::Segment_3 &seg2,
const typename K::Segment_3 &seg1,
const typename K::Segment_3 &seg2,
const K& k)
{
typedef typename K::Vector_3 Vector_3;
@ -207,8 +207,8 @@ template <class K>
inline
typename K::RT
_distance_measure_sub(typename K::RT startwdist, typename K::RT endwdist,
const typename CGAL_WRAP(K)::Vector_3 &start,
const typename CGAL_WRAP(K)::Vector_3 &end,
const typename K::Vector_3 &start,
const typename K::Vector_3 &end,
const K&)
{
return CGAL_NTS abs(wmult((K*)0, startwdist, end.hw())) -
@ -219,8 +219,8 @@ _distance_measure_sub(typename K::RT startwdist, typename K::RT endwdist,
template <class K>
typename K::FT
squared_distance(
const typename CGAL_WRAP(K)::Segment_3 &seg1,
const typename CGAL_WRAP(K)::Segment_3 &seg2,
const typename K::Segment_3 &seg1,
const typename K::Segment_3 &seg2,
const K& k)
{
typename K::Construct_vector_3 construct_vector;
@ -341,8 +341,8 @@ squared_distance(
template <class K>
typename K::FT
squared_distance_parallel(
const typename CGAL_WRAP(K)::Segment_3 &seg,
const typename CGAL_WRAP(K)::Ray_3 &ray,
const typename K::Segment_3 &seg,
const typename K::Ray_3 &ray,
const K& k)
{
@ -369,8 +369,8 @@ squared_distance_parallel(
template <class K>
typename K::FT
squared_distance(
const typename CGAL_WRAP(K)::Segment_3 &seg,
const typename CGAL_WRAP(K)::Ray_3 &ray,
const typename K::Segment_3 &seg,
const typename K::Ray_3 &ray,
const K& k)
{
typename K::Construct_vector_3 construct_vector;
@ -462,8 +462,8 @@ template <class K>
inline
typename K::FT
squared_distance(
const typename CGAL_WRAP(K)::Ray_3 & ray,
const typename CGAL_WRAP(K)::Segment_3 & seg,
const typename K::Ray_3 & ray,
const typename K::Segment_3 & seg,
const K& k)
{
return squared_distance(seg, ray, k);
@ -473,8 +473,8 @@ squared_distance(
template <class K>
typename K::FT
squared_distance(
const typename CGAL_WRAP(K)::Segment_3 &seg,
const typename CGAL_WRAP(K)::Line_3 &line,
const typename K::Segment_3 &seg,
const typename K::Line_3 &line,
const K& k)
{
typename K::Construct_vector_3 construct_vector;
@ -531,8 +531,8 @@ template <class K>
inline
typename K::FT
squared_distance(
const typename CGAL_WRAP(K)::Line_3 & line,
const typename CGAL_WRAP(K)::Segment_3 & seg,
const typename K::Line_3 & line,
const typename K::Segment_3 & seg,
const K& k)
{
return squared_distance(seg, line, k);
@ -544,9 +544,9 @@ squared_distance(
template <class K>
typename K::FT
ray_ray_squared_distance_parallel(
const typename CGAL_WRAP(K)::Vector_3 &ray1dir,
const typename CGAL_WRAP(K)::Vector_3 &ray2dir,
const typename CGAL_WRAP(K)::Vector_3 &s1_min_s2,
const typename K::Vector_3 &ray1dir,
const typename K::Vector_3 &ray2dir,
const typename K::Vector_3 &s1_min_s2,
const K& k)
{
if (!is_acute_angle(ray2dir, s1_min_s2, k)) {
@ -560,8 +560,8 @@ ray_ray_squared_distance_parallel(
template <class K>
typename K::FT
squared_distance(
const typename CGAL_WRAP(K)::Ray_3 &ray1,
const typename CGAL_WRAP(K)::Ray_3 &ray2,
const typename K::Ray_3 &ray1,
const typename K::Ray_3 &ray2,
const K& k)
{
typename K::Construct_vector_3 construct_vector;
@ -628,8 +628,8 @@ squared_distance(
template <class K>
typename K::FT
squared_distance(
const typename CGAL_WRAP(K)::Line_3 &line,
const typename CGAL_WRAP(K)::Ray_3 &ray,
const typename K::Line_3 &line,
const typename K::Ray_3 &ray,
const K& k)
{
typename K::Construct_vector_3 construct_vector;
@ -671,8 +671,8 @@ squared_distance(
template <class K>
inline typename K::FT
squared_distance(
const typename CGAL_WRAP(K)::Ray_3 & ray,
const typename CGAL_WRAP(K)::Line_3 & line,
const typename K::Ray_3 & ray,
const typename K::Line_3 & line,
const K& k)
{
return squared_distance(line, ray, k);
@ -684,8 +684,8 @@ squared_distance(
template <class K>
typename K::FT
squared_distance(
const typename CGAL_WRAP(K)::Line_3 &line1,
const typename CGAL_WRAP(K)::Line_3 &line2,
const typename K::Line_3 &line1,
const typename K::Line_3 &line2,
const K& k)
{
typename K::Construct_vector_3 construct_vector;

36
Distance_3/include/CGAL/squared_distance_3_2.h
View File

@ -38,8 +38,8 @@ namespace CGALi {
template <class K>
bool
contains_vector(const typename CGAL_WRAP(K)::Plane_3 &pl,
const typename CGAL_WRAP(K)::Vector_3 &vec,
contains_vector(const typename K::Plane_3 &pl,
const typename K::Vector_3 &vec,
const K&)
{
typedef typename K::RT RT;
@ -50,8 +50,8 @@ contains_vector(const typename CGAL_WRAP(K)::Plane_3 &pl,
template <class K>
inline typename K::FT
squared_distance(
const typename CGAL_WRAP(K)::Point_3 & pt,
const typename CGAL_WRAP(K)::Plane_3 & plane,
const typename K::Point_3 & pt,
const typename K::Plane_3 & plane,
const K& k)
{
typename K::Construct_vector_3 construct_vector;
@ -65,8 +65,8 @@ squared_distance(
template <class K>
inline typename K::FT
squared_distance(
const typename CGAL_WRAP(K)::Plane_3 & plane,
const typename CGAL_WRAP(K)::Point_3 & pt,
const typename K::Plane_3 & plane,
const typename K::Point_3 & pt,
const K& k)
{
return squared_distance(pt, plane, k);
@ -75,8 +75,8 @@ squared_distance(
template <class K>
typename K::FT
squared_distance(
const typename CGAL_WRAP(K)::Line_3 &line,
const typename CGAL_WRAP(K)::Plane_3 &plane,
const typename K::Line_3 &line,
const typename K::Plane_3 &plane,
const K& k)
{
typedef typename K::FT FT;
@ -89,8 +89,8 @@ squared_distance(
template <class K>
inline typename K::FT
squared_distance(
const typename CGAL_WRAP(K)::Plane_3 & p,
const typename CGAL_WRAP(K)::Line_3 & line,
const typename K::Plane_3 & p,
const typename K::Line_3 & line,
const K& k)
{
return squared_distance(line, p, k);
@ -99,8 +99,8 @@ squared_distance(
template <class K>
typename K::FT
squared_distance(
const typename CGAL_WRAP(K)::Ray_3 &ray,
const typename CGAL_WRAP(K)::Plane_3 &plane,
const typename K::Ray_3 &ray,
const typename K::Plane_3 &plane,
const K& k)
{
typename K::Construct_vector_3 construct_vector;
@ -134,8 +134,8 @@ squared_distance(
template <class K>
inline typename K::FT
squared_distance(
const typename CGAL_WRAP(K)::Plane_3 & plane,
const typename CGAL_WRAP(K)::Ray_3 & ray,
const typename K::Plane_3 & plane,
const typename K::Ray_3 & ray,
const K& k)
{
return squared_distance(ray, plane, k);
@ -144,8 +144,8 @@ squared_distance(
template <class K>
typename K::FT
squared_distance(
const typename CGAL_WRAP(K)::Segment_3 &seg,
const typename CGAL_WRAP(K)::Plane_3 &plane,
const typename K::Segment_3 &seg,
const typename K::Plane_3 &plane,
const K& k)
{
typename K::Construct_vector_3 construct_vector;
@ -188,8 +188,8 @@ squared_distance(
template <class K>
inline typename K::FT
squared_distance(
const typename CGAL_WRAP(K)::Plane_3 & plane,
const typename CGAL_WRAP(K)::Segment_3 & seg,
const typename K::Plane_3 & plane,
const typename K::Segment_3 & seg,
const K& k)
{
return squared_distance(seg, plane, k);

24
Envelope_3/include/CGAL/Envelope_3/Env_plane_traits_3_functions.h
View File

@ -25,9 +25,9 @@
CGAL_BEGIN_NAMESPACE
template <class K>
Object plane_half_plane_proj_intersection(const typename CGAL_WRAP(K)::Plane_3 &h1,
const typename CGAL_WRAP(K)::Plane_3 &h2,
const typename CGAL_WRAP(K)::Line_2 &l,
Object plane_half_plane_proj_intersection(const typename K::Plane_3 &h1,
const typename K::Plane_3 &h2,
const typename K::Line_2 &l,
const K& k)
{
typedef typename K::Vector_2 Vector_2;
@ -58,10 +58,10 @@ Object plane_half_plane_proj_intersection(const typename CGAL_WRAP(K)::Plane_3 &
}
template <class K>
Object half_plane_half_plane_proj_intersection(const typename CGAL_WRAP(K)::Plane_3 &h1,
const typename CGAL_WRAP(K)::Line_2 &l1,
const typename CGAL_WRAP(K)::Plane_3 &h2,
const typename CGAL_WRAP(K)::Line_2 &l2,
Object half_plane_half_plane_proj_intersection(const typename K::Plane_3 &h1,
const typename K::Line_2 &l1,
const typename K::Plane_3 &h2,
const typename K::Line_2 &l2,
const K& k)
{
typedef typename K::Ray_2 Ray_2;
@ -84,7 +84,7 @@ Object half_plane_half_plane_proj_intersection(const typename CGAL_WRAP(K)::Plan
}
template <class K>
typename CGAL_WRAP(K)::Line_2 project_xy(const typename CGAL_WRAP(K)::Line_3& l,
typename K::Line_2 project_xy(const typename K::Line_3& l,
const K& k)
{
typedef typename K::Vector_3 Vector_3;
@ -104,8 +104,8 @@ typename CGAL_WRAP(K)::Line_2 project_xy(const typename CGAL_WRAP(K)::Line_3& l,
// l1 is a line, l2 is a linear constraint (determined by the direction
// of the line).
template <class K>
Object line_under_linear_constraint(const typename CGAL_WRAP(K)::Line_2& l1,
const typename CGAL_WRAP(K)::Line_2& l2,
Object line_under_linear_constraint(const typename K::Line_2& l1,
const typename K::Line_2& l2,
const K& k)
{
typedef typename K::Ray_2 Ray_2;
@ -151,8 +151,8 @@ Object line_under_linear_constraint(const typename CGAL_WRAP(K)::Line_2& l1,
}
template <class K>
Object ray_under_linear_constraint(const typename CGAL_WRAP(K)::Ray_2& ray,
const typename CGAL_WRAP(K)::Line_2& l,
Object ray_under_linear_constraint(const typename K::Ray_2& ray,
const typename K::Line_2& l,
const K& k)
{
typedef typename K::Ray_2 Ray_2;

38
Installation/config/testfiles/CGAL_CFG_MATCHING_BUG_4.cpp
View File

@ -1,38 +0,0 @@
// Copyright (c) 2003 Utrecht University (The Netherlands),
// ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany),
// INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg
// (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria),
// and Tel-Aviv University (Israel). 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$
//
//
// Author(s) : Michael Hoffmann
// ---------------------------------------------------------------------
// This program is used by install_cgal.
// The following documentation will be pasted in the generated configfile.
// ---------------------------------------------------------------------
//| This flag is set, if a compiler cannot distinguish the signature
//| of overloaded function templates, which have arguments whose type
//| depends on the template parameter.
//| This bug appears for example on Sunpro 5.3 and 5.4.
template <class K> void foo(typename K::P, typename K::L, K) {}
template <class K> void foo(typename K::L, typename K::P, K) {}
int main() { return 0; }

15
Installation/include/CGAL/config.h
View File

@ -87,21 +87,6 @@ namespace std {
}
#endif
// FIXME: what is the problem with Sun 5.5? MATCHING_BUG_4 is not
// triggered, but there are runtime errors, e.g., with Distance_3,
// that do not appear when using the wrapper...
#if defined(CGAL_CFG_MATCHING_BUG_4)
// || (defined(__sun) && defined(__SUNPRO_CC))
namespace CGAL {
template < typename T >
struct Self { typedef T Type; };
}
# define CGAL_WRAP(K) CGAL::Self<K>::Type
#else
# define CGAL_WRAP(K) K
#endif
#ifndef CGAL_CFG_TYPENAME_BEFORE_DEFAULT_ARGUMENT_BUG
# define CGAL_TYPENAME_DEFAULT_ARG typename

4
Intersections_2/include/CGAL/Circle_2_Circle_2_intersection.h
View File

@ -35,8 +35,8 @@ namespace CGALi {
template <class K>
bool
do_intersect(const typename CGAL_WRAP(K)::Circle_2 & circ1,
const typename CGAL_WRAP(K)::Circle_2& circ2,
do_intersect(const typename K::Circle_2 & circ1,
const typename K::Circle_2& circ2,
const K&)
{
typedef typename K::FT FT;

4
Intersections_2/include/CGAL/Intersections_2/Triangle_2_Triangle_2_intersection_impl.h
View File

@ -357,8 +357,8 @@ Triangle_2_Triangle_2_pair<K>::intersection(
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Triangle_2 &tr1,
const typename CGAL_WRAP(K)::Triangle_2 &tr2,
intersection(const typename K::Triangle_2 &tr1,
const typename K::Triangle_2 &tr2,
const K&)
{
typedef Triangle_2_Triangle_2_pair<K> is_t;

4
Intersections_2/include/CGAL/Iso_rectangle_2_Iso_rectangle_2_intersection.h
View File

@ -35,8 +35,8 @@ namespace CGALi {
template <class K>
Object
intersection(
const typename CGAL_WRAP(K)::Iso_rectangle_2 &irect1,
const typename CGAL_WRAP(K)::Iso_rectangle_2 &irect2,
const typename K::Iso_rectangle_2 &irect1,
const typename K::Iso_rectangle_2 &irect2,
const K&)
{
typedef typename K::FT FT;

16
Intersections_2/include/CGAL/Line_2_Iso_rectangle_2_intersection.h
View File

@ -60,8 +60,8 @@ protected:
};
template <class K>
inline bool do_intersect(const typename CGAL_WRAP(K)::Line_2 &p1,
const typename CGAL_WRAP(K)::Iso_rectangle_2 &p2,
inline bool do_intersect(const typename K::Line_2 &p1,
const typename K::Iso_rectangle_2 &p2,
const K&)
{
typedef Line_2_Iso_rectangle_2_pair<K> pair_t;
@ -70,8 +70,8 @@ inline bool do_intersect(const typename CGAL_WRAP(K)::Line_2 &p1,
}
template <class K>
inline bool do_intersect(const typename CGAL_WRAP(K)::Iso_rectangle_2 &p2,
const typename CGAL_WRAP(K)::Line_2 &p1,
inline bool do_intersect(const typename K::Iso_rectangle_2 &p2,
const typename K::Line_2 &p1,
const K& k)
{
return CGALi::do_intersect(p1, p2, k);
@ -203,8 +203,8 @@ intersection(typename K::Segment_2 &result) const
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Line_2 &line,
const typename CGAL_WRAP(K)::Iso_rectangle_2 &iso,
intersection(const typename K::Line_2 &line,
const typename K::Iso_rectangle_2 &iso,
const K&)
{
typename K::Construct_object_2 construct_object;
@ -230,8 +230,8 @@ intersection(const typename CGAL_WRAP(K)::Line_2 &line,
template <class K>
inline
Object
intersection(const typename CGAL_WRAP(K)::Iso_rectangle_2 &iso,
const typename CGAL_WRAP(K)::Line_2 &line,
intersection(const typename K::Iso_rectangle_2 &iso,
const typename K::Line_2 &line,
const K& k)
{
return CGALi::intersection(line, iso, k);

8
Intersections_2/include/CGAL/Line_2_Line_2_intersection.h
View File

@ -59,8 +59,8 @@ protected:
template <class K>
inline bool do_intersect(
const typename CGAL_WRAP(K)::Line_2 &p1,
const typename CGAL_WRAP(K)::Line_2 &p2,
const typename K::Line_2 &p1,
const typename K::Line_2 &p2,
const K&)
{
typedef Line_2_Line_2_pair<K> pair_t;
@ -72,8 +72,8 @@ inline bool do_intersect(
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Line_2 &line1,
const typename CGAL_WRAP(K)::Line_2 &line2,
intersection(const typename K::Line_2 &line1,
const typename K::Line_2 &line2,
const K&)
{
typedef Line_2_Line_2_pair<K> is_t;

16
Intersections_2/include/CGAL/Line_2_Triangle_2_intersection.h
View File

@ -63,8 +63,8 @@ protected:
template <class K>
inline
bool
do_intersect(const typename CGAL_WRAP(K)::Line_2 &p1,
const typename CGAL_WRAP(K)::Triangle_2 &p2,
do_intersect(const typename K::Line_2 &p1,
const typename K::Triangle_2 &p2,
const K&)
{
typedef Line_2_Triangle_2_pair<K> pair_t;
@ -75,8 +75,8 @@ do_intersect(const typename CGAL_WRAP(K)::Line_2 &p1,
template <class K>
inline
bool
do_intersect(const typename CGAL_WRAP(K)::Triangle_2 &p2,
const typename CGAL_WRAP(K)::Line_2 &p1,
do_intersect(const typename K::Triangle_2 &p2,
const typename K::Line_2 &p1,
const K& k)
{
return CGALi::do_intersect(p1, p2, k);
@ -185,8 +185,8 @@ intersection(typename K::Segment_2 &result) const
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Line_2 &line,
const typename CGAL_WRAP(K)::Triangle_2 &tr,
intersection(const typename K::Line_2 &line,
const typename K::Triangle_2 &tr,
const K&)
{
typedef Line_2_Triangle_2_pair<K> is_t;
@ -212,8 +212,8 @@ intersection(const typename CGAL_WRAP(K)::Line_2 &line,
template <class K>
inline
Object
intersection(const typename CGAL_WRAP(K)::Triangle_2 &tr,
const typename CGAL_WRAP(K)::Line_2 &line,
intersection(const typename K::Triangle_2 &tr,
const typename K::Line_2 &line,
const K& k)
{
return intersection(line, tr, k);

16
Intersections_2/include/CGAL/Point_2_Iso_rectangle_2_intersection.h
View File

@ -36,8 +36,8 @@ namespace CGALi {
template <class K>
inline
bool
do_intersect(const typename CGAL_WRAP(K)::Point_2 &pt,
const typename CGAL_WRAP(K)::Iso_rectangle_2 &iso,
do_intersect(const typename K::Point_2 &pt,
const typename K::Iso_rectangle_2 &iso,
const K&)
{
return !iso.has_on_unbounded_side(pt);
@ -46,8 +46,8 @@ do_intersect(const typename CGAL_WRAP(K)::Point_2 &pt,
template <class K>
inline
bool
do_intersect(const typename CGAL_WRAP(K)::Iso_rectangle_2 &iso,
const typename CGAL_WRAP(K)::Point_2 &pt,
do_intersect(const typename K::Iso_rectangle_2 &iso,
const typename K::Point_2 &pt,
const K&)
{
return !iso.has_on_unbounded_side(pt);
@ -55,8 +55,8 @@ do_intersect(const typename CGAL_WRAP(K)::Iso_rectangle_2 &iso,
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Point_2 &pt,
const typename CGAL_WRAP(K)::Iso_rectangle_2 &iso,
intersection(const typename K::Point_2 &pt,
const typename K::Iso_rectangle_2 &iso,
const K& k)
{
if (CGALi::do_intersect(pt,iso,k)) {
@ -68,8 +68,8 @@ intersection(const typename CGAL_WRAP(K)::Point_2 &pt,
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Iso_rectangle_2 &iso,
const typename CGAL_WRAP(K)::Point_2 &pt,
intersection(const typename K::Iso_rectangle_2 &iso,
const typename K::Point_2 &pt,
const K& k)
{
if (CGALi::do_intersect(pt,iso,k)) {

16
Intersections_2/include/CGAL/Point_2_Line_2_intersection.h
View File

@ -35,8 +35,8 @@ namespace CGALi {
template <class K>
inline bool
do_intersect(const typename CGAL_WRAP(K)::Point_2 &pt,
const typename CGAL_WRAP(K)::Line_2 &line,
do_intersect(const typename K::Point_2 &pt,
const typename K::Line_2 &line,
const K&)
{
return line.has_on(pt);
@ -44,8 +44,8 @@ do_intersect(const typename CGAL_WRAP(K)::Point_2 &pt,
template <class K>
inline bool
do_intersect(const typename CGAL_WRAP(K)::Line_2 &line,
const typename CGAL_WRAP(K)::Point_2 &pt,
do_intersect(const typename K::Line_2 &line,
const typename K::Point_2 &pt,
const K&)
{
return line.has_on(pt);
@ -53,8 +53,8 @@ do_intersect(const typename CGAL_WRAP(K)::Line_2 &line,
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Point_2 &pt,
const typename CGAL_WRAP(K)::Line_2 &line,
intersection(const typename K::Point_2 &pt,
const typename K::Line_2 &line,
const K& k)
{
if (do_intersect(pt,line, k)) {
@ -65,8 +65,8 @@ intersection(const typename CGAL_WRAP(K)::Point_2 &pt,
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Line_2 &line,
const typename CGAL_WRAP(K)::Point_2 &pt,
intersection(const typename K::Line_2 &line,
const typename K::Point_2 &pt,
const K& k)
{
if (do_intersect(pt,line, k)) {

8
Intersections_2/include/CGAL/Point_2_Point_2_intersection.h
View File

@ -34,16 +34,16 @@ namespace CGALi {
template <class K>
inline bool
do_intersect(const typename CGAL_WRAP(K)::Point_2 &pt1,
const typename CGAL_WRAP(K)::Point_2 &pt2)
do_intersect(const typename K::Point_2 &pt1,
const typename K::Point_2 &pt2)
{
return pt1 == pt2;
}
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Point_2 &pt1,
const typename CGAL_WRAP(K)::Point_2 &pt2)
intersection(const typename K::Point_2 &pt1,
const typename K::Point_2 &pt2)
{
if (pt1 == pt2) {
return make_object(pt1);

16
Intersections_2/include/CGAL/Point_2_Ray_2_intersection.h
View File

@ -36,8 +36,8 @@ namespace CGALi {
template <class K>
inline
bool
do_intersect(const typename CGAL_WRAP(K)::Point_2 &pt,
const typename CGAL_WRAP(K)::Ray_2 &ray,
do_intersect(const typename K::Point_2 &pt,
const typename K::Ray_2 &ray,
const K&)
{
return ray.has_on(pt);
@ -47,8 +47,8 @@ do_intersect(const typename CGAL_WRAP(K)::Point_2 &pt,
template <class K>
inline
bool
do_intersect(const typename CGAL_WRAP(K)::Ray_2 &ray,
const typename CGAL_WRAP(K)::Point_2 &pt,
do_intersect(const typename K::Ray_2 &ray,
const typename K::Point_2 &pt,
const K&)
{
return ray.has_on(pt);
@ -57,8 +57,8 @@ do_intersect(const typename CGAL_WRAP(K)::Ray_2 &ray,
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Point_2 &pt,
const typename CGAL_WRAP(K)::Ray_2 &ray,
intersection(const typename K::Point_2 &pt,
const typename K::Ray_2 &ray,
const K& k)
{
if (do_intersect(pt,ray, k)) {
@ -69,8 +69,8 @@ intersection(const typename CGAL_WRAP(K)::Point_2 &pt,
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Ray_2 &ray,
const typename CGAL_WRAP(K)::Point_2 &pt,
intersection(const typename K::Ray_2 &ray,
const typename K::Point_2 &pt,
const K& k)
{
if (do_intersect(pt,ray, k)) {

16
Intersections_2/include/CGAL/Point_2_Segment_2_intersection.h
View File

@ -36,8 +36,8 @@ namespace CGALi {
template <class K>
inline
bool
do_intersect(const typename CGAL_WRAP(K)::Point_2 &pt,
const typename CGAL_WRAP(K)::Segment_2 &seg,
do_intersect(const typename K::Point_2 &pt,
const typename K::Segment_2 &seg,
const K&)
{
return seg.has_on(pt);
@ -46,8 +46,8 @@ do_intersect(const typename CGAL_WRAP(K)::Point_2 &pt,
template <class K>
inline
bool
do_intersect(const typename CGAL_WRAP(K)::Segment_2 &seg,
const typename CGAL_WRAP(K)::Point_2 &pt,
do_intersect(const typename K::Segment_2 &seg,
const typename K::Point_2 &pt,
const K&)
{
return seg.has_on(pt);
@ -57,8 +57,8 @@ do_intersect(const typename CGAL_WRAP(K)::Segment_2 &seg,
template <class K>
inline
Object
intersection(const typename CGAL_WRAP(K)::Point_2 &pt,
const typename CGAL_WRAP(K)::Segment_2 &seg,
intersection(const typename K::Point_2 &pt,
const typename K::Segment_2 &seg,
const K&)
{
if (do_intersect(pt,seg)) {
@ -70,8 +70,8 @@ intersection(const typename CGAL_WRAP(K)::Point_2 &pt,
template <class K>
inline
Object
intersection( const typename CGAL_WRAP(K)::Segment_2 &seg,
const typename CGAL_WRAP(K)::Point_2 &pt,
intersection( const typename K::Segment_2 &seg,
const typename K::Point_2 &pt,
const K&)
{
if (do_intersect(pt,seg)) {

16
Intersections_2/include/CGAL/Point_2_Triangle_2_intersection.h
View File

@ -59,8 +59,8 @@ protected:
};
template <class K>
inline bool do_intersect(const typename CGAL_WRAP(K)::Point_2 &p1,
const typename CGAL_WRAP(K)::Triangle_2 &p2,
inline bool do_intersect(const typename K::Point_2 &p1,
const typename K::Triangle_2 &p2,
const K&)
{
typedef Point_2_Triangle_2_pair<K> pair_t;
@ -68,8 +68,8 @@ inline bool do_intersect(const typename CGAL_WRAP(K)::Point_2 &p1,
return pair.intersection_type() != pair_t::NO_INTERSECTION;
}
template <class K>
inline bool do_intersect(const typename CGAL_WRAP(K)::Triangle_2 &p2,
const typename CGAL_WRAP(K)::Point_2 &p1,
inline bool do_intersect(const typename K::Triangle_2 &p2,
const typename K::Point_2 &p1,
const K& k)
{
return CGALi::do_intersect(p1, p2, k);
@ -150,8 +150,8 @@ intersection(typename K::Point_2 &result) const
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Point_2 &pt,
const typename CGAL_WRAP(K)::Triangle_2 &tr,
intersection(const typename K::Point_2 &pt,
const typename K::Triangle_2 &tr,
const K&)
{
typedef Point_2_Triangle_2_pair<K> is_t;
@ -169,8 +169,8 @@ intersection(const typename CGAL_WRAP(K)::Point_2 &pt,
template <class K>
inline
Object
intersection(const typename CGAL_WRAP(K)::Triangle_2 &tr,
const typename CGAL_WRAP(K)::Point_2 &pt,
intersection(const typename K::Triangle_2 &tr,
const typename K::Point_2 &pt,
const K&k)
{
return CGALi::intersection(pt, tr, k);

16
Intersections_2/include/CGAL/Ray_2_Iso_rectangle_2_intersection.h
View File

@ -62,8 +62,8 @@ protected:
};
template <class K>
inline bool do_intersect(const typename CGAL_WRAP(K)::Ray_2 &p1,
const typename CGAL_WRAP(K)::Iso_rectangle_2 &p2,
inline bool do_intersect(const typename K::Ray_2 &p1,
const typename K::Iso_rectangle_2 &p2,
const K& k)
{
typedef Ray_2_Iso_rectangle_2_pair<K> pair_t;
@ -72,8 +72,8 @@ inline bool do_intersect(const typename CGAL_WRAP(K)::Ray_2 &p1,
}
template <class K>
inline bool do_intersect(const typename CGAL_WRAP(K)::Iso_rectangle_2 &p2,
const typename CGAL_WRAP(K)::Ray_2 &p1,
inline bool do_intersect(const typename K::Iso_rectangle_2 &p2,
const typename K::Ray_2 &p1,
const K& k)
{
return do_intersect(p1, p2, k);
@ -81,8 +81,8 @@ inline bool do_intersect(const typename CGAL_WRAP(K)::Iso_rectangle_2 &p2,
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Ray_2 &ray,
const typename CGAL_WRAP(K)::Iso_rectangle_2 &iso,
intersection(const typename K::Ray_2 &ray,
const typename K::Iso_rectangle_2 &iso,
const K& )
{
typedef Ray_2_Iso_rectangle_2_pair<K> is_t;
@ -106,8 +106,8 @@ intersection(const typename CGAL_WRAP(K)::Ray_2 &ray,
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Iso_rectangle_2 &iso,
const typename CGAL_WRAP(K)::Ray_2 &ray,
intersection(const typename K::Iso_rectangle_2 &iso,
const typename K::Ray_2 &ray,
const K& k)
{
return intersection(ray, iso, k);

16
Intersections_2/include/CGAL/Ray_2_Line_2_intersection.h
View File

@ -60,8 +60,8 @@ protected:
template <class K>
inline bool do_intersect(
const typename CGAL_WRAP(K)::Ray_2 &p1,
const typename CGAL_WRAP(K)::Line_2 &p2)
const typename K::Ray_2 &p1,
const typename K::Line_2 &p2)
{
typedef Ray_2_Line_2_pair<K> pair_t;
pair_t pair(&p1, &p2);
@ -72,8 +72,8 @@ inline bool do_intersect(
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Ray_2 &ray,
const typename CGAL_WRAP(K)::Line_2 &line,
intersection(const typename K::Ray_2 &ray,
const typename K::Line_2 &line,
const K&)
{
typedef Ray_2_Line_2_pair<K> is_t;
@ -97,8 +97,8 @@ intersection(const typename CGAL_WRAP(K)::Ray_2 &ray,
template <class K>
inline
Object
intersection(const typename CGAL_WRAP(K)::Line_2 &line,
const typename CGAL_WRAP(K)::Ray_2 &ray,
intersection(const typename K::Line_2 &line,
const typename K::Ray_2 &ray,
const K& k)
{
return CGALi::intersection(ray, line, k);
@ -115,8 +115,8 @@ public:
template <class K>
inline bool do_intersect(
const typename CGAL_WRAP(K)::Line_2 &p1,
const typename CGAL_WRAP(K)::Ray_2 &p2,
const typename K::Line_2 &p1,
const typename K::Ray_2 &p2,
const K&)
{
typedef Line_2_Ray_2_pair<K> pair_t;

8
Intersections_2/include/CGAL/Ray_2_Ray_2_intersection.h
View File

@ -63,8 +63,8 @@ protected:
template <class K>
inline bool do_intersect(
const typename CGAL_WRAP(K)::Ray_2 &p1,
const typename CGAL_WRAP(K)::Ray_2 &p2,
const typename K::Ray_2 &p1,
const typename K::Ray_2 &p2,
const K& k)
{
typedef Ray_2_Ray_2_pair<K> pair_t;
@ -258,8 +258,8 @@ Ray_2_Ray_2_pair<K>::intersection(typename K::Ray_2 &result) const
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Ray_2 &ray1,
const typename CGAL_WRAP(K)::Ray_2 &ray2,
intersection(const typename K::Ray_2 &ray1,
const typename K::Ray_2 &ray2,
const K&)
{
typedef Ray_2_Ray_2_pair<K> is_t;

16
Intersections_2/include/CGAL/Ray_2_Segment_2_intersection.h
View File

@ -60,8 +60,8 @@ protected:
};
template <class K>
inline bool do_intersect(const typename CGAL_WRAP(K)::Ray_2 &p1,
const typename CGAL_WRAP(K)::Segment_2 &p2,
inline bool do_intersect(const typename K::Ray_2 &p1,
const typename K::Segment_2 &p2,
const K& k)
{
typedef Ray_2_Segment_2_pair<K> pair_t;
@ -70,8 +70,8 @@ inline bool do_intersect(const typename CGAL_WRAP(K)::Ray_2 &p1,
}
template <class K>
inline bool do_intersect(const typename CGAL_WRAP(K)::Segment_2 &p2,
const typename CGAL_WRAP(K)::Ray_2 &p1,
inline bool do_intersect(const typename K::Segment_2 &p2,
const typename K::Ray_2 &p1,
const K& k)
{
return CGALi::do_intersect(p1, p2, k);
@ -258,8 +258,8 @@ Ray_2_Segment_2_pair<K>::intersection(typename K::Segment_2 &result) const
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Ray_2 &ray,
const typename CGAL_WRAP(K)::Segment_2&seg,
intersection(const typename K::Ray_2 &ray,
const typename K::Segment_2&seg,
const K&)
{
typedef Ray_2_Segment_2_pair<K> is_t;
@ -284,8 +284,8 @@ intersection(const typename CGAL_WRAP(K)::Ray_2 &ray,
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Segment_2 &seg,
const typename CGAL_WRAP(K)::Ray_2 &ray,
intersection(const typename K::Segment_2 &seg,
const typename K::Ray_2 &ray,
const K& k)
{
return CGALi::intersection(ray, seg, k);

16
Intersections_2/include/CGAL/Ray_2_Triangle_2_intersection.h
View File

@ -174,8 +174,8 @@ intersection(typename K::Segment_2 &result) const
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Ray_2 &ray,
const typename CGAL_WRAP(K)::Triangle_2&tr,
intersection(const typename K::Ray_2 &ray,
const typename K::Triangle_2&tr,
const K&)
{
typedef Ray_2_Triangle_2_pair<K> is_t;
@ -199,8 +199,8 @@ intersection(const typename CGAL_WRAP(K)::Ray_2 &ray,
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Triangle_2&tr,
const typename CGAL_WRAP(K)::Ray_2 &ray,
intersection(const typename K::Triangle_2&tr,
const typename K::Ray_2 &ray,
const K& k)
{
return CGALi::intersection(ray, tr, k);
@ -219,8 +219,8 @@ public:
template <class K>
inline bool do_intersect(
const typename CGAL_WRAP(K)::Ray_2 &p1,
const typename CGAL_WRAP(K)::Triangle_2 &p2,
const typename K::Ray_2 &p1,
const typename K::Triangle_2 &p2,
const K&)
{
typedef Ray_2_Triangle_2_pair<K> pair_t;
@ -231,8 +231,8 @@ inline bool do_intersect(
template <class K>
inline bool do_intersect(
const typename CGAL_WRAP(K)::Triangle_2 &p1,
const typename CGAL_WRAP(K)::Ray_2 &p2,
const typename K::Triangle_2 &p1,
const typename K::Ray_2 &p2,
const K&)
{
typedef Triangle_2_Ray_2_pair<K> pair_t;

16
Intersections_2/include/CGAL/Segment_2_Iso_rectangle_2_intersection.h
View File

@ -60,8 +60,8 @@ protected:
template <class K>
inline bool do_intersect(
const typename CGAL_WRAP(K)::Segment_2 &p1,
const typename CGAL_WRAP(K)::Iso_rectangle_2 &p2,
const typename K::Segment_2 &p1,
const typename K::Iso_rectangle_2 &p2,
const K&)
{
typedef Segment_2_Iso_rectangle_2_pair<K> pair_t;
@ -76,8 +76,8 @@ inline bool do_intersect(
template <class K>
Object
intersection(
const typename CGAL_WRAP(K)::Segment_2 &seg,
const typename CGAL_WRAP(K)::Iso_rectangle_2 &iso,
const typename K::Segment_2 &seg,
const typename K::Iso_rectangle_2 &iso,
const K&)
{
typedef Segment_2_Iso_rectangle_2_pair<K> is_t;
@ -102,8 +102,8 @@ intersection(
template <class K>
inline
Object
intersection(const typename CGAL_WRAP(K)::Iso_rectangle_2 &iso,
const typename CGAL_WRAP(K)::Segment_2 &seg,
intersection(const typename K::Iso_rectangle_2 &iso,
const typename K::Segment_2 &seg,
const K& k)
{
return CGALi::intersection(seg, iso, k);
@ -241,8 +241,8 @@ public:
template <class K>
inline bool do_intersect(
const typename CGAL_WRAP(K)::Iso_rectangle_2 &p1,
const typename CGAL_WRAP(K)::Segment_2 &p2,
const typename K::Iso_rectangle_2 &p1,
const typename K::Segment_2 &p2,
const K&)
{
typedef Iso_rectangle_2_Segment_2_pair<K> pair_t;

16
Intersections_2/include/CGAL/Segment_2_Line_2_intersection.h
View File

@ -59,8 +59,8 @@ protected:
template <class K>
inline bool do_intersect(
const typename CGAL_WRAP(K)::Segment_2 &p1,
const typename CGAL_WRAP(K)::Line_2 &p2,
const typename K::Segment_2 &p1,
const typename K::Line_2 &p2,
const K&)
{
typedef Segment_2_Line_2_pair<K> pair_t;
@ -70,8 +70,8 @@ inline bool do_intersect(
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Segment_2 &seg,
const typename CGAL_WRAP(K)::Line_2 &line,
intersection(const typename K::Segment_2 &seg,
const typename K::Line_2 &line,
const K&)
{
typedef Segment_2_Line_2_pair<K> is_t;
@ -92,8 +92,8 @@ intersection(const typename CGAL_WRAP(K)::Segment_2 &seg,
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Line_2 &line,
const typename CGAL_WRAP(K)::Segment_2 &seg,
intersection(const typename K::Line_2 &line,
const typename K::Segment_2 &seg,
const K& k)
{
return CGALi::intersection(seg, line, k);
@ -111,8 +111,8 @@ public:
template <class K>
inline bool do_intersect(
const typename CGAL_WRAP(K)::Line_2 &p1,
const typename CGAL_WRAP(K)::Segment_2 &p2,
const typename K::Line_2 &p1,
const typename K::Segment_2 &p2,
const K&)
{
typedef Line_2_Segment_2_pair<K> pair_t;

8
Intersections_2/include/CGAL/Segment_2_Segment_2_intersection.h
View File

@ -115,8 +115,8 @@ bool seg_seg_do_intersect_contained(
template <class K>
bool
do_intersect(const typename CGAL_WRAP(K)::Segment_2 &seg1,
const typename CGAL_WRAP(K)::Segment_2 &seg2,
do_intersect(const typename K::Segment_2 &seg1,
const typename K::Segment_2 &seg2,
const K& k)
{
typename K::Point_2 const & A1 = seg1.source();
@ -464,8 +464,8 @@ Segment_2_Segment_2_pair<K>::intersection(typename K::Segment_2 &result) const
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Segment_2 &seg1,
const typename CGAL_WRAP(K)::Segment_2 &seg2,
intersection(const typename K::Segment_2 &seg1,
const typename K::Segment_2 &seg2,
const K&)
{
typedef Segment_2_Segment_2_pair<K> is_t;

16
Intersections_2/include/CGAL/Segment_2_Triangle_2_intersection.h
View File

@ -62,8 +62,8 @@ protected:
template <class K>
inline bool do_intersect(
const typename CGAL_WRAP(K)::Segment_2 &p1,
const typename CGAL_WRAP(K)::Triangle_2 &p2,
const typename K::Segment_2 &p1,
const typename K::Triangle_2 &p2,
const K&)
{
typedef Segment_2_Triangle_2_pair<K> pair_t;
@ -178,8 +178,8 @@ intersection(typename K::Segment_2 &result) const
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Segment_2 &seg,
const typename CGAL_WRAP(K)::Triangle_2&tr,
intersection(const typename K::Segment_2 &seg,
const typename K::Triangle_2&tr,
const K&)
{
typedef Segment_2_Triangle_2_pair<K> is_t;
@ -204,8 +204,8 @@ intersection(const typename CGAL_WRAP(K)::Segment_2 &seg,
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Triangle_2&tr,
const typename CGAL_WRAP(K)::Segment_2 &seg,
intersection(const typename K::Triangle_2&tr,
const typename K::Segment_2 &seg,
const K& k)
{
return CGALi::intersection(seg, tr, k);
@ -224,8 +224,8 @@ public:
template <class K>
inline bool do_intersect(
const typename CGAL_WRAP(K)::Triangle_2 &p1,
const typename CGAL_WRAP(K)::Segment_2 &p2,
const typename K::Triangle_2 &p1,
const typename K::Segment_2 &p2,
const K&)
{
typedef Triangle_2_Segment_2_pair<K> pair_t;

4
Intersections_2/include/CGAL/Triangle_2_Triangle_2_do_intersect.h
View File

@ -107,8 +107,8 @@ bool intersection_test_edge(const typename K::Point_2 * P1,
template <class K>
bool do_intersect(const typename CGAL_WRAP(K)::Triangle_2 &t1,
const typename CGAL_WRAP(K)::Triangle_2 &t2,
bool do_intersect(const typename K::Triangle_2 &t1,
const typename K::Triangle_2 &t2,
const K & k ){
CGAL_kernel_precondition( ! k.is_degenerate_2_object() (t1) );

98
Intersections_3/include/CGAL/Intersections_3/intersection_3_1_impl.h
View File

@ -30,8 +30,8 @@ namespace CGALi {
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Plane_3 &plane,
const typename CGAL_WRAP(K)::Line_3 &line,
intersection(const typename K::Plane_3 &plane,
const typename K::Line_3 &line,
const K&)
{
typedef typename K::Point_3 Point_3;
@ -64,8 +64,8 @@ intersection(const typename CGAL_WRAP(K)::Plane_3 &plane,
template <class K>
inline
Object
intersection(const typename CGAL_WRAP(K)::Line_3 &line,
const typename CGAL_WRAP(K)::Plane_3 &plane,
intersection(const typename K::Line_3 &line,
const typename K::Plane_3 &plane,
const K& k)
{
return intersection(plane, line, k);
@ -73,8 +73,8 @@ intersection(const typename CGAL_WRAP(K)::Line_3 &line,
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Plane_3 &plane1,
const typename CGAL_WRAP(K)::Plane_3 &plane2,
intersection(const typename K::Plane_3 &plane1,
const typename K::Plane_3 &plane2,
const K&)
{
typedef typename K::Point_3 Point_3;
@ -133,9 +133,9 @@ intersection(const typename CGAL_WRAP(K)::Plane_3 &plane1,
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Plane_3 &plane1,
const typename CGAL_WRAP(K)::Plane_3 &plane2,
const typename CGAL_WRAP(K)::Plane_3 &plane3,
intersection(const typename K::Plane_3 &plane1,
const typename K::Plane_3 &plane2,
const typename K::Plane_3 &plane3,
const K& k)
{
typedef typename K::Line_3 Line_3;
@ -157,8 +157,8 @@ intersection(const typename CGAL_WRAP(K)::Plane_3 &plane1,
template <class K>
bool
do_intersect(const typename CGAL_WRAP(K)::Plane_3 &plane,
const typename CGAL_WRAP(K)::Line_3 &line,
do_intersect(const typename K::Plane_3 &plane,
const typename K::Line_3 &line,
const K&)
{
typedef typename K::Point_3 Point_3;
@ -185,8 +185,8 @@ do_intersect(const typename CGAL_WRAP(K)::Plane_3 &plane,
template <class K>
inline
bool
do_intersect(const typename CGAL_WRAP(K)::Line_3 &line,
const typename CGAL_WRAP(K)::Plane_3 &plane,
do_intersect(const typename K::Line_3 &line,
const typename K::Plane_3 &plane,
const K& k)
{
return do_intersect(plane, line, k);
@ -195,8 +195,8 @@ do_intersect(const typename CGAL_WRAP(K)::Line_3 &line,
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Plane_3 &plane,
const typename CGAL_WRAP(K)::Ray_3 &ray,
intersection(const typename K::Plane_3 &plane,
const typename K::Ray_3 &ray,
const K& k)
{
typedef typename K::Point_3 Point_3;
@ -217,8 +217,8 @@ intersection(const typename CGAL_WRAP(K)::Plane_3 &plane,
template <class K>
inline
Object
intersection(const typename CGAL_WRAP(K)::Ray_3 &ray,
const typename CGAL_WRAP(K)::Plane_3 &plane,
intersection(const typename K::Ray_3 &ray,
const typename K::Plane_3 &plane,
const K& k)
{
return intersection(plane, ray, k);
@ -228,8 +228,8 @@ intersection(const typename CGAL_WRAP(K)::Ray_3 &ray,
template <class K>
bool
do_intersect(const typename CGAL_WRAP(K)::Plane_3 &plane,
const typename CGAL_WRAP(K)::Ray_3 &ray,
do_intersect(const typename K::Plane_3 &plane,
const typename K::Ray_3 &ray,
const K& k)
{
typedef typename K::Point_3 Point_3;
@ -246,8 +246,8 @@ do_intersect(const typename CGAL_WRAP(K)::Plane_3 &plane,
template <class K>
inline
bool
do_intersect(const typename CGAL_WRAP(K)::Ray_3 &ray,
const typename CGAL_WRAP(K)::Plane_3 &plane,
do_intersect(const typename K::Ray_3 &ray,
const typename K::Plane_3 &plane,
const K& k)
{
return do_intersect(plane, ray, k);
@ -256,8 +256,8 @@ do_intersect(const typename CGAL_WRAP(K)::Ray_3 &ray,
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Plane_3 &plane,
const typename CGAL_WRAP(K)::Segment_3 &seg,
intersection(const typename K::Plane_3 &plane,
const typename K::Segment_3 &seg,
const K& k)
{
typedef typename K::Point_3 Point_3;
@ -300,8 +300,8 @@ intersection(const typename CGAL_WRAP(K)::Plane_3 &plane,
template <class K>
inline
Object
intersection(const typename CGAL_WRAP(K)::Segment_3 &seg,
const typename CGAL_WRAP(K)::Plane_3 &plane,
intersection(const typename K::Segment_3 &seg,
const typename K::Plane_3 &plane,
const K& k)
{
return intersection(plane, seg, k);
@ -310,8 +310,8 @@ intersection(const typename CGAL_WRAP(K)::Segment_3 &seg,
template <class K>
bool
do_intersect(const typename CGAL_WRAP(K)::Plane_3 &plane,
const typename CGAL_WRAP(K)::Segment_3 &seg,
do_intersect(const typename K::Plane_3 &plane,
const typename K::Segment_3 &seg,
const K&)
{
typedef typename K::Point_3 Point_3;
@ -332,8 +332,8 @@ do_intersect(const typename CGAL_WRAP(K)::Plane_3 &plane,
template <class K>
inline
bool
do_intersect(const typename CGAL_WRAP(K)::Segment_3 &seg,
const typename CGAL_WRAP(K)::Plane_3 &plane,
do_intersect(const typename K::Segment_3 &seg,
const typename K::Plane_3 &plane,
const K& k)
{
return do_intersect(plane, seg, k);
@ -342,7 +342,7 @@ do_intersect(const typename CGAL_WRAP(K)::Segment_3 &seg,
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Line_3 &line,
intersection(const typename K::Line_3 &line,
const Bbox_3 &box,
const K&)
{
@ -366,7 +366,7 @@ template <class K>
inline
Object
intersection(const Bbox_3 &box,
const typename CGAL_WRAP(K)::Line_3 &line,
const typename K::Line_3 &line,
const K& k)
{
return intersection(line, box, k);
@ -375,7 +375,7 @@ intersection(const Bbox_3 &box,
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Ray_3 &ray,
intersection(const typename K::Ray_3 &ray,
const Bbox_3 &box,
const K&)
{
@ -399,7 +399,7 @@ template <class K>
inline
Object
intersection(const Bbox_3 &box,
const typename CGAL_WRAP(K)::Ray_3 &ray,
const typename K::Ray_3 &ray,
const K& k)
{
return intersection(ray, box, k);
@ -409,7 +409,7 @@ intersection(const Bbox_3 &box,
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Segment_3 &seg,
intersection(const typename K::Segment_3 &seg,
const Bbox_3 &box,
const K&)
{
@ -433,7 +433,7 @@ template <class K>
inline
Object
intersection(const Bbox_3 &box,
const typename CGAL_WRAP(K)::Segment_3 &seg,
const typename K::Segment_3 &seg,
const K& k)
{
return intersection(seg, box, k);
@ -442,8 +442,8 @@ intersection(const Bbox_3 &box,
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Line_3 &line,
const typename CGAL_WRAP(K)::Iso_cuboid_3 &box,
intersection(const typename K::Line_3 &line,
const typename K::Iso_cuboid_3 &box,
const K&)
{
typedef typename K::Point_3 Point_3;
@ -505,8 +505,8 @@ intersection(const typename CGAL_WRAP(K)::Line_3 &line,
template <class K>
inline
Object
intersection(const typename CGAL_WRAP(K)::Iso_cuboid_3 &box,
const typename CGAL_WRAP(K)::Line_3 &line,
intersection(const typename K::Iso_cuboid_3 &box,
const typename K::Line_3 &line,
const K& k)
{
return intersection(line, box, k);
@ -516,8 +516,8 @@ intersection(const typename CGAL_WRAP(K)::Iso_cuboid_3 &box,
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Ray_3 &ray,
const typename CGAL_WRAP(K)::Iso_cuboid_3 &box,
intersection(const typename K::Ray_3 &ray,
const typename K::Iso_cuboid_3 &box,
const K&)
{
typedef typename K::Point_3 Point_3;
@ -578,8 +578,8 @@ intersection(const typename CGAL_WRAP(K)::Ray_3 &ray,
template <class K>
inline
Object
intersection(const typename CGAL_WRAP(K)::Iso_cuboid_3 &box,
const typename CGAL_WRAP(K)::Ray_3 &ray,
intersection(const typename K::Iso_cuboid_3 &box,
const typename K::Ray_3 &ray,
const K& k)
{
return intersection(ray, box, k);
@ -588,8 +588,8 @@ intersection(const typename CGAL_WRAP(K)::Iso_cuboid_3 &box,
template <class K>
Object
intersection(const typename CGAL_WRAP(K)::Segment_3 &seg,
const typename CGAL_WRAP(K)::Iso_cuboid_3 &box,
intersection(const typename K::Segment_3 &seg,
const typename K::Iso_cuboid_3 &box,
const K&)
{
typedef typename K::Point_3 Point_3;
@ -650,8 +650,8 @@ intersection(const typename CGAL_WRAP(K)::Segment_3 &seg,
template <class K>
inline
Object
intersection(const typename CGAL_WRAP(K)::Iso_cuboid_3 &box,
const typename CGAL_WRAP(K)::Segment_3 &seg,
intersection(const typename K::Iso_cuboid_3 &box,
const typename K::Segment_3 &seg,
const K& k)
{
return intersection(seg, box, k);
@ -661,8 +661,8 @@ intersection(const typename CGAL_WRAP(K)::Iso_cuboid_3 &box,
template <class K>
Object
intersection(
const typename CGAL_WRAP(K)::Iso_cuboid_3 &icub1,
const typename CGAL_WRAP(K)::Iso_cuboid_3 &icub2,
const typename K::Iso_cuboid_3 &icub1,
const typename K::Iso_cuboid_3 &icub2,
const K&)
{
typedef typename K::Point_3 Point_3;

8
Intersections_3/include/CGAL/Triangle_3_Line_3_do_intersect.h
View File

@ -26,8 +26,8 @@ CGAL_BEGIN_NAMESPACE
namespace CGALi {
template <class K>
bool do_intersect(const typename CGAL_WRAP(K)::Triangle_3 &t,
const typename CGAL_WRAP(K)::Line_3 &l,
bool do_intersect(const typename K::Triangle_3 &t,
const typename K::Line_3 &l,
const K & k )
{
@ -98,8 +98,8 @@ bool do_intersect(const typename CGAL_WRAP(K)::Triangle_3 &t,
template <class K>
inline
bool do_intersect(const typename CGAL_WRAP(K)::Line_3 &l,
const typename CGAL_WRAP(K)::Triangle_3 &t,
bool do_intersect(const typename K::Line_3 &l,
const typename K::Triangle_3 &t,
const K & k )
{
return do_intersect(t, l, k);

8
Intersections_3/include/CGAL/Triangle_3_Plane_3_do_intersect.h
View File

@ -26,8 +26,8 @@ CGAL_BEGIN_NAMESPACE
namespace CGALi {
template <class K>
bool do_intersect(const typename CGAL_WRAP(K)::Triangle_3 &t,
const typename CGAL_WRAP(K)::Plane_3 &h,
bool do_intersect(const typename K::Triangle_3 &t,
const typename K::Plane_3 &h,
const K & k)
{
@ -61,8 +61,8 @@ bool do_intersect(const typename CGAL_WRAP(K)::Triangle_3 &t,
template <class K>
inline
bool do_intersect(const typename CGAL_WRAP(K)::Plane_3 &h,
const typename CGAL_WRAP(K)::Triangle_3 &t,
bool do_intersect(const typename K::Plane_3 &h,
const typename K::Triangle_3 &t,
const K & k)
{
return do_intersect(t, h, k);

8
Intersections_3/include/CGAL/Triangle_3_Point_3_do_intersect.h
View File

@ -26,8 +26,8 @@ CGAL_BEGIN_NAMESPACE
namespace CGALi {
template <class K>
bool do_intersect(const typename CGAL_WRAP(K)::Triangle_3 &t,
const typename CGAL_WRAP(K)::Point_3 &p,
bool do_intersect(const typename K::Triangle_3 &t,
const typename K::Point_3 &p,
const K & k )
{
@ -82,8 +82,8 @@ bool do_intersect(const typename CGAL_WRAP(K)::Triangle_3 &t,
template <class K>
bool do_intersect(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Triangle_3 &t,
bool do_intersect(const typename K::Point_3 &p,
const typename K::Triangle_3 &t,
const K & k )
{
return do_intersect(t, p, k);

12
Intersections_3/include/CGAL/Triangle_3_Ray_3_do_intersect.h
View File

@ -26,8 +26,8 @@ CGAL_BEGIN_NAMESPACE
namespace CGALi {
template <class K>
bool do_intersect(const typename CGAL_WRAP(K)::Triangle_3 &t,
const typename CGAL_WRAP(K)::Ray_3 &r,
bool do_intersect(const typename K::Triangle_3 &t,
const typename K::Ray_3 &r,
const K & k)
{
@ -147,8 +147,8 @@ bool do_intersect(const typename CGAL_WRAP(K)::Triangle_3 &t,
template <class K>
inline
bool do_intersect(const typename CGAL_WRAP(K)::Ray_3 &r,
const typename CGAL_WRAP(K)::Triangle_3 &t,
bool do_intersect(const typename K::Ray_3 &r,
const typename K::Triangle_3 &t,
const K & k)
{
return do_intersect(t,r, k);
@ -156,8 +156,8 @@ bool do_intersect(const typename CGAL_WRAP(K)::Ray_3 &r,
template <class K>
bool do_intersect_coplanar(const typename CGAL_WRAP(K)::Triangle_3 &t,
const typename CGAL_WRAP(K)::Ray_3 &r,
bool do_intersect_coplanar(const typename K::Triangle_3 &t,
const typename K::Ray_3 &r,
const K & k )
{

12
Intersections_3/include/CGAL/Triangle_3_Segment_3_do_intersect.h
View File

@ -27,8 +27,8 @@ namespace CGALi {
template <class K>
bool do_intersect_coplanar(const typename CGAL_WRAP(K)::Triangle_3 &t,
const typename CGAL_WRAP(K)::Segment_3 &s,
bool do_intersect_coplanar(const typename K::Triangle_3 &t,
const typename K::Segment_3 &s,
const K & k )
{
@ -181,8 +181,8 @@ bool do_intersect_coplanar(const typename CGAL_WRAP(K)::Triangle_3 &t,
template <class K>
bool do_intersect(const typename CGAL_WRAP(K)::Triangle_3 &t,
const typename CGAL_WRAP(K)::Segment_3 &s,
bool do_intersect(const typename K::Triangle_3 &t,
const typename K::Segment_3 &s,
const K & k)
{
@ -293,8 +293,8 @@ bool do_intersect(const typename CGAL_WRAP(K)::Triangle_3 &t,
template <class K>
inline
bool do_intersect(const typename CGAL_WRAP(K)::Segment_3 &s,
const typename CGAL_WRAP(K)::Triangle_3 &t,
bool do_intersect(const typename K::Segment_3 &s,
const typename K::Triangle_3 &t,
const K & k)
{
return do_intersect(t, s, k);

8
Intersections_3/include/CGAL/Triangle_3_Tetrahedron_3_do_intersect.h
View File

@ -32,8 +32,8 @@ namespace CGALi {
// This code is not optimized:
template <class K>
bool do_intersect(const typename CGAL_WRAP(K)::Triangle_3 &tr,
const typename CGAL_WRAP(K)::Tetrahedron_3 &tet,
bool do_intersect(const typename K::Triangle_3 &tr,
const typename K::Tetrahedron_3 &tet,
const K & k)
{
typedef typename K::Triangle_3 Triangle;
@ -58,8 +58,8 @@ bool do_intersect(const typename CGAL_WRAP(K)::Triangle_3 &tr,
template <class K>
inline
bool do_intersect(const typename CGAL_WRAP(K)::Tetrahedron_3 &tet,
const typename CGAL_WRAP(K)::Triangle_3 &tr,
bool do_intersect(const typename K::Tetrahedron_3 &tet,
const typename K::Triangle_3 &tr,
const K & k)
{
return do_intersect(tr, tet, k);

8
Intersections_3/include/CGAL/Triangle_3_Triangle_3_do_intersect.h
View File

@ -115,8 +115,8 @@ bool _intersection_test_edge(const typename K::Point_3 * p,
template <class K>
bool do_intersect_coplanar(const typename CGAL_WRAP(K)::Triangle_3 &t1,
const typename CGAL_WRAP(K)::Triangle_3 &t2,
bool do_intersect_coplanar(const typename K::Triangle_3 &t1,
const typename K::Triangle_3 &t2,
const K & k)
{
@ -192,8 +192,8 @@ bool do_intersect_coplanar(const typename CGAL_WRAP(K)::Triangle_3 &t1,
template <class K>
bool do_intersect(const typename CGAL_WRAP(K)::Triangle_3 &t1,
const typename CGAL_WRAP(K)::Triangle_3 &t2,
bool do_intersect(const typename K::Triangle_3 &t1,
const typename K::Triangle_3 &t2,
const K & k)
{

4
Kernel_23/include/CGAL/Kernel/global_functions_2.h
View File

@ -726,7 +726,7 @@ operator!=(const Vector_2<K>& v, const Vector_2<K>& w)
template < class K >
inline
typename K::Vector_2
operator*(const typename CGAL_WRAP(K)::FT &c, const Vector_2<K> &w)
operator*(const typename K::FT &c, const Vector_2<K> &w)
{
return K().construct_scaled_vector_2_object()(w, c);
}
@ -734,7 +734,7 @@ operator*(const typename CGAL_WRAP(K)::FT &c, const Vector_2<K> &w)
template < class K >
inline
typename K::Vector_2
operator*(const Vector_2<K> &w, const typename CGAL_WRAP(K)::FT &c)
operator*(const Vector_2<K> &w, const typename K::FT &c)
{
return K().construct_scaled_vector_2_object()(w, c);
}

4
Kernel_23/include/CGAL/Kernel/global_functions_3.h
View File

@ -664,7 +664,7 @@ operator>=(const Point_3<K>& p, const Point_3<K>& q)
template < class K >
inline
typename K::Vector_3
operator*(const typename CGAL_WRAP(K)::FT &c, const Vector_3<K> &w)
operator*(const typename K::FT &c, const Vector_3<K> &w)
{
return K().construct_scaled_vector_3_object()(w, c);
}
@ -672,7 +672,7 @@ operator*(const typename CGAL_WRAP(K)::FT &c, const Vector_3<K> &w)
template < class K >
inline
typename K::Vector_3
operator*(const Vector_3<K> &w, const typename CGAL_WRAP(K)::FT &c)
operator*(const Vector_3<K> &w, const typename K::FT &c)
{
return K().construct_scaled_vector_3_object()(w, c);
}

400
Kernel_23/include/CGAL/Kernel/global_functions_internal_2.h
View File

@ -38,9 +38,9 @@ namespace CGALi {
template < class K >
inline
Angle
angle(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
const typename CGAL_WRAP(K)::Point_2 &r, const K& k)
angle(const typename K::Point_2 &p,
const typename K::Point_2 &q,
const typename K::Point_2 &r, const K& k)
{
return k.angle_2_object()(p, q, r);
}
@ -48,9 +48,9 @@ angle(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
bool
are_ordered_along_line(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
const typename CGAL_WRAP(K)::Point_2 &r, const K& k)
are_ordered_along_line(const typename K::Point_2 &p,
const typename K::Point_2 &q,
const typename K::Point_2 &r, const K& k)
{
return k.are_ordered_along_line_2_object()(p, q, r);
}
@ -58,9 +58,9 @@ are_ordered_along_line(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
bool
are_strictly_ordered_along_line(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
const typename CGAL_WRAP(K)::Point_2 &r,
are_strictly_ordered_along_line(const typename K::Point_2 &p,
const typename K::Point_2 &q,
const typename K::Point_2 &r,
const K& k)
{
return k.are_strictly_ordered_along_line_2_object()(p, q, r);
@ -69,9 +69,9 @@ are_strictly_ordered_along_line(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
typename K::FT
area(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
const typename CGAL_WRAP(K)::Point_2 &r,
area(const typename K::Point_2 &p,
const typename K::Point_2 &q,
const typename K::Point_2 &r,
const K& k)
{
return k.compute_area_2_object()(p, q, r);
@ -80,8 +80,8 @@ area(const typename CGAL_WRAP(K)::Point_2 &p,
template <typename K>
inline
typename K::Line_2
bisector(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q, const K &k)
bisector(const typename K::Point_2 &p,
const typename K::Point_2 &q, const K &k)
{
return k.construct_bisector_2_object()(p, q);
}
@ -89,8 +89,8 @@ bisector(const typename CGAL_WRAP(K)::Point_2 &p,
template <typename K>
inline
typename K::Line_2
bisector(const typename CGAL_WRAP(K)::Line_2 &l1,
const typename CGAL_WRAP(K)::Line_2 &l2, const K &k)
bisector(const typename K::Line_2 &l1,
const typename K::Line_2 &l2, const K &k)
{
return k.construct_bisector_2_object()(l1, l2);
}
@ -98,9 +98,9 @@ bisector(const typename CGAL_WRAP(K)::Line_2 &l1,
template < class K >
inline
typename K::Point_2
centroid(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
const typename CGAL_WRAP(K)::Point_2 &r, const K& k)
centroid(const typename K::Point_2 &p,
const typename K::Point_2 &q,
const typename K::Point_2 &r, const K& k)
{
return k.construct_centroid_2_object()(p, q, r);
}
@ -108,10 +108,10 @@ centroid(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
typename K::Point_2
centroid(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
const typename CGAL_WRAP(K)::Point_2 &r,
const typename CGAL_WRAP(K)::Point_2 &s, const K& k)
centroid(const typename K::Point_2 &p,
const typename K::Point_2 &q,
const typename K::Point_2 &r,
const typename K::Point_2 &s, const K& k)
{
return k.construct_centroid_2_object()(p, q, r, s);
}
@ -119,7 +119,7 @@ centroid(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
typename K::Point_2
centroid(const typename CGAL_WRAP(K)::Triangle_2 &t, const K& k)
centroid(const typename K::Triangle_2 &t, const K& k)
{
return k.construct_centroid_2_object()(t);
}
@ -127,8 +127,8 @@ centroid(const typename CGAL_WRAP(K)::Triangle_2 &t, const K& k)
template < class K >
inline
typename K::Point_2
circumcenter(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q, const K& k)
circumcenter(const typename K::Point_2 &p,
const typename K::Point_2 &q, const K& k)
{
return k.construct_circumcenter_2_object()(p, q);
}
@ -136,9 +136,9 @@ circumcenter(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
typename K::Point_2
circumcenter(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
const typename CGAL_WRAP(K)::Point_2 &r, const K& k)
circumcenter(const typename K::Point_2 &p,
const typename K::Point_2 &q,
const typename K::Point_2 &r, const K& k)
{
return k.construct_circumcenter_2_object()(p, q, r);
}
@ -146,7 +146,7 @@ circumcenter(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
typename K::Point_2
circumcenter(const typename CGAL_WRAP(K)::Triangle_2 &t, const K& k)
circumcenter(const typename K::Triangle_2 &t, const K& k)
{
return k.construct_circumcenter_2_object()(t);
}
@ -154,9 +154,9 @@ circumcenter(const typename CGAL_WRAP(K)::Triangle_2 &t, const K& k)
template < class K >
inline
bool
collinear(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
const typename CGAL_WRAP(K)::Point_2 &r, const K& k)
collinear(const typename K::Point_2 &p,
const typename K::Point_2 &q,
const typename K::Point_2 &r, const K& k)
{
return k.collinear_2_object()(p, q, r);
}
@ -164,9 +164,9 @@ collinear(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
bool
collinear_are_ordered_along_line(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
const typename CGAL_WRAP(K)::Point_2 &r,
collinear_are_ordered_along_line(const typename K::Point_2 &p,
const typename K::Point_2 &q,
const typename K::Point_2 &r,
const K& k)
{
return k.collinear_are_ordered_along_line_2_object()(p, q, r);
@ -176,9 +176,9 @@ template < class K >
inline
bool
collinear_are_strictly_ordered_along_line(
const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
const typename CGAL_WRAP(K)::Point_2 &r, const K& k)
const typename K::Point_2 &p,
const typename K::Point_2 &q,
const typename K::Point_2 &r, const K& k)
{
return k.collinear_are_strictly_ordered_along_line_2_object()(p, q, r);
}
@ -186,8 +186,8 @@ collinear_are_strictly_ordered_along_line(
template < typename K >
inline
Comparison_result
compare_angle_with_x_axis(const typename CGAL_WRAP(K)::Direction_2& d1,
const typename CGAL_WRAP(K)::Direction_2& d2,
compare_angle_with_x_axis(const typename K::Direction_2& d1,
const typename K::Direction_2& d2,
const K& k)
{
return k.compare_angle_with_x_axis_2_object()(d1, d2);
@ -196,9 +196,9 @@ compare_angle_with_x_axis(const typename CGAL_WRAP(K)::Direction_2& d1,
template <class K >
inline
Comparison_result
compare_distance_to_point(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
const typename CGAL_WRAP(K)::Point_2 &r, const K& k)
compare_distance_to_point(const typename K::Point_2 &p,
const typename K::Point_2 &q,
const typename K::Point_2 &r, const K& k)
{
return k.compare_distance_2_object()(p, q, r);
}
@ -206,9 +206,9 @@ compare_distance_to_point(const typename CGAL_WRAP(K)::Point_2 &p,
template <class K >
inline
Comparison_result
compare_squared_distance(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
const typename CGAL_WRAP(K)::FT &d2, const K& k)
compare_squared_distance(const typename K::Point_2 &p,
const typename K::Point_2 &q,
const typename K::FT &d2, const K& k)
{
return k.compare_squared_distance_2_object()(p, q, d2);
}
@ -216,10 +216,10 @@ compare_squared_distance(const typename CGAL_WRAP(K)::Point_2 &p,
template <class K>
inline
Comparison_result
compare_signed_distance_to_line(const typename CGAL_WRAP(K)::Point_2& p,
const typename CGAL_WRAP(K)::Point_2& q,
const typename CGAL_WRAP(K)::Point_2& r,
const typename CGAL_WRAP(K)::Point_2& s,
compare_signed_distance_to_line(const typename K::Point_2& p,
const typename K::Point_2& q,
const typename K::Point_2& r,
const typename K::Point_2& s,
const K& k)
{
if (k.less_signed_distance_to_line_2_object()(p, q, r, s)) return SMALLER;
@ -230,9 +230,9 @@ compare_signed_distance_to_line(const typename CGAL_WRAP(K)::Point_2& p,
template <class K>
inline
Comparison_result
compare_signed_distance_to_line(const typename CGAL_WRAP(K)::Line_2& l,
const typename CGAL_WRAP(K)::Point_2& p,
const typename CGAL_WRAP(K)::Point_2& q,
compare_signed_distance_to_line(const typename K::Line_2& l,
const typename K::Point_2& p,
const typename K::Point_2& q,
const K& k)
{
if (k.less_signed_distance_to_line_2_object()(l, p, q)) return SMALLER;
@ -243,8 +243,8 @@ compare_signed_distance_to_line(const typename CGAL_WRAP(K)::Line_2& l,
template < class K >
inline
Comparison_result
compare_slopes(const typename CGAL_WRAP(K)::Line_2 &l1,
const typename CGAL_WRAP(K)::Line_2 &l2, const K& k)
compare_slopes(const typename K::Line_2 &l1,
const typename K::Line_2 &l2, const K& k)
{
return k.compare_slope_2_object()(l1, l2);
}
@ -252,8 +252,8 @@ compare_slopes(const typename CGAL_WRAP(K)::Line_2 &l1,
template < class K >
inline
Comparison_result
compare_slopes(const typename CGAL_WRAP(K)::Segment_2 &s1,
const typename CGAL_WRAP(K)::Segment_2 &s2, const K& k)
compare_slopes(const typename K::Segment_2 &s1,
const typename K::Segment_2 &s2, const K& k)
{
return k.compare_slope_2_object()(s1, s2);
}
@ -261,8 +261,8 @@ compare_slopes(const typename CGAL_WRAP(K)::Segment_2 &s1,
template < class K >
inline
Comparison_result
compare_x(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q, const K& k)
compare_x(const typename K::Point_2 &p,
const typename K::Point_2 &q, const K& k)
{
return k.compare_x_2_object()(p, q);
}
@ -270,9 +270,9 @@ compare_x(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
Comparison_result
compare_x(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Line_2 &l1,
const typename CGAL_WRAP(K)::Line_2 &l2, const K& k)
compare_x(const typename K::Point_2 &p,
const typename K::Line_2 &l1,
const typename K::Line_2 &l2, const K& k)
{
return k.compare_x_2_object()(p, l1, l2);
}
@ -280,9 +280,9 @@ compare_x(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
Comparison_result
compare_x(const typename CGAL_WRAP(K)::Line_2 &l,
const typename CGAL_WRAP(K)::Line_2 &h1,
const typename CGAL_WRAP(K)::Line_2 &h2, const K& k)
compare_x(const typename K::Line_2 &l,
const typename K::Line_2 &h1,
const typename K::Line_2 &h2, const K& k)
{
return k.compare_x_2_object()(l, h1, h2);
}
@ -290,10 +290,10 @@ compare_x(const typename CGAL_WRAP(K)::Line_2 &l,
template < class K >
inline
Comparison_result
compare_x(const typename CGAL_WRAP(K)::Line_2 &l1,
const typename CGAL_WRAP(K)::Line_2 &h1,
const typename CGAL_WRAP(K)::Line_2 &l2,
const typename CGAL_WRAP(K)::Line_2 &h2, const K& k)
compare_x(const typename K::Line_2 &l1,
const typename K::Line_2 &h1,
const typename K::Line_2 &l2,
const typename K::Line_2 &h2, const K& k)
{
return k.compare_x_2_object()(l1, h1, l2, h2);
}
@ -301,8 +301,8 @@ compare_x(const typename CGAL_WRAP(K)::Line_2 &l1,
template < class K >
inline
Comparison_result
compare_x_at_y(const typename CGAL_WRAP(K)::Point_2& p,
const typename CGAL_WRAP(K)::Line_2& h, const K& k)
compare_x_at_y(const typename K::Point_2& p,
const typename K::Line_2& h, const K& k)
{
return k.compare_x_at_y_2_object()(p, h);
}
@ -311,8 +311,8 @@ compare_x_at_y(const typename CGAL_WRAP(K)::Point_2& p,
template < class K >
inline
Comparison_result
compare_y_at_x(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Segment_2 &s, const K& k)
compare_y_at_x(const typename K::Point_2 &p,
const typename K::Segment_2 &s, const K& k)
{
return k.compare_y_at_x_2_object()(p, s);
}
@ -321,9 +321,9 @@ compare_y_at_x(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
Comparison_result
compare_x_at_y(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Line_2 &h1,
const typename CGAL_WRAP(K)::Line_2 &h2, const K& k)
compare_x_at_y(const typename K::Point_2 &p,
const typename K::Line_2 &h1,
const typename K::Line_2 &h2, const K& k)
{
return k.compare_x_at_y_2_object()(p, h1, h2);
}
@ -331,9 +331,9 @@ compare_x_at_y(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
Comparison_result
compare_x_at_y(const typename CGAL_WRAP(K)::Line_2 &l1,
const typename CGAL_WRAP(K)::Line_2 &l2,
const typename CGAL_WRAP(K)::Line_2 &h, const K& k)
compare_x_at_y(const typename K::Line_2 &l1,
const typename K::Line_2 &l2,
const typename K::Line_2 &h, const K& k)
{
return k.compare_x_at_y_2_object()(l1, l2, h);
}
@ -341,10 +341,10 @@ compare_x_at_y(const typename CGAL_WRAP(K)::Line_2 &l1,
template < class K >
inline
Comparison_result
compare_x_at_y(const typename CGAL_WRAP(K)::Line_2 &l1,
const typename CGAL_WRAP(K)::Line_2 &l2,
const typename CGAL_WRAP(K)::Line_2 &h1,
const typename CGAL_WRAP(K)::Line_2 &h2, const K& k)
compare_x_at_y(const typename K::Line_2 &l1,
const typename K::Line_2 &l2,
const typename K::Line_2 &h1,
const typename K::Line_2 &h2, const K& k)
{
return k.compare_x_at_y_2_object()(l1, l2, h1, h2);
}
@ -352,8 +352,8 @@ compare_x_at_y(const typename CGAL_WRAP(K)::Line_2 &l1,
template < class K >
inline
Comparison_result
compare_xy(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q, const K& k)
compare_xy(const typename K::Point_2 &p,
const typename K::Point_2 &q, const K& k)
{
return k.compare_xy_2_object()(p, q);
}
@ -361,8 +361,8 @@ compare_xy(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
Comparison_result
compare_yx(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q, const K& k)
compare_yx(const typename K::Point_2 &p,
const typename K::Point_2 &q, const K& k)
{
return k.compare_yx_2_object()(p, q);
}
@ -370,8 +370,8 @@ compare_yx(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
Comparison_result
compare_y(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q, const K& k)
compare_y(const typename K::Point_2 &p,
const typename K::Point_2 &q, const K& k)
{
return k.compare_y_2_object()(p, q);
}
@ -379,9 +379,9 @@ compare_y(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
Comparison_result
compare_y(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Line_2 &l1,
const typename CGAL_WRAP(K)::Line_2 &l2, const K& k)
compare_y(const typename K::Point_2 &p,
const typename K::Line_2 &l1,
const typename K::Line_2 &l2, const K& k)
{
return k.compare_y_2_object()(p, l1, l2);
}
@ -389,10 +389,10 @@ compare_y(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
Comparison_result
compare_y(const typename CGAL_WRAP(K)::Line_2 &l1,
const typename CGAL_WRAP(K)::Line_2 &l2,
const typename CGAL_WRAP(K)::Line_2 &h1,
const typename CGAL_WRAP(K)::Line_2 &h2, const K& k)
compare_y(const typename K::Line_2 &l1,
const typename K::Line_2 &l2,
const typename K::Line_2 &h1,
const typename K::Line_2 &h2, const K& k)
{
return k.compare_y_2_object()(l1, l2, h1, h2);
}
@ -400,9 +400,9 @@ compare_y(const typename CGAL_WRAP(K)::Line_2 &l1,
template < class K >
inline
Comparison_result
compare_y(const typename CGAL_WRAP(K)::Line_2 &l,
const typename CGAL_WRAP(K)::Line_2 &h1,
const typename CGAL_WRAP(K)::Line_2 &h2, const K& k)
compare_y(const typename K::Line_2 &l,
const typename K::Line_2 &h1,
const typename K::Line_2 &h2, const K& k)
{
return k.compare_y_2_object()(l, h1, h2);
}
@ -410,8 +410,8 @@ compare_y(const typename CGAL_WRAP(K)::Line_2 &l,
template < class K >
inline
Comparison_result
compare_y_at_x(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Segment_2 &s, const K& k)
compare_y_at_x(const typename K::Point_2 &p,
const typename K::Segment_2 &s, const K& k)
{
return k.compare_y_at_x_2_object()(p, s);
}
@ -419,9 +419,9 @@ compare_y_at_x(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
Comparison_result
compare_y_at_x(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Segment_2 &s1,
const typename CGAL_WRAP(K)::Segment_2 &s2, const K& k)
compare_y_at_x(const typename K::Point_2 &p,
const typename K::Segment_2 &s1,
const typename K::Segment_2 &s2, const K& k)
{
return k.compare_y_at_x_2_object()(p, s1, s2);
}
@ -429,8 +429,8 @@ compare_y_at_x(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
Comparison_result
compare_y_at_x(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Line_2 &l, const K& k)
compare_y_at_x(const typename K::Point_2 &p,
const typename K::Line_2 &l, const K& k)
{
return k.compare_y_at_x_2_object()(p, l);
}
@ -438,9 +438,9 @@ compare_y_at_x(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
Comparison_result
compare_y_at_x(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Line_2 &h1,
const typename CGAL_WRAP(K)::Line_2 &h2, const K& k)
compare_y_at_x(const typename K::Point_2 &p,
const typename K::Line_2 &h1,
const typename K::Line_2 &h2, const K& k)
{
return k.compare_y_at_x_2_object()(p, h1, h2);
}
@ -448,9 +448,9 @@ compare_y_at_x(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
Comparison_result
compare_y_at_x(const typename CGAL_WRAP(K)::Line_2 &l1,
const typename CGAL_WRAP(K)::Line_2 &l2,
const typename CGAL_WRAP(K)::Line_2 &h, const K& k)
compare_y_at_x(const typename K::Line_2 &l1,
const typename K::Line_2 &l2,
const typename K::Line_2 &h, const K& k)
{
return k.compare_y_at_x_2_object()(l1, l2, h);
}
@ -458,10 +458,10 @@ compare_y_at_x(const typename CGAL_WRAP(K)::Line_2 &l1,
template < class K >
inline
Comparison_result
compare_y_at_x(const typename CGAL_WRAP(K)::Line_2 &l1,
const typename CGAL_WRAP(K)::Line_2 &l2,
const typename CGAL_WRAP(K)::Line_2 &h1,
const typename CGAL_WRAP(K)::Line_2 &h2, const K& k)
compare_y_at_x(const typename K::Line_2 &l1,
const typename K::Line_2 &l2,
const typename K::Line_2 &h1,
const typename K::Line_2 &h2, const K& k)
{
return k.compare_y_at_x_2_object()(l1, l2, h1, h2);
}
@ -469,8 +469,8 @@ compare_y_at_x(const typename CGAL_WRAP(K)::Line_2 &l1,
template < class K >
inline
typename K::FT
determinant(const typename CGAL_WRAP(K)::Vector_2 &v0,
const typename CGAL_WRAP(K)::Vector_2 &v1, const K &k)
determinant(const typename K::Vector_2 &v0,
const typename K::Vector_2 &v1, const K &k)
{
return k.compute_determinant_2_object()(v0, v1);
}
@ -478,9 +478,9 @@ determinant(const typename CGAL_WRAP(K)::Vector_2 &v0,
template <class K>
inline
bool
has_larger_distance_to_point(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
const typename CGAL_WRAP(K)::Point_2 &r,
has_larger_distance_to_point(const typename K::Point_2 &p,
const typename K::Point_2 &q,
const typename K::Point_2 &r,
const K& k)
{
return k.less_distance_to_point_2_object()(p, r, q);
@ -489,9 +489,9 @@ has_larger_distance_to_point(const typename CGAL_WRAP(K)::Point_2 &p,
template <class K>
inline
bool
has_smaller_distance_to_point(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
const typename CGAL_WRAP(K)::Point_2 &r,
has_smaller_distance_to_point(const typename K::Point_2 &p,
const typename K::Point_2 &q,
const typename K::Point_2 &r,
const K& k)
{
return k.less_distance_to_point_2_object()(p, q, r);
@ -500,9 +500,9 @@ has_smaller_distance_to_point(const typename CGAL_WRAP(K)::Point_2 &p,
template <class K>
inline
bool
has_smaller_signed_distance_to_line(const typename CGAL_WRAP(K)::Line_2& l,
const typename CGAL_WRAP(K)::Point_2& p,
const typename CGAL_WRAP(K)::Point_2& q,
has_smaller_signed_distance_to_line(const typename K::Line_2& l,
const typename K::Point_2& p,
const typename K::Point_2& q,
const K& k)
{
return k.less_signed_distance_to_line_2_object()(l, p, q);
@ -511,9 +511,9 @@ has_smaller_signed_distance_to_line(const typename CGAL_WRAP(K)::Line_2& l,
template <class K>
inline
bool
has_larger_signed_distance_to_line(const typename CGAL_WRAP(K)::Line_2& l,
const typename CGAL_WRAP(K)::Point_2& p,
const typename CGAL_WRAP(K)::Point_2& q,
has_larger_signed_distance_to_line(const typename K::Line_2& l,
const typename K::Point_2& p,
const typename K::Point_2& q,
const K& k)
{
return k.less_signed_distance_to_line_2_object()(l, q, p);
@ -522,10 +522,10 @@ has_larger_signed_distance_to_line(const typename CGAL_WRAP(K)::Line_2& l,
template <class K>
inline
bool
has_larger_signed_distance_to_line(const typename CGAL_WRAP(K)::Point_2& p,
const typename CGAL_WRAP(K)::Point_2& q,
const typename CGAL_WRAP(K)::Point_2& r,
const typename CGAL_WRAP(K)::Point_2& s,
has_larger_signed_distance_to_line(const typename K::Point_2& p,
const typename K::Point_2& q,
const typename K::Point_2& r,
const typename K::Point_2& s,
const K& k)
{
return k.less_signed_distance_to_line_2_object()(p, q, s, r);
@ -534,10 +534,10 @@ has_larger_signed_distance_to_line(const typename CGAL_WRAP(K)::Point_2& p,
template <class K>
inline
bool
has_smaller_signed_distance_to_line(const typename CGAL_WRAP(K)::Point_2& p,
const typename CGAL_WRAP(K)::Point_2& q,
const typename CGAL_WRAP(K)::Point_2& r,
const typename CGAL_WRAP(K)::Point_2& s,
has_smaller_signed_distance_to_line(const typename K::Point_2& p,
const typename K::Point_2& q,
const typename K::Point_2& r,
const typename K::Point_2& s,
const K& k)
{
return k.less_signed_distance_to_line_2_object()(p, q, r, s);
@ -546,9 +546,9 @@ has_smaller_signed_distance_to_line(const typename CGAL_WRAP(K)::Point_2& p,
template < class K >
inline
bool
left_turn(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
const typename CGAL_WRAP(K)::Point_2 &r, const K& k)
left_turn(const typename K::Point_2 &p,
const typename K::Point_2 &q,
const typename K::Point_2 &r, const K& k)
{
return k.left_turn_2_object()(p, q, r);
}
@ -556,8 +556,8 @@ left_turn(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
bool
less_x(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q, const K& k)
less_x(const typename K::Point_2 &p,
const typename K::Point_2 &q, const K& k)
{
return k.less_x_2_object()(p, q);
}
@ -565,8 +565,8 @@ less_x(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
bool
less_y(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q, const K& k)
less_y(const typename K::Point_2 &p,
const typename K::Point_2 &q, const K& k)
{
return k.less_y_2_object()(p, q);
}
@ -574,8 +574,8 @@ less_y(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
bool
lexicographically_xy_larger(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
lexicographically_xy_larger(const typename K::Point_2 &p,
const typename K::Point_2 &q,
const K& k)
{
return k.compare_xy_2_object()(p, q) == LARGER;
@ -584,8 +584,8 @@ lexicographically_xy_larger(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
bool
lexicographically_xy_larger_or_equal(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
lexicographically_xy_larger_or_equal(const typename K::Point_2 &p,
const typename K::Point_2 &q,
const K& k)
{
return k.compare_xy_2_object()(p, q) != SMALLER;
@ -594,8 +594,8 @@ lexicographically_xy_larger_or_equal(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
bool
lexicographically_xy_smaller(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
lexicographically_xy_smaller(const typename K::Point_2 &p,
const typename K::Point_2 &q,
const K& k)
{
return k.less_xy_2_object()(p, q);
@ -604,8 +604,8 @@ lexicographically_xy_smaller(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
bool
lexicographically_xy_smaller_or_equal(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
lexicographically_xy_smaller_or_equal(const typename K::Point_2 &p,
const typename K::Point_2 &q,
const K& k)
{
return k.compare_xy_2_object()(p, q) != LARGER;
@ -614,8 +614,8 @@ lexicographically_xy_smaller_or_equal(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
bool
lexicographically_yx_smaller(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
lexicographically_yx_smaller(const typename K::Point_2 &p,
const typename K::Point_2 &q,
const K& k)
{
return k.less_yx_2_object()(p, q);
@ -624,8 +624,8 @@ lexicographically_yx_smaller(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
bool
lexicographically_yx_smaller_or_equal(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
lexicographically_yx_smaller_or_equal(const typename K::Point_2 &p,
const typename K::Point_2 &q,
const K& k)
{
return !k.less_yx_2_object()(q, p);
@ -635,8 +635,8 @@ lexicographically_yx_smaller_or_equal(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
bool
lexicographically_yx_larger(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
lexicographically_yx_larger(const typename K::Point_2 &p,
const typename K::Point_2 &q,
const K& k)
{
return k.less_yx_2_object()(q, p);
@ -646,8 +646,8 @@ lexicographically_yx_larger(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
bool
lexicographically_yx_larger_or_equal(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
lexicographically_yx_larger_or_equal(const typename K::Point_2 &p,
const typename K::Point_2 &q,
const K& k)
{
return !k.less_yx_2_object()(p, q);
@ -656,8 +656,8 @@ lexicographically_yx_larger_or_equal(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
typename K::Point_2
midpoint(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q, const K &k)
midpoint(const typename K::Point_2 &p,
const typename K::Point_2 &q, const K &k)
{
return k.construct_midpoint_2_object()(p, q);
}
@ -665,7 +665,7 @@ midpoint(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
typename K::Point_2
max_vertex(const typename CGAL_WRAP(K)::Iso_rectangle_2 &ir, const K &k)
max_vertex(const typename K::Iso_rectangle_2 &ir, const K &k)
{
return k.construct_max_vertex_2_object()(ir);
}
@ -673,7 +673,7 @@ max_vertex(const typename CGAL_WRAP(K)::Iso_rectangle_2 &ir, const K &k)
template < class K >
inline
typename K::Point_2
min_vertex(const typename CGAL_WRAP(K)::Iso_rectangle_2 &ir, const K &k)
min_vertex(const typename K::Iso_rectangle_2 &ir, const K &k)
{
return k.construct_min_vertex_2_object()(ir);
}
@ -681,9 +681,9 @@ min_vertex(const typename CGAL_WRAP(K)::Iso_rectangle_2 &ir, const K &k)
template <typename K>
inline
Orientation
orientation(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
const typename CGAL_WRAP(K)::Point_2 &r, const K &k)
orientation(const typename K::Point_2 &p,
const typename K::Point_2 &q,
const typename K::Point_2 &r, const K &k)
{
return k.orientation_2_object()(p, q, r);
}
@ -691,8 +691,8 @@ orientation(const typename CGAL_WRAP(K)::Point_2 &p,
template <typename K>
inline
Orientation
orientation(const typename CGAL_WRAP(K)::Vector_2 &u,
const typename CGAL_WRAP(K)::Vector_2 &v, const K &k)
orientation(const typename K::Vector_2 &u,
const typename K::Vector_2 &v, const K &k)
{
return k.orientation_2_object()(u, v);
}
@ -700,8 +700,8 @@ orientation(const typename CGAL_WRAP(K)::Vector_2 &u,
template <typename K>
inline
bool
parallel(const typename CGAL_WRAP(K)::Line_2 &l1,
const typename CGAL_WRAP(K)::Line_2 &l2, const K &k)
parallel(const typename K::Line_2 &l1,
const typename K::Line_2 &l2, const K &k)
{
return k.are_parallel_2_object()(l1, l2);
}
@ -709,8 +709,8 @@ parallel(const typename CGAL_WRAP(K)::Line_2 &l1,
template <typename K>
inline
bool
parallel(const typename CGAL_WRAP(K)::Ray_2 &r1,
const typename CGAL_WRAP(K)::Ray_2 &r2, const K &k)
parallel(const typename K::Ray_2 &r1,
const typename K::Ray_2 &r2, const K &k)
{
return k.are_parallel_2_object()(r1, r2);
}
@ -718,8 +718,8 @@ parallel(const typename CGAL_WRAP(K)::Ray_2 &r1,
template <typename K>
inline
bool
parallel(const typename CGAL_WRAP(K)::Segment_2 &s1,
const typename CGAL_WRAP(K)::Segment_2 &s2, const K &k)
parallel(const typename K::Segment_2 &s1,
const typename K::Segment_2 &s2, const K &k)
{
return k.are_parallel_2_object()(s1, s2);
}
@ -727,9 +727,9 @@ parallel(const typename CGAL_WRAP(K)::Segment_2 &s1,
template <typename K>
inline
bool
right_turn(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
const typename CGAL_WRAP(K)::Point_2 &r, const K &k)
right_turn(const typename K::Point_2 &p,
const typename K::Point_2 &q,
const typename K::Point_2 &r, const K &k)
{
return CGALi::orientation(p, q, r, k) == RIGHT_TURN;
}
@ -737,10 +737,10 @@ right_turn(const typename CGAL_WRAP(K)::Point_2 &p,
template <class K>
inline
Bounded_side
side_of_bounded_circle(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
const typename CGAL_WRAP(K)::Point_2 &r,
const typename CGAL_WRAP(K)::Point_2 &t, const K &k)
side_of_bounded_circle(const typename K::Point_2 &p,
const typename K::Point_2 &q,
const typename K::Point_2 &r,
const typename K::Point_2 &t, const K &k)
{
return k.side_of_bounded_circle_2_object()(p, q, r, t);
}
@ -748,9 +748,9 @@ side_of_bounded_circle(const typename CGAL_WRAP(K)::Point_2 &p,
template <class K>
inline
Bounded_side
side_of_bounded_circle(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
const typename CGAL_WRAP(K)::Point_2 &r, const K &k)
side_of_bounded_circle(const typename K::Point_2 &p,
const typename K::Point_2 &q,
const typename K::Point_2 &r, const K &k)
{
return k.side_of_bounded_circle_2_object()(p, q, r);
}
@ -758,10 +758,10 @@ side_of_bounded_circle(const typename CGAL_WRAP(K)::Point_2 &p,
template <class K>
inline
Oriented_side
side_of_oriented_circle(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
const typename CGAL_WRAP(K)::Point_2 &r,
const typename CGAL_WRAP(K)::Point_2 &t, const K &k)
side_of_oriented_circle(const typename K::Point_2 &p,
const typename K::Point_2 &q,
const typename K::Point_2 &r,
const typename K::Point_2 &t, const K &k)
{
return k.side_of_oriented_circle_2_object()(p, q, r, t);
}
@ -769,8 +769,8 @@ side_of_oriented_circle(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
typename K::FT
squared_radius(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q, const K &k)
squared_radius(const typename K::Point_2 &p,
const typename K::Point_2 &q, const K &k)
{
return k.compute_squared_radius_2_object()(p, q);
}
@ -778,9 +778,9 @@ squared_radius(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
CGAL_KERNEL_INLINE
typename K::FT
squared_radius(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q,
const typename CGAL_WRAP(K)::Point_2 &r, const K &k)
squared_radius(const typename K::Point_2 &p,
const typename K::Point_2 &q,
const typename K::Point_2 &r, const K &k)
{
return k.compute_squared_radius_2_object()(p, q, r);
}
@ -788,8 +788,8 @@ squared_radius(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
bool
x_equal(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q, const K &k)
x_equal(const typename K::Point_2 &p,
const typename K::Point_2 &q, const K &k)
{
return k.equal_x_2_object()(p, q);
}
@ -797,8 +797,8 @@ x_equal(const typename CGAL_WRAP(K)::Point_2 &p,
template < class K >
inline
bool
y_equal(const typename CGAL_WRAP(K)::Point_2 &p,
const typename CGAL_WRAP(K)::Point_2 &q, const K &k)
y_equal(const typename K::Point_2 &p,
const typename K::Point_2 &q, const K &k)
{
return k.equal_y_2_object()(p, q);
}

382
Kernel_23/include/CGAL/Kernel/global_functions_internal_3.h
View File

@ -34,9 +34,9 @@ namespace CGALi {
template <typename K>
inline
Angle
angle(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r, const K &k)
angle(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r, const K &k)
{
return k.angle_3_object()(p, q, r);
}
@ -44,9 +44,9 @@ angle(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
bool
are_ordered_along_line(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r, const K& k)
are_ordered_along_line(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r, const K& k)
{
return k.are_ordered_along_line_3_object()(p, q, r);
}
@ -54,9 +54,9 @@ are_ordered_along_line(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
bool
are_strictly_ordered_along_line(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r,
are_strictly_ordered_along_line(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r,
const K& k)
{
return k.are_strictly_ordered_along_line_3_object()(p, q, r);
@ -65,8 +65,8 @@ are_strictly_ordered_along_line(const typename CGAL_WRAP(K)::Point_3 &p,
template <typename K>
inline
typename K::Plane_3
bisector(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q, const K &k)
bisector(const typename K::Point_3 &p,
const typename K::Point_3 &q, const K &k)
{
return k.construct_bisector_3_object()(p, q);
}
@ -74,8 +74,8 @@ bisector(const typename CGAL_WRAP(K)::Point_3 &p,
template <typename K>
inline
typename K::Plane_3
bisector(const typename CGAL_WRAP(K)::Plane_3 &h1,
const typename CGAL_WRAP(K)::Plane_3 &h2, const K &k)
bisector(const typename K::Plane_3 &h1,
const typename K::Plane_3 &h2, const K &k)
{
return k.construct_bisector_3_object()(h1, h2);
}
@ -83,10 +83,10 @@ bisector(const typename CGAL_WRAP(K)::Plane_3 &h1,
template < class K >
inline
typename K::Point_3
centroid(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r,
const typename CGAL_WRAP(K)::Point_3 &s, const K &k)
centroid(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r,
const typename K::Point_3 &s, const K &k)
{
return k.construct_centroid_3_object()(p, q, r, s);
}
@ -94,9 +94,9 @@ centroid(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
typename K::Point_3
centroid(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r, const K &k)
centroid(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r, const K &k)
{
return k.construct_centroid_3_object()(p, q, r);
}
@ -104,7 +104,7 @@ centroid(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
typename K::Point_3
centroid(const typename CGAL_WRAP(K)::Tetrahedron_3 &t, const K &k)
centroid(const typename K::Tetrahedron_3 &t, const K &k)
{
return k.construct_centroid_3_object()(t);
}
@ -112,7 +112,7 @@ centroid(const typename CGAL_WRAP(K)::Tetrahedron_3 &t, const K &k)
template < class K >
inline
typename K::Point_3
centroid(const typename CGAL_WRAP(K)::Triangle_3 &t, const K &k)
centroid(const typename K::Triangle_3 &t, const K &k)
{
return k.construct_centroid_3_object()(t);
}
@ -120,8 +120,8 @@ centroid(const typename CGAL_WRAP(K)::Triangle_3 &t, const K &k)
template < class K >
inline
typename K::Point_3
circumcenter(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q, const K &k)
circumcenter(const typename K::Point_3 &p,
const typename K::Point_3 &q, const K &k)
{
return k.construct_circumcenter_3_object()(p, q);
}
@ -129,9 +129,9 @@ circumcenter(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
typename K::Point_3
circumcenter(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r, const K &k)
circumcenter(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r, const K &k)
{
return k.construct_circumcenter_3_object()(p, q, r);
}
@ -139,10 +139,10 @@ circumcenter(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
typename K::Point_3
circumcenter(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r,
const typename CGAL_WRAP(K)::Point_3 &s, const K &k)
circumcenter(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r,
const typename K::Point_3 &s, const K &k)
{
return k.construct_circumcenter_3_object()(p, q, r, s);
}
@ -150,7 +150,7 @@ circumcenter(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
typename K::Point_3
circumcenter(const typename CGAL_WRAP(K)::Tetrahedron_3 &t, const K& k)
circumcenter(const typename K::Tetrahedron_3 &t, const K& k)
{
return k.construct_circumcenter_3_object()(t);
}
@ -158,7 +158,7 @@ circumcenter(const typename CGAL_WRAP(K)::Tetrahedron_3 &t, const K& k)
template < class K >
inline
typename K::Point_3
circumcenter(const typename CGAL_WRAP(K)::Triangle_3 &t, const K& k)
circumcenter(const typename K::Triangle_3 &t, const K& k)
{
return k.construct_circumcenter_3_object()(t);
}
@ -166,9 +166,9 @@ circumcenter(const typename CGAL_WRAP(K)::Triangle_3 &t, const K& k)
template < class K >
inline
bool
collinear(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r,
collinear(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r,
const K& k)
{
return k.collinear_3_object()(p, q, r);
@ -178,9 +178,9 @@ template < class K >
inline
bool
collinear_are_ordered_along_line(
const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r,
const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r,
const K& k)
{
return k.collinear_are_ordered_along_line_3_object()(p, q, r);
@ -190,9 +190,9 @@ template < class K >
inline
bool
collinear_are_strictly_ordered_along_line(
const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r,
const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r,
const K& k)
{
return k.collinear_are_strictly_ordered_along_line_3_object()(p, q, r);
@ -201,9 +201,9 @@ collinear_are_strictly_ordered_along_line(
template < class K >
inline
Comparison_result
compare_distance_to_point(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r,
compare_distance_to_point(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r,
const K& k)
{
return k.compare_distance_3_object()(p, q, r);
@ -212,9 +212,9 @@ compare_distance_to_point(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
Comparison_result
compare_squared_distance(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::FT &d2,
compare_squared_distance(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::FT &d2,
const K& k)
{
return k.compare_squared_distance_3_object()(p, q, d2);
@ -223,8 +223,8 @@ compare_squared_distance(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
Comparison_result
compare_lexicographically_xyz(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
compare_lexicographically_xyz(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const K& k)
{
return k.compare_xyz_3_object()(p, q);
@ -233,9 +233,9 @@ compare_lexicographically_xyz(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
Comparison_result
compare_signed_distance_to_plane(const typename CGAL_WRAP(K)::Plane_3 &h,
const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
compare_signed_distance_to_plane(const typename K::Plane_3 &h,
const typename K::Point_3 &p,
const typename K::Point_3 &q,
const K &k)
{
if (k.less_signed_distance_to_plane_3_object()(h, p, q)) return SMALLER;
@ -246,11 +246,11 @@ compare_signed_distance_to_plane(const typename CGAL_WRAP(K)::Plane_3 &h,
template < class K >
inline
Comparison_result
compare_signed_distance_to_plane(const typename CGAL_WRAP(K)::Point_3 &hp,
const typename CGAL_WRAP(K)::Point_3 &hq,
const typename CGAL_WRAP(K)::Point_3 &hr,
const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
compare_signed_distance_to_plane(const typename K::Point_3 &hp,
const typename K::Point_3 &hq,
const typename K::Point_3 &hr,
const typename K::Point_3 &p,
const typename K::Point_3 &q,
const K &k)
{
if (k.less_signed_distance_to_plane_3_object()(hp, hq, hr, p, q))
@ -263,8 +263,8 @@ compare_signed_distance_to_plane(const typename CGAL_WRAP(K)::Point_3 &hp,
template < class K >
inline
Comparison_result
compare_x(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
compare_x(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const K &k)
{
return k.compare_x_3_object()(p, q);
@ -273,8 +273,8 @@ compare_x(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
Comparison_result
compare_y(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
compare_y(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const K &k)
{
return k.compare_y_3_object()(p, q);
@ -283,8 +283,8 @@ compare_y(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
Comparison_result
compare_z(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
compare_z(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const K &k)
{
return k.compare_z_3_object()(p, q);
@ -293,8 +293,8 @@ compare_z(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
Comparison_result
compare_xyz(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
compare_xyz(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const K &k)
{
return k.compare_xyz_3_object()(p, q);
@ -303,10 +303,10 @@ compare_xyz(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
bool
coplanar(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r,
const typename CGAL_WRAP(K)::Point_3 &s, const K& k)
coplanar(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r,
const typename K::Point_3 &s, const K& k)
{
return k.coplanar_3_object()(p, q, r, s);
}
@ -314,10 +314,10 @@ coplanar(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
Orientation
coplanar_orientation(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r,
const typename CGAL_WRAP(K)::Point_3 &s, const K& k)
coplanar_orientation(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r,
const typename K::Point_3 &s, const K& k)
{
return k.coplanar_orientation_3_object()(p, q, r, s);
}
@ -325,9 +325,9 @@ coplanar_orientation(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
Orientation
coplanar_orientation(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r, const K& k)
coplanar_orientation(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r, const K& k)
{
return k.coplanar_orientation_3_object()(p, q, r);
}
@ -335,10 +335,10 @@ coplanar_orientation(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
Bounded_side
coplanar_side_of_bounded_circle(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r,
const typename CGAL_WRAP(K)::Point_3 &t,
coplanar_side_of_bounded_circle(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r,
const typename K::Point_3 &t,
const K& k)
{
return k.coplanar_side_of_bounded_circle_3_object()(p, q, r, t);
@ -347,8 +347,8 @@ coplanar_side_of_bounded_circle(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
typename K::Vector_3
cross_product(const typename CGAL_WRAP(K)::Vector_3 &v,
const typename CGAL_WRAP(K)::Vector_3 &w, const K& k)
cross_product(const typename K::Vector_3 &v,
const typename K::Vector_3 &w, const K& k)
{
return k.construct_cross_product_vector_3_object()(v, w);
}
@ -356,9 +356,9 @@ cross_product(const typename CGAL_WRAP(K)::Vector_3 &v,
template < class K >
inline
typename K::FT
determinant(const typename CGAL_WRAP(K)::Vector_3 &v0,
const typename CGAL_WRAP(K)::Vector_3 &v1,
const typename CGAL_WRAP(K)::Vector_3 &v2, const K &k)
determinant(const typename K::Vector_3 &v0,
const typename K::Vector_3 &v1,
const typename K::Vector_3 &v2, const K &k)
{
return k.compute_determinant_3_object()(v0, v1, v2);
}
@ -366,9 +366,9 @@ determinant(const typename CGAL_WRAP(K)::Vector_3 &v0,
template < class K >
inline
typename K::Line_3
equidistant_line(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r, const K& k)
equidistant_line(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r, const K& k)
{
return k.construct_equidistant_line_3_object()(p, q, r);
}
@ -376,9 +376,9 @@ equidistant_line(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
bool
has_smaller_distance_to_point(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r,
has_smaller_distance_to_point(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r,
const K &k)
{
return k.less_distance_to_point_3_object()(p, q, r);
@ -387,9 +387,9 @@ has_smaller_distance_to_point(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
bool
has_larger_distance_to_point(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r,
has_larger_distance_to_point(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r,
const K &k)
{
return k.compare_distance_3_object()(p, q, r) == LARGER;
@ -398,9 +398,9 @@ has_larger_distance_to_point(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
bool
has_larger_signed_distance_to_plane(const typename CGAL_WRAP(K)::Plane_3 &h,
const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
has_larger_signed_distance_to_plane(const typename K::Plane_3 &h,
const typename K::Point_3 &p,
const typename K::Point_3 &q,
const K &k)
{
return k.less_signed_distance_to_plane_3_object()(h, q, p);
@ -409,11 +409,11 @@ has_larger_signed_distance_to_plane(const typename CGAL_WRAP(K)::Plane_3 &h,
template < class K >
inline
bool
has_larger_signed_distance_to_plane(const typename CGAL_WRAP(K)::Point_3 &hp,
const typename CGAL_WRAP(K)::Point_3 &hq,
const typename CGAL_WRAP(K)::Point_3 &hr,
const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
has_larger_signed_distance_to_plane(const typename K::Point_3 &hp,
const typename K::Point_3 &hq,
const typename K::Point_3 &hr,
const typename K::Point_3 &p,
const typename K::Point_3 &q,
const K &k)
{
return k.less_signed_distance_to_plane_3_object()(hp, hq, hr, q, p);
@ -422,9 +422,9 @@ has_larger_signed_distance_to_plane(const typename CGAL_WRAP(K)::Point_3 &hp,
template < class K >
inline
bool
has_smaller_signed_distance_to_plane(const typename CGAL_WRAP(K)::Plane_3 &h,
const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
has_smaller_signed_distance_to_plane(const typename K::Plane_3 &h,
const typename K::Point_3 &p,
const typename K::Point_3 &q,
const K &k)
{
return k.less_signed_distance_to_plane_3_object()(h, p, q);
@ -433,11 +433,11 @@ has_smaller_signed_distance_to_plane(const typename CGAL_WRAP(K)::Plane_3 &h,
template < class K >
inline
bool
has_smaller_signed_distance_to_plane(const typename CGAL_WRAP(K)::Point_3 &hp,
const typename CGAL_WRAP(K)::Point_3 &hq,
const typename CGAL_WRAP(K)::Point_3 &hr,
const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
has_smaller_signed_distance_to_plane(const typename K::Point_3 &hp,
const typename K::Point_3 &hq,
const typename K::Point_3 &hr,
const typename K::Point_3 &p,
const typename K::Point_3 &q,
const K &k)
{
return k.less_signed_distance_to_plane_3_object()(hp, hq, hr, p, q);
@ -446,8 +446,8 @@ has_smaller_signed_distance_to_plane(const typename CGAL_WRAP(K)::Point_3 &hp,
template < class K >
inline
bool
less_x(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
less_x(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const K &k)
{
return k.less_x_3_object()(p, q);
@ -456,8 +456,8 @@ less_x(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
bool
less_y(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
less_y(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const K &k)
{
return k.less_y_3_object()(p, q);
@ -466,8 +466,8 @@ less_y(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
bool
less_z(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
less_z(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const K &k)
{
return k.less_z_3_object()(p, q);
@ -476,8 +476,8 @@ less_z(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
bool
lexicographically_xyz_smaller(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
lexicographically_xyz_smaller(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const K &k)
{
return k.less_xyz_3_object()(p, q);
@ -486,8 +486,8 @@ lexicographically_xyz_smaller(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
typename K::Point_3
midpoint(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q, const K &k)
midpoint(const typename K::Point_3 &p,
const typename K::Point_3 &q, const K &k)
{
return k.construct_midpoint_3_object()(p, q);
}
@ -495,7 +495,7 @@ midpoint(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
typename K::Point_3
max_vertex(const typename CGAL_WRAP(K)::Iso_cuboid_3 &ic, const K &k)
max_vertex(const typename K::Iso_cuboid_3 &ic, const K &k)
{
return k.construct_max_vertex_3_object()(ic);
}
@ -503,7 +503,7 @@ max_vertex(const typename CGAL_WRAP(K)::Iso_cuboid_3 &ic, const K &k)
template < class K >
inline
typename K::Point_3
min_vertex(const typename CGAL_WRAP(K)::Iso_cuboid_3 &ic, const K &k)
min_vertex(const typename K::Iso_cuboid_3 &ic, const K &k)
{
return k.construct_min_vertex_3_object()(ic);
}
@ -511,10 +511,10 @@ min_vertex(const typename CGAL_WRAP(K)::Iso_cuboid_3 &ic, const K &k)
template <class K >
inline
Orientation
orientation(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r,
const typename CGAL_WRAP(K)::Point_3 &s, const K &k)
orientation(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r,
const typename K::Point_3 &s, const K &k)
{
return k.orientation_3_object()(p, q, r, s);
}
@ -522,9 +522,9 @@ orientation(const typename CGAL_WRAP(K)::Point_3 &p,
template <class K >
inline
Orientation
orientation(const typename CGAL_WRAP(K)::Vector_3 &u,
const typename CGAL_WRAP(K)::Vector_3 &v,
const typename CGAL_WRAP(K)::Vector_3 &w, const K &k)
orientation(const typename K::Vector_3 &u,
const typename K::Vector_3 &v,
const typename K::Vector_3 &w, const K &k)
{
return k.orientation_3_object()(u, v, w);
}
@ -532,9 +532,9 @@ orientation(const typename CGAL_WRAP(K)::Vector_3 &u,
template < class K >
inline
typename K::Vector_3
orthogonal_vector(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r, const K &k)
orthogonal_vector(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r, const K &k)
{
return k.construct_orthogonal_vector_3_object()(p, q, r);
}
@ -542,7 +542,7 @@ orthogonal_vector(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
typename K::Vector_3
orthogonal_vector(const typename CGAL_WRAP(K)::Plane_3 &p, const K &k)
orthogonal_vector(const typename K::Plane_3 &p, const K &k)
{
return k.construct_orthogonal_vector_3_object()(p);
}
@ -550,8 +550,8 @@ orthogonal_vector(const typename CGAL_WRAP(K)::Plane_3 &p, const K &k)
template <typename K>
inline
bool
parallel(const typename CGAL_WRAP(K)::Line_3 &l1,
const typename CGAL_WRAP(K)::Line_3 &l2, const K &k)
parallel(const typename K::Line_3 &l1,
const typename K::Line_3 &l2, const K &k)
{
return k.are_parallel_3_object()(l1, l2);
}
@ -559,8 +559,8 @@ parallel(const typename CGAL_WRAP(K)::Line_3 &l1,
template <typename K>
inline
bool
parallel(const typename CGAL_WRAP(K)::Plane_3 &h1,
const typename CGAL_WRAP(K)::Plane_3 &h2, const K &k)
parallel(const typename K::Plane_3 &h1,
const typename K::Plane_3 &h2, const K &k)
{
return k.are_parallel_3_object()(h1, h2);
}
@ -568,8 +568,8 @@ parallel(const typename CGAL_WRAP(K)::Plane_3 &h1,
template <typename K>
inline
bool
parallel(const typename CGAL_WRAP(K)::Ray_3 &r1,
const typename CGAL_WRAP(K)::Ray_3 &r2, const K &k)
parallel(const typename K::Ray_3 &r1,
const typename K::Ray_3 &r2, const K &k)
{
return k.are_parallel_3_object()(r1, r2);
}
@ -577,8 +577,8 @@ parallel(const typename CGAL_WRAP(K)::Ray_3 &r1,
template <typename K>
inline
bool
parallel(const typename CGAL_WRAP(K)::Segment_3 &s1,
const typename CGAL_WRAP(K)::Segment_3 &s2, const K &k)
parallel(const typename K::Segment_3 &s1,
const typename K::Segment_3 &s2, const K &k)
{
return k.are_parallel_3_object()(s1, s2);
}
@ -586,9 +586,9 @@ parallel(const typename CGAL_WRAP(K)::Segment_3 &s1,
template <class K >
inline
Bounded_side
side_of_bounded_sphere(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &test, const K &k)
side_of_bounded_sphere(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &test, const K &k)
{
return k.side_of_bounded_sphere_3_object()(p, q, test);
}
@ -596,10 +596,10 @@ side_of_bounded_sphere(const typename CGAL_WRAP(K)::Point_3 &p,
template <class K >
inline
Bounded_side
side_of_bounded_sphere(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r,
const typename CGAL_WRAP(K)::Point_3 &test, const K &k)
side_of_bounded_sphere(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r,
const typename K::Point_3 &test, const K &k)
{
return k.side_of_bounded_sphere_3_object()(p, q, r, test);
}
@ -607,11 +607,11 @@ side_of_bounded_sphere(const typename CGAL_WRAP(K)::Point_3 &p,
template <class K >
inline
Bounded_side
side_of_bounded_sphere(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r,
const typename CGAL_WRAP(K)::Point_3 &s,
const typename CGAL_WRAP(K)::Point_3 &test, const K &k)
side_of_bounded_sphere(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r,
const typename K::Point_3 &s,
const typename K::Point_3 &test, const K &k)
{
return k.side_of_bounded_sphere_3_object()(p, q, r, s, test);
}
@ -619,11 +619,11 @@ side_of_bounded_sphere(const typename CGAL_WRAP(K)::Point_3 &p,
template <class K >
inline
Oriented_side
side_of_oriented_sphere(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r,
const typename CGAL_WRAP(K)::Point_3 &s,
const typename CGAL_WRAP(K)::Point_3 &test, const K &k)
side_of_oriented_sphere(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r,
const typename K::Point_3 &s,
const typename K::Point_3 &test, const K &k)
{
return k.side_of_oriented_sphere_3_object()(p, q, r, s, test);
}
@ -631,9 +631,9 @@ side_of_oriented_sphere(const typename CGAL_WRAP(K)::Point_3 &p,
template <typename K>
inline
typename K::FT
squared_area(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r, const K &k)
squared_area(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r, const K &k)
{
return k.compute_squared_area_3_object()(p, q, r);
}
@ -641,10 +641,10 @@ squared_area(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
typename K::FT
squared_radius(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r,
const typename CGAL_WRAP(K)::Point_3 &s, const K &k)
squared_radius(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r,
const typename K::Point_3 &s, const K &k)
{
return k.compute_squared_radius_3_object()(p, q, r, s);
}
@ -652,9 +652,9 @@ squared_radius(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
typename K::FT
squared_radius(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r, const K &k)
squared_radius(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r, const K &k)
{
return k.compute_squared_radius_3_object()(p, q, r);
}
@ -662,8 +662,8 @@ squared_radius(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
typename K::FT
squared_radius(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q, const K &k)
squared_radius(const typename K::Point_3 &p,
const typename K::Point_3 &q, const K &k)
{
return k.compute_squared_radius_3_object()(p, q);
}
@ -671,10 +671,10 @@ squared_radius(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
typename K::FT
volume(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r,
const typename CGAL_WRAP(K)::Point_3 &s, const K &k)
volume(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r,
const typename K::Point_3 &s, const K &k)
{
return k.compute_volume_3_object()(p, q, r, s);
}
@ -682,8 +682,8 @@ volume(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
bool
x_equal(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q, const K &k)
x_equal(const typename K::Point_3 &p,
const typename K::Point_3 &q, const K &k)
{
return k.equal_x_3_object()(p, q);
}
@ -691,8 +691,8 @@ x_equal(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
bool
y_equal(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q, const K &k)
y_equal(const typename K::Point_3 &p,
const typename K::Point_3 &q, const K &k)
{
return k.equal_y_3_object()(p, q);
}
@ -700,8 +700,8 @@ y_equal(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
bool
z_equal(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q, const K &k)
z_equal(const typename K::Point_3 &p,
const typename K::Point_3 &q, const K &k)
{
return k.equal_z_3_object()(p, q);
}
@ -712,10 +712,10 @@ z_equal(const typename CGAL_WRAP(K)::Point_3 &p,
template <typename K>
inline
bool
are_negative_oriented(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r,
const typename CGAL_WRAP(K)::Point_3 &s, const K &k)
are_negative_oriented(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r,
const typename K::Point_3 &s, const K &k)
{
return CGALi::orientation(p, q, r, s, k) == NEGATIVE;
}
@ -723,10 +723,10 @@ are_negative_oriented(const typename CGAL_WRAP(K)::Point_3 &p,
template <typename K>
inline
bool
are_positive_oriented(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
const typename CGAL_WRAP(K)::Point_3 &r,
const typename CGAL_WRAP(K)::Point_3 &s, const K &k)
are_positive_oriented(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const typename K::Point_3 &r,
const typename K::Point_3 &s, const K &k)
{
return CGALi::orientation(p, q, r, s, k) == POSITIVE;
}
@ -734,8 +734,8 @@ are_positive_oriented(const typename CGAL_WRAP(K)::Point_3 &p,
template < class K >
inline
bool
lexicographically_xyz_smaller_or_equal(const typename CGAL_WRAP(K)::Point_3 &p,
const typename CGAL_WRAP(K)::Point_3 &q,
lexicographically_xyz_smaller_or_equal(const typename K::Point_3 &p,
const typename K::Point_3 &q,
const K&k)
{
return CGALi::compare_lexicographically_xyz(p, q, k) != LARGER;