Rocstar  1.0
Rocstar multiphysics simulation application
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Classes | Namespaces | Functions
Segment_2_Segment_2_intersection.h File Reference
#include <CGAL/Segment_2.h>
#include <CGAL/Point_2.h>
#include <CGAL/utils.h>
#include <CGAL/number_utils.h>
#include <cassert>
#include <CGAL/predicates_on_points_2.h>
#include <CGAL/Line_2.h>
#include <CGAL/Line_2_Line_2_intersection.h>
#include <CGAL/Object.h>
Include dependency graph for Segment_2_Segment_2_intersection.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

class  Segment_2_Segment_2_pair< R >
 

Namespaces

 CGAL
 

Functions

template<class R >
bool do_intersect (const Segment_2< R > &seg1, const Segment_2< R > &seg2)
 
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)
 
template<class R >
CGAL_END_NAMESPACE
CGAL_BEGIN_NAMESPACE Object 		intersection (const Segment_2< R > &seg1, const Segment_2< R > &seg2)
 

Function Documentation

bool 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(), CGAL::seg_seg_do_intersect_contained(), CGAL::seg_seg_do_intersect_crossing(), SMALLER, Segment_2< R, T >::source(), and Segment_2< R, T >::target().

Referenced by Triangulation::is_diagonalie().

243 {
244  typename R::Point_2 const & A1 = seg1.source();
245  typename R::Point_2 const & A2 = seg1.target();
246  typename R::Point_2 const & B1 = seg2.source();
247  typename R::Point_2 const & B2 = seg2.target();
248  if (lexicographically_yx_smaller(A1,A2)) {
249  if (lexicographically_yx_smaller(B1,B2)) {
250  if (lexicographically_yx_smaller(A2,B1)
251  || lexicographically_yx_smaller(B2,A1))
252  return false;
253  } else {
254  if (lexicographically_yx_smaller(A2,B2)
255  || lexicographically_yx_smaller(B1,A1))
256  return false;
257  }
258  } else {
259  if (lexicographically_yx_smaller(B1,B2)) {
260  if (lexicographically_yx_smaller(A1,B1)
261  || lexicographically_yx_smaller(B2,A2))
262  return false;
263  } else {
264  if (lexicographically_yx_smaller(A1,B2)
265  || lexicographically_yx_smaller(B1,A2))
266  return false;
267  }
268  }
269  if (lexicographically_xy_smaller(A1,A2)) {
270  if (lexicographically_xy_smaller(B1,B2)) {
271  switch(compare_lexicographically_xy(A1,B1)) {
272  case SMALLER:
273  switch(compare_lexicographically_xy(A2,B1)) {
274  case SMALLER:
275  return false;
276  case EQUAL:
277  return true;
278  case LARGER:
279  switch(compare_lexicographically_xy(A2,B2)) {
280  case SMALLER:
281  return seg_seg_do_intersect_crossing(A1,A2,B1,B2);
282  case EQUAL:
283  return true;
284  case LARGER:
285  return seg_seg_do_intersect_contained(A1,A2,B1,B2);
286  }
287  }
288  case EQUAL:
289  return true;
290  case LARGER:
291  switch(compare_lexicographically_xy(B2,A1)) {
292  case SMALLER:
293  return false;
294  case EQUAL:
295  return true;
296  case LARGER:
297  switch(compare_lexicographically_xy(B2,A2)) {
298  case SMALLER:
299  return seg_seg_do_intersect_crossing(B1,B2,A1,A2);
300  case EQUAL:
301  return true;
302  case LARGER:
303  return seg_seg_do_intersect_contained(B1,B2,A1,A2);
304  }
305  }
306  }
307  } else {
308  switch(compare_lexicographically_xy(A1,B2)) {
309  case SMALLER:
310  switch(compare_lexicographically_xy(A2,B2)) {
311  case SMALLER:
312  return false;
313  case EQUAL:
314  return true;
315  case LARGER:
316  switch(compare_lexicographically_xy(A2,B1)) {
317  case SMALLER:
318  return seg_seg_do_intersect_crossing(A1,A2,B2,B1);
319  case EQUAL:
320  return true;
321  case LARGER:
322  return seg_seg_do_intersect_contained(A1,A2,B2,B1);
323  }
324  }
325  case EQUAL:
326  return true;
327  case LARGER:
328  switch(compare_lexicographically_xy(B1,A1)) {
329  case SMALLER:
330  return false;
331  case EQUAL:
332  return true;
333  case LARGER:
334  switch(compare_lexicographically_xy(B1,A2)) {
335  case SMALLER:
336  return seg_seg_do_intersect_crossing(B2,B1,A1,A2);
337  case EQUAL:
338  return true;
339  case LARGER:
340  return seg_seg_do_intersect_contained(B2,B1,A1,A2);
341  }
342  }
343  }
344  }
345  } else {
346  if (lexicographically_xy_smaller(B1,B2)) {
347  switch(compare_lexicographically_xy(A2,B1)) {
348  case SMALLER:
349  switch(compare_lexicographically_xy(A1,B1)) {
350  case SMALLER:
351  return false;
352  case EQUAL:
353  return true;
354  case LARGER:
355  switch(compare_lexicographically_xy(A1,B2)) {
356  case SMALLER:
357  return seg_seg_do_intersect_crossing(A2,A1,B1,B2);
358  case EQUAL:
359  return true;
360  case LARGER:
361  return seg_seg_do_intersect_contained(A2,A1,B1,B2);
362  }
363  }
364  case EQUAL:
365  return true;
366  case LARGER:
367  switch(compare_lexicographically_xy(B2,A2)) {
368  case SMALLER:
369  return false;
370  case EQUAL:
371  return true;
372  case LARGER:
373  switch(compare_lexicographically_xy(B2,A1)) {
374  case SMALLER:
375  return seg_seg_do_intersect_crossing(B1,B2,A2,A1);
376  case EQUAL:
377  return true;
378  case LARGER:
379  return seg_seg_do_intersect_contained(B1,B2,A2,A1);
380  }
381  }
382  }
383  } else {
384  switch(compare_lexicographically_xy(A2,B2)) {
385  case SMALLER:
386  switch(compare_lexicographically_xy(A1,B2)) {
387  case SMALLER:
388  return false;
389  case EQUAL:
390  return true;
391  case LARGER:
392  switch(compare_lexicographically_xy(A1,B1)) {
393  case SMALLER:
394  return seg_seg_do_intersect_crossing(A2,A1,B2,B1);
395  case EQUAL:
396  return true;
397  case LARGER:
398  return seg_seg_do_intersect_contained(A2,A1,B2,B1);
399  }
400  }
401  case EQUAL:
402  return true;
403  case LARGER:
404  switch(compare_lexicographically_xy(B1,A2)) {
405  case SMALLER:
406  return false;
407  case EQUAL:
408  return true;
409  case LARGER:
410  switch(compare_lexicographically_xy(B1,A1)) {
411  case SMALLER:
412  return seg_seg_do_intersect_crossing(B2,B1,A2,A1);
413  case EQUAL:
414  return true;
415  case LARGER:
416  return seg_seg_do_intersect_contained(B2,B1,A2,A1);
417  }
418  }
419  }
420  }
421  }
422  assert(false);
423  return false;
424 }
lexicographically_xy_smaller
bool lexicographically_xy_smaller(const Point_2< R > &p, const Point_2< R > &q)
Definition: predicates_on_points_2.h:158
CGAL::seg_seg_do_intersect_contained
bool seg_seg_do_intersect_contained(PT const &p1, PT const &p2, PT const &p3, PT const &p4)
Definition: Segment_2_Segment_2_intersection.h:224
Segment_2::target
CGAL::Point_2< R > target() const
Definition: Segment_2.h:139
SMALLER
Definition: enum.h:96
CGAL::seg_seg_do_intersect_crossing
bool seg_seg_do_intersect_crossing(PT const &p1, PT const &p2, PT const &p3, PT const &p4)
Definition: Segment_2_Segment_2_intersection.h:207
Segment_2::source
CGAL::Point_2< R > source() const
Definition: Segment_2.h:136
lexicographically_yx_smaller
bool lexicographically_yx_smaller(const Point_2< R > &p, const Point_2< R > &q)
Definition: predicates_on_points_2.h:214
LARGER
Definition: enum.h:98
compare_lexicographically_xy
Comparison_result compare_lexicographically_xy(const Point_2< R > &p, const Point_2< R > &q)
Definition: predicates_on_points_2.h:136
EQUAL
Definition: enum.h:97
Point_2
SURF::Vector_2< Real > Point_2
Definition: rfc_basic.h:43

Here is the call graph for this function:

Here is the caller graph for this function:

CGAL_END_NAMESPACE CGAL_BEGIN_NAMESPACE Object intersection ( const Segment_2< R > &  seg1,
const Segment_2< R > &  seg2 
)

Definition at line 602 of file Segment_2_Segment_2_intersection.h.

603 {
604  typedef Segment_2_Segment_2_pair<R> is_t;
605  is_t ispair(&seg1, &seg2);
606  switch (ispair.intersection_type()) {
607  case is_t::NO:
608  default:
609  return Object();
610  case is_t::POINT: {
611  Point_2<R> pt;
612  ispair.intersection(pt);
613  return Object(new Wrapper< Point_2<R> >(pt));
614  }
615  case is_t::SEGMENT: {
616  Segment_2<R> iseg;
617  ispair.intersection(iseg);
618  return Object(new Wrapper< Segment_2<R> >(iseg));
619  }
620  }
621 }
Segment_2< R >
Segment_2_Segment_2_pair
Definition: Segment_2_Segment_2_intersection.h:61
Point_2< R >