CGAL::intersection

Depending on which Cgal kernel is used, different versions of this global function are available. This is described below.

With the basic 2D and 3D Kernel (see Chapter 11)

#include <CGAL/intersections.h>

The possible value for types Type1 and Type2 and the possible return values wrapped in Object are the following:

There is also an intersection function between 3 planes.

With the 2D Circular Kernel (see Chapter 13)

#include <CGAL/Circular_kernel_intersections.h>

If this kernel is used, in addition to the function and the combination of 2D types described above, another version of the function is provided.

Since both the number of intersections, if any, and their type, depend on the arguments, the function returns an output iterator on Object's, as presented below.

where Type1 and Type2 can both be either

• Line_2<CircularKernel> or
• Line_arc_2<CircularKernel> or
• Circle_2<CircularKernel> or
• Circular_arc_2<CircularKernel>.

Depending on the types Type1 and Type2, these elements can be assigned to

• std::pair<Circular_arc_point_2<CircularKernel>, unsigned>, where the unsigned integer is the multiplicity of the corresponding intersection point between obj1 and obj2,
• Circular_arc_2<CircularKernel> in case of an overlap of two circular arcs,
• Line_arc_2<CircularKernel> in case of an overlap of two line segments or
• Line_2<CircularKernel> or Circle_2<CircularKernel> in case of two equal input lines or circles.

With the 3D Spherical Kernel (see Chapter 14)

#include <CGAL/Spherical_kernel_intersections.h>

If this kernel is used, in addition to the function and the combination of 3D types described above, two other versions of the function are provided.

Since both the number of intersections, if any, and their type, depend on the arguments, the functions return an output iterator on Object's, as presented below.

The first function is:

where Type1 and Type2 can both be either:

• Sphere_3<SphericalKernel>,
• Plane_3<SphericalKernel>,
• Line_3<SphericalKernel>,
• Circle_3<SphericalKernel>,
• Line_arc_3<SphericalKernel> or
• Circular_arc_3<SphericalKernel>,

and depending on the types Type1 and Type2, the computed CGAL::Objects can be assigned to

• std::pair<Circular_arc_point_3<SphericalKernel>, unsigned>, where the unsigned integer is the multiplicity of the corresponding intersection point between obj1 and obj2,
• Type1, when Type1 and Type2 are equal, and if the two objets obj1 and obj2 are equal,
• Line_3<SphericalKernel> or Circle_3<SphericalKernel> when Type1 and Type2 are two-dimensional objets intersecting along a curve (2 planes, or 2 spheres, or one plane and one sphere),
• Circular_arc_3<SphericalKernel> in case of an overlap of two circular arcs or
• Line_arc_3<SphericalKernel> in case of an overlap of two line segments.

The second function is:

where Type1, Type2 and Type3 can be either

• Sphere_3<SphericalKernel> or
• Plane_3<SphericalKernel>

and depending of these types, the computed CGAL::Objects can be assigned to

• std::pair<Circular_arc_point_3<SphericalKernel>, unsigned>, where the unsigned integer is the multiplicity of the corresponding intersection point,
• Circle_3<SphericalKernel> or
• Type1, when Type1, Type2 and Type3 are equal, and if the three objets obj1 and obj2 and obj3 are equal.

Example

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

#include <CGAL/intersections.h>

void foo(CGAL::Segment_2<Kernel> seg, CGAL::Line_2<Kernel> line)
{
    CGAL::Object result = CGAL::intersection(seg, line);
    if (const CGAL::Point_2<Kernel> *ipoint = CGAL::object_cast<CGAL::Point_2<Kernel> >(&result)) {

        // handle the point intersection case with *ipoint.

    } else
        if (const CGAL::Segment_2<Kernel> *iseg = CGAL::object_cast<CGAL::Segment_2<Kernel> >(&result)) {

            // handle the segment intersection case with *iseg.

        } else {

            // handle the no intersection case.
        }
}

Examples illustrating the use of this function in the case of the 2D Circular Kernel and the 3D Spherical Kernel are presented respectively in Chapters 13 and 14.

See Also