Namespaces
	NTS

Classes
class	Handle_for

class	Ref_counted

class	Wrapper

class	Object_base

class	Object

Functions
template<class NT >
bool	is_zero (const NT &x)

template<class NT >
bool	is_one (const NT &x)

template<class NT >
bool	is_negative (const NT &x)

template<class NT >
bool	is_positive (const NT &x)

template<class NT >
CGAL_KERNEL_INLINE Sign	sign (const NT &x)

template<class NT >
CGAL_KERNEL_INLINE Sign	lexicographical_sign (const NT &x, const NT &y)

template<class NT >
CGAL_KERNEL_INLINE NT	abs (const NT &x)

template<class NT >
CGAL_KERNEL_INLINE Comparison_result	compare (const NT &n1, const NT &n2)

template<class NT >
NT	square (const NT &n)

template<class T >
Object	make_object (const T &t)

template<class T >
bool	assign (T &t, const Object &o)

template<class PT >
bool	seg_seg_do_intersect_crossing (PT const &p1, PT const &p2, PT const &p3, PT const &p4)

template<class PT >
bool	seg_seg_do_intersect_contained (PT const &p1, PT const &p2, PT const &p3, PT const &p4)

template<class R >
bool	do_intersect (const Segment_2< R > &seg1, const Segment_2< R > &seg2)

Function Documentation

CGAL_KERNEL_INLINE NT CGAL::abs ( const NT & x )

Definition at line 130 of file number_utils.h.

References x.

 {
 #ifndef CGAL_NO_NTS_NAMESPACE
   bool abs_is_obsolete__qualify_call_by_CGAL_NTS;
 #endif // CGAL_NO_NTS_NAMESPACE
   return (x < NT(0)) ? -x: x;
 }

bool CGAL::assign	(	T &	t,
		const Object &	o
	)

Definition at line 138 of file Object.h.

References Object::ptr.

Referenced by Assign::operator()().

 {
 # ifdef CGAL_CFG_DYNAMIC_CAST_BUG
   Wrapper<T>   instantiate_it;
 # endif // CGAL_CFG_DYNAMIC_CAST_BUG
   Wrapper<T>*  wp = dynamic_cast<Wrapper<T>*>(o.ptr);
   if ( wp == static_cast<Wrapper<T>*>(0) ) { return false; }
   t = *(wp);
   return true;
 }

Here is the caller graph for this function:

CGAL_KERNEL_INLINE Comparison_result CGAL::compare	(	const NT &	n1,
		const NT &	n2
	)

Definition at line 143 of file number_utils.h.

References EQUAL, LARGER, and SMALLER.

Referenced by cmp_dist_to_pointC2(), cmp_dist_to_pointC3(), cmp_signed_dist_to_directionC2(), cmp_signed_dist_to_directionC3(), cmp_signed_dist_to_lineC2(), Kdtree_d< Traits >::comp(), Kdtree_d< Traits >::ExtPoint::compare(), compare_deltax_deltayC2(), compare_lexicographically_xyC2(), compare_lexicographically_xyzC3(), compare_x(), compare_xC2(), compare_y(), compare_z(), dominanceC3(), Kdtree_d< Traits >::Node::Plane::is_in(), Compare< NT >::operator()(), tecplot_data::parse(), ComSwitch::parseValuesFromArguments(), sign_of_determinant2x2(), strict_dominanceC3(), and tecplot_data::zone_detect().

 {
 #ifndef CGAL_NO_NTS_NAMESPACE
   bool compare_is_obsolete__qualify_call_by_CGAL_NTS;
 #endif // CGAL_NO_NTS_NAMESPACE
   if (n1 < n2)
   {
     return SMALLER ;
   }
   return (n2 < n1) ? LARGER : EQUAL;
 }

Here is the caller graph for this function:

bool CGAL::do_intersect	(	const Segment_2< R > &	seg1,
		const Segment_2< R > &	seg2
	)

inline

Definition at line 242 of file Segment_2_Segment_2_intersection.h.

References compare_lexicographically_xy(), EQUAL, LARGER, lexicographically_xy_smaller(), lexicographically_yx_smaller(), seg_seg_do_intersect_contained(), seg_seg_do_intersect_crossing(), SMALLER, Segment_2< R, T >::source(), and Segment_2< R, T >::target().

Referenced by Triangulation::is_diagonalie().

 {
     typename R::Point_2 const & A1 = seg1.source();
     typename R::Point_2 const & A2 = seg1.target();
     typename R::Point_2 const & B1 = seg2.source();
     typename R::Point_2 const & B2 = seg2.target();
     if (lexicographically_yx_smaller(A1,A2)) {
         if (lexicographically_yx_smaller(B1,B2)) {
             if (lexicographically_yx_smaller(A2,B1)
              || lexicographically_yx_smaller(B2,A1))
                 return false;
         } else {
             if (lexicographically_yx_smaller(A2,B2)
              || lexicographically_yx_smaller(B1,A1))
                 return false;
         }
     } else {
         if (lexicographically_yx_smaller(B1,B2)) {
             if (lexicographically_yx_smaller(A1,B1)
              || lexicographically_yx_smaller(B2,A2))
                 return false;
         } else {
             if (lexicographically_yx_smaller(A1,B2)
              || lexicographically_yx_smaller(B1,A2))
                 return false;
         }
     }
     if (lexicographically_xy_smaller(A1,A2)) {
         if (lexicographically_xy_smaller(B1,B2)) {
             switch(compare_lexicographically_xy(A1,B1)) {
             case SMALLER:
                 switch(compare_lexicographically_xy(A2,B1)) {
                 case SMALLER:
                     return false;
                 case EQUAL:
                     return true;
                 case LARGER:
                     switch(compare_lexicographically_xy(A2,B2)) {
                     case SMALLER:
                         return seg_seg_do_intersect_crossing(A1,A2,B1,B2);
                     case EQUAL:
                         return true;
                     case LARGER:
                         return seg_seg_do_intersect_contained(A1,A2,B1,B2);
                     }
                 }
             case EQUAL:
                 return true;
             case LARGER:
                 switch(compare_lexicographically_xy(B2,A1)) {
                 case SMALLER:
                     return false;
                 case EQUAL:
                     return true;
                 case LARGER:
                     switch(compare_lexicographically_xy(B2,A2)) {
                     case SMALLER:
                         return seg_seg_do_intersect_crossing(B1,B2,A1,A2);
                     case EQUAL:
                         return true;
                     case LARGER:
                         return seg_seg_do_intersect_contained(B1,B2,A1,A2);
                     }
                 }
             }
         } else {
             switch(compare_lexicographically_xy(A1,B2)) {
             case SMALLER:
                 switch(compare_lexicographically_xy(A2,B2)) {
                 case SMALLER:
                     return false;
                 case EQUAL:
                     return true;
                 case LARGER:
                     switch(compare_lexicographically_xy(A2,B1)) {
                     case SMALLER:
                         return seg_seg_do_intersect_crossing(A1,A2,B2,B1);
                     case EQUAL:
                         return true;
                     case LARGER:
                         return seg_seg_do_intersect_contained(A1,A2,B2,B1);
                     }
                 }
             case EQUAL:
                 return true;
             case LARGER:
                 switch(compare_lexicographically_xy(B1,A1)) {
                 case SMALLER:
                     return false;
                 case EQUAL:
                     return true;
                 case LARGER:
                     switch(compare_lexicographically_xy(B1,A2)) {
                     case SMALLER:
                         return seg_seg_do_intersect_crossing(B2,B1,A1,A2);
                     case EQUAL:
                         return true;
                     case LARGER:
                         return seg_seg_do_intersect_contained(B2,B1,A1,A2);
                     }
                 }
             }
         }
     } else {
         if (lexicographically_xy_smaller(B1,B2)) {
             switch(compare_lexicographically_xy(A2,B1)) {
             case SMALLER:
                 switch(compare_lexicographically_xy(A1,B1)) {
                 case SMALLER:
                     return false;
                 case EQUAL:
                     return true;
                 case LARGER:
                     switch(compare_lexicographically_xy(A1,B2)) {
                     case SMALLER:
                         return seg_seg_do_intersect_crossing(A2,A1,B1,B2);
                     case EQUAL:
                         return true;
                     case LARGER:
                         return seg_seg_do_intersect_contained(A2,A1,B1,B2);
                     }
                 }
             case EQUAL:
                 return true;
             case LARGER:
                 switch(compare_lexicographically_xy(B2,A2)) {
                 case SMALLER:
                     return false;
                 case EQUAL:
                     return true;
                 case LARGER:
                     switch(compare_lexicographically_xy(B2,A1)) {
                     case SMALLER:
                         return seg_seg_do_intersect_crossing(B1,B2,A2,A1);
                     case EQUAL:
                         return true;
                     case LARGER:
                         return seg_seg_do_intersect_contained(B1,B2,A2,A1);
                     }
                 }
             }
         } else {
             switch(compare_lexicographically_xy(A2,B2)) {
             case SMALLER:
                 switch(compare_lexicographically_xy(A1,B2)) {
                 case SMALLER:
                     return false;
                 case EQUAL:
                     return true;
                 case LARGER:
                     switch(compare_lexicographically_xy(A1,B1)) {
                     case SMALLER:
                         return seg_seg_do_intersect_crossing(A2,A1,B2,B1);
                     case EQUAL:
                         return true;
                     case LARGER:
                         return seg_seg_do_intersect_contained(A2,A1,B2,B1);
                     }
                 }
             case EQUAL:
                 return true;
             case LARGER:
                 switch(compare_lexicographically_xy(B1,A2)) {
                 case SMALLER:
                     return false;
                 case EQUAL:
                     return true;
                 case LARGER:
                     switch(compare_lexicographically_xy(B1,A1)) {
                     case SMALLER:
                         return seg_seg_do_intersect_crossing(B2,B1,A2,A1);
                     case EQUAL:
                         return true;
                     case LARGER:
                         return seg_seg_do_intersect_contained(B2,B1,A2,A1);
                     }
                 }
             }
         }
     }
     assert(false);
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool CGAL::is_negative ( const NT & x )

inline

Definition at line 86 of file number_utils.h.

Referenced by Is_negative< NT >::operator()().

 {
 #ifndef CGAL_NO_NTS_NAMESPACE
   bool is_negative_is_obsolete__qualify_call_by_CGAL_NTS;
 #endif // CGAL_NO_NTS_NAMESPACE
   return x < NT(0);
 }

Here is the caller graph for this function:

bool CGAL::is_one ( const NT & x )

inline

Definition at line 75 of file number_utils.h.

Referenced by Is_one< NT >::operator()().

 {
 #ifndef CGAL_NO_NTS_NAMESPACE
   bool is_one_is_obsolete__qualify_call_by_CGAL_NTS;
 #endif // CGAL_NO_NTS_NAMESPACE
   return x == NT(1);
 }

Here is the caller graph for this function:

bool CGAL::is_positive ( const NT & x )

inline

Definition at line 97 of file number_utils.h.

References x.

Referenced by Is_positive< NT >::operator()().

 {
 #ifndef CGAL_NO_NTS_NAMESPACE
   bool is_positive_is_obsolete__qualify_call_by_CGAL_NTS;
 #endif // CGAL_NO_NTS_NAMESPACE
   return NT(0) < x;
 }

Here is the caller graph for this function:

bool CGAL::is_zero ( const NT & x )

inline

Definition at line 64 of file number_utils.h.

Referenced by Is_zero< NT >::operator()().

 {
 #ifndef CGAL_NO_NTS_NAMESPACE
   bool is_zero_is_obsolete__qualify_call_by_CGAL_NTS;
 #endif // CGAL_NO_NTS_NAMESPACE
   return x == NT(0);
 }

Here is the caller graph for this function:

CGAL_KERNEL_INLINE Sign CGAL::lexicographical_sign	(	const NT &	x,
		const NT &	y
	)

Definition at line 119 of file number_utils.h.

References sign().

Referenced by Lexicographical_sign< NT >::operator()().

 {
 #ifndef CGAL_NO_NTS_NAMESPACE
   bool lexicographical_sign_is_obsolete__qualify_call_by_CGAL_NTS;
 #endif // CGAL_NO_NTS_NAMESPACE
   return (x == NT(0)) ? CGAL::sign(y) : CGAL::sign(x);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Object CGAL::make_object ( const T & t )

Definition at line 132 of file Object.h.

133 { return Object(new Wrapper< T >(t)); }

bool CGAL::seg_seg_do_intersect_contained	(	PT const &	p1,
		PT const &	p2,
		PT const &	p3,
		PT const &	p4
	)

Definition at line 224 of file Segment_2_Segment_2_intersection.h.

References COLLINEAR, LEFTTURN, leftturn(), orientation(), RIGHTTURN, and rightturn().

Referenced by do_intersect().

 {
     switch (orientation(p1,p2,p3)) {
     case LEFTTURN:
         return !leftturn(p1,p2,p4);
     case RIGHTTURN:
         return !rightturn(p1,p2,p4);
     case COLLINEAR:
         return true;
     }
     assert(false);
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool CGAL::seg_seg_do_intersect_crossing	(	PT const &	p1,
		PT const &	p2,
		PT const &	p3,
		PT const &	p4
	)

Definition at line 207 of file Segment_2_Segment_2_intersection.h.

References COLLINEAR, LEFTTURN, leftturn(), orientation(), RIGHTTURN, and rightturn().

Referenced by do_intersect().

 {
     switch (orientation(p1,p2,p3)) {
     case LEFTTURN:
         return !rightturn(p3,p4,p2);
     case RIGHTTURN:
         return !leftturn(p3,p4,p2);
     case COLLINEAR:
         return true;
     }
     assert(false);
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

CGAL_KERNEL_INLINE Sign CGAL::sign ( const NT & x )

Definition at line 108 of file number_utils.h.

References NEGATIVE, POSITIVE, x, and ZERO.

Referenced by lexicographical_sign().

 {
 #ifndef CGAL_NO_NTS_NAMESPACE
   bool sign_is_obsolete__qualify_call_by_CGAL_NTS;
 #endif // CGAL_NO_NTS_NAMESPACE
   return (x < NT(0)) ? NEGATIVE : (NT(0) < x) ? POSITIVE : ZERO;
 }

Here is the caller graph for this function:

NT CGAL::square ( const NT & n )

inline

Definition at line 158 of file number_utils.h.

References n.

 {
 #ifndef CGAL_NO_NTS_NAMESPACE
   bool square_is_obsolete__qualify_call_by_CGAL_NTS;
 #endif // CGAL_NO_NTS_NAMESPACE
   return n*n;
 }

Namespaces

Classes

Functions

Function Documentation