\( \newcommand{\E}{\mathrm{E}} \) \( \newcommand{\A}{\mathrm{A}} \) \( \newcommand{\R}{\mathrm{R}} \) \( \newcommand{\N}{\mathrm{N}} \) \( \newcommand{\Q}{\mathrm{Q}} \) \( \newcommand{\Z}{\mathrm{Z}} \) \( \def\ccSum #1#2#3{ \sum_{#1}^{#2}{#3} } \def\ccProd #1#2#3{ \sum_{#1}^{#2}{#3} }\)
CGAL 4.6 - 2D and 3D Linear Geometry Kernel
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Groups Pages
CGAL::intersection() (2D/3D Linear Kernel)

Functions

template<typename Kernel >
cpp11::result_of
< Kernel::Intersect_23(Type1,
Type2)>::type 
CGAL::intersection (Type1< Kernel > obj1, Type2< Kernel > obj2)
 Two objects obj1 and obj2 intersect if there is a point p that is part of both obj1 and obj2. More...
 
template<typename Kernel >
boost::optional
< boost::variant< Point_3,
Line_3, Plane_3 > > 
CGAL::intersection (const Plane_3< Kernel > &pl1, const Plane_3< Kernel > &pl2, const Plane_3< Kernel > &pl3)
 returns the intersection of 3 planes, which can be a point, a line, a plane, or empty.
 

Function Documentation

template<typename Kernel >
cpp11::result_of<Kernel::Intersect_23(Type1, Type2)>::type CGAL::intersection ( Type1< Kernel obj1,
Type2< Kernel obj2 
)

Two objects obj1 and obj2 intersect if there is a point p that is part of both obj1 and obj2.

The intersection region of those two objects is defined as the set of all points p that are part of both obj1 and obj2. Note that for objects like triangles and polygons that enclose a bounded region, this region is considered part of the object. If a segment lies completely inside a triangle, then those two objects intersect and the intersection region is the complete segment.

Here, Intersect_23 means either Intersect_2 or Intersect_3, depending on the arguments.

The following tables give the possible values for Type1 and Type2.

2D intersections

The return type can be obtained through cpp11::result_of<Kernel::Intersect_2(A, B)>::type. It is equivalent to boost::optional< boost::variant< T... > >, the last column in the table providing the template parameter pack.

Type1 Type2 Return Type: T...
Iso_rectangle_2 Iso_rectangle_2

Iso_rectangle_2

Iso_rectangle_2 Line_2 Point_2, or Segment_2
Iso_rectangle_2 Ray_2 Point_2, or Segment_2
Iso_rectangle_2 Segment_2 Point_2, or Segment_2
Iso_rectangle_2 Triangle_2 Point_2, or Segment_2, or Triangle_2, or std::vector<Point_2>
Line_2 Line_2 Point_2, or Line_2
Line_2 Ray_2 Point_2, or Ray_2
Line_2 Segment_2 Point_2, or Segment_2
Line_2 Triangle_2 Point_2, or Segment_2
Ray_2 Ray_2 Point_2, or Segment_2, or Ray_2
Ray_2 Segment_2 Point_2, or Segment_2
Ray_2 Triangle_2 Point_2, or Segment_2
Segment_2 Segment_2 Point_2, or Segment_2
Segment_2 Triangle_2 Point_2, or Segment_2
Triangle_2 Triangle_2 Point_2, or Segment_2, or Triangle_2, or std::vector<Point_2>

3D intersections

The return type can be obtained through cpp11::result_of<Kernel::Intersect_3(A, B)>::type. It is equivalent to boost::optional< boost::variant< T... > >, the last column in the table providing the template parameter pack.

Type1 Type2 Return Type: T...
Line_3 Line_3 Point_3, or Line_3
Line_3 Plane_3 Point_3, or Line_3
Line_3 Ray_3 Point_3, or Ray_3
Line_3 Segment_3 Point_3, or Segment_3
Line_3 Triangle_3 Point_3, or Segment_3
Plane_3 Plane_3 Line_3, or Plane_3
Plane_3 Ray_3 Point_3, or Ray_3
Plane_3 Segment_3 Point_3, or Segment_3
Plane_3 Sphere_3 Point_3, or Circle_3
Plane_3 Triangle_3 Point_3, or Segment_3, or Triangle_3
Ray_3 Ray_3 Point_3, or Ray_3, or Segment_3
Ray_3 Segment_3 Point_3, or Segment_3
Ray_3 Triangle_3 p Point_3, or Segment_3
Segment_3 Segment_3 Point_3, or Segment_3
Segment_3 Triangle_3 Point_3, or Segment_3
Sphere_3 Sphere_3 Point_3, or Circle_3, or Sphere_3
Triangle_3 Triangle_3 Point_3, or Segment_3, or Triangle_3, or std::vector < Point_3 >

Example

The following example demonstrates the most common use of intersection routines with the 2D and 3D Linear Kernel.

#include <CGAL/intersections.h>
template <typename R>
struct Intersection_visitor {
typedef void result_type;
void operator()(const Point_2<R>& p) const
{
// handle point
}
void operator()(const Segment_2<R>& s) const
{
// handle segment
}
};
template <typename R>
void foo (const Segment_2<R>& seg, const Line_2<R>& lin)
{
// with C++11 support
// auto result = intersection(seg, lin);
// without C++11
cpp11::result_of<R::Intersect_2(Segment_2<R>, Line_2<R>)>::type
result = intersection(seg, lin);
if (result) { boost::apply_visitor(Intersection_visitor(), *result); }
else {
// no intersection
}
// alternatively:
if (result) {
if (const Segment_2<R>* s = boost::get<Segment_2>(&*result)) {
// handle segment
} else {
const Point_2<R>* p = boost::get<Point_2<R> >(&*result);
// handle point
}
}
}

Another example showing the use of the intersection function as a plain function call and with Dispatch_output_iterator combined with a standard library algorithm.


File Kernel_23/intersections.cpp

#include <CGAL/Simple_cartesian.h>
#include <CGAL/intersections.h>
#include <CGAL/iterator.h>
#include <CGAL/point_generators_2.h>
#include <boost/bind.hpp>
typedef K::Point_2 Point;
typedef K::Segment_2 Segment;
typedef CGAL::Random_points_on_segment_2<Point,Pt_creator> P1;
typedef CGAL::Random_points_on_circle_2<Point,Pt_creator> P2;
struct Intersector{
const Segment& s;
K::Intersect_2 intersect;
Intersector(const Segment& seg): s(seg) {}
result_type
operator() ( const Segment& other) const
{
return intersect(s, other);
}
};
int main()
{
std::vector<Segment> input;
// Prepare point generator for the horizontal segment, length 200.
P1 p1( Point(-100,0), Point(100,0));
// Prepare point generator for random points on circle, radius 250.
P2 p2( 250);
// Create segments.
Seg_iterator g( p1, p2);
CGAL::cpp11::copy_n( g, 200, std::back_inserter(input));
// splitting results with Dispatch_output_iterator
std::vector<Point> points;
std::vector<Segment> segments;
CGAL::cpp11::tuple<Point,Segment>, CGAL::cpp0x::tuple< std::back_insert_iterator<std::vector<Point> >,
std::back_insert_iterator<std::vector<Segment> > > >
Dispatcher;
Dispatcher disp = CGAL::dispatch_output<Point,Segment>( std::back_inserter(points),
std::back_inserter(segments) );
// intersects the first segment of input with all other segments
// The resulting points or segments are written in the vectors with the same names
std::transform( input.begin(), input.end(), disp,
Intersector(input.front()) );
std::cout << "Point intersections: " << points.size() << std::endl;
std::cout << "Segment intersections: " << segments.size() << std::endl;
return 0;
}

#include <CGAL/intersections.h>