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

Cleaned up; replaced `typedef` with `using`, etc.

This commit is contained in:
Efi Fogel 2025-08-26 21:58:34 +03:00
parent e5049d4b03
commit a74945062c
23 changed files with 647 additions and 809 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/Bso_internal_functions.h
View File

@ -52,7 +52,7 @@ inline bool s_do_intersect(const Pgn1& pgn1, const Pgn2& pgn2) {
// With Traits // With Traits
template <typename InputIterator, typename Traits> template <typename InputIterator, typename Traits>
inline bool r_do_intersect(InputIterator begin, InputIterator end, inline bool r_do_intersect(InputIterator begin, InputIterator end,
Traits& traits, unsigned int k = 5) { Traits& traits, std::size_t k = 5) {
if (begin == end) return false; if (begin == end) return false;
General_polygon_set_2<Traits> gps(*begin, traits); General_polygon_set_2<Traits> gps(*begin, traits);
return gps.do_intersect(std::next(begin), end, k); return gps.do_intersect(std::next(begin), end, k);
@ -61,7 +61,7 @@ inline bool r_do_intersect(InputIterator begin, InputIterator end,
// Without Traits // Without Traits
template <typename InputIterator> template <typename InputIterator>
inline bool r_do_intersect(InputIterator begin, InputIterator end, inline bool r_do_intersect(InputIterator begin, InputIterator end,
unsigned int k = 5) { std::size_t k = 5) {
using Pgn = typename std::iterator_traits<InputIterator>::value_type; using Pgn = typename std::iterator_traits<InputIterator>::value_type;
typename Gps_polyline_traits<Pgn>::Traits traits; typename Gps_polyline_traits<Pgn>::Traits traits;
const typename Gps_polyline_traits<Pgn>::Polyline_traits& ptraits(traits); const typename Gps_polyline_traits<Pgn>::Polyline_traits& ptraits(traits);
@ -74,7 +74,7 @@ inline bool r_do_intersect(InputIterator begin, InputIterator end,
template <typename InputIterator1, typename InputIterator2, typename Traits> template <typename InputIterator1, typename InputIterator2, typename Traits>
inline bool r_do_intersect(InputIterator1 begin1, InputIterator1 end1, inline bool r_do_intersect(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2, InputIterator2 begin2, InputIterator2 end2,
Traits& traits, unsigned int k = 5) { Traits& traits, std::size_t k = 5) {
if (begin1 == end1) return do_intersect(begin2, end2, traits, k); if (begin1 == end1) return do_intersect(begin2, end2, traits, k);
General_polygon_set_2<Traits> gps(*begin1, traits); General_polygon_set_2<Traits> gps(*begin1, traits);
return gps.do_intersect(std::next(begin1), end1, begin2, end2, k); return gps.do_intersect(std::next(begin1), end1, begin2, end2, k);
@ -84,7 +84,7 @@ inline bool r_do_intersect(InputIterator1 begin1, InputIterator1 end1,
template <typename InputIterator1, typename InputIterator2> template <typename InputIterator1, typename InputIterator2>
inline bool r_do_intersect (InputIterator1 begin1, InputIterator1 end1, inline bool r_do_intersect (InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2, InputIterator2 begin2, InputIterator2 end2,
unsigned int k = 5) { std::size_t k = 5) {
using Pgn = typename std::iterator_traits<InputIterator1>::value_type; using Pgn = typename std::iterator_traits<InputIterator1>::value_type;
typename Gps_polyline_traits<Pgn>::Traits traits; typename Gps_polyline_traits<Pgn>::Traits traits;
const typename Gps_polyline_traits<Pgn>::Polyline_traits& ptraits(traits); const typename Gps_polyline_traits<Pgn>::Polyline_traits& ptraits(traits);
@ -162,7 +162,7 @@ inline OutputIterator s_intersection(const Pgn1& pgn1, const Pgn2& pgn2,
template <typename InputIterator, typename OutputIterator, typename Traits> template <typename InputIterator, typename OutputIterator, typename Traits>
inline OutputIterator r_intersection(InputIterator begin, InputIterator end, inline OutputIterator r_intersection(InputIterator begin, InputIterator end,
OutputIterator oi, Traits& traits, OutputIterator oi, Traits& traits,
unsigned int k = 5) { std::size_t k = 5) {
if (begin == end) return (oi); if (begin == end) return (oi);
General_polygon_set_2<Traits> gps(*begin, traits); General_polygon_set_2<Traits> gps(*begin, traits);
gps.intersection(std::next(begin), end, k); gps.intersection(std::next(begin), end, k);
@ -172,7 +172,7 @@ inline OutputIterator r_intersection(InputIterator begin, InputIterator end,
// Without Traits // Without Traits
template <typename InputIterator, typename OutputIterator> template <typename InputIterator, typename OutputIterator>
inline OutputIterator r_intersection(InputIterator begin, InputIterator end, inline OutputIterator r_intersection(InputIterator begin, InputIterator end,
OutputIterator oi, unsigned int k = 5) { OutputIterator oi, std::size_t k = 5) {
using Pgn = typename std::iterator_traits<InputIterator>::value_type; using Pgn = typename std::iterator_traits<InputIterator>::value_type;
typename Gps_polyline_traits<Pgn>::Traits traits; typename Gps_polyline_traits<Pgn>::Traits traits;
const typename Gps_polyline_traits<Pgn>::Polyline_traits& ptraits(traits); const typename Gps_polyline_traits<Pgn>::Polyline_traits& ptraits(traits);
@ -189,7 +189,7 @@ template <typename InputIterator1, typename InputIterator2,
inline OutputIterator r_intersection(InputIterator1 begin1, InputIterator1 end1, inline OutputIterator r_intersection(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2, InputIterator2 begin2, InputIterator2 end2,
OutputIterator oi, Traits& traits, OutputIterator oi, Traits& traits,
unsigned int k = 5) { std::size_t k = 5) {
if (begin1 == end1) return r_intersection(begin2, end2, oi, traits, k); if (begin1 == end1) return r_intersection(begin2, end2, oi, traits, k);
General_polygon_set_2<Traits> gps(*begin1, traits); General_polygon_set_2<Traits> gps(*begin1, traits);
gps.intersection(std::next(begin1), end1, begin2, end2, k); gps.intersection(std::next(begin1), end1, begin2, end2, k);
@ -202,7 +202,7 @@ template <typename InputIterator1, typename InputIterator2,
inline OutputIterator inline OutputIterator
r_intersection(InputIterator1 begin1, InputIterator1 end1, r_intersection(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2, InputIterator2 begin2, InputIterator2 end2,
OutputIterator oi, unsigned int k = 5) { OutputIterator oi, std::size_t k = 5) {
using Pgn = typename std::iterator_traits<InputIterator1>::value_type; using Pgn = typename std::iterator_traits<InputIterator1>::value_type;
typename Gps_polyline_traits<Pgn>::Traits traits; typename Gps_polyline_traits<Pgn>::Traits traits;
const typename Gps_polyline_traits<Pgn>::Polyline_traits& ptraits(traits); const typename Gps_polyline_traits<Pgn>::Polyline_traits& ptraits(traits);
@ -286,7 +286,7 @@ inline bool s_join(const Pgn1& pgn1, const Pgn2& pgn2, Pwh& pwh) {
template <typename InputIterator, typename OutputIterator, typename Traits> template <typename InputIterator, typename OutputIterator, typename Traits>
inline OutputIterator r_join(InputIterator begin, InputIterator end, inline OutputIterator r_join(InputIterator begin, InputIterator end,
OutputIterator oi, Traits& traits, OutputIterator oi, Traits& traits,
unsigned int k = 5) { std::size_t k = 5) {
if (begin == end) return oi; if (begin == end) return oi;
General_polygon_set_2<Traits> gps(*begin, traits); General_polygon_set_2<Traits> gps(*begin, traits);
gps.join(std::next(begin), end, k); gps.join(std::next(begin), end, k);
@ -296,7 +296,7 @@ inline OutputIterator r_join(InputIterator begin, InputIterator end,
// Without traits // Without traits
template <typename InputIterator, typename OutputIterator> template <typename InputIterator, typename OutputIterator>
inline OutputIterator r_join(InputIterator begin, InputIterator end, inline OutputIterator r_join(InputIterator begin, InputIterator end,
OutputIterator oi, unsigned int k = 5) { OutputIterator oi, std::size_t k = 5) {
using Pgn = typename std::iterator_traits<InputIterator>::value_type; using Pgn = typename std::iterator_traits<InputIterator>::value_type;
typename Gps_polyline_traits<Pgn>::Traits traits; typename Gps_polyline_traits<Pgn>::Traits traits;
const typename Gps_polyline_traits<Pgn>::Polyline_traits& ptraits(traits); const typename Gps_polyline_traits<Pgn>::Polyline_traits& ptraits(traits);
@ -315,7 +315,7 @@ template <typename InputIterator1, typename InputIterator2,
inline OutputIterator r_join(InputIterator1 begin1, InputIterator1 end1, inline OutputIterator r_join(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2, InputIterator2 begin2, InputIterator2 end2,
OutputIterator oi, Traits& traits, OutputIterator oi, Traits& traits,
unsigned int k = 5) { std::size_t k = 5) {
if (begin1 == end1) return r_join(begin2, end2, oi, traits, k); if (begin1 == end1) return r_join(begin2, end2, oi, traits, k);
General_polygon_set_2<Traits> gps(*begin1, traits); General_polygon_set_2<Traits> gps(*begin1, traits);
gps.join(std::next(begin1), end1, begin2, end2, k); gps.join(std::next(begin1), end1, begin2, end2, k);
@ -327,7 +327,7 @@ template <typename InputIterator1, typename InputIterator2,
typename OutputIterator> typename OutputIterator>
inline OutputIterator r_join(InputIterator1 begin1, InputIterator1 end1, inline OutputIterator r_join(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2, InputIterator2 begin2, InputIterator2 end2,
OutputIterator oi, unsigned int k = 5) { OutputIterator oi, std::size_t k = 5) {
using Pgn = typename std::iterator_traits<InputIterator1>::value_type; using Pgn = typename std::iterator_traits<InputIterator1>::value_type;
typename Gps_polyline_traits<Pgn>::Traits traits; typename Gps_polyline_traits<Pgn>::Traits traits;
const typename Gps_polyline_traits<Pgn>::Polyline_traits& ptraits(traits); const typename Gps_polyline_traits<Pgn>::Polyline_traits& ptraits(traits);
@ -407,7 +407,7 @@ template <typename InputIterator, typename OutputIterator, typename Traits>
inline inline
OutputIterator r_symmetric_difference(InputIterator begin, InputIterator end, OutputIterator r_symmetric_difference(InputIterator begin, InputIterator end,
OutputIterator oi, Traits& traits, OutputIterator oi, Traits& traits,
unsigned int k = 5) { std::size_t k = 5) {
if (begin == end) return (oi); if (begin == end) return (oi);
General_polygon_set_2<Traits> gps(*begin, traits); General_polygon_set_2<Traits> gps(*begin, traits);
gps.symmetric_difference(std::next(begin), end, k); gps.symmetric_difference(std::next(begin), end, k);
@ -419,7 +419,7 @@ template <typename InputIterator, typename OutputIterator>
inline OutputIterator r_symmetric_difference(InputIterator begin, inline OutputIterator r_symmetric_difference(InputIterator begin,
InputIterator end, InputIterator end,
OutputIterator oi, OutputIterator oi,
unsigned int k = 5) { std::size_t k = 5) {
using Pgn = typename std::iterator_traits<InputIterator>::value_type; using Pgn = typename std::iterator_traits<InputIterator>::value_type;
typename Gps_polyline_traits<Pgn>::Traits traits; typename Gps_polyline_traits<Pgn>::Traits traits;
const typename Gps_polyline_traits<Pgn>::Polyline_traits& ptraits(traits); const typename Gps_polyline_traits<Pgn>::Polyline_traits& ptraits(traits);
@ -438,7 +438,7 @@ inline OutputIterator r_symmetric_difference(InputIterator1 begin1,
InputIterator2 begin2, InputIterator2 begin2,
InputIterator2 end2, InputIterator2 end2,
OutputIterator oi, Traits& traits, OutputIterator oi, Traits& traits,
unsigned int k = 5) { std::size_t k = 5) {
if (begin1 == end1) return r_symmetric_difference(begin2, end2, oi, traits, k); if (begin1 == end1) return r_symmetric_difference(begin2, end2, oi, traits, k);
General_polygon_set_2<Traits> gps(*begin1, traits); General_polygon_set_2<Traits> gps(*begin1, traits);
gps.symmetric_difference(std::next(begin1), end1, begin2, end2, k); gps.symmetric_difference(std::next(begin1), end1, begin2, end2, k);
@ -453,7 +453,7 @@ inline OutputIterator r_symmetric_difference(InputIterator1 begin1,
InputIterator2 begin2, InputIterator2 begin2,
InputIterator2 end2, InputIterator2 end2,
OutputIterator oi, OutputIterator oi,
unsigned int k = 5) { std::size_t k = 5) {
using Pgn = typename std::iterator_traits<InputIterator1>::value_type; using Pgn = typename std::iterator_traits<InputIterator1>::value_type;
typename Gps_polyline_traits<Pgn>::Traits traits; typename Gps_polyline_traits<Pgn>::Traits traits;
const typename Gps_polyline_traits<Pgn>::Polyline_traits& ptraits(traits); const typename Gps_polyline_traits<Pgn>::Polyline_traits& ptraits(traits);

141
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/Gps_agg_meta_traits.h
View File

@ -24,18 +24,17 @@
namespace CGAL { namespace CGAL {
template <typename Arrangement_> template <typename Arrangement_>
class Gps_agg_curve_data : public Curve_with_halfedge<Arrangement_> class Gps_agg_curve_data : public Curve_with_halfedge<Arrangement_> {
{
protected: protected:
typedef Arrangement_ Arrangement; using Arrangement = Arrangement_;
typedef typename Arrangement::Halfedge_handle Halfedge_handle; using Halfedge_handle = typename Arrangement::Halfedge_handle;
typedef Curve_with_halfedge<Arrangement_> Base; using Base = Curve_with_halfedge<Arrangement_>;
const Arrangement* m_arr; // pointer to the arrangement containing the edge. const Arrangement* m_arr; // pointer to the arrangement containing the edge.
unsigned int m_bc; // the boundary counter of the halfedge with the same std::size_t m_bc; // the boundary counter of the halfedge with the same
// direction as the curve // direction as the curve
unsigned int m_twin_bc; // the boundary counter of the halfedge with the same std::size_t m_twin_bc; // the boundary counter of the halfedge with the same
// direction as the curve // direction as the curve
public: public:
@ -47,24 +46,24 @@ public:
{} {}
Gps_agg_curve_data(const Arrangement* arr, Halfedge_handle he, Gps_agg_curve_data(const Arrangement* arr, Halfedge_handle he,
unsigned int bc, unsigned int twin_bc) : std::size_t bc, std::size_t twin_bc) :
Base(he), Base(he),
m_arr(arr), m_arr(arr),
m_bc(bc), m_bc(bc),
m_twin_bc(twin_bc) m_twin_bc(twin_bc)
{} {}
unsigned int bc() const { return m_bc; } std::size_t bc() const { return m_bc; }
unsigned int twin_bc() const { return m_twin_bc; } std::size_t twin_bc() const { return m_twin_bc; }
unsigned int& bc() { return m_bc; } std::size_t& bc() { return m_bc; }
unsigned int& twin_bc() { return m_twin_bc; } std::size_t& twin_bc() { return m_twin_bc; }
void set_bc(unsigned int bc) { m_bc = bc; } void set_bc(std::size_t bc) { m_bc = bc; }
void set_twin_bc(unsigned int twin_bc) { m_twin_bc = twin_bc; } void set_twin_bc(std::size_t twin_bc) { m_twin_bc = twin_bc; }
const Arrangement* arr() const { return m_arr; } const Arrangement* arr() const { return m_arr; }
}; };
@ -73,54 +72,50 @@ template <typename Arrangement_>
class Gps_agg_meta_traits : class Gps_agg_meta_traits :
public Gps_traits_decorator<typename Arrangement_::Traits_adaptor_2, public Gps_traits_decorator<typename Arrangement_::Traits_adaptor_2,
Gps_agg_curve_data<Arrangement_>, Gps_agg_curve_data<Arrangement_>,
Point_with_vertex<Arrangement_> > Point_with_vertex<Arrangement_>> {
{ using Arrangement = Arrangement_;
typedef Arrangement_ Arrangement; using Arr = Arrangement;
typedef Arrangement Arr;
typedef typename Arr::Traits_adaptor_2 Traits; using Traits = typename Arr::Traits_adaptor_2;
typedef Traits Gt2; using Gt2 = Traits;
typedef typename Gt2::X_monotone_curve_2 Base_x_monotone_curve_2; using Base_x_monotone_curve_2 = typename Gt2::X_monotone_curve_2;
typedef typename Gt2::Point_2 Base_point_2; using Base_point_2 = typename Gt2::Point_2;
typedef typename Gt2::Construct_min_vertex_2 Base_Construct_min_vertex_2; using Base_Construct_min_vertex_2 = typename Gt2::Construct_min_vertex_2;
typedef typename Gt2::Construct_max_vertex_2 Base_Construct_max_vertex_2; using Base_Construct_max_vertex_2 = typename Gt2::Construct_max_vertex_2;
typedef typename Gt2::Compare_endpoints_xy_2 Base_Compare_endpoints_xy_2; using Base_Compare_endpoints_xy_2 = typename Gt2::Compare_endpoints_xy_2;
typedef typename Gt2::Compare_xy_2 Base_Compare_xy_2; using Base_Compare_xy_2 = typename Gt2::Compare_xy_2;
typedef typename Gt2::Compare_y_at_x_right_2 Base_Compare_y_at_x_right_2; using Base_Compare_y_at_x_right_2 = typename Gt2::Compare_y_at_x_right_2;
typedef typename Gt2::Compare_y_at_x_2 Base_Compare_y_at_x_2; using Base_Compare_y_at_x_2 = typename Gt2::Compare_y_at_x_2;
typedef typename Gt2::Intersect_2 Base_Intersect_2; using Base_Intersect_2 = typename Gt2::Intersect_2;
typedef typename Gt2::Split_2 Base_Split_2; using Base_Split_2 = typename Gt2::Split_2;
typedef typename Gt2::Parameter_space_in_x_2 Base_Parameter_space_in_x_2; using Base_Parameter_space_in_x_2 = typename Gt2::Parameter_space_in_x_2;
typedef typename Gt2::Compare_y_near_boundary_2 using Base_Compare_y_near_boundary_2 = typename Gt2::Compare_y_near_boundary_2;
Base_Compare_y_near_boundary_2;
typedef typename Gt2::Parameter_space_in_y_2 Base_Parameter_space_in_y_2; using Base_Parameter_space_in_y_2 = typename Gt2::Parameter_space_in_y_2;
typedef typename Gt2::Compare_x_near_boundary_2 using Base_Compare_x_near_boundary_2 = typename Gt2::Compare_x_near_boundary_2;
Base_Compare_x_near_boundary_2;
public: public:
typedef typename Gt2::Multiplicity Multiplicity; using Multiplicity = typename Gt2::Multiplicity;
typedef Gps_agg_curve_data<Arr> Curve_data; using Curve_data = Gps_agg_curve_data<Arr>;
typedef Point_with_vertex<Arr> Point_data; using Point_data = Point_with_vertex<Arr>;
private: private:
typedef Gps_agg_meta_traits<Arrangement> Self; using Self = Gps_agg_meta_traits<Arrangement>;
typedef Gps_traits_decorator<Gt2, Curve_data, Point_data> Base; using Base = Gps_traits_decorator<Gt2, Curve_data, Point_data>;
public: public:
typedef typename Base::X_monotone_curve_2 X_monotone_curve_2; using X_monotone_curve_2 = typename Base::X_monotone_curve_2;
typedef typename Base::Point_2 Point_2; using Point_2 = typename Base::Point_2;
typedef typename Gt2::Has_left_category Has_left_category; using Has_left_category = typename Gt2::Has_left_category;
typedef typename Gt2::Has_merge_category Has_merge_category; using Has_merge_category = typename Gt2::Has_merge_category;
typedef typename Gt2::Has_do_intersect_category using Has_do_intersect_category = typename Gt2::Has_do_intersect_category;
Has_do_intersect_category;
typedef typename Arr::Left_side_category Left_side_category; using Left_side_category = typename Arr::Left_side_category;
typedef typename Arr::Bottom_side_category Bottom_side_category; using Bottom_side_category = typename Arr::Bottom_side_category;
typedef typename Arr::Top_side_category Top_side_category; using Top_side_category = typename Arr::Top_side_category;
typedef typename Arr::Right_side_category Right_side_category; using Right_side_category = typename Arr::Right_side_category;
// a side is either oblivious or open (unbounded) // a side is either oblivious or open (unbounded)
static_assert(std::is_same<Left_side_category, Arr_oblivious_side_tag>::value || static_assert(std::is_same<Left_side_category, Arr_oblivious_side_tag>::value ||
@ -132,8 +127,8 @@ public:
static_assert(std::is_same<Right_side_category, Arr_oblivious_side_tag>::value || static_assert(std::is_same<Right_side_category, Arr_oblivious_side_tag>::value ||
std::is_same<Right_side_category, Arr_open_side_tag>::value); std::is_same<Right_side_category, Arr_open_side_tag>::value);
typedef typename Arr::Halfedge_handle Halfedge_handle; using Halfedge_handle = typename Arr::Halfedge_handle;
typedef typename Arr::Vertex_handle Vertex_handle; using Vertex_handle = typename Arr::Vertex_handle;
Gps_agg_meta_traits() {} Gps_agg_meta_traits() {}
@ -152,16 +147,13 @@ public:
template <typename OutputIterator> template <typename OutputIterator>
OutputIterator operator()(const X_monotone_curve_2& cv1, OutputIterator operator()(const X_monotone_curve_2& cv1,
const X_monotone_curve_2& cv2, const X_monotone_curve_2& cv2,
OutputIterator oi) const OutputIterator oi) const {
{
// Check whether the curves are already in the same arrangement, and thus // Check whether the curves are already in the same arrangement, and thus
// must be interior-disjoint // must be interior-disjoint
if (cv1.data().arr() == cv2.data().arr()) return oi; if (cv1.data().arr() == cv2.data().arr()) return oi;
typedef const std::pair<Base_point_2, Multiplicity> using Intersection_base_point = const std::pair<Base_point_2, Multiplicity>;
Intersection_base_point; using Intersection_base_result = std::variant<Intersection_base_point, Base_x_monotone_curve_2>;
typedef std::variant<Intersection_base_point, Base_x_monotone_curve_2>
Intersection_base_result;
const auto* base_traits = m_traits.m_base_traits; const auto* base_traits = m_traits.m_base_traits;
auto base_cmp_xy = base_traits->compare_xy_2_object(); auto base_cmp_xy = base_traits->compare_xy_2_object();
@ -191,8 +183,8 @@ public:
const Base_x_monotone_curve_2* overlap_cv = const Base_x_monotone_curve_2* overlap_cv =
std::get_if<Base_x_monotone_curve_2>(&xection); std::get_if<Base_x_monotone_curve_2>(&xection);
CGAL_assertion(overlap_cv != nullptr); CGAL_assertion(overlap_cv != nullptr);
unsigned int ov_bc; std::size_t ov_bc;
unsigned int ov_twin_bc; std::size_t ov_twin_bc;
if (base_cmp_endpoints(cv1) == base_cmp_endpoints(cv2)) { if (base_cmp_endpoints(cv1) == base_cmp_endpoints(cv2)) {
// cv1 and cv2 have the same directions // cv1 and cv2 have the same directions
ov_bc = cv1.data().bc() + cv2.data().bc(); ov_bc = cv1.data().bc() + cv2.data().bc();
@ -230,8 +222,7 @@ public:
Split_2(const Base_Split_2& base) : m_base_split(base) {} Split_2(const Base_Split_2& base) : m_base_split(base) {}
void operator()(const X_monotone_curve_2& cv, const Point_2 & p, void operator()(const X_monotone_curve_2& cv, const Point_2 & p,
X_monotone_curve_2& c1, X_monotone_curve_2& c2) const X_monotone_curve_2& c1, X_monotone_curve_2& c2) const {
{
m_base_split(cv.base(), p.base(), c1.base(), c2.base()); m_base_split(cv.base(), p.base(), c1.base(), c2.base());
const Curve_data& cv_data = cv.data(); const Curve_data& cv_data = cv.data();
c1.set_data(Curve_data(cv_data.arr(), Halfedge_handle(), cv_data.bc(), c1.set_data(Curve_data(cv_data.arr(), Halfedge_handle(), cv_data.bc(),
@ -259,8 +250,7 @@ public:
* \param cv The curve. * \param cv The curve.
* \return The left endpoint. * \return The left endpoint.
*/ */
Point_2 operator()(const X_monotone_curve_2 & cv) const Point_2 operator()(const X_monotone_curve_2 & cv) const {
{
if (cv.data().halfedge() == Halfedge_handle()) if (cv.data().halfedge() == Halfedge_handle())
return (Point_2(m_base(cv.base()))); return (Point_2(m_base(cv.base())));
@ -272,8 +262,7 @@ public:
}; };
/*! Get a Construct_min_vertex_2 functor object. */ /*! Get a Construct_min_vertex_2 functor object. */
Construct_min_vertex_2 construct_min_vertex_2_object() const Construct_min_vertex_2 construct_min_vertex_2_object() const {
{
return Construct_min_vertex_2(this->m_base_traits-> return Construct_min_vertex_2(this->m_base_traits->
construct_min_vertex_2_object()); construct_min_vertex_2_object());
} }
@ -292,8 +281,7 @@ public:
* \param cv The curve. * \param cv The curve.
* \return The right endpoint. * \return The right endpoint.
*/ */
Point_2 operator()(const X_monotone_curve_2& cv) const Point_2 operator()(const X_monotone_curve_2& cv) const {
{
if (cv.data().halfedge() == Halfedge_handle()) if (cv.data().halfedge() == Halfedge_handle())
return (Point_2(m_base(cv.base()))); return (Point_2(m_base(cv.base())));
@ -304,8 +292,7 @@ public:
}; };
/*! Get a Construct_min_vertex_2 functor object. */ /*! Get a Construct_min_vertex_2 functor object. */
Construct_max_vertex_2 construct_max_vertex_2_object() const Construct_max_vertex_2 construct_max_vertex_2_object() const {
{
return Construct_max_vertex_2(this->m_base_traits-> return Construct_max_vertex_2(this->m_base_traits->
construct_max_vertex_2_object()); construct_max_vertex_2_object());
} }
@ -321,8 +308,7 @@ public:
* \param cv The curve. * \param cv The curve.
* \return The left endpoint. * \return The left endpoint.
*/ */
Comparison_result operator()(const Point_2& p1, const Point_2& p2) const Comparison_result operator()(const Point_2& p1, const Point_2& p2) const {
{
const Point_data& inf1 = p1.data(); const Point_data& inf1 = p1.data();
const Point_data& inf2 = p2.data(); const Point_data& inf2 = p2.data();
@ -390,8 +376,7 @@ public:
}; };
/*! Obtain a Construct_min_vertex_2 functor object. */ /*! Obtain a Construct_min_vertex_2 functor object. */
Compare_y_near_boundary_2 compare_y_near_boundary_2_object() const Compare_y_near_boundary_2 compare_y_near_boundary_2_object() const {
{
return Compare_y_near_boundary_2(this->m_base_traits-> return Compare_y_near_boundary_2(this->m_base_traits->
compare_y_near_boundary_2_object() compare_y_near_boundary_2_object()
); );
@ -429,8 +414,7 @@ public:
}; };
/*! Obtain a Construct_min_vertex_2 functor object. */ /*! Obtain a Construct_min_vertex_2 functor object. */
Parameter_space_in_y_2 parameter_space_in_y_2_object() const Parameter_space_in_y_2 parameter_space_in_y_2_object() const {
{
return Parameter_space_in_y_2(this->m_base_traits-> return Parameter_space_in_y_2(this->m_base_traits->
parameter_space_in_y_2_object()); parameter_space_in_y_2_object());
} }
@ -462,8 +446,7 @@ public:
}; };
/*! Obtain a Construct_min_vertex_2 functor object. */ /*! Obtain a Construct_min_vertex_2 functor object. */
Compare_x_near_boundary_2 compare_x_near_boundary_2_object() const Compare_x_near_boundary_2 compare_x_near_boundary_2_object() const {
{
return Compare_x_near_boundary_2(this->m_base_traits-> return Compare_x_near_boundary_2(this->m_base_traits->
compare_x_near_boundary_2_object()); compare_x_near_boundary_2_object());
} }

70
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/Gps_agg_op.h
View File

@ -39,29 +39,29 @@ namespace CGAL {
template <typename Arrangement_, typename BfsVisitor> template <typename Arrangement_, typename BfsVisitor>
class Gps_agg_op { class Gps_agg_op {
typedef Arrangement_ Arrangement_2; using Arrangement_2 = Arrangement_;
typedef BfsVisitor Bfs_visitor; using Bfs_visitor = BfsVisitor;
typedef typename Arrangement_2::Traits_adaptor_2 Geometry_traits_2; using Geometry_traits_2 = typename Arrangement_2::Traits_adaptor_2;
typedef typename Arrangement_2::Topology_traits Topology_traits; using Topology_traits = typename Arrangement_2::Topology_traits;
typedef Arrangement_2 Arr; using Arr = Arrangement_2;
typedef Geometry_traits_2 Gt2; using Gt2 = Geometry_traits_2;
typedef Topology_traits Tt; using Tt = Topology_traits;
typedef typename Gt2::Curve_const_iterator Curve_const_iterator; using Curve_const_iterator = typename Gt2::Curve_const_iterator;
typedef Gps_agg_meta_traits<Arr> Mgt2; using Mgt2 = Gps_agg_meta_traits<Arr>;
typedef typename Mgt2::Curve_data Curve_data; using Curve_data = typename Mgt2::Curve_data;
typedef typename Mgt2::X_monotone_curve_2 Meta_X_monotone_curve_2; using Meta_X_monotone_curve_2 = typename Mgt2::X_monotone_curve_2;
typedef typename Arr::Halfedge_handle Halfedge_handle; using Halfedge_handle = typename Arr::Halfedge_handle;
typedef typename Arr::Halfedge_iterator Halfedge_iterator; using Halfedge_iterator = typename Arr::Halfedge_iterator;
typedef typename Arr::Face_handle Face_handle; using Face_handle = typename Arr::Face_handle;
typedef typename Arr::Edge_iterator Edge_iterator; using Edge_iterator = typename Arr::Edge_iterator;
typedef typename Arr::Vertex_handle Vertex_handle; using Vertex_handle = typename Arr::Vertex_handle;
typedef typename Arr::Allocator Allocator; using Allocator = typename Arr::Allocator;
typedef std::pair<Arr*, std::vector<Vertex_handle> *> Arr_entry; using Arr_entry = std::pair<Arr*, std::vector<Vertex_handle> *>;
// We obtain a proper helper type from the topology traits of the arrangement. // We obtain a proper helper type from the topology traits of the arrangement.
// However, the arrangement is parametrized with the Gt2 geometry traits, // However, the arrangement is parametrized with the Gt2 geometry traits,
@ -70,21 +70,17 @@ class Gps_agg_op {
// We cannot parameterized the arrangement with the Mgt2 geometry // We cannot parameterized the arrangement with the Mgt2 geometry
// traits to start with, because it extends the curve type with arrangement // traits to start with, because it extends the curve type with arrangement
// dependent types. (It is parameterized with the arrangement type.) // dependent types. (It is parameterized with the arrangement type.)
typedef Indexed_event<Mgt2, Arr, Allocator> Event; using Event = Indexed_event<Mgt2, Arr, Allocator>;
typedef Arr_construction_subcurve<Mgt2, Event, Allocator> using Subcurve = Arr_construction_subcurve<Mgt2, Event, Allocator>;
Subcurve; using Helper_tmp = typename Tt::template Construction_helper<Event, Subcurve>;
typedef typename Tt::template Construction_helper<Event, Subcurve> using Helper = typename Helper_tmp::template rebind<Mgt2, Arr, Event, Subcurve>::other;
Helper_tmp; using Visitor = Gps_agg_op_visitor<Helper, Arr>;
typedef typename Helper_tmp::template rebind<Mgt2, Arr, Event, Subcurve>::other using Surface_sweep_2 = Gps_agg_op_surface_sweep_2<Arr, Visitor>;
Helper;
typedef Gps_agg_op_visitor<Helper, Arr> Visitor;
typedef Gps_agg_op_surface_sweep_2<Arr, Visitor> Surface_sweep_2;
typedef Unique_hash_map<Halfedge_handle, unsigned int> using Edges_hash = Unique_hash_map<Halfedge_handle, std::size_t>;
Edges_hash;
typedef Unique_hash_map<Face_handle, unsigned int> Faces_hash; using Faces_hash = Unique_hash_map<Face_handle, std::size_t>;
typedef Gps_bfs_scanner<Arr, Bfs_visitor> Bfs_scanner; using Bfs_scanner = Gps_bfs_scanner<Arr, Bfs_visitor>;
protected: protected:
Arr* m_arr; Arr* m_arr;
@ -103,17 +99,15 @@ public:
m_surface_sweep(m_traits, &m_visitor) m_surface_sweep(m_traits, &m_visitor)
{} {}
void sweep_arrangements(unsigned int lower, unsigned int upper, void sweep_arrangements(std::size_t lower, std::size_t upper,
unsigned int jump, std::vector<Arr_entry>& arr_vec) std::size_t jump, std::vector<Arr_entry>& arr_vec) {
{
std::list<Meta_X_monotone_curve_2> curves_list; std::list<Meta_X_monotone_curve_2> curves_list;
unsigned int n_inf_pgn = 0; // number of infinite polygons (arrangement std::size_t n_inf_pgn = 0; // number of infinite polygons (arrangement
// with a contained unbounded face // with a contained unbounded face
unsigned int n_pgn = 0; // number of polygons (arrangements) std::size_t n_pgn = 0; // number of polygons (arrangements)
unsigned int i;
for (i = lower; i <= upper; i += jump, ++n_pgn) { for (std::size_t i = lower; i <= upper; i += jump, ++n_pgn) {
// The BFS scan (after the loop) starts in the reference face, // The BFS scan (after the loop) starts in the reference face,
// so we count the number of polygons that contain the reference face. // so we count the number of polygons that contain the reference face.
Arr* arr = (arr_vec[i]).first; Arr* arr = (arr_vec[i]).first;

63
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/Gps_agg_op_surface_sweep_2.h
View File

@ -27,34 +27,34 @@ namespace Ss2 = Surface_sweep_2;
template <typename Arrangement_, typename Visitor_> template <typename Arrangement_, typename Visitor_>
class Gps_agg_op_surface_sweep_2 : public Ss2::Surface_sweep_2<Visitor_> { class Gps_agg_op_surface_sweep_2 : public Ss2::Surface_sweep_2<Visitor_> {
public: public:
typedef Arrangement_ Arrangement_2; using Arrangement_2 = Arrangement_;
typedef Visitor_ Visitor; using Visitor = Visitor_;
typedef typename Visitor::Geometry_traits_2 Geometry_traits_2; using Geometry_traits_2 = typename Visitor::Geometry_traits_2;
typedef Arrangement_2 Arr; using Arr = Arrangement_2;
typedef Geometry_traits_2 Gt2; using Gt2 = Geometry_traits_2;
typedef typename Gt2::Point_2 Point_2; using Point_2 = typename Gt2::Point_2;
typedef typename Gt2::X_monotone_curve_2 X_monotone_curve_2; using X_monotone_curve_2 = typename Gt2::X_monotone_curve_2;
typedef typename Arr::Vertex_handle Vertex_handle; using Vertex_handle = typename Arr::Vertex_handle;
typedef typename Arr::Halfedge_handle Halfedge_handle; using Halfedge_handle = typename Arr::Halfedge_handle;
typedef std::pair<Arr*, std::vector<Vertex_handle> *> Arr_entry; using Arr_entry = std::pair<Arr*, std::vector<Vertex_handle> *>;
typedef Ss2::Surface_sweep_2<Visitor> Base; using Base = Ss2::Surface_sweep_2<Visitor>;
typedef typename Visitor::Event Event; using Event = typename Visitor::Event;
typedef typename Visitor::Subcurve Subcurve; using Subcurve = typename Visitor::Subcurve;
typedef typename Base::Event_queue_iterator EventQueueIter; using EventQueueIter = typename Base::Event_queue_iterator;
typedef typename Event::Subcurve_iterator EventCurveIter; using EventCurveIter = typename Event::Subcurve_iterator;
typedef typename Event::Attribute Attribute; using Attribute = typename Event::Attribute;
typedef std::list<Subcurve*> SubCurveList; using SubCurveList = std::list<Subcurve*>;
typedef typename SubCurveList::iterator SubCurveListIter; using SubCurveListIter = typename SubCurveList::iterator;
public: public:
/*! Constructor. /*! Constructor.
@ -73,18 +73,16 @@ public:
/*! Perform the sweep. */ /*! Perform the sweep. */
template <class CurveInputIterator> template <class CurveInputIterator>
void sweep(CurveInputIterator curves_begin, CurveInputIterator curves_end, void sweep(CurveInputIterator curves_begin, CurveInputIterator curves_end,
unsigned int lower, unsigned int upper, unsigned int jump, std::size_t lower, std::size_t upper, std::size_t jump,
std::vector<Arr_entry>& arr_vec) std::vector<Arr_entry>& arr_vec) {
{
CGAL_assertion(this->m_queue->empty() && this->m_statusLine.size() == 0); CGAL_assertion(this->m_queue->empty() && this->m_statusLine.size() == 0);
typedef Unique_hash_map<Vertex_handle, Event*> Vertices_map; using Vertices_map = Unique_hash_map<Vertex_handle, Event*>;
typedef typename Gt2::Compare_xy_2 Compare_xy_2; using Compare_xy_2 = typename Gt2::Compare_xy_2;
this->m_visitor->before_sweep(); this->m_visitor->before_sweep();
// Allocate all of the Subcurve objects as one block. // Allocate all of the Subcurve objects as one block.
this->m_num_of_subCurves = this->m_num_of_subCurves = std::distance(curves_begin, curves_end);
static_cast<unsigned int>(std::distance(curves_begin, curves_end));
if (this->m_num_of_subCurves > 0) if (this->m_num_of_subCurves > 0)
this->m_subCurves = this->m_subCurves =
this->m_subCurveAlloc.allocate(this->m_num_of_subCurves); this->m_subCurveAlloc.allocate(this->m_num_of_subCurves);
@ -95,9 +93,9 @@ public:
Vertices_map vert_map; Vertices_map vert_map;
Vertex_handle vh; Vertex_handle vh;
Vertex_handle invalid_v; Vertex_handle invalid_v;
unsigned int i = lower; std::size_t i = lower;
unsigned int n = static_cast<unsigned int>((arr_vec[i].second)->size()); auto n = (arr_vec[i].second)->size();
unsigned int j; std::size_t j;
EventQueueIter q_iter; EventQueueIter q_iter;
bool first = true; bool first = true;
Attribute event_type; Attribute event_type;
@ -135,7 +133,7 @@ public:
for (i += jump; i <= upper; i += jump) { for (i += jump; i <= upper; i += jump) {
// Merge the vertices of the other vectors into the existing queue. // Merge the vertices of the other vectors into the existing queue.
q_iter = this->m_queue->begin(); q_iter = this->m_queue->begin();
n = static_cast<unsigned int>((arr_vec[i].second)->size()); n = (arr_vec[i].second)->size();
for (j = 0; j < n && (vh = (*(arr_vec[i].second))[j]) != invalid_v; j++) { for (j = 0; j < n && (vh = (*(arr_vec[i].second))[j]) != invalid_v; j++) {
event_type = _type_of_vertex(vh); event_type = _type_of_vertex(vh);
@ -170,7 +168,7 @@ public:
// Go over all curves (which are associated with halfedges) and associate // Go over all curves (which are associated with halfedges) and associate
// them with the events we have just created. // them with the events we have just created.
unsigned int index = 0; std::size_t index = 0;
CurveInputIterator iter; CurveInputIterator iter;
Halfedge_handle he; Halfedge_handle he;
Event* e_left; Event* e_left;
@ -194,7 +192,7 @@ public:
} }
// Create the subcurve object. // Create the subcurve object.
typedef decltype(this->m_subCurveAlloc) Subcurve_alloc; using Subcurve_alloc = decltype(this->m_subCurveAlloc);
std::allocator_traits<Subcurve_alloc>::construct(this->m_subCurveAlloc, this->m_subCurves + index, std::allocator_traits<Subcurve_alloc>::construct(this->m_subCurveAlloc, this->m_subCurves + index,
this->m_masterSubcurve); this->m_masterSubcurve);
(this->m_subCurves + index)->init(*iter); (this->m_subCurves + index)->init(*iter);
@ -218,8 +216,7 @@ private:
* Check if the given vertex is an endpoint of an edge we are going * Check if the given vertex is an endpoint of an edge we are going
* to use in the sweep. * to use in the sweep.
*/ */
Attribute _type_of_vertex(Vertex_handle v) Attribute _type_of_vertex(Vertex_handle v) {
{
typename Arr::Halfedge_around_vertex_circulator first, circ; typename Arr::Halfedge_around_vertex_circulator first, circ;
circ = first = v->incident_halfedges(); circ = first = v->incident_halfedges();

80
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/Gps_agg_op_visitor.h
View File

@ -34,30 +34,28 @@ class Gps_agg_op_base_visitor :
Visitor_> >::type> Visitor_> >::type>
{ {
public: public:
typedef Helper_ Helper; using Helper = Helper_;
typedef Arrangement_ Arrangement_2; using Arrangement_2 = Arrangement_;
typedef typename Helper::Geometry_traits_2 Geometry_traits_2; using Geometry_traits_2 = typename Helper::Geometry_traits_2;
typedef typename Helper::Event Event; using Event = typename Helper::Event;
typedef typename Helper::Subcurve Subcurve; using Subcurve = typename Helper::Subcurve;
private: private:
typedef Geometry_traits_2 Gt2; using Gt2 = Geometry_traits_2;
typedef Arrangement_2 Arr; using Arr = Arrangement_2;
typedef Gps_agg_op_base_visitor<Helper, Arr, Visitor_> using Self = Gps_agg_op_base_visitor<Helper, Arr, Visitor_>;
Self; using Visitor = typename Default::Get<Visitor_, Self>::type;
typedef typename Default::Get<Visitor_, Self>::type Visitor; using Base = Arr_construction_ss_visitor<Helper, Visitor>;
typedef Arr_construction_ss_visitor<Helper, Visitor> Base;
public: public:
typedef typename Arr::Halfedge_handle Halfedge_handle; using Halfedge_handle = typename Arr::Halfedge_handle;
typedef typename Arr::Vertex_handle Vertex_handle; using Vertex_handle = typename Arr::Vertex_handle;
typedef typename Gt2::X_monotone_curve_2 X_monotone_curve_2; using X_monotone_curve_2 = typename Gt2::X_monotone_curve_2;
typedef typename Gt2::Point_2 Point_2; using Point_2 = typename Gt2::Point_2;
typedef Unique_hash_map<Halfedge_handle, unsigned int> using Edges_hash = Unique_hash_map<Halfedge_handle, std::size_t>;
Edges_hash;
protected: protected:
Edges_hash* m_edges_hash; // maps halfedges to their BC (coundary counter) Edges_hash* m_edges_hash; // maps halfedges to their BC (coundary counter)
@ -138,29 +136,29 @@ class Gps_agg_op_visitor :
Visitor_> > Visitor_> >
{ {
public: public:
typedef Helper_ Helper; using Helper = Helper_;
typedef Arrangement_ Arrangement_2; using Arrangement_2 = Arrangement_;
typedef typename Helper::Geometry_traits_2 Geometry_traits_2; using Geometry_traits_2 = typename Helper::Geometry_traits_2;
typedef typename Helper::Event Event; using Event = typename Helper::Event;
typedef typename Helper::Subcurve Subcurve; using Subcurve = typename Helper::Subcurve;
private: private:
typedef Geometry_traits_2 Gt2; using Gt2 = Geometry_traits_2;
typedef Arrangement_2 Arr; using Arr = Arrangement_2;
typedef Gps_agg_op_visitor<Helper, Arr, Visitor_> Self; using Self = Gps_agg_op_visitor<Helper, Arr, Visitor_>;
typedef typename Default::Get<Visitor_, Self>::type Visitor; using Visitor = typename Default::Get<Visitor_, Self>::type;
typedef Gps_agg_op_base_visitor<Helper, Arr, Visitor> Base; using Base = Gps_agg_op_base_visitor<Helper, Arr, Visitor>;
public: public:
typedef typename Base::Halfedge_handle Halfedge_handle; using Halfedge_handle = typename Base::Halfedge_handle;
typedef typename Base::Vertex_handle Vertex_handle; using Vertex_handle = typename Base::Vertex_handle;
typedef typename Gt2::X_monotone_curve_2 X_monotone_curve_2; using X_monotone_curve_2 = typename Gt2::X_monotone_curve_2;
typedef typename Gt2::Point_2 Point_2; using Point_2 = typename Gt2::Point_2;
protected: protected:
unsigned int m_event_count; // The number of events so far. std::size_t m_event_count; // The number of events so far.
std::vector<Vertex_handle>* m_vertices_vec; // The vertices, sorted in std::vector<Vertex_handle>* m_vertices_vec; // The vertices, sorted in
// ascending order. // ascending order.
@ -172,15 +170,13 @@ public:
m_vertices_vec(vertices_vec) m_vertices_vec(vertices_vec)
{} {}
void before_handle_event(Event* event) void before_handle_event(Event* event) {
{
event->set_index(m_event_count); event->set_index(m_event_count);
m_event_count++; m_event_count++;
} }
virtual Halfedge_handle virtual Halfedge_handle
insert_in_face_interior(const X_monotone_curve_2& cv, Subcurve* sc) insert_in_face_interior(const X_monotone_curve_2& cv, Subcurve* sc) {
{
Halfedge_handle res_he = Base::insert_in_face_interior(cv, sc); Halfedge_handle res_he = Base::insert_in_face_interior(cv, sc);
// We now have a halfedge whose source vertex is associated with the // We now have a halfedge whose source vertex is associated with the
@ -198,8 +194,7 @@ public:
virtual Halfedge_handle insert_from_right_vertex(const X_monotone_curve_2& cv, virtual Halfedge_handle insert_from_right_vertex(const X_monotone_curve_2& cv,
Halfedge_handle he, Halfedge_handle he,
Subcurve* sc) Subcurve* sc) {
{
Halfedge_handle res_he = Base::insert_from_right_vertex(cv, he, sc); Halfedge_handle res_he = Base::insert_from_right_vertex(cv, he, sc);
// We now have a halfedge whose target vertex is associated with the // We now have a halfedge whose target vertex is associated with the
@ -213,8 +208,7 @@ public:
virtual Halfedge_handle insert_from_left_vertex(const X_monotone_curve_2& cv, virtual Halfedge_handle insert_from_left_vertex(const X_monotone_curve_2& cv,
Halfedge_handle he, Halfedge_handle he,
Subcurve* sc) Subcurve* sc) {
{
Halfedge_handle res_he = Base::insert_from_left_vertex(cv, he, sc); Halfedge_handle res_he = Base::insert_from_left_vertex(cv, he, sc);
// We now have a halfedge whose target vertex is associated with the // We now have a halfedge whose target vertex is associated with the
@ -228,13 +222,11 @@ public:
} }
private: private:
void _insert_vertex(const Event* event, Vertex_handle v) void _insert_vertex(const Event* event, Vertex_handle v) {
{ const auto index = event->index();
const unsigned int index = event->index();
if (index >= m_vertices_vec->size()) m_vertices_vec->resize(2 * (index + 1)); if (index >= m_vertices_vec->size()) m_vertices_vec->resize(2 * (index + 1));
(*m_vertices_vec)[index] = v; (*m_vertices_vec)[index] = v;
} }
}; };
} // namespace CGAL } // namespace CGAL

54
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/Gps_bfs_base_visitor.h
View File

@ -16,82 +16,76 @@
#include <CGAL/license/Boolean_set_operations_2.h> #include <CGAL/license/Boolean_set_operations_2.h>
#include <CGAL/Unique_hash_map.h> #include <CGAL/Unique_hash_map.h>
namespace CGAL { namespace CGAL {
//! Gps_bfs_base_visitor //! Gps_bfs_base_visitor
/*! This is a base class for all visitors that are responsible for merging /*! This is a base class for all visitors that are responsible for merging
polygon sets. * polygon sets.
We use DerivedVisitor for static polymorphism for using contained_criteria * We use DerivedVisitor for static polymorphism for using contained_criteria
which determines if we should mark the face as contained given the inside * which determines if we should mark the face as contained given the inside
count of the face. * count of the face.
*/ */
template <class Arrangement_, class DerivedVisitor> template <class Arrangement_, class DerivedVisitor>
class Gps_bfs_base_visitor class Gps_bfs_base_visitor {
{ using Arrangement = Arrangement_;
typedef Arrangement_ Arrangement; using Face_iterator = typename Arrangement::Face_iterator;
typedef typename Arrangement::Face_iterator Face_iterator; using Halfedge_iterator = typename Arrangement::Halfedge_iterator;
typedef typename Arrangement::Halfedge_iterator Halfedge_iterator;
public: public:
typedef Unique_hash_map<Halfedge_iterator, unsigned int> Edges_hash; using Edges_hash = Unique_hash_map<Halfedge_iterator, std::size_t>;
typedef Unique_hash_map<Face_iterator, unsigned int> Faces_hash; using Faces_hash = Unique_hash_map<Face_iterator, std::size_t>;
protected: protected:
Edges_hash* m_edges_hash; Edges_hash* m_edges_hash;
Faces_hash* m_faces_hash; Faces_hash* m_faces_hash;
unsigned int m_num_of_polygons; // number of polygons std::size_t m_num_of_polygons; // number of polygons
public: public:
Gps_bfs_base_visitor(Edges_hash* edges_hash, Gps_bfs_base_visitor(Edges_hash* edges_hash,
Faces_hash* faces_hash, Faces_hash* faces_hash,
unsigned int n_pgn): std::size_t n_pgn):
m_edges_hash(edges_hash), m_edges_hash(edges_hash),
m_faces_hash(faces_hash), m_faces_hash(faces_hash),
m_num_of_polygons(n_pgn) m_num_of_polygons(n_pgn)
{} {}
//! discovered_face //! discovered_face
/*! discovered_face is called by Gps_bfs_scanner when it reveals a new face /*! discovered_face is called by Gps_bfs_scanner when it reveals a new face
during a BFS scan. In the BFS traversal we are going from old_face to * during a BFS scan. In the BFS traversal we are going from old_face to
new_face through the half-edge he. * new_face through the half-edge he.
\param old_face The face that was already revealed * \param old_face The face that was already revealed
\param new_face The face that we have just now revealed * \param new_face The face that we have just now revealed
\param he The half-edge that is used to traverse between them. * \param he The half-edge that is used to traverse between them.
*/ */
void discovered_face(Face_iterator old_face, void discovered_face(Face_iterator old_face,
Face_iterator new_face, Face_iterator new_face,
Halfedge_iterator he) Halfedge_iterator he) {
{ std::size_t ic = compute_ic(old_face, new_face, he);
unsigned int ic = compute_ic(old_face, new_face, he);
if (static_cast<DerivedVisitor*>(this)->contained_criteria(ic)) if (static_cast<DerivedVisitor*>(this)->contained_criteria(ic))
new_face->set_contained(true); new_face->set_contained(true);
} }
// mark the unbounded_face (true iff contained) // mark the unbounded_face (true iff contained)
void visit_ubf(Face_iterator ubf, unsigned int ubf_ic) void visit_ubf(Face_iterator ubf, std::size_t ubf_ic) {
{
CGAL_assertion(ubf->is_unbounded()); CGAL_assertion(ubf->is_unbounded());
if (static_cast<DerivedVisitor*>(this)->contained_criteria(ubf_ic)) if (static_cast<DerivedVisitor*>(this)->contained_criteria(ubf_ic))
ubf->set_contained(true); ubf->set_contained(true);
} }
protected: protected:
// compute the inside count of a face // compute the inside count of a face
unsigned int compute_ic(Face_iterator f1, std::size_t compute_ic(Face_iterator f1,
Face_iterator f2, Face_iterator f2,
Halfedge_iterator he) Halfedge_iterator he) {
{
CGAL_assertion(m_edges_hash->is_defined(he) && CGAL_assertion(m_edges_hash->is_defined(he) &&
m_edges_hash->is_defined(he->twin()) && m_edges_hash->is_defined(he->twin()) &&
m_faces_hash->is_defined(f1) && m_faces_hash->is_defined(f1) &&
!m_faces_hash->is_defined(f2)); !m_faces_hash->is_defined(f2));
unsigned int ic_f2 = std::size_t ic_f2 =
(*m_faces_hash)[f1] - (*m_edges_hash)[he] + (*m_edges_hash)[he->twin()]; (*m_faces_hash)[f1] - (*m_edges_hash)[he] + (*m_edges_hash)[he->twin()];
(*m_faces_hash)[f2] = ic_f2; (*m_faces_hash)[f2] = ic_f2;

36
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/Gps_bfs_intersection_visitor.h
View File

@ -12,54 +12,46 @@
// Author(s): Baruch Zukerman <baruchzu@post.tau.ac.il> // Author(s): Baruch Zukerman <baruchzu@post.tau.ac.il>
// Ophir Setter <ophir.setter@cs.tau.ac.il> // Ophir Setter <ophir.setter@cs.tau.ac.il>
#ifndef CGAL_GPS_BFS_INTERSECTION_VISITOR_H #ifndef CGAL_GPS_BFS_INTERSECTION_VISITOR_H
#define CGAL_GPS_BFS_INTERSECTION_VISITOR_H #define CGAL_GPS_BFS_INTERSECTION_VISITOR_H
#include <CGAL/license/Boolean_set_operations_2.h> #include <CGAL/license/Boolean_set_operations_2.h>
#include <CGAL/Boolean_set_operations_2/Gps_bfs_base_visitor.h> #include <CGAL/Boolean_set_operations_2/Gps_bfs_base_visitor.h>
namespace CGAL { namespace CGAL {
template <class Arrangement_> template <class Arrangement_>
class Gps_bfs_intersection_visitor : class Gps_bfs_intersection_visitor :
public Gps_bfs_base_visitor<Arrangement_, Gps_bfs_intersection_visitor<Arrangement_> > public Gps_bfs_base_visitor<Arrangement_, Gps_bfs_intersection_visitor<Arrangement_>> {
{ using Arrangement = Arrangement_;
typedef Arrangement_ Arrangement; using Face_iterator = typename Arrangement::Face_iterator;
typedef typename Arrangement::Face_iterator Face_iterator; using Halfedge_iterator = typename Arrangement::Halfedge_iterator;
typedef typename Arrangement::Halfedge_iterator Halfedge_iterator; using Self = Gps_bfs_intersection_visitor<Arrangement>;
typedef Gps_bfs_intersection_visitor<Arrangement> Self; using Base = Gps_bfs_base_visitor<Arrangement, Self>;
typedef Gps_bfs_base_visitor<Arrangement, Self> Base; using Edges_hash = typename Base::Edges_hash;
typedef typename Base::Edges_hash Edges_hash; using Faces_hash = typename Base::Faces_hash;
typedef typename Base::Faces_hash Faces_hash;
public: public:
Gps_bfs_intersection_visitor(Edges_hash* edges_hash, Gps_bfs_intersection_visitor(Edges_hash* edges_hash,
Faces_hash* faces_hash, Faces_hash* faces_hash,
unsigned int n_polygons): std::size_t n_polygons):
Base(edges_hash, faces_hash, n_polygons) Base(edges_hash, faces_hash, n_polygons)
{} {}
//! contained_criteria //! contained_criteria
/*! contained_criteria is used to the determine if the face which has /*! contained_criteria is used to the determine if the face which has
inside count should be marked as contained. * inside count should be marked as contained.
\param ic the inner count of the talked-about face. * \param ic the inner count of the talked-about face.
\return true if the face of ic, otherwise false. * \return true if the face of ic, otherwise false.
*/ */
bool contained_criteria(unsigned int ic) bool contained_criteria(std::size_t ic) {
{
// intersection means that all polygons contain the face. // intersection means that all polygons contain the face.
CGAL_assertion(ic <= this->m_num_of_polygons); CGAL_assertion(ic <= this->m_num_of_polygons);
return (ic == this->m_num_of_polygons); return (ic == this->m_num_of_polygons);
} }
void after_scan(Arrangement&) void after_scan(Arrangement&) {}
{}
}; };
} //namespace CGAL } //namespace CGAL

36
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/Gps_bfs_join_visitor.h
View File

@ -16,44 +16,38 @@
#include <CGAL/license/Boolean_set_operations_2.h> #include <CGAL/license/Boolean_set_operations_2.h>
#include <CGAL/Boolean_set_operations_2/Gps_bfs_base_visitor.h> #include <CGAL/Boolean_set_operations_2/Gps_bfs_base_visitor.h>
namespace CGAL { namespace CGAL {
template <class Arrangement_> template <typename Arrangement_>
class Gps_bfs_join_visitor : class Gps_bfs_join_visitor :
public Gps_bfs_base_visitor<Arrangement_, Gps_bfs_join_visitor<Arrangement_> > public Gps_bfs_base_visitor<Arrangement_, Gps_bfs_join_visitor<Arrangement_>> {
{ using Arrangement = Arrangement_;
typedef Arrangement_ Arrangement; using Face_iterator = typename Arrangement::Face_iterator;
typedef typename Arrangement::Face_iterator Face_iterator; using Halfedge_iterator = typename Arrangement::Halfedge_iterator;
typedef typename Arrangement::Halfedge_iterator Halfedge_iterator; using Self = Gps_bfs_join_visitor<Arrangement>;
typedef Gps_bfs_join_visitor<Arrangement> Self; using Base = Gps_bfs_base_visitor<Arrangement, Self>;
typedef Gps_bfs_base_visitor<Arrangement, Self> Base; using Edges_hash = typename Base::Edges_hash;
typedef typename Base::Edges_hash Edges_hash; using Faces_hash = typename Base::Faces_hash;
typedef typename Base::Faces_hash Faces_hash;
public: public:
Gps_bfs_join_visitor(Edges_hash* edges_hash, Faces_hash* faces_hash, std::size_t n_pgn):
Gps_bfs_join_visitor(Edges_hash* edges_hash, Faces_hash* faces_hash, unsigned int n_pgn):
Base(edges_hash, faces_hash, n_pgn) Base(edges_hash, faces_hash, n_pgn)
{} {}
//! contained_criteria //! contained_criteria
/*! contained_criteria is used to the determine if the face which has /*! contained_criteria is used to the determine if the face which has
inside count should be marked as contained. * inside count should be marked as contained.
\param ic the inner count of the talked-about face. * \param ic the inner count of the talked-about face.
\return true if the face of ic, otherwise false. * \return true if the face of ic, otherwise false.
*/ */
bool contained_criteria(unsigned int ic) bool contained_criteria(std::size_t ic) {
{
// at least one polygon contains the face. // at least one polygon contains the face.
return (ic > 0); return (ic > 0);
} }
void after_scan(Arrangement&) void after_scan(Arrangement&) {}
{}
}; };
} //namespace CGAL } //namespace CGAL

32
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/Gps_bfs_xor_visitor.h
View File

@ -23,20 +23,18 @@ namespace CGAL {
template <class Arrangement_> template <class Arrangement_>
class Gps_bfs_xor_visitor : class Gps_bfs_xor_visitor :
public Gps_bfs_base_visitor<Arrangement_, Gps_bfs_xor_visitor<Arrangement_> > public Gps_bfs_base_visitor<Arrangement_, Gps_bfs_xor_visitor<Arrangement_>> {
{ using Arrangement = Arrangement_;
typedef Arrangement_ Arrangement; using Face_iterator = typename Arrangement::Face_iterator;
typedef typename Arrangement::Face_iterator Face_iterator; using Halfedge_iterator = typename Arrangement::Halfedge_iterator;
typedef typename Arrangement::Halfedge_iterator Halfedge_iterator; using Self = Gps_bfs_xor_visitor<Arrangement>;
typedef Gps_bfs_xor_visitor<Arrangement> Self; using Base = Gps_bfs_base_visitor<Arrangement, Self>;
typedef Gps_bfs_base_visitor<Arrangement, Self> Base; using Edges_hash = typename Base::Edges_hash;
typedef typename Base::Edges_hash Edges_hash; using Faces_hash = typename Base::Faces_hash;
typedef typename Base::Faces_hash Faces_hash;
public: public:
Gps_bfs_xor_visitor(Edges_hash* edges_hash, Faces_hash* faces_hash, Gps_bfs_xor_visitor(Edges_hash* edges_hash, Faces_hash* faces_hash,
unsigned int n_pgn) : std::size_t n_pgn) :
Base(edges_hash, faces_hash, n_pgn) Base(edges_hash, faces_hash, n_pgn)
{} {}
@ -46,8 +44,7 @@ public:
\param ic the inner count of the talked-about face. \param ic the inner count of the talked-about face.
\return true if the face of ic, otherwise false. \return true if the face of ic, otherwise false.
*/ */
bool contained_criteria(unsigned int ic) bool contained_criteria(std::size_t ic) {
{
// xor means odd number of polygons. // xor means odd number of polygons.
return (ic % 2) == 1; return (ic % 2) == 1;
} }
@ -58,8 +55,7 @@ public:
\param arr The given arrangement. \param arr The given arrangement.
*/ */
void after_scan(Arrangement& arr) void after_scan(Arrangement& arr) {
{
typedef typename Arrangement::Geometry_traits_2 Traits; typedef typename Arrangement::Geometry_traits_2 Traits;
typedef typename Traits::Compare_endpoints_xy_2 Compare_endpoints_xy_2; typedef typename Traits::Compare_endpoints_xy_2 Compare_endpoints_xy_2;
typedef typename Traits::Construct_opposite_2 Construct_opposite_2; typedef typename Traits::Construct_opposite_2 Construct_opposite_2;
@ -71,10 +67,7 @@ public:
tr.compare_endpoints_xy_2_object(); tr.compare_endpoints_xy_2_object();
Construct_opposite_2 ctr_opp = tr.construct_opposite_2_object(); Construct_opposite_2 ctr_opp = tr.construct_opposite_2_object();
for(Edge_iterator eit = arr.edges_begin(); for (auto eit = arr.edges_begin(); eit != arr.edges_end(); ++eit) {
eit != arr.edges_end();
++eit)
{
Halfedge_iterator he = eit; Halfedge_iterator he = eit;
const X_monotone_curve_2& cv = he->curve(); const X_monotone_curve_2& cv = he->curve();
const bool is_cont = he->face()->contained(); const bool is_cont = he->face()->contained();
@ -87,7 +80,6 @@ public:
arr.modify_edge(he, ctr_opp(cv)); arr.modify_edge(he, ctr_opp(cv));
} }
} }
}; };
} //namespace CGAL } //namespace CGAL

67
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/Gps_merge.h
View File

@ -14,7 +14,6 @@
#include <CGAL/license/Boolean_set_operations_2.h> #include <CGAL/license/Boolean_set_operations_2.h>
#include <CGAL/Boolean_set_operations_2/Gps_agg_op.h> #include <CGAL/Boolean_set_operations_2/Gps_agg_op.h>
#include <CGAL/Boolean_set_operations_2/Gps_bfs_join_visitor.h> #include <CGAL/Boolean_set_operations_2/Gps_bfs_join_visitor.h>
#include <CGAL/Boolean_set_operations_2/Gps_bfs_xor_visitor.h> #include <CGAL/Boolean_set_operations_2/Gps_bfs_xor_visitor.h>
@ -23,38 +22,31 @@
namespace CGAL { namespace CGAL {
/*! /*! \file Gps_merge.h
\file Gps_merge.h * \brief This file contains classes that are responsible for merging
\brief This file contains classes that are responsible for merging * two sets of polygons in the divide-and-conquer algorithm.
two sets of polygons in the divide-and-conquer algorithm. * The file contains 3 mergers: Join_merge, Intersection_merge and
The file contains 3 mergers: Join_merge, Intersection_merge and * Xor_merge. Join_merge is used when we want to merge the two sets,
Xor_merge. Join_merge is used when we want to merge the two sets, * Intersection_merge is used for intersection, and Xor_merge is used
Intersection_merge is used for intersection, and Xor_merge is used * for symmetric difference.
for symmetric difference.
*/ */
//! Base_merge //! Base_merge
/*! Base_merge is the base class for all merger classes. /*! Base_merge is the base class for all merger classes.
All merges used BFS algorithm with a different visitor when discovering * All merges used BFS algorithm with a different visitor when discovering
a new face. * a new face.
*/ */
template <class Arrangement_, class Visitor_> template <typename Arrangement_, typename Visitor_>
class Base_merge class Base_merge {
{ using Arrangement_2 = Arrangement_;
typedef Arrangement_ Arrangement_2; using Visitor = Visitor_;
typedef Visitor_ Visitor; using Vertex_handle = typename Arrangement_2::Vertex_handle;
typedef typename Arrangement_2::Vertex_handle Vertex_handle; using Arr_entry = std::pair<Arrangement_2*, std::vector<Vertex_handle>*>;
typedef std::pair<Arrangement_2 *,
std::vector<Vertex_handle> *> Arr_entry;
public: public:
void operator()(unsigned int i, void operator()(std::size_t i, std::size_t j, std::size_t jump,
unsigned int j, std::vector<Arr_entry>& arr_vec) {
unsigned int jump, if (i == j) return;
std::vector<Arr_entry>& arr_vec)
{
if(i==j)
return;
const typename Arrangement_2::Geometry_traits_2* tr = const typename Arrangement_2::Geometry_traits_2* tr =
arr_vec[i].first->geometry_traits(); arr_vec[i].first->geometry_traits();
@ -65,8 +57,7 @@ public:
agg_op(*res, *verts, *(res->traits_adaptor())); agg_op(*res, *verts, *(res->traits_adaptor()));
agg_op.sweep_arrangements(i, j, jump, arr_vec); agg_op.sweep_arrangements(i, j, jump, arr_vec);
for(unsigned int count=i; count<=j; count+=jump) for (std::size_t count = i; count <= j; count += jump) {
{
delete (arr_vec[count].first); delete (arr_vec[count].first);
delete (arr_vec[count].second); delete (arr_vec[count].second);
} }
@ -74,37 +65,31 @@ public:
arr_vec[i].first = res; arr_vec[i].first = res;
arr_vec[i].second = verts; arr_vec[i].second = verts;
} }
}; };
//! Join_merge //! Join_merge
/*! Join_merge is used to join two sets of polygons together in the D&C /*! Join_merge is used to join two sets of polygons together in the D&C
algorithm. It is a base merge with a visitor that joins faces. * algorithm. It is a base merge with a visitor that joins faces.
*/ */
template <class Arrangement_> template <class Arrangement_>
class Join_merge : public Base_merge<Arrangement_, class Join_merge : public Base_merge<Arrangement_, Gps_bfs_join_visitor<Arrangement_>>
Gps_bfs_join_visitor<Arrangement_> >
{}; {};
//! Intersection_merge //! Intersection_merge
/*! Intersection_merge is used to merge two sets of polygons creating their /*! Intersection_merge is used to merge two sets of polygons creating their
intersection. * intersection.
*/ */
template <class Arrangement_> template <class Arrangement_>
class Intersection_merge : public Base_merge<Arrangement_, class Intersection_merge : public Base_merge<Arrangement_, Gps_bfs_intersection_visitor<Arrangement_>>
Gps_bfs_intersection_visitor<Arrangement_> >
{}; {};
//! Xor_merge //! Xor_merge
/*! Xor_merge is used to merge two sets of polygons creating their /*! Xor_merge is used to merge two sets of polygons creating their
symmetric difference. * symmetric difference.
*/ */
template <class Arrangement_> template <class Arrangement_>
class Xor_merge : public Base_merge<Arrangement_, class Xor_merge : public Base_merge<Arrangement_, Gps_bfs_xor_visitor<Arrangement_>>
Gps_bfs_xor_visitor<Arrangement_> > {};
{
};
} //namespace CGAL } //namespace CGAL

192
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/Gps_on_surface_base_2.h
View File

@ -131,7 +131,7 @@ protected:
Aos_2* m_arr; Aos_2* m_arr;
public: public:
// default constructor // constructs default
Gps_on_surface_base_2() : Gps_on_surface_base_2() :
m_traits(new Traits_2()), m_traits(new Traits_2()),
m_traits_adaptor(*m_traits), m_traits_adaptor(*m_traits),
@ -140,7 +140,7 @@ public:
{} {}
// constructor with traits object // constructs with traits object
Gps_on_surface_base_2(const Traits_2& tr) : Gps_on_surface_base_2(const Traits_2& tr) :
m_traits(&tr), m_traits(&tr),
m_traits_adaptor(*m_traits), m_traits_adaptor(*m_traits),
@ -148,7 +148,7 @@ public:
m_arr(new Aos_2(m_traits)) m_arr(new Aos_2(m_traits))
{} {}
// Copy constructor // copy constructs
Gps_on_surface_base_2(const Self& ps) : Gps_on_surface_base_2(const Self& ps) :
m_traits(new Traits_2(*(ps.m_traits))), m_traits(new Traits_2(*(ps.m_traits))),
m_traits_adaptor(*m_traits), m_traits_adaptor(*m_traits),
@ -156,7 +156,7 @@ public:
m_arr(new Aos_2(*(ps.m_arr))) m_arr(new Aos_2(*(ps.m_arr)))
{} {}
// Assignment operator // assigns
Gps_on_surface_base_2& operator=(const Self& ps) { Gps_on_surface_base_2& operator=(const Self& ps) {
if (this == &ps) return (*this); if (this == &ps) return (*this);
@ -169,7 +169,7 @@ public:
return (*this); return (*this);
} }
// Constructor // constructs
explicit Gps_on_surface_base_2(const Polygon_2& pgn) : explicit Gps_on_surface_base_2(const Polygon_2& pgn) :
m_traits(new Traits_2()), m_traits(new Traits_2()),
m_traits_adaptor(*m_traits), m_traits_adaptor(*m_traits),
@ -179,7 +179,7 @@ public:
_insert(pgn, *m_arr); _insert(pgn, *m_arr);
} }
// Constructor // constructs
explicit Gps_on_surface_base_2(const Polygon_2& pgn, const Traits_2& tr) : explicit Gps_on_surface_base_2(const Polygon_2& pgn, const Traits_2& tr) :
m_traits(&tr), m_traits(&tr),
m_traits_adaptor(*m_traits), m_traits_adaptor(*m_traits),
@ -189,7 +189,7 @@ public:
_insert(pgn, *m_arr); _insert(pgn, *m_arr);
} }
// Constructor // constructs
explicit Gps_on_surface_base_2(const Polygon_with_holes_2& pgn_with_holes) : explicit Gps_on_surface_base_2(const Polygon_with_holes_2& pgn_with_holes) :
m_traits(new Traits_2()), m_traits(new Traits_2()),
m_traits_adaptor(*m_traits), m_traits_adaptor(*m_traits),
@ -199,7 +199,7 @@ public:
_insert(pgn_with_holes, *m_arr); _insert(pgn_with_holes, *m_arr);
} }
// Constructor // constructs
explicit Gps_on_surface_base_2(const Polygon_with_holes_2& pgn_with_holes, explicit Gps_on_surface_base_2(const Polygon_with_holes_2& pgn_with_holes,
const Traits_2& tr) : const Traits_2& tr) :
m_traits(&tr), m_traits(&tr),
@ -211,14 +211,15 @@ public:
} }
protected: protected:
Gps_on_surface_base_2(Aos_2* arr) : m_traits(new Traits_2()), Gps_on_surface_base_2(Aos_2* arr) :
m_traits(new Traits_2()),
m_traits_adaptor(*m_traits), m_traits_adaptor(*m_traits),
m_traits_owner(true), m_traits_owner(true),
m_arr(arr) m_arr(arr)
{} {}
public: public:
//destructor // destructs
virtual ~Gps_on_surface_base_2() { virtual ~Gps_on_surface_base_2() {
delete m_arr; delete m_arr;
@ -241,25 +242,25 @@ public:
gps.polygons_with_holes(oi); gps.polygons_with_holes(oi);
} }
// insert a simple polygon // inserts a simple polygon
void insert(const Polygon_2& pgn) { void insert(const Polygon_2& pgn) {
ValidationPolicy::is_valid(pgn, *m_traits); ValidationPolicy::is_valid(pgn, *m_traits);
_insert(pgn, *m_arr); _insert(pgn, *m_arr);
} }
// insert a polygon with holes // inserts a polygon with holes
void insert(const Polygon_with_holes_2& pgn_with_holes) { void insert(const Polygon_with_holes_2& pgn_with_holes) {
ValidationPolicy::is_valid(pgn_with_holes, *m_traits); ValidationPolicy::is_valid(pgn_with_holes, *m_traits);
_insert(pgn_with_holes, *m_arr); _insert(pgn_with_holes, *m_arr);
} }
// insert a range of polygons that can be either simple polygons // inserts a range of polygons that can be either simple polygons
// or polygons with holes // or polygons with holes
// precondition: the polygons are disjoint and simple // precondition: the polygons are disjoint and simple
template <typename PolygonIterator> template <typename PolygonIterator>
void insert(PolygonIterator pgn_begin, PolygonIterator pgn_end); void insert(PolygonIterator pgn_begin, PolygonIterator pgn_end);
// insert two ranges of : the first one for simple polygons, // inserts two ranges of : the first one for simple polygons,
// the second one for polygons with holes // the second one for polygons with holes
// precondition: the first range is disjoint simple polygons // precondition: the first range is disjoint simple polygons
// the second range is disjoint polygons with holes // the second range is disjoint polygons with holes
@ -268,21 +269,21 @@ public:
PolygonWithHolesIterator pgn_with_holes_begin, PolygonWithHolesIterator pgn_with_holes_begin,
PolygonWithHolesIterator pgn_with_holes_end); PolygonWithHolesIterator pgn_with_holes_end);
// test for intersection with a simple polygon // tests for intersection with a simple polygon
bool do_intersect(const Polygon_2& pgn) const { bool do_intersect(const Polygon_2& pgn) const {
ValidationPolicy::is_valid(pgn, *m_traits); ValidationPolicy::is_valid(pgn, *m_traits);
Self other(pgn, *m_traits); Self other(pgn, *m_traits);
return do_intersect(other); return do_intersect(other);
} }
// test for intersection with a polygon with holes // tests for intersection with a polygon with holes
bool do_intersect(const Polygon_with_holes_2& pgn_with_holes) const { bool do_intersect(const Polygon_with_holes_2& pgn_with_holes) const {
ValidationPolicy::is_valid(pgn_with_holes, *m_traits); ValidationPolicy::is_valid(pgn_with_holes, *m_traits);
Self other(pgn_with_holes, *m_traits); Self other(pgn_with_holes, *m_traits);
return do_intersect(other); return do_intersect(other);
} }
//test for intersection with another Gps_on_surface_base_2 object // tests for intersection with another Gps_on_surface_base_2 object
bool do_intersect(const Self& other) const { bool do_intersect(const Self& other) const {
if (this->is_empty() || other.is_empty()) return false; if (this->is_empty() || other.is_empty()) return false;
if (this->is_plane() || other.is_plane()) return true; if (this->is_plane() || other.is_plane()) return true;
@ -292,19 +293,19 @@ public:
return func.found_reg_intersection(); return func.found_reg_intersection();
} }
// intersection with a simple polygon // intersects with a simple polygon
void intersection(const Polygon_2& pgn) { void intersection(const Polygon_2& pgn) {
ValidationPolicy::is_valid(pgn, *m_traits); ValidationPolicy::is_valid(pgn, *m_traits);
_intersection(pgn); _intersection(pgn);
} }
// intersection with a polygon with holes // intersects with a polygon with holes
void intersection(const Polygon_with_holes_2& pgn) { void intersection(const Polygon_with_holes_2& pgn) {
ValidationPolicy::is_valid(pgn, *m_traits); ValidationPolicy::is_valid(pgn, *m_traits);
_intersection(pgn); _intersection(pgn);
} }
// intersection with another Gps_on_surface_base_2 object // intersects with another Gps_on_surface_base_2 object
void intersection(const Self& other) { _intersection(other); } void intersection(const Self& other) { _intersection(other); }
void intersection(const Self& gps1, const Self& gps2) { void intersection(const Self& gps1, const Self& gps2) {
@ -312,19 +313,19 @@ public:
_intersection(*(gps1.m_arr), *(gps2.m_arr), *(this->m_arr)); _intersection(*(gps1.m_arr), *(gps2.m_arr), *(this->m_arr));
} }
// join with a simple polygon // joins with a simple polygon
void join(const Polygon_2& pgn) { void join(const Polygon_2& pgn) {
ValidationPolicy::is_valid(pgn, *m_traits); ValidationPolicy::is_valid(pgn, *m_traits);
_join(pgn); _join(pgn);
} }
// join with a polygon with holes // joins with a polygon with holes
void join(const Polygon_with_holes_2& pgn) { void join(const Polygon_with_holes_2& pgn) {
ValidationPolicy::is_valid(pgn, *m_traits); ValidationPolicy::is_valid(pgn, *m_traits);
_join(pgn); _join(pgn);
} }
//join with another Gps_on_surface_base_2 object // joins with another Gps_on_surface_base_2 object
void join(const Self& other) { _join(other); } void join(const Self& other) { _join(other); }
void join(const Self& gps1, const Self& gps2) { void join(const Self& gps1, const Self& gps2) {
@ -332,19 +333,19 @@ public:
_join(*(gps1.m_arr), *(gps2.m_arr), *(this->m_arr)); _join(*(gps1.m_arr), *(gps2.m_arr), *(this->m_arr));
} }
// difference with a simple polygon // computes the difference with a simple polygon
void difference(const Polygon_2& pgn) { void difference(const Polygon_2& pgn) {
ValidationPolicy::is_valid(pgn, *m_traits); ValidationPolicy::is_valid(pgn, *m_traits);
_difference(pgn); _difference(pgn);
} }
// difference with a polygon with holes // computes the difference with a polygon with holes
void difference(const Polygon_with_holes_2& pgn) { void difference(const Polygon_with_holes_2& pgn) {
ValidationPolicy::is_valid(pgn, *m_traits); ValidationPolicy::is_valid(pgn, *m_traits);
_difference(pgn); _difference(pgn);
} }
//difference with another Gps_on_surface_base_2 object // computes the difference with another Gps_on_surface_base_2 object
void difference(const Self& other) { _difference(other); } void difference(const Self& other) { _difference(other); }
void difference(const Self& gps1, const Self& gps2) { void difference(const Self& gps1, const Self& gps2) {
@ -352,19 +353,19 @@ public:
_difference(*(gps1.m_arr), *(gps2.m_arr), *(this->m_arr)); _difference(*(gps1.m_arr), *(gps2.m_arr), *(this->m_arr));
} }
// symmetric_difference with a simple polygon // computes the symmetric_difference with a simple polygon
void symmetric_difference(const Polygon_2& pgn) { void symmetric_difference(const Polygon_2& pgn) {
ValidationPolicy::is_valid(pgn, *m_traits); ValidationPolicy::is_valid(pgn, *m_traits);
_symmetric_difference(pgn); _symmetric_difference(pgn);
} }
// symmetric_difference with a polygon with holes // computes the symmetric_difference with a polygon with holes
void symmetric_difference(const Polygon_with_holes_2& pgn) { void symmetric_difference(const Polygon_with_holes_2& pgn) {
ValidationPolicy::is_valid(pgn, *m_traits); ValidationPolicy::is_valid(pgn, *m_traits);
_symmetric_difference(pgn); _symmetric_difference(pgn);
} }
//symmetric_difference with another Gps_on_surface_base_2 object // computes the symmetric_difference with another Gps_on_surface_base_2 object
void symmetric_difference(const Self& other) { _symmetric_difference(other); } void symmetric_difference(const Self& other) { _symmetric_difference(other); }
void symmetric_difference(const Self& gps1, const Self& gps2) { void symmetric_difference(const Self& gps1, const Self& gps2) {
@ -414,7 +415,6 @@ public:
Face_const_iterator f; Face_const_iterator f;
if (CGAL::assign(f, obj)) { if (CGAL::assign(f, obj)) {
if (f->contained()) return ON_POSITIVE_SIDE; if (f->contained()) return ON_POSITIVE_SIDE;
return ON_NEGATIVE_SIDE ; return ON_NEGATIVE_SIDE ;
} }
return ON_ORIENTED_BOUNDARY ; return ON_ORIENTED_BOUNDARY ;
@ -433,14 +433,10 @@ public:
} }
Oriented_side oriented_side(const Self& other) const { Oriented_side oriented_side(const Self& other) const {
if (this->is_empty() || other.is_empty()) if (this->is_empty() || other.is_empty()) return ON_NEGATIVE_SIDE;
return ON_NEGATIVE_SIDE; if (this->is_plane() || other.is_plane()) return ON_POSITIVE_SIDE;
if (this->is_plane() || other.is_plane())
return ON_POSITIVE_SIDE;
Aos_2 res_arr; Aos_2 res_arr;
Gps_do_intersect_functor<Aos_2> func; Gps_do_intersect_functor<Aos_2> func;
overlay(*m_arr, *(other.m_arr), res_arr, func); overlay(*m_arr, *(other.m_arr), res_arr, func);
if (func.found_reg_intersection()) return ON_POSITIVE_SIDE; if (func.found_reg_intersection()) return ON_POSITIVE_SIDE;
@ -448,15 +444,15 @@ public:
return ON_NEGATIVE_SIDE; return ON_NEGATIVE_SIDE;
} }
// returns the location of the query point // obtains the location of the query point
bool locate(const Point_2& q, Polygon_with_holes_2& pgn) const; bool locate(const Point_2& q, Polygon_with_holes_2& pgn) const;
/*! Obtain a const reference to the underlying arrangement /*! obtains a const reference to the underlying arrangement
* \return the underlying arrangement. * \return the underlying arrangement.
*/ */
const Aos_2& arrangement() const { return *m_arr; } const Aos_2& arrangement() const { return *m_arr; }
/*! Obtain a reference to the underlying arrangement /*! obtains a reference to the underlying arrangement
* \return the underlying arrangement. * \return the underlying arrangement.
*/ */
Aos_2& arrangement() { return *m_arr; } Aos_2& arrangement() { return *m_arr; }
@ -486,16 +482,16 @@ protected:
} }
public: public:
/*! */ //
bool is_valid() { return _is_valid(*this->m_arr); } bool is_valid() { return _is_valid(*this->m_arr); }
// get the simple polygons, takes O(n) // obtains the simple polygons, takes O(n)
template <typename OutputIterator> template <typename OutputIterator>
OutputIterator polygons_with_holes(OutputIterator out) const; OutputIterator polygons_with_holes(OutputIterator out) const;
// test for intersection of a range of polygons // tests for intersection of a range of polygons
template <typename InputIterator> template <typename InputIterator>
bool do_intersect(InputIterator begin, InputIterator end, unsigned int k = 5) { bool do_intersect(InputIterator begin, InputIterator end, std::size_t k = 5) {
Self other(*this); Self other(*this);
other.intersection(begin, end, k); other.intersection(begin, end, k);
return (other.is_empty()); return (other.is_empty());
@ -504,32 +500,32 @@ public:
template <typename InputIterator1, typename InputIterator2> template <typename InputIterator1, typename InputIterator2>
bool do_intersect(InputIterator1 begin1, InputIterator1 end1, bool do_intersect(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2, InputIterator2 begin2, InputIterator2 end2,
unsigned int k = 5) { std::size_t k = 5) {
Self other(*this); Self other(*this);
other.intersection(begin1, end1, begin2, end2, k); other.intersection(begin1, end1, begin2, end2, k);
return (other.is_empty()); return (other.is_empty());
} }
// join a range of polygons // joins a range of polygons
template <typename InputIterator> template <typename InputIterator>
void join(InputIterator begin, InputIterator end, unsigned int k = 5) { void join(InputIterator begin, InputIterator end, std::size_t k = 5) {
typename std::iterator_traits<InputIterator>::value_type pgn; typename std::iterator_traits<InputIterator>::value_type pgn;
this->join(begin, end, pgn, k); this->join(begin, end, pgn, k);
this->remove_redundant_edges(); this->remove_redundant_edges();
this->_reset_faces(); this->_reset_faces();
} }
// join range of simple polygons // joins a range of simple polygons
// 5 is the magic number in which we switch to a sweep-based algorithm // 5 is the magic number in which we switch to a sweep-based algorithm
// instead of a D&C algorithm. This point should be further studies, as // instead of a D&C algorithm. This point should be further studies, as
// it is hard to believe that this is the best value for all applications. // it is hard to believe that this is the best value for all applications.
template <typename InputIterator> template <typename InputIterator>
inline void join(InputIterator begin, InputIterator end, Polygon_2&, inline void join(InputIterator begin, InputIterator end, Polygon_2&,
unsigned int k = 5) { std::size_t k = 5) {
std::vector<Arr_entry> arr_vec(std::distance(begin, end) + 1); std::vector<Arr_entry> arr_vec(std::distance(begin, end) + 1);
arr_vec[0].first = this->m_arr; arr_vec[0].first = this->m_arr;
unsigned int i = 1; std::size_t i = 1;
for (InputIterator itr = begin; itr != end; ++itr, ++i) { for (InputIterator itr = begin; itr != end; ++itr, ++i) {
ValidationPolicy::is_valid((*itr), *m_traits); ValidationPolicy::is_valid((*itr), *m_traits);
arr_vec[i].first = new Aos_2(m_traits); arr_vec[i].first = new Aos_2(m_traits);
@ -538,21 +534,21 @@ public:
Join_merge<Aos_2> join_merge; Join_merge<Aos_2> join_merge;
_build_sorted_vertices_vectors(arr_vec); _build_sorted_vertices_vectors(arr_vec);
_divide_and_conquer(0, static_cast<unsigned int>(arr_vec.size()-1), arr_vec, k, join_merge); _divide_and_conquer(0, arr_vec.size() - 1, arr_vec, k, join_merge);
//the result arrangement is at index 0 //the result arrangement is at index 0
this->m_arr = arr_vec[0].first; this->m_arr = arr_vec[0].first;
delete arr_vec[0].second; delete arr_vec[0].second;
} }
//join range of polygons with holes (see previous comment about k=5). // joins a range of polygons with holes (see previous comment about k=5).
template <typename InputIterator> template <typename InputIterator>
inline void join(InputIterator begin, InputIterator end, inline void join(InputIterator begin, InputIterator end,
Polygon_with_holes_2&, unsigned int k = 5) { Polygon_with_holes_2&, std::size_t k = 5) {
std::vector<Arr_entry> arr_vec(std::distance(begin, end) + 1); std::vector<Arr_entry> arr_vec(std::distance(begin, end) + 1);
arr_vec[0].first = this->m_arr; arr_vec[0].first = this->m_arr;
unsigned int i = 1; std::size_t i = 1;
for (InputIterator itr = begin; itr!=end; ++itr, ++i) { for (InputIterator itr = begin; itr!=end; ++itr, ++i) {
ValidationPolicy::is_valid((*itr), *m_traits); ValidationPolicy::is_valid((*itr), *m_traits);
arr_vec[i].first = new Aos_2(m_traits); arr_vec[i].first = new Aos_2(m_traits);
@ -561,7 +557,7 @@ public:
Join_merge<Aos_2> join_merge; Join_merge<Aos_2> join_merge;
_build_sorted_vertices_vectors(arr_vec); _build_sorted_vertices_vectors(arr_vec);
_divide_and_conquer(0, static_cast<unsigned int>(arr_vec.size()-1), arr_vec, k, join_merge); _divide_and_conquer(0, arr_vec.size() - 1, arr_vec, k, join_merge);
// the result arrangement is at index 0 // the result arrangement is at index 0
this->m_arr = arr_vec[0].first; this->m_arr = arr_vec[0].first;
@ -572,11 +568,11 @@ public:
template <typename InputIterator1, typename InputIterator2> template <typename InputIterator1, typename InputIterator2>
inline void join(InputIterator1 begin1, InputIterator1 end1, inline void join(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2, InputIterator2 begin2, InputIterator2 end2,
unsigned int k = 5) { std::size_t k = 5) {
std::vector<Arr_entry> arr_vec(std::distance(begin1, end1) + std::distance(begin2, end2) + 1); std::vector<Arr_entry> arr_vec(std::distance(begin1, end1) + std::distance(begin2, end2) + 1);
arr_vec[0].first = this->m_arr; arr_vec[0].first = this->m_arr;
unsigned int i = 1; std::size_t i = 1;
for (InputIterator1 itr1 = begin1; itr1 != end1; ++itr1, ++i) { for (InputIterator1 itr1 = begin1; itr1 != end1; ++itr1, ++i) {
arr_vec[i].first = new Aos_2(m_traits); arr_vec[i].first = new Aos_2(m_traits);
@ -590,7 +586,7 @@ public:
Join_merge<Aos_2> join_merge; Join_merge<Aos_2> join_merge;
_build_sorted_vertices_vectors(arr_vec); _build_sorted_vertices_vectors(arr_vec);
_divide_and_conquer(0, static_cast<unsigned int>(arr_vec.size()-1), arr_vec, k, join_merge); _divide_and_conquer(0, arr_vec.size() - 1, arr_vec, k, join_merge);
// the result arrangement is at index 0 // the result arrangement is at index 0
this->m_arr = arr_vec[0].first; this->m_arr = arr_vec[0].first;
@ -599,23 +595,23 @@ public:
this->_reset_faces(); this->_reset_faces();
} }
// intersect range of polygins (see previous comment about k=5). // intersects a range of polygins (see previous comment about k=5).
template <typename InputIterator> template <typename InputIterator>
inline void intersection(InputIterator begin, InputIterator end, inline void intersection(InputIterator begin, InputIterator end,
unsigned int k = 5) { std::size_t k = 5) {
typename std::iterator_traits<InputIterator>::value_type pgn; typename std::iterator_traits<InputIterator>::value_type pgn;
this->intersection(begin, end, pgn, k); this->intersection(begin, end, pgn, k);
this->remove_redundant_edges(); this->remove_redundant_edges();
this->_reset_faces(); this->_reset_faces();
} }
// intersect range of simple polygons // intersects a range of simple polygons
template <typename InputIterator> template <typename InputIterator>
inline void intersection(InputIterator begin, InputIterator end, inline void intersection(InputIterator begin, InputIterator end,
Polygon_2&, unsigned int k) { Polygon_2&, std::size_t k) {
std::vector<Arr_entry> arr_vec(std::distance(begin, end) + 1); std::vector<Arr_entry> arr_vec(std::distance(begin, end) + 1);
arr_vec[0].first = this->m_arr; arr_vec[0].first = this->m_arr;
unsigned int i = 1; std::size_t i = 1;
for (InputIterator itr = begin; itr != end; ++itr, ++i) { for (InputIterator itr = begin; itr != end; ++itr, ++i) {
ValidationPolicy::is_valid((*itr), *m_traits); ValidationPolicy::is_valid((*itr), *m_traits);
@ -625,20 +621,20 @@ public:
Intersection_merge<Aos_2> intersection_merge; Intersection_merge<Aos_2> intersection_merge;
_build_sorted_vertices_vectors(arr_vec); _build_sorted_vertices_vectors(arr_vec);
_divide_and_conquer(0, static_cast<unsigned int>(arr_vec.size()-1), arr_vec, k, intersection_merge); _divide_and_conquer(0, arr_vec.size() - 1, arr_vec, k, intersection_merge);
// the result arrangement is at index 0 // the result arrangement is at index 0
this->m_arr = arr_vec[0].first; this->m_arr = arr_vec[0].first;
delete arr_vec[0].second; delete arr_vec[0].second;
} }
// intersect range of polygons with holes // intersects a range of polygons with holes
template <typename InputIterator> template <typename InputIterator>
inline void intersection(InputIterator begin, InputIterator end, inline void intersection(InputIterator begin, InputIterator end,
Polygon_with_holes_2&, unsigned int k) { Polygon_with_holes_2&, std::size_t k) {
std::vector<Arr_entry> arr_vec(std::distance(begin, end) + 1); std::vector<Arr_entry> arr_vec(std::distance(begin, end) + 1);
arr_vec[0].first = this->m_arr; arr_vec[0].first = this->m_arr;
unsigned int i = 1; std::size_t i = 1;
for (InputIterator itr = begin; itr!=end; ++itr, ++i) { for (InputIterator itr = begin; itr!=end; ++itr, ++i) {
ValidationPolicy::is_valid((*itr), *m_traits); ValidationPolicy::is_valid((*itr), *m_traits);
@ -648,7 +644,7 @@ public:
Intersection_merge<Aos_2> intersection_merge; Intersection_merge<Aos_2> intersection_merge;
_build_sorted_vertices_vectors(arr_vec); _build_sorted_vertices_vectors(arr_vec);
_divide_and_conquer(0, static_cast<unsigned int>(arr_vec.size()-1), arr_vec, k, intersection_merge); _divide_and_conquer(0, arr_vec.size() - 1, arr_vec, k, intersection_merge);
// the result arrangement is at index 0 // the result arrangement is at index 0
this->m_arr = arr_vec[0].first; this->m_arr = arr_vec[0].first;
@ -658,10 +654,10 @@ public:
template <typename InputIterator1, typename InputIterator2> template <typename InputIterator1, typename InputIterator2>
inline void intersection(InputIterator1 begin1, InputIterator1 end1, inline void intersection(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2, InputIterator2 begin2, InputIterator2 end2,
unsigned int k = 5) { std::size_t k = 5) {
std::vector<Arr_entry> arr_vec(std::distance(begin1, end1) + std::distance(begin2, end2) + 1); std::vector<Arr_entry> arr_vec(std::distance(begin1, end1) + std::distance(begin2, end2) + 1);
arr_vec[0].first = this->m_arr; arr_vec[0].first = this->m_arr;
unsigned int i = 1; std::size_t i = 1;
for (InputIterator1 itr1 = begin1; itr1!=end1; ++itr1, ++i) { for (InputIterator1 itr1 = begin1; itr1!=end1; ++itr1, ++i) {
ValidationPolicy::is_valid(*itr1, *m_traits); ValidationPolicy::is_valid(*itr1, *m_traits);
@ -677,7 +673,7 @@ public:
Intersection_merge<Aos_2> intersection_merge; Intersection_merge<Aos_2> intersection_merge;
_build_sorted_vertices_vectors(arr_vec); _build_sorted_vertices_vectors(arr_vec);
_divide_and_conquer(0, static_cast<unsigned int>(arr_vec.size()-1), arr_vec, k, intersection_merge); _divide_and_conquer(0, arr_vec.size() - 1, arr_vec, k, intersection_merge);
// the result arrangement is at index 0 // the result arrangement is at index 0
this->m_arr = arr_vec[0].first; this->m_arr = arr_vec[0].first;
@ -686,24 +682,24 @@ public:
this->_reset_faces(); this->_reset_faces();
} }
// symmetric_difference of a range of polygons (similar to xor) // computes the symmetric_difference of a range of polygons (similar to xor)
// (see previous comment about k=5). // (see previous comment about k=5).
template <typename InputIterator> template <typename InputIterator>
inline void symmetric_difference(InputIterator begin, InputIterator end, inline void symmetric_difference(InputIterator begin, InputIterator end,
unsigned int k = 5) { std::size_t k = 5) {
typename std::iterator_traits<InputIterator>::value_type pgn; typename std::iterator_traits<InputIterator>::value_type pgn;
this->symmetric_difference(begin, end, pgn, k); this->symmetric_difference(begin, end, pgn, k);
this->remove_redundant_edges(); this->remove_redundant_edges();
this->_reset_faces(); this->_reset_faces();
} }
// intersect range of simple polygons (see previous comment about k=5). // intersect a range of simple polygons (see previous comment about k=5).
template <typename InputIterator> template <typename InputIterator>
inline void symmetric_difference(InputIterator begin, InputIterator end, inline void symmetric_difference(InputIterator begin, InputIterator end,
Polygon_2&, unsigned int k = 5) { Polygon_2&, std::size_t k = 5) {
std::vector<Arr_entry> arr_vec(std::distance(begin, end) + 1); std::vector<Arr_entry> arr_vec(std::distance(begin, end) + 1);
arr_vec[0].first = this->m_arr; arr_vec[0].first = this->m_arr;
unsigned int i = 1; std::size_t i = 1;
for (InputIterator itr = begin; itr!=end; ++itr, ++i) { for (InputIterator itr = begin; itr!=end; ++itr, ++i) {
ValidationPolicy::is_valid(*itr,*m_traits); ValidationPolicy::is_valid(*itr,*m_traits);
@ -713,20 +709,20 @@ public:
Xor_merge<Aos_2> xor_merge; Xor_merge<Aos_2> xor_merge;
_build_sorted_vertices_vectors(arr_vec); _build_sorted_vertices_vectors(arr_vec);
_divide_and_conquer(0, static_cast<unsigned int>(arr_vec.size()-1), arr_vec, k, xor_merge); _divide_and_conquer(0, arr_vec.size() - 1, arr_vec, k, xor_merge);
// the result arrangement is at index 0 // the result arrangement is at index 0
this->m_arr = arr_vec[0].first; this->m_arr = arr_vec[0].first;
delete arr_vec[0].second; delete arr_vec[0].second;
} }
//intersect range of polygons with holes (see previous comment about k=5). // intersects a range of polygons with holes (see previous comment about k=5).
template <typename InputIterator> template <typename InputIterator>
inline void symmetric_difference(InputIterator begin, InputIterator end, inline void symmetric_difference(InputIterator begin, InputIterator end,
Polygon_with_holes_2&, unsigned int k = 5) { Polygon_with_holes_2&, std::size_t k = 5) {
std::vector<Arr_entry> arr_vec(std::distance(begin, end) + 1); std::vector<Arr_entry> arr_vec(std::distance(begin, end) + 1);
arr_vec[0].first = this->m_arr; arr_vec[0].first = this->m_arr;
unsigned int i = 1; std::size_t i = 1;
for (InputIterator itr = begin; itr != end; ++itr, ++i) { for (InputIterator itr = begin; itr != end; ++itr, ++i) {
ValidationPolicy::is_valid(*itr,*m_traits); ValidationPolicy::is_valid(*itr,*m_traits);
@ -736,7 +732,7 @@ public:
Xor_merge<Aos_2> xor_merge; Xor_merge<Aos_2> xor_merge;
_build_sorted_vertices_vectors(arr_vec); _build_sorted_vertices_vectors(arr_vec);
_divide_and_conquer(0, static_cast<unsigned int>(arr_vec.size()-1), arr_vec, k, xor_merge); _divide_and_conquer(0, arr_vec.size() - 1, arr_vec, k, xor_merge);
// the result arrangement is at index 0 // the result arrangement is at index 0
this->m_arr = arr_vec[0].first; this->m_arr = arr_vec[0].first;
@ -747,10 +743,10 @@ public:
template <typename InputIterator1, typename InputIterator2> template <typename InputIterator1, typename InputIterator2>
inline void symmetric_difference(InputIterator1 begin1, InputIterator1 end1, inline void symmetric_difference(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2, InputIterator2 begin2, InputIterator2 end2,
unsigned int k = 5) { std::size_t k = 5) {
std::vector<Arr_entry> arr_vec(std::distance(begin1, end1) + std::distance(begin2, end2) + 1); std::vector<Arr_entry> arr_vec(std::distance(begin1, end1) + std::distance(begin2, end2) + 1);
arr_vec[0].first = this->m_arr; arr_vec[0].first = this->m_arr;
unsigned int i = 1; std::size_t i = 1;
for (InputIterator1 itr1 = begin1; itr1 != end1; ++itr1, ++i) { for (InputIterator1 itr1 = begin1; itr1 != end1; ++itr1, ++i) {
ValidationPolicy::is_valid(*itr1, *m_traits); ValidationPolicy::is_valid(*itr1, *m_traits);
@ -766,7 +762,7 @@ public:
Xor_merge<Aos_2> xor_merge; Xor_merge<Aos_2> xor_merge;
_build_sorted_vertices_vectors(arr_vec); _build_sorted_vertices_vectors(arr_vec);
_divide_and_conquer(0, static_cast<unsigned int>(arr_vec.size()-1), arr_vec, k, xor_merge); _divide_and_conquer(0, arr_vec.size() - 1, arr_vec, k, xor_merge);
// the result arrangement is at index 0 // the result arrangement is at index 0
this->m_arr = arr_vec[0].first; this->m_arr = arr_vec[0].first;
@ -1136,7 +1132,7 @@ protected:
} }
} }
//fix the directions of the curves (given correct marked face) // fixes the directions of the curves (given correct marked face)
// it should be called mostly after symmetric_difference. // it should be called mostly after symmetric_difference.
void _fix_curves_direction(Aos_2& arr) { void _fix_curves_direction(Aos_2& arr) {
Compare_endpoints_xy_2 cmp_endpoints = Compare_endpoints_xy_2 cmp_endpoints =
@ -1161,20 +1157,16 @@ protected:
void _build_sorted_vertices_vectors(std::vector<Arr_entry>& arr_vec) { void _build_sorted_vertices_vectors(std::vector<Arr_entry>& arr_vec) {
Less_vertex_handle comp(m_traits->compare_xy_2_object()); Less_vertex_handle comp(m_traits->compare_xy_2_object());
Aos_2* p_arr;
Vertex_iterator vit;
const std::size_t n = arr_vec.size(); const std::size_t n = arr_vec.size();
std::size_t i, j; for (std::size_t i = 0; i < n; i++) {
// Allocate a vector of handles to all vertices in the current arrangement.
for (i = 0; i < n; i++) { Aos_2* p_arr = arr_vec[i].first;
// Allocate a vector of handles to all vertices in the current
// arrangement.
p_arr = arr_vec[i].first;
arr_vec[i].second = new std::vector<Vertex_handle>; arr_vec[i].second = new std::vector<Vertex_handle>;
arr_vec[i].second->resize(p_arr->number_of_vertices()); arr_vec[i].second->resize(p_arr->number_of_vertices());
for (j = 0, vit = p_arr->vertices_begin(); vit != p_arr->vertices_end(); j++, ++vit) { std::size_t j = 0;
(*(arr_vec[i].second))[j] = vit; for (auto vit = p_arr->vertices_begin(); vit != p_arr->vertices_end(); ++vit) {
(*(arr_vec[i].second))[j++] = vit;
} }
// Sort the vector. // Sort the vector.
@ -1183,25 +1175,25 @@ protected:
} }
template <typename Merge> template <typename Merge>
void _divide_and_conquer(unsigned int lower, unsigned int upper, void _divide_and_conquer(std::size_t lower, std::size_t upper,
std::vector<Arr_entry>& arr_vec, std::vector<Arr_entry>& arr_vec,
unsigned int k, Merge merge_func) { std::size_t k, Merge merge_func) {
if ((upper - lower) < k) { if ((upper - lower) < k) {
merge_func(lower, upper, 1, arr_vec); merge_func(lower, upper, 1, arr_vec);
return; return;
} }
unsigned int sub_size = ((upper - lower + 1) / k); auto sub_size = ((upper - lower + 1) / k);
unsigned int curr_lower = lower; auto curr_lower = lower;
for (unsigned int i = 0; i < k - 1; ++i, curr_lower += sub_size) { for (std::size_t i = 0; i < k - 1; ++i, curr_lower += sub_size) {
_divide_and_conquer(curr_lower, curr_lower + sub_size-1, arr_vec, k, merge_func); _divide_and_conquer(curr_lower, curr_lower + sub_size-1, arr_vec, k, merge_func);
} }
_divide_and_conquer(curr_lower, upper, arr_vec, k, merge_func); _divide_and_conquer(curr_lower, upper, arr_vec, k, merge_func);
merge_func(lower, curr_lower, sub_size, arr_vec); merge_func(lower, curr_lower, sub_size, arr_vec);
} }
// mark all faces as non-visited // marks all faces as non-visited
void _reset_faces() const { _reset_faces(m_arr); } void _reset_faces() const { _reset_faces(m_arr); }
void _reset_faces(Aos_2* arr) const { void _reset_faces(Aos_2* arr) const {

82
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/Gps_polygon_simplifier.h
View File

@ -31,34 +31,33 @@ namespace Ss2 = Surface_sweep_2;
template <typename Arrangement_> template <typename Arrangement_>
class Gps_polygon_simplifier { class Gps_polygon_simplifier {
typedef Arrangement_ Arrangement_2; using Arrangement_2 = Arrangement_;
typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; using Geometry_traits_2 = typename Arrangement_2::Geometry_traits_2;
typedef typename Arrangement_2::Topology_traits Topology_traits; using Topology_traits = typename Arrangement_2::Topology_traits;
typedef Arrangement_2 Arr; using Arr = Arrangement_2;
typedef Geometry_traits_2 Gt2; using Gt2 = Geometry_traits_2;
typedef Topology_traits Tt; using Tt = Topology_traits;
typedef typename Gt2::Curve_const_iterator Curve_const_iterator; using Curve_const_iterator = typename Gt2::Curve_const_iterator;
typedef typename Gt2::Polygon_2 Polygon_2; using Polygon_2 = typename Gt2::Polygon_2;
typedef typename Gt2::Polygon_with_holes_2 Polygon_with_holes_2; using Polygon_with_holes_2 = typename Gt2::Polygon_with_holes_2;
typedef typename Gt2::Construct_curves_2 Construct_curves_2; using Construct_curves_2 = typename Gt2::Construct_curves_2;
typedef Gps_simplifier_traits<Gt2> Mgt2; using Mgt2 = Gps_simplifier_traits<Gt2>;
typedef typename Mgt2::Curve_data Curve_data; using Curve_data = typename Mgt2::Curve_data;
typedef typename Mgt2::X_monotone_curve_2 Meta_X_monotone_curve_2; using Meta_X_monotone_curve_2 = typename Mgt2::X_monotone_curve_2;
typedef typename Arr::Halfedge_handle Halfedge_handle; using Halfedge_handle = typename Arr::Halfedge_handle;
typedef typename Arr::Halfedge_iterator Halfedge_iterator; using Halfedge_iterator = typename Arr::Halfedge_iterator;
typedef typename Arr::Face_handle Face_handle; using Face_handle = typename Arr::Face_handle;
typedef typename Arr::Face_iterator Face_iterator; using Face_iterator = typename Arr::Face_iterator;
typedef typename Arr::Edge_iterator Edge_iterator; using Edge_iterator = typename Arr::Edge_iterator;
typedef typename Arr::Vertex_handle Vertex_handle; using Vertex_handle = typename Arr::Vertex_handle;
typedef typename Arr::Ccb_halfedge_const_circulator using Ccb_halfedge_const_circulator = typename Arr::Ccb_halfedge_const_circulator;
Ccb_halfedge_const_circulator; using Ccb_halfedge_circulator = typename Arr::Ccb_halfedge_circulator;
typedef typename Arr::Ccb_halfedge_circulator Ccb_halfedge_circulator; using Allocator = typename Arr::Allocator;
typedef typename Arr::Allocator Allocator;
// We obtain a proper helper type from the topology traits of the arrangement. // We obtain a proper helper type from the topology traits of the arrangement.
// However, the arrangement is parametrized with the Gt2 geometry traits, // However, the arrangement is parametrized with the Gt2 geometry traits,
@ -67,22 +66,18 @@ class Gps_polygon_simplifier {
// We cannot parameterized the arrangement with the Mgt2 geometry // We cannot parameterized the arrangement with the Mgt2 geometry
// traits to start with, because it extends the curve type with arrangement // traits to start with, because it extends the curve type with arrangement
// dependent types. (It is parameterized with the arrangement type.) // dependent types. (It is parameterized with the arrangement type.)
typedef Indexed_event<Mgt2, Arr, Allocator> Event; using Event = Indexed_event<Mgt2, Arr, Allocator>;
typedef Arr_construction_subcurve<Mgt2, Event, Allocator> using Subcurve = Arr_construction_subcurve<Mgt2, Event, Allocator>;
Subcurve; using Helper_tmp = typename Tt::template Construction_helper<Event, Subcurve>;
typedef typename Tt::template Construction_helper<Event, Subcurve> using Helper = typename Helper_tmp::template rebind<Mgt2, Arr, Event, Subcurve>::other;
Helper_tmp; using Visitor = Gps_agg_op_base_visitor<Helper, Arr>;
typedef typename Helper_tmp::template rebind<Mgt2, Arr, Event, Subcurve>::other using Surface_sweep_2 = Ss2::Surface_sweep_2<Visitor>;
Helper;
typedef Gps_agg_op_base_visitor<Helper, Arr> Visitor;
typedef Ss2::Surface_sweep_2<Visitor> Surface_sweep_2;
typedef Unique_hash_map<Halfedge_handle, unsigned int> using Edges_hash = Unique_hash_map<Halfedge_handle, std::size_t>;
Edges_hash;
typedef Unique_hash_map<Face_handle, unsigned int> Faces_hash; using Faces_hash = Unique_hash_map<Face_handle, std::size_t>;
typedef Gps_bfs_join_visitor<Arr> Bfs_visitor; using Bfs_visitor = Gps_bfs_join_visitor<Arr>;
typedef Gps_bfs_scanner<Arr, Bfs_visitor> Bfs_scanner; using Bfs_scanner = Gps_bfs_scanner<Arr, Bfs_visitor>;
protected: protected:
Arr* m_arr; Arr* m_arr;
@ -104,16 +99,14 @@ public:
{} {}
/*! Destructor. */ /*! Destructor. */
~Gps_polygon_simplifier() ~Gps_polygon_simplifier() {
{
if (m_own_traits && (m_traits != nullptr)) { if (m_own_traits && (m_traits != nullptr)) {
delete m_traits; delete m_traits;
m_traits = nullptr; m_traits = nullptr;
} }
} }
void simplify(const Polygon_2& pgn) void simplify(const Polygon_2& pgn) {
{
Construct_curves_2 ctr_curves = Construct_curves_2 ctr_curves =
reinterpret_cast<const Gt2*>(m_traits)->construct_curves_2_object(); reinterpret_cast<const Gt2*>(m_traits)->construct_curves_2_object();
@ -122,14 +115,13 @@ public:
std::pair<Curve_const_iterator, Curve_const_iterator> itr_pair = std::pair<Curve_const_iterator, Curve_const_iterator> itr_pair =
ctr_curves(pgn); ctr_curves(pgn);
unsigned int index = 0; std::size_t index = 0;
for (Curve_const_iterator itr = itr_pair.first; itr != itr_pair.second; for (Curve_const_iterator itr = itr_pair.first; itr != itr_pair.second;
++itr, ++index) ++itr, ++index) {
{
Curve_data cv_data(1, 0, index); Curve_data cv_data(1, 0, index);
curves_list.push_back(Meta_X_monotone_curve_2(*itr, cv_data)); curves_list.push_back(Meta_X_monotone_curve_2(*itr, cv_data));
} }
m_traits->set_polygon_size(static_cast<unsigned int>(curves_list.size())); m_traits->set_polygon_size(curves_list.size());
m_surface_sweep.sweep(curves_list.begin(), curves_list.end()); m_surface_sweep.sweep(curves_list.begin(), curves_list.end());

109
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/Gps_simplifier_traits.h
View File

@ -23,97 +23,94 @@ namespace CGAL {
class Gps_simplifier_curve_data { class Gps_simplifier_curve_data {
protected: protected:
unsigned int m_bc; std::size_t m_bc;
unsigned int m_twin_bc; std::size_t m_twin_bc;
unsigned int m_index; std::size_t m_index;
public: public:
Gps_simplifier_curve_data() {} Gps_simplifier_curve_data() {}
Gps_simplifier_curve_data(unsigned int bc, unsigned int twin_bc, Gps_simplifier_curve_data(std::size_t bc, std::size_t twin_bc,
unsigned int index): std::size_t index):
m_bc(bc), m_bc(bc),
m_twin_bc(twin_bc), m_twin_bc(twin_bc),
m_index(index) m_index(index)
{} {}
unsigned int bc() const { return m_bc; } std::size_t bc() const { return m_bc; }
unsigned int twin_bc() const { return m_twin_bc; } std::size_t twin_bc() const { return m_twin_bc; }
unsigned int index() const { return m_index; } std::size_t index() const { return m_index; }
unsigned int& index() { return m_index; } std::size_t& index() { return m_index; }
unsigned int& twin_bc() { return m_twin_bc; } std::size_t& twin_bc() { return m_twin_bc; }
void set_bc(unsigned int bc) { m_bc = bc; } void set_bc(std::size_t bc) { m_bc = bc; }
void set_twin_bc(unsigned int twin_bc) { m_twin_bc = twin_bc; } void set_twin_bc(std::size_t twin_bc) { m_twin_bc = twin_bc; }
void set_index(unsigned int index) { m_index = index; } void set_index(std::size_t index) { m_index = index; }
}; };
struct Gps_simplifier_point_data { struct Gps_simplifier_point_data {
protected: protected:
unsigned int m_index; std::size_t m_index;
public: public:
Gps_simplifier_point_data() {} Gps_simplifier_point_data() {}
Gps_simplifier_point_data(unsigned int index) : m_index(index) {} Gps_simplifier_point_data(std::size_t index) : m_index(index) {}
unsigned int index() const { return m_index; } std::size_t index() const { return m_index; }
void set_index(unsigned int index) { m_index = index; } void set_index(std::size_t index) { m_index = index; }
}; };
template <typename Traits_> template <typename Traits_>
class Gps_simplifier_traits : class Gps_simplifier_traits :
public Gps_traits_decorator<Traits_, public Gps_traits_decorator<Traits_,
Gps_simplifier_curve_data, Gps_simplifier_curve_data,
Gps_simplifier_point_data> Gps_simplifier_point_data> {
{
public: public:
typedef Traits_ Traits; using Traits = Traits_;
typedef Gps_traits_decorator<Traits_, using Base = Gps_traits_decorator<Traits_, Gps_simplifier_curve_data, Gps_simplifier_point_data>;
Gps_simplifier_curve_data, using Self = Gps_simplifier_traits<Traits>;
Gps_simplifier_point_data> Base; using Base_x_monotone_curve_2 = typename Traits::X_monotone_curve_2;
typedef Gps_simplifier_traits<Traits> Self; using Base_point_2 = typename Traits::Point_2;
typedef typename Traits::X_monotone_curve_2 Base_x_monotone_curve_2; using Base_Construct_min_vertex_2 = typename Traits::Construct_min_vertex_2;
typedef typename Traits::Point_2 Base_point_2; using Base_Construct_max_vertex_2 = typename Traits::Construct_max_vertex_2;
typedef typename Traits::Construct_min_vertex_2 Base_Construct_min_vertex_2; using Base_Compare_endpoints_xy_2 = typename Traits::Compare_endpoints_xy_2;
typedef typename Traits::Construct_max_vertex_2 Base_Construct_max_vertex_2; using Base_Compare_xy_2 = typename Traits::Compare_xy_2;
typedef typename Traits::Compare_endpoints_xy_2 Base_Compare_endpoints_xy_2; using Base_Compare_y_at_x_right_2 = typename Traits::Compare_y_at_x_right_2;
typedef typename Traits::Compare_xy_2 Base_Compare_xy_2; using Base_Compare_y_at_x_2 = typename Traits::Compare_y_at_x_2;
typedef typename Traits::Compare_y_at_x_right_2 Base_Compare_y_at_x_right_2; using Base_Intersect_2 = typename Traits::Intersect_2;
typedef typename Traits::Compare_y_at_x_2 Base_Compare_y_at_x_2; using Base_Split_2 = typename Traits::Split_2;
typedef typename Traits::Intersect_2 Base_Intersect_2;
typedef typename Traits::Split_2 Base_Split_2;
protected: protected:
mutable unsigned int m_pgn_size; mutable std::size_t m_pgn_size;
public: public:
typedef typename Base::X_monotone_curve_2 X_monotone_curve_2; using X_monotone_curve_2 = typename Base::X_monotone_curve_2;
typedef typename Base::Point_2 Point_2; using Point_2 = typename Base::Point_2;
typedef typename Base::Multiplicity Multiplicity; using Multiplicity = typename Base::Multiplicity;
typedef typename Base::Curve_data Curve_data; using Curve_data = typename Base::Curve_data;
typedef typename Base::Point_data Point_data; using Point_data = typename Base::Point_data;
Gps_simplifier_traits() {} Gps_simplifier_traits() {}
Gps_simplifier_traits(const Traits& tr) : Base(tr) {} Gps_simplifier_traits(const Traits& tr) : Base(tr) {}
unsigned int polygon_size() const { return m_pgn_size; } std::size_t polygon_size() const { return m_pgn_size; }
void set_polygon_size(unsigned int pgn_size) const { m_pgn_size = pgn_size; } void set_polygon_size(std::size_t pgn_size) const { m_pgn_size = pgn_size; }
bool is_valid_index(unsigned int index) const bool is_valid_index(std::size_t index) const
{ return (index < m_pgn_size); } { return (index < m_pgn_size); }
unsigned int invalid_index() const { return (m_pgn_size); } std::size_t invalid_index() const { return (m_pgn_size); }
class Intersect_2 { class Intersect_2 {
private: private:
@ -129,12 +126,9 @@ public:
template <typename OutputIterator> template <typename OutputIterator>
OutputIterator operator()(const X_monotone_curve_2& cv1, OutputIterator operator()(const X_monotone_curve_2& cv1,
const X_monotone_curve_2& cv2, const X_monotone_curve_2& cv2,
OutputIterator oi) const OutputIterator oi) const {
{ using Intersection_base_point = const std::pair<Base_point_2, Multiplicity>;
typedef const std::pair<Base_point_2, Multiplicity> using Intersection_base_result = std::variant<Intersection_base_point, Base_x_monotone_curve_2>;
Intersection_base_point;
typedef std::variant<Intersection_base_point, Base_x_monotone_curve_2>
Intersection_base_result;
const auto* base_traits = m_traits.m_base_traits; const auto* base_traits = m_traits.m_base_traits;
auto base_cmp_xy = base_traits->compare_xy_2_object(); auto base_cmp_xy = base_traits->compare_xy_2_object();
@ -146,7 +140,7 @@ public:
//if (m_traits.is_valid_index(cv1.data().index()) && //if (m_traits.is_valid_index(cv1.data().index()) &&
// m_traits.is_valid_index(cv2.data().index())) // m_traits.is_valid_index(cv2.data().index()))
//{ //{
// unsigned int index_diff = // std::size_t index_diff =
// (cv1.data().index() > cv2.data().index()) ? // (cv1.data().index() > cv2.data().index()) ?
// (cv1.data().index() - cv2.data().index()): // (cv1.data().index() - cv2.data().index()):
// (cv2.data().index() - cv1.data().index()); // (cv2.data().index() - cv1.data().index());
@ -180,8 +174,8 @@ public:
std::get_if<Base_x_monotone_curve_2>(&xection); std::get_if<Base_x_monotone_curve_2>(&xection);
CGAL_assertion(overlap_cv != nullptr); CGAL_assertion(overlap_cv != nullptr);
unsigned int ov_bc; std::size_t ov_bc;
unsigned int ov_twin_bc; std::size_t ov_twin_bc;
if (base_cmp_endpoints(cv1) == base_cmp_endpoints(cv2)) { if (base_cmp_endpoints(cv1) == base_cmp_endpoints(cv2)) {
// cv1 and cv2 have the same directions // cv1 and cv2 have the same directions
ov_bc = cv1.data().bc() + cv2.data().bc(); ov_bc = cv1.data().bc() + cv2.data().bc();
@ -250,8 +244,7 @@ public:
* \param cv The curve. * \param cv The curve.
* \return The left endpoint. * \return The left endpoint.
*/ */
Point_2 operator()(const X_monotone_curve_2 & cv) const Point_2 operator()(const X_monotone_curve_2 & cv) const {
{
const auto* base_traits = m_traits.m_base_traits; const auto* base_traits = m_traits.m_base_traits;
auto base_ctr_min_vertex = base_traits->construct_min_vertex_2_object(); auto base_ctr_min_vertex = base_traits->construct_min_vertex_2_object();
@ -290,8 +283,7 @@ public:
* \param cv The curve. * \param cv The curve.
* \return The left endpoint. * \return The left endpoint.
*/ */
Point_2 operator() (const X_monotone_curve_2 & cv) const Point_2 operator() (const X_monotone_curve_2 & cv) const {
{
const auto* base_traits = m_traits.m_base_traits; const auto* base_traits = m_traits.m_base_traits;
auto base_ctr_max_vertex = base_traits->construct_max_vertex_2_object(); auto base_ctr_max_vertex = base_traits->construct_max_vertex_2_object();
if (! m_traits.is_valid_index(cv.data().index())) if (! m_traits.is_valid_index(cv.data().index()))
@ -329,8 +321,7 @@ public:
* \param cv The curve. * \param cv The curve.
* \return The left endpoint. * \return The left endpoint.
*/ */
Comparison_result operator()(const Point_2& p1, const Point_2& p2) const Comparison_result operator()(const Point_2& p1, const Point_2& p2) const {
{
const auto* base_traits = m_traits.m_base_traits; const auto* base_traits = m_traits.m_base_traits;
auto base_cmp_xy = base_traits->compare_xy_2_object(); auto base_cmp_xy = base_traits->compare_xy_2_object();

9
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/Indexed_event.h
View File

@ -32,17 +32,16 @@ class Indexed_event :
Arrangement_, Arrangement_,
Allocator_>, Allocator_>,
Allocator_>, Allocator_>,
Arrangement_> Arrangement_> {
{
private: private:
unsigned int m_index; std::size_t m_index;
public: public:
Indexed_event() : m_index (0) {} Indexed_event() : m_index (0) {}
unsigned int index() const { return (m_index); } std::size_t index() const { return (m_index); }
void set_index(unsigned int index) { m_index = index; } void set_index(std::size_t index) { m_index = index; }
}; };
} // namespace CGAL } // namespace CGAL

12
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/do_intersect.h
View File

@ -201,13 +201,13 @@ inline bool do_intersect(const General_polygon_with_holes_2<Polygon_>& pgn1,
// With Traits // With Traits
template <typename InputIterator, typename Traits> template <typename InputIterator, typename Traits>
inline bool do_intersect(InputIterator begin, InputIterator end, Traits& traits, inline bool do_intersect(InputIterator begin, InputIterator end, Traits& traits,
unsigned int k = 5, std::size_t k = 5,
std::enable_if_t<CGAL::is_iterator<InputIterator>::value>* = 0) std::enable_if_t<CGAL::is_iterator<InputIterator>::value>* = 0)
{ return r_do_intersect(begin, end, traits, k); } { return r_do_intersect(begin, end, traits, k); }
// Without Traits // Without Traits
template <typename InputIterator> template <typename InputIterator>
inline bool do_intersect(InputIterator begin, InputIterator end, unsigned int k = 5, inline bool do_intersect(InputIterator begin, InputIterator end, std::size_t k = 5,
std::enable_if_t<CGAL::is_iterator<InputIterator>::value>* = 0, std::enable_if_t<CGAL::is_iterator<InputIterator>::value>* = 0,
Enable_if_Polygon_2_iterator<InputIterator>* = 0) { Enable_if_Polygon_2_iterator<InputIterator>* = 0) {
typename Iterator_to_gps_traits<InputIterator>::Traits traits; typename Iterator_to_gps_traits<InputIterator>::Traits traits;
@ -217,7 +217,7 @@ inline bool do_intersect(InputIterator begin, InputIterator end, unsigned int k
// General polygons or polygons with holes // General polygons or polygons with holes
template <typename InputIterator> template <typename InputIterator>
inline bool do_intersect(InputIterator begin, InputIterator end, inline bool do_intersect(InputIterator begin, InputIterator end,
unsigned int k = 5, std::size_t k = 5,
std::enable_if_t<CGAL::is_iterator<InputIterator>::value>* = 0, std::enable_if_t<CGAL::is_iterator<InputIterator>::value>* = 0,
Disable_if_Polygon_2_iterator<InputIterator>* = 0) { Disable_if_Polygon_2_iterator<InputIterator>* = 0) {
typename Iterator_to_gps_traits<InputIterator>::Traits traits; typename Iterator_to_gps_traits<InputIterator>::Traits traits;
@ -228,14 +228,14 @@ inline bool do_intersect(InputIterator begin, InputIterator end,
template <typename InputIterator1, typename InputIterator2, typename Traits> template <typename InputIterator1, typename InputIterator2, typename Traits>
inline bool do_intersect(InputIterator1 begin1, InputIterator1 end1, inline bool do_intersect(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2, InputIterator2 begin2, InputIterator2 end2,
Traits& traits, unsigned int k = 5) Traits& traits, std::size_t k = 5)
{ return r_do_intersect(begin1, end1, begin2, end2, traits, k); } { return r_do_intersect(begin1, end1, begin2, end2, traits, k); }
// Without Traits // Without Traits
template <typename InputIterator1, typename InputIterator2> template <typename InputIterator1, typename InputIterator2>
inline bool do_intersect(InputIterator1 begin1, InputIterator1 end1, inline bool do_intersect(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2, InputIterator2 begin2, InputIterator2 end2,
unsigned int k = 5, std::size_t k = 5,
Enable_if_Polygon_2_iterator<InputIterator1>* = 0) Enable_if_Polygon_2_iterator<InputIterator1>* = 0)
{ return r_do_intersect(begin1, end1, begin2, end2, k); } { return r_do_intersect(begin1, end1, begin2, end2, k); }
@ -243,7 +243,7 @@ inline bool do_intersect(InputIterator1 begin1, InputIterator1 end1,
template <typename InputIterator1, typename InputIterator2> template <typename InputIterator1, typename InputIterator2>
inline bool do_intersect(InputIterator1 begin1, InputIterator1 end1, inline bool do_intersect(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2, InputIterator2 begin2, InputIterator2 end2,
unsigned int k = 5, std::size_t k = 5,
Disable_if_Polygon_2_iterator<InputIterator1>* = 0) { Disable_if_Polygon_2_iterator<InputIterator1>* = 0) {
typename Iterator_to_gps_traits<InputIterator1>::Traits traits; typename Iterator_to_gps_traits<InputIterator1>::Traits traits;
return r_do_intersect(begin1, end1, begin2, end2, traits, k); return r_do_intersect(begin1, end1, begin2, end2, traits, k);

73
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/intersection.h
View File

@ -33,8 +33,7 @@
#include <CGAL/Boolean_set_operations_2/Polygon_conversions.h> #include <CGAL/Boolean_set_operations_2/Polygon_conversions.h>
#include <CGAL/type_traits/is_iterator.h> #include <CGAL/type_traits/is_iterator.h>
namespace CGAL namespace CGAL {
{
/// \name intersection() functions. /// \name intersection() functions.
//@{ //@{
@ -59,10 +58,9 @@ inline OutputIterator intersection(const Polygon_2<Kernel, Container>& pgn1,
template <typename Kernel, typename Container, typename OutputIterator> template <typename Kernel, typename Container, typename OutputIterator>
inline OutputIterator intersection(const Polygon_2<Kernel, Container>& pgn1, inline OutputIterator intersection(const Polygon_2<Kernel, Container>& pgn1,
const Polygon_2<Kernel, Container>& pgn2, const Polygon_2<Kernel, Container>& pgn2,
OutputIterator out, Tag_false) OutputIterator out, Tag_false) {
{
// Use the first polygon to determine the (default) traits // Use the first polygon to determine the (default) traits
typedef Polygon_2<Kernel, Container> Polygon; using Polygon = Polygon_2<Kernel, Container>;
typename Gps_default_traits<Polygon>::Traits traits; typename Gps_default_traits<Polygon>::Traits traits;
return s_intersection(pgn1, pgn2, out, traits); return s_intersection(pgn1, pgn2, out, traits);
} }
@ -90,10 +88,9 @@ template <typename Kernel, typename Container, typename OutputIterator>
inline OutputIterator inline OutputIterator
intersection(const Polygon_2<Kernel, Container>& pgn1, intersection(const Polygon_2<Kernel, Container>& pgn1,
const Polygon_with_holes_2<Kernel, Container>& pgn2, const Polygon_with_holes_2<Kernel, Container>& pgn2,
OutputIterator out, Tag_false) OutputIterator out, Tag_false) {
{
// Use the first polygon to determine the (default) traits // Use the first polygon to determine the (default) traits
typedef Polygon_2<Kernel, Container> Polygon; using Polygon = Polygon_2<Kernel, Container>;
typename Gps_default_traits<Polygon>::Traits traits; typename Gps_default_traits<Polygon>::Traits traits;
return s_intersection(pgn1, pgn2, out, traits); return s_intersection(pgn1, pgn2, out, traits);
} }
@ -121,10 +118,9 @@ template <typename Kernel, typename Container, typename OutputIterator>
inline OutputIterator inline OutputIterator
intersection(const Polygon_with_holes_2<Kernel, Container>& pgn1, intersection(const Polygon_with_holes_2<Kernel, Container>& pgn1,
const Polygon_2<Kernel, Container>& pgn2, const Polygon_2<Kernel, Container>& pgn2,
OutputIterator out, Tag_false) OutputIterator out, Tag_false) {
{
// Use the first polygon to determine the (default) traits // Use the first polygon to determine the (default) traits
typedef Polygon_with_holes_2<Kernel, Container> Polygon_with_holes; using Polygon_with_holes = Polygon_with_holes_2<Kernel, Container>;
typename Gps_default_traits<Polygon_with_holes>::Traits traits; typename Gps_default_traits<Polygon_with_holes>::Traits traits;
return s_intersection(pgn1, pgn2, out, traits); return s_intersection(pgn1, pgn2, out, traits);
} }
@ -152,10 +148,9 @@ template <typename Kernel, typename Container, typename OutputIterator>
inline OutputIterator inline OutputIterator
intersection(const Polygon_with_holes_2<Kernel, Container>& pgn1, intersection(const Polygon_with_holes_2<Kernel, Container>& pgn1,
const Polygon_with_holes_2<Kernel, Container>& pgn2, const Polygon_with_holes_2<Kernel, Container>& pgn2,
OutputIterator out, Tag_false) OutputIterator out, Tag_false) {
{
// Use the first polygon to determine the (default) traits // Use the first polygon to determine the (default) traits
typedef Polygon_with_holes_2<Kernel, Container> Polygon_with_holes; using Polygon_with_holes = Polygon_with_holes_2<Kernel, Container>;
typename Gps_default_traits<Polygon_with_holes>::Traits traits; typename Gps_default_traits<Polygon_with_holes>::Traits traits;
return s_intersection(pgn1, pgn2, out, traits); return s_intersection(pgn1, pgn2, out, traits);
} }
@ -172,10 +167,9 @@ inline OutputIterator intersection(const General_polygon_2<ArrTraits>& pgn1,
template <typename ArrTraits, typename OutputIterator> template <typename ArrTraits, typename OutputIterator>
inline OutputIterator intersection(const General_polygon_2<ArrTraits>& pgn1, inline OutputIterator intersection(const General_polygon_2<ArrTraits>& pgn1,
const General_polygon_2<ArrTraits>& pgn2, const General_polygon_2<ArrTraits>& pgn2,
OutputIterator out) OutputIterator out) {
{
// Use the first polygon to determine the (default) traits // Use the first polygon to determine the (default) traits
typedef General_polygon_2<ArrTraits> Polygon; using Polygon = General_polygon_2<ArrTraits>;
typename Gps_default_traits<Polygon>::Traits traits; typename Gps_default_traits<Polygon>::Traits traits;
return s_intersection(pgn1, pgn2, out, traits); return s_intersection(pgn1, pgn2, out, traits);
} }
@ -194,10 +188,9 @@ template <typename ArrTraits, typename OutputIterator>
inline OutputIterator intersection(const General_polygon_2<ArrTraits>& pgn1, inline OutputIterator intersection(const General_polygon_2<ArrTraits>& pgn1,
const General_polygon_with_holes_2 const General_polygon_with_holes_2
<General_polygon_2<ArrTraits> >& pgn2, <General_polygon_2<ArrTraits> >& pgn2,
OutputIterator out) OutputIterator out) {
{
// Use the first polygon to determine the (default) traits // Use the first polygon to determine the (default) traits
typedef General_polygon_2<ArrTraits> Polygon; using Polygon = General_polygon_2<ArrTraits>;
typename Gps_default_traits<Polygon>::Traits traits; typename Gps_default_traits<Polygon>::Traits traits;
return s_intersection(pgn1, pgn2, out, traits); return s_intersection(pgn1, pgn2, out, traits);
} }
@ -216,11 +209,10 @@ template <typename ArrTraits, typename OutputIterator>
inline OutputIterator intersection(const General_polygon_with_holes_2 inline OutputIterator intersection(const General_polygon_with_holes_2
<General_polygon_2<ArrTraits> >& pgn1, <General_polygon_2<ArrTraits> >& pgn1,
const General_polygon_2<ArrTraits>& pgn2, const General_polygon_2<ArrTraits>& pgn2,
OutputIterator out) OutputIterator out) {
{
// Use the first polygon to determine the (default) traits // Use the first polygon to determine the (default) traits
typedef General_polygon_2<ArrTraits> Polygon; using Polygon = General_polygon_2<ArrTraits>;
typedef General_polygon_with_holes_2<Polygon> Polygon_with_holes; using Polygon_with_holes = General_polygon_with_holes_2<Polygon>;
typename Gps_default_traits<Polygon_with_holes>::Traits traits; typename Gps_default_traits<Polygon_with_holes>::Traits traits;
return s_intersection(pgn1, pgn2, out, traits); return s_intersection(pgn1, pgn2, out, traits);
} }
@ -239,10 +231,9 @@ template <typename Polygon_, typename OutputIterator>
inline OutputIterator inline OutputIterator
intersection(const General_polygon_with_holes_2<Polygon_>& pgn1, intersection(const General_polygon_with_holes_2<Polygon_>& pgn1,
const General_polygon_with_holes_2<Polygon_>& pgn2, const General_polygon_with_holes_2<Polygon_>& pgn2,
OutputIterator out) OutputIterator out) {
{
// Use the first polygon to determine the (default) traits // Use the first polygon to determine the (default) traits
typedef General_polygon_with_holes_2<Polygon_> Polygon_with_holes; using Polygon_with_holes = General_polygon_with_holes_2<Polygon_>;
typename Gps_default_traits<Polygon_with_holes>::Traits traits; typename Gps_default_traits<Polygon_with_holes>::Traits traits;
return s_intersection(pgn1, pgn2, out, traits); return s_intersection(pgn1, pgn2, out, traits);
} }
@ -256,7 +247,7 @@ intersection(const General_polygon_with_holes_2<Polygon_>& pgn1,
template <typename InputIterator, typename OutputIterator, typename Traits> template <typename InputIterator, typename OutputIterator, typename Traits>
inline OutputIterator intersection(InputIterator begin, InputIterator end, inline OutputIterator intersection(InputIterator begin, InputIterator end,
OutputIterator oi, Traits& traits, OutputIterator oi, Traits& traits,
unsigned int k=5) std::size_t k = 5)
{ return r_intersection(begin, end, oi, traits, k); } { return r_intersection(begin, end, oi, traits, k); }
// Without Traits // Without Traits
@ -265,7 +256,7 @@ template <typename InputIterator, typename OutputIterator>
inline OutputIterator inline OutputIterator
intersection(InputIterator begin, InputIterator end, intersection(InputIterator begin, InputIterator end,
OutputIterator oi, Tag_true = Tag_true(), OutputIterator oi, Tag_true = Tag_true(),
unsigned int k=5, std::size_t k = 5,
Enable_if_Polygon_2_iterator<InputIterator>* = 0) Enable_if_Polygon_2_iterator<InputIterator>* = 0)
{ return r_intersection(begin, end, oi, k); } { return r_intersection(begin, end, oi, k); }
@ -273,9 +264,8 @@ intersection(InputIterator begin, InputIterator end,
template <typename InputIterator, typename OutputIterator> template <typename InputIterator, typename OutputIterator>
inline OutputIterator inline OutputIterator
intersection(InputIterator begin, InputIterator end, intersection(InputIterator begin, InputIterator end,
OutputIterator oi, Tag_false, unsigned int k=5, OutputIterator oi, Tag_false, std::size_t k = 5,
Enable_if_Polygon_2_iterator<InputIterator>* = 0) Enable_if_Polygon_2_iterator<InputIterator>* = 0) {
{
typename Iterator_to_gps_traits<InputIterator>::Traits traits; typename Iterator_to_gps_traits<InputIterator>::Traits traits;
return r_intersection(begin, end, oi, traits, k); return r_intersection(begin, end, oi, traits, k);
} }
@ -284,11 +274,10 @@ intersection(InputIterator begin, InputIterator end,
template <typename InputIterator, typename OutputIterator> template <typename InputIterator, typename OutputIterator>
inline OutputIterator inline OutputIterator
intersection(InputIterator begin, InputIterator end, intersection(InputIterator begin, InputIterator end,
OutputIterator oi, unsigned int k=5, OutputIterator oi, std::size_t k = 5,
// workaround to avoid ambiguous calls with kernel functions // workaround to avoid ambiguous calls with kernel functions
std::enable_if_t<CGAL::is_iterator<InputIterator>::value>* = 0, std::enable_if_t<CGAL::is_iterator<InputIterator>::value>* = 0,
Disable_if_Polygon_2_iterator<InputIterator>* = 0) Disable_if_Polygon_2_iterator<InputIterator>* = 0) {
{
typename Iterator_to_gps_traits<InputIterator>::Traits traits; typename Iterator_to_gps_traits<InputIterator>::Traits traits;
return r_intersection(begin, end, oi, traits, k); return r_intersection(begin, end, oi, traits, k);
} }
@ -300,7 +289,7 @@ template <typename InputIterator1, typename InputIterator2,
inline OutputIterator intersection(InputIterator1 begin1, InputIterator1 end1, inline OutputIterator intersection(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2, InputIterator2 begin2, InputIterator2 end2,
OutputIterator oi, Traits& traits, OutputIterator oi, Traits& traits,
unsigned int k=5) std::size_t k = 5)
{ return r_intersection(begin1, end1, begin2, end2, oi, traits, k); } { return r_intersection(begin1, end1, begin2, end2, oi, traits, k); }
// Without Traits // Without Traits
@ -310,7 +299,7 @@ template <typename InputIterator1, typename InputIterator2,
inline OutputIterator inline OutputIterator
intersection(InputIterator1 begin1, InputIterator1 end1, intersection(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2, InputIterator2 begin2, InputIterator2 end2,
OutputIterator oi, Tag_true = Tag_true(), unsigned int k=5, OutputIterator oi, Tag_true = Tag_true(), std::size_t k = 5,
Enable_if_Polygon_2_iterator<InputIterator1>* = 0) Enable_if_Polygon_2_iterator<InputIterator1>* = 0)
{ return r_intersection(begin1, end1, begin2, end2, oi, k); } { return r_intersection(begin1, end1, begin2, end2, oi, k); }
@ -320,9 +309,8 @@ template <typename InputIterator1, typename InputIterator2,
inline OutputIterator inline OutputIterator
intersection(InputIterator1 begin1, InputIterator1 end1, intersection(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2, InputIterator2 begin2, InputIterator2 end2,
OutputIterator oi, Tag_false, unsigned int k=5, OutputIterator oi, Tag_false, std::size_t k = 5,
Enable_if_Polygon_2_iterator<InputIterator1>* = 0) Enable_if_Polygon_2_iterator<InputIterator1>* = 0) {
{
typename Iterator_to_gps_traits<InputIterator1>::Traits traits; typename Iterator_to_gps_traits<InputIterator1>::Traits traits;
return r_intersection(begin1, end1, begin2, end2, oi, traits, k); return r_intersection(begin1, end1, begin2, end2, oi, traits, k);
} }
@ -333,9 +321,8 @@ template <typename InputIterator1, typename InputIterator2,
inline OutputIterator inline OutputIterator
intersection(InputIterator1 begin1, InputIterator1 end1, intersection(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2, InputIterator2 begin2, InputIterator2 end2,
OutputIterator oi, unsigned int k=5, OutputIterator oi, std::size_t k = 5,
Disable_if_Polygon_2_iterator<InputIterator1>* = 0) Disable_if_Polygon_2_iterator<InputIterator1>* = 0) {
{
typename Iterator_to_gps_traits<InputIterator1>::Traits traits; typename Iterator_to_gps_traits<InputIterator1>::Traits traits;
return r_intersection(begin1, end1, begin2, end2, oi, traits, k); return r_intersection(begin1, end1, begin2, end2, oi, traits, k);
} }

73
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/join.h
View File

@ -33,8 +33,7 @@
#include <CGAL/Boolean_set_operations_2/Polygon_conversions.h> #include <CGAL/Boolean_set_operations_2/Polygon_conversions.h>
#include <CGAL/type_traits/is_iterator.h> #include <CGAL/type_traits/is_iterator.h>
namespace CGAL namespace CGAL {
{
/// \name join() functions. /// \name join() functions.
//@{ //@{
@ -60,10 +59,9 @@ template <typename Kernel, typename Container>
inline bool join(const Polygon_2<Kernel, Container>& pgn1, inline bool join(const Polygon_2<Kernel, Container>& pgn1,
const Polygon_2<Kernel, Container>& pgn2, const Polygon_2<Kernel, Container>& pgn2,
Polygon_with_holes_2<Kernel, Container>& res, Polygon_with_holes_2<Kernel, Container>& res,
Tag_false) Tag_false) {
{
// Use the first polygon to determine the (default) traits // Use the first polygon to determine the (default) traits
typedef Polygon_2<Kernel, Container> Polygon; using Polygon = Polygon_2<Kernel, Container>;
typename Gps_default_traits<Polygon>::Traits traits; typename Gps_default_traits<Polygon>::Traits traits;
return s_join(pgn1, pgn2, res, traits); return s_join(pgn1, pgn2, res, traits);
} }
@ -89,10 +87,9 @@ template <typename Kernel, typename Container>
inline bool join(const Polygon_2<Kernel, Container>& pgn1, inline bool join(const Polygon_2<Kernel, Container>& pgn1,
const Polygon_with_holes_2<Kernel, Container>& pgn2, const Polygon_with_holes_2<Kernel, Container>& pgn2,
Polygon_with_holes_2<Kernel, Container>& res, Polygon_with_holes_2<Kernel, Container>& res,
Tag_false) Tag_false) {
{
// Use the first polygon to determine the (default) traits // Use the first polygon to determine the (default) traits
typedef Polygon_2<Kernel, Container> Polygon; using Polygon = Polygon_2<Kernel, Container>;
typename Gps_default_traits<Polygon>::Traits traits; typename Gps_default_traits<Polygon>::Traits traits;
return s_join(pgn1, pgn2, res, traits); return s_join(pgn1, pgn2, res, traits);
} }
@ -118,10 +115,9 @@ template <typename Kernel, typename Container>
inline bool join(const Polygon_with_holes_2<Kernel, Container>& pgn1, inline bool join(const Polygon_with_holes_2<Kernel, Container>& pgn1,
const Polygon_2<Kernel, Container>& pgn2, const Polygon_2<Kernel, Container>& pgn2,
Polygon_with_holes_2<Kernel, Container>& res, Polygon_with_holes_2<Kernel, Container>& res,
Tag_false) Tag_false) {
{
// Use the first polygon to determine the (default) traits // Use the first polygon to determine the (default) traits
typedef Polygon_with_holes_2<Kernel, Container> Polygon_with_holes; using Polygon_with_holes = Polygon_with_holes_2<Kernel, Container>;
typename Gps_default_traits<Polygon_with_holes>::Traits traits; typename Gps_default_traits<Polygon_with_holes>::Traits traits;
return s_join(pgn1, pgn2, res, traits); return s_join(pgn1, pgn2, res, traits);
} }
@ -147,10 +143,9 @@ template <typename Kernel, typename Container>
inline bool join(const Polygon_with_holes_2<Kernel, Container>& pgn1, inline bool join(const Polygon_with_holes_2<Kernel, Container>& pgn1,
const Polygon_with_holes_2<Kernel, Container>& pgn2, const Polygon_with_holes_2<Kernel, Container>& pgn2,
Polygon_with_holes_2<Kernel, Container>& res, Polygon_with_holes_2<Kernel, Container>& res,
Tag_false) Tag_false) {
{
// Use the first polygon to determine the (default) traits // Use the first polygon to determine the (default) traits
typedef Polygon_with_holes_2<Kernel, Container> Polygon_with_holes; using Polygon_with_holes = Polygon_with_holes_2<Kernel, Container>;
typename Gps_default_traits<Polygon_with_holes>::Traits traits; typename Gps_default_traits<Polygon_with_holes>::Traits traits;
return s_join(pgn1, pgn2, res, traits); return s_join(pgn1, pgn2, res, traits);
} }
@ -170,10 +165,9 @@ template <typename ArrTraits>
inline bool inline bool
join(const General_polygon_2<ArrTraits>& pgn1, join(const General_polygon_2<ArrTraits>& pgn1,
const General_polygon_2<ArrTraits>& pgn2, const General_polygon_2<ArrTraits>& pgn2,
General_polygon_with_holes_2<General_polygon_2<ArrTraits> >& res) General_polygon_with_holes_2<General_polygon_2<ArrTraits> >& res) {
{
// Use the first polygon to determine the (default) traits // Use the first polygon to determine the (default) traits
typedef General_polygon_2<ArrTraits> Polygon; using Polygon = General_polygon_2<ArrTraits>;
typename Gps_default_traits<Polygon>::Traits traits; typename Gps_default_traits<Polygon>::Traits traits;
return s_join(pgn1, pgn2, res, traits); return s_join(pgn1, pgn2, res, traits);
} }
@ -193,10 +187,9 @@ template <typename ArrTraits>
inline bool inline bool
join(const General_polygon_2<ArrTraits>& pgn1, join(const General_polygon_2<ArrTraits>& pgn1,
const General_polygon_with_holes_2<General_polygon_2<ArrTraits> >& pgn2, const General_polygon_with_holes_2<General_polygon_2<ArrTraits> >& pgn2,
General_polygon_with_holes_2<General_polygon_2<ArrTraits> >& res) General_polygon_with_holes_2<General_polygon_2<ArrTraits> >& res) {
{
// Use the first polygon to determine the (default) traits // Use the first polygon to determine the (default) traits
typedef General_polygon_2<ArrTraits> Polygon; using Polygon = General_polygon_2<ArrTraits>;
typename Gps_default_traits<Polygon>::Traits traits; typename Gps_default_traits<Polygon>::Traits traits;
return s_join(pgn1, pgn2, res, traits); return s_join(pgn1, pgn2, res, traits);
} }
@ -216,11 +209,10 @@ template <typename ArrTraits>
inline bool inline bool
join(const General_polygon_with_holes_2<General_polygon_2<ArrTraits> >& pgn1, join(const General_polygon_with_holes_2<General_polygon_2<ArrTraits> >& pgn1,
const General_polygon_2<ArrTraits>& pgn2, const General_polygon_2<ArrTraits>& pgn2,
General_polygon_with_holes_2<General_polygon_2<ArrTraits> >& res) General_polygon_with_holes_2<General_polygon_2<ArrTraits> >& res) {
{
// Use the first polygon to determine the (default) traits // Use the first polygon to determine the (default) traits
typedef General_polygon_2<ArrTraits> Polygon; using Polygon = General_polygon_2<ArrTraits>;
typedef General_polygon_with_holes_2<Polygon> Polygon_with_holes; using Polygon_with_holes = General_polygon_with_holes_2<Polygon>;
typename Gps_default_traits<Polygon_with_holes>::Traits traits; typename Gps_default_traits<Polygon_with_holes>::Traits traits;
return s_join(pgn1, pgn2, res, traits); return s_join(pgn1, pgn2, res, traits);
} }
@ -237,10 +229,9 @@ inline bool join(const General_polygon_with_holes_2<Polygon_>& pgn1,
template <typename Polygon_> template <typename Polygon_>
inline bool join(const General_polygon_with_holes_2<Polygon_>& pgn1, inline bool join(const General_polygon_with_holes_2<Polygon_>& pgn1,
const General_polygon_with_holes_2<Polygon_>& pgn2, const General_polygon_with_holes_2<Polygon_>& pgn2,
General_polygon_with_holes_2<Polygon_>& res) General_polygon_with_holes_2<Polygon_>& res) {
{
// Use the first polygon to determine the (default) traits // Use the first polygon to determine the (default) traits
typedef General_polygon_with_holes_2<Polygon_> Polygon_with_holes; using Polygon_with_holes = General_polygon_with_holes_2<Polygon_>;
typename Gps_default_traits<Polygon_with_holes>::Traits traits; typename Gps_default_traits<Polygon_with_holes>::Traits traits;
return s_join(pgn1, pgn2, res, traits); return s_join(pgn1, pgn2, res, traits);
} }
@ -253,7 +244,7 @@ inline bool join(const General_polygon_with_holes_2<Polygon_>& pgn1,
// With Traits // With Traits
template <typename InputIterator, typename OutputIterator, typename Traits> template <typename InputIterator, typename OutputIterator, typename Traits>
inline OutputIterator join(InputIterator begin, InputIterator end, inline OutputIterator join(InputIterator begin, InputIterator end,
OutputIterator oi, Traits& traits, unsigned int k=5) OutputIterator oi, Traits& traits, std::size_t k = 5)
{ return r_join(begin, end, oi, traits, k); } { return r_join(begin, end, oi, traits, k); }
// Without Traits // Without Traits
@ -261,16 +252,15 @@ inline OutputIterator join(InputIterator begin, InputIterator end,
template <typename InputIterator, typename OutputIterator> template <typename InputIterator, typename OutputIterator>
inline OutputIterator join(InputIterator begin, InputIterator end, inline OutputIterator join(InputIterator begin, InputIterator end,
OutputIterator oi, Tag_true = Tag_true(), OutputIterator oi, Tag_true = Tag_true(),
unsigned int k=5, std::size_t k = 5,
Enable_if_Polygon_2_iterator<InputIterator>* = 0) Enable_if_Polygon_2_iterator<InputIterator>* = 0)
{ return r_join(begin, end, oi, k); } { return r_join(begin, end, oi, k); }
// Tag_false => do not convert to polylines // Tag_false => do not convert to polylines
template <typename InputIterator, typename OutputIterator> template <typename InputIterator, typename OutputIterator>
inline OutputIterator join(InputIterator begin, InputIterator end, inline OutputIterator join(InputIterator begin, InputIterator end,
OutputIterator oi, Tag_false, unsigned int k=5, OutputIterator oi, Tag_false, std::size_t k = 5,
Enable_if_Polygon_2_iterator<InputIterator>* = 0) Enable_if_Polygon_2_iterator<InputIterator>* = 0) {
{
typename Iterator_to_gps_traits<InputIterator>::Traits traits; typename Iterator_to_gps_traits<InputIterator>::Traits traits;
return r_join(begin, end, oi, traits, k); return r_join(begin, end, oi, traits, k);
} }
@ -278,9 +268,8 @@ inline OutputIterator join(InputIterator begin, InputIterator end,
// General polygons or polygons with holes // General polygons or polygons with holes
template <typename InputIterator, typename OutputIterator> template <typename InputIterator, typename OutputIterator>
inline OutputIterator join(InputIterator begin, InputIterator end, inline OutputIterator join(InputIterator begin, InputIterator end,
OutputIterator oi, unsigned int k=5, OutputIterator oi, std::size_t k = 5,
Disable_if_Polygon_2_iterator<InputIterator>* = 0) Disable_if_Polygon_2_iterator<InputIterator>* = 0) {
{
typename Iterator_to_gps_traits<InputIterator>::Traits traits; typename Iterator_to_gps_traits<InputIterator>::Traits traits;
return r_join(begin, end, oi, traits, k); return r_join(begin, end, oi, traits, k);
} }
@ -291,7 +280,7 @@ template <typename InputIterator1, typename InputIterator2,
typename OutputIterator, typename Traits> typename OutputIterator, typename Traits>
inline OutputIterator join(InputIterator1 begin1, InputIterator1 end1, inline OutputIterator join(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2, InputIterator2 begin2, InputIterator2 end2,
OutputIterator oi, Traits& traits, unsigned int k=5) OutputIterator oi, Traits& traits, std::size_t k = 5)
{ return r_join(begin1, end1, begin2, end2, oi, traits, k); } { return r_join(begin1, end1, begin2, end2, oi, traits, k); }
// Without Traits // Without Traits
@ -301,7 +290,7 @@ template <typename InputIterator1, typename InputIterator2,
inline OutputIterator join(InputIterator1 begin1, InputIterator1 end1, inline OutputIterator join(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2, InputIterator2 begin2, InputIterator2 end2,
OutputIterator oi, Tag_true = Tag_true(), OutputIterator oi, Tag_true = Tag_true(),
unsigned int k=5, std::size_t k = 5,
Enable_if_Polygon_2_iterator<InputIterator1>* = 0) Enable_if_Polygon_2_iterator<InputIterator1>* = 0)
{ return r_join(begin1, end1, begin2, end2, oi, k); } { return r_join(begin1, end1, begin2, end2, oi, k); }
@ -310,9 +299,8 @@ template <typename InputIterator1, typename InputIterator2,
typename OutputIterator> typename OutputIterator>
inline OutputIterator join(InputIterator1 begin1, InputIterator1 end1, inline OutputIterator join(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2, InputIterator2 begin2, InputIterator2 end2,
OutputIterator oi, Tag_false, unsigned int k=5, OutputIterator oi, Tag_false, std::size_t k = 5,
Enable_if_Polygon_2_iterator<InputIterator1>* = 0) Enable_if_Polygon_2_iterator<InputIterator1>* = 0) {
{
typename Iterator_to_gps_traits<InputIterator1>::Traits traits; typename Iterator_to_gps_traits<InputIterator1>::Traits traits;
return r_join(begin1, end1, begin2, end2, oi, traits, k); return r_join(begin1, end1, begin2, end2, oi, traits, k);
} }
@ -322,9 +310,8 @@ template <typename InputIterator1, typename InputIterator2,
typename OutputIterator> typename OutputIterator>
inline OutputIterator join(InputIterator1 begin1, InputIterator1 end1, inline OutputIterator join(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2, InputIterator2 begin2, InputIterator2 end2,
OutputIterator oi, unsigned int k=5, OutputIterator oi, std::size_t k = 5,
Disable_if_Polygon_2_iterator<InputIterator1>* = 0) Disable_if_Polygon_2_iterator<InputIterator1>* = 0) {
{
typename Iterator_to_gps_traits<InputIterator1>::Traits traits; typename Iterator_to_gps_traits<InputIterator1>::Traits traits;
return r_join(begin1, end1, begin2, end2, oi, traits, k); return r_join(begin1, end1, begin2, end2, oi, traits, k);
} }

73
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/symmetric_difference.h
View File

@ -33,8 +33,7 @@
#include <CGAL/Boolean_set_operations_2/Polygon_conversions.h> #include <CGAL/Boolean_set_operations_2/Polygon_conversions.h>
#include <CGAL/type_traits/is_iterator.h> #include <CGAL/type_traits/is_iterator.h>
namespace CGAL namespace CGAL {
{
/// \name symmetric_difference() functions. /// \name symmetric_difference() functions.
//@{ //@{
@ -62,10 +61,9 @@ template <typename Kernel, typename Container, typename OutputIterator>
inline OutputIterator inline OutputIterator
symmetric_difference(const Polygon_2<Kernel, Container>& pgn1, symmetric_difference(const Polygon_2<Kernel, Container>& pgn1,
const Polygon_2<Kernel, Container>& pgn2, const Polygon_2<Kernel, Container>& pgn2,
OutputIterator oi, Tag_false) OutputIterator oi, Tag_false) {
{
// Use the first polygon to determine the (default) traits // Use the first polygon to determine the (default) traits
typedef Polygon_2<Kernel, Container> Polygon; using Polygon = Polygon_2<Kernel, Container>;
typename Gps_default_traits<Polygon>::Traits traits; typename Gps_default_traits<Polygon>::Traits traits;
return s_symmetric_difference(pgn1, pgn2, oi, traits); return s_symmetric_difference(pgn1, pgn2, oi, traits);
} }
@ -93,10 +91,9 @@ template <typename Kernel, typename Container, typename OutputIterator>
inline OutputIterator inline OutputIterator
symmetric_difference(const Polygon_2<Kernel, Container>& pgn1, symmetric_difference(const Polygon_2<Kernel, Container>& pgn1,
const Polygon_with_holes_2<Kernel, Container>& pgn2, const Polygon_with_holes_2<Kernel, Container>& pgn2,
OutputIterator oi, Tag_false) OutputIterator oi, Tag_false) {
{
// Use the first polygon to determine the (default) traits // Use the first polygon to determine the (default) traits
typedef Polygon_2<Kernel, Container> Polygon; using Polygon = Polygon_2<Kernel, Container>;
typename Gps_default_traits<Polygon>::Traits traits; typename Gps_default_traits<Polygon>::Traits traits;
return s_symmetric_difference(pgn1, pgn2, oi, traits); return s_symmetric_difference(pgn1, pgn2, oi, traits);
} }
@ -124,10 +121,9 @@ template <typename Kernel, typename Container, typename OutputIterator>
inline OutputIterator inline OutputIterator
symmetric_difference(const Polygon_with_holes_2<Kernel, Container>& pgn1, symmetric_difference(const Polygon_with_holes_2<Kernel, Container>& pgn1,
const Polygon_2<Kernel, Container>& pgn2, const Polygon_2<Kernel, Container>& pgn2,
OutputIterator oi, Tag_false) OutputIterator oi, Tag_false) {
{
// Use the first polygon to determine the (default) traits // Use the first polygon to determine the (default) traits
typedef Polygon_with_holes_2<Kernel, Container> Polygon_with_holes; using Polygon_with_holes = Polygon_with_holes_2<Kernel, Container>;
typename Gps_default_traits<Polygon_with_holes>::Traits traits; typename Gps_default_traits<Polygon_with_holes>::Traits traits;
return s_symmetric_difference(pgn1, pgn2, oi, traits); return s_symmetric_difference(pgn1, pgn2, oi, traits);
} }
@ -155,10 +151,9 @@ template <typename Kernel, typename Container, typename OutputIterator>
inline OutputIterator inline OutputIterator
symmetric_difference(const Polygon_with_holes_2<Kernel, Container>& pgn1, symmetric_difference(const Polygon_with_holes_2<Kernel, Container>& pgn1,
const Polygon_with_holes_2<Kernel, Container>& pgn2, const Polygon_with_holes_2<Kernel, Container>& pgn2,
OutputIterator oi, Tag_false) OutputIterator oi, Tag_false) {
{
// Use the first polygon to determine the (default) traits // Use the first polygon to determine the (default) traits
typedef Polygon_with_holes_2<Kernel, Container> Polygon_with_holes; using Polygon_with_holes = Polygon_with_holes_2<Kernel, Container>;
typename Gps_default_traits<Polygon_with_holes>::Traits traits; typename Gps_default_traits<Polygon_with_holes>::Traits traits;
return s_symmetric_difference(pgn1, pgn2, oi, traits); return s_symmetric_difference(pgn1, pgn2, oi, traits);
} }
@ -176,10 +171,9 @@ template <typename ArrTraits, typename OutputIterator>
inline OutputIterator inline OutputIterator
symmetric_difference(const General_polygon_2<ArrTraits>& pgn1, symmetric_difference(const General_polygon_2<ArrTraits>& pgn1,
const General_polygon_2<ArrTraits>& pgn2, const General_polygon_2<ArrTraits>& pgn2,
OutputIterator oi) OutputIterator oi) {
{
// Use the first polygon to determine the (default) traits // Use the first polygon to determine the (default) traits
typedef General_polygon_2<ArrTraits> Polygon; using Polygon = General_polygon_2<ArrTraits>;
typename Gps_default_traits<Polygon>::Traits traits; typename Gps_default_traits<Polygon>::Traits traits;
return s_symmetric_difference(pgn1, pgn2, oi, traits); return s_symmetric_difference(pgn1, pgn2, oi, traits);
} }
@ -200,10 +194,9 @@ inline OutputIterator
symmetric_difference(const General_polygon_2<ArrTraits>& pgn1, symmetric_difference(const General_polygon_2<ArrTraits>& pgn1,
const General_polygon_with_holes_2 const General_polygon_with_holes_2
<General_polygon_2<ArrTraits> >& pgn2, <General_polygon_2<ArrTraits> >& pgn2,
OutputIterator oi) OutputIterator oi) {
{
// Use the first polygon to determine the (default) traits // Use the first polygon to determine the (default) traits
typedef General_polygon_2<ArrTraits> Polygon; using Polygon = General_polygon_2<ArrTraits>;
typename Gps_default_traits<Polygon>::Traits traits; typename Gps_default_traits<Polygon>::Traits traits;
return s_symmetric_difference(pgn1, pgn2, oi, traits); return s_symmetric_difference(pgn1, pgn2, oi, traits);
} }
@ -224,11 +217,10 @@ inline OutputIterator
symmetric_difference(const General_polygon_with_holes_2 symmetric_difference(const General_polygon_with_holes_2
<General_polygon_2<ArrTraits> >& pgn1, <General_polygon_2<ArrTraits> >& pgn1,
const General_polygon_2<ArrTraits>& pgn2, const General_polygon_2<ArrTraits>& pgn2,
OutputIterator oi) OutputIterator oi) {
{
// Use the first polygon to determine the (default) traits // Use the first polygon to determine the (default) traits
typedef General_polygon_2<ArrTraits> Polygon; using Polygon = General_polygon_2<ArrTraits>;
typedef General_polygon_with_holes_2<Polygon> Polygon_with_holes; using Polygon_with_holes = General_polygon_with_holes_2<Polygon>;
typename Gps_default_traits<Polygon_with_holes>::Traits traits; typename Gps_default_traits<Polygon_with_holes>::Traits traits;
return s_symmetric_difference(pgn1, pgn2, oi, traits); return s_symmetric_difference(pgn1, pgn2, oi, traits);
} }
@ -247,9 +239,8 @@ template <typename Polygon_, typename OutputIterator>
inline OutputIterator inline OutputIterator
symmetric_difference(const General_polygon_with_holes_2<Polygon_>& pgn1, symmetric_difference(const General_polygon_with_holes_2<Polygon_>& pgn1,
const General_polygon_with_holes_2<Polygon_>& pgn2, const General_polygon_with_holes_2<Polygon_>& pgn2,
OutputIterator oi) OutputIterator oi) {
{ using Polygon_with_holes = General_polygon_with_holes_2<Polygon_>;
typedef General_polygon_with_holes_2<Polygon_> Polygon_with_holes;
typename Gps_default_traits<Polygon_with_holes>::Traits traits; typename Gps_default_traits<Polygon_with_holes>::Traits traits;
return s_symmetric_difference(pgn1, pgn2, oi, traits); return s_symmetric_difference(pgn1, pgn2, oi, traits);
} }
@ -264,7 +255,7 @@ template <typename InputIterator, typename OutputIterator, typename Traits>
inline inline
OutputIterator symmetric_difference(InputIterator begin, InputIterator end, OutputIterator symmetric_difference(InputIterator begin, InputIterator end,
OutputIterator oi, Traits& traits, OutputIterator oi, Traits& traits,
unsigned int k=5) std::size_t k = 5)
{ return r_symmetric_difference(begin, end, oi, traits, k); } { return r_symmetric_difference(begin, end, oi, traits, k); }
// Without Traits // Without Traits
@ -272,7 +263,7 @@ OutputIterator symmetric_difference(InputIterator begin, InputIterator end,
template <typename InputIterator, typename OutputIterator> template <typename InputIterator, typename OutputIterator>
inline OutputIterator inline OutputIterator
symmetric_difference(InputIterator begin, InputIterator end, symmetric_difference(InputIterator begin, InputIterator end,
OutputIterator oi, Tag_true = Tag_true(), unsigned int k=5, OutputIterator oi, Tag_true = Tag_true(), std::size_t k = 5,
Enable_if_Polygon_2_iterator<InputIterator>* = 0) Enable_if_Polygon_2_iterator<InputIterator>* = 0)
{ return r_symmetric_difference(begin, end, oi, k); } { return r_symmetric_difference(begin, end, oi, k); }
@ -280,9 +271,8 @@ symmetric_difference(InputIterator begin, InputIterator end,
template <typename InputIterator, typename OutputIterator> template <typename InputIterator, typename OutputIterator>
inline OutputIterator inline OutputIterator
symmetric_difference(InputIterator begin, InputIterator end, symmetric_difference(InputIterator begin, InputIterator end,
OutputIterator oi, Tag_false, unsigned int k=5, OutputIterator oi, Tag_false, std::size_t k = 5,
Enable_if_Polygon_2_iterator<InputIterator>* = 0) Enable_if_Polygon_2_iterator<InputIterator>* = 0) {
{
typename Iterator_to_gps_traits<InputIterator>::Traits traits; typename Iterator_to_gps_traits<InputIterator>::Traits traits;
return r_symmetric_difference(begin, end, oi, traits, k); return r_symmetric_difference(begin, end, oi, traits, k);
} }
@ -291,9 +281,8 @@ symmetric_difference(InputIterator begin, InputIterator end,
template <typename InputIterator, typename OutputIterator> template <typename InputIterator, typename OutputIterator>
inline OutputIterator inline OutputIterator
symmetric_difference(InputIterator begin, InputIterator end, symmetric_difference(InputIterator begin, InputIterator end,
OutputIterator oi, unsigned int k=5, OutputIterator oi, std::size_t k = 5,
Disable_if_Polygon_2_iterator<InputIterator>* = 0) Disable_if_Polygon_2_iterator<InputIterator>* = 0) {
{
typename Iterator_to_gps_traits<InputIterator>::Traits traits; typename Iterator_to_gps_traits<InputIterator>::Traits traits;
return r_symmetric_difference(begin, end, oi, traits, k); return r_symmetric_difference(begin, end, oi, traits, k);
} }
@ -306,7 +295,7 @@ inline
OutputIterator symmetric_difference(InputIterator1 begin1, InputIterator1 end1, OutputIterator symmetric_difference(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2, InputIterator2 begin2, InputIterator2 end2,
OutputIterator oi, Traits& traits, OutputIterator oi, Traits& traits,
unsigned int k=5) std::size_t k = 5)
{ return r_symmetric_difference(begin1, end1, begin2, end2, oi, traits, k); } { return r_symmetric_difference(begin1, end1, begin2, end2, oi, traits, k); }
// Without Traits // Without Traits
@ -316,7 +305,7 @@ template <typename InputIterator1, typename InputIterator2,
inline OutputIterator inline OutputIterator
symmetric_difference(InputIterator1 begin1, InputIterator1 end1, symmetric_difference(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2, InputIterator2 begin2, InputIterator2 end2,
OutputIterator oi, Tag_true = Tag_true(), unsigned int k=5, OutputIterator oi, Tag_true = Tag_true(), std::size_t k = 5,
Enable_if_Polygon_2_iterator<InputIterator1>* = 0) Enable_if_Polygon_2_iterator<InputIterator1>* = 0)
{ return r_symmetric_difference(begin1, end1, begin2, end2, oi, k); } { return r_symmetric_difference(begin1, end1, begin2, end2, oi, k); }
@ -326,9 +315,8 @@ template <typename InputIterator1, typename InputIterator2,
inline OutputIterator inline OutputIterator
symmetric_difference(InputIterator1 begin1, InputIterator1 end1, symmetric_difference(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2, InputIterator2 begin2, InputIterator2 end2,
OutputIterator oi, Tag_false, unsigned int k=5, OutputIterator oi, Tag_false, std::size_t k = 5,
Enable_if_Polygon_2_iterator<InputIterator1>* = 0) Enable_if_Polygon_2_iterator<InputIterator1>* = 0) {
{
typename Iterator_to_gps_traits<InputIterator1>::Traits traits; typename Iterator_to_gps_traits<InputIterator1>::Traits traits;
return r_symmetric_difference(begin1, end1, begin2, end2, oi, traits, k); return r_symmetric_difference(begin1, end1, begin2, end2, oi, traits, k);
} }
@ -339,9 +327,8 @@ template <typename InputIterator1, typename InputIterator2,
inline OutputIterator inline OutputIterator
symmetric_difference(InputIterator1 begin1, InputIterator1 end1, symmetric_difference(InputIterator1 begin1, InputIterator1 end1,
InputIterator2 begin2, InputIterator2 end2, InputIterator2 begin2, InputIterator2 end2,
OutputIterator oi, unsigned int k=5, OutputIterator oi, std::size_t k = 5,
Disable_if_Polygon_2_iterator<InputIterator1>* = 0) Disable_if_Polygon_2_iterator<InputIterator1>* = 0) {
{
typename Iterator_to_gps_traits<InputIterator1>::Traits traits; typename Iterator_to_gps_traits<InputIterator1>::Traits traits;
return r_symmetric_difference(begin1, end1, begin2, end2, oi, traits, k); return r_symmetric_difference(begin1, end1, begin2, end2, oi, traits, k);
} }

20
Boolean_set_operations_2/test/Boolean_set_operations_2/test_compilation.cpp
View File

@ -257,45 +257,25 @@ void test_CGAL_Polygon_variants()
Traits tr; Traits tr;
CGAL::do_intersect(pgn1, pgn2); CGAL::do_intersect(pgn1, pgn2);
CGAL::do_intersect(pgn1, pgn2, CGAL::Tag_true());
CGAL::do_intersect(pgn1, pgn2, CGAL::Tag_false());
CGAL::do_intersect(pgn1, pgn2, tr); CGAL::do_intersect(pgn1, pgn2, tr);
CGAL::do_intersect(pgn1, pgn_with_holes2); CGAL::do_intersect(pgn1, pgn_with_holes2);
CGAL::do_intersect(pgn1, pgn_with_holes2, CGAL::Tag_true());
CGAL::do_intersect(pgn1, pgn_with_holes2, CGAL::Tag_false());
CGAL::do_intersect(pgn1, pgn_with_holes2, tr); CGAL::do_intersect(pgn1, pgn_with_holes2, tr);
CGAL::do_intersect(pgn_with_holes1, pgn2); CGAL::do_intersect(pgn_with_holes1, pgn2);
CGAL::do_intersect(pgn_with_holes1, pgn2, CGAL::Tag_true());
CGAL::do_intersect(pgn_with_holes1, pgn2, CGAL::Tag_false());
CGAL::do_intersect(pgn_with_holes1, pgn2, tr); CGAL::do_intersect(pgn_with_holes1, pgn2, tr);
CGAL::do_intersect(pgn_with_holes1, pgn_with_holes2); CGAL::do_intersect(pgn_with_holes1, pgn_with_holes2);
CGAL::do_intersect(pgn_with_holes1, pgn_with_holes2, CGAL::Tag_true());
CGAL::do_intersect(pgn_with_holes1, pgn_with_holes2, CGAL::Tag_false());
CGAL::do_intersect(pgn_with_holes1, pgn_with_holes2, tr); CGAL::do_intersect(pgn_with_holes1, pgn_with_holes2, tr);
CGAL::do_intersect(polygons.begin(), polygons.end()); CGAL::do_intersect(polygons.begin(), polygons.end());
CGAL::do_intersect(polygons.begin(), polygons.end(), CGAL::Tag_true());
CGAL::do_intersect(polygons.begin(), polygons.end(), CGAL::Tag_false());
CGAL::do_intersect(polygons.begin(), polygons.end(), tr); CGAL::do_intersect(polygons.begin(), polygons.end(), tr);
CGAL::do_intersect(polygons_with_holes.begin(), polygons_with_holes.end()); CGAL::do_intersect(polygons_with_holes.begin(), polygons_with_holes.end());
CGAL::do_intersect(polygons_with_holes.begin(), polygons_with_holes.end(),
CGAL::Tag_true());
CGAL::do_intersect(polygons_with_holes.begin(), polygons_with_holes.end(),
CGAL::Tag_false());
CGAL::do_intersect(polygons_with_holes.begin(), polygons_with_holes.end(), tr); CGAL::do_intersect(polygons_with_holes.begin(), polygons_with_holes.end(), tr);
CGAL::do_intersect(polygons.begin(), polygons.end(), CGAL::do_intersect(polygons.begin(), polygons.end(),
polygons_with_holes.begin(), polygons_with_holes.end()); polygons_with_holes.begin(), polygons_with_holes.end());
CGAL::do_intersect(polygons.begin(), polygons.end(),
polygons_with_holes.begin(), polygons_with_holes.end(),
CGAL::Tag_true());
CGAL::do_intersect(polygons.begin(), polygons.end(),
polygons_with_holes.begin(), polygons_with_holes.end(),
CGAL::Tag_false());
CGAL::do_intersect(polygons.begin(), polygons.end(), CGAL::do_intersect(polygons.begin(), polygons.end(),
polygons_with_holes.begin(), polygons_with_holes.end(), tr); polygons_with_holes.begin(), polygons_with_holes.end(), tr);