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

finished with an uncritical \todo for later

This commit is contained in:
Andreas Fabri 2012-10-11 15:09:28 +00:00
parent 0dbce45c62
commit 6df656f4b5
6 changed files with 78 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Box_intersection_d/doc/Box_intersection_d/Box_intersection_d.txt
View File

@ -40,7 +40,7 @@ and \cite cgal:ze-fsbi-02 for more details.
\section secboxintersdef Definition \section secboxintersdef Definition
A \f$ d\f$-dimensional iso-oriented box is defined as the A \f$ d\f$-dimensional iso-oriented box is defined as the
Cartesian product of \f$ d\f$ intervals. We call the %Cartesian product of \f$ d\f$ intervals. We call the
box <I>half-open</I> if the \f$ d\f$ intervals \f$ \{ [lo_i,hi_i) \,|\, 0 \leq box <I>half-open</I> if the \f$ d\f$ intervals \f$ \{ [lo_i,hi_i) \,|\, 0 \leq
i < d\}\f$ are half-open intervals, and we call the box <I>closed</I> if i < d\}\f$ are half-open intervals, and we call the box <I>closed</I> if
the \f$ d\f$ intervals \f$ \{ [lo_i,hi_i] \,|\, 0 \leq i < d\}\f$ are closed the \f$ d\f$ intervals \f$ \{ [lo_i,hi_i] \,|\, 0 \leq i < d\}\f$ are closed
@ -288,7 +288,7 @@ just converting from the `double` to the `float`
representation incurs rounding that needs to be controlled properly, representation incurs rounding that needs to be controlled properly,
otherwise the box might shrink and one might miss intersections. otherwise the box might shrink and one might miss intersections.
\section secboxintersparams Example Using the topology and the cutoff Parameters \section secboxintersparams Example Using the Topology and the Cutoff Parameters
Boxes can be interpreted by the box intersection algorithm as closed Boxes can be interpreted by the box intersection algorithm as closed
or as half-open boxes, see also Section \ref secboxintersdef. Closed or as half-open boxes, see also Section \ref secboxintersdef. Closed
@ -411,7 +411,7 @@ remainder of the example stays the same and we omit the part from the
previous example for brevity that illustrates the half-open box topology. previous example for brevity that illustrates the half-open box topology.
The requirements for the box implementation are best studied on The requirements for the box implementation are best studied on
page \ref ccRef_BoxIntersectionBox_d in the Reference Manual. In a the reference manual page of `BoxIntersectionBox_d`. In a
nutshell, we have to define the type `NT` for the box coordinates nutshell, we have to define the type `NT` for the box coordinates
and the type `ID` for the `id`-number. Member functions and the type `ID` for the `id`-number. Member functions
give access to the coordinates and the `id`-number. A static give access to the coordinates and the `id`-number. A static
@ -435,7 +435,7 @@ from above, i.e., points are reported if their distance is smaller
than `2*eps`. than `2*eps`.
The requirements for the box traits class are best studied on The requirements for the box traits class are best studied on
page \ref ccRef_BoxIntersectionTraits_d in the Reference Manual. In a the reference manual page of `BoxIntersectionTraits_d`. In a
nutshell, we have to define the type `NT` for the box coordinates, nutshell, we have to define the type `NT` for the box coordinates,
the type `ID` for the `id`-number, and the type `Box_parameter` the type `ID` for the `id`-number, and the type `Box_parameter`
similar to the box handle, here `Point_3*` since we work with the pointers. similar to the box handle, here `Point_3*` since we work with the pointers.

6
Box_intersection_d/doc/Box_intersection_d/CGAL/Box_intersection_d/Box_d.h
View File

@ -1,7 +1,7 @@
namespace CGAL { namespace CGAL {
namespace Box_intersection_d { namespace Box_intersection_d {
/*! /*!
\ingroup PkgBoxIntersectionD \ingroup PkgBoxIntersectionDClasses
`Box_d` is a generic iso-oriented bounding box in dimension \f$ D\f$. `Box_d` is a generic iso-oriented bounding box in dimension \f$ D\f$.
It provides in each dimension an interval with lower and upper It provides in each dimension an interval with lower and upper
@ -29,14 +29,14 @@ the box and automatically created and assigned at construction
time of the box. Note that copying a box (copy-constructor and time of the box. Note that copying a box (copy-constructor and
assignment) does not create a new `id`-number but keeps assignment) does not create a new `id`-number but keeps
the old one, which is the behavior needed by the the old one, which is the behavior needed by the
`CGAL::box_self_intersection` algorithm. This is therefore `CGAL::box_self_intersection_3()` algorithm. This is therefore
the safe default implementation. the safe default implementation.
<LI>`ID_FROM_BOX_ADDRESS`: casts the address of the box into a <LI>`ID_FROM_BOX_ADDRESS`: casts the address of the box into a
`std::ptrdiff_t` to create the `id`-number. Works fine `std::ptrdiff_t` to create the `id`-number. Works fine
if the intersection algorithms work effectively with pointers if the intersection algorithms work effectively with pointers
to boxes, but not in the case where the algorithms work with to boxes, but not in the case where the algorithms work with
box values, because the algorithms modify the order of the box values, because the algorithms modify the order of the
boxes, and the `CGAL::box_self_intersection` algorithm boxes, and the `CGAL::box_self_intersection_d()` algorithm
creates copies of the boxes that would not have identical creates copies of the boxes that would not have identical
`id`-numbers. `id`-numbers.
</UL> </UL>

21
Box_intersection_d/doc/Box_intersection_d/CGAL/Box_intersection_d/Box_traits_d.h
View File

@ -1,7 +1,7 @@
namespace CGAL { namespace CGAL {
namespace Box_intersection_d { namespace Box_intersection_d {
/*! /*!
\ingroup PkgBoxIntersectionD \ingroup PkgBoxIntersectionDClasses
This is the default traits class for the intersection algorithms for This is the default traits class for the intersection algorithms for
iso-oriented boxes. There are actually three versions depending on the iso-oriented boxes. There are actually three versions depending on the
@ -24,9 +24,9 @@ const-pointer `const B*`, where `B` is a model of the
\models ::BoxIntersectionTraits_d \models ::BoxIntersectionTraits_d
\sa `CGAL::box_intersection_d` \sa `CGAL::box_intersection_d()`
\sa `CGAL::box_self_intersection_d` \sa `CGAL::box_self_intersection_d()`
\sa `CGAL::box_intersection_all_pairs_d` \sa `CGAL::box_intersection_all_pairs_d()`
\sa `BoxIntersectionBox_d` \sa `BoxIntersectionBox_d`
\sa `CGAL::Box_intersection_d::Box_d<NT,int D,IdPolicy>` \sa `CGAL::Box_intersection_d::Box_d<NT,int D,IdPolicy>`
@ -46,5 +46,18 @@ Box_traits_d();
/// @} /// @}
}; /* end Box_traits_d */ }; /* end Box_traits_d */
/*!
\ingroup PkgBoxIntersectionDFunctions
*/
enum Setting { COMPLETE, BIPARTITE };
/*!
\ingroup PkgBoxIntersectionDFunctions
*/
enum Topology { HALF_OPEN, CLOSED };
} /* Box_intersection_d */ } /* Box_intersection_d */
} /* end namespace CGAL */ } /* end namespace CGAL */

10
Box_intersection_d/doc/Box_intersection_d/CGAL/Box_intersection_d/Box_with_handle_d.h
View File

@ -2,7 +2,7 @@ namespace CGAL {
namespace Box_intersection_d { namespace Box_intersection_d {
/*! /*!
\ingroup PkgBoxIntersectionD \ingroup PkgBoxIntersectionDClasses
`Box_with_handle_d` is a generic iso-oriented bounding box in dimension \f$ D\f$ `Box_with_handle_d` is a generic iso-oriented bounding box in dimension \f$ D\f$
that stores additionally a handle to some underlying geometric object. that stores additionally a handle to some underlying geometric object.
@ -32,14 +32,14 @@ the box and automatically created and assigned at construction
time of the box. Note that copying a box (copy-constructor and time of the box. Note that copying a box (copy-constructor and
assignment) does not create a new `id`-number but keeps assignment) does not create a new `id`-number but keeps
the old one, which is the behavior needed by the the old one, which is the behavior needed by the
`CGAL::box_self_intersection` algorithm. This is therefore `CGAL::box_self_intersection_d()` algorithm. This is therefore
the safe default implementation. the safe default implementation.
<LI>`ID_FROM_BOX_ADDRESS`: casts the address of the box into a <LI>`ID_FROM_BOX_ADDRESS`: casts the address of the box into a
`std::ptrdiff_t` to create the `id`-number. Works fine `std::ptrdiff_t` to create the `id`-number. Works fine
if the intersection algorithms work effectively with pointers if the intersection algorithms work effectively with pointers
to boxes, but not in the case where the algorithms work with to boxes, but not in the case where the algorithms work with
box values, because the algorithms modify the order of the box values, because the algorithms modify the order of the
boxes, and the `CGAL::box_self_intersection` algorithm boxes, and the `CGAL::box_self_intersection_d()` algorithm
creates copies of the boxes that would not have identical creates copies of the boxes that would not have identical
`id`-numbers. `id`-numbers.
<LI>`ID_FROM_HANDLE`: casts the address of the value of the <LI>`ID_FROM_HANDLE`: casts the address of the value of the
@ -98,8 +98,8 @@ Box_with_handle_d();
/*! /*!
initializes to the initializes to the
complete or the empty space. If empty, all interval starting(end) complete or the empty space. If empty, all interval starting (end)
points will be set to positive(negative) infinity, sets handle to \f$ h\f$. points will be set to positive (negative) infinity, sets handle to \f$ h\f$.
*/ */
Box_with_handle_d(bool complete, Handle h); Box_with_handle_d(bool complete, Handle h);

75
Box_intersection_d/doc/Box_intersection_d/CGAL/box_intersection_d.h
View File

@ -1,13 +1,12 @@
namespace CGAL { namespace CGAL {
/*! /*!
\page box_intersection_all_pairs_d box_intersection_all_pairs_d \addtogroup PkgBoxIntersectionD_box_intersection_all_pairs_d
The function `box_intersection_all_pairs_d` computes the pairwise intersecting boxes The function `box_intersection_all_pairs_d` computes the pairwise intersecting boxes
between two sequences of iso-oriented boxes in arbitrary dimension. between two sequences of iso-oriented boxes in arbitrary dimension.
It does so by comparing all possible pairs of boxes and is thus It does so by comparing all possible pairs of boxes and is thus
inferior to the fast `CGAL::box_intersection_d` algorithm on page inferior to the fast `CGAL::box_intersection_d` algorithm.
\ref ccRef_CGALbox_intersection_d.
The sequences of boxes are given with two forward iterator ranges. The The sequences of boxes are given with two forward iterator ranges. The
sequences are not modified. For each intersecting pair of boxes a sequences are not modified. For each intersecting pair of boxes a
@ -21,7 +20,7 @@ namespace CGAL {
either our box type or a pointer type to our box type. either our box type or a pointer type to our box type.
A \f$ d\f$-dimensional iso-oriented box is defined as the A \f$ d\f$-dimensional iso-oriented box is defined as the
Cartesian product of \f$ d\f$ intervals. We call the %Cartesian product of \f$ d\f$ intervals. We call the
box <I>half-open</I> if the \f$ d\f$ intervals \f$ \{ [lo_i,hi_i) \,|\, 0 \leq box <I>half-open</I> if the \f$ d\f$ intervals \f$ \{ [lo_i,hi_i) \,|\, 0 \leq
i < d\}\f$ are half-open intervals, and we call the box <I>closed</I> if i < d\}\f$ are half-open intervals, and we call the box <I>closed</I> if
the \f$ d\f$ intervals \f$ \{ [lo_i,hi_i] \,|\, 0 \leq i < d\}\f$ are closed the \f$ d\f$ intervals \f$ \{ [lo_i,hi_i] \,|\, 0 \leq i < d\}\f$ are closed
@ -65,7 +64,7 @@ namespace CGAL {
*/ */
/*! /*!
\page box_intersection_d box_intersection_d \addtogroup PkgBoxIntersectionD_box_intersection_d
The function `box_intersection_d` computes the pairwise intersecting boxes The function `box_intersection_d` computes the pairwise intersecting boxes
between two sequences of iso-oriented boxes in arbitrary dimension. between two sequences of iso-oriented boxes in arbitrary dimension.
@ -87,7 +86,7 @@ namespace CGAL {
const pointer) to the box type. const pointer) to the box type.
A \f$ d\f$-dimensional iso-oriented box is defined as the A \f$ d\f$-dimensional iso-oriented box is defined as the
Cartesian product of \f$ d\f$ intervals. We call the %Cartesian product of \f$ d\f$ intervals. We call the
box <I>half-open</I> if the \f$ d\f$ intervals \f$ \{ [lo_i,hi_i) \,|\, 0 \leq box <I>half-open</I> if the \f$ d\f$ intervals \f$ \{ [lo_i,hi_i) \,|\, 0 \leq
i < d\}\f$ are half-open intervals, and we call the box <I>closed</I> if i < d\}\f$ are half-open intervals, and we call the box <I>closed</I> if
the \f$ d\f$ intervals \f$ \{ [lo_i,hi_i] \,|\, 0 \leq i < d\}\f$ are closed the \f$ d\f$ intervals \f$ \{ [lo_i,hi_i] \,|\, 0 \leq i < d\}\f$ are closed
@ -210,14 +209,13 @@ namespace CGAL {
*/ */
/*! /*!
\ingroup PkgBoxIntersectionD \ingroup PkgBoxIntersectionD_box_intersection_all_pairs_d
Invocation of box intersection with default box traits Invocation of box intersection with default box traits
`CGAL::Box_intersection_d::Box_traits_d<Box_handle>`, where `CGAL::Box_intersection_d::Box_traits_d<Box_handle>`, where
`Box_handle` corresponds to the iterator value type of `Box_handle` corresponds to the iterator value type of
`ForwardIterator1`. `ForwardIterator1`.
See \ref box_intersection_all_pairs_d.
*/ */
template< class ForwardIterator1, template< class ForwardIterator1,
class ForwardIterator2, class ForwardIterator2,
@ -226,14 +224,13 @@ void box_intersection_all_pairs_d(
ForwardIterator1 begin1, ForwardIterator1 end1, ForwardIterator1 begin1, ForwardIterator1 end1,
ForwardIterator2 begin2, ForwardIterator2 end2, ForwardIterator2 begin2, ForwardIterator2 end2,
Callback callback, Callback callback,
Box_intersection_d::Topology topology = Box_intersection_d::CLOSED); CGAL::Box_intersection_d::Topology topology = CGAL::Box_intersection_d::CLOSED);
/*! /*!
\ingroup PkgBoxIntersectionD \ingroup PkgBoxIntersectionD_box_intersection_all_pairs_d
Invocation with custom box traits. Invocation with custom box traits.
See \ref box_intersection_all_pairs_d.
*/ */
template< class ForwardIterator1, template< class ForwardIterator1,
class ForwardIterator2, class ForwardIterator2,
@ -243,21 +240,20 @@ void box_intersection_all_pairs_d(
ForwardIterator2 begin2, ForwardIterator2 end2, ForwardIterator2 begin2, ForwardIterator2 end2,
Callback callback, Callback callback,
BoxTraits box_traits, BoxTraits box_traits,
Box_intersection_d::Topology topology = Box_intersection_d::CLOSED); CGAL::Box_intersection_d::Topology topology = CGAL::Box_intersection_d::CLOSED);
} /* namespace CGAL */ } /* namespace CGAL */
namespace CGAL { namespace CGAL {
/*! /*!
\ingroup PkgBoxIntersectionD \ingroup PkgBoxIntersectionD_box_intersection_d
Invocation of box intersection with default box traits Invocation of box intersection with default box traits
`CGAL::Box_intersection_d::Box_traits_d<Box_handle>`, where `CGAL::Box_intersection_d::Box_traits_d<Box_handle>`, where
`Box_handle` corresponds to the iterator value type of `Box_handle` corresponds to the iterator value type of
`RandomAccessIterator1`. `RandomAccessIterator1`.
See \ref box_intersection_d.
*/ */
template< class RandomAccessIterator1, template< class RandomAccessIterator1,
@ -268,16 +264,14 @@ void box_intersection_d(
RandomAccessIterator2 begin2, RandomAccessIterator2 end2, RandomAccessIterator2 begin2, RandomAccessIterator2 end2,
Callback callback, Callback callback,
std::ptrdiff_t cutoff = 10, std::ptrdiff_t cutoff = 10,
Box_intersection_d::Topology topology = Box_intersection_d::CLOSED, CGAL::Box_intersection_d::Topology topology = CGAL::Box_intersection_d::CLOSED,
Box_intersection_d::Setting setting = Box_intersection_d::BIPARTITE); CGAL::Box_intersection_d::Setting setting = CGAL::Box_intersection_d::BIPARTITE);
/*! /*!
\ingroup PkgBoxIntersectionD \ingroup PkgBoxIntersectionD_box_intersection_d
Invocation with custom box traits. Invocation with custom box traits.
See \ref box_intersection_d.
*/ */
template< class RandomAccessIterator1, template< class RandomAccessIterator1,
class RandomAccessIterator2, class RandomAccessIterator2,
@ -288,20 +282,19 @@ void box_intersection_d(
Callback callback, Callback callback,
BoxTraits box_traits, BoxTraits box_traits,
std::ptrdiff_t cutoff = 10, std::ptrdiff_t cutoff = 10,
Box_intersection_d::Topology topology = Box_intersection_d::CLOSED, CGAL::Box_intersection_d::Topology topology = CGAL::Box_intersection_d::CLOSED,
Box_intersection_d::Setting setting = Box_intersection_d::BIPARTITE); CGAL::Box_intersection_d::Setting setting = CGAL::Box_intersection_d::BIPARTITE);
} /* namespace CGAL */ } /* namespace CGAL */
namespace CGAL { namespace CGAL {
/*! /*!
\page box_self_intersection_all_pairs_d box_self_intersection_all_pairs_d \addtogroup PkgBoxIntersectionD_box_self_intersection_all_pairs_d
The function `box_self_intersection_all_pairs_d` computes the pairwise intersecting boxes The function `box_self_intersection_all_pairs_d` computes the pairwise intersecting boxes
in a sequence of iso-oriented boxes in arbitrary dimension. in a sequence of iso-oriented boxes in arbitrary dimension.
It does so by comparing all possible pairs of boxes and is thus It does so by comparing all possible pairs of boxes and is thus
inferior to the fast `CGAL::box_self_intersection_d` algorithm on inferior to the fast `CGAL::box_self_intersection_d` algorithm.
page \ref ccRef_CGALbox_self_intersection_d.
The sequence of boxes is given with a forward iterator range. The The sequence of boxes is given with a forward iterator range. The
sequences are not modified. For each intersecting pair of boxes a sequences are not modified. For each intersecting pair of boxes a
@ -314,7 +307,7 @@ namespace CGAL {
either our box type or a pointer type to our box type. either our box type or a pointer type to our box type.
A \f$ d\f$-dimensional iso-oriented box is defined as the A \f$ d\f$-dimensional iso-oriented box is defined as the
Cartesian product of \f$ d\f$ intervals. We call the %Cartesian product of \f$ d\f$ intervals. We call the
box <I>half-open</I> if the \f$ d\f$ intervals \f$ \{ [lo_i,hi_i) \,|\, 0 \leq box <I>half-open</I> if the \f$ d\f$ intervals \f$ \{ [lo_i,hi_i) \,|\, 0 \leq
i < d\}\f$ are half-open intervals, and we call the box <I>closed</I> if i < d\}\f$ are half-open intervals, and we call the box <I>closed</I> if
the \f$ d\f$ intervals \f$ \{ [lo_i,hi_i] \,|\, 0 \leq i < d\}\f$ are closed the \f$ d\f$ intervals \f$ \{ [lo_i,hi_i] \,|\, 0 \leq i < d\}\f$ are closed
@ -367,27 +360,25 @@ namespace CGAL {
*/ */
/*! /*!
\ingroup PkgBoxIntersectionD \ingroup PkgBoxIntersectionD_box_self_intersection_all_pairs_d
Invocation of box intersection with default box traits Invocation of box intersection with default box traits
`CGAL::Box_intersection_d::Box_traits_d<Box_handle>`, where `CGAL::Box_intersection_d::Box_traits_d<Box_handle>`, where
`Box_handle` corresponds to the iterator value type of `Box_handle` corresponds to the iterator value type of
`ForwardIterator`. `ForwardIterator`.
See \ref box_self_intersection_all_pairs_d.
*/ */
template< class ForwardIterator, class Callback > template< class ForwardIterator, class Callback >
void box_self_intersection_all_pairs_d( void box_self_intersection_all_pairs_d(
ForwardIterator begin, ForwardIterator end, ForwardIterator begin, ForwardIterator end,
Callback callback, Callback callback,
Box_intersection_d::Topology topology = Box_intersection_d::CLOSED); CGAL::Box_intersection_d::Topology topology = CGAL::Box_intersection_d::CLOSED);
/*! /*!
\ingroup PkgBoxIntersectionD \ingroup PkgBoxIntersectionD_box_self_intersection_all_pairs_d
Invocation with custom box traits. Invocation with custom box traits.
See \ref box_self_intersection_all_pairs_d.
*/ */
template< class ForwardIterator, template< class ForwardIterator,
@ -396,14 +387,14 @@ void box_self_intersection_all_pairs_d(
ForwardIterator begin, ForwardIterator end, ForwardIterator begin, ForwardIterator end,
Callback callback, Callback callback,
BoxTraits box_traits, BoxTraits box_traits,
Box_intersection_d::Topology topology = Box_intersection_d::CLOSED); CGAL::Box_intersection_d::Topology topology = CGAL::Box_intersection_d::CLOSED);
} /* namespace CGAL */ } /* namespace CGAL */
namespace CGAL { namespace CGAL {
/*! /*!
\page box_self_intersection_d box_self_intersection_d \addtogroup PkgBoxIntersectionD_box_self_intersection_d
The function `box_self_intersection_d` computes the pairwise intersecting boxes The function `box_self_intersection_d` computes the pairwise intersecting boxes
in a sequence of iso-oriented boxes in arbitrary dimension. in a sequence of iso-oriented boxes in arbitrary dimension.
The sequence of boxes is given with as a random-access iterator The sequence of boxes is given with as a random-access iterator
@ -413,8 +404,7 @@ namespace CGAL {
box from the sequence, the second argument is a copy of a box from the box from the sequence, the second argument is a copy of a box from the
sequence. The performance of the algorithm can be tuned with a sequence. The performance of the algorithm can be tuned with a
`cutoff` parameter, see the implementation section of the `cutoff` parameter, see the implementation section of the
`CGAL::box_intersection_d` function on page `CGAL::box_intersection_d` function.
\ref ccRef_CGALbox_intersection_d.
The algorithm creates a second copy of the boxes and reorders the The algorithm creates a second copy of the boxes and reorders the
boxes in the course of the algorithm. Now, depending on the size of a boxes in the course of the algorithm. Now, depending on the size of a
@ -426,7 +416,7 @@ namespace CGAL {
box type. box type.
A \f$ d\f$-dimensional iso-oriented box is defined as the A \f$ d\f$-dimensional iso-oriented box is defined as the
Cartesian product of \f$ d\f$ intervals. We call the %Cartesian product of \f$ d\f$ intervals. We call the
box <I>half-open</I> if the \f$ d\f$ intervals \f$ \{ [lo_i,hi_i) \,|\, 0 \leq box <I>half-open</I> if the \f$ d\f$ intervals \f$ \{ [lo_i,hi_i) \,|\, 0 \leq
i < d\}\f$ are half-open intervals, and we call the box <I>closed</I> if i < d\}\f$ are half-open intervals, and we call the box <I>closed</I> if
the \f$ d\f$ intervals \f$ \{ [lo_i,hi_i] \,|\, 0 \leq i < d\}\f$ are closed the \f$ d\f$ intervals \f$ \{ [lo_i,hi_i] \,|\, 0 \leq i < d\}\f$ are closed
@ -483,7 +473,7 @@ namespace CGAL {
### Implementation ### ### Implementation ###
See the implementation section of the `CGAL::box_intersection_d` See the implementation section of the `CGAL::box_intersection_d`
function on page \ref ccRef_CGALbox_intersection_d. function.
### Example ### ### Example ###
@ -505,30 +495,25 @@ namespace CGAL {
*/ */
/*! /*!
\ingroup PkgBoxIntersectionD \ingroup PkgBoxIntersectionD_box_self_intersection_d
Invocation of box intersection with default box traits Invocation of box intersection with default box traits
`CGAL::Box_intersection_d::Box_traits_d<Box_handle>`, where `CGAL::Box_intersection_d::Box_traits_d<Box_handle>`, where
`Box_handle` corresponds to the iterator value type of `Box_handle` corresponds to the iterator value type of
`RandomAccessIterator`. `RandomAccessIterator`.
See \ref box_self_intersection_d.
*/ */
template< class RandomAccessIterator, class Callback > template< class RandomAccessIterator, class Callback >
void box_self_intersection_d( void box_self_intersection_d(
RandomAccessIterator begin, RandomAccessIterator end, RandomAccessIterator begin, RandomAccessIterator end,
Callback callback, Callback callback,
std::ptrdiff_t cutoff = 10, std::ptrdiff_t cutoff = 10,
Box_intersection_d::Topology topology = Box_intersection_d::CLOSED); CGAL::Box_intersection_d::Topology topology = CGAL::Box_intersection_d::CLOSED);
/*! /*!
\ingroup PkgBoxIntersectionD \ingroup PkgBoxIntersectionD_box_self_intersection_d
Invocation with custom box traits. Invocation with custom box traits.
See \ref box_self_intersection_d.
*/ */
template< class RandomAccessIterator, template< class RandomAccessIterator,
class Callback, class BoxTraits > class Callback, class BoxTraits >
@ -537,6 +522,6 @@ void box_self_intersection_d(
Callback callback, Callback callback,
BoxTraits box_traits, BoxTraits box_traits,
std::ptrdiff_t cutoff = 10, std::ptrdiff_t cutoff = 10,
Box_intersection_d::Topology topology = Box_intersection_d::CLOSED); CGAL::Box_intersection_d::Topology topology = CGAL::Box_intersection_d::CLOSED);
} /* namespace CGAL */ } /* namespace CGAL */

20
Box_intersection_d/doc/Box_intersection_d/PackageDescription.txt
View File

@ -1,9 +1,27 @@
/// \defgroup PkgBoxIntersectionD Intersecting Sequences of dD Iso-oriented Boxes Reference /// \defgroup PkgBoxIntersectionD Intersecting Sequences of dD Iso-oriented Boxes Reference
/// \defgroup PkgBoxIntersectionDConcepts Concepts /// \defgroup PkgBoxIntersectionDConcepts Concepts
/// \ingroup PkgBoxIntersectionD /// \ingroup PkgBoxIntersectionD
/// \defgroup PkgBoxIntersectionDClasses Classes
/// \ingroup PkgBoxIntersectionD
/// \defgroup PkgBoxIntersectionD_box_intersection_d box_intersection_d
/// \ingroup PkgBoxIntersectionD
/// \defgroup PkgBoxIntersectionD_box_intersection_all_pairs_d box_intersection_all_pairs_d
/// \ingroup PkgBoxIntersectionD
/// \defgroup PkgBoxIntersectionD_box_self_intersection_d box_self_intersection_d
/// \ingroup PkgBoxIntersectionD
/// \defgroup PkgBoxIntersectionD_box_self_intersection_all_pairs_d box_self_intersection_all_pairs_d
/// \ingroup PkgBoxIntersectionD
/*! /*!
\addtogroup PkgBoxIntersectionD \addtogroup PkgBoxIntersectionD
\todo check generated documentation
\todo de-math and change D to d for the dimension
\PkgDescriptionBegin{Intersecting Sequences of dD Iso-oriented Boxes,PkgBoxIntersectionDSummary} \PkgDescriptionBegin{Intersecting Sequences of dD Iso-oriented Boxes,PkgBoxIntersectionDSummary}
\PkgPicture{box_inters-small.gif} \PkgPicture{box_inters-small.gif}
\PkgAuthors{Lutz Kettner, Andreas Meyer, and Afra Zomorodian} \PkgAuthors{Lutz Kettner, Andreas Meyer, and Afra Zomorodian}